@team-agent/installer 0.5.60 → 0.5.61

package/crates/team-agent/src/model/pane_authority_refusal.rs

@@ -0,0 +1,358 @@
+//! Shared typed catalog for ambient tmux pane authority refusals.
+//!
+//! This module owns identities and payload shape only. Launchers and CLI
+//! presenters remain responsible for collecting facts and rendering them.
+
+use std::path::PathBuf;
+
+pub const REASON_FIELD: &str = "reason";
+pub const AVAILABILITY_FIELD: &str = "availability";
+pub const CAUSE_FIELD: &str = "cause";
+pub const ACTION_REQUIRED_FIELD: &str = "action_required";
+pub const HINT_ACTION_FIELD: &str = "hint_action";
+pub const ACTION_FIELD: &str = "action";
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityRefusalField {
+    RequestedWorkspace,
+    ObservedPaneId,
+    ObservedPaneWorkspace,
+    Endpoint,
+    CallerControllingTty,
+    ObservedPaneTty,
+}
+
+impl PaneAuthorityRefusalField {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::RequestedWorkspace => "requested_workspace",
+            Self::ObservedPaneId => "observed_pane_id",
+            Self::ObservedPaneWorkspace => "observed_pane_workspace",
+            Self::Endpoint => "endpoint",
+            Self::CallerControllingTty => "caller_controlling_tty",
+            Self::ObservedPaneTty => "observed_pane_tty",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityRefusalReason {
+    AmbientTmuxEndpointUnavailable,
+    AmbientPaneIdUnavailable,
+    AmbientPaneWorkspaceUnavailable,
+    CallerControllingTtyUnavailable,
+    ObservedPaneTtyUnavailable,
+    PaneTtyMismatch,
+    PaneWorkspaceMismatch,
+}
+
+impl PaneAuthorityRefusalReason {
+    pub const ALL: [Self; 7] = [
+        Self::AmbientTmuxEndpointUnavailable,
+        Self::AmbientPaneIdUnavailable,
+        Self::AmbientPaneWorkspaceUnavailable,
+        Self::CallerControllingTtyUnavailable,
+        Self::ObservedPaneTtyUnavailable,
+        Self::PaneTtyMismatch,
+        Self::PaneWorkspaceMismatch,
+    ];
+
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::AmbientTmuxEndpointUnavailable => "AmbientTmuxEndpointUnavailable",
+            Self::AmbientPaneIdUnavailable => "AmbientPaneIdUnavailable",
+            Self::AmbientPaneWorkspaceUnavailable => "AmbientPaneWorkspaceUnavailable",
+            Self::CallerControllingTtyUnavailable => "CallerControllingTtyUnavailable",
+            Self::ObservedPaneTtyUnavailable => "ObservedPaneTtyUnavailable",
+            Self::PaneTtyMismatch => "PaneTtyMismatch",
+            Self::PaneWorkspaceMismatch => "PaneWorkspaceMismatch",
+        }
+    }
+
+    pub const fn required_fact_fields(self) -> &'static [PaneAuthorityRefusalField] {
+        use PaneAuthorityRefusalField::{
+            CallerControllingTty, Endpoint, ObservedPaneId, ObservedPaneTty, ObservedPaneWorkspace,
+            RequestedWorkspace,
+        };
+
+        match self {
+            Self::AmbientTmuxEndpointUnavailable => &[RequestedWorkspace, Endpoint],
+            Self::AmbientPaneIdUnavailable => &[RequestedWorkspace, ObservedPaneId, Endpoint],
+            Self::AmbientPaneWorkspaceUnavailable => &[
+                RequestedWorkspace,
+                ObservedPaneId,
+                ObservedPaneWorkspace,
+                Endpoint,
+            ],
+            Self::CallerControllingTtyUnavailable => &[
+                RequestedWorkspace,
+                ObservedPaneId,
+                Endpoint,
+                CallerControllingTty,
+            ],
+            Self::ObservedPaneTtyUnavailable => &[
+                RequestedWorkspace,
+                ObservedPaneId,
+                Endpoint,
+                ObservedPaneTty,
+            ],
+            Self::PaneTtyMismatch => &[
+                RequestedWorkspace,
+                ObservedPaneId,
+                Endpoint,
+                CallerControllingTty,
+                ObservedPaneTty,
+            ],
+            Self::PaneWorkspaceMismatch => &[
+                RequestedWorkspace,
+                ObservedPaneId,
+                ObservedPaneWorkspace,
+                Endpoint,
+            ],
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityFactAvailability {
+    Unavailable,
+}
+
+impl PaneAuthorityFactAvailability {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Unavailable => "unavailable",
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct UnavailablePaneAuthorityFact<C> {
+    pub cause: C,
+}
+
+impl<C> UnavailablePaneAuthorityFact<C> {
+    pub const fn new(cause: C) -> Self {
+        Self { cause }
+    }
+
+    pub const fn availability(&self) -> PaneAuthorityFactAvailability {
+        PaneAuthorityFactAvailability::Unavailable
+    }
+}
+
+macro_rules! unavailable_causes {
+    ($name:ident { $($variant:ident => $wire:literal),+ $(,)? }) => {
+        #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+        pub enum $name {
+            $($variant),+
+        }
+
+        impl $name {
+            pub const fn as_str(self) -> &'static str {
+                match self {
+                    $(Self::$variant => $wire),+
+                }
+            }
+        }
+    };
+}
+
+unavailable_causes!(AmbientTmuxEndpointUnavailableCause {
+    TmuxValueNotUnicode => "tmux_value_not_unicode",
+    TmuxTupleFieldCountInvalid => "tmux_tuple_field_count_invalid",
+    EndpointMissing => "endpoint_missing",
+    EndpointNotAbsolute => "endpoint_not_absolute",
+    ServerPidInvalid => "server_pid_invalid",
+    SessionIndexInvalid => "session_index_invalid",
+});
+
+unavailable_causes!(AmbientPaneIdUnavailableCause {
+    EnvironmentValueMissing => "environment_value_missing",
+    EnvironmentValueEmpty => "environment_value_empty",
+    EnvironmentValueNotUnicode => "environment_value_not_unicode",
+});
+
+unavailable_causes!(AmbientPaneWorkspaceUnavailableCause {
+    PaneQueryFailed => "pane_query_failed",
+    PaneNotFound => "pane_not_found",
+    CurrentPathMissing => "current_path_missing",
+});
+
+unavailable_causes!(CallerControllingTtyUnavailableCause {
+    NoControllingTty => "no_controlling_tty",
+    DeviceIdentityUnresolvable => "device_identity_unresolvable",
+    PlatformUnsupported => "platform_unsupported",
+});
+
+unavailable_causes!(ObservedPaneTtyUnavailableCause {
+    PaneTtyMissing => "pane_tty_missing",
+    PaneTtyUnresolvable => "pane_tty_unresolvable",
+    PaneTtyNotCharacterDevice => "pane_tty_not_character_device",
+});
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AmbientTmuxEndpointUnavailableFacts {
+    pub requested_workspace: PathBuf,
+    pub endpoint: UnavailablePaneAuthorityFact<AmbientTmuxEndpointUnavailableCause>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AmbientPaneIdUnavailableFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: UnavailablePaneAuthorityFact<AmbientPaneIdUnavailableCause>,
+    pub endpoint: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AmbientPaneWorkspaceUnavailableFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: String,
+    pub observed_pane_workspace: UnavailablePaneAuthorityFact<AmbientPaneWorkspaceUnavailableCause>,
+    pub endpoint: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct CallerControllingTtyUnavailableFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: String,
+    pub endpoint: String,
+    pub caller_controlling_tty: UnavailablePaneAuthorityFact<CallerControllingTtyUnavailableCause>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ObservedPaneTtyUnavailableFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: String,
+    pub endpoint: String,
+    pub observed_pane_tty: UnavailablePaneAuthorityFact<ObservedPaneTtyUnavailableCause>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PaneTtyMismatchFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: String,
+    pub endpoint: String,
+    pub caller_controlling_tty: u64,
+    pub observed_pane_tty: u64,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PaneWorkspaceMismatchFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: String,
+    pub observed_pane_workspace: PathBuf,
+    pub endpoint: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityRefusalFacts {
+    AmbientTmuxEndpointUnavailable(AmbientTmuxEndpointUnavailableFacts),
+    AmbientPaneIdUnavailable(AmbientPaneIdUnavailableFacts),
+    AmbientPaneWorkspaceUnavailable(AmbientPaneWorkspaceUnavailableFacts),
+    CallerControllingTtyUnavailable(CallerControllingTtyUnavailableFacts),
+    ObservedPaneTtyUnavailable(ObservedPaneTtyUnavailableFacts),
+    PaneTtyMismatch(PaneTtyMismatchFacts),
+    PaneWorkspaceMismatch(PaneWorkspaceMismatchFacts),
+}
+
+impl PaneAuthorityRefusalFacts {
+    pub const fn reason(&self) -> PaneAuthorityRefusalReason {
+        match self {
+            Self::AmbientTmuxEndpointUnavailable(_) => {
+                PaneAuthorityRefusalReason::AmbientTmuxEndpointUnavailable
+            }
+            Self::AmbientPaneIdUnavailable(_) => {
+                PaneAuthorityRefusalReason::AmbientPaneIdUnavailable
+            }
+            Self::AmbientPaneWorkspaceUnavailable(_) => {
+                PaneAuthorityRefusalReason::AmbientPaneWorkspaceUnavailable
+            }
+            Self::CallerControllingTtyUnavailable(_) => {
+                PaneAuthorityRefusalReason::CallerControllingTtyUnavailable
+            }
+            Self::ObservedPaneTtyUnavailable(_) => {
+                PaneAuthorityRefusalReason::ObservedPaneTtyUnavailable
+            }
+            Self::PaneTtyMismatch(_) => PaneAuthorityRefusalReason::PaneTtyMismatch,
+            Self::PaneWorkspaceMismatch(_) => PaneAuthorityRefusalReason::PaneWorkspaceMismatch,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityRecoveryHint {
+    AttachLeader,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityRecoveryAction {
+    OpenTerminalOutsideCurrentTmuxPaneOrAttachFromMatchingPane,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct PaneAuthorityRecovery {
+    pub action_required: bool,
+    pub hint_action: PaneAuthorityRecoveryHint,
+    pub action: PaneAuthorityRecoveryAction,
+}
+
+impl PaneAuthorityRecovery {
+    pub const REQUIRED: Self = Self {
+        action_required: true,
+        hint_action: PaneAuthorityRecoveryHint::AttachLeader,
+        action:
+            PaneAuthorityRecoveryAction::OpenTerminalOutsideCurrentTmuxPaneOrAttachFromMatchingPane,
+    };
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PaneAuthorityRefusal {
+    pub facts: PaneAuthorityRefusalFacts,
+    pub recovery: PaneAuthorityRecovery,
+}
+
+impl PaneAuthorityRefusal {
+    pub const fn new(facts: PaneAuthorityRefusalFacts) -> Self {
+        Self {
+            facts,
+            recovery: PaneAuthorityRecovery::REQUIRED,
+        }
+    }
+
+    pub const fn reason(&self) -> PaneAuthorityRefusalReason {
+        self.facts.reason()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{PaneAuthorityRefusalField as Field, PaneAuthorityRefusalReason as Reason};
+
+    #[test]
+    fn reason_catalog_is_closed_and_mismatch_requires_all_four_workspace_facts() {
+        assert_eq!(Reason::ALL.len(), 7);
+        assert_eq!(
+            Reason::PaneWorkspaceMismatch.required_fact_fields(),
+            &[
+                Field::RequestedWorkspace,
+                Field::ObservedPaneId,
+                Field::ObservedPaneWorkspace,
+                Field::Endpoint,
+            ]
+        );
+    }
+
+    #[test]
+    fn unavailable_reasons_require_the_fact_they_could_not_observe() {
+        assert!(Reason::AmbientTmuxEndpointUnavailable
+            .required_fact_fields()
+            .contains(&Field::Endpoint));
+        assert!(Reason::AmbientPaneIdUnavailable
+            .required_fact_fields()
+            .contains(&Field::ObservedPaneId));
+        assert!(Reason::AmbientPaneWorkspaceUnavailable
+            .required_fact_fields()
+            .contains(&Field::ObservedPaneWorkspace));
+    }
+}

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

@@ -400,6 +400,7 @@ fn check_agent(agent: &Yaml, path: &str, errors: &mut Vec<String>) {
         "preferred_for",
         "avoid_for",
         "output_contract",
+        "communication_mode",
         "paused",
         "auth_mode",
         "profile",
@@ -412,6 +413,21 @@ fn check_agent(agent: &Yaml, path: &str, errors: &mut Vec<String>) {
     if !agent.is_map() {
         return;
     }
+    if let Some(value) = agent.get("communication_mode") {
+        match value.as_str() {
+            Some(raw) if crate::communication_mode::CommunicationMode::parse(raw).is_none() => {
+                errors.push(format!(
+                    "{path}/communication_mode: unknown communication_mode '{raw}'"
+                ));
+            }
+            None => {
+                errors.push(format!(
+                    "{path}/communication_mode: unknown communication_mode"
+                ));
+            }
+            Some(_) => {}
+        }
+    }
     // 0.4.x provider effort MVP step 3: effort syntactic + semantic validation.
     if let Some(raw) = agent.get("effort").and_then(Yaml::as_str) {
         match crate::model::enums::ProviderEffort::parse(raw) {

package/crates/team-agent/src/provider/session/capture.rs

@@ -284,12 +284,22 @@ where
                 .zip(candidate.captured.session_id.as_ref())
                 .is_some_and(|(expected, captured)| expected.as_str() != captured.as_str());
             if mismatch {
-                report.ambiguous.push(AmbiguousSessionCapture {
-                    agent_id: item.agent_id.clone(),
-                    spawn_cwd: item.context.spawn_cwd.to_string_lossy().to_string(),
-                });
+                let ambiguity_changed = agent_obj
+                    .get("attribution_ambiguous")
+                    .and_then(Value::as_bool)
+                    != Some(true);
+                if !finalize_ambiguous || ambiguity_changed {
+                    report.ambiguous.push(AmbiguousSessionCapture {
+                        agent_id: item.agent_id.clone(),
+                        spawn_cwd: item.context.spawn_cwd.to_string_lossy().to_string(),
+                    });
+                }
                 if finalize_ambiguous {
-                    agent_obj.insert("attribution_ambiguous".to_string(), serde_json::json!(true));
+                    if ambiguity_changed {
+                        agent_obj
+                            .insert("attribution_ambiguous".to_string(), serde_json::json!(true));
+                        report.changed = true;
+                    }
                     // 0.4.6 tuple-atomic contract (audit:93): do NOT write
                     // `captured_at` for ambiguity diagnostics. `captured_at`
                     // is part of the authoritative tuple and may only be
@@ -299,7 +309,6 @@ where
                     // "looks captured" rows. Ambiguity diagnostics live in
                     // the `attribution_ambiguous` flag + events; persist
                     // event log for the timestamp.
-                    report.changed = true;
                 }
                 continue;
             }
@@ -317,19 +326,29 @@ where
             continue;
         }
         if ambiguous_ids.contains(&item.agent_id) {
-            report.ambiguous.push(AmbiguousSessionCapture {
-                agent_id: item.agent_id.clone(),
-                spawn_cwd: item.context.spawn_cwd.to_string_lossy().to_string(),
-            });
+            let ambiguity_changed = agent_obj
+                .get("attribution_ambiguous")
+                .and_then(Value::as_bool)
+                != Some(true)
+                || agent_obj.get("capture_state").and_then(Value::as_str)
+                    != Some("attribution_ambiguous");
+            if !finalize_ambiguous || ambiguity_changed {
+                report.ambiguous.push(AmbiguousSessionCapture {
+                    agent_id: item.agent_id.clone(),
+                    spawn_cwd: item.context.spawn_cwd.to_string_lossy().to_string(),
+                });
+            }
             if finalize_ambiguous {
-                agent_obj.insert("attribution_ambiguous".to_string(), serde_json::json!(true));
-                agent_obj.insert(
-                    "capture_state".to_string(),
-                    serde_json::json!("attribution_ambiguous"),
-                );
-                // 0.4.6 tuple-atomic contract: see comment above. Removed
-                // `captured_at` ambiguity write.
-                report.changed = true;
+                if ambiguity_changed {
+                    agent_obj.insert("attribution_ambiguous".to_string(), serde_json::json!(true));
+                    agent_obj.insert(
+                        "capture_state".to_string(),
+                        serde_json::json!("attribution_ambiguous"),
+                    );
+                    // 0.4.6 tuple-atomic contract: see comment above. Removed
+                    // `captured_at` ambiguity write.
+                    report.changed = true;
+                }
             }
             continue;
         }
@@ -666,6 +685,9 @@ fn pending_session_capture<F>(
 where
     F: FnMut(Provider) -> Box<dyn ProviderAdapter>,
 {
+    if agent.get("capture_state").and_then(Value::as_str) == Some("attribution_ambiguous") {
+        return None;
+    }
     let provider = incomplete_resumable_provider(agent, adapter_for)?;
     let spawn_cwd = agent
         .get("spawn_cwd")

package/crates/team-agent/src/provider/session_scan/claude.rs

@@ -1,6 +1,7 @@
 use std::path::{Path, PathBuf};
 
-use crate::provider::types::SessionId;
+use crate::provider::helpers::find_session_id;
+use crate::provider::types::{CaptureVia, CapturedSession, Confidence, RolloutPath, SessionId};
 use crate::provider::Provider;
 
 use super::{CaptureSessionContext, CapturedSessionCandidate};
@@ -14,7 +15,7 @@ pub(crate) fn projects_dir_for_cwd(home: &Path, spawn_cwd: &Path) -> Option<Path
     Some(home.join(".claude").join("projects").join(encoded))
 }
 
-fn encode_projects_dir(path: &str) -> String {
+pub(super) fn encode_projects_dir(path: &str) -> String {
     let mut out = String::with_capacity(path.len());
     for c in path.chars() {
         if c.is_ascii_alphanumeric() {
@@ -26,6 +27,65 @@ fn encode_projects_dir(path: &str) -> String {
     out
 }
 
+pub(super) fn scan_expected_session(
+    context: &CaptureSessionContext,
+) -> Vec<CapturedSessionCandidate> {
+    let Some(expected) = context.expected_session_id.as_ref() else {
+        return Vec::new();
+    };
+    let Some(projects_root) = context.provider_projects_root.clone().or_else(|| {
+        std::env::var_os("HOME")
+            .map(PathBuf::from)
+            .map(|home| home.join(".claude").join("projects"))
+    }) else {
+        return Vec::new();
+    };
+    let canonical =
+        std::fs::canonicalize(&context.spawn_cwd).unwrap_or_else(|_| context.spawn_cwd.clone());
+    let encoded = encode_projects_dir(&canonical.to_string_lossy());
+    if encoded.is_empty() {
+        return Vec::new();
+    }
+    let path = projects_root
+        .join(encoded)
+        .join(format!("{}.jsonl", expected.as_str()));
+    let Ok(text) = super::common::read_head_text(&path, super::common::CAPTURE_HEAD_BYTES) else {
+        return Vec::new();
+    };
+    let records = super::common::parse_session_records(&text);
+    let session_matches = records
+        .iter()
+        .find_map(find_session_id)
+        .is_some_and(|session_id| session_id == expected.as_str());
+    let has_lifecycle_record = records.iter().any(|record| {
+        matches!(
+            record.get("type").and_then(serde_json::Value::as_str),
+            Some("user" | "assistant")
+        )
+    });
+    if !session_matches
+        || !has_lifecycle_record
+        || records_have_leader_marker(&records)
+        || !records.iter().any(has_cwd_field)
+    {
+        return Vec::new();
+    }
+    let embedded_agent_id = super::common::embedded_team_agent_worker_id_from_text(&text);
+    let positive_agent_id_match = embedded_agent_id.as_deref() == Some(context.agent_id.as_str());
+    vec![CapturedSessionCandidate {
+        captured: CapturedSession {
+            session_id: Some(expected.clone()),
+            rollout_path: Some(RolloutPath::new(path)),
+            captured_via: CaptureVia::FsWatch,
+            attribution_confidence: Confidence::High,
+            spawn_cwd: context.spawn_cwd.clone(),
+        },
+        embedded_agent_id,
+        positive_agent_id_match,
+        agent_path_match: false,
+    }]
+}
+
 pub(crate) fn rollout_path_has_leader_marker(provider: Provider, rollout_path: &Path) -> bool {
     if !matches!(provider, Provider::Claude | Provider::ClaudeCode) {
         return false;
@@ -112,6 +172,7 @@ mod tests {
         std::fs::create_dir_all(dir).unwrap();
         let path = dir.join(format!("{uuid}.jsonl"));
         let line = serde_json::json!({
+            "type": "user",
             "sessionId": uuid,
             "cwd": cwd.to_string_lossy(),
         });
@@ -119,6 +180,11 @@ mod tests {
         path
     }
 
+    fn expected_transcript_dir(projects_root: &Path, cwd: &Path) -> PathBuf {
+        let canonical = std::fs::canonicalize(cwd).unwrap_or_else(|_| cwd.to_path_buf());
+        projects_root.join(encode_projects_dir(&canonical.to_string_lossy()))
+    }
+
     #[test]
     fn claude_leader_marker_in_custom_title_is_detected() {
         let records = vec![serde_json::json!({
@@ -205,7 +271,11 @@ mod tests {
         std::fs::create_dir_all(&cwd).unwrap();
         let proj = base.join("projects");
         write_transcript(&proj, "11111111-1111-4111-8111-111111111111", &cwd);
-        write_transcript(&proj, "22222222-2222-4222-8222-222222222222", &cwd);
+        let expected = write_transcript(
+            &expected_transcript_dir(&proj, &cwd),
+            "22222222-2222-4222-8222-222222222222",
+            &cwd,
+        );
         let ctx = CaptureSessionContext {
             agent_id: "w1".to_string(),
             spawn_cwd: cwd.clone(),
@@ -221,6 +291,10 @@ mod tests {
             out[0].captured.session_id.as_ref().unwrap().as_str(),
             "22222222-2222-4222-8222-222222222222"
         );
+        assert_eq!(
+            out[0].captured.rollout_path.as_ref().unwrap().as_path(),
+            expected
+        );
         let _ = std::fs::remove_dir_all(&base);
     }
 
@@ -284,6 +358,21 @@ mod tests {
         let proj = base.join("projects");
         let leader = write_transcript(&proj, "11111111-1111-4111-8111-111111111111", &cwd);
         let stale = write_transcript(&proj, "22222222-2222-4222-8222-222222222222", &cwd);
+        let addressed =
+            expected_transcript_dir(&proj, &cwd).join("99999999-9999-4999-8999-999999999999.jsonl");
+        std::fs::create_dir_all(addressed.parent().unwrap()).unwrap();
+        std::fs::write(
+            &addressed,
+            format!(
+                "{}\n",
+                serde_json::json!({
+                    "type": "user",
+                    "sessionId": "22222222-2222-4222-8222-222222222222",
+                    "cwd": cwd.to_string_lossy(),
+                })
+            ),
+        )
+        .unwrap();
         let _ = (leader, stale);
         let ctx = CaptureSessionContext {
             agent_id: "claude-worker".to_string(),