feat(panel): missing-repo detection + hide action (v0.1.1 prep 6/6)

Closes out the v0.1.1 discovery overhaul. Cached repos that disappear
from disk now grey out instead of silently returning empty timelines,
and a one-click ✕ lets the user tombstone a row so it doesn't keep
showing up.

Backend:

* discovery_orchestrator::verify_existing_repos — runs at the head of
  each pipeline pass. Walks all cached rows whose user_state isn't
  'removed', flips status to 'missing' for paths that don't exist on
  disk, restores 'active' (clears missing_since) for paths that came
  back. Cheap: just is_dir() per row, no git2 here — full
  re-validation happens via the regular tier flow when a candidate
  comes through.
* discovery_orchestrator::hide_repo — sets user_state='removed' AND
  inserts into discovery_tombstones so the next prewarm doesn't auto-
  rediscover. Manual add (commit 5) already removes the tombstone, so
  the user can always bring a hidden repo back.
* cache::list_repos filters out user_state='removed' (tombstoned) rows
  and now returns the status column so the UI can grey out 'missing'.
* commands::hide_repo Tauri wrapper.
* New event `timeline://repo-status` { canonicalPath, status } emitted
  on every transition (active → missing, missing → active, * → removed)
  so the frontend can patch state without a full reload.

Frontend:

* `Repo.status: "active" | "missing" | "removed"` added to types.
* `hideRepo` in lib/ipc.ts.
* RepoChip:
  - Missing rows render with 0.45 opacity name+path plus a small
    "· missing" suffix tag.
  - Pin star (★) is swapped for a hide button (✕) on missing rows —
    can't pin something that isn't there.
  - Tooltip on missing rows explains "moved or deleted on disk; drop
    the new path to relink, or click ✕ to hide".
* App.tsx:
  - Listens to timeline://repo-status; patches allRepos in place
    (greys / restores / drops the row) and adjusts discoveredCount on
    removal. No full re-list_repos() round-trip needed.
  - onHide handler does an optimistic local remove, then calls
    hideRepo; on backend failure, falls back to a fresh list_repos()
    so the UI re-syncs with truth.
  - onRepoDiscovered now stamps status: "active" on the inserted Repo
    (matching the new type shape).

CSS:
  - .chip-item-row.missing greys name + path.
  - .chip-item-missing-tag in muted red.
  - .chip-hide as the per-row hide button (transparent until hover).
  - Dark-mode pairs for all three.

Rust tests 34/34. TS type-check clean. Completes the v0.1.1
discovery + drop/paste + lifecycle arc end-to-end — ready to tag.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: var-gg

src-tauri/src/cache.rs

@@ -9,9 +9,19 @@ use tauri::{AppHandle, Manager};
 use crate::git::CommitSummary;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct Repo {
     pub path: String,
     pub name: String,
+    /// Lifecycle status: "active" | "missing" | "removed". Frontend
+    /// greys out "missing" rows and filters out "removed". Defaults to
+    /// "active" for old rows that predate the lifecycle migration.
+    #[serde(default = "default_status")]
+    pub status: String,
+}
+
+fn default_status() -> String {
+    "active".to_string()
 }
 
 /// Default ceiling for the diffs blob store. Older entries are evicted in
@@ -238,12 +248,23 @@ pub fn open(app: &AppHandle) -> Result<Connection> {
 // ----- repos -----
 
 pub fn list_repos(conn: &Connection) -> Result<Vec<Repo>> {
-    let mut stmt = conn.prepare("SELECT path, name FROM repos ORDER BY name COLLATE NOCASE")?;
+    // Filter out user-removed (tombstoned) rows so a deleted repo
+    // doesn't reappear in the chip dropdown. Missing rows DO come
+    // through — the UI greys them out so the user can decide.
+    let mut stmt = conn.prepare(
+        r#"
+        SELECT path, name, status
+        FROM repos
+        WHERE user_state != 'removed'
+        ORDER BY name COLLATE NOCASE
+        "#,
+    )?;
     let rows = stmt
         .query_map([], |row| {
             Ok(Repo {
                 path: row.get(0)?,
                 name: row.get(1)?,
+                status: row.get(2)?,
             })
         })?
         .collect::<Result<Vec<_>, _>>()?;

src-tauri/src/commands.rs

@@ -177,6 +177,23 @@ pub async fn explicit_add_repo(
     .map_err(|e| e.to_string())?
 }
 
+/// Hide a repo from the panel and prevent auto-rediscovery. Tombstoned;
+/// the user can bring it back with explicit_add_repo. Used by the
+/// "hide" affordance on missing-status rows in the RepoChip.
+#[tauri::command]
+pub async fn hide_repo(
+    app: AppHandle,
+    canonical_path: String,
+) -> Result<(), String> {
+    let app2 = app.clone();
+    tauri::async_runtime::spawn_blocking(move || {
+        discovery_orchestrator::hide_repo(&app2, &canonical_path)
+            .map_err(|e| e.to_string())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
 #[tauri::command]
 pub async fn changed_files(
     repo_path: String,
@@ -468,6 +485,7 @@ pub async fn discover_repos(app: AppHandle) -> Result<usize, String> {
                 let repo = cache::Repo {
                     path: path_str.clone(),
                     name: name.clone(),
+                    status: "active".to_string(),
                 };
                 found.push(repo.clone());
                 let _ = app.emit(

src-tauri/src/discovery_orchestrator.rs

@@ -50,6 +50,16 @@ pub struct ScanProgressPayload {
     pub errors: usize,
 }
 
+/// Repo lifecycle transition (active → missing or vice versa). Frontend
+/// uses this to grey out a row that moved/disappeared on disk, or to
+/// restore a row that came back.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepoStatusPayload {
+    pub canonical_path: String,
+    pub status: &'static str,
+}
+
 /// Meta-table key that tracks whether the first-launch full scan has
 /// already completed. Lives in cache.db (not settings.json) so wiping
 /// the cache correctly re-triggers the full scan.
@@ -223,6 +233,99 @@ async fn run_discovery_async(app: AppHandle, cancel: CancellationToken) -> Resul
     }
 }
 
+/// Walk active rows, check path existence, flip status accordingly.
+/// Emits one `timeline://repo-status` event per row that changed state
+/// so the frontend can grey out / restore individual rows without a
+/// full reload. Read-only: never deletes a row even if it's been gone
+/// forever — that's the user's call via hide/relink.
+fn verify_existing_repos(app: &AppHandle, conn: &mut Connection) -> Result<()> {
+    let mut stmt = conn.prepare(
+        r#"
+        SELECT canonical_path, status
+        FROM repos
+        WHERE user_state NOT IN ('removed')
+          AND status IN ('active', 'missing')
+        "#,
+    )?;
+    let rows: Vec<(String, String)> = stmt
+        .query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)))?
+        .collect::<Result<Vec<_>, _>>()?;
+    drop(stmt);
+
+    let now = unix_now();
+    let mut transitions: Vec<(String, &'static str)> = Vec::new();
+    let tx = conn.transaction()?;
+    for (path, status) in rows {
+        let exists = Path::new(&path).is_dir();
+        let new_status: &'static str = if exists { "active" } else { "missing" };
+        if status == new_status {
+            continue;
+        }
+        if new_status == "missing" {
+            tx.execute(
+                "UPDATE repos SET status = 'missing', missing_since = ?1 WHERE canonical_path = ?2",
+                params![now, &path],
+            )?;
+        } else {
+            tx.execute(
+                "UPDATE repos SET status = 'active', missing_since = NULL, last_verified_at = ?1 WHERE canonical_path = ?2",
+                params![now, &path],
+            )?;
+        }
+        transitions.push((path, new_status));
+    }
+    tx.commit()?;
+
+    for (path, status) in transitions {
+        let _ = app.emit(
+            "timeline://repo-status",
+            &RepoStatusPayload {
+                canonical_path: path,
+                status,
+            },
+        );
+    }
+    Ok(())
+}
+
+/// Mark a repo as user-hidden. Sets user_state='removed' (so UI filters
+/// it out) and adds a tombstone (so future discovery passes don't auto-
+/// rediscover it). Returns the canonical path that was hidden, or an
+/// error if no such repo exists in cache.
+pub fn hide_repo(app: &AppHandle, canonical_path: &str) -> Result<()> {
+    let mut conn = cache::open(app)?;
+    let now = unix_now();
+    let tx = conn.transaction()?;
+    let updated = tx.execute(
+        "UPDATE repos SET user_state = 'removed', removed_at = ?1 WHERE canonical_path = ?2",
+        params![now, canonical_path],
+    )?;
+    if updated == 0 {
+        return Err(anyhow::anyhow!("no such repo: {canonical_path}"));
+    }
+    tx.execute(
+        r#"
+        INSERT INTO discovery_tombstones (canonical_path, removed_at, reason)
+        VALUES (?1, ?2, 'user_hide')
+        ON CONFLICT(canonical_path) DO UPDATE SET
+            removed_at = excluded.removed_at,
+            reason = excluded.reason
+        "#,
+        params![canonical_path, now],
+    )?;
+    tx.commit()?;
+
+    let _ = app.emit(
+        "timeline://repo-status",
+        &RepoStatusPayload {
+            canonical_path: canonical_path.to_string(),
+            status: "removed",
+        },
+    );
+    let _ = append_scan_log(app, &format!("{now} user_hide: {canonical_path}"));
+    Ok(())
+}
+
 /// Update the tray tooltip to reflect the current scan state. Best-
 /// effort: tray might not exist yet or the tooltip API might fail on
 /// some Linux distros — log to stderr if so but don't propagate.
@@ -252,6 +355,16 @@ fn run_pipeline_sync(
     cancel: CancellationToken,
     is_first_run: bool,
 ) -> Result<(usize, usize)> {
+    // Verification sweep: check active cached repos for path existence
+    // BEFORE doing new discovery. Repos that disappeared on disk get
+    // marked 'missing' so the UI can grey them out. Repos that came
+    // back from 'missing' get restored. Path existence is cheap (no
+    // git2 here) — full re-validation happens when a candidate comes
+    // through the regular tier flow.
+    if let Err(e) = verify_existing_repos(app, conn) {
+        eprintln!("orchestrator verification sweep failed: {e:#}");
+    }
+
     let mut candidates: Vec<Candidate> = Vec::new();
 
     // Tier 1: VS Code-family recents (VS Code / Insiders / Cursor / Windsurf).

src-tauri/src/lib.rs

@@ -257,6 +257,7 @@ pub fn run() {
             commands::list_branches,
             commands::current_upstream_status,
             commands::explicit_add_repo,
+            commands::hide_repo,
             commands::repo_commits,
             commands::changed_files,
             commands::file_diff,

src/App.tsx

@@ -12,6 +12,7 @@ import {
   dismissPanel,
   explicitAddRepo,
   getPinnedRepos,
+  hideRepo,
   listBranches,
   listRecentCommitsCached,
   listRepos,
@@ -166,6 +167,7 @@ function App() {
     let unProgress: UnlistenFn | undefined;
     let unDiscovered: UnlistenFn | undefined;
     let unFill: UnlistenFn | undefined;
+    let unStatus: UnlistenFn | undefined;
 
     (async () => {
       try {
@@ -204,7 +206,13 @@ function App() {
         if (!mounted) return;
         setAllRepos((prev) => {
           if (prev.some((r) => r.path === p.path)) return prev;
-          const next = [...prev, { path: p.path, name: p.name }];
+          // Orchestrator only emits for validated repos, so status='active'
+          // is correct on insert. Status transitions later flip this via
+          // the repo-status listener.
+          const next = [
+            ...prev,
+            { path: p.path, name: p.name, status: "active" as const },
+          ];
           // Keep stable display order to avoid jitter in the chip dropdown.
           next.sort((a, b) => a.name.localeCompare(b.name));
           return next;
@@ -218,6 +226,35 @@ function App() {
         } catch {}
       });
 
+      // Repo status transitions (active ↔ missing ↔ removed) — backend
+      // emits one event per row that changed. Patch allRepos in place
+      // so the RepoChip row greys out / restores / drops without a
+      // full reload.
+      const { listen } = await import("@tauri-apps/api/event");
+      unStatus = await listen<{ canonicalPath: string; status: string }>(
+        "timeline://repo-status",
+        (e) => {
+          if (!mounted) return;
+          const { canonicalPath, status } = e.payload;
+          if (status === "removed") {
+            setAllRepos((prev) => prev.filter((r) => r.path !== canonicalPath));
+            setDiscoveredCount((prev) =>
+              prev != null ? Math.max(0, prev - 1) : prev,
+            );
+            return;
+          }
+          if (status === "active" || status === "missing") {
+            setAllRepos((prev) =>
+              prev.map((r) =>
+                r.path === canonicalPath
+                  ? { ...r, status: status as "active" | "missing" }
+                  : r,
+              ),
+            );
+          }
+        },
+      );
+
       unFill = await onTimelineRepoFill((p) => {
         if (!mounted) return;
         // Only merge into the All-repos timeline; ignore while in single mode.
@@ -243,6 +280,7 @@ function App() {
       unProgress?.();
       unDiscovered?.();
       unFill?.();
+      unStatus?.();
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
@@ -529,6 +567,19 @@ function App() {
             selectedPath={selectedRepoPath}
             onSelect={setSelectedRepoPath}
             onTogglePin={togglePin}
+            onHide={(path) => {
+              // Optimistic: drop from local list immediately; backend
+              // will tombstone so it stays gone across restarts.
+              setAllRepos((prev) => prev.filter((r) => r.path !== path));
+              setDiscoveredCount((prev) =>
+                prev != null ? Math.max(0, prev - 1) : prev,
+              );
+              void hideRepo(path).catch(() => {
+                // If the backend rejects (race / already gone), fall
+                // back to re-fetching the list so UI matches truth.
+                void listRepos().then((r) => setAllRepos(r));
+              });
+            }}
             totalRepoCount={repoCount}
           />
           {singleMode && (