@team-agent/installer 0.5.51 → 0.5.53

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.51"
+version = "0.5.53"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.51"
+version = "0.5.53"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/adapters.rs

@@ -876,8 +876,10 @@ fn fake_shutdown(workspace: &Path) -> Result<Value, CliError> {
             }
         }
     }
-    crate::state::repository::StateRepository::new(workspace)
-        .save(crate::state::repository::StateWriteIntent::FakeE2eSeed, &state)?;
+    crate::state::repository::StateRepository::new(workspace).save(
+        crate::state::repository::StateWriteIntent::FakeE2eSeed,
+        &state,
+    )?;
     Ok(json!({
         "ok": true,
         "session_name": state.get("session_name").cloned().unwrap_or(Value::Null),
@@ -1375,6 +1377,20 @@ pub fn cmd_fork_agent(args: &ForkAgentArgs) -> Result<CmdResult, CliError> {
     ))
 }
 
+pub fn cmd_clone_agent(args: &CloneAgentArgs) -> Result<CmdResult, CliError> {
+    Ok(CmdResult::from_json(
+        lifecycle_port::clone_agent(
+            &args.workspace,
+            &args.source_agent,
+            &args.as_agent,
+            args.label.as_deref(),
+            !args.no_display,
+            args.team.as_deref(),
+        )?,
+        args.json,
+    ))
+}
+
 /// `cmd_remove_agent`(`commands.py:394`)。
 pub fn cmd_remove_agent(args: &RemoveAgentArgs) -> Result<CmdResult, CliError> {
     Ok(CmdResult::from_json(

package/crates/team-agent/src/cli/emit.rs

@@ -115,6 +115,7 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "stop-agent" => cmd_stop_agent(&stop_agent_args(args, cwd)?).map(emit_result),
         "reset-agent" => cmd_reset_agent(&reset_agent_args(args, cwd)?).map(emit_result),
         "add-agent" => cmd_add_agent(&add_agent_args(args, cwd)?).map(emit_result),
+        "clone-agent" => cmd_clone_agent(&clone_agent_args(args, cwd)?).map(emit_result),
         "fork-agent" => cmd_fork_agent(&fork_agent_args(args, cwd)?).map(emit_result),
         "remove-agent" => cmd_remove_agent(&remove_agent_args(args, cwd)?).map(emit_result),
         "stuck-list" => cmd_stuck_list(&stuck_list_args(args, cwd)).map(emit_result),
@@ -330,6 +331,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("start-agent") => "usage: team-agent start-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--force] [--allow-fresh] [--no-display] [--json]".to_string(),
         Some("stop-agent") => "usage: team-agent stop-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("add-agent") => "usage: team-agent add-agent AGENT --role-file FILE [--force] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]".to_string(),
+        Some("clone-agent") => "usage: team-agent clone-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]".to_string(),
         Some("fork-agent") => "usage: team-agent fork-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]".to_string(),
         Some("remove-agent") => "usage: team-agent remove-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--from-spec] [--confirm] [--force] [--json]".to_string(),
         // 0.5.26 (§7.6): removed from help; dispatch was never wired.
@@ -1366,6 +1368,21 @@ fn fork_agent_args(args: &[String], cwd: &Path) -> Result<ForkAgentArgs, CliErro
     })
 }
 
+fn clone_agent_args(args: &[String], cwd: &Path) -> Result<CloneAgentArgs, CliError> {
+    let parsed = parse_args(args);
+    Ok(CloneAgentArgs {
+        source_agent: required_pos(&parsed, 0, "source_agent")?,
+        workspace: workspace(&parsed, cwd),
+        team: parsed.team,
+        as_agent: parsed
+            .as_agent
+            .ok_or_else(|| CliError::Usage("missing --as".to_string()))?,
+        label: parsed.label,
+        no_display: parsed.no_display,
+        json: parsed.json,
+    })
+}
+
 fn remove_agent_args(args: &[String], cwd: &Path) -> Result<RemoveAgentArgs, CliError> {
     let parsed = parse_args(args);
     let workspace = workspace(&parsed, cwd);

package/crates/team-agent/src/cli/mod.rs

@@ -374,6 +374,19 @@ pub mod lifecycle_port {
                     );
                     let mut error = None;
                     for session in &sessions {
+                        let targets = vec![session.as_str().to_string()];
+                        if let Err(audit_error) = crate::kill_audit::pre_kill_audit(
+                            event_log,
+                            transport,
+                            "shutdown.shared_socket_individual",
+                            crate::kill_audit::KILL_SESSION,
+                            &targets,
+                        ) {
+                            error.get_or_insert_with(|| {
+                                format!("pre-kill audit failed: {audit_error}")
+                            });
+                            continue;
+                        }
                         if let Err(err) = transport.kill_session(session) {
                             if !tmux_absent_error(&err.to_string()) {
                                 error.get_or_insert_with(|| err.to_string());
@@ -386,7 +399,20 @@ pub mod lifecycle_port {
                         error,
                     };
                 }
-                let error = transport.kill_server().err().map(|error| error.to_string());
+                let targets = sessions
+                    .iter()
+                    .map(|session| session.as_str().to_string())
+                    .collect::<Vec<_>>();
+                let error = match crate::kill_audit::pre_kill_audit(
+                    event_log,
+                    transport,
+                    "shutdown.exclusive_socket",
+                    crate::kill_audit::KILL_SERVER,
+                    &targets,
+                ) {
+                    Ok(()) => transport.kill_server().err().map(|error| error.to_string()),
+                    Err(error) => Some(format!("pre-kill audit failed: {error}")),
+                };
                 ShutdownSocketCleanup {
                     killed_sessions: sessions,
                     spared_sessions: Vec::new(),
@@ -406,6 +432,18 @@ pub mod lifecycle_port {
                 }
                 let mut error = None;
                 for session in &to_kill {
+                    let targets = vec![session.as_str().to_string()];
+                    if let Err(audit_error) = crate::kill_audit::pre_kill_audit(
+                        event_log,
+                        transport,
+                        "shutdown.selected_session",
+                        crate::kill_audit::KILL_SESSION,
+                        &targets,
+                    ) {
+                        error
+                            .get_or_insert_with(|| format!("pre-kill audit failed: {audit_error}"));
+                        continue;
+                    }
                     if let Err(err) = transport.kill_session(session) {
                         if !tmux_absent_error(&err.to_string()) {
                             error.get_or_insert_with(|| err.to_string());
@@ -421,6 +459,59 @@ pub mod lifecycle_port {
         }
     }
 
+    #[cfg(test)]
+    mod kill_audit_tests {
+        use std::collections::BTreeMap;
+
+        use super::*;
+        use crate::transport::test_support::OfflineTransport;
+        use crate::transport::{PaneId, PaneInfo, SessionName};
+
+        #[test]
+        fn audit_write_failure_skips_destructive_kill() {
+            let root =
+                std::env::temp_dir().join(format!("ta-kill-audit-fail-{}", std::process::id()));
+            let blocked_parent = root.join("not-a-directory");
+            std::fs::create_dir_all(&root).unwrap();
+            std::fs::write(&blocked_parent, b"file").unwrap();
+            let event_log = crate::event_log::EventLog::at(blocked_parent.join("events.jsonl"));
+            let session = SessionName::new("team-audit-fail");
+            let transport = OfflineTransport::new()
+                .with_session_present(true)
+                .with_targets(vec![PaneInfo {
+                    pane_id: PaneId::new("%1"),
+                    session: session.clone(),
+                    window_index: Some(0),
+                    window_name: None,
+                    pane_index: Some(0),
+                    tty: None,
+                    current_command: None,
+                    current_path: None,
+                    active: true,
+                    pane_pid: None,
+                    leader_env: BTreeMap::new(),
+                }]);
+            let cleanup = bare_shutdown_socket_cleanup(
+                &transport,
+                &json!({
+                    "is_external_leader": true,
+                    "tmux_socket_source": "leader_env",
+                }),
+                &event_log,
+            );
+
+            assert!(
+                !transport.calls().contains(&"kill_session"),
+                "an unaudited destructive call must not execute"
+            );
+            assert!(cleanup
+                .error
+                .as_deref()
+                .is_some_and(|error| error.contains("pre-kill audit failed")));
+            let _ = std::fs::remove_dir_all(root);
+        }
+    }
+
     fn state_uses_external_leader(state: &Value) -> bool {
         crate::state::projection::state_is_external_leader(state)
     }
@@ -501,6 +592,17 @@ pub mod lifecycle_port {
                 );
                 continue;
             }
+            let targets = vec![session.as_str().to_string()];
+            if let Err(audit_error) = crate::kill_audit::pre_kill_audit(
+                event_log,
+                transport,
+                "shutdown.managed_worker_session",
+                crate::kill_audit::KILL_SESSION,
+                &targets,
+            ) {
+                error.get_or_insert_with(|| format!("pre-kill audit failed: {audit_error}"));
+                continue;
+            }
             if let Err(err) = transport.kill_session(session) {
                 if !tmux_absent_error(&err.to_string()) {
                     error.get_or_insert_with(|| err.to_string());
@@ -598,6 +700,16 @@ pub mod lifecycle_port {
             );
             return cleanup;
         }
+        if let Err(error) = crate::kill_audit::pre_kill_audit(
+            event_log,
+            transport,
+            "shutdown.empty_owned_endpoint",
+            crate::kill_audit::KILL_SERVER,
+            &[],
+        ) {
+            cleanup.error = Some(format!("pre-kill audit failed: {error}"));
+            return cleanup;
+        }
         if let Err(error) = transport.kill_server() {
             cleanup.error = Some(error.to_string());
         }
@@ -748,11 +860,24 @@ pub mod lifecycle_port {
                 let _ =
                     crate::lifecycle::display::close_team_display_backends(&run_workspace, session);
             } else {
-                push_unique_session(&mut killed_sessions, session.clone());
-                if let Err(error) = transport.kill_session(session) {
-                    if !tmux_absent_error(&error.to_string()) {
+                let targets = vec![session.as_str().to_string()];
+                let event_log = crate::event_log::EventLog::new(&run_workspace);
+                if let Err(error) = crate::kill_audit::pre_kill_audit(
+                    &event_log,
+                    transport,
+                    "shutdown.team_session",
+                    crate::kill_audit::KILL_SESSION,
+                    &targets,
+                ) {
+                    kill_error = Some(format!("pre-kill audit failed: {error}"));
+                } else if let Err(error) = transport.kill_session(session) {
+                    if tmux_absent_error(&error.to_string()) {
+                        push_unique_session(&mut killed_sessions, session.clone());
+                    } else {
                         kill_error = Some(error.to_string());
                     }
+                } else {
+                    push_unique_session(&mut killed_sessions, session.clone());
                 }
                 let _ =
                     crate::lifecycle::display::close_team_display_backends(&run_workspace, session);
@@ -2357,10 +2482,36 @@ pub mod lifecycle_port {
                 "ok": true,
                 "source_agent_id": report.source_agent_id.as_str(),
                 "new_agent_id": report.new_agent_id.as_str(),
+                "session_id": report.session_id.as_ref().map(|session| session.as_str()),
+                "new_session_id": report.session_id.as_ref().map(|session| session.as_str()),
             })),
             Err(e) => Ok(error_value(e)),
         }
     }
+    pub fn clone_agent(
+        workspace: &Path,
+        source_agent: &str,
+        as_agent_id: &str,
+        label: Option<&str>,
+        open_display: bool,
+        team: Option<&str>,
+    ) -> Result<Value, CliError> {
+        let source = crate::model::ids::AgentId::new(source_agent);
+        let dest = crate::model::ids::AgentId::new(as_agent_id);
+        match crate::lifecycle::clone_agent(workspace, &source, &dest, label, open_display, team) {
+            Ok(report) => Ok(json!({
+                "ok": true,
+                "status": "cloned",
+                "source_agent_id": report.source_agent_id.as_str(),
+                "new_agent_id": report.new_agent_id.as_str(),
+                "session_id": report.session_id.as_ref().map(|session| session.as_str()),
+                "new_session_id": report.session_id.as_ref().map(|session| session.as_str()),
+                "backing_path": report.backing_path.as_ref().map(|path| path.to_string_lossy()),
+                "backing_state": report.backing_state,
+            })),
+            Err(error) => Ok(error_value(error)),
+        }
+    }
     /// `runtime.remove_agent`(`cmd_remove_agent`;`--from-spec` 须配 `--confirm`)。
     pub fn remove_agent(
         workspace: &Path,

package/crates/team-agent/src/cli/named_address.rs

@@ -939,103 +939,71 @@ fn resolve_leader(
         );
         return Err(err);
     }
-    if crate::codex_app_server::receiver_is_app_server(receiver) {
-        return resolve_app_server_leader(
-            sender_workspace,
-            target_workspace,
-            team,
-            parsed,
-            receiver,
-        );
-    }
-    let pane_id = string_field(receiver, "pane_id")
-        .filter(|pane| !pane.is_empty())
-        .ok_or_else(|| {
-            let mut err = leader_not_attached_third_party(
-                target_workspace,
-                team,
-                None,
-                None,
-                None,
-                transport.tmux_endpoint(),
-            );
-            err.candidates =
-                leader_advisory_candidates(state, team, transport, "state_recorded_socket");
-            err
-        })?;
     let session = string_field(receiver, "session_name");
     let window = string_field(receiver, "window_name");
     let socket = string_field(receiver, "tmux_socket")
         .map(str::to_string)
         .or_else(|| transport.tmux_endpoint());
-    let targets = list_targets(transport)?;
-    let matches = targets
-        .iter()
-        .filter(|target| {
-            target.pane_id.as_str() == pane_id
-                && session.is_none_or(|expected| target.session.as_str() == expected)
-                && window.is_none_or(|expected| {
-                    target
-                        .window_name
-                        .as_ref()
-                        .is_some_and(|name| name.as_str() == expected)
-                })
-        })
-        .collect::<Vec<_>>();
-    let stale_pane_seen = targets
-        .iter()
-        .any(|target| target.pane_id.as_str() == pane_id);
-    match matches.len() {
-        1 => Ok(ResolvedNamedAddress {
+    match crate::messaging::resolve_live_leader_channel(
+        target_workspace,
+        receiver,
+        transport,
+    ) {
+        crate::messaging::LeaderChannelResolution::Live(
+            crate::messaging::LiveLeaderChannel::DirectTmux(channel),
+        ) => Ok(ResolvedNamedAddress {
             raw_name: parsed.display_name(),
             target_kind: NamedTargetKind::Leader,
             sender_workspace: sender_workspace.to_path_buf(),
             target_workspace: target_workspace.to_path_buf(),
             team_key: Some(team.to_string()),
             agent_id: None,
-            pane_id: pane_id.to_string(),
+            pane_id: channel.pane_id.clone(),
             session_name: session.map(str::to_string),
             window_name: window.map(str::to_string),
             tmux_endpoint: socket,
             transport_kind: Some("direct_tmux".to_string()),
             app_server: None,
-            state_pane_id: Some(pane_id.to_string()),
+            state_pane_id: Some(channel.pane_id),
             state_pane_stale: false,
             agent_status: None,
-            warning: None,
+            warning: (!channel.metadata_drift.is_empty()).then(|| {
+                format!(
+                    "leader_channel_metadata_drift:{}",
+                    channel.metadata_drift.join(",")
+                )
+            }),
         }),
-        0 => {
+        crate::messaging::LeaderChannelResolution::Live(
+            crate::messaging::LiveLeaderChannel::CodexAppServer(_),
+        ) => resolve_app_server_leader(sender_workspace, target_workspace, team, parsed, receiver),
+        crate::messaging::LeaderChannelResolution::Unbound(reason) => {
+            let pane_id = string_field(receiver, "pane_id");
             let mut err = leader_not_attached_third_party(
                 target_workspace,
                 team,
-                Some(pane_id),
+                pane_id,
                 session,
                 window,
                 socket,
             );
-            if stale_pane_seen {
-                err.log = format!("{} stale_tuple_mismatch=true", err.log);
-            }
+            err.log = format!("{} channel_unbound={reason:?}", err.log);
             err.candidates =
                 leader_advisory_candidates(state, team, transport, "state_recorded_socket");
             Err(err)
         }
-        _ => Err(name_ambiguous(
-            "multiple live panes matched leader_receiver pane id",
-            matches
-                .into_iter()
-                .map(|pane| {
-                    json!({
-                        "name": format!("{team}/leader"),
-                        "workspace": target_workspace.display().to_string(),
-                        "team_key": team,
-                        "pane_id": pane.pane_id.as_str(),
-                        "session": pane.session.as_str(),
-                        "window": pane.window_name.as_ref().map(|w| w.as_str()),
-                    })
-                })
-                .collect(),
-        )),
+        crate::messaging::LeaderChannelResolution::ProbeFailed(error) => {
+            let mut err = leader_not_attached_third_party(
+                target_workspace,
+                team,
+                string_field(receiver, "pane_id"),
+                session,
+                window,
+                socket,
+            );
+            err.log = format!("{} channel_probe_failed={error}", err.log);
+            Err(err)
+        }
     }
 }
 

package/crates/team-agent/src/cli/spec.rs

@@ -55,6 +55,7 @@ pub(crate) enum DispatchKind {
     StopAgent,
     ResetAgent,
     AddAgent,
+    CloneAgent,
     ForkAgent,
     RemoveAgent,
     StuckList,
@@ -98,6 +99,7 @@ pub(crate) const ALL_DISPATCH_KINDS: &[DispatchKind] = &[
     DispatchKind::StopAgent,
     DispatchKind::ResetAgent,
     DispatchKind::AddAgent,
+    DispatchKind::CloneAgent,
     DispatchKind::ForkAgent,
     DispatchKind::RemoveAgent,
     DispatchKind::StuckList,
@@ -183,6 +185,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "attach-app-server-leader", tier: CommandTier::Guided, category: CommandCategory::GuidedRecovery, kind: CommandKind::Dispatch(DispatchKind::AttachAppServerLeader), summary: "bind an app-server leader receiver", usage: "usage: team-agent attach-app-server-leader [--workspace WORKSPACE] [--team TEAM] --socket unix:///path.sock --thread-id THREAD_ID [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "remove-agent", tier: CommandTier::Secondary, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::RemoveAgent), summary: "remove a worker", usage: "usage: team-agent remove-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--from-spec] [--confirm] [--force] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "fork-agent", tier: CommandTier::Secondary, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::ForkAgent), summary: "fork a worker", usage: "usage: team-agent fork-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
+    CommandSpec { name: "clone-agent", tier: CommandTier::Secondary, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::CloneAgent), summary: "clone a worker role into a fresh session", usage: "usage: team-agent clone-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "allow-peer-talk", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::AllowPeerTalk), summary: "allow direct worker peer talk", usage: "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "capability/config surface" }) },
     CommandSpec { name: "approvals", tier: CommandTier::Secondary, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Approvals), summary: "inspect provider approval state", usage: "usage: team-agent approvals [AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "approval diagnostics" }) },
     CommandSpec { name: "profile", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::Profile), summary: "manage provider profiles", usage: "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "provider/profile setup" }) },

package/crates/team-agent/src/cli/tests/main_preserved.rs

@@ -400,6 +400,7 @@ fn ux_wait_ready_does_not_report_ready_true_without_ready_runtime_state() {
     crate::state::persist::save_runtime_state(
         &ws,
         &json!({
+            "active_team_key": "wait-ready",
             "agents": {"w1": {"status": "starting"}},
             "tasks": [{"id": "t1", "assignee": "w1", "status": "pending"}],
             "leader_receiver": {"status": "attached"},

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

@@ -514,6 +514,17 @@ pub struct ForkAgentArgs {
     pub json: bool,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CloneAgentArgs {
+    pub source_agent: String,
+    pub workspace: PathBuf,
+    pub team: Option<String>,
+    pub as_agent: String,
+    pub label: Option<String>,
+    pub no_display: bool,
+    pub json: bool,
+}
+
 /// `remove-agent`(`parser.py:414`)。`--from-spec` 须配 `--confirm`。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RemoveAgentArgs {

package/crates/team-agent/src/diagnose/orphans.rs

@@ -48,6 +48,14 @@ impl OrphanScanScope {
             canonical_current_workspace: canonicalize_workspace(workspace),
         }
     }
+
+    fn workspace(&self) -> &Path {
+        match self {
+            Self::CurrentWorkspace {
+                canonical_current_workspace,
+            } => canonical_current_workspace,
+        }
+    }
 }
 
 fn canonicalize_workspace(workspace: &Path) -> PathBuf {
@@ -262,7 +270,7 @@ fn cleanup_report(report: ScanReport, scope: &OrphanScanScope) -> CleanupReport
             }
             continue;
         }
-        if kill_tmux_session(orphan) {
+        if kill_tmux_session(orphan, scope.workspace()) {
             killed.push(orphan_value(orphan, "killed"));
         } else {
             failed.push(orphan_value(orphan, "failed"));
@@ -790,14 +798,27 @@ fn orphan_value(orphan: &OrphanRecord, action: &str) -> Value {
     value
 }
 
-fn kill_tmux_session(orphan: &OrphanRecord) -> bool {
+fn kill_tmux_session(orphan: &OrphanRecord, audit_workspace: &Path) -> bool {
     let (Some(socket), Some(session)) = (&orphan.tmux_socket, &orphan.session) else {
         return false;
     };
     // Phase 1d Batch 6: factory tmux-socket-name helper. Explicit
     // tmux-only kill; conpty shim orphans are NOT routed here (design
     // §Batch 6).
-    crate::transport_factory::tmux_socket_name_transport(socket)
+    let transport = crate::transport_factory::tmux_socket_name_transport(socket);
+    let targets = vec![session.clone()];
+    if crate::kill_audit::pre_kill_audit(
+        &crate::event_log::EventLog::new(audit_workspace),
+        &transport,
+        "diagnose.orphans.tmux_session",
+        crate::kill_audit::KILL_SESSION,
+        &targets,
+    )
+    .is_err()
+    {
+        return false;
+    }
+    transport
         .kill_session(&SessionName::new(session.clone()))
         .is_ok()
 }

package/crates/team-agent/src/kill_audit.rs

@@ -0,0 +1,67 @@
+//! Durable, fail-closed observation immediately before destructive transport calls.
+
+use std::path::Path;
+
+use serde_json::json;
+
+use crate::event_log::{EventLog, EventLogError};
+use crate::transport::{BackendKind, Transport};
+
+pub(crate) const KILL_SERVER: &str = "kill-server";
+pub(crate) const KILL_SESSION: &str = "kill-session";
+
+pub(crate) fn pre_kill_audit(
+    event_log: &EventLog,
+    transport: &dyn Transport,
+    caller: &str,
+    action: &str,
+    targets: &[String],
+) -> Result<(), EventLogError> {
+    let endpoint = transport.tmux_endpoint();
+    let argv = destructive_argv(transport.kind(), endpoint.as_deref(), action, targets);
+    event_log.write(
+        "transport.pre_kill_audit",
+        json!({
+            "phase": "pre_call",
+            "caller": caller,
+            "caller_pid": std::process::id(),
+            "action": action,
+            "argv": argv,
+            "endpoint": endpoint,
+            "targets": targets,
+        }),
+    )?;
+    Ok(())
+}
+
+fn destructive_argv(
+    kind: BackendKind,
+    endpoint: Option<&str>,
+    action: &str,
+    targets: &[String],
+) -> Vec<String> {
+    let mut argv = if kind == BackendKind::Tmux {
+        let mut argv = vec!["tmux".to_string()];
+        if let Some(endpoint) = endpoint.filter(|endpoint| !endpoint.is_empty()) {
+            if endpoint != "default" {
+                argv.push(if Path::new(endpoint).is_absolute() {
+                    "-S".to_string()
+                } else {
+                    "-L".to_string()
+                });
+                argv.push(endpoint.to_string());
+            }
+        }
+        argv
+    } else {
+        vec![format!("{kind:?}").to_ascii_lowercase()]
+    };
+    argv.push(action.to_string());
+    if action == KILL_SESSION {
+        for target in targets {
+            argv.push("-t".to_string());
+            argv.push(target.clone());
+        }
+    }
+    argv
+}