@team-agent/installer 0.5.66 → 0.5.68

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

@@ -1,18 +1,105 @@
+//! ---
+//! purpose: 在当前席位窗口注入官方斜杠命令完成就地分身，不读 provider session 落盘
+//! contract:
+//!   provides:
+//!     - name: fork_agent_with_transport
+//!       what: grok/claude subscription 注入纯净斜杠命令；屏幕出现该 provider 的实测标记才算成功
+//!     - name: in_window_fork
+//!       what: 已验证的 provider+subscription 给出 command+screen_mark；未验证返回 None
+//!   depends:
+//!     - crate::lifecycle::lock
+//!     - crate::lifecycle::pane_input_lock
+//!     - crate::lifecycle::profile_launch
+//!     - crate::transport::Transport
+//! boundary:
+//!   - 不 spawn 新 pane，不改 TEAM_AGENT_ID / MCP / 席位名
+//!   - 不读 provider 会话落盘文件取会话身份
+//!   - 重试只重按回车，不重粘 /fork
+//!   - 不把 pane 锁超时从 200ms 调大
+//!   - 未验证的 provider 不猜斜杠命令
+//! maturity: wired
+//! ---
+
 use super::*;
-use crate::lifecycle::profile_launch::parse_provider;
+use crate::lifecycle::pane_input_lock::{
+    acquire_or_proceed, PaneInputLockRequest, PANE_INPUT_LOCK_TIMEOUT_EVENT,
+};
+use crate::lifecycle::profile_launch::{parse_auth_mode, parse_provider};
+use crate::model::enums::{AuthMode, Provider};
+
+const MAX_ENTER_RETRIES: u32 = 8;
+
+/// Injected slash command + the screen mark that proves it landed.
+/// Difference between providers lives only in this data.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct InWindowFork {
+    pub command: &'static str,
+    pub screen_mark: &'static str,
+}
+
+/// ---
+/// purpose: 给出该 provider 与鉴权方式下窗口内 fork 用的斜杠命令与成功标记
+/// returns: 已实测验证的组合返回命令与屏幕标记，其余一律 None
+/// ---
+/// Official in-window fork. None = unverified or unsupported-auth.
+/// grok `/fork` mark `forked from` (2026-08-17).
+/// claude `/branch` mark `Branched conversation` (Claude Code v2.1.181, 2026-08-17).
+/// claude `/fork` is a background-agent command (`Usage: /fork <directive>`), not the session split.
+pub fn in_window_fork(provider: Provider, auth: AuthMode) -> Option<InWindowFork> {
+    match (provider, auth) {
+        (Provider::Grok, AuthMode::Subscription) => Some(InWindowFork {
+            command: "/fork",
+            screen_mark: "forked from",
+        }),
+        (Provider::Claude | Provider::ClaudeCode, AuthMode::Subscription) => Some(InWindowFork {
+            command: "/branch",
+            screen_mark: "Branched conversation",
+        }),
+        _ => None,
+    }
+}
 
-mod completion;
+/// ---
+/// purpose: 只取窗口内 fork 的斜杠命令
+/// returns: 有已验证组合时返回命令，否则 None
+/// ---
+pub fn in_window_fork_command(provider: Provider, auth: AuthMode) -> Option<&'static str> {
+    in_window_fork(provider, auth).map(|spec| spec.command)
+}
 
+fn refuse_missing_in_window_fork(provider: Provider, provider_raw: &str) -> LifecycleError {
+    if matches!(
+        provider,
+        Provider::Grok | Provider::Claude | Provider::ClaudeCode | Provider::CursorAgent
+    ) {
+        LifecycleError::Provider(format!(
+            "{provider_raw} does not support native session fork"
+        ))
+    } else {
+        LifecycleError::Provider(format!(
+            "{provider_raw} in-window fork is unverified (未验证)"
+        ))
+    }
+}
+
+/// ---
+/// purpose: 在源席窗口内注入官方斜杠命令完成就地分身
+/// params:
+///   source_agent_id: 被 fork 的席位
+///   as_agent_id: 新席位名
+///   transport: 目标 team 实际使用的 transport
+/// returns: fork 报告，屏幕出现该 provider 的实测标记才记为已验证
+/// errors: 选不到 team 返回 TeamSelect，provider 或鉴权方式未验证返回 Provider，注入失败返回 LifecycleError
+/// ---
 pub fn fork_agent_with_transport(
     workspace: &Path,
     source_agent_id: &AgentId,
     as_agent_id: &AgentId,
-    label: Option<&str>,
-    open_display: bool,
+    _label: Option<&str>,
+    _open_display: bool,
     team: Option<&str>,
     transport: &dyn Transport,
 ) -> Result<ForkAgentReport, LifecycleError> {
-    let _ = open_display;
     let selected = crate::state::selector::resolve_active_team(
         workspace,
         team,
@@ -21,11 +108,11 @@ pub fn fork_agent_with_transport(
     .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
     let lock_workspace = selected.run_workspace.clone();
     let lock_team_key = selected.team_key.clone();
-    let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+    let _lifecycle_lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &lock_workspace,
         operation: "fork-agent",
         team: Some(lock_team_key.as_str()),
-        agent_id: Some(as_agent_id),
+        agent_id: Some(source_agent_id),
     })?;
     let selected = crate::state::selector::resolve_active_team(
         &lock_workspace,
@@ -33,467 +120,128 @@ pub fn fork_agent_with_transport(
         crate::state::selector::SelectorMode::RequireSpec,
     )
     .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
-    // E5 §3:team_dir(角色定义+profiles)恒用户目录。spec 读用 selector 解析的 spec_path
-    // (读序 B:runtime 优先、legacy 回落),写恒走 runtime_spec_path(canonical 落点)。
-    let fork_team_dir = selected.team_dir.clone();
-    let fork_team = selected.team_key.clone();
-    let read_spec_path = selected
-        .spec_path
-        .clone()
-        .ok_or_else(|| LifecycleError::TeamSelect("active team spec not found".to_string()))?;
-    let workspace = selected.run_workspace;
-    let state = selected.state;
-    ensure_owner_allowed_for_state(&state, Some(source_agent_id))?;
-    let spec_path = crate::model::paths::runtime_spec_path(&workspace, &fork_team);
-    let text = std::fs::read_to_string(&read_spec_path)
-        .map_err(|e| LifecycleError::Compile(format!("{}: {e}", read_spec_path.display())))?;
-    let spec = yaml::loads(&text).map_err(|e| LifecycleError::Compile(e.to_string()))?;
-    if fork_spec_agent(&spec, as_agent_id).is_some() || leader_id_matches(&spec, as_agent_id) {
-        return Err(LifecycleError::RequirementUnmet(format!(
-            "agent id already exists: {as_agent_id}"
-        )));
-    }
-    // Source existence authority: state.get("agents"), matching clone-agent.
-    let (session_id, source_backing) = fork_source_tuple(&state, source_agent_id)?;
-    let session_name = state
-        .get("session_name")
-        .and_then(|v| v.as_str())
-        .filter(|s| !s.is_empty())
-        .map(SessionName::new)
-        .unwrap_or_else(|| spec_session_name(&spec));
-    if transport
-        .list_windows(&session_name)
-        .map(|windows| windows.iter().any(|w| w.as_str() == as_agent_id.as_str()))
-        .unwrap_or(false)
-    {
-        return Err(LifecycleError::Transport(format!(
-            "tmux window already exists for fork target: {}:{}",
-            session_name.as_str(),
-            as_agent_id.as_str()
-        )));
-    }
-    let mut materialized_role = materialize_latest_role(
-        &workspace,
-        &fork_team_dir,
-        &state,
-        source_agent_id,
-        as_agent_id,
-        label,
-    )?;
-    clamp_materialized_role_to_leader(materialized_role.path(), &spec)?;
-    let team_meta = crate::compiler::read_front_matter(&fork_team_dir.join("TEAM.md"))
-        .map(|(meta, _)| meta)
-        .map_err(|error| LifecycleError::Compile(error.to_string()))?;
-    let workspace_s = workspace.to_string_lossy().to_string();
-    let compiled =
-        crate::compiler::compile_role_agent(materialized_role.path(), &team_meta, &workspace_s)
-            .map_err(|error| LifecycleError::Compile(error.to_string()))?;
-    let new_spec =
-        append_forked_agent(&spec, &compiled.agent, source_agent_id, as_agent_id, label)?;
-    // validate 用角色定义目录的 team_workspace(校验 working_directory),非 spec 落点。
-    let validate_ws =
-        crate::model::paths::team_workspace(&fork_team_dir).unwrap_or_else(|_| workspace.clone());
-    crate::model::spec::validate_spec(&new_spec, &validate_ws)
-        .map_err(|e| LifecycleError::Compile(e.to_string()))?;
-    write_spec_atomic(&spec_path, &new_spec)?;
-    let new_agent = fork_spec_agent(&new_spec, as_agent_id).ok_or_else(|| {
-        LifecycleError::RequirementUnmet(format!("unknown worker agent id: {as_agent_id}"))
-    })?;
-    let provider = new_agent
+    let run_ws = selected.run_workspace.clone();
+    let agent = selected
+        .state
+        .get("agents")
+        .and_then(|agents| agents.get(source_agent_id.as_str()))
+        .ok_or_else(|| {
+            LifecycleError::RequirementUnmet(format!("unknown worker agent id: {source_agent_id}"))
+        })?;
+    let provider_raw = agent
         .get("provider")
-        .and_then(Value::as_str)
-        .and_then(parse_provider)
-        .unwrap_or(Provider::Codex);
-    let auth_mode = new_agent
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("unknown");
+    let auth_raw = agent
         .get("auth_mode")
-        .and_then(Value::as_str)
-        .and_then(parse_auth_mode)
-        .unwrap_or(AuthMode::Subscription);
-    let adapter = crate::provider::get_adapter(provider);
-    let provider_str = new_agent
-        .get("provider")
-        .and_then(Value::as_str)
-        .unwrap_or("codex");
-    if auth_mode == AuthMode::CompatibleApi || !adapter.caps().fork {
-        let _ = std::fs::write(&spec_path, text.as_bytes());
-        return Err(LifecycleError::Provider(format!(
-            "{provider_str} does not support native session fork"
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("subscription");
+    let provider = parse_provider(provider_raw).unwrap_or(Provider::Grok);
+    let auth = parse_auth_mode(auth_raw).unwrap_or(AuthMode::Subscription);
+    let Some(spec) = in_window_fork(provider, auth) else {
+        return Err(refuse_missing_in_window_fork(provider, provider_raw));
+    };
+    if as_agent_id.as_str() != source_agent_id.as_str() {
+        return Err(LifecycleError::RequirementUnmet(format!(
+            "in-place fork refuses --as {as_agent_id}: session stays on {source_agent_id}"
         )));
     }
-    let model = new_agent.get("model").and_then(Value::as_str);
-    let safety = effective_runtime_config_for_worker_spawn(new_agent, provider)?;
-    let command_agent = crate::lifecycle::worker_command_context::WorkerCommandAgent::from_yaml(
-        new_agent,
-        Some(as_agent_id.as_str()),
-        provider,
-    )?;
-    let system_prompt =
-        crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
-    let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(
-        &command_agent,
-        provider,
-    )?;
-    let resolved_tool_refs: Vec<&str> = tools.iter().map(String::as_str).collect();
-    let mcp_config = adapter.mcp_config(auth_mode).map_err(|e| {
-        let _ = std::fs::write(&spec_path, text.as_bytes());
-        LifecycleError::Provider(e.to_string())
-    })?;
-    let mcp_config = resolve_mcp_config(mcp_config, &workspace, as_agent_id.as_str(), &fork_team);
-    let mcp_config_path = write_worker_mcp_config_for_provider(
-        &workspace,
-        as_agent_id.as_str(),
-        &mcp_config,
-        Some(provider),
-    )
-    .map_err(|e| {
-        let _ = std::fs::write(&spec_path, text.as_bytes());
-        e
-    })?;
-    // E5 §3:profiles 随角色定义目录(team_dir),不随已迁出的 spec。
-    let profile_dir = fork_team_dir.join("profiles");
-    let mut profile_launch =
-        match crate::lifecycle::profile_launch::prepare_provider_profile_launch_with_profile_dir(
-            &workspace,
-            as_agent_id.as_str(),
-            new_agent,
-            Some(&profile_dir),
-            Some(&mcp_config),
-        ) {
-            Ok(profile_launch) => profile_launch,
-            Err(error) => {
-                let _ = std::fs::write(&spec_path, text.as_bytes());
-                let _ = std::fs::remove_file(&mcp_config_path);
-                return Err(error);
-            }
-        };
-    let mut copilot_fork = None;
-    if provider == Provider::Copilot {
-        let materialized = crate::provider::adapters::copilot_fork::materialize_copilot_fork(
-            &workspace,
-            as_agent_id.as_str(),
-            &session_id,
-        )
-        .map_err(|error| {
-            let _ = std::fs::write(&spec_path, text.as_bytes());
-            cleanup_fork_mcp_artifacts(&workspace, as_agent_id, &mcp_config_path, &profile_launch);
-            LifecycleError::Provider(error.to_string())
+    let pane_raw = agent
+        .get("pane_id")
+        .and_then(serde_json::Value::as_str)
+        .filter(|s| !s.is_empty())
+        .ok_or_else(|| {
+            LifecycleError::RequirementUnmet(format!(
+                "source agent {source_agent_id} has no pane_id"
+            ))
         })?;
-        profile_launch.env_overlay.insert(
-            "COPILOT_HOME".to_string(),
-            materialized.home().to_string_lossy().to_string(),
+    let target = Target::Pane(PaneId::new(pane_raw));
+    let lock = acquire_or_proceed(PaneInputLockRequest {
+        workspace: Some(&run_ws),
+        target_key: pane_raw,
+        operation: "fork-inject",
+    });
+    if lock.is_none() {
+        let _ = crate::event_log::EventLog::new(&run_ws).write(
+            PANE_INPUT_LOCK_TIMEOUT_EVENT,
+            serde_json::json!({
+                "during": "fork-inject",
+                "agent_id": source_agent_id.as_str(),
+                "pane_id": pane_raw,
+                "observed_at": chrono::Utc::now().to_rfc3339(),
+            }),
         );
-        profile_launch.env_overlay.insert(
-            "TEAM_AGENT_INTERNAL_COPILOT_FORK_SESSION_ID".to_string(),
-            materialized.session_id().as_str().to_string(),
-        );
-        copilot_fork = Some(materialized);
-    }
-    let command_model = profile_launch.command_overrides.model.as_deref().or(model);
-    // 0.4.x provider effort MVP: fork inherits effort from the new agent JSON
-    // (compiler.rs propagated the role/team effort into the agent at fork-spawn).
-    let fork_effort = provider_effort_for_spawn(new_agent, provider);
-    if let Some(event_value) =
-        provider_effort_event_if_dropped(new_agent, provider, as_agent_id.as_str())
-    {
-        let _ = crate::event_log::EventLog::new(&workspace)
-            .write("provider.effort_unsupported", event_value);
-    }
-    let mut plan = adapter
-        .fork_plan(
-            Some(&session_id),
-            crate::provider::ProviderCommandContext {
-                auth_mode,
-                mcp_config: Some(&mcp_config),
-                system_prompt: Some(system_prompt.as_str()),
-                model: command_model,
-                tools: &resolved_tool_refs,
-                profile_launch: Some(&profile_launch),
-                agent_id_hint: Some(as_agent_id.as_str()),
-                effort: fork_effort,
-            },
-        )
-        .map_err(|e| {
-            let _ = std::fs::write(&spec_path, text.as_bytes());
-            cleanup_fork_mcp_artifacts(&workspace, as_agent_id, &mcp_config_path, &profile_launch);
-            LifecycleError::Provider(e.to_string())
-        })?;
-    profile_launch
-        .env_overlay
-        .remove("TEAM_AGENT_INTERNAL_COPILOT_FORK_SESSION_ID");
-    if !plan.managed_mcp_config && !profile_launch.managed_mcp_config {
-        point_native_mcp_config_at_file(&mut plan.argv, provider, &mcp_config_path);
-    }
-    fill_spawn_placeholders_full(
-        &mut plan.argv,
-        &workspace,
-        as_agent_id.as_str(),
-        Some(&fork_team),
-    );
-    let spawned_at = spawn_timestamp_for_agent(1);
-    let mut fork_backing = adapter
-        .materialize_fork_backing(
-            &source_backing,
-            &session_id,
-            source_agent_id.as_str(),
-            as_agent_id.as_str(),
-            &mut plan,
-        )
-        .map_err(|error| {
-            let _ = std::fs::write(&spec_path, text.as_bytes());
-            cleanup_fork_mcp_artifacts(&workspace, as_agent_id, &mcp_config_path, &profile_launch);
-            LifecycleError::Provider(error.to_string())
-        })?;
-    let mut expected_backing_path = fork_backing
-        .as_ref()
-        .map(|materialized| materialized.path().to_path_buf());
-    if matches!(provider, Provider::Claude | Provider::ClaudeCode) {
-        plan.provider_projects_root = source_backing.parent().map(Path::to_path_buf);
-    }
-    let window = WindowName::new(as_agent_id.as_str());
-    let mut claude_fork = prepare_claude_fork_backing(
-        provider,
-        &plan,
-        &source_backing,
-        &session_id,
-        source_agent_id,
-        as_agent_id,
-    )
-    .map_err(|error| {
-        let _ = std::fs::write(&spec_path, text.as_bytes());
-        cleanup_fork_mcp_artifacts(&workspace, as_agent_id, &mcp_config_path, &profile_launch);
-        error
-    })?;
-    if expected_backing_path.is_none() {
-        expected_backing_path = claude_fork
-            .as_ref()
-            .map(|materialized| materialized.path().to_path_buf());
     }
-    // The framework-created Claude snapshot is only fork input, not provider
-    // proof. Observe changes made after materialization so a spawn-only
-    // provider cannot turn the copied source backing into a Verified result.
-    let backing_before = crate::provider::session::ContextBackingSnapshot::capture(provider, &plan);
-    let mut env =
-        inherited_env_with_team_overrides(&workspace, as_agent_id.as_str(), Some(&fork_team));
-    apply_profile_launch_env(&mut env, &profile_launch);
-    apply_mcp_auto_approval_env(&mut env, &safety);
-    if provider == Provider::Copilot {
-        apply_copilot_instructions_overlay(
-            &workspace,
-            as_agent_id.as_str(),
-            &system_prompt,
-            &mut env,
+    inject_clean_command(transport, &target, spec.command)?;
+    wait_for_screen_mark(transport, &target, spec.screen_mark)?;
+    drop(lock);
+    crate::event_log::EventLog::new(&run_ws)
+        .write(
+            "lifecycle.fork.in_place",
+            serde_json::json!({
+                "source_agent_id": source_agent_id.as_str(),
+                "agent_id": source_agent_id.as_str(),
+                "pane_id": pane_raw,
+                "command": spec.command,
+                "screen_mark": spec.screen_mark,
+            }),
         )
-        .map_err(|error| {
-            let _ = std::fs::write(&spec_path, text.as_bytes());
-            cleanup_fork_mcp_artifacts(&workspace, as_agent_id, &mcp_config_path, &profile_launch);
-            error
-        })?;
-    }
-    let mut reserved_state = state.clone();
-    reserve_forked_agent_state(
-        &mut reserved_state,
-        source_agent_id,
-        as_agent_id,
-        new_agent,
-        materialized_role.path(),
-    )?;
-    if let Err(error) = crate::state::repository::StateRepository::new(&workspace).save(
-        crate::state::repository::StateWriteIntent::ForkAgent {
-            team_key: &fork_team,
-            agent_id: as_agent_id.as_str(),
+        .map_err(|e| LifecycleError::StatePersist(format!("fork audit write failed: {e}")))?;
+    Ok(ForkAgentReport {
+        source_agent_id: source_agent_id.clone(),
+        new_agent_id: source_agent_id.clone(),
+        env: AgentActionEnvelope {
+            agent_id: source_agent_id.clone(),
+            state_file: crate::state::persist::runtime_state_path(&run_ws),
+            coordinator_started: false,
         },
-        &reserved_state,
-    ) {
-        let _ = std::fs::write(&spec_path, text.as_bytes());
-        cleanup_fork_mcp_artifacts(&workspace, as_agent_id, &mcp_config_path, &profile_launch);
-        return Err(LifecycleError::StatePersist(error.to_string()));
-    }
-    // Match launch/restart: absent session spawns first; otherwise add a window.
-    let session_live = transport.has_session(&session_name).unwrap_or(false);
-    let env_unset = crate::layout::worker_env::isolate_worker_spawn_env(
-        provider,
-        &mut env,
-        extend_worker_env_unset_for_effort(
-            profile_launch.env_unset.iter().cloned().collect(),
-            provider,
-        ),
-    );
-    // Release the metadata lock before per-seat provider convergence; finalize reacquires it.
-    drop(_lock);
-    let spawn_epoch = 1_u64;
-    let spawn_result = if session_live {
-        transport.spawn_into_with_env_unset(
-            &session_name,
-            &window,
-            &plan.argv,
-            &workspace,
-            &env,
-            &env_unset,
-        )
-    } else {
-        transport.spawn_first_with_env_unset(
-            &session_name,
-            &window,
-            &plan.argv,
-            &workspace,
-            &env,
-            &env_unset,
+        session_id: None,
+        backing_state: ForkBackingState::Verified,
+    })
+}
+
+fn inject_clean_command(
+    transport: &dyn Transport,
+    target: &Target,
+    command: &str,
+) -> Result<(), LifecycleError> {
+    transport
+        .inject(
+            target,
+            &crate::transport::InjectPayload::TextSkipConsumptionPoll(command.to_string()),
+            crate::transport::Key::Enter,
+            false,
         )
-    };
-    let spawn = match spawn_result {
-        Ok(spawn) => spawn,
-        Err(error) => {
-            rollback_fork_after_spawn(
-                &workspace,
-                transport,
-                &session_name,
-                &window,
-                &mcp_config_path,
-                as_agent_id,
-                &profile_launch,
-                &fork_team,
-            );
-            return Err(LifecycleError::Transport(error.to_string()));
+        .map_err(|e| LifecycleError::Transport(e.to_string()))?;
+    Ok(())
+}
+
+const NO_CONVERSATION_TO_BRANCH: &str = "Failed to branch conversation: No conversation to branch";
+
+fn wait_for_screen_mark(
+    transport: &dyn Transport,
+    target: &Target,
+    screen_mark: &str,
+) -> Result<(), LifecycleError> {
+    for attempt in 0..MAX_ENTER_RETRIES {
+        let cap = transport
+            .capture(target, crate::transport::CaptureRange::Tail(40))
+            .map_err(|e| LifecycleError::Transport(e.to_string()))?;
+        if cap.text.contains(screen_mark) {
+            return Ok(());
         }
-    };
-    if let Some(materialized) = fork_backing.as_mut() {
-        materialized.handoff();
-    }
-    ensure_fork_spawn_live(ForkPostSpawnInput {
-        workspace: &workspace,
-        transport,
-        session_name: &session_name,
-        window: &window,
-        mcp_config_path: &mcp_config_path,
-        agent_id: as_agent_id,
-        profile_launch: &profile_launch,
-        team_key: &fork_team,
-        spawn: &spawn,
-    })?;
-    let convergence_deadline =
-        crate::provider::session::context_fork_convergence_deadline(provider);
-    let context_outcome = crate::provider::session::observe_context_fork(
-        provider,
-        &session_id,
-        &plan,
-        &backing_before,
-        expected_backing_path.as_deref(),
-        source_agent_id.as_str(),
-        as_agent_id.as_str(),
-        &workspace,
-        &spawned_at,
-        convergence_deadline,
-    );
-    let context_proof = match context_outcome {
-        crate::provider::session::ContextForkOutcome::Verified(proof) => Some(proof),
-        crate::provider::session::ContextForkOutcome::Pending(pending) => {
-            if let Err(error) = finalize_pending_fork_state(ForkPendingFinalizeInput {
-                workspace: &workspace,
-                team_key: &fork_team,
-                source_agent_id,
-                agent_id: as_agent_id,
-                spec_agent: new_agent,
-                safety: &safety,
-                plan: &plan,
-                profile_launch: &profile_launch,
-                spawn: &spawn,
-                profile_dir: &profile_dir,
-                dynamic_role_file: materialized_role.path(),
-                pending: &pending,
-                spawn_epoch,
-            }) {
-                rollback_fork_after_spawn(
-                    &workspace,
-                    transport,
-                    &session_name,
-                    &window,
-                    &mcp_config_path,
-                    as_agent_id,
-                    &profile_launch,
-                    &fork_team,
-                );
-                return Err(error);
-            }
-            None
+        if cap.text.contains(NO_CONVERSATION_TO_BRANCH) {
+            return Err(LifecycleError::RequirementUnmet(
+                NO_CONVERSATION_TO_BRANCH.to_string(),
+            ));
         }
-        crate::provider::session::ContextForkOutcome::Rejected(error) => {
-            rollback_fork_after_spawn(
-                &workspace,
-                transport,
-                &session_name,
-                &window,
-                &mcp_config_path,
-                as_agent_id,
-                &profile_launch,
-                &fork_team,
-            );
-            return Err(LifecycleError::Provider(error.to_string()));
+        if attempt + 1 < MAX_ENTER_RETRIES {
+            // Mixed text in the box is not failure. Retry Enter only — never re-paste the slash command.
+            let _ = transport.send_keys(target, &[crate::transport::Key::Enter]);
+            std::thread::sleep(std::time::Duration::from_millis(80));
         }
-    };
-    if let Some(context_proof) = context_proof.as_ref() {
-        let finalized = match finalize_fork_state(ForkFinalizeInput {
-            workspace: &workspace,
-            team_key: &fork_team,
-            source_agent_id,
-            agent_id: as_agent_id,
-            spec_agent: new_agent,
-            safety: &safety,
-            plan: &plan,
-            profile_launch: &profile_launch,
-            spawn: &spawn,
-            profile_dir: &profile_dir,
-            dynamic_role_file: materialized_role.path(),
-            context_proof: &context_proof,
-            spawned_at: &spawned_at,
-            spawn_epoch,
-        }) {
-            Ok(finalized) => finalized,
-            Err(error) => {
-                rollback_fork_after_spawn(
-                    &workspace,
-                    transport,
-                    &session_name,
-                    &window,
-                    &mcp_config_path,
-                    as_agent_id,
-                    &profile_launch,
-                    &fork_team,
-                );
-                return Err(error);
-            }
-        };
-        finalized
-            .write_audit(&crate::event_log::EventLog::new(&workspace))
-            .map_err(|error| LifecycleError::StatePersist(error.to_string()))?;
     }
-    let coordinator_started = completion::complete_fork(completion::CompleteForkInput {
-        workspace: &workspace,
-        team_key: &fork_team,
-        agent_id: as_agent_id,
-        spawn: &spawn,
-        window: &window,
-        transport,
-        session_name: &session_name,
-        mcp_config_path: &mcp_config_path,
-        profile_launch: &profile_launch,
-        materialized_role: &mut materialized_role,
-        claude_fork: &mut claude_fork,
-        copilot_fork: &mut copilot_fork,
-    })?;
-    let backing_state = if context_proof.is_some() {
-        ForkBackingState::Verified
-    } else {
-        ForkBackingState::PendingContextFork
-    };
-    Ok(ForkAgentReport {
-        source_agent_id: source_agent_id.clone(),
-        new_agent_id: as_agent_id.clone(),
-        env: AgentActionEnvelope {
-            agent_id: as_agent_id.clone(),
-            state_file: crate::state::persist::runtime_state_path(&workspace),
-            coordinator_started,
-        },
-        session_id: context_proof.map(|proof| proof.new_session_id),
-        backing_state,
-    })
+    Err(LifecycleError::RequirementUnmet(format!(
+        "fork inject did not produce {screen_mark:?} on screen"
+    )))
 }