Fix workspace scope & full-scan backfill, add tests

Improve workspace startup scoping and harden full-history backfill. Removed the stale last-workspace restore when no workspace hint is provided and added resolve_workspace_path to ensure non-git --cwd/--project selections yield an "All workspaces" result (launches outside a repo now behave correctly). Strengthened compute_snapshot so a full scan with --scan-time-budget-ms 0 forces full reparse (ignores planner file/byte caps) and skips trusting cached rows when reparsing is required. Added comprehensive unit tests covering workspace selection precedence, full-scan stale-cache repair, append-only file resume via cached offsets, and other planner behaviors. Updated README/CHANGELOG and bumped package version to 0.3.2.

Author: ssh4net

CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project are documented in this file.
 
+## 0.3.2 - 2026-02-17
+
+- Fixed workspace startup scoping:
+  - Launching outside a git repo now always uses **All workspaces**.
+  - A non-git `--project`/`--cwd` now disables repo filtering, even if launch dir is inside a repo.
+  - `comon` no longer restores a stale last workspace filter when no workspace hint is detected.
+- Hardened long-history backfill behavior:
+  - `--full-scan --scan-time-budget-ms 0` now forces full reparse instead of trusting unchanged cache rows.
+  - Full scan now ignores planner file/byte caps.
+- Added regression tests for:
+  - workspace selection precedence
+  - full-scan stale-cache repair
+  - append-only file resume via cached file offsets
+
 ## 0.3.0 - 2026-02-16
 
 - Added incremental session parsing with persisted offsets and parser state in `comon.db`.

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "comon"
-version = "0.3.0"
+version = "0.3.2"
 edition = "2021"
 license = "Apache-2.0"
 

Cargo.toml

@@ -11,10 +11,12 @@ See `CHANGELOG.md` for release history.
 
 <img width="1647" height="861" alt="Dkh7CxLgx7" src="https://github.com/user-attachments/assets/edec765d-0924-493b-8c10-cb32bca867a9" />
 
-## Release 0.3.0
+## Release 0.3.2
 
 - Added incremental session parsing with persisted offsets and parser state in `comon.db`.
 - Reduced restart regressions: unchanged files outside current scan plan now stay visible via cache.
+- Fixed full backfill behavior: `--full-scan --scan-time-budget-ms 0` now forces a full reparse and cache refresh.
+- Fixed workspace startup behavior: non-repo launches show **All workspaces** and do not reuse a stale last workspace filter.
 - Added `--scan-time-budget-ms` for bounded per-refresh parse time (`0` disables budget).
 - Added `--max-jsonl-line-kib` to cap parsed line size without hard-dropping large files.
 - Added cache DB schema migration (`v1 -> v2`) for offset/parser-state fields.
@@ -40,6 +42,9 @@ If started outside a git repo, usage is shown as **All workspaces**.
 If you start outside a git repo but pass `--cwd` (or `--project`) pointing inside a git repo,
 `comon` will auto-detect the git root from that path.
 
+If `--cwd` (or `--project`) points to a non-git directory, `comon` shows **All workspaces**
+even when launched from inside a git repo.
+
 ```bash
 # If installed (recommended):
 comon
@@ -64,7 +69,7 @@ Common flags:
 - `--max-session-files <n>`: max number of session files to scan per refresh (default from config)
 - `--max-jsonl-line-kib <n>`: max parsed JSONL line size in KiB (default from config)
 - `--scan-time-budget-ms <n>`: max parse time budget per refresh in ms (`0` disables budget)
-- `--full-scan`: scan all files under `CODEX_HOME/sessions`, including old months (ignores mtime cutoff)
+- `--full-scan`: scan all files under `CODEX_HOME/sessions`, including old months (ignores mtime cutoff and file/byte planning caps)
 - `--no-full-scan`: disable full scan for this run (overrides config)
 - `--scan-cache-max-entries <n>`: max entries kept in cache database (`comon.db`) (default from config)
 - `--rebuild-cache-on-start`: delete local scan cache DB files (`comon.db`, `comon.db-wal`, `comon.db-shm`) before first usage scan
@@ -102,7 +107,7 @@ comon --codex-home "C:\\Users\\You\\.codex" --cwd "C:\\Repos\\some-git-repo"
 Large-log recovery/tuning example:
 
 ```bash
-# One-time backfill for copied/old sessions:
+# One-time backfill for copied/old sessions (full reparse + cache refresh):
 comon --full-scan --scan-time-budget-ms 0
 
 # Normal usage with bounded incremental refresh:
@@ -293,7 +298,7 @@ CI also runs this check on each push and pull request via `.github/workflows/asc
 - comon stores local app state in `~/.comon/state.json` by default (or `$COMON_HOME`, or `--comon-home`).
 - comon stores scan cache in `~/.comon/comon.db` to avoid rereading unchanged session files.
 - Large session logs are parsed incrementally with persisted parser offsets in `comon.db`; unchanged files are reused from cache.
-- If historical days look incomplete after adding old session files, run once with `--full-scan --scan-time-budget-ms 0` to complete backfill.
+- If historical days look incomplete after adding old session files, run once with `--full-scan --scan-time-budget-ms 0` to force a full reparse and refresh cached summaries.
 - comon uses embedded SQLite (`rusqlite` with bundled SQLite); no system `sqlite3` CLI is required at runtime.
 - comon stores user-editable runtime settings in `~/.comon/config.json` by default.
 - Privacy: comon stores metadata (workspace paths, timestamps, token/run/time aggregates) and does not persist prompt/completion text.

README.md

@@ -574,9 +574,6 @@ fn load_persisted_ui_state(
             state.orientation = orientation;
         }
     }
-    if state.workspace_path.is_none() {
-        state.workspace_path = store.global.last_workspace_path.map(PathBuf::from);
-    }
 
     if let Some(workspace_path) = state.workspace_path.as_ref() {
         let workspace_key = workspace_path.to_string_lossy();
@@ -708,3 +705,63 @@ impl AppState {
         Some(crate::ui::format_updated_label(updated_at))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    static TEMP_ID_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+    fn make_temp_dir(prefix: &str) -> PathBuf {
+        let unique = format!(
+            "{}-{}-{}",
+            std::process::id(),
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .map(|duration| duration.as_nanos())
+                .unwrap_or(0),
+            TEMP_ID_COUNTER.fetch_add(1, Ordering::Relaxed)
+        );
+        let dir = std::env::temp_dir().join(format!("comon-app-{prefix}-{unique}"));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        dir
+    }
+
+    #[test]
+    fn load_persisted_ui_state_does_not_restore_last_workspace_without_hint() {
+        let comon_home = make_temp_dir("state-no-hint");
+        let mut store = StateStore::default();
+        store.global.last_workspace_path = Some("/tmp/old-workspace".to_string());
+        write_state_store(&comon_home, &store).expect("write state store");
+
+        let loaded = load_persisted_ui_state(&comon_home, None).expect("load persisted ui state");
+        assert_eq!(loaded.workspace_path, None);
+
+        let _ = std::fs::remove_dir_all(comon_home);
+    }
+
+    #[test]
+    fn load_persisted_ui_state_uses_workspace_hint_and_workspace_state() {
+        let comon_home = make_temp_dir("state-hint");
+        let workspace_path = PathBuf::from("/tmp/repo-workspace");
+        let mut store = StateStore::default();
+        store.global.last_workspace_path = Some("/tmp/other-workspace".to_string());
+        store.workspaces.insert(
+            workspace_path.to_string_lossy().into_owned(),
+            StoredWorkspaceState {
+                no_sessions_confirm_dismissed: true,
+                updated_at: 1,
+            },
+        );
+        write_state_store(&comon_home, &store).expect("write state store");
+
+        let loaded = load_persisted_ui_state(&comon_home, Some(workspace_path.as_path()))
+            .expect("load persisted ui state");
+        assert_eq!(loaded.workspace_path, Some(workspace_path));
+        assert!(loaded.no_sessions_confirm_dismissed);
+
+        let _ = std::fs::remove_dir_all(comon_home);
+    }
+}

src/app/mod.rs

@@ -78,6 +78,15 @@ fn detect_git_root(start: &std::path::Path) -> Option<PathBuf> {
     None
 }
 
+fn resolve_workspace_path(
+    launch_dir: &Path,
+    cwd_override: Option<&Path>,
+    project_override: Option<&Path>,
+) -> Option<PathBuf> {
+    let project_candidate = project_override.or(cwd_override).unwrap_or(launch_dir);
+    detect_git_root(project_candidate).map(|path| std::fs::canonicalize(&path).unwrap_or(path))
+}
+
 fn resolve_comon_home(override_home: Option<PathBuf>) -> Option<PathBuf> {
     if let Some(path) = override_home {
         return Some(path);
@@ -238,14 +247,12 @@ async fn main() -> Result<()> {
         .map(|p| validate_dir(&p, "--project"))
         .transpose()?;
 
-    let project_candidate = project_override
-        .as_deref()
-        .or(cwd_override.as_deref())
-        .unwrap_or(launch_dir.as_path());
-
     // Only treat something as a "project" if it is inside a git work tree.
-    let project =
-        detect_git_root(project_candidate).map(|p| std::fs::canonicalize(&p).unwrap_or(p));
+    let project = resolve_workspace_path(
+        launch_dir.as_path(),
+        cwd_override.as_deref(),
+        project_override.as_deref(),
+    );
 
     // `cwd` controls where `codex app-server` is launched.
     let cwd = cwd_override
@@ -333,3 +340,83 @@ async fn main() -> Result<()> {
 
     app::run(config).await
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use std::time::SystemTime;
+
+    static TEMP_ID_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+    fn make_temp_dir(prefix: &str) -> PathBuf {
+        let unique = format!(
+            "{}-{}-{}",
+            std::process::id(),
+            SystemTime::now()
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .map(|duration| duration.as_nanos())
+                .unwrap_or(0),
+            TEMP_ID_COUNTER.fetch_add(1, Ordering::Relaxed)
+        );
+        let dir = std::env::temp_dir().join(format!("comon-main-{prefix}-{unique}"));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        dir
+    }
+
+    fn make_git_repo(path: &Path) -> PathBuf {
+        std::fs::create_dir_all(path.join(".git")).expect("create .git directory");
+        std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf())
+    }
+
+    #[test]
+    fn resolve_workspace_path_uses_all_workspaces_outside_repo() {
+        let root = make_temp_dir("non-repo");
+        let workspace = resolve_workspace_path(root.as_path(), None, None);
+        assert!(workspace.is_none());
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn resolve_workspace_path_uses_launch_repo_when_no_overrides() {
+        let root = make_temp_dir("launch-repo");
+        let repo = root.join("repo");
+        std::fs::create_dir_all(&repo).expect("create repo dir");
+        let expected = make_git_repo(&repo);
+
+        let workspace = resolve_workspace_path(repo.as_path(), None, None);
+        assert_eq!(workspace, Some(expected));
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn resolve_workspace_path_prefers_project_override_repo() {
+        let root = make_temp_dir("project-override-repo");
+        let launch = root.join("launch");
+        std::fs::create_dir_all(&launch).expect("create launch dir");
+        let repo = root.join("repo");
+        let nested = repo.join("nested");
+        std::fs::create_dir_all(&nested).expect("create nested repo dir");
+        let expected = make_git_repo(&repo);
+
+        let workspace = resolve_workspace_path(launch.as_path(), None, Some(nested.as_path()));
+        assert_eq!(workspace, Some(expected));
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn resolve_workspace_path_uses_all_when_project_override_not_repo() {
+        let root = make_temp_dir("project-override-non-repo");
+        let launch_repo = root.join("launch-repo");
+        std::fs::create_dir_all(&launch_repo).expect("create launch repo dir");
+        let _ = make_git_repo(&launch_repo);
+        let non_repo = root.join("plain-dir");
+        std::fs::create_dir_all(&non_repo).expect("create non-repo dir");
+
+        let workspace =
+            resolve_workspace_path(launch_repo.as_path(), None, Some(non_repo.as_path()));
+        assert!(workspace.is_none());
+        let _ = std::fs::remove_dir_all(root);
+    }
+}