work-kit-cli 0.3.0 → 0.4.0

package/cli/src/config/workflow.ts

@@ -44,7 +44,7 @@ const WORKFLOW_MATRIX: Record<Classification, Record<string, InclusionRule>> = {
     "review/self-review": "YES", "review/security": "skip", "review/performance": "skip",
     "review/compliance": "skip", "review/handoff": "YES",
     "deploy/merge": "YES", "deploy/monitor": "optional", "deploy/remediate": "optional",
-    "wrap-up/summary": "YES",
+    "wrap-up/summary": "YES", "wrap-up/knowledge": "skip",
   },
   "small-change": {
     "plan/clarify": "YES", "plan/investigate": "skip", "plan/sketch": "skip", "plan/scope": "skip",
@@ -55,7 +55,7 @@ const WORKFLOW_MATRIX: Record<Classification, Record<string, InclusionRule>> = {
     "review/self-review": "YES", "review/security": "skip", "review/performance": "skip",
     "review/compliance": "skip", "review/handoff": "YES",
     "deploy/merge": "YES", "deploy/monitor": "optional", "deploy/remediate": "optional",
-    "wrap-up/summary": "YES",
+    "wrap-up/summary": "YES", "wrap-up/knowledge": "skip",
   },
   refactor: {
     "plan/clarify": "YES", "plan/investigate": "YES", "plan/sketch": "skip", "plan/scope": "skip",
@@ -66,7 +66,7 @@ const WORKFLOW_MATRIX: Record<Classification, Record<string, InclusionRule>> = {
     "review/self-review": "YES", "review/security": "skip", "review/performance": "YES",
     "review/compliance": "skip", "review/handoff": "YES",
     "deploy/merge": "YES", "deploy/monitor": "optional", "deploy/remediate": "optional",
-    "wrap-up/summary": "YES",
+    "wrap-up/summary": "YES", "wrap-up/knowledge": "YES",
   },
   feature: {
     "plan/clarify": "YES", "plan/investigate": "YES", "plan/sketch": "YES", "plan/scope": "YES",
@@ -77,7 +77,7 @@ const WORKFLOW_MATRIX: Record<Classification, Record<string, InclusionRule>> = {
     "review/self-review": "YES", "review/security": "YES", "review/performance": "skip",
     "review/compliance": "YES", "review/handoff": "YES",
     "deploy/merge": "YES", "deploy/monitor": "optional", "deploy/remediate": "optional",
-    "wrap-up/summary": "YES",
+    "wrap-up/summary": "YES", "wrap-up/knowledge": "YES",
   },
   "large-feature": {
     "plan/clarify": "YES", "plan/investigate": "YES", "plan/sketch": "YES", "plan/scope": "YES",
@@ -88,7 +88,7 @@ const WORKFLOW_MATRIX: Record<Classification, Record<string, InclusionRule>> = {
     "review/self-review": "YES", "review/security": "YES", "review/performance": "YES",
     "review/compliance": "YES", "review/handoff": "YES",
     "deploy/merge": "YES", "deploy/monitor": "optional", "deploy/remediate": "optional",
-    "wrap-up/summary": "YES",
+    "wrap-up/summary": "YES", "wrap-up/knowledge": "YES",
   },
 };
 

package/cli/src/index.ts

@@ -20,8 +20,11 @@ import { cancelCommand } from "./commands/cancel.js";
 import { pauseCommand } from "./commands/pause.js";
 import { resumeCommand } from "./commands/resume.js";
 import { reportCommand } from "./commands/report.js";
+import { learnCommand } from "./commands/learn.js";
+import { extractCommand } from "./commands/extract.js";
 import { bold, green, yellow, red } from "./utils/colors.js";
-import type { Classification, PhaseName } from "./state/schema.js";
+import type { Classification, ModelPolicy, PhaseName } from "./state/schema.js";
+import { isModelPolicy } from "./state/schema.js";
 
 import { createRequire } from "node:module";
 
@@ -44,14 +47,23 @@ program
   .requiredOption("--description <text>", "Description of the work")
   .option("--classification <type>", "Work classification (auto mode): bug-fix, small-change, refactor, feature, large-feature")
   .option("--gated", "Wait for user approval between phases (default: auto-proceed)")
+  .option("--model-policy <policy>", "Session model policy: auto, opus, sonnet, haiku, inherit (default: auto)")
   .option("--worktree-root <path>", "Override worktree root directory")
   .action((opts) => {
     try {
+      if (opts.modelPolicy !== undefined && !isModelPolicy(opts.modelPolicy)) {
+        console.error(JSON.stringify({
+          action: "error",
+          message: `Invalid --model-policy "${opts.modelPolicy}". Use one of: auto, opus, sonnet, haiku, inherit.`,
+        }));
+        process.exit(1);
+      }
       const result = initCommand({
         mode: opts.mode as "full" | "auto" | undefined,
         description: opts.description,
         classification: opts.classification as Classification | undefined,
         gated: opts.gated,
+        modelPolicy: opts.modelPolicy as ModelPolicy | undefined,
         worktreeRoot: opts.worktreeRoot,
       });
       console.log(JSON.stringify(result, null, 2));
@@ -244,8 +256,9 @@ program
   .command("observe")
   .description("Real-time dashboard of all active work items")
   .option("--repo <path>", "Main repository root")
+  .option("--all", "Observe every work-kit project found under ~/.claude/projects/")
   .action(async (opts) => {
-    await observeCommand({ mainRepo: opts.repo });
+    await observeCommand({ mainRepo: opts.repo, all: opts.all });
   });
 
 // ── uninstall ────────────────────────────────────────────────────────
@@ -296,11 +309,12 @@ program
 
 program
   .command("resume")
-  .description("Resume a paused work-kit session")
-  .option("--worktree-root <path>", "Override worktree root")
+  .description("Resume a paused work-kit session (lists paused sessions when no slug is given)")
+  .option("--worktree-root <path>", "Override worktree root (resume session at exact path)")
+  .option("--slug <slug>", "Resume the paused session with this slug")
   .action((opts) => {
     try {
-      const result = resumeCommand(opts.worktreeRoot);
+      const result = resumeCommand({ worktreeRoot: opts.worktreeRoot, slug: opts.slug });
       console.log(JSON.stringify(result, null, 2));
       process.exit(result.action === "error" ? 1 : 0);
     } catch (e: any) {
@@ -343,4 +357,55 @@ program
     }
   });
 
+// ── learn ───────────────────────────────────────────────────────────
+
+program
+  .command("learn")
+  .description("Append a knowledge entry (lesson/convention/risk/workflow) to .work-kit-knowledge/")
+  .requiredOption("--type <type>", "Entry type: lesson, convention, risk, workflow")
+  .requiredOption("--text <text>", "Free-form text. Secrets are auto-redacted at write time.")
+  .option("--scope <glob>", "Optional path glob (stored, not yet used for filtering)")
+  .option("--phase <phase>", "Override session phase auto-fill")
+  .option("--step <step>", "Override session step auto-fill")
+  .option("--source <source>", "Override entry source label", "explicit-cli")
+  .option("--worktree-root <path>", "Override worktree root")
+  .action((opts) => {
+    try {
+      const result = learnCommand({
+        type: opts.type,
+        text: opts.text,
+        scope: opts.scope,
+        phase: opts.phase,
+        step: opts.step,
+        source: opts.source,
+        worktreeRoot: opts.worktreeRoot,
+      });
+      console.log(JSON.stringify(result, null, 2));
+      if (result.action === "error") process.exit(1);
+      if (result.redacted) {
+        console.error(yellow(`! Redacted ${result.redactedKinds?.length ?? 0} secret(s) before writing.`));
+      }
+    } catch (e: any) {
+      console.error(JSON.stringify({ action: "error", message: e.message }));
+      process.exit(1);
+    }
+  });
+
+// ── extract ─────────────────────────────────────────────────────────
+
+program
+  .command("extract")
+  .description("Parse current session's state.md + tracker.json and append entries to knowledge files")
+  .option("--worktree-root <path>", "Override worktree root")
+  .action((opts) => {
+    try {
+      const result = extractCommand({ worktreeRoot: opts.worktreeRoot });
+      console.log(JSON.stringify(result, null, 2));
+      if (result.action === "error") process.exit(1);
+    } catch (e: any) {
+      console.error(JSON.stringify({ action: "error", message: e.message }));
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/cli/src/observer/data.ts

@@ -1,9 +1,10 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { execFileSync } from "node:child_process";
 import type { WorkKitState, PhaseName } from "../state/schema.js";
 import { PHASE_NAMES, STEPS_BY_PHASE, MODE_AUTO } from "../state/schema.js";
-import { readState, stateExists, STATE_DIR, AWAITING_INPUT_MARKER_FILE, IDLE_MARKER_FILE } from "../state/store.js";
+import { readState, stateExists, STATE_DIR, AWAITING_INPUT_MARKER_FILE, IDLE_MARKER_FILE, gitMainRepoRoot } from "../state/store.js";
 import { TRACKER_DIR, INDEX_FILE } from "../config/constants.js";
 
 const AWAITING_INPUT_MARKER = path.join(STATE_DIR, AWAITING_INPUT_MARKER_FILE);
@@ -11,8 +12,14 @@ const IDLE_MARKER = path.join(STATE_DIR, IDLE_MARKER_FILE);
 
 // ── View Types ─────────────────────────────────────────────────────
 
+export interface WorktreeEntry {
+  root: string;     // main repo root that owns this worktree
+  worktree: string; // worktree path (may equal root)
+}
+
 export interface WorkItemView {
   slug: string;
+  repoName: string;
   branch: string;
   mode: string;
   classification?: string;
@@ -37,6 +44,7 @@ export interface WorkItemView {
 
 export interface CompletedItemView {
   slug: string;
+  repoName: string;
   pr?: string;
   completedAt: string;
   phases: string;
@@ -80,9 +88,97 @@ export function discoverWorktrees(mainRepoRoot: string): string[] {
   return worktrees;
 }
 
+// ── Discover All Work-Kit Projects on the System ───────────────────
+//
+// Scans ~/.claude/projects/ for sessions, reads `cwd` from session
+// jsonl files, resolves each to a git toplevel, and keeps only those
+// roots that have at least one work-kit-tracked worktree.
+
+const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), ".claude", "projects");
+
+function extractCwdFromJsonl(filePath: string): string | null {
+  let fd: number | null = null;
+  try {
+    const buf = Buffer.alloc(16 * 1024);
+    fd = fs.openSync(filePath, "r");
+    const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+    const content = buf.subarray(0, bytesRead).toString("utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (!line.includes('"cwd"')) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (typeof obj.cwd === "string" && obj.cwd.length > 0) return obj.cwd;
+      } catch {
+        // Likely a truncated final line — skip
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try { fs.closeSync(fd); } catch { /* ignore */ }
+    }
+  }
+}
+
+export function discoverWorkKitProjects(): string[] {
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(CLAUDE_PROJECTS_DIR);
+  } catch {
+    return [];
+  }
+
+  const cwds = new Set<string>();
+  for (const entry of entries) {
+    const projDir = path.join(CLAUDE_PROJECTS_DIR, entry);
+    let files: string[];
+    try {
+      files = fs.readdirSync(projDir).filter(f => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    if (files.length === 0) continue;
+
+    // Single-pass scan for the most-recently-modified jsonl — avoids
+    // re-statting in a sort comparator (which is O(N log N) stats).
+    let newestFile: string | null = null;
+    let newestMtime = -Infinity;
+    for (const f of files) {
+      try {
+        const m = fs.statSync(path.join(projDir, f)).mtimeMs;
+        if (m > newestMtime) {
+          newestMtime = m;
+          newestFile = f;
+        }
+      } catch { /* ignore */ }
+    }
+    if (!newestFile) continue;
+
+    const cwd = extractCwdFromJsonl(path.join(projDir, newestFile));
+    if (cwd) cwds.add(cwd);
+  }
+
+  // Resolve each cwd to its main repo root (works whether the session
+  // was run from the main repo or from inside a worktree) and keep
+  // only roots that actually have work-kit setup.
+  const roots = new Set<string>();
+  for (const cwd of cwds) {
+    const mainRoot = gitMainRepoRoot(cwd);
+    if (!mainRoot || roots.has(mainRoot)) continue;
+    if (discoverWorktrees(mainRoot).length > 0) {
+      roots.add(mainRoot);
+    }
+  }
+
+  return Array.from(roots);
+}
+
 // ── Collect Single Work Item ───────────────────────────────────────
 
-export function collectWorkItem(worktreeRoot: string): WorkItemView | null {
+export function collectWorkItem(worktreeRoot: string, mainRepoRoot?: string): WorkItemView | null {
   if (!stateExists(worktreeRoot)) return null;
 
   let state: WorkKitState;
@@ -182,8 +278,10 @@ export function collectWorkItem(worktreeRoot: string): WorkItemView | null {
       : undefined,
   };
 
+  const repoRoot = mainRepoRoot ?? worktreeRoot;
   return {
     slug: state.slug,
+    repoName: path.basename(repoRoot),
     branch: state.branch,
     mode: state.mode,
     classification: state.classification,
@@ -245,6 +343,7 @@ export function collectCompletedItems(mainRepoRoot: string): CompletedItemView[]
     if (col1 === "Date" || col1.startsWith("-")) continue;
     items.push({
       slug: match[2].trim(),
+      repoName: path.basename(mainRepoRoot),
       pr: match[3].trim() !== "n/a" ? match[3].trim() : undefined,
       completedAt: col1,
       phases: match[5].trim(),
@@ -256,13 +355,29 @@ export function collectCompletedItems(mainRepoRoot: string): CompletedItemView[]
 
 // ── Collect All Dashboard Data ─────────────────────────────────────
 
-export function collectDashboardData(mainRepoRoot: string, cachedWorktrees?: string[]): DashboardData {
-  const worktrees = cachedWorktrees ?? discoverWorktrees(mainRepoRoot);
+export function collectDashboardData(
+  mainRepoRoots: string[],
+  cachedEntries?: WorktreeEntry[]
+): DashboardData {
+  let entries: WorktreeEntry[];
+  if (cachedEntries) {
+    entries = cachedEntries;
+  } else {
+    entries = [];
+    const seen = new Set<string>();
+    for (const root of mainRepoRoots) {
+      for (const wt of discoverWorktrees(root)) {
+        if (seen.has(wt)) continue;
+        seen.add(wt);
+        entries.push({ root, worktree: wt });
+      }
+    }
+  }
   const activeItems: WorkItemView[] = [];
   const completedFromWorktrees: CompletedItemView[] = [];
 
-  for (const wt of worktrees) {
-    const item = collectWorkItem(wt);
+  for (const entry of entries) {
+    const item = collectWorkItem(entry.worktree, entry.root);
     if (!item) continue;
     if (item.status === "completed") {
       const phaseNames = item.phases
@@ -271,6 +386,7 @@ export function collectDashboardData(mainRepoRoot: string, cachedWorktrees?: str
         .join("→");
       completedFromWorktrees.push({
         slug: item.slug,
+        repoName: item.repoName,
         completedAt: item.startedAt,
         phases: phaseNames,
       });
@@ -288,13 +404,20 @@ export function collectDashboardData(mainRepoRoot: string, cachedWorktrees?: str
     return new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime();
   });
 
-  // Merge completed items from worktrees and index file, dedup by slug
+  // Merge completed items from worktrees and index files, dedup by slug
   const activeSlugs = new Set(activeItems.map(i => i.slug));
-  const indexItems = collectCompletedItems(mainRepoRoot);
+  const indexItems: CompletedItemView[] = [];
+  for (const root of mainRepoRoots) {
+    indexItems.push(...collectCompletedItems(root));
+  }
   const seen = new Set(completedFromWorktrees.map(i => i.slug));
   const completedItems = [
     ...completedFromWorktrees.filter(i => !activeSlugs.has(i.slug)),
-    ...indexItems.filter(i => !seen.has(i.slug) && !activeSlugs.has(i.slug)),
+    ...indexItems.filter(i => {
+      if (activeSlugs.has(i.slug) || seen.has(i.slug)) return false;
+      seen.add(i.slug);
+      return true;
+    }),
   ];
 
   return {

package/cli/src/observer/renderer.ts

@@ -1,7 +1,8 @@
+import * as path from "node:path";
 import {
   bold, dim, green, yellow, red, cyan, magenta,
-  bgYellow, bgCyan, bgRed, bgMagenta, bgGreen, bgBlue,
-  boldCyan, boldGreen, boldMagenta,
+  bgYellow, bgCyan, bgRed, bgMagenta, bgGreen, bgBlue, bgDim,
+  boldCyan, boldGreen, boldMagenta, boldRed,
 } from "../utils/colors.js";
 import { formatDurationMs, formatDurationSince } from "../utils/time.js";
 import { MODE_FULL } from "../state/schema.js";
@@ -376,21 +377,14 @@ function renderStepBox(
 function renderWorkItem(item: WorkItemView, innerWidth: number, tick: number): string[] {
   const lines: string[] = [];
 
-  // Line 1: status dot + bold slug + elapsed time (right)
-  const slugText = `${statusDot(item.status)} ${bold(item.slug)}`;
-  const elapsed = formatTimeAgo(item.startedAt);
-  const elapsedText = dim(`⏱ ${elapsed}`);
-  const slugLen = stripAnsi(slugText).length;
-  const elapsedLen = stripAnsi(elapsedText).length;
-  const gap1 = Math.max(2, innerWidth - slugLen - elapsedLen);
-  lines.push(slugText + " ".repeat(gap1) + elapsedText);
+  const repoPrefix = item.repoName ? dim(`${item.repoName} › `) : "";
+  const titleText = `${statusDot(item.status)} ${repoPrefix}${bold(item.slug)}`;
 
-  // Line 2: mode badge + gated badge + classification + blocking state
   let badges = renderModeBadge(item.mode);
-  if (item.gated) badges += " " + renderGatedBadge();
-  if (item.status === "paused") badges += " " + bgYellow(" PAUSED ");
-  if (item.status === "failed") badges += " " + bgRed(" FAILED ");
   if (item.classification) badges += " " + renderClassificationBadge(item.classification);
+  if (item.status === "paused") badges += " " + bgDim(" ⏸ PAUSED ");
+  if (item.status === "failed") badges += " " + boldRed("✗ FAILED");
+  if (item.gated) badges += " " + renderGatedBadge();
   if (item.awaitingInput) {
     // Loud: agent definitely blocked on a permission prompt or AskUserQuestion
     const arrow = tick % 2 === 0 ? "▶" : "▷";
@@ -399,20 +393,26 @@ function renderWorkItem(item: WorkItemView, innerWidth: number, tick: number): s
     // Soft: turn ended but step not complete — probably asking a question in prose
     badges += " " + dim("⏸ idle");
   }
-  lines.push("  " + badges);
+
+  const leftLine = `${titleText}  ${badges}`;
+  const elapsed = formatTimeAgo(item.startedAt);
+  const elapsedText = dim(`⏱ ${elapsed}`);
+  const leftLen = stripAnsi(leftLine).length;
+  const elapsedLen = stripAnsi(elapsedText).length;
+  const gap1 = Math.max(2, innerWidth - leftLen - elapsedLen);
+  lines.push(leftLine + " ".repeat(gap1) + elapsedText);
   lines.push("");
 
-  // Line 3: progress bar with animated head
-  const barMaxWidth = Math.max(20, Math.min(40, innerWidth - 20));
-  lines.push("  " + renderProgressBar(
-    item.progress.completed,
-    item.progress.total,
-    item.progress.percent,
-    barMaxWidth,
-    tick
-  ));
-
-  // Line 4-5: phase pipeline with connectors, spinner, and timing row
+  // TODO(progress-bar): re-enable after redesign — hidden per user request
+  // const barMaxWidth = Math.max(20, Math.min(40, innerWidth - 20));
+  // lines.push("  " + renderProgressBar(
+  //   item.progress.completed,
+  //   item.progress.total,
+  //   item.progress.percent,
+  //   barMaxWidth,
+  //   tick
+  // ));
+
   const pipelineLines = renderPhasePipeline(item.phases, tick, item.awaitingInput, item.currentPhase);
   for (const pl of pipelineLines) {
     lines.push("  " + pl);
@@ -439,14 +439,9 @@ function renderWorkItem(item: WorkItemView, innerWidth: number, tick: number): s
     lines.push(loopStr);
   }
 
-  // Worktree path, then branch beneath it
+  // Worktree (basename only) and branch
   if (item.worktreePath) {
-    let displayPath = item.worktreePath;
-    const maxPathLen = innerWidth - 8;
-    if (displayPath.length > maxPathLen) {
-      displayPath = "…" + displayPath.slice(displayPath.length - maxPathLen + 1);
-    }
-    lines.push("  " + dim("⌂ " + displayPath));
+    lines.push("  " + dim("worktree: " + path.basename(item.worktreePath)));
   }
   lines.push("  " + dim("⎇ " + item.branch));
 
@@ -456,28 +451,31 @@ function renderWorkItem(item: WorkItemView, innerWidth: number, tick: number): s
 // ── Render Completed Item ───────────────────────────────────────────
 
 interface CompletedColumnWidths {
+  repo: number;
   slug: number;
   pr: number;
   date: number;
 }
 
 function computeCompletedWidths(items: CompletedItemView[]): CompletedColumnWidths {
-  let slug = 4, pr = 2, date = 4;
+  let repo = 4, slug = 4, pr = 2, date = 4;
   for (const item of items) {
+    repo = Math.max(repo, (item.repoName || "").length);
     slug = Math.max(slug, item.slug.length);
     pr = Math.max(pr, (item.pr || "—").length);
     date = Math.max(date, (item.completedAt || "").length);
   }
-  return { slug, pr, date };
+  return { repo, slug, pr, date };
 }
 
 function renderCompletedItem(item: CompletedItemView, cols: CompletedColumnWidths): string {
   const check = green("✓");
+  const repo = padRight(dim(item.repoName || ""), cols.repo);
   const slug = padRight(item.slug, cols.slug);
   const pr = padRight(dim(item.pr || "—"), cols.pr);
   const date = padRight(dim(item.completedAt || ""), cols.date);
   const phases = item.phases ? dim(item.phases) : "";
-  return `${check} ${slug}  ${pr}  ${date}  ${phases}`;
+  return `${check} ${repo}  ${slug}  ${pr}  ${date}  ${phases}`;
 }
 
 // ── Main Render Function ────────────────────────────────────────────

package/cli/src/observer/watcher.ts

@@ -1,21 +1,21 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { discoverWorktrees } from "./data.js";
+import { discoverWorktrees, type WorktreeEntry } from "./data.js";
 
 export interface WatcherHandle {
   stop: () => void;
-  getWorktrees: () => string[];
+  getWorktrees: () => WorktreeEntry[];
 }
 
 export function startWatching(
-  mainRepoRoot: string,
+  mainRepoRoots: string[],
   onUpdate: () => void
 ): WatcherHandle {
   const watchers = new Map<string, fs.FSWatcher>();
   let debounceTimer: ReturnType<typeof setTimeout> | null = null;
   let pollTimer: ReturnType<typeof setInterval> | null = null;
   let stopped = false;
-  let cachedWorktrees: string[] = [];
+  let cachedEntries: WorktreeEntry[] = [];
 
   function debouncedUpdate(): void {
     if (stopped) return;
@@ -60,19 +60,29 @@ export function startWatching(
 
   function refreshWorktrees(): void {
     if (stopped) return;
-    const current = discoverWorktrees(mainRepoRoot);
-    const currentSet = new Set(current);
+    const seen = new Set<string>();
+    const current: WorktreeEntry[] = [];
+    for (const root of mainRepoRoots) {
+      for (const wt of discoverWorktrees(root)) {
+        if (seen.has(wt)) continue;
+        seen.add(wt);
+        current.push({ root, worktree: wt });
+      }
+    }
 
-    // Only trigger update if worktree list actually changed
-    const changed = current.length !== cachedWorktrees.length
-      || current.some((wt, i) => wt !== cachedWorktrees[i]);
+    // Only trigger update if the entry list actually changed. Compare
+    // both fields so a worktree path reused under a different root is
+    // detected as a real change.
+    const changed = current.length !== cachedEntries.length
+      || current.some((e, i) =>
+        e.worktree !== cachedEntries[i].worktree || e.root !== cachedEntries[i].root);
 
-    for (const wt of current) {
-      watchStateFile(wt);
+    for (const e of current) {
+      watchStateFile(e.worktree);
     }
-    unwatchRemoved(currentSet);
+    unwatchRemoved(seen);
 
-    cachedWorktrees = current;
+    cachedEntries = current;
 
     if (changed) {
       debouncedUpdate();
@@ -82,10 +92,12 @@ export function startWatching(
   // Initial setup
   refreshWorktrees();
 
-  // Poll for new/removed worktrees every 5 seconds
+  // Poll for new/removed worktrees. Each tick spawns one `git worktree
+  // list` per root, so back off when watching many repos under --all.
+  const pollIntervalMs = mainRepoRoots.length > 1 ? 30_000 : 5_000;
   pollTimer = setInterval(() => {
     if (!stopped) refreshWorktrees();
-  }, 5000);
+  }, pollIntervalMs);
 
   return {
     stop() {
@@ -98,7 +110,7 @@ export function startWatching(
       watchers.clear();
     },
     getWorktrees() {
-      return cachedWorktrees;
+      return cachedEntries;
     },
   };
 }