@team-agent/installer 0.5.52 → 0.5.54

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

@@ -446,7 +446,10 @@ fn message_not_silently_stuck_accepted_when_coordinator_dead() {
     assert!(out.ok, "durable persistence is the send success boundary");
     assert_eq!(out.status, DeliveryStatus::Blocked);
     assert_eq!(out.message_status.0, "queued_coordinator_unavailable");
-    assert!(out.message_id.as_deref().is_some_and(|id| id.starts_with("msg_")));
+    assert!(out
+        .message_id
+        .as_deref()
+        .is_some_and(|id| id.starts_with("msg_")));
     assert_eq!(out.reason, Some(DeliveryRefusal::CoordinatorUnavailable));
     assert!(
         out.verification
@@ -2290,6 +2293,53 @@ fn u1_multi_team_send_does_not_backfill_top_level_leader_binding() {
     assert_eq!(owner_team_id.as_deref(), Some("team-b"));
 }
 
+#[test]
+fn casefile_leader_send_is_durable_without_entering_leader_funnel() {
+    let ws = tmp_ws("casefile-send");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &serde_json::json!({
+            "session_name": "team-a",
+            "active_team_key": "team-a",
+            "agents": {}
+        }),
+    )
+    .unwrap();
+    let opts = SendOptions {
+        team: Some(TeamKey::new("team-a")),
+        requires_ack: false,
+        presentation: crate::messaging::presentation::PresentationRequest {
+            sink: crate::messaging::presentation::PresentationSink::Casefile,
+            class: crate::messaging::presentation::PresentationClass::Progress,
+            case_id: Some("case-1".to_string()),
+        },
+        ..SendOptions::default()
+    };
+    let out = send_message(
+        &ws,
+        &MessageTarget::Single("leader".to_string()),
+        "internal progress",
+        &opts,
+    )
+    .unwrap();
+    assert_eq!(out.status, DeliveryStatus::StoredOnly);
+    assert_eq!(out.message_status.0, "stored_only");
+    let store = store_for(&ws);
+    let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+    let (status, presentation): (String, String) = conn
+        .query_row(
+            "select status, presentation from messages where message_id = ?1",
+            [out.message_id.as_deref().unwrap()],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )
+        .unwrap();
+    assert_eq!(status, "stored_only");
+    assert_eq!(
+        serde_json::from_str::<serde_json::Value>(&presentation).unwrap()["effective_sink"],
+        "casefile"
+    );
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // GROUP V — retry_result_deliveries: re-route notify_failed watchers with
 // dedupe_reason rebind_retry. result_delivery.py:19-35.
@@ -3221,30 +3271,41 @@ fn gate054_status_surfaces_pending_leader_notifications() {
 
 #[test]
 fn gate054_fallback_pane_grep_guard_no_cross_server_chain_when_socket_recorded() {
-    // Structural grep: the recorded-socket branch of the fallback inject
-    // chain must NOT compose the workspace or default tmux backends after
-    // the endpoint backend rejects. This is the byte-level fence against
-    // silent regression.
+    // Structural grep: the recorded-socket transport set must contain only
+    // the endpoint backend, while workspace/default transports remain in the
+    // no-socket arm. Physical injection must consume the pane returned by the
+    // shared resolver rather than rebuilding a target from state.
     let src = include_str!("../leader_receiver.rs");
-    let inject_start = src
-        .find("let inject_result: Result<InjectReport, TransportError>")
-        .expect("fallback inject chain must remain single-typed");
-    let inject_end = src[inject_start..]
-        .find("};\n\n    match inject_result")
-        .map(|off| inject_start + off + 2)
-        .expect("fallback inject chain must terminate before match");
-    let chain = &src[inject_start..inject_end];
-    // The socket-recorded arm is the `Some(socket) => {..}` block. It must
-    // NOT contain a workspace or default fallback.
-    let some_arm_start = chain.find("Some(socket) => {").expect("Some(socket) arm");
-    let some_arm_end = chain[some_arm_start..]
-        .find("None => {")
-        .map(|off| some_arm_start + off)
-        .expect("None arm must follow");
-    let some_arm = &chain[some_arm_start..some_arm_end];
+    let transports_start = src
+        .find("let transports: Vec<Box<dyn Transport>>")
+        .expect("fallback transport set must remain explicit");
+    let transports_end = src[transports_start..]
+        .find("let mut resolved")
+        .map(|off| transports_start + off)
+        .expect("transport selection must precede shared resolution");
+    let transports = &src[transports_start..transports_end];
+    let socket_arm_start = transports
+        .find("Some(socket) =>")
+        .expect("recorded-socket arm");
+    let socket_arm_end = transports[socket_arm_start..]
+        .find("None =>")
+        .map(|off| socket_arm_start + off)
+        .expect("no-socket arm must follow");
+    let socket_arm = &transports[socket_arm_start..socket_arm_end];
+    assert!(
+        socket_arm.contains("tmux_endpoint_transport")
+            && !socket_arm.contains("tmux_workspace_transport")
+            && !socket_arm.contains("tmux_default_transport"),
+        "0.5.5 gate054: socket-recorded fallback arm must remain endpoint-only; arm={socket_arm}"
+    );
+    let no_socket_arm = &transports[socket_arm_end..];
+    assert!(
+        no_socket_arm.contains("tmux_workspace_transport")
+            && no_socket_arm.contains("tmux_default_transport"),
+        "0.5.5 gate054: workspace/default transports belong only to the no-socket arm; arm={no_socket_arm}"
+    );
     assert!(
-        !some_arm.contains("tmux_workspace_transport")
-            && !some_arm.contains("tmux_default_transport"),
-        "0.5.5 gate054: socket-recorded fallback arm must not compose workspace/default backends; arm={some_arm}"
+        src.contains("let target = Target::Pane(PaneId::new(channel.pane_id));"),
+        "fallback injection must consume the shared resolver's typed channel"
     );
 }

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

@@ -20,6 +20,8 @@ use super::helpers::MessageStatusShadow;
 #[serde(rename_all = "snake_case")]
 pub enum DeliveryStatus {
     Delivered,
+    /// Durable presentation obligation intentionally did not enter physical injection.
+    StoredOnly,
     Failed,
     /// busy → 延后不丢 (card §131:不 mark failed,留队列)。
     Queued,

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

@@ -195,6 +195,7 @@ fn deliver_primary_watcher(
         false,
         None,
         super::InitialDisposition::Accepted,
+        None,
     )?
     else {
         unreachable!("watcher notifications do not accept caller-supplied ids")

package/crates/team-agent/src/provider/adapter.rs

@@ -301,14 +301,14 @@ impl ProviderAdapter for BasicProviderAdapter {
                 native_mcp_config: false,
                 writes_global_settings: false,
             },
-            // Copilot(C-4-1 cr verdict):resume 走 --resume <sid>;**无 fork** 旗标,
-            // session-store 不支持 branched continuation → caps.fork=false 显式拒。
+            // Copilot resume 走 --resume <sid>;store fork 在隔离 COPILOT_HOME
+            // 复制并重键 session backing 后以 --resume <new sid> 启动。
             // native_mcp_config=true(`--additional-mcp-config` 接 inline JSON 或 @file);
             // writes_global_settings=false(session 走 --session-id 预定 UUID,不污染
             // ~/.copilot/mcp-config.json,help 原文 "augments config for this session")。
             Provider::Copilot => ProviderCaps {
                 resume: true,
-                fork: false,
+                fork: true,
                 native_mcp_config: true,
                 writes_global_settings: false,
             },
@@ -829,10 +829,9 @@ impl ProviderAdapter for BasicProviderAdapter {
                 argv.push("--fork-session".to_string());
                 Ok(argv)
             }
-            // C-4-2 cr verdict: copilot 无 fork 旗标 + session-store 不支持 branched
-            // continuation → 显式 CapabilityUnsupported,**绝不** silent fallback 到
-            // restart-from-scratch(MUST-NOT-13 诚实)。本分支理论上不可达(caps.fork=false
-            // 已在 fork_with_context 入口拦截,line 582),保留作 totality 守护。
+            // Context-free adapter calls cannot materialize the Copilot store fork.
+            // The lifecycle path uses `fork_plan`, which receives the prepared isolated
+            // backing; never degrade this context-free call to a fresh spawn.
             Provider::Copilot => Err(ProviderError::CapabilityUnsupported(
                 "copilot CLI 无 fork 旗标,session-store 不支持 branched continuation".to_string(),
             )),
@@ -858,11 +857,11 @@ impl ProviderAdapter for BasicProviderAdapter {
                         provider_wire(self.provider)
                     )));
                 }
-                let Some(session_id) = session_id else {
+                if session_id.is_none() {
                     return Err(ProviderError::ResumeUnavailable(
                         "fork requires session_id".to_string(),
                     ));
-                };
+                }
                 let expected = next_session_token();
                 let managed = ctx
                     .profile_launch
@@ -881,11 +880,8 @@ impl ProviderAdapter for BasicProviderAdapter {
                     managed,
                     ctx.effort,
                 )?;
-                argv.push("--session-id".to_string());
-                argv.push(expected.clone());
                 argv.push("--resume".to_string());
-                argv.push(session_id.as_str().to_string());
-                argv.push("--fork-session".to_string());
+                argv.push(expected.clone());
                 Ok(CommandPlan {
                     argv,
                     expected_session_id: Some(SessionId::new(expected)),
@@ -918,6 +914,51 @@ impl ProviderAdapter for BasicProviderAdapter {
                 argv.push(session_id.as_str().to_string());
                 Ok(CommandPlan::argv_only(argv))
             }
+            Provider::Copilot => {
+                if ctx.auth_mode == AuthMode::CompatibleApi {
+                    return Err(ProviderError::CapabilityUnsupported(
+                        "copilot does not support session fork in compatible_api mode".to_string(),
+                    ));
+                }
+                let profile = ctx.profile_launch.ok_or_else(|| {
+                    ProviderError::Command(
+                        "copilot fork requires a prepared provider profile".to_string(),
+                    )
+                })?;
+                let expected = profile
+                    .env_overlay
+                    .get("TEAM_AGENT_INTERNAL_COPILOT_FORK_SESSION_ID")
+                    .filter(|value| !value.is_empty())
+                    .map(SessionId::new)
+                    .ok_or_else(|| {
+                        ProviderError::Command(
+                            "copilot fork session backing was not materialized".to_string(),
+                        )
+                    })?;
+                let root = profile
+                    .env_overlay
+                    .get("COPILOT_HOME")
+                    .filter(|value| !value.is_empty())
+                    .map(PathBuf::from)
+                    .ok_or_else(|| {
+                        ProviderError::Command("copilot fork root was not materialized".to_string())
+                    })?;
+                let mut argv = copilot_base_command_resume(
+                    ctx.auth_mode,
+                    ctx.mcp_config,
+                    ctx.system_prompt,
+                    ctx.model,
+                    ctx.tools,
+                );
+                argv.push("--resume".to_string());
+                argv.push(expected.as_str().to_string());
+                Ok(CommandPlan {
+                    argv,
+                    expected_session_id: Some(expected),
+                    provider_projects_root: Some(root),
+                    managed_mcp_config: profile.managed_mcp_config,
+                })
+            }
             _ => self
                 .fork_with_context(
                     session_id,

package/crates/team-agent/src/provider/adapters/claude_fork.rs

@@ -0,0 +1,122 @@
+use std::path::{Path, PathBuf};
+
+use crate::provider::{ProviderError, SessionId};
+
+#[derive(Debug)]
+pub(crate) struct ClaudeForkMaterialization {
+    path: PathBuf,
+    keep: bool,
+}
+
+impl ClaudeForkMaterialization {
+    pub(crate) fn path(&self) -> &Path {
+        &self.path
+    }
+
+    pub(crate) fn keep(&mut self) {
+        self.keep = true;
+    }
+}
+
+impl Drop for ClaudeForkMaterialization {
+    fn drop(&mut self) {
+        if !self.keep {
+            let _ = std::fs::remove_file(&self.path);
+        }
+    }
+}
+
+pub(crate) fn materialize_claude_fork(
+    source_path: &Path,
+    source_session_id: &SessionId,
+    target_session_id: &SessionId,
+) -> Result<ClaudeForkMaterialization, ProviderError> {
+    let parent = source_path.parent().ok_or_else(|| {
+        ProviderError::Io(format!(
+            "claude source backing has no parent: {}",
+            source_path.display()
+        ))
+    })?;
+    let target_path = parent.join(format!("{}.jsonl", target_session_id.as_str()));
+    if target_path.exists() {
+        return Err(ProviderError::Io(format!(
+            "claude fork destination already exists: {}",
+            target_path.display()
+        )));
+    }
+    let source = std::fs::read_to_string(source_path)
+        .map_err(|error| ProviderError::Io(error.to_string()))?;
+    let rewritten = source.replace(source_session_id.as_str(), target_session_id.as_str());
+    validate_jsonl(&rewritten)?;
+    let temp = parent.join(format!(
+        ".{}.tmp-{}",
+        target_session_id.as_str(),
+        std::process::id()
+    ));
+    let result = std::fs::write(&temp, rewritten)
+        .and_then(|_| std::fs::rename(&temp, &target_path))
+        .map_err(|error| ProviderError::Io(error.to_string()));
+    if let Err(error) = result {
+        let _ = std::fs::remove_file(&temp);
+        return Err(error);
+    }
+    Ok(ClaudeForkMaterialization {
+        path: target_path,
+        keep: false,
+    })
+}
+
+fn validate_jsonl(text: &str) -> Result<(), ProviderError> {
+    let mut rows = 0_usize;
+    for (index, line) in text.lines().enumerate() {
+        if line.trim().is_empty() {
+            continue;
+        }
+        serde_json::from_str::<serde_json::Value>(line).map_err(|error| {
+            ProviderError::Io(format!(
+                "claude fork source has invalid JSONL at line {}: {error}",
+                index + 1
+            ))
+        })?;
+        rows += 1;
+    }
+    if rows == 0 {
+        return Err(ProviderError::Io(
+            "claude fork source backing has no JSONL records".to_string(),
+        ));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn snapshot_rekeys_every_record_and_preserves_source() {
+        let dir = std::env::temp_dir().join(format!("ta-claude-fork-copy-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let source_id = SessionId::new("11111111-1111-4111-8111-111111111111");
+        let target_id = SessionId::new("22222222-2222-4222-8222-222222222222");
+        let source_path = dir.join(format!("{}.jsonl", source_id.as_str()));
+        let source = format!(
+            "{{\"sessionId\":\"{}\"}}\n{{\"payload\":{{\"session_id\":\"{}\"}}}}\n",
+            source_id.as_str(),
+            source_id.as_str()
+        );
+        std::fs::write(&source_path, &source).unwrap();
+
+        let mut materialized =
+            materialize_claude_fork(&source_path, &source_id, &target_id).unwrap();
+        let target_path = dir.join(format!("{}.jsonl", target_id.as_str()));
+        let target = std::fs::read_to_string(&target_path).unwrap();
+        assert!(!target.contains(source_id.as_str()));
+        assert!(target.contains(target_id.as_str()));
+        assert_eq!(std::fs::read_to_string(&source_path).unwrap(), source);
+        materialized.keep();
+        drop(materialized);
+        assert!(target_path.is_file());
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}

package/crates/team-agent/src/provider/adapters/copilot_fork.rs

@@ -0,0 +1,306 @@
+use std::path::{Path, PathBuf};
+
+use rusqlite::{params, Connection};
+
+use crate::provider::{next_session_token, ProviderError, SessionId};
+
+const SESSION_TABLES: [&str; 6] = [
+    "turns",
+    "checkpoints",
+    "session_files",
+    "session_refs",
+    "forge_trajectory_events",
+    "search_index",
+];
+
+#[derive(Debug, Clone)]
+pub(crate) struct CopilotForkMaterialization {
+    session_id: SessionId,
+    home: PathBuf,
+    keep: bool,
+}
+
+impl CopilotForkMaterialization {
+    pub(crate) fn session_id(&self) -> &SessionId {
+        &self.session_id
+    }
+
+    pub(crate) fn home(&self) -> &Path {
+        &self.home
+    }
+
+    pub(crate) fn keep(&mut self) {
+        self.keep = true;
+    }
+}
+
+impl Drop for CopilotForkMaterialization {
+    fn drop(&mut self) {
+        if !self.keep {
+            let _ = std::fs::remove_dir_all(&self.home);
+        }
+    }
+}
+
+pub(crate) fn copilot_home() -> Result<PathBuf, ProviderError> {
+    if let Some(home) = std::env::var_os("COPILOT_HOME").filter(|value| !value.is_empty()) {
+        return Ok(PathBuf::from(home));
+    }
+    std::env::var_os("HOME")
+        .map(PathBuf::from)
+        .map(|home| home.join(".copilot"))
+        .ok_or_else(|| ProviderError::Io("HOME is unset; cannot resolve COPILOT_HOME".to_string()))
+}
+
+pub(crate) fn materialize_copilot_fork(
+    workspace: &Path,
+    agent_id: &str,
+    source_session_id: &SessionId,
+) -> Result<CopilotForkMaterialization, ProviderError> {
+    let source_home = copilot_home()?;
+    let source_dir = source_home
+        .join("session-state")
+        .join(source_session_id.as_str());
+    let source_db = source_home.join("session-store.db");
+    if !source_dir.is_dir() || !source_db.is_file() {
+        return Err(ProviderError::Io(format!(
+            "copilot source backing is incomplete under {}",
+            source_home.display()
+        )));
+    }
+
+    let session_id = SessionId::new(next_session_token());
+    let parent = workspace
+        .join(".team/runtime/provider-session-forks/copilot")
+        .join(agent_id);
+    let home = parent.join(session_id.as_str());
+    let temp = parent.join(format!(
+        ".{}.tmp-{}",
+        session_id.as_str(),
+        std::process::id()
+    ));
+    if home.exists() || temp.exists() {
+        return Err(ProviderError::Io(format!(
+            "copilot fork destination already exists: {}",
+            home.display()
+        )));
+    }
+    std::fs::create_dir_all(temp.join("session-state"))
+        .map_err(|error| ProviderError::Io(error.to_string()))?;
+
+    let result = (|| {
+        let target_session_dir = temp.join("session-state").join(session_id.as_str());
+        copy_tree(&source_dir, &target_session_dir)?;
+        rewrite_text_tree(
+            &target_session_dir,
+            source_session_id.as_str(),
+            session_id.as_str(),
+        )?;
+        rewrite_per_session_db(
+            &target_session_dir.join("session.db"),
+            source_session_id.as_str(),
+            session_id.as_str(),
+        )?;
+        clone_and_rekey_store(
+            &source_db,
+            &temp.join("session-store.db"),
+            source_session_id.as_str(),
+            session_id.as_str(),
+        )?;
+        std::fs::rename(&temp, &home).map_err(|error| ProviderError::Io(error.to_string()))
+    })();
+    if let Err(error) = result {
+        let _ = std::fs::remove_dir_all(&temp);
+        return Err(error);
+    }
+    Ok(CopilotForkMaterialization {
+        session_id,
+        home,
+        keep: false,
+    })
+}
+
+fn copy_tree(source: &Path, target: &Path) -> Result<(), ProviderError> {
+    std::fs::create_dir_all(target).map_err(|error| ProviderError::Io(error.to_string()))?;
+    for entry in std::fs::read_dir(source).map_err(|error| ProviderError::Io(error.to_string()))? {
+        let entry = entry.map_err(|error| ProviderError::Io(error.to_string()))?;
+        let source_path = entry.path();
+        let target_path = target.join(entry.file_name());
+        if source_path.is_dir() {
+            copy_tree(&source_path, &target_path)?;
+        } else {
+            std::fs::copy(&source_path, &target_path)
+                .map_err(|error| ProviderError::Io(error.to_string()))?;
+        }
+    }
+    Ok(())
+}
+
+fn rewrite_text_tree(root: &Path, source: &str, target: &str) -> Result<(), ProviderError> {
+    for entry in std::fs::read_dir(root).map_err(|error| ProviderError::Io(error.to_string()))? {
+        let entry = entry.map_err(|error| ProviderError::Io(error.to_string()))?;
+        let path = entry.path();
+        if path.is_dir() {
+            rewrite_text_tree(&path, source, target)?;
+            continue;
+        }
+        if path.extension().and_then(|ext| ext.to_str()) == Some("db") {
+            continue;
+        }
+        let Ok(text) = std::fs::read_to_string(&path) else {
+            continue;
+        };
+        if text.contains(source) {
+            std::fs::write(&path, text.replace(source, target))
+                .map_err(|error| ProviderError::Io(error.to_string()))?;
+        }
+    }
+    Ok(())
+}
+
+fn clone_and_rekey_store(
+    source_db: &Path,
+    target_db: &Path,
+    source: &str,
+    target: &str,
+) -> Result<(), ProviderError> {
+    let source_conn = Connection::open(source_db).map_err(sql_error)?;
+    source_conn
+        .execute("VACUUM INTO ?1", [target_db.to_string_lossy().as_ref()])
+        .map_err(sql_error)?;
+    drop(source_conn);
+
+    let mut conn = Connection::open(target_db).map_err(sql_error)?;
+    conn.pragma_update(None, "foreign_keys", "OFF")
+        .map_err(sql_error)?;
+    let tx = conn.transaction().map_err(sql_error)?;
+    let session_rows = tx
+        .execute(
+            "update sessions set id = ?1 where id = ?2",
+            params![target, source],
+        )
+        .map_err(sql_error)?;
+    if session_rows != 1 {
+        return Err(ProviderError::Io(format!(
+            "copilot session-store source row count must be 1, got {session_rows}"
+        )));
+    }
+    for table in SESSION_TABLES {
+        require_session_column(&tx, table)?;
+        tx.execute(
+            &format!("update {table} set session_id = ?1 where session_id = ?2"),
+            params![target, source],
+        )
+        .map_err(sql_error)?;
+    }
+    tx.commit().map_err(sql_error)?;
+    verify_rekeyed_store(&conn, source, target)
+}
+
+fn require_session_column(conn: &Connection, table: &str) -> Result<(), ProviderError> {
+    let mut stmt = conn
+        .prepare(&format!("pragma table_info({table})"))
+        .map_err(sql_error)?;
+    let mut rows = stmt.query([]).map_err(sql_error)?;
+    while let Some(row) = rows.next().map_err(sql_error)? {
+        let name: String = row.get(1).map_err(sql_error)?;
+        if name == "session_id" {
+            return Ok(());
+        }
+    }
+    Err(ProviderError::Io(format!(
+        "copilot session-store table {table} is missing session_id"
+    )))
+}
+
+fn verify_rekeyed_store(
+    conn: &Connection,
+    source: &str,
+    target: &str,
+) -> Result<(), ProviderError> {
+    let target_sessions: i64 = conn
+        .query_row(
+            "select count(*) from sessions where id = ?1",
+            [target],
+            |row| row.get(0),
+        )
+        .map_err(sql_error)?;
+    let source_sessions: i64 = conn
+        .query_row(
+            "select count(*) from sessions where id = ?1",
+            [source],
+            |row| row.get(0),
+        )
+        .map_err(sql_error)?;
+    if target_sessions != 1 || source_sessions != 0 {
+        return Err(ProviderError::Io(
+            "copilot session-store session id rekey verification failed".to_string(),
+        ));
+    }
+    for table in SESSION_TABLES {
+        let remaining: i64 = conn
+            .query_row(
+                &format!("select count(*) from {table} where session_id = ?1"),
+                [source],
+                |row| row.get(0),
+            )
+            .map_err(sql_error)?;
+        if remaining != 0 {
+            return Err(ProviderError::Io(format!(
+                "copilot session-store table {table} still references source session"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn rewrite_per_session_db(path: &Path, source: &str, target: &str) -> Result<(), ProviderError> {
+    if !path.is_file() {
+        return Ok(());
+    }
+    let mut conn = Connection::open(path).map_err(sql_error)?;
+    let columns: Vec<(String, String)> = {
+        let mut tables = conn
+            .prepare("select name from sqlite_master where type = 'table'")
+            .map_err(sql_error)?;
+        let names = tables
+            .query_map([], |row| row.get::<_, String>(0))
+            .map_err(sql_error)?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(sql_error)?;
+        let mut columns = Vec::new();
+        for table in names {
+            let mut stmt = conn
+                .prepare(&format!(
+                    "pragma table_info('{}')",
+                    table.replace('\'', "''")
+                ))
+                .map_err(sql_error)?;
+            let rows = stmt
+                .query_map([], |row| row.get::<_, String>(1))
+                .map_err(sql_error)?;
+            for column in rows {
+                let column = column.map_err(sql_error)?;
+                if column == "session_id" || column == "recipient_session_id" {
+                    columns.push((table.clone(), column));
+                }
+            }
+        }
+        columns
+    };
+    let tx = conn.transaction().map_err(sql_error)?;
+    for (table, column) in columns {
+        let table = table.replace('"', "\"\"");
+        let column = column.replace('"', "\"\"");
+        tx.execute(
+            &format!("update \"{table}\" set \"{column}\" = ?1 where \"{column}\" = ?2"),
+            params![target, source],
+        )
+        .map_err(sql_error)?;
+    }
+    tx.commit().map_err(sql_error)
+}
+
+fn sql_error(error: rusqlite::Error) -> ProviderError {
+    ProviderError::Io(format!("copilot sqlite: {error}"))
+}