sigit-code 1.7.0__tar.gz → 1.7.1__tar.gz

{sigit_code-1.7.0 → sigit_code-1.7.1}/Cargo.lock

@@ -5945,7 +5945,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sigit"
-version = "1.7.0"
+version = "1.7.1"
 dependencies = [
  "agent-client-protocol",
  "anyhow",
@@ -5976,7 +5976,7 @@ dependencies = [
 
 [[package]]
 name = "sigit-agent"
-version = "1.7.0"
+version = "1.7.1"
 dependencies = [
  "agent-client-protocol",
  "anyhow",

{sigit_code-1.7.0 → sigit_code-1.7.1}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/cli", "crates/sigit-*"]
 
 [workspace.package]
-version = "1.7.0"
+version = "1.7.1"
 edition = "2024"
 license = "Apache-2.0"
 repository = "https://github.com/getsigit/sigit"
@@ -16,7 +16,7 @@ authors = ["Seto Elkahfi <seto@sigit.si>", "paydii <193906237+paydii@users.norep
 # crates.io, so this resolves from the registry rather than the onde-ed checkout next door.
 ed-acp = { version = "1.3.0", default-features = false }
 ed-acp-testkit = "1.3.0"
-sigit-agent = { version = "1.7.0", default-features = false, path = "crates/sigit-agent" }
+sigit-agent = { version = "1.7.1", default-features = false, path = "crates/sigit-agent" }
 
 # ACP protocol SDK
 agent-client-protocol = { version = "2.2", features = ["unstable_session_fork"] }

{sigit_code-1.7.0 → sigit_code-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sigit-code
-Version: 1.7.0
+Version: 1.7.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{sigit_code-1.7.0 → sigit_code-1.7.1}/crates/cli/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 repository.workspace = true
 homepage.workspace = true
 readme = "README.md"
-keywords = ["cli", "ai", "coding-agent", "llm", "acp", "local", "on-device", "sigit"]
+keywords = ["cli", "ai", "coding-agent", "llm", "acp"]
 categories = ["command-line-utilities"]
 authors.workspace = true
 # `src/bin/` holds test-only helper binaries (the MCP stdio stub used by the

{sigit_code-1.7.0 → sigit_code-1.7.1}/crates/cli/src/chat.rs

@@ -1634,6 +1634,10 @@ mod tui {
                     };
                     if app.history_pending_delete.as_deref() == Some(id.as_str()) {
                         crate::session_store::delete(&id);
+                        // A plan must not outlive its conversation. The id is
+                        // the live session's key when the user deletes the
+                        // thread the TUI is currently running.
+                        crate::tools::clear_todos(&id);
                         app.refresh_history();
                         app.history_notice = Some(format!("Deleted session '{id}'."));
                     } else {
@@ -2837,6 +2841,8 @@ mod tui {
                 crate::permissions::reset_session(crate::permissions::TUI_SESSION);
                 // The saved session must not resurrect what the user just wiped.
                 crate::session_store::delete(TUI_STORE_SESSION);
+                // The plan belongs to the conversation, so the wipe drops it too.
+                crate::tools::clear_todos(crate::permissions::TUI_SESSION);
                 app.context_tokens_used = None;
                 app.messages.push(ChatMessage::system(format!(
                     "Cleared {cleared} turn(s). History is empty.",

{sigit_code-1.7.0 → sigit_code-1.7.1}/crates/cli/src/main.rs

@@ -743,11 +743,12 @@ fn todos_arguments_to_plan(arguments: &str) -> Option<Plan> {
     Some(Plan::new(entries))
 }
 
-/// Rebuilds an ACP [`Plan`] from the persisted todo list in `tools::get_todos()`.
-/// Used to re-emit the plan on error turns so the client panel stays populated
-/// when the model never got to (or forgot to) call `write_todos` this turn.
-fn persisted_todos_to_plan() -> Option<Plan> {
-    let todos = tools::get_todos()?;
+/// Rebuilds an ACP [`Plan`] from the session's persisted todo list in
+/// `tools::get_todos()`. Used to re-emit the plan on error turns so the client
+/// panel stays populated when the model never got to (or forgot to) call
+/// `write_todos` this turn.
+fn persisted_todos_to_plan(session: &SessionId) -> Option<Plan> {
+    let todos = tools::get_todos(&session.to_string())?;
     let entries = todos
         .into_iter()
         .map(|todo| {
@@ -3011,10 +3012,11 @@ impl SiGitAgent {
     ///
     /// Drops everything this process holds for it: the parked state (and with
     /// it the MCP servers the client named), its permission grants and plan
-    /// mode, and the background commands it started. The saved history stays,
-    /// so the thread still lists and reopens. The caller has already signalled
-    /// the session's running turn (see `begin_close`) and holds the session's
-    /// lock and `workspace_lock`, so that turn has ended by the time this runs.
+    /// mode, its todo list, and the background commands it started. The saved
+    /// history stays, so the thread still lists and reopens. The caller has
+    /// already signalled the session's running turn (see `begin_close`) and
+    /// holds the session's lock and `workspace_lock`, so that turn has ended by
+    /// the time this runs.
     ///
     /// An id this process does not hold is answered with success. The spec
     /// allows an error there, but the client wants the session gone and it is.
@@ -3050,6 +3052,10 @@ impl SiGitAgent {
         self.announced_titles.lock().unwrap().remove(&key);
         let killed = tools::kill_session_tasks(&key);
         tools::forget_abort(&key);
+        // The plan is the conversation's, so it goes with the conversation:
+        // an id that comes back later starts with an empty panel rather than
+        // the previous life's list.
+        tools::clear_todos(&key);
         self.closing_sessions.lock().unwrap().remove(&key);
 
         log::info!(
@@ -3599,7 +3605,7 @@ impl SiGitAgent {
                 // Re-emit the persisted plan so the client panel doesn't go
                 // empty when the initial inference call fails before the model
                 // can call `write_todos`.
-                if let Some(plan) = persisted_todos_to_plan() {
+                if let Some(plan) = persisted_todos_to_plan(&session_id) {
                     let _ = self.send_plan_update(cx, session_id.clone(), plan);
                 }
                 // Verbatim, no prefix: the backend has already turned this into
@@ -3996,7 +4002,7 @@ impl SiGitAgent {
                     log::error!("send_tool_results failed: {error}");
                     // Re-emit the persisted plan so the client panel doesn't go
                     // empty when a tool round fails mid-turn.
-                    if let Some(plan) = persisted_todos_to_plan() {
+                    if let Some(plan) = persisted_todos_to_plan(&session_id) {
                         let _ = self.send_plan_update(cx, session_id.clone(), plan);
                     }
                     self.finish_prompt(&session_id, &cancellation);
@@ -5492,6 +5498,13 @@ async fn exec_slash_acp(
             permissions::reset_session(&session_key);
             // The saved session must not resurrect what the user just wiped.
             session_store::delete(&session_key);
+            // The plan belongs to the conversation, so the wipe drops it too.
+            // The empty plan is what clears the client's panel: without it the
+            // editor keeps showing the list of the thread that no longer exists.
+            tools::clear_todos(&session_key);
+            agent
+                .send_plan_update(cx, session_id.clone(), Plan::new(Vec::new()))
+                .ok();
             // The wipe drops the session's Permissions override too; push the
             // refreshed chip so it doesn't keep showing a stale pick.
             let config_options = {
@@ -5922,6 +5935,12 @@ fn init_logging(is_tty: bool) {
 /// LeaveAlternateScreen (ratatui 0.29 hides `writer_mut()`).
 #[cfg(unix)]
 async fn run_interactive(tty: std::fs::File, mut cleanup_tty: std::fs::File) -> anyhow::Result<()> {
+    // The TUI is one long-lived conversation and shares the key the permission
+    // and session stores already use, so its tool calls are scoped to it —
+    // background task ownership and the todo list — instead of the session-less
+    // `""` key, which no teardown path can name.
+    tools::set_active_session(Some(permissions::TUI_SESSION));
+
     let engine = Arc::new(ChatEngine::new());
 
     let startup_selection = setup::startup_model_selection();
@@ -6042,6 +6061,18 @@ async fn run_interactive(tty: std::fs::File, mut cleanup_tty: std::fs::File) ->
         }
     }
 
+    // The conversation is over, however it ended (`/exit`, Ctrl+C, a panic in
+    // the event loop). Drop what it owned — background tasks, the plan, the
+    // permission grants and the abort slot — and detach the active session, so
+    // nothing outlives the conversation. The saved history deliberately stays:
+    // it is what `/resume` brings back on the next launch.
+    let killed = tools::kill_session_tasks(permissions::TUI_SESSION);
+    tools::clear_todos(permissions::TUI_SESSION);
+    tools::forget_abort(permissions::TUI_SESSION);
+    permissions::reset_session(permissions::TUI_SESSION);
+    tools::set_active_session(None);
+    log::info!("tui exit: {killed} background task(s) stopped");
+
     chat_result
 }
 
@@ -6896,7 +6927,7 @@ mod tests {
     async fn unknown_session_is_rejected_instead_of_borrowing_live_cwd() {
         let agent = SiGitAgent::new(
             Arc::new(ChatEngine::new()),
-            default_local_model_config(),
+            GgufModelConfig::qwen25_3b(),
             Arc::new(AtomicBool::new(true)),
             Arc::new(AtomicBool::new(false)),
             Arc::new(std::sync::Mutex::new(None)),
@@ -6917,7 +6948,7 @@ mod tests {
     async fn a_turn_leaves_no_cancellation_behind_however_it_returns() {
         let agent = SiGitAgent::new(
             Arc::new(ChatEngine::new()),
-            default_local_model_config(),
+            GgufModelConfig::qwen25_3b(),
             Arc::new(AtomicBool::new(true)),
             Arc::new(AtomicBool::new(false)),
             Arc::new(std::sync::Mutex::new(None)),
@@ -6956,7 +6987,7 @@ mod tests {
     async fn a_finished_turn_does_not_remove_its_successors_cancellation() {
         let agent = SiGitAgent::new(
             Arc::new(ChatEngine::new()),
-            default_local_model_config(),
+            GgufModelConfig::qwen25_3b(),
             Arc::new(AtomicBool::new(true)),
             Arc::new(AtomicBool::new(false)),
             Arc::new(std::sync::Mutex::new(None)),
@@ -6982,7 +7013,7 @@ mod tests {
     async fn cancel_signals_only_the_matching_active_prompt() {
         let agent = SiGitAgent::new(
             Arc::new(ChatEngine::new()),
-            default_local_model_config(),
+            GgufModelConfig::qwen25_3b(),
             Arc::new(AtomicBool::new(true)),
             Arc::new(AtomicBool::new(false)),
             Arc::new(std::sync::Mutex::new(None)),
@@ -7034,7 +7065,7 @@ mod tests {
             std::env::set_var("SIGIT_LOCAL_INFERENCE", "on");
         }
 
-        let local = default_local_model_config();
+        let local = GgufModelConfig::qwen25_3b();
         let agent = SiGitAgent::new(
             Arc::new(ChatEngine::new()),
             local.clone(),
@@ -7131,7 +7162,7 @@ mod tests {
 
         let agent = SiGitAgent::new(
             Arc::new(ChatEngine::new()),
-            default_local_model_config(),
+            GgufModelConfig::qwen25_3b(),
             Arc::new(AtomicBool::new(true)),
             Arc::new(AtomicBool::new(false)),
             Arc::new(std::sync::Mutex::new(None)),
@@ -7287,7 +7318,7 @@ mod tests {
 
         let agent = SiGitAgent::new(
             Arc::new(ChatEngine::new()),
-            default_local_model_config(),
+            GgufModelConfig::qwen25_3b(),
             Arc::new(AtomicBool::new(true)),
             Arc::new(AtomicBool::new(false)),
             Arc::new(std::sync::Mutex::new(None)),
@@ -7378,7 +7409,7 @@ mod tests {
 
         let agent = SiGitAgent::new(
             Arc::new(ChatEngine::new()),
-            default_local_model_config(),
+            GgufModelConfig::qwen25_3b(),
             Arc::new(AtomicBool::new(true)),
             Arc::new(AtomicBool::new(false)),
             Arc::new(std::sync::Mutex::new(None)),
@@ -7477,7 +7508,7 @@ mod tests {
             .unwrap_or_else(|poisoned| poisoned.into_inner());
         let agent = Arc::new(SiGitAgent::new(
             Arc::new(ChatEngine::new()),
-            default_local_model_config(),
+            GgufModelConfig::qwen25_3b(),
             Arc::new(AtomicBool::new(true)),
             Arc::new(AtomicBool::new(false)),
             Arc::new(std::sync::Mutex::new(None)),
@@ -7525,7 +7556,7 @@ mod tests {
             .unwrap_or_else(|poisoned| poisoned.into_inner());
         let agent = SiGitAgent::new(
             Arc::new(ChatEngine::new()),
-            default_local_model_config(),
+            GgufModelConfig::qwen25_3b(),
             Arc::new(AtomicBool::new(true)),
             Arc::new(AtomicBool::new(false)),
             Arc::new(std::sync::Mutex::new(None)),

{sigit_code-1.7.0 → sigit_code-1.7.1}/crates/cli/src/setup.rs

@@ -109,27 +109,70 @@ pub enum ModelCacheHealth {
     NotDownloaded,
 }
 
+/// Where the model store lives, resolved once and handed to the readers.
+///
+/// Resolving it from the environment is a global decision, so a caller that
+/// needs a store of its own — a test pointing at a scratch directory — passes
+/// the roots in rather than mutating `HF_HUB_CACHE`, `HF_HOME` and `HOME` out
+/// from under whatever else is running in the same process.
+#[derive(Debug, Clone, Default)]
+struct ModelRoots {
+    /// Onde App Group model hub, when the signed app has run at least once.
+    app_group: Option<PathBuf>,
+    /// `HF_HUB_CACHE`, or `HF_HOME/hub`, when set and present.
+    configured_cache: Option<PathBuf>,
+    /// `~/.cache/huggingface/hub`, when present.
+    default_cache: Option<PathBuf>,
+    /// File holding the persisted selection.
+    selected_model_file: Option<PathBuf>,
+}
+
+impl ModelRoots {
+    fn from_env() -> Self {
+        Self {
+            app_group: app_group_models_root(),
+            configured_cache: hf_cache_root(),
+            default_cache: default_hf_cache_root(),
+            selected_model_file: selected_model_file_path(),
+        }
+    }
+
+    /// One cache dir and one selection file, with no environment lookups at all.
+    #[cfg(test)]
+    fn in_dir(cache_root: &Path, selected_model_file: &Path) -> Self {
+        Self {
+            configured_cache: Some(cache_root.to_path_buf()),
+            selected_model_file: Some(selected_model_file.to_path_buf()),
+            ..Self::default()
+        }
+    }
+}
+
 /// find all GGUF models on disk. checks Onde app group first, then HF cache.
 pub fn discover_local_models() -> Vec<DiscoveredModel> {
+    discover_local_models_in(&ModelRoots::from_env())
+}
+
+fn discover_local_models_in(roots: &ModelRoots) -> Vec<DiscoveredModel> {
     let mut models = Vec::new();
     let mut seen_roots = Vec::new();
 
-    if let Some(app_group_models) = app_group_models_root() {
+    if let Some(app_group_models) = roots.app_group.as_ref() {
         seen_roots.push(app_group_models.clone());
-        collect_models_from_cache_root(&app_group_models, true, &mut models);
+        collect_models_from_cache_root(app_group_models, true, &mut models);
     }
 
-    if let Some(hf_cache) = hf_cache_root()
-        && !seen_roots.iter().any(|root| root == &hf_cache)
+    if let Some(hf_cache) = roots.configured_cache.as_ref()
+        && !seen_roots.iter().any(|root| root == hf_cache)
     {
         seen_roots.push(hf_cache.clone());
-        collect_models_from_cache_root(&hf_cache, false, &mut models);
+        collect_models_from_cache_root(hf_cache, false, &mut models);
     }
 
-    if let Some(default_hf_cache) = default_hf_cache_root()
-        && !seen_roots.iter().any(|root| root == &default_hf_cache)
+    if let Some(default_hf_cache) = roots.default_cache.as_ref()
+        && !seen_roots.iter().any(|root| root == default_hf_cache)
     {
-        collect_models_from_cache_root(&default_hf_cache, false, &mut models);
+        collect_models_from_cache_root(default_hf_cache, false, &mut models);
     }
 
     models.sort_by(|left, right| {
@@ -300,7 +343,10 @@ fn default_hf_cache_root() -> Option<PathBuf> {
 }
 
 pub fn load_selected_model() -> Option<SelectedModel> {
-    let path = selected_model_file_path()?;
+    load_selected_model_from(&selected_model_file_path()?)
+}
+
+fn load_selected_model_from(path: &Path) -> Option<SelectedModel> {
     let contents = std::fs::read_to_string(path).ok()?;
     let trimmed = contents.trim();
     if trimmed.is_empty() {
@@ -333,9 +379,16 @@ pub fn load_selected_model_name() -> Option<String> {
 /// pick a model for startup: saved selection > first local model > none.
 /// if we fall back to a local model, persist it so ACP and TUI agree next time.
 pub fn startup_model_selection() -> Option<StartupModelSelection> {
-    let discovered = discover_local_models();
+    startup_model_selection_in(&ModelRoots::from_env())
+}
 
-    if let Some(saved_model) = load_selected_model()
+fn startup_model_selection_in(roots: &ModelRoots) -> Option<StartupModelSelection> {
+    let discovered = discover_local_models_in(roots);
+
+    if let Some(saved_model) = roots
+        .selected_model_file
+        .as_deref()
+        .and_then(load_selected_model_from)
         && let Some(model) = discovered.iter().find(|model| {
             saved_model.matches(model) && model.cache_health == ModelCacheHealth::Complete
         })
@@ -351,7 +404,9 @@ pub fn startup_model_selection() -> Option<StartupModelSelection> {
         .find(|model| model.cache_health == ModelCacheHealth::Complete)
         .map(|model| {
             let selected_model = SelectedModel::from_discovered(&model);
-            let _ = save_selected_model(&selected_model);
+            if let Some(path) = roots.selected_model_file.as_deref() {
+                let _ = save_selected_model_to(path, &selected_model);
+            }
             StartupModelSelection {
                 display_name: model.display_name.clone(),
                 selected_model: Some(selected_model),
@@ -363,6 +418,10 @@ pub fn save_selected_model(selected_model: &SelectedModel) -> Result<(), String>
     let path = selected_model_file_path()
         .ok_or_else(|| "Could not determine where to store the selected model.".to_string())?;
 
+    save_selected_model_to(&path, selected_model)
+}
+
+fn save_selected_model_to(path: &Path, selected_model: &SelectedModel) -> Result<(), String> {
     if let Some(parent) = path.parent()
         && !parent.exists()
     {
@@ -375,7 +434,7 @@ pub fn save_selected_model(selected_model: &SelectedModel) -> Result<(), String>
         selected_model.model_id, selected_model.gguf_file
     );
 
-    std::fs::write(&path, contents)
+    std::fs::write(path, contents)
         .map_err(|error| format!("Could not save selected model: {error}"))
 }
 
@@ -431,22 +490,32 @@ fn resolve_shared_container() -> Option<PathBuf> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::sync::Mutex;
 
-    /// The crate-wide lock, not one of this module's own: the model picker
-    /// reads this cache from other modules' tests, and they must not see it
-    /// pointed at a scratch directory halfway through.
-    fn env_lock() -> &'static Mutex<()> {
-        &crate::ENV_TEST_LOCK
+    /// A cache dir and selection file owned by this test. The model store is
+    /// resolved from `HF_HUB_CACHE`/`HF_HOME`/`HOME`, which are process-global
+    /// and read by the picker on other threads, so tests hand their roots in
+    /// instead of aiming those variables at a scratch directory.
+    fn test_roots(cache_root: &Path, selection_dir: &Path) -> ModelRoots {
+        ModelRoots::in_dir(cache_root, &selection_dir.join(SELECTED_MODEL_FILE_NAME))
     }
 
+    /// A scratch directory no other test in this run can land on. The clock
+    /// alone is not enough: its resolution is coarse on some platforms and
+    /// parallel test threads can read the same tick, so the pid and a
+    /// process-local counter are mixed in.
     fn unique_temp_dir(name: &str) -> PathBuf {
+        static COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+
         let nanos = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
             .expect("system time before unix epoch")
             .as_nanos();
+        let seq = COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
 
-        std::env::temp_dir().join(format!("sigit-setup-tests-{name}-{nanos}"))
+        std::env::temp_dir().join(format!(
+            "sigit-setup-tests-{name}-{}-{seq}-{nanos}",
+            std::process::id()
+        ))
     }
 
     fn create_snapshot(
@@ -474,48 +543,11 @@ mod tests {
         snapshot_dir
     }
 
-    fn with_test_env<T>(hf_hub_cache: &Path, hf_home: &Path, f: impl FnOnce() -> T) -> T {
-        let _guard = env_lock().lock().expect("lock env");
-
-        let old_hf_hub_cache = std::env::var_os("HF_HUB_CACHE");
-        let old_hf_home = std::env::var_os("HF_HOME");
-        let old_home = std::env::var_os("HOME");
-
-        // SAFETY: tests serialize environment mutation with a process-wide mutex.
-        unsafe {
-            std::env::set_var("HF_HUB_CACHE", hf_hub_cache);
-            std::env::set_var("HF_HOME", hf_home);
-            std::env::set_var("HOME", hf_home);
-        }
-
-        let result = f();
-
-        // SAFETY: tests serialize environment mutation with a process-wide mutex.
-        unsafe {
-            match old_hf_hub_cache {
-                Some(value) => std::env::set_var("HF_HUB_CACHE", value),
-                None => std::env::remove_var("HF_HUB_CACHE"),
-            }
-            match old_hf_home {
-                Some(value) => std::env::set_var("HF_HOME", value),
-                None => std::env::remove_var("HF_HOME"),
-            }
-            match old_home {
-                Some(value) => std::env::set_var("HOME", value),
-                None => std::env::remove_var("HOME"),
-            }
-        }
-
-        result
-    }
-
     #[test]
     fn discover_local_models_marks_complete_and_incomplete_snapshots() {
         let root = unique_temp_dir("discover-health");
         let cache_root = root.join("hf-cache");
-        let hf_home = root.join("hf-home");
         std::fs::create_dir_all(&cache_root).expect("create cache root");
-        std::fs::create_dir_all(&hf_home).expect("create hf home");
 
         create_snapshot(
             &cache_root,
@@ -532,7 +564,7 @@ mod tests {
             false,
         );
 
-        let models = with_test_env(&cache_root, &hf_home, discover_local_models);
+        let models = discover_local_models_in(&test_roots(&cache_root, &root));
 
         assert_eq!(models.len(), 2);
 
@@ -557,9 +589,7 @@ mod tests {
     fn startup_model_selection_skips_saved_incomplete_model_and_picks_complete_one() {
         let root = unique_temp_dir("startup-selection");
         let cache_root = root.join("hf-cache");
-        let hf_home = root.join("hf-home");
         std::fs::create_dir_all(&cache_root).expect("create cache root");
-        std::fs::create_dir_all(&hf_home).expect("create hf home");
 
         create_snapshot(
             &cache_root,
@@ -576,20 +606,18 @@ mod tests {
             true,
         );
 
-        let selection = with_test_env(&cache_root, &hf_home, || {
-            let selected_path = selected_model_file_path().expect("selected model path");
-            if let Some(parent) = selected_path.parent() {
-                std::fs::create_dir_all(parent).expect("create selected model parent");
-            }
+        let roots = test_roots(&cache_root, &root);
+        let selected_path = roots
+            .selected_model_file
+            .clone()
+            .expect("selected model path");
+        std::fs::write(
+            &selected_path,
+            "bartowski/Qwen2.5-Coder-3B-Instruct-GGUF\nQwen2.5-Coder-3B-Instruct-Q4_K_M.gguf\n",
+        )
+        .expect("write selected model");
 
-            std::fs::write(
-                &selected_path,
-                "bartowski/Qwen2.5-Coder-3B-Instruct-GGUF\nQwen2.5-Coder-3B-Instruct-Q4_K_M.gguf\n",
-            )
-            .expect("write selected model");
-
-            startup_model_selection().expect("startup selection")
-        });
+        let selection = startup_model_selection_in(&roots).expect("startup selection");
 
         assert_eq!(
             selection.display_name,
@@ -606,11 +634,9 @@ mod tests {
     fn discover_empty_cache_returns_no_models() {
         let root = unique_temp_dir("discover-empty");
         let cache_root = root.join("hf-cache");
-        let hf_home = root.join("hf-home");
         std::fs::create_dir_all(&cache_root).expect("create cache root");
-        std::fs::create_dir_all(&hf_home).expect("create hf home");
 
-        let models = with_test_env(&cache_root, &hf_home, discover_local_models);
+        let models = discover_local_models_in(&test_roots(&cache_root, &root));
         assert!(models.is_empty());
 
         std::fs::remove_dir_all(root).expect("remove temp dir");
@@ -620,9 +646,7 @@ mod tests {
     fn complete_models_sort_before_incomplete() {
         let root = unique_temp_dir("sort-order");
         let cache_root = root.join("hf-cache");
-        let hf_home = root.join("hf-home");
         std::fs::create_dir_all(&cache_root).expect("create cache root");
-        std::fs::create_dir_all(&hf_home).expect("create hf home");
 
         create_snapshot(
             &cache_root,
@@ -639,7 +663,7 @@ mod tests {
             true,
         );
 
-        let models = with_test_env(&cache_root, &hf_home, discover_local_models);
+        let models = discover_local_models_in(&test_roots(&cache_root, &root));
         assert_eq!(models.len(), 2);
         assert_eq!(models[0].cache_health, ModelCacheHealth::Complete);
         assert_eq!(models[1].cache_health, ModelCacheHealth::Incomplete);
@@ -650,21 +674,19 @@ mod tests {
     #[test]
     fn load_selected_model_roundtrip() {
         let root = unique_temp_dir("persistence-roundtrip");
-        let hf_home = root.join("hf-home");
-        std::fs::create_dir_all(&hf_home).expect("create hf home");
+        let path = root.join(SELECTED_MODEL_FILE_NAME);
 
-        with_test_env(&hf_home, &hf_home, || {
-            let original = SelectedModel {
-                model_id: "bartowski/Qwen_Qwen3-4B-GGUF".to_string(),
-                gguf_file: "Qwen_Qwen3-4B-Q4_K_M.gguf".to_string(),
-            };
+        let original = SelectedModel {
+            model_id: "bartowski/Qwen_Qwen3-4B-GGUF".to_string(),
+            gguf_file: "Qwen_Qwen3-4B-Q4_K_M.gguf".to_string(),
+        };
 
-            save_selected_model(&original).expect("save");
-            let loaded = load_selected_model().expect("load");
+        // The parent dir does not exist yet: saving has to create it.
+        save_selected_model_to(&path, &original).expect("save");
+        let loaded = load_selected_model_from(&path).expect("load");
 
-            assert_eq!(loaded.model_id, original.model_id);
-            assert_eq!(loaded.gguf_file, original.gguf_file);
-        });
+        assert_eq!(loaded.model_id, original.model_id);
+        assert_eq!(loaded.gguf_file, original.gguf_file);
 
         std::fs::remove_dir_all(root).expect("remove temp dir");
     }
@@ -672,18 +694,11 @@ mod tests {
     #[test]
     fn load_selected_model_empty_file_returns_none() {
         let root = unique_temp_dir("persistence-empty");
-        let hf_home = root.join("hf-home");
-        std::fs::create_dir_all(&hf_home).expect("create hf home");
+        let path = root.join(SELECTED_MODEL_FILE_NAME);
+        std::fs::create_dir_all(&root).expect("create root");
+        std::fs::write(&path, "").expect("write empty");
 
-        with_test_env(&hf_home, &hf_home, || {
-            let path = selected_model_file_path().expect("path");
-            if let Some(parent) = path.parent() {
-                std::fs::create_dir_all(parent).expect("create parent");
-            }
-            std::fs::write(&path, "").expect("write empty");
-
-            assert!(load_selected_model().is_none());
-        });
+        assert!(load_selected_model_from(&path).is_none());
 
         std::fs::remove_dir_all(root).expect("remove temp dir");
     }

{sigit_code-1.7.0 → sigit_code-1.7.1}/crates/cli/src/tools.rs

@@ -577,7 +577,9 @@ fn execute_sync_tool(name: &str, arguments: &str, owner: Option<&str>) -> ToolOu
         "read_website" => exec_read_website(arguments),
         "create_directory" => exec_create_directory(arguments),
         "glob" => exec_glob(arguments),
-        "write_todos" => exec_write_todos(arguments),
+        // A missing owner is a session-less call (the headless runner sets
+        // one too), and its list is scoped to that same empty key.
+        "write_todos" => exec_write_todos(arguments, owner.unwrap_or("")),
         "remember" => exec_remember(arguments),
         "delete_file" => exec_delete_file(arguments),
         "run_command" => exec_run_command(arguments, owner),
@@ -2081,43 +2083,58 @@ impl TodoStatus {
     }
 }
 
-/// Process-global todo store. The model owns the list conceptually, but when
-/// it forgets to re-send the full list — an error turn, a context shift, a
-/// simple omission — the panel goes empty with nothing to fall back on. This
-/// keeps the last-known list so `main.rs` can re-emit it.
-/// (`todos_arguments_to_plan` + `SessionUpdate::Plan`) without the model's
-/// help.
-static TODOS: RwLock<Option<Vec<Todo>>> = RwLock::new(None);
-
-/// Read the persisted todo list, if any. Returns `None` when no `write_todos`
-/// call has succeeded yet (or the list was cleared).
-pub fn get_todos() -> Option<Vec<Todo>> {
-    TODOS
-        .read()
-        .unwrap_or_else(|poisoned| poisoned.into_inner())
-        .clone()
+/// Per-session todo store. The model owns the list conceptually, but when it
+/// forgets to re-send the full list — an error turn, a context shift, a simple
+/// omission — the panel goes empty with nothing to fall back on. This keeps
+/// the last-known list so `main.rs` can re-emit it (`todos_arguments_to_plan` +
+/// `SessionUpdate::Plan`) without the model's help.
+///
+/// Keyed by session, like `permissions::sessions()`: one process serves every
+/// thread an editor has open, and a plan belonging to one conversation must
+/// never surface in another.
+fn todo_sessions() -> &'static Mutex<HashMap<String, Vec<Todo>>> {
+    static SESSIONS: OnceLock<Mutex<HashMap<String, Vec<Todo>>>> = OnceLock::new();
+    SESSIONS.get_or_init(|| Mutex::new(HashMap::new()))
 }
 
-/// Serializes tests that touch the process-global `TODOS` store. Without
-/// this, parallel `cargo test` runs clobber each other's list.
-#[cfg(test)]
-static TODOS_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+/// Read the session's persisted todo list, if any. Returns `None` when no
+/// `write_todos` call has succeeded yet (or the list was cleared).
+pub fn get_todos(session: &str) -> Option<Vec<Todo>> {
+    todo_sessions()
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner())
+        .get(session)
+        .cloned()
+}
 
-/// Reset the store. Used by tests so one test's list doesn't leak into the
-/// next — the store is process-global.
-#[cfg(test)]
-fn reset_todos() {
-    let mut guard = TODOS
-        .write()
+/// Store the session's list, or drop the key when `None`. Dropping it rather
+/// than storing an empty list keeps "no plan" a single state the map doesn't
+/// accumulate entries for.
+fn set_todos(session: &str, todos: Option<Vec<Todo>>) {
+    let mut map = todo_sessions()
+        .lock()
         .unwrap_or_else(|poisoned| poisoned.into_inner());
-    *guard = None;
+    match todos {
+        Some(todos) => {
+            map.insert(session.to_string(), todos);
+        }
+        None => {
+            map.remove(session);
+        }
+    }
+}
+
+/// Forget a session's list (session teardown, a wiped conversation) so a plan
+/// never outlives the conversation it belongs to.
+pub fn clear_todos(session: &str) {
+    set_todos(session, None);
 }
 
 /// Renders the model's task checklist back as the tool result so the surface
 /// (TUI / ACP client) can show live progress. Also persists the list so the
 /// panel survives model omissions and error turns — the list is still owned
 /// by the model, but the last-known state is kept as a fallback.
-fn exec_write_todos(arguments: &str) -> String {
+fn exec_write_todos(arguments: &str, session: &str) -> String {
     let args: Value = match serde_json::from_str(arguments) {
         Ok(v) => v,
         Err(err) => return format!("Error: failed to parse arguments: {err}"),
@@ -2132,10 +2149,7 @@ fn exec_write_todos(arguments: &str) -> String {
     // restate at least one step. Clear the store too so a later omission
     // doesn't bring the old list back from the dead.
     if todos.is_empty() {
-        let mut guard = TODOS
-            .write()
-            .unwrap_or_else(|poisoned| poisoned.into_inner());
-        *guard = None;
+        set_todos(session, None);
         return "Task list cleared.".to_string();
     }
 
@@ -2172,10 +2186,7 @@ fn exec_write_todos(arguments: &str) -> String {
     // Persist the parsed list so the panel survives a later turn that omits
     // `write_todos` or errors out before reaching it. The store is the
     // fallback `get_todos()` reads.
-    let mut guard = TODOS
-        .write()
-        .unwrap_or_else(|poisoned| poisoned.into_inner());
-    *guard = Some(persisted);
+    set_todos(session, Some(persisted));
 
     format!(
         "Task list updated ({completed}/{} done):\n{}",
@@ -3569,7 +3580,7 @@ mod tests {
             ]
         })
         .to_string();
-        let result = exec_write_todos(&args);
+        let result = exec_write_todos(&args, "todos-test-render");
         assert!(result.contains("1/3 done"), "{result}");
         assert!(result.contains("[x] Read code"), "{result}");
         assert!(result.contains("[~] Make change"), "{result}");
@@ -3578,7 +3589,7 @@ mod tests {
 
     #[test]
     fn test_write_todos_accepts_an_empty_list_to_clear() {
-        let result = exec_write_todos(r#"{"todos":[]}"#);
+        let result = exec_write_todos(r#"{"todos":[]}"#, "todos-test-empty-clear");
         assert_eq!(result, "Task list cleared.");
     }
 
@@ -5378,15 +5389,14 @@ mod tests {
     }
 
     // ── write_todos persistence ───────────────────────────────────────────
-    // The store is process-global, so every test acquires `TODOS_TEST_LOCK`
-    // and calls `reset_todos()` first or it inherits whatever the previous
-    // test left behind.
+    // Each test owns a distinct session key, so the store's per-session
+    // scoping is what keeps parallel `cargo test` runs out of each other's
+    // lists — no shared lock needed.
 
     #[test]
     fn write_todos_persists_list() {
-        let _guard = TODOS_TEST_LOCK.lock().unwrap();
-        reset_todos();
-        assert!(get_todos().is_none());
+        let session = "todos-test-persists";
+        assert!(get_todos(session).is_none());
 
         let output = exec_write_todos(
             r#"{"todos":[
@@ -5394,10 +5404,11 @@ mod tests {
                 {"content":"step two","status":"in_progress"},
                 {"content":"step three","status":"pending"}
             ]}"#,
+            session,
         );
         assert!(output.contains("Task list updated (1/3 done)"));
 
-        let todos = get_todos().expect("list should be persisted");
+        let todos = get_todos(session).expect("list should be persisted");
         assert_eq!(todos.len(), 3);
         assert_eq!(todos[0].content, "step one");
         assert_eq!(todos[0].status, TodoStatus::Completed);
@@ -5406,63 +5417,105 @@ mod tests {
     }
 
     #[test]
-    fn get_todos_returns_none_after_reset() {
-        let _guard = TODOS_TEST_LOCK.lock().unwrap();
-        reset_todos();
-        assert!(get_todos().is_none());
+    fn write_todos_is_scoped_to_one_session() {
+        exec_write_todos(
+            r#"{"todos":[{"content":"mine","status":"pending"}]}"#,
+            "todos-test-scope-a",
+        );
+
+        // A second session starts empty rather than inheriting the first
+        // session's plan, and writing there leaves the first untouched.
+        assert!(get_todos("todos-test-scope-b").is_none());
+        exec_write_todos(
+            r#"{"todos":[{"content":"theirs","status":"completed"}]}"#,
+            "todos-test-scope-b",
+        );
+
+        let mine = get_todos("todos-test-scope-a").expect("first session keeps its list");
+        assert_eq!(mine.len(), 1);
+        assert_eq!(mine[0].content, "mine");
+        let theirs = get_todos("todos-test-scope-b").expect("second session has its own");
+        assert_eq!(theirs[0].content, "theirs");
+    }
+
+    #[test]
+    fn get_todos_returns_none_for_unknown_session() {
+        assert!(get_todos("todos-test-unknown").is_none());
+    }
+
+    #[test]
+    fn clear_todos_forgets_only_that_session() {
+        exec_write_todos(
+            r#"{"todos":[{"content":"gone","status":"pending"}]}"#,
+            "todos-test-clear",
+        );
+        exec_write_todos(
+            r#"{"todos":[{"content":"kept","status":"pending"}]}"#,
+            "todos-test-clear-other",
+        );
+
+        clear_todos("todos-test-clear");
+
+        assert!(get_todos("todos-test-clear").is_none());
+        assert!(get_todos("todos-test-clear-other").is_some());
     }
 
     #[test]
     fn write_todos_empty_list_clears_store() {
-        let _guard = TODOS_TEST_LOCK.lock().unwrap();
+        let session = "todos-test-empty";
         // Seed the store so we can prove the empty call wipes it.
-        exec_write_todos(r#"{"todos":[{"content":"seed","status":"pending"}]}"#);
-        assert!(get_todos().is_some());
+        exec_write_todos(
+            r#"{"todos":[{"content":"seed","status":"pending"}]}"#,
+            session,
+        );
+        assert!(get_todos(session).is_some());
 
-        let output = exec_write_todos(r#"{"todos":[]}"#);
+        let output = exec_write_todos(r#"{"todos":[]}"#, session);
         assert_eq!(output, "Task list cleared.");
-        assert!(get_todos().is_none());
+        assert!(get_todos(session).is_none());
     }
 
     #[test]
     fn write_todos_unknown_status_falls_back_to_pending() {
-        let _guard = TODOS_TEST_LOCK.lock().unwrap();
-        reset_todos();
-        exec_write_todos(r#"{"todos":[{"content":"weird","status":"bogus"}]}"#);
-        let todos = get_todos().expect("list should be persisted");
+        let session = "todos-test-unknown-status";
+        exec_write_todos(
+            r#"{"todos":[{"content":"weird","status":"bogus"}]}"#,
+            session,
+        );
+        let todos = get_todos(session).expect("list should be persisted");
         assert_eq!(todos.len(), 1);
         assert_eq!(todos[0].status, TodoStatus::Pending);
     }
 
     #[test]
     fn write_todos_missing_status_defaults_to_pending() {
-        let _guard = TODOS_TEST_LOCK.lock().unwrap();
-        reset_todos();
-        exec_write_todos(r#"{"todos":[{"content":"no status"}]}"#);
-        let todos = get_todos().expect("list should be persisted");
+        let session = "todos-test-missing-status";
+        exec_write_todos(r#"{"todos":[{"content":"no status"}]}"#, session);
+        let todos = get_todos(session).expect("list should be persisted");
         assert_eq!(todos.len(), 1);
         assert_eq!(todos[0].status, TodoStatus::Pending);
     }
 
     #[test]
     fn write_todos_overwrites_previous_list() {
-        let _guard = TODOS_TEST_LOCK.lock().unwrap();
-        reset_todos();
+        let session = "todos-test-overwrite";
         exec_write_todos(
             r#"{"todos":[
                 {"content":"a","status":"pending"},
                 {"content":"b","status":"pending"}
             ]}"#,
+            session,
         );
-        assert_eq!(get_todos().unwrap().len(), 2);
+        assert_eq!(get_todos(session).unwrap().len(), 2);
 
         // A second call with a different list replaces, not appends.
         exec_write_todos(
             r#"{"todos":[
                 {"content":"only","status":"completed"}
             ]}"#,
+            session,
         );
-        let todos = get_todos().unwrap();
+        let todos = get_todos(session).unwrap();
         assert_eq!(todos.len(), 1);
         assert_eq!(todos[0].content, "only");
         assert_eq!(todos[0].status, TodoStatus::Completed);