fix: propagate persona harness edits to live agent instances (#1244)

Signed-off-by: Will Pfleger <pfleger.will@gmail.com>
Co-authored-by: npub1mn7jgtj4w2pd0g0zeuhxsa6jy6p0rewxz4kujt98my82ahfmp72sxjexk7 <dcfd242e557282d7a1e2cf2e6877522682f1e5c6156dc92ca7d90eaedd3b0f95@sprout-oss.stage.blox.sqprod.co>

Author: wpfleger96

desktop/scripts/check-file-sizes.mjs

@@ -37,15 +37,27 @@ const overrides = new Map([
   // self-contained repos_dir functions and their unit tests live in repos.rs;
   // this is the seam that must stay in nest.rs. Approved override; still queued
   // to split with the rest of this list.
-  ["src-tauri/src/managed_agents/nest.rs", 1447],
-  ["src-tauri/src/managed_agents/runtime.rs", 1953],
+  ["src-tauri/src/managed_agents/nest.rs", 1448],
+  // harness-persona-sync: persona-runtime resolution threaded into the spawn
+  // path here. Load-bearing feature growth; queued to split in the resolver
+  // unify refactor followup.
+  ["src-tauri/src/managed_agents/runtime.rs", 1966],
   ["src-tauri/src/managed_agents/personas.rs", 1080],
   ["src-tauri/src/managed_agents/persona_card.rs", 1050],
   // applyWorkspace reposDir parameter plus the validateReposDir binding,
-  // threaded through Tauri invokes for configurable repos_dir — a 4-line
-  // overage from load-bearing parameter plumbing, not generic debt growth.
-  // Approved override; still queued to split.
-  ["src/shared/api/tauri.ts", 1199],
+  // threaded through Tauri invokes for configurable repos_dir, plus the
+  // harness-persona-sync `harnessOverride` create-input bit — load-bearing
+  // parameter plumbing, not generic debt growth. Approved override; still
+  // queued to split.
+  ["src/shared/api/tauri.ts", 1202],
+  // harness-persona-sync feature growth, queued to split in the resolver-unify
+  // refactor followup. discovery.rs is dominated by the new test module
+  // (the effective_agent_command / divergent / create-time override matrix);
+  // types.rs adds the persona/instance harness fields; migration_tests.rs adds
+  // the harness-sync migration coverage. Load-bearing, not generic debt.
+  ["src-tauri/src/managed_agents/discovery.rs", 1043],
+  ["src-tauri/src/managed_agents/types.rs", 1010],
+  ["src-tauri/src/migration_tests.rs", 1033],
   ["src-tauri/src/nostr_convert.rs", 1126],
   ["src/shared/api/relayClientSession.ts", 1022],
   ["src-tauri/src/migration.rs", 1295],

desktop/src-tauri/src/commands/agent_models.rs

@@ -49,11 +49,21 @@ pub async fn get_agent_models(
         let resolved = resolve_command(&record.acp_command)
             .ok_or_else(|| missing_command_message(&record.acp_command, "ACP harness command"))?;
 
-        let args = normalize_agent_args(&record.agent_command, record.agent_args.clone());
+        // Resolve the effective harness from the linked persona (mirrors spawn),
+        // so model discovery runs against the persona's current harness, not the
+        // frozen record snapshot. An explicit per-agent override wins.
+        let personas = load_personas(&app).unwrap_or_default();
+        let effective_command = crate::managed_agents::effective_agent_command(
+            record.persona_id.as_deref(),
+            &personas,
+            record.agent_command_override.as_deref(),
+        );
+
+        let args = normalize_agent_args(&effective_command, record.agent_args.clone());
 
-        let resolved_agent = resolve_command(&record.agent_command)
+        let resolved_agent = resolve_command(&effective_command)
             .map(|p| p.display().to_string())
-            .unwrap_or_else(|| record.agent_command.clone());
+            .unwrap_or_else(|| effective_command.clone());
 
         // Same env layering as runtime spawn: persona env < agent env.
         // Model discovery needs the user's credentials. Fail closed on
@@ -65,7 +75,6 @@ pub async fn get_agent_models(
 
         // Resolve the effective model from the linked persona so the ModelPicker
         // dropdown shows the current persona model as selected.
-        let personas = load_personas(&app).unwrap_or_default();
         let (_prompt, effective_model, _provider) = resolve_effective_prompt_model_provider(
             record.persona_id.as_deref(),
             &personas,
@@ -197,8 +206,18 @@ pub async fn update_managed_agent(
         if let Some(acp_command) = input.acp_command {
             record.acp_command = acp_command;
         }
+        // Harness edit: the persona's runtime is authoritative, so we persist an
+        // explicit `agent_command_override` ONLY when the user picks a command
+        // that diverges from the persona. An empty/whitespace value (the
+        // "Inherit from persona" sentinel) clears the pin back to `None`. A
+        // name-only edit (`agent_command == None`) leaves the pin intact.
         if let Some(agent_command) = input.agent_command {
-            record.agent_command = agent_command;
+            let personas = load_personas(&app).unwrap_or_default();
+            record.agent_command_override = crate::managed_agents::divergent_agent_command_override(
+                record.persona_id.as_deref(),
+                &personas,
+                Some(&agent_command),
+            );
         }
         if let Some(agent_args) = input.agent_args {
             record.agent_args = agent_args;
@@ -253,10 +272,19 @@ pub async fn update_managed_agent(
                 &relay_ws_url_with_override(&state),
             );
             let display_name = record.name.clone();
+            // Avatar fallback derives from the EFFECTIVE harness (persona-wins),
+            // not the frozen snapshot, so an inherited harness picks the right
+            // default avatar.
+            let personas = load_personas(&app).unwrap_or_default();
+            let effective_command = crate::managed_agents::effective_agent_command(
+                record.persona_id.as_deref(),
+                &personas,
+                record.agent_command_override.as_deref(),
+            );
             let avatar_url = record
                 .avatar_url
                 .clone()
-                .or_else(|| managed_agent_avatar_url(&record.agent_command));
+                .or_else(|| managed_agent_avatar_url(&effective_command));
             let auth_tag = record.auth_tag.clone();
             Some((agent_keys, relay_url, display_name, avatar_url, auth_tag))
         } else {

desktop/src-tauri/src/commands/agents.rs

@@ -158,10 +158,9 @@ fn build_deploy_payload(
 
     // Resolve effective model/provider from the persona's structured fields.
     // Agent record's model takes precedence (user override via UI).
+    let personas = load_personas(app)
+        .map_err(|e| format!("failed to load personas for deploy payload resolution: {e}"))?;
     let (effective_model, effective_provider) = if let Some(ref pid) = record.persona_id {
-        let personas = load_personas(app).map_err(|e| {
-            format!("failed to load personas for deploy payload model resolution: {e}")
-        })?;
         let persona = personas.iter().find(|p| p.id == *pid);
         let model = record
             .model
@@ -173,6 +172,17 @@ fn build_deploy_payload(
         (record.model.clone(), None)
     };
 
+    // Resolve the effective harness (persona-wins, override-honored) so the
+    // remote provider runs the same harness a local spawn would — derive args
+    // from it rather than the frozen record snapshot.
+    let effective_command = crate::managed_agents::effective_agent_command(
+        record.persona_id.as_deref(),
+        &personas,
+        record.agent_command_override.as_deref(),
+    );
+    let effective_args =
+        crate::managed_agents::normalize_agent_args(&effective_command, record.agent_args.clone());
+
     Ok(serde_json::json!({
         "name": &record.name,
         // Resolve the per-agent pin against the active workspace relay here:
@@ -186,8 +196,8 @@ fn build_deploy_payload(
         ),
         "private_key_nsec": &record.private_key_nsec,
         "auth_tag": &record.auth_tag,
-        "agent_command": &record.agent_command,
-        "agent_args": &record.agent_args,
+        "agent_command": &effective_command,
+        "agent_args": &effective_args,
         "system_prompt": &record.system_prompt,
         "model": effective_model,
         "provider": effective_provider,
@@ -461,13 +471,31 @@ pub async fn create_managed_agent(
             None
         };
 
-        let agent_command = input
-            .agent_command
-            .as_deref()
-            .map(str::trim)
-            .filter(|value| !value.is_empty())
-            .map(str::to_string)
-            .unwrap_or_else(crate::managed_agents::default_agent_command);
+        // Load personas once for harness/pack/avatar resolution below.
+        let personas = load_personas(&app).unwrap_or_default();
+
+        // Harness resolution: the persona's runtime is authoritative. A
+        // persona-backed create stores an `agent_command_override` ONLY when the
+        // user deliberately picked a divergent runtime (`harness_override`) —
+        // e.g. AddChannelBotDialog's runtime selector. A divergence WITHOUT that
+        // flag is a missing-runtime fallback from `resolvePersonaRuntime`, not a
+        // pin, and must inherit so it doesn't freeze on the fallback harness once
+        // the persona's runtime is installed. A persona-less create always
+        // preserves the picked command as a real pin.
+        let agent_command_override = crate::managed_agents::create_time_agent_command_override(
+            requested_persona_id.as_deref(),
+            &personas,
+            input.agent_command.as_deref(),
+            input.harness_override,
+        );
+        // The create-time snapshot used for arg/mcp/avatar derivations and
+        // legacy reconcile. Authoritative spawn resolution re-derives this via
+        // `effective_agent_command` at use-time.
+        let agent_command = crate::managed_agents::effective_agent_command(
+            requested_persona_id.as_deref(),
+            &personas,
+            agent_command_override.as_deref(),
+        );
         let agent_args = normalize_agent_args(
             &agent_command,
             input
@@ -496,7 +524,6 @@ pub async fn create_managed_agent(
         // matches on this internal name, NOT display_name.
         let pack_metadata: Option<(std::path::PathBuf, String)> =
             requested_persona_id.as_deref().and_then(|pid| {
-                let personas = load_personas(&app).ok()?;
                 let persona = personas.iter().find(|p| p.id == pid)?;
                 let team_id = persona.source_team.as_deref()?;
                 let slug = persona.source_team_persona_slug.as_deref()?;
@@ -512,11 +539,11 @@ pub async fn create_managed_agent(
         // fallback. Storing it lets reconciliation compare against what was
         // actually published instead of re-deriving it.
         let persona_avatar_url = requested_persona_id.as_ref().and_then(|persona_id| {
-            load_personas(&app)
-                .ok()?
-                .into_iter()
+            personas
+                .iter()
                 .find(|persona| persona.id == *persona_id)?
                 .avatar_url
+                .clone()
         });
         let resolved_avatar_url = resolve_created_avatar_url(
             input.avatar_url.as_deref(),
@@ -540,6 +567,7 @@ pub async fn create_managed_agent(
                 .unwrap_or(DEFAULT_ACP_COMMAND)
                 .to_string(),
             agent_command,
+            agent_command_override,
             agent_args,
             mcp_command,
             turn_timeout_seconds: input
@@ -797,14 +825,24 @@ pub async fn start_managed_agent(
 
         let record = find_managed_agent_mut(&mut records, &pubkey)?;
 
+        // Resolve the effective harness for the avatar-fallback derivation in
+        // profile reconcile (the create-time snapshot may be empty or stale for
+        // a persona-inherited harness).
+        let reconcile_personas = load_personas(&app).unwrap_or_default();
+        let reconcile_effective_command = crate::managed_agents::effective_agent_command(
+            record.persona_id.as_deref(),
+            &reconcile_personas,
+            record.agent_command_override.as_deref(),
+        );
+
         let reconcile = ProfileReconcileData {
             private_key_nsec: record.private_key_nsec.clone(),
             name: record.name.clone(),
             relay_url: record.relay_url.clone(),
             avatar_url: record.avatar_url.clone(),
             auth_tag: record.auth_tag.clone(),
             pubkey: record.pubkey.clone(),
-            agent_command: record.agent_command.clone(),
+            agent_command: reconcile_effective_command,
             persona_id: record.persona_id.clone(),
         };