@team-agent/installer 0.4.0 → 0.4.2

package/crates/team-agent/src/lifecycle/launch.rs

@@ -1141,12 +1141,21 @@ fn drop_foreign_seeded_owner(
     };
     if owner_pane_belongs_to_other_team(existing, launched_key, pane) {
         let replacement = unbound_launched_owner(launched, launched_key);
-        if let Some(obj) = launched.as_object_mut() {
-            if let Some(owner) = replacement {
-                obj.insert("team_owner".to_string(), owner);
-            } else {
-                obj.remove("team_owner");
+        // Stage 3a (identity-boundary unified plan, architect direction
+        // 2026-06-23): route owner replace through ownership repository.
+        // Both branches (Some owner replacement; None = removal) preserve
+        // pre-3a behaviour: write_owner overwrites the top-level fields
+        // when given; the None branch falls back to direct mutation (the
+        // repository has no remove API yet — removal is uncommon enough
+        // to leave it inline).
+        if let Some(owner) = replacement {
+            let record = crate::state::ownership::OwnershipWrite::new().with_team_owner(owner);
+            crate::state::ownership::write_owner(launched, launched_key, record);
+            if let Some(obj) = launched.as_object_mut() {
+                obj.remove("owner_epoch");
             }
+        } else if let Some(obj) = launched.as_object_mut() {
+            obj.remove("team_owner");
             obj.remove("owner_epoch");
         }
     }
@@ -1423,11 +1432,13 @@ fn seed_unbound_launched_owner(launched: &mut serde_json::Value, launched_key: &
         "owner_epoch": owner_epoch,
         "discovery": "quick_start",
     });
-    if let Some(obj) = launched.as_object_mut() {
-        obj.insert("leader_receiver".to_string(), receiver);
-        obj.insert("team_owner".to_string(), owner);
-        obj.insert("owner_epoch".to_string(), serde_json::json!(owner_epoch));
-    }
+    // Stage 3a (identity-boundary unified plan, architect direction 2026-06-23):
+    // route quick-start unbound seed through ownership repository.
+    let record = crate::state::ownership::OwnershipWrite::new()
+        .with_leader_receiver(receiver)
+        .with_team_owner(owner)
+        .with_owner_epoch(owner_epoch);
+    crate::state::ownership::write_owner(launched, launched_key, record);
 }
 
 fn unbound_launched_owner(
@@ -1536,15 +1547,16 @@ mod e22_unbound_owner_provider_tests {
 
         seed_unbound_launched_owner(&mut launched, "team-e22");
 
+        // Stage 3d: canonical owner/receiver at teams.team-e22.
         assert_eq!(
             launched
-                .pointer("/team_owner/provider")
+                .pointer("/teams/team-e22/team_owner/provider")
                 .and_then(serde_json::Value::as_str),
             Some("copilot")
         );
         assert_eq!(
             launched
-                .pointer("/leader_receiver/provider")
+                .pointer("/teams/team-e22/leader_receiver/provider")
                 .and_then(serde_json::Value::as_str),
             Some("copilot")
         );
@@ -1561,13 +1573,16 @@ mod e22_unbound_owner_provider_tests {
 
         seed_unbound_launched_owner(&mut launched, "team-e22");
 
+        // Stage 3d: no receiver should be seeded at canonical location.
         assert!(
-            launched.get("leader_receiver").is_none(),
+            launched
+                .pointer("/teams/team-e22/leader_receiver")
+                .is_none(),
             "unattributed unbound owner must not seed a codex receiver: {launched}"
         );
         assert!(
             launched
-                .pointer("/team_owner/provider")
+                .pointer("/teams/team-e22/team_owner/provider")
                 .and_then(serde_json::Value::as_str)
                 != Some("codex"),
             "unattributed unbound owner must not silently become codex: {launched}"
@@ -1597,16 +1612,15 @@ mod e22_unbound_owner_provider_tests {
             |pane| (pane.as_str() == "%0").then_some(Provider::Copilot),
         ));
 
+        // Stage 3d: canonical owner/receiver at teams.<team_state_key>.
+        // State has no team_key/team_dir/spec_path → fallback "current".
+        let team_key = crate::state::projection::team_state_key(&state);
         assert_eq!(
-            state
-                .pointer("/team_owner/provider")
-                .and_then(serde_json::Value::as_str),
+            state["teams"][&team_key]["team_owner"]["provider"].as_str(),
             Some("copilot")
         );
         assert_eq!(
-            state
-                .pointer("/leader_receiver/provider")
-                .and_then(serde_json::Value::as_str),
+            state["teams"][&team_key]["leader_receiver"]["provider"].as_str(),
             Some("copilot")
         );
     }
@@ -1623,30 +1637,21 @@ mod e22_unbound_owner_provider_tests {
             caller("", "%0"),
             |_| None,
         ));
+        let team_key = crate::state::projection::team_state_key(&state);
         assert_eq!(
-            state
-                .pointer("/team_owner/pane_id")
-                .and_then(serde_json::Value::as_str),
+            state["teams"][&team_key]["team_owner"]["pane_id"].as_str(),
             Some("%0")
         );
         assert_eq!(
-            state
-                .pointer("/leader_receiver/pane_id")
-                .and_then(serde_json::Value::as_str),
+            state["teams"][&team_key]["leader_receiver"]["pane_id"].as_str(),
             Some("%0")
         );
         assert!(
-            state
-                .pointer("/leader_receiver/provider")
-                .and_then(serde_json::Value::as_str)
-                != Some("codex"),
+            state["teams"][&team_key]["leader_receiver"]["provider"].as_str() != Some("codex"),
             "unknown caller pane must not silently seed a codex receiver: {state}"
         );
         assert!(
-            state
-                .pointer("/team_owner/provider")
-                .and_then(serde_json::Value::as_str)
-                != Some("codex"),
+            state["teams"][&team_key]["team_owner"]["provider"].as_str() != Some("codex"),
             "unknown caller pane must not silently become codex: {state}"
         );
     }
@@ -2653,18 +2658,17 @@ fn json_team_identity_matches(state: &serde_json::Value, team: &str) -> bool {
             .is_some_and(|value| value == team)
 }
 
-/// `quick_start(agents_dir, name, yes, fresh, team_id)`(`diagnose/quick_start.py:18`)。
+/// `quick_start(agents_dir, name, yes, team_id)`(`diagnose/quick_start.py:18`)。
 /// 面向用户的零配置入口:编译 team_dir → `launch` → autobind leader receiver → 起
 /// coordinator → `wait_ready` 轮询就绪。归入 lifecycle module(不与 diagnose 混)。
 pub fn quick_start(
     agents_dir: &Path,
     name: Option<&str>,
     yes: bool,
-    fresh: bool,
     team_id: Option<&str>,
 ) -> Result<QuickStartReport, LifecycleError> {
     let workspace = team_workspace(agents_dir);
-    quick_start_in_workspace(&workspace, agents_dir, name, yes, fresh, team_id)
+    quick_start_in_workspace(&workspace, agents_dir, name, yes, team_id)
 }
 
 pub fn quick_start_in_workspace(
@@ -2672,7 +2676,6 @@ pub fn quick_start_in_workspace(
     agents_dir: &Path,
     name: Option<&str>,
     yes: bool,
-    fresh: bool,
     team_id: Option<&str>,
 ) -> Result<QuickStartReport, LifecycleError> {
     let workspace = explicit_quick_start_workspace(workspace);
@@ -2682,7 +2685,6 @@ pub fn quick_start_in_workspace(
         agents_dir,
         name,
         yes,
-        fresh,
         team_id,
         &transport,
     )
@@ -2693,7 +2695,6 @@ pub fn quick_start_in_workspace_with_display(
     agents_dir: &Path,
     name: Option<&str>,
     yes: bool,
-    fresh: bool,
     team_id: Option<&str>,
     open_display: bool,
 ) -> Result<QuickStartReport, LifecycleError> {
@@ -2704,7 +2705,6 @@ pub fn quick_start_in_workspace_with_display(
         agents_dir,
         name,
         yes,
-        fresh,
         team_id,
         &transport,
         open_display,
@@ -2779,13 +2779,12 @@ pub fn quick_start_with_transport(
     agents_dir: &Path,
     name: Option<&str>,
     yes: bool,
-    fresh: bool,
     team_id: Option<&str>,
     transport: &dyn Transport,
 ) -> Result<QuickStartReport, LifecycleError> {
     let workspace = team_workspace(agents_dir);
     quick_start_with_transport_in_workspace(
-        &workspace, agents_dir, name, yes, fresh, team_id, transport,
+        &workspace, agents_dir, name, yes, team_id, transport,
     )
 }
 
@@ -2794,12 +2793,11 @@ pub fn quick_start_with_transport_in_workspace(
     agents_dir: &Path,
     name: Option<&str>,
     yes: bool,
-    fresh: bool,
     team_id: Option<&str>,
     transport: &dyn Transport,
 ) -> Result<QuickStartReport, LifecycleError> {
     quick_start_with_transport_in_workspace_with_display(
-        workspace, agents_dir, name, yes, fresh, team_id, transport, true,
+        workspace, agents_dir, name, yes, team_id, transport, true,
     )
 }
 
@@ -2808,7 +2806,6 @@ pub fn quick_start_with_transport_in_workspace_with_display(
     agents_dir: &Path,
     name: Option<&str>,
     yes: bool,
-    fresh: bool,
     team_id: Option<&str>,
     transport: &dyn Transport,
     open_display: bool,
@@ -2851,57 +2848,63 @@ pub fn quick_start_with_transport_in_workspace_with_display(
             team_depth.team_depth.saturating_sub(1)
         )));
     }
-    if !fresh {
-        let state_path = crate::state::persist::runtime_state_path(&workspace);
-        if state_path.exists() {
-            let state = crate::state::persist::load_runtime_state(&workspace)
-                .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-            if requested_team
-                .as_deref()
-                .is_none_or(|team| runtime_state_has_quick_start_team(&state, team))
-            {
-                let session_name = state
-                    .get("session_name")
-                    .and_then(serde_json::Value::as_str)
-                    .filter(|s| !s.is_empty())
-                    .map(SessionName::new);
-                let attach_commands = session_name
-                    .as_ref()
-                    .map(|session| {
-                        let windows = quick_start_attach_window_names(&state);
-                        attach_commands_for_runtime_windows(
-                            state
-                                .get("tmux_endpoint")
-                                .and_then(serde_json::Value::as_str)
-                                .or_else(|| {
-                                    state.get("tmux_socket").and_then(serde_json::Value::as_str)
-                                }),
-                            &workspace,
-                            session,
-                            windows.iter().map(String::as_str),
-                        )
-                    })
-                    .unwrap_or_default();
-                let mut next_actions = vec![
-                    "run restart to resume the existing team or pass --fresh to replace it"
-                        .to_string(),
-                ];
-                if session_name.is_some() {
-                    if crate::tmux_backend::socket_probe_missing_for_workspace(&workspace) {
-                        next_actions.push(crate::tmux_backend::socket_missing_hint_for_workspace(
-                            &workspace,
-                        ));
-                    }
-                    next_actions.extend(attach_commands.iter().cloned());
+    let state_path = crate::state::persist::runtime_state_path(&workspace);
+    if state_path.exists() {
+        let state = crate::state::persist::load_runtime_state(&workspace)
+            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+        if requested_team
+            .as_deref()
+            .is_none_or(|team| runtime_state_has_quick_start_team(&state, team))
+        {
+            let session_name = state
+                .get("session_name")
+                .and_then(serde_json::Value::as_str)
+                .filter(|s| !s.is_empty())
+                .map(SessionName::new);
+            let attach_commands = session_name
+                .as_ref()
+                .map(|session| {
+                    let windows = quick_start_attach_window_names(&state);
+                    attach_commands_for_runtime_windows(
+                        state
+                            .get("tmux_endpoint")
+                            .and_then(serde_json::Value::as_str)
+                            .or_else(|| {
+                                state.get("tmux_socket").and_then(serde_json::Value::as_str)
+                            }),
+                        &workspace,
+                        session,
+                        windows.iter().map(String::as_str),
+                    )
+                })
+                .unwrap_or_default();
+            // Stage QR (design doc .team/artifacts/quickstart-restart-separation-design.md):
+            // quick-start is initial-creation-only. When the team
+            // already has runtime state, do NOT mention `--fresh`
+            // (it's been removed); steer the operator to the
+            // restart flow which owns resume + reset semantics.
+            let mut next_actions = vec![
+                "this team already has runtime state — use `team-agent restart` \
+                 to resume it (quick-start is for first-time creation only). \
+                 If recovery is impossible and the operator EXPLICITLY \
+                 accepts losing context, restart accepts `--allow-fresh`."
+                    .to_string(),
+            ];
+            if session_name.is_some() {
+                if crate::tmux_backend::socket_probe_missing_for_workspace(&workspace) {
+                    next_actions.push(crate::tmux_backend::socket_missing_hint_for_workspace(
+                        &workspace,
+                    ));
                 }
-                return Ok(QuickStartReport::ExistingRuntime {
-                    team: requested_team.clone(),
-                    session_name,
-                    state_path: Some(state_path),
-                    next_actions,
-                    attach_commands,
-                });
+                next_actions.extend(attach_commands.iter().cloned());
             }
+            return Ok(QuickStartReport::ExistingRuntime {
+                team: requested_team.clone(),
+                session_name,
+                state_path: Some(state_path),
+                next_actions,
+                attach_commands,
+            });
         }
     }
     // CR-040/042: repeated quick-start from one template with distinct --team-id/--name
@@ -2982,6 +2985,16 @@ pub fn quick_start_with_transport_in_workspace_with_display(
     let mut next_actions = vec![format!(
         "team compiled; real spawn is behind the transport/provider boundary; {coordinator_action}"
     )];
+    // Stage QR (design doc
+    // .team/artifacts/quickstart-restart-separation-design.md):
+    // quick-start is initial-creation-only. After success, remind the
+    // operator that subsequent starts must go through restart so the
+    // user's context (sessions, ownership, tasks) survives.
+    next_actions.push(
+        "quick-start initialized this team; for all subsequent starts use \
+         `team-agent restart` to resume context (quick-start refuses on \
+         already-initialised teams)".to_string(),
+    );
     if crate::tmux_backend::socket_probe_missing_for_workspace(&workspace) {
         next_actions.push(crate::tmux_backend::socket_missing_hint_for_workspace(&workspace));
     }
@@ -4681,11 +4694,14 @@ fn seed_launched_owner_from_caller_with_provider_lookup(
     ) {
         receiver.insert("tmux_socket".to_string(), serde_json::json!(socket));
     }
-    if let Some(obj) = state.as_object_mut() {
-        obj.insert("leader_receiver".to_string(), receiver);
-        obj.insert("team_owner".to_string(), owner);
-        obj.insert("owner_epoch".to_string(), serde_json::json!(owner_epoch));
-    }
+    // Stage 3a (identity-boundary unified plan, architect direction 2026-06-23):
+    // route quick-start attached-from-env seed through ownership repository.
+    let team_key = crate::state::projection::team_state_key(state);
+    let record = crate::state::ownership::OwnershipWrite::new()
+        .with_leader_receiver(receiver)
+        .with_team_owner(owner)
+        .with_owner_epoch(owner_epoch);
+    crate::state::ownership::write_owner(state, &team_key, record);
     true
 }
 

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -606,18 +606,11 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         restart_readiness_deadline(readiness_deadline_ms),
         restart_readiness_poll_interval(),
     )?;
-    let attach_windows = crate::lifecycle::launch::attach_window_names_for_state_agents(
-        &state,
-        successful_agents
-            .iter()
-            .map(|decision| decision.agent_id.as_str()),
-    );
-    let attach_commands = crate::tmux_backend::attach_commands_for_windows(
-        &selected.run_workspace,
-        &session_name,
-        attach_windows.iter().map(String::as_str),
-    );
-    let mut next_actions = attach_commands.clone();
+    let attach_commands =
+        crate::tmux_backend::attach_command_for_session(&selected.run_workspace, &session_name)
+            .into_iter()
+            .collect::<Vec<_>>();
+    let mut next_actions = Vec::new();
     if !failed_agents.is_empty() {
         next_actions.extend(restart_failure_next_actions(&failed_agents));
         write_restart_completed_event(

package/crates/team-agent/src/lifecycle/tests/core.rs

@@ -890,7 +890,7 @@ fn save_snapshot_writes_atomic_state_json_under_teams_dir() {
 fn quick_start_empty_dir_returns_typed_report_not_error_path_only() {
     let ws = temp_ws();
     // 空目录无可编译 team:应是 typed 阻塞 / 编译错,绝不 Ready。
-    match quick_start(&ws, None, false, false, None) {
+    match quick_start(&ws, None, false, None) {
         Ok(QuickStartReport::Ready { .. }) => {
             panic!("空 agents_dir 不应 Ready —— 无 team 可编译")
         }

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -115,7 +115,7 @@ fn unowned_running_ws() -> PathBuf {
 fn quick_start_compiles_real_spec_to_team_spec_yaml() {
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let transport = OfflineTransport::new();
-    let result = quick_start_with_transport(&team, None, true, true, None, &transport);
+    let result = quick_start_with_transport(&team, None, true, None, &transport);
 
     // OBSERVABLE 1 (real compiler ran; spawn-independent): the compiled spec is written.
     // E5: spec lands in .team/runtime/<team_key>/ (NOT the user team dir).
@@ -153,7 +153,7 @@ fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_coll
     std::fs::write(team.join("agents").join("implementer.md"), QS_VALID_ROLE).unwrap();
 
     let transport = OfflineTransport::new();
-    let result = quick_start_with_transport(&team, None, true, true, None, &transport);
+    let result = quick_start_with_transport(&team, None, true, None, &transport);
     assert!(
         matches!(result, Ok(QuickStartReport::Ready { .. })),
         "quick-start failed: {result:?}"
@@ -208,6 +208,7 @@ fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_coll
         detail: false,
         summary: false,
         json: true,
+        team: None,
     });
     assert!(
         status.is_ok(),
@@ -218,6 +219,7 @@ fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_coll
         result_file: None,
         workspace: team.clone(),
         json: true,
+        team: None,
     });
     assert!(
         collect.is_ok(),
@@ -239,7 +241,6 @@ fn quick_start_default_workspace_compiled_spec_uses_project_root() {
         &workspace,
         None,
         true,
-        true,
         None,
         &transport,
     )
@@ -286,7 +287,7 @@ fn quick_start_default_workspace_compiled_spec_uses_project_root() {
 fn quick_start_invalid_role_doc_surfaces_real_compile_error() {
     let team = quick_start_team_dir(QS_ROLE_NO_PROVIDER);
     let transport = OfflineTransport::new();
-    let result = quick_start_with_transport(&team, None, true, true, None, &transport);
+    let result = quick_start_with_transport(&team, None, true, None, &transport);
 
     let text = format!("{result:?}");
     assert!(
@@ -413,7 +414,7 @@ fn fork_agent_proceeds_past_owner_gate_for_unowned_workspace() {
             happens inside launch's real spawn). Acceptance-crate boundary, not a unit RED."]
 fn quick_start_full_ready_real_spawn() {
     let team = quick_start_team_dir(QS_VALID_ROLE);
-    let report = quick_start(&team, None, true, true, None).expect("quick_start launches the team");
+    let report = quick_start(&team, None, true, None).expect("quick_start launches the team");
     assert!(
         matches!(report, QuickStartReport::Ready { .. }),
         "got {report:?}"
@@ -532,7 +533,7 @@ fn unowned_running_ws_all_paused() -> PathBuf {
 fn spine_quick_start_seeds_state_under_team_workspace_not_team_dir() {
     let team = quick_start_team_dir(QS_VALID_ROLE); // <base>/teamdir
     let transport = OfflineTransport::new();
-    let _ = quick_start_with_transport(&team, None, true, true, None, &transport);
+    let _ = quick_start_with_transport(&team, None, true, None, &transport);
     let workspace = team.parent().unwrap(); // team_workspace(<base>/teamdir) = <base>
     let ws_state = crate::model::paths::runtime_dir(workspace).join("state.json");
     assert!(
@@ -1060,7 +1061,7 @@ fn quick_start_with_transport_spawns_workers_not_dry_run() {
     seed_healthy_coordinator(workspace);
     let transport = OfflineTransport::new();
 
-    let report = quick_start_with_transport(&team, None, true, true, None, &transport)
+    let report = quick_start_with_transport(&team, None, true, None, &transport)
         .expect("quick_start_with_transport must reach a report");
 
     let launch = match report {
@@ -1153,7 +1154,7 @@ fn quick_start_default_adaptive_groups_workers_into_layout_panes() {
     seed_healthy_coordinator(workspace);
     let transport = OfflineTransport::new();
 
-    let report = quick_start_with_transport(&team, None, true, true, None, &transport)
+    let report = quick_start_with_transport(&team, None, true, None, &transport)
         .expect("quick_start_with_transport must reach Ready");
 
     let (launch, attach_commands, display_backend) = match report {
@@ -1222,7 +1223,7 @@ fn quick_start_persists_selected_tmux_endpoint_and_attach_commands() {
     let endpoint = "/tmp/team-agent-layout-selected-socket";
     let transport = OfflineTransport::new().with_tmux_endpoint(endpoint);
 
-    let report = quick_start_with_transport(&team, None, true, true, None, &transport)
+    let report = quick_start_with_transport(&team, None, true, None, &transport)
         .expect("quick_start_with_transport must reach Ready");
     let attach_commands = match report {
         QuickStartReport::Ready { attach_commands, .. } => attach_commands,
@@ -1297,7 +1298,7 @@ fn quick_start_preserves_managed_leader_topology_and_emits_leader_attach_command
     .expect("seed managed leader state");
     let transport = OfflineTransport::new();
 
-    let report = quick_start_with_transport(&team, None, true, true, None, &transport)
+    let report = quick_start_with_transport(&team, None, true, None, &transport)
         .expect("quick_start_with_transport must reach Ready");
     let attach_commands = match report {
         QuickStartReport::Ready { attach_commands, .. } => attach_commands,
@@ -1375,7 +1376,7 @@ fn quick_start_no_display_keeps_one_window_per_agent() {
     let transport = OfflineTransport::new();
 
     let report = quick_start_with_transport_in_workspace_with_display(
-        workspace, &team, None, true, true, None, &transport, false,
+        workspace, &team, None, true, None, &transport, false,
     )
     .expect("quick_start_with_transport must reach Ready");
 
@@ -1407,7 +1408,7 @@ fn quick_start_no_display_keeps_one_window_per_agent() {
 #[ignore = "real-machine: live tmux session + resident coordinator daemon (framework verifies via ps)"]
 fn quick_start_fresh_ws_spawns_resident_tmux_and_coordinator() {
     let team = quick_start_team_dir(QS_VALID_ROLE);
-    let report = quick_start(&team, None, true, true, None).expect("quick_start");
+    let report = quick_start(&team, None, true, None).expect("quick_start");
     match report {
         QuickStartReport::Ready { launch, .. } => {
             assert!(
@@ -2462,7 +2463,7 @@ fn start_agent_adaptive_restarts_missing_pane_in_existing_layout_window() {
 fn quick_start_seeds_tasks_key_from_compiled_spec() {
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let transport = OfflineTransport::new();
-    let _ = quick_start_with_transport(&team, None, true, true, None, &transport);
+    let _ = quick_start_with_transport(&team, None, true, None, &transport);
     let workspace = team
         .parent()
         .expect("team_workspace(<base>/teamdir) = <base>");
@@ -2519,7 +2520,7 @@ fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
     let _tmux = EnvVarGuard::unset("TMUX");
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let transport = OfflineTransport::new();
-    let _ = quick_start_with_transport(&team, None, true, true, None, &transport);
+    let _ = quick_start_with_transport(&team, None, true, None, &transport);
     let workspace = team
         .parent()
         .expect("team_workspace(<base>/teamdir) = <base>");
@@ -2608,7 +2609,7 @@ fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
     let _clock_guard = EnvVarGuard::set("TEAM_AGENT_TEST_FIXED_SPAWNED_AT", FIXED_SPAWNED_AT);
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let transport = OfflineTransport::new();
-    let _ = quick_start_with_transport(&team, None, true, true, None, &transport);
+    let _ = quick_start_with_transport(&team, None, true, None, &transport);
     let workspace = team
         .parent()
         .expect("team_workspace(<base>/teamdir) = <base>");

package/crates/team-agent/src/lifecycle/types.rs

@@ -498,7 +498,7 @@ pub enum QuickStartReport {
         /// failed to spawn) so the CLI surface cannot lie about availability.
         worker_readiness: QuickStartReadiness,
     },
-    /// 已有 runtime state,非 --fresh → 引导用 restart(`quick_start.py:42`)。
+    /// 已有 runtime state → quick-start 拒绝并引导用 restart。
     ExistingRuntime {
         team: Option<String>,
         session_name: Option<SessionName>,

package/crates/team-agent/src/messaging/leader_receiver.rs

@@ -230,16 +230,23 @@ pub fn claim_leader_receiver(
             "runtime state root is not an object".to_string(),
         ));
     };
-    let owner = root
-        .entry("team_owner")
-        .or_insert_with(|| serde_json::json!({}));
-    if let Some(owner) = owner.as_object_mut() {
+    // Build the updated owner + receiver values in-place (field-level
+    // mutation preserves any extra fields the caller carries), then publish
+    // through the ownership repository. This keeps `claim_leader_receiver`'s
+    // legacy field-merge semantics while sourcing all owner mutations from
+    // one API surface (Stage 3a, architect direction 2026-06-23).
+    let mut owner_value = root
+        .get("team_owner")
+        .cloned()
+        .unwrap_or_else(|| serde_json::json!({}));
+    if let Some(owner) = owner_value.as_object_mut() {
         owner.insert("owner_epoch".to_string(), serde_json::json!(next_epoch));
     }
-    let receiver = root
-        .entry("leader_receiver")
-        .or_insert_with(|| serde_json::json!({}));
-    if let Some(receiver) = receiver.as_object_mut() {
+    let mut receiver_value = root
+        .get("leader_receiver")
+        .cloned()
+        .unwrap_or_else(|| serde_json::json!({}));
+    if let Some(receiver) = receiver_value.as_object_mut() {
         receiver.insert("mode".to_string(), serde_json::json!("direct_tmux"));
         receiver.insert("owner_epoch".to_string(), serde_json::json!(next_epoch));
         copy_candidate_field(receiver, candidate, "pane_id");
@@ -255,6 +262,13 @@ pub fn claim_leader_receiver(
             receiver.insert("tmux_socket".to_string(), serde_json::json!(socket));
         }
     }
+    // The `root` borrow above is released by NLL before this call.
+    let team_key = crate::state::projection::team_state_key(state);
+    let record = crate::state::ownership::OwnershipWrite::new()
+        .with_team_owner(owner_value)
+        .with_leader_receiver(receiver_value)
+        .with_owner_epoch(next_epoch);
+    crate::state::ownership::write_owner(state, &team_key, record);
     crate::state::persist::save_runtime_state(workspace, state)?;
     event_log.write(
         "leader_receiver.claimed",