@team-agent/installer 0.5.56 → 0.5.58

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

@@ -172,6 +172,110 @@ pub(super) fn finalize_fork_state(input: ForkFinalizeInput<'_>) -> Result<(), Li
         .map_err(|error| LifecycleError::StatePersist(error.to_string()))
 }
 
+pub(super) struct ForkPendingFinalizeInput<'a> {
+    pub workspace: &'a Path,
+    pub team_key: &'a str,
+    pub source_agent_id: &'a AgentId,
+    pub agent_id: &'a AgentId,
+    pub spec_agent: &'a Value,
+    pub safety: &'a DangerousApproval,
+    pub plan: &'a crate::provider::CommandPlan,
+    pub profile_launch: &'a crate::provider::ProviderProfileLaunch,
+    pub spawn: &'a crate::transport::SpawnResult,
+    pub profile_dir: &'a Path,
+    pub dynamic_role_file: &'a Path,
+    pub pending: &'a crate::provider::session::PendingContextFork,
+    pub spawn_epoch: u64,
+}
+
+pub(super) fn finalize_pending_fork_state(
+    input: ForkPendingFinalizeInput<'_>,
+) -> Result<(), LifecycleError> {
+    let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: input.workspace,
+        operation: "fork-agent-pending",
+        team: Some(input.team_key),
+        agent_id: Some(input.agent_id),
+    })?;
+    let mut next_state = crate::state::selector::resolve_active_team(
+        input.workspace,
+        Some(input.team_key),
+        crate::state::selector::SelectorMode::RequireSpec,
+    )
+    .map_err(|error| LifecycleError::TeamSelect(error.to_string()))?
+    .state;
+    upsert_pending_forked_agent_state(
+        &mut next_state,
+        input.source_agent_id,
+        input.agent_id,
+        input.spec_agent,
+        input.safety,
+        input.plan,
+        input.profile_launch,
+        input.spawn,
+        Some(input.profile_dir),
+        input.dynamic_role_file,
+        input.pending,
+        input.spawn_epoch,
+    )?;
+    maybe_fail_fork_after_spawn("save_runtime_state")?;
+    crate::state::repository::StateRepository::new(input.workspace)
+        .save(
+            crate::state::repository::StateWriteIntent::ForkAgent {
+                team_key: input.team_key,
+                agent_id: input.agent_id.as_str(),
+            },
+            &next_state,
+        )
+        .map_err(|error| LifecycleError::StatePersist(error.to_string()))
+}
+
+pub(crate) fn finalize_pending_fork_capture(
+    agent: &mut serde_json::Map<String, serde_json::Value>,
+    captured: &crate::provider::CapturedSession,
+) -> bool {
+    let Some(session_id) = captured.session_id.as_ref() else {
+        return false;
+    };
+    let Some(rollout_path) = captured.rollout_path.as_ref() else {
+        return false;
+    };
+    if agent
+        .get("fork_source_session_id")
+        .and_then(serde_json::Value::as_str)
+        == Some(session_id.as_str())
+    {
+        return false;
+    }
+    agent.insert(
+        "session_id".to_string(),
+        serde_json::json!(session_id.as_str()),
+    );
+    agent.insert(
+        "rollout_path".to_string(),
+        serde_json::json!(rollout_path.as_path().to_string_lossy()),
+    );
+    agent.insert(
+        "captured_at".to_string(),
+        serde_json::json!(chrono::Utc::now().to_rfc3339()),
+    );
+    agent.insert(
+        "captured_via".to_string(),
+        serde_json::to_value(captured.captured_via).unwrap_or(serde_json::Value::Null),
+    );
+    agent.insert(
+        "attribution_confidence".to_string(),
+        serde_json::to_value(captured.attribution_confidence).unwrap_or(serde_json::Value::Null),
+    );
+    agent.remove("_pending_session_id");
+    agent.remove("attribution_ambiguous");
+    agent.remove("fork_source_session_id");
+    agent.remove("pending_target_agent");
+    agent.remove("pending_grace_secs");
+    agent.insert("capture_state".to_string(), serde_json::json!("captured"));
+    true
+}
+
 pub(super) fn verify_fork_registration(
     workspace: &Path,
     team_key: &str,

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

@@ -0,0 +1,109 @@
+use super::*;
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn upsert_pending_forked_agent_state(
+    state: &mut serde_json::Value,
+    source_agent_id: &AgentId,
+    as_agent_id: &AgentId,
+    spec_agent: &Value,
+    safety: &DangerousApproval,
+    plan: &crate::provider::CommandPlan,
+    profile_launch: &crate::provider::ProviderProfileLaunch,
+    spawn: &crate::transport::SpawnResult,
+    profile_dir: Option<&Path>,
+    dynamic_role_file: &Path,
+    pending: &crate::provider::session::PendingContextFork,
+    spawn_epoch: u64,
+) -> Result<(), LifecycleError> {
+    let root = state.as_object_mut().ok_or_else(|| {
+        LifecycleError::StatePersist("runtime state root is not an object".to_string())
+    })?;
+    let agents = root
+        .entry("agents".to_string())
+        .or_insert_with(|| serde_json::json!({}))
+        .as_object_mut()
+        .ok_or_else(|| {
+            LifecycleError::StatePersist("runtime state agents is not an object".to_string())
+        })?;
+    let mut entry = serde_json::Map::new();
+    entry.insert("status".to_string(), serde_json::json!("running"));
+    entry.insert(
+        "capture_state".to_string(),
+        serde_json::json!("pending_context_fork"),
+    );
+    entry.insert(
+        "agent_id".to_string(),
+        serde_json::json!(as_agent_id.as_str()),
+    );
+    entry.insert(
+        "window".to_string(),
+        serde_json::json!(as_agent_id.as_str()),
+    );
+    entry.insert(
+        "forked_from".to_string(),
+        serde_json::json!(source_agent_id.as_str()),
+    );
+    entry.insert(
+        "fork_source_session_id".to_string(),
+        serde_json::json!(pending.source_session_id.as_str()),
+    );
+    entry.insert(
+        "pending_target_agent".to_string(),
+        serde_json::json!(pending.target_agent),
+    );
+    entry.insert(
+        "dynamic_role_file".to_string(),
+        serde_json::json!(dynamic_role_file.to_string_lossy().to_string()),
+    );
+    entry.insert(
+        "role_source_ownership".to_string(),
+        serde_json::json!("managed"),
+    );
+    entry.insert(
+        "spawn_cwd".to_string(),
+        serde_json::json!(pending
+            .scanner_context
+            .spawn_cwd
+            .to_string_lossy()
+            .to_string()),
+    );
+    entry.insert(
+        "pane_id".to_string(),
+        serde_json::json!(spawn.pane_id.as_str()),
+    );
+    entry.insert(
+        "spawned_at".to_string(),
+        serde_json::json!(pending.spawned_at),
+    );
+    entry.insert("spawn_epoch".to_string(), serde_json::json!(spawn_epoch));
+    if let Some(pid) = spawn.child_pid {
+        entry.insert("pane_pid".to_string(), serde_json::json!(pid));
+    }
+    for key in [
+        "provider",
+        "auth_mode",
+        "model",
+        "profile",
+        "role",
+        "effort",
+    ] {
+        if let Some(value) = spec_agent.get(key) {
+            entry.insert(key.to_string(), yaml_value_to_json(value));
+        }
+    }
+    if spec_agent.get("profile").is_some() {
+        if let Some(profile_dir) = profile_dir {
+            entry.insert(
+                "_profile_dir".to_string(),
+                serde_json::json!(profile_dir.to_string_lossy().to_string()),
+            );
+        }
+    }
+    persist_command_plan_state(&mut entry, plan, profile_launch);
+    persist_effective_approval_policy(&mut entry, safety);
+    agents.insert(
+        as_agent_id.as_str().to_string(),
+        serde_json::Value::Object(entry),
+    );
+    Ok(())
+}

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

@@ -14,6 +14,10 @@ use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest}
 
 use super::*;
 
+#[path = "fork_pending.rs"]
+mod fork_pending;
+pub(super) use fork_pending::upsert_pending_forked_agent_state;
+
 pub(super) fn reserve_forked_agent_state(
     state: &mut serde_json::Value,
     source_agent_id: &AgentId,
@@ -134,6 +138,51 @@ pub(super) fn find_spec_agent<'a>(spec: &'a Value, agent_id: &AgentId) -> Option
     })
 }
 
+pub(super) fn fork_spec_agent<'a>(spec: &'a Value, agent_id: &AgentId) -> Option<&'a Value> {
+    find_spec_agent(spec, agent_id)
+}
+
+pub(super) fn fork_source_tuple(
+    state: &serde_json::Value,
+    source_agent_id: &AgentId,
+) -> Result<(crate::provider::SessionId, PathBuf), LifecycleError> {
+    let source = state
+        .get("agents")
+        .and_then(|agents| agents.get(source_agent_id.as_str()))
+        .ok_or_else(|| {
+            LifecycleError::Provider(format!("unknown worker agent id: {source_agent_id}"))
+        })?;
+    let field = |name: &str| {
+        source
+            .get(name)
+            .and_then(serde_json::Value::as_str)
+            .filter(|value| !value.is_empty())
+    };
+    let (Some(session_id), Some(backing)) = (field("session_id"), field("rollout_path")) else {
+        return Err(LifecycleError::Provider(format!(
+            "cannot fork {source_agent_id}: source session backing is missing or incomplete \
+             (session_id+rollout_path+captured_at+captured_via required)"
+        )));
+    };
+    if field("captured_at").is_none() || field("captured_via").is_none() {
+        return Err(LifecycleError::Provider(format!(
+            "cannot fork {source_agent_id}: source session backing is missing or incomplete \
+             (session_id+rollout_path+captured_at+captured_via required)"
+        )));
+    }
+    let backing = PathBuf::from(backing);
+    if !backing.is_file() {
+        return Err(LifecycleError::Provider(format!(
+            "cannot fork {source_agent_id}: source session backing is not readable: {}",
+            backing.display()
+        )));
+    }
+    Ok((
+        crate::provider::SessionId::new(session_id.to_string()),
+        backing,
+    ))
+}
+
 pub(super) fn append_forked_agent(
     spec: &Value,
     source_agent: &Value,

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

@@ -295,6 +295,7 @@ mod fork_state;
 pub(super) use fork_state::*;
 
 mod fork_finalize;
+pub(crate) use fork_finalize::finalize_pending_fork_capture;
 pub(super) use fork_finalize::*;
 
 mod role_source;

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

@@ -664,6 +664,14 @@ pub struct ForkAgentReport {
     pub new_agent_id: AgentId,
     pub env: AgentActionEnvelope,
     pub session_id: Option<SessionId>,
+    pub backing_state: ForkBackingState,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ForkBackingState {
+    Verified,
+    PendingContextFork,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

package/crates/team-agent/src/mcp_server/lifecycle_tools/agent_ops.rs

@@ -130,6 +130,7 @@ pub(crate) fn fork_agent(
             "state_file": report.env.state_file.to_string_lossy().to_string(),
             "coordinator_started": report.env.coordinator_started,
             "session_id": report.session_id.as_ref().map(|session| session.as_str()),
+            "backing_state": report.backing_state,
         })),
     })
 }

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

@@ -848,35 +848,7 @@ pub fn requeue_worker_target_missing_messages(
     recipient: &str,
     owner_team_id: Option<&str>,
 ) -> Result<Vec<String>, MessagingError> {
-    let conn = crate::db::schema::open_db(store.db_path())?;
-    let now = chrono::Utc::now().to_rfc3339();
-    let mut stmt = conn.prepare(
-        "select message_id from messages
-         where recipient = ?1
-           and status = 'queued_pane_missing'
-           and error = 'tmux_target_missing'
-           and (
-               (?2 is null and owner_team_id is null)
-               or owner_team_id = ?2
-           )
-         order by created_at, message_id",
-    )?;
-    let ids = stmt
-        .query_map(params![recipient, owner_team_id], |row| {
-            row.get::<_, String>(0)
-        })?
-        .collect::<Result<Vec<_>, _>>()?;
-    drop(stmt);
-    for message_id in &ids {
-        conn.execute(
-            "update messages
-             set status = 'accepted',
-                 error = null,
-                 updated_at = ?2
-             where message_id = ?1",
-            params![message_id, now.as_str()],
-        )?;
-    }
+    let ids = store.recover_worker_pane_available(recipient, owner_team_id)?;
     if !ids.is_empty() {
         event_log.write(
             "worker_receiver.blocked_messages_requeued",
@@ -2446,10 +2418,8 @@ fn save_scoped_state(
     state: &serde_json::Value,
     owner_team_id: Option<&str>,
 ) -> Result<(), MessagingError> {
-    let scoped_owner_team_id = owner_team_id
-        .filter(|team| !team.is_empty())
-        .filter(|_| {
-            state
+    let scoped_owner_team_id = owner_team_id.filter(|team| !team.is_empty()).filter(|_| {
+        state
             .get("teams")
             .and_then(serde_json::Value::as_object)
             .is_some_and(|teams| {
@@ -2461,7 +2431,7 @@ fn save_scoped_state(
                     })
                     .is_some_and(|team| teams.contains_key(&team))
             })
-        });
+    });
     crate::state::repository::StateRepository::new(workspace).save(
         crate::state::repository::StateWriteIntent::MessagingDeliveryState {
             owner_team_id: scoped_owner_team_id,
@@ -2480,10 +2450,8 @@ fn save_scoped_state_reapplying_after_conflict<F>(
 where
     F: FnOnce(&mut serde_json::Value),
 {
-    let scoped_owner_team_id = owner_team_id
-        .filter(|team| !team.is_empty())
-        .filter(|_| {
-            state
+    let scoped_owner_team_id = owner_team_id.filter(|team| !team.is_empty()).filter(|_| {
+        state
             .get("teams")
             .and_then(serde_json::Value::as_object)
             .is_some_and(|teams| {
@@ -2495,7 +2463,7 @@ where
                     })
                     .is_some_and(|team| teams.contains_key(&team))
             })
-        });
+    });
     crate::state::repository::StateRepository::new(workspace).save_reapplying(
         crate::state::repository::StateWriteIntent::MessagingDeliveryState {
             owner_team_id: scoped_owner_team_id,

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

@@ -23,6 +23,7 @@ fn stuck_cancel_snapshot_delivered_message_ids_uses_golden_status_set() {
     let m_ack = store
         .create_message(None, "leader", "w1", "ack-me", None, true, Some("teamX"))
         .unwrap();
+    store.mark(&m_ack, "delivered", None).unwrap();
     store.mark(&m_ack, "acknowledged", None).unwrap();
     let m_vis = store
         .create_message(None, "leader", "w1", "vis", None, true, Some("teamX"))

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

@@ -9,6 +9,12 @@ use crate::message_store::{MessageStore, NotificationClaimParams};
 use crate::model::ids::{TaskId, TeamKey};
 use crate::transport::PaneId;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RecoveryIncident {
+    pub incident_id: String,
+    pub occurred_at: String,
+}
+
 use super::{MessagingError, WatcherNotice, RESULT_DELIVERY_MAX_ATTEMPTS};
 
 /// `notify_result_watchers` (`result_delivery.py:38`):匹配 + 去重 + (有界) 投递 result 给 leader
@@ -460,13 +466,31 @@ pub fn requeue_after_claim_leader(
         )?;
     }
     let requeued_blocked =
-        requeue_blocked_leader_messages(&conn, event_log, owner_team_id, claimed_pane_id)?;
+        requeue_blocked_leader_messages(store, event_log, owner_team_id, claimed_pane_id)?;
     if !out.is_empty() || requeued_blocked > 0 {
         let _ = retry_result_deliveries(workspace, event_log)?;
     }
     Ok(out)
 }
 
+pub fn recover_watchers_for_incident(
+    workspace: &Path,
+    store: &MessageStore,
+    event_log: &EventLog,
+    owner_team_id: &TeamKey,
+    claimed_pane_id: &PaneId,
+    incident: &RecoveryIncident,
+) -> Result<Vec<WatcherNotice>, MessagingError> {
+    requeue_after_claim_leader(
+        workspace,
+        store,
+        event_log,
+        owner_team_id,
+        claimed_pane_id,
+        Some(&incident.occurred_at),
+    )
+}
+
 /// 0.5.5 gate054 round-2: attach-leader (and claim-leader) requeue for leader messages
 /// that were refused with `rebind_required` while no leader pane was attached.
 ///
@@ -477,7 +501,7 @@ pub fn requeue_after_claim_leader(
 /// already crossed the transport boundary and is claim-immutable. Any future
 /// retry belongs to a separate typed recovery arm, not attach/claim convergence.
 pub(crate) fn requeue_blocked_leader_messages(
-    conn: &rusqlite::Connection,
+    store: &MessageStore,
     event_log: &EventLog,
     owner_team_id: &TeamKey,
     claimed_pane_id: &PaneId,
@@ -492,19 +516,8 @@ pub(crate) fn requeue_blocked_leader_messages(
     // could not have churned while the leader was unattached.
     // `submitted_pending_acceptance` remains parked and claim-immutable; a
     // future typed recovery arm must own any deliberate retry.
-    let requeued = conn.execute(
-        "update messages
-         set status = 'accepted',
-             error = null,
-             updated_at = ?2
-         where recipient = 'leader'
-           and owner_team_id = ?1
-           and (
-             (status = 'failed' and error = 'leader_not_attached')
-             or status = 'queued_until_leader_attach'
-           )",
-        params![owner_team_id.as_str(), chrono::Utc::now().to_rfc3339()],
-    )?;
+    let counts = store.requeue_blocked_leader_messages(owner_team_id.as_str())?;
+    let requeued = counts.total();
     if requeued > 0 {
         event_log.write(
             "leader_receiver.blocked_messages_requeued",
@@ -512,6 +525,10 @@ pub(crate) fn requeue_blocked_leader_messages(
                 "team_id": owner_team_id.as_str(),
                 "claimed_pane_id": claimed_pane_id.as_str(),
                 "count": requeued,
+                "by_prior_state": {
+                    "blocked_leader_unbound": counts.blocked_leader_unbound,
+                    "queued_until_leader_attach": counts.queued_until_leader_attach,
+                },
             }),
         )?;
     }
@@ -573,7 +590,7 @@ pub fn requeue_delivery_exhausted_watchers(
         )?;
     }
     drop(stmt);
-    let _ = requeue_blocked_leader_messages(&conn, event_log, owner_team_id, claimed_pane_id)?;
+    let _ = requeue_blocked_leader_messages(store, event_log, owner_team_id, claimed_pane_id)?;
     Ok(out)
 }
 

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

@@ -469,13 +469,25 @@ fn classify_pending_capture_state(
     const TRIGGER_GRACE_SECS: i64 = 15;
     let past_spawn_grace = elapsed_since_spawn >= SPAWN_GRACE_SECS;
     let past_trigger_grace = has_trigger && elapsed_since_trigger >= TRIGGER_GRACE_SECS;
+    let fork_pending_expired = agent_obj.get("capture_state").and_then(Value::as_str)
+        == Some("pending_context_fork")
+        && crate::provider::session::transition_pending_context_fork(
+            has_trigger,
+            past_spawn_grace && past_trigger_grace,
+        )
+        .is_some();
     // transcript_missing requires BOTH: a trigger occurred AND we've
     // waited past the spawn grace (so we're not blamed for slow startup).
     // candidate_count == 0 is the "no backing" signal; non-zero
     // candidates that didn't satisfy assignment go through the ambiguous
     // path above and don't reach here.
-    if has_trigger && past_spawn_grace && past_trigger_grace && candidate_count == 0 {
+    if (fork_pending_expired || has_trigger && past_spawn_grace && past_trigger_grace)
+        && candidate_count == 0
+    {
         "transcript_missing"
+    } else if agent_obj.get("capture_state").and_then(Value::as_str) == Some("pending_context_fork")
+    {
+        "pending_context_fork"
     } else {
         "pending_first_turn"
     }
@@ -1143,6 +1155,9 @@ fn apply_captured_session(
     agent_obj: &mut serde_json::Map<String, Value>,
     captured: &CapturedSession,
 ) -> bool {
+    if agent_obj.get("capture_state").and_then(Value::as_str) == Some("pending_context_fork") {
+        return crate::lifecycle::finalize_pending_fork_capture(agent_obj, captured);
+    }
     let Some(session_id) = captured.session_id.as_ref() else {
         return false;
     };
@@ -1984,6 +1999,27 @@ mod u1_tests {
         );
     }
 
+    #[test]
+    fn pending_context_fork_keeps_typed_state_until_trigger_grace_expires() {
+        let old = (chrono::Utc::now() - chrono::Duration::seconds(60)).to_rfc3339();
+        let mut agent = serde_json::Map::new();
+        agent.insert("spawned_at".to_string(), serde_json::json!(old));
+        agent.insert(
+            "capture_state".to_string(),
+            serde_json::json!("pending_context_fork"),
+        );
+        assert_eq!(
+            super::classify_pending_capture_state(&agent, 0),
+            "pending_context_fork"
+        );
+        let trigger = (chrono::Utc::now() - chrono::Duration::seconds(20)).to_rfc3339();
+        agent.insert("first_send_at".to_string(), serde_json::json!(trigger));
+        assert_eq!(
+            super::classify_pending_capture_state(&agent, 0),
+            "transcript_missing"
+        );
+    }
+
     #[test]
     fn canonical_pending_capture_preserves_legacy_missing_boundary() {
         let agent = serde_json::json!({

package/crates/team-agent/src/provider/session/context_fork/claude.rs

@@ -0,0 +1,85 @@
+use super::*;
+
+pub(super) fn verify_claude_fork(
+    provider: Provider,
+    source_session_id: &SessionId,
+    plan: &CommandPlan,
+    before: &ContextBackingSnapshot,
+    expected_backing_path: Option<&Path>,
+    spawn_cwd: &Path,
+    deadline: Duration,
+) -> Result<ContextForkProof, ContextForkTermination> {
+    let expected = plan.expected_session_id.as_ref().ok_or_else(|| {
+        ProviderError::CaptureFailed(
+            "context_fork_unverified: Claude plan has no expected session id".to_string(),
+        )
+    })?;
+    let path = expected_backing_path.ok_or_else(|| {
+        ProviderError::CaptureFailed(
+            "context_fork_unverified: Claude plan has no exact snapshot backing".to_string(),
+        )
+    })?;
+    let expected_name = format!("{}.jsonl", expected.as_str());
+    if path.file_name().and_then(|name| name.to_str()) != Some(expected_name.as_str()) {
+        return Err(ProviderError::CaptureFailed(format!(
+            "context_fork_unverified: Claude snapshot backing does not match expected session {}",
+            expected.as_str()
+        ))
+        .into());
+    }
+    let started = std::time::Instant::now();
+    loop {
+        if let Some(stamp) = file_stamp(path) {
+            let changed = before.files.get(path).is_none_or(|old| *old != stamp);
+            let observed_matches =
+                session_id_from_jsonl(path).is_none_or(|observed| observed == expected.as_str());
+            if changed && readable_jsonl(path) && observed_matches && expected != source_session_id
+            {
+                return Ok(ContextForkProof {
+                    provider,
+                    source_session_id: source_session_id.clone(),
+                    new_session_id: expected.clone(),
+                    backing_path: path.to_path_buf(),
+                    captured_via: "context_fork_verified".to_string(),
+                    attribution_confidence: "high".to_string(),
+                    managed_backing_root: None,
+                });
+            }
+        }
+        if let Some(provider_path) = std::env::var_os("HOME")
+            .map(PathBuf::from)
+            .and_then(|home| {
+                crate::provider::session_scan::claude::projects_dir_for_cwd(&home, spawn_cwd)
+            })
+            .map(|root| root.join(&expected_name))
+        {
+            let observed_matches = session_id_from_jsonl(&provider_path)
+                .is_some_and(|observed| observed == expected.as_str());
+            let changed = file_stamp(&provider_path)
+                .is_some_and(|stamp| before.files.get(&provider_path) != Some(&stamp));
+            if changed
+                && readable_jsonl(&provider_path)
+                && observed_matches
+                && expected != source_session_id
+            {
+                return Ok(ContextForkProof {
+                    provider,
+                    source_session_id: source_session_id.clone(),
+                    new_session_id: expected.clone(),
+                    backing_path: provider_path,
+                    captured_via: "context_fork_verified".to_string(),
+                    attribution_confidence: "high".to_string(),
+                    managed_backing_root: None,
+                });
+            }
+        }
+        if started.elapsed() >= deadline {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(50));
+    }
+    Err(ContextForkTermination::Timeout {
+        provider,
+        deadline_ms: deadline.as_millis(),
+    })
+}