squadrant 0.16.4 → 0.16.6

package/dist/index.js

@@ -1313,6 +1313,9 @@ function stampAttempt(rec, patch, now) {
     attempts.push(last);
   return { ...rec, attempts };
 }
+function isStickyAttention(state) {
+  return state === "blocked" || state === "review";
+}
 function nextPendingTool(current, ev, now) {
   if (ev.note === "agent.hook.PreToolUse")
     return { name: ev.tool ?? "tool", since: now };
@@ -1320,6 +1323,11 @@ function nextPendingTool(current, ev, now) {
     return void 0;
   return current;
 }
+function nextPendingMonitor(current, ev, now) {
+  if (ev.note === "agent.hook.PreToolUse" && ev.tool === "Monitor")
+    return { since: now };
+  return current;
+}
 function reduce(rec, ev, now) {
   if (ev.type === "task.reopened") {
     return { ...rec, state: "working", question: void 0, error: void 0, lastHeartbeat: now, lastEvent: ev.type };
@@ -1336,20 +1344,23 @@ function reduce(rec, ev, now) {
         sessionId: ev.sessionId ?? rec.sessionId,
         question: void 0,
         // resuming after a blocked→reply clears the question
-        pendingTool: void 0
+        pendingTool: void 0,
         // #354: a new turn closes any prior tool window
+        pendingMonitor: void 0
+        // #594a: same reset — a new turn moots any prior watch
       };
     case "task.progress": {
       const pendingTool = nextPendingTool(rec.pendingTool, ev, now);
-      if (rec.state === "blocked")
-        return { ...rec, lastHeartbeat: now, lastEvent: ev.type, pendingTool };
-      const b = { ...base, pendingTool };
+      const pendingMonitor = nextPendingMonitor(rec.pendingMonitor, ev, now);
+      if (isStickyAttention(rec.state))
+        return { ...rec, lastHeartbeat: now, lastEvent: ev.type, pendingTool, pendingMonitor };
+      const b = { ...base, pendingTool, pendingMonitor };
       if (rec.state === "awaiting-input" || rec.state === "stalled")
         return { ...stampAttempt(b, {}, now), state: "working" };
       return stampAttempt(b, {}, now);
     }
     case "heartbeat":
-      if (rec.state === "blocked")
+      if (isStickyAttention(rec.state))
         return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
       if (rec.state === "awaiting-input")
         return { ...base, state: "working" };
@@ -1357,8 +1368,13 @@ function reduce(rec, ev, now) {
     case "task.blocked":
       if (rec.state === "blocked")
         return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
-      return { ...base, state: "blocked", question: ev.question, pendingTool: void 0 };
+      return { ...base, state: "blocked", question: ev.question, pendingTool: void 0, pendingMonitor: void 0 };
+    case "task.review":
+      return { ...base, state: "review", reviewNote: ev.message, pendingTool: void 0, pendingMonitor: void 0 };
     case "task.done":
+      if (rec.state === "review" && ev.source !== "approve") {
+        return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
+      }
       return { ...base, state: "done", resultRef: ev.resultRef, parseWarning: ev.parseWarning };
     case "task.failed":
       return { ...base, state: "failed", error: ev.error, exitCode: ev.exitCode };
@@ -1369,19 +1385,19 @@ function reduce(rec, ev, now) {
     case "task.session":
       return stampAttempt(base, { resumeRef: ev.resumeRef }, now);
     case "task.turn.started":
-      return { ...stampAttempt(base, {}, now), state: "working", pendingTool: void 0 };
+      return { ...stampAttempt(base, {}, now), state: "working", pendingTool: void 0, pendingMonitor: void 0 };
     case "task.turn.completed":
-      if (rec.state === "blocked")
+      if (isStickyAttention(rec.state))
         return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
-      if (rec.pendingTool)
+      if (rec.pendingTool || rec.pendingMonitor)
         return stampAttempt(base, {}, now);
-      return { ...stampAttempt(base, {}, now), state: "awaiting-input", pendingTool: void 0 };
+      return { ...stampAttempt(base, {}, now), state: "awaiting-input", pendingTool: void 0, pendingMonitor: void 0 };
     case "task.delta":
       return stampAttempt(base, {}, now);
     // heartbeat-only
     case "task.input.requested":
     case "task.approval.requested":
-      return { ...stampAttempt(base, {}, now), state: "blocked", question: ev.question, pendingTool: void 0 };
+      return { ...stampAttempt(base, {}, now), state: "blocked", question: ev.question, pendingTool: void 0, pendingMonitor: void 0 };
     case "task.reattached":
       return stampAttempt(base, {}, now);
     case "task.first-turn.confirmed":
@@ -1406,15 +1422,21 @@ var init_state_machine = __esm({
 });
 
 // packages/core/dist/watchdog.js
-function evaluateStall(rec, now, toolStallMs = TOOL_STALL_BUDGET_MS) {
+function evaluateStall(rec, now, toolStallMs = TOOL_STALL_BUDGET_MS, monitorStallMs = MONITOR_STALL_BUDGET_MS) {
   if (rec.state !== "working")
     return null;
   if (rec.mode === "interactive") {
-    if (!rec.pendingTool)
-      return null;
-    if (now - rec.pendingTool.since <= toolStallMs)
-      return null;
-    return { ...rec, state: "stalled", lastEvent: "watchdog.tool-stall" };
+    if (rec.pendingTool) {
+      if (now - rec.pendingTool.since <= toolStallMs)
+        return null;
+      return { ...rec, state: "stalled", lastEvent: "watchdog.tool-stall" };
+    }
+    if (rec.pendingMonitor) {
+      if (now - rec.pendingMonitor.since <= monitorStallMs)
+        return null;
+      return { ...rec, state: "stalled", lastEvent: "watchdog.monitor-stall" };
+    }
+    return null;
   }
   const liveness = rec.attempts.at(-1)?.lastHeartbeatAt ?? rec.lastHeartbeat;
   if (now - liveness <= rec.heartbeatBudgetMs)
@@ -1424,12 +1446,13 @@ function evaluateStall(rec, now, toolStallMs = TOOL_STALL_BUDGET_MS) {
 function recoverStall(rec, now) {
   if (rec.state !== "stalled")
     return null;
-  return { ...rec, state: "working", lastHeartbeat: now, lastEvent: "watchdog.recover", pendingTool: void 0 };
+  return { ...rec, state: "working", lastHeartbeat: now, lastEvent: "watchdog.recover", pendingTool: void 0, pendingMonitor: void 0 };
 }
-var TOOL_STALL_BUDGET_MS;
+var TOOL_STALL_BUDGET_MS, MONITOR_STALL_BUDGET_MS;
 var init_watchdog = __esm({
   "packages/core/dist/watchdog.js"() {
     TOOL_STALL_BUDGET_MS = 10 * 60 * 1e3;
+    MONITOR_STALL_BUDGET_MS = 60 * 60 * 1e3;
   }
 });
 
@@ -1454,6 +1477,10 @@ function formatMessage(rec, event) {
     }
     case "blocked":
       return `CREW BLOCKED ${tag}: ${(rec.question ?? "(no question)").trim()}`;
+    case "review": {
+      const note = (rec.reviewNote ?? "").trim();
+      return `CREW REVIEW ${tag}: ${note || "ready for review"} \u2014 run 'squadrant diff ${rec.project} ${rec.name ?? rec.id}' then 'squadrant crew approve' or send feedback.`;
+    }
     case "failed":
       return `CREW FAILED ${tag}: ${(rec.error ?? "(no error)").trim()}`;
     case "stalled": {
@@ -1699,7 +1726,7 @@ function createDaemon(deps) {
           store.delete(r.project, r.id);
           continue;
         }
-        if (!TERMINAL_STATES.has(r.state)) {
+        if (!TERMINAL_STATES.has(r.state) && !isStickyAttention(r.state)) {
           const ceiling = deps.taskTimeoutMs ?? DEFAULT_TASK_TIMEOUT_MS;
           if (t - r.createdAt > ceiling) {
             const prevState = r.state;
@@ -1744,7 +1771,7 @@ function createDaemon(deps) {
         const idle = evaluateStall(r, t);
         if (idle) {
           store.put(idle);
-          const synthEvent = idle.pendingTool ? { type: "task.stalled", id: r.id, heartbeatBudgetMs: r.heartbeatBudgetMs, tool: idle.pendingTool.name, elapsedMs: t - idle.pendingTool.since } : { type: "task.stalled", id: r.id, heartbeatBudgetMs: r.heartbeatBudgetMs };
+          const synthEvent = idle.pendingTool ? { type: "task.stalled", id: r.id, heartbeatBudgetMs: r.heartbeatBudgetMs, tool: idle.pendingTool.name, elapsedMs: t - idle.pendingTool.since } : idle.pendingMonitor ? { type: "task.stalled", id: r.id, heartbeatBudgetMs: r.heartbeatBudgetMs, tool: "Monitor", elapsedMs: t - idle.pendingMonitor.since } : { type: "task.stalled", id: r.id, heartbeatBudgetMs: r.heartbeatBudgetMs };
           firePush(deps, r.project, r.state, idle, synthEvent, lastCaptainTurnAt.get(r.id));
           continue;
         }
@@ -1829,14 +1856,15 @@ var init_reduce = __esm({
     DEFAULT_TASK_TIMEOUT_MS = 8 * 60 * 60 * 1e3;
     TERMINAL_RECORD_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
     TERMINAL_RECORD_KEEP_PER_PROJECT = 20;
-    ATTENTION_STATES = /* @__PURE__ */ new Set(["done", "blocked", "failed", "stalled", "awaiting-input"]);
-    REAPABLE_SURFACE_STATES = /* @__PURE__ */ new Set(["working", "stalled", "awaiting-input", "blocked"]);
+    ATTENTION_STATES = /* @__PURE__ */ new Set(["done", "blocked", "review", "failed", "stalled", "awaiting-input"]);
+    REAPABLE_SURFACE_STATES = /* @__PURE__ */ new Set(["working", "stalled", "awaiting-input", "blocked", "review"]);
     IDLE_DEBOUNCE_MS = 12e3;
     KNOWN_EVENT_TYPES = /* @__PURE__ */ new Set([
       "task.started",
       "task.progress",
       "heartbeat",
       "task.blocked",
+      "task.review",
       "task.done",
       "task.failed",
       "task.session",
@@ -3306,9 +3334,11 @@ var init_defer_delivery = __esm({
   "packages/core/dist/delivery/defer-delivery.js"() {
     DeferDelivery = class extends Error {
       draft;
-      constructor(draft = null) {
+      reason;
+      constructor(draft = null, reason = "draft") {
         super("deferred: captain composing");
         this.draft = draft;
+        this.reason = reason;
         this.name = "DeferDelivery";
       }
     };
@@ -3332,6 +3362,7 @@ var init_captain_delivery = __esm({
       deferCounts = /* @__PURE__ */ new Map();
       lastContent = /* @__PURE__ */ new Map();
       stableCounts = /* @__PURE__ */ new Map();
+      lastReason = /* @__PURE__ */ new Map();
       constructor(opts) {
         this.opts = opts;
       }
@@ -3354,29 +3385,40 @@ var init_captain_delivery = __esm({
           this.deferCounts.delete(seq);
           this.stableCounts.delete(seq);
           this.lastContent.delete(seq);
+          this.lastReason.delete(seq);
           return { delivered: true };
         } catch (e) {
           if (e instanceof DeferDelivery) {
             this.deferCounts.set(seq, deferCount + 1);
             const content = e.draft;
+            let stableCount;
             if (content && content === this.lastContent.get(seq)) {
-              this.stableCounts.set(seq, (this.stableCounts.get(seq) ?? 0) + 1);
+              stableCount = (this.stableCounts.get(seq) ?? 0) + 1;
+              this.stableCounts.set(seq, stableCount);
             } else {
+              stableCount = 0;
               this.stableCounts.set(seq, 0);
             }
             this.lastContent.set(seq, content);
-            return { deferred: true };
+            const reason = e.reason !== "draft" ? e.reason : stableCount >= this.opts.stableProbePolls ? "stable" : "draft";
+            this.lastReason.set(seq, reason);
+            return { deferred: true, reason };
           }
-          return { deferred: true };
+          this.lastReason.set(seq, "unknown");
+          return { deferred: true, reason: "unknown" };
         }
       }
       /** Read-only. Never mutates — safe to poll from the snapshot assembler every tick. */
       stats() {
         let maxDeferCount = 0;
-        for (const c of this.deferCounts.values())
-          if (c > maxDeferCount)
+        let reason;
+        for (const [seq, c] of this.deferCounts) {
+          if (c > maxDeferCount) {
             maxDeferCount = c;
-        return { maxDeferCount, stuck: maxDeferCount >= this.opts.maxDefers };
+            reason = this.lastReason.get(seq);
+          }
+        }
+        return { maxDeferCount, stuck: maxDeferCount >= this.opts.maxDefers, reason };
       }
     };
   }
@@ -3476,6 +3518,10 @@ function createDelivery(ctx, daemonCmux) {
   const notifyFault = ctx.notifyFault ?? (() => {
   });
   const defaultNotify = async (args) => {
+    const fresh = store.get(args.project, args.record.id);
+    if (fresh && TERMINAL_STATES.has(fresh.state) && fresh.state !== args.record.state) {
+      return;
+    }
     try {
       await appendToMailbox({
         stateRoot,
@@ -3565,16 +3611,19 @@ function createDelivery(ctx, daemonCmux) {
           log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=delivered`);
           await writeCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
         } else {
-          log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=deferred`);
+          const { maxDeferCount } = d.stats();
+          if (maxDeferCount === 1 || maxDeferCount % 30 === 0) {
+            log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=deferred project=${project} reason=${result.reason}`);
+          }
           break;
         }
       }
       const stuck = d.stats().stuck;
       if (stuck && !stuckNotified.has(project)) {
         stuckNotified.add(project);
-        const { maxDeferCount } = d.stats();
-        log(`delivery stuck project=${project} deferCount=${maxDeferCount}`);
-        const text = `\u26A0\uFE0F DELIVERY STUCK: an in-progress draft (or ghost text) in your input box has blocked pending notification(s) for ${maxDeferCount}+ retries. Your input is never touched \u2014 this keeps retrying safely and will deliver automatically once you submit or clear it.`;
+        const { maxDeferCount, reason } = d.stats();
+        log(`delivery stuck project=${project} deferCount=${maxDeferCount} reason=${reason ?? "unknown"}`);
+        const text = reason === "modal" ? `\u26A0\uFE0F DELIVERY STUCK: a modal question is open in your captain pane and has blocked pending notification(s) for ${maxDeferCount}+ retries. This keeps retrying safely and will deliver automatically once you answer or dismiss it.` : `\u26A0\uFE0F DELIVERY STUCK: an in-progress draft (or ghost text) in your input box has blocked pending notification(s) for ${maxDeferCount}+ retries. Your input is never touched \u2014 this keeps retrying safely and will deliver automatically once you submit or clear it.`;
         appendCaptainMessage({ stateRoot, project, text, source: "daemon" }).catch((e) => log(`delivery stuck alert failed project=${project}: ${e.message}`));
         Promise.resolve(notifyFault(project, text)).catch((e) => log(`delivery stuck fault-notify failed project=${project}: ${e.message}`));
         telegramBridge?.pushRaw(project, text);
@@ -4309,8 +4358,12 @@ var init_commands = __esm({
         build: (a) => a[0] ? ok("crews", ["crew", "list", a[0]]) : usage("crews", "usage: /crews <project>")
       },
       launch: {
+        // --headless (#586, same reason as #520 on the boot-if-down path): runCommand
+        // execs this argv from the daemon, which has no CMUX_WORKSPACE_ID and no
+        // terminal — a plain `launch` would open the cmux GUI app and exit 0 before
+        // the workspace is ever launched.
         usage: "/launch <project>",
-        build: (a) => a[0] ? ok("launch", ["launch", a[0]]) : usage("launch", "usage: /launch <project>")
+        build: (a) => a[0] ? ok("launch", ["launch", a[0], "--headless"]) : usage("launch", "usage: /launch <project>")
       },
       effort: {
         usage: "/effort [max|balance|low]",
@@ -4484,6 +4537,9 @@ ${ev.message}` : "");
     case "task.blocked":
       return `\u{1F6A7} [${project}] CREW BLOCKED \xB7 ${ev.id}
 ${ev.question}`;
+    case "task.review":
+      return `\u{1F440} [${project}] CREW REVIEW \xB7 ${ev.id}` + (ev.message ? `
+${ev.message}` : "");
     case "task.idle":
       return `\u{1F4A4} [${project}] CREW IDLE \xB7 ${ev.id}`;
     case "task.failed":
@@ -4716,6 +4772,7 @@ var init_tiers = __esm({
     ALERTS = /* @__PURE__ */ new Set([
       ...DONE_ONLY,
       "task.blocked",
+      "task.review",
       "task.approval.requested",
       "task.input.requested",
       "task.timeout"
@@ -5932,7 +5989,7 @@ async function runCrewSend(project, name, message, runtime, workspaceId, deps) {
     if (task) {
       if (TERMINAL_STATES.has(task.state)) {
         await deps.emitEvent(project, { type: "task.reopened", id: task.id });
-      } else if (task.state === "blocked" || task.state === "awaiting-input") {
+      } else if (task.state === "blocked" || task.state === "awaiting-input" || task.state === "review") {
         await deps.emitEvent(project, { type: "task.started", id: task.id });
       }
     }
@@ -6058,6 +6115,7 @@ __export(dist_exports2, {
   GROUP_DISPATCH_WARMUP_TIMEOUT_MS: () => GROUP_DISPATCH_WARMUP_TIMEOUT_MS,
   IDLE_DEBOUNCE_MS: () => IDLE_DEBOUNCE_MS,
   LABEL: () => LABEL,
+  MONITOR_STALL_BUDGET_MS: () => MONITOR_STALL_BUDGET_MS,
   PROBE_QUIET_MS: () => PROBE_QUIET_MS,
   PROTOCOL_VERSION: () => PROTOCOL_VERSION,
   STALE_THRESHOLD_MS: () => STALE_THRESHOLD_MS,
@@ -6127,6 +6185,7 @@ __export(dist_exports2, {
   isDaemonSocketLive: () => isDaemonSocketLive,
   isNotifyActive: () => isNotifyActive,
   isSideTitle: () => isSideTitle,
+  isStickyAttention: () => isStickyAttention,
   isTurnAccepted: () => isTurnAccepted,
   kickstartArgv: () => kickstartArgv,
   launchOneWorkspace: () => launchOneWorkspace,
@@ -6277,6 +6336,18 @@ function cmux(args) {
     );
   });
 }
+function cmuxStdin(args, input) {
+  return new Promise((resolve3, reject) => {
+    const child = execFile2(resolveCmuxBin(), args, { encoding: "utf-8", timeout: CMUX_TIMEOUT, env: { ...process.env, CMUX_QUIET: "1" } }, (err, stdout) => {
+      if (err) {
+        reject(err.code === "ETIMEDOUT" ? new CmuxTimeoutError(args.join(" ")) : err);
+        return;
+      }
+      resolve3(stdout.trim());
+    });
+    child.stdin.end(input);
+  });
+}
 function parseList(output) {
   let parsed;
   try {
@@ -6633,9 +6704,9 @@ function createCmuxDriver() {
       }
       const draft = parseDraftFromScreen(screen);
       if (draft === null)
-        throw new DeferDelivery(null);
+        throw new DeferDelivery(null, "no-box");
       if (hasModalOptionList(screen))
-        throw new DeferDelivery(null);
+        throw new DeferDelivery(null, "modal");
       if (draft === "") {
         await deliver();
         return;
@@ -6676,6 +6747,37 @@ function createCmuxDriver() {
       }
       throw new DeferDelivery(draft);
     },
+    async showDiff(opts) {
+      const source = opts.source ?? "branch";
+      const args = ["diff"];
+      if (source === "staged") {
+        args.push("--staged");
+      } else if (source === "unstaged") {
+        args.push("--unstaged");
+      } else {
+        args.push("--branch", "--base", opts.base);
+        if (opts.lastTurn)
+          args.push("--last-turn");
+      }
+      args.push("--cwd", opts.cwd, "--workspace", opts.workspaceId, "--layout", opts.layout ?? "split");
+      if (opts.title)
+        args.push("--title", opts.title);
+      if (opts.focus === false)
+        args.push("--no-focus");
+      else
+        args.push("--focus", "true");
+      await cmux(args);
+    },
+    async showPatch(opts) {
+      const args = ["diff", "-", "--workspace", opts.workspaceId, "--layout", opts.layout ?? "split"];
+      if (opts.title)
+        args.push("--title", opts.title);
+      if (opts.focus === false)
+        args.push("--no-focus");
+      else
+        args.push("--focus", "true");
+      await cmuxStdin(args, opts.patch);
+    },
     async listSurfaces(workspaceId) {
       let output;
       try {
@@ -7429,6 +7531,7 @@ function installClaudeHooks(opts = {}) {
   });
   let settings = {};
   const raw = readFile6(settingsPath);
+  const hadExistingSettings = raw !== void 0;
   if (raw) {
     try {
       settings = JSON.parse(raw);
@@ -7441,6 +7544,7 @@ function installClaudeHooks(opts = {}) {
   }
   const hooks = settings.hooks;
   let changed = false;
+  const repaired = [];
   for (const [eventName, sub, matcher] of CLAUDE_HOOK_EVENTS) {
     if (!Array.isArray(hooks[eventName])) {
       hooks[eventName] = [];
@@ -7452,6 +7556,26 @@ function installClaudeHooks(opts = {}) {
     if (!alreadyPresent) {
       entries.push({ matcher: hookMatcher, hooks: [{ type: "command", command, timeout: 10 }] });
       changed = true;
+      repaired.push(`${eventName}/${sub}`);
+    }
+  }
+  if (repaired.length > 0 && hadExistingSettings) {
+    log(`native-hook: repaired ${repaired.length} missing squadrant hook(s) in ${settingsPath} [${repaired.join(", ")}] \u2014 WARNING: blocked-signalling or lifecycle tracking may have been broken until this run`);
+  }
+  if (opts.claudeEnv && Object.keys(opts.claudeEnv).length > 0) {
+    if (typeof settings.env !== "object" || settings.env === null || Array.isArray(settings.env)) {
+      settings.env = {};
+    }
+    const env = settings.env;
+    for (const [key, value] of Object.entries(opts.claudeEnv)) {
+      if (key in env) {
+        if (env[key] !== value) {
+          log(`native-hook: claudeEnv key '${key}' already set to '${String(env[key])}' in ${settingsPath} \u2014 not overwriting with '${value}'`);
+        }
+        continue;
+      }
+      env[key] = value;
+      changed = true;
     }
   }
   if (changed) {
@@ -7526,9 +7650,9 @@ var init_native_hook_source = __esm({
       cache = /* @__PURE__ */ new Map();
       active = false;
       constructor(opts = {}) {
-        this.hookInstall = opts.hookInstall ?? {};
         this.log = opts.log ?? (() => {
         });
+        this.hookInstall = { log: this.log, ...opts.hookInstall };
       }
       start(deps) {
         this.deps = deps;
@@ -9944,7 +10068,7 @@ var init_require_daemon = __esm({
 // packages/cli/src/index.ts
 init_dist();
 init_dist2();
-import { Command as Command31 } from "commander";
+import { Command as Command32 } from "commander";
 import { readFileSync as readFileSync15, existsSync as existsSync12, writeFileSync as writeFileSync11 } from "fs";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { dirname as dirname9, join as join29 } from "path";
@@ -10975,6 +11099,7 @@ init_dist4();
 import { Command as Command8 } from "commander";
 import { createConnection as createConnection3 } from "net";
 import { randomUUID as randomUUID4 } from "crypto";
+import { execFileSync as execFileSync6 } from "child_process";
 import { homedir as homedir16 } from "os";
 import { join as join21 } from "path";
 import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync10 } from "fs";
@@ -11374,6 +11499,8 @@ function buildSignalRequest(signal, o) {
     };
   } else if (signal === "blocked") {
     event = { type: "task.blocked", id: taskId, reason: "crew signaled blocked", question: o.question ?? "" };
+  } else if (signal === "review") {
+    event = { type: "task.review", id: taskId, ...o.message !== void 0 ? { message: o.message } : {} };
   } else {
     event = { type: "task.failed", id: taskId, error: o.error ?? "crew signaled failed" };
   }
@@ -11402,6 +11529,63 @@ async function runCrewSignal(signal, o, deps) {
   const req = buildSignalRequest(signal, { ...o, writeResult: o.writeResult ?? defaultWriteResult });
   await deps.call(req);
 }
+function resolveApproveTarget(tasks, crew) {
+  const matches = tasks.filter((t) => t.name === crew);
+  if (matches.length === 0) return null;
+  return matches.reduce((a, b) => (b.createdAt ?? 0) > (a.createdAt ?? 0) ? b : a);
+}
+function defaultPushBranch(cwd, branch) {
+  execFileSync6("git", ["-C", cwd, "push", "-u", "origin", branch], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+}
+function defaultCreatePr(cwd, o) {
+  return execFileSync6(
+    "gh",
+    ["pr", "create", "--base", o.base, "--head", o.branch, "--title", o.title, "--body", o.body],
+    { cwd, encoding: "utf-8" }
+  ).trim();
+}
+function defaultGetCommitSubject(cwd) {
+  try {
+    return execFileSync6("git", ["-C", cwd, "log", "-1", "--format=%s"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+async function runCrewApprove(project, crew, deps) {
+  const config = loadConfig();
+  const proj = config.projects[project];
+  if (!proj) throw new Error(`Project '${project}' not found. Run 'squadrant projects list'.`);
+  const tasks = await deps.call({ kind: "list", project });
+  const task = resolveApproveTarget(tasks, crew);
+  if (!task) throw new Error(`Crew '${crew}' not found for ${project}. Run 'squadrant crew list ${project}'.`);
+  if (task.state !== "review") {
+    throw new Error(
+      `Crew '${crew}' is not awaiting review (state=${task.state}). Only a crew that signaled 'review' can be approved.`
+    );
+  }
+  const cwd = task.cwd ?? proj.path;
+  const base = resolveWorktreeBase(proj.path);
+  const branch = crewBranch(crew);
+  const body = (task.reviewNote ?? task.task ?? "").trim();
+  const getCommitSubject = deps.getCommitSubject ?? defaultGetCommitSubject;
+  const commitSubject = getCommitSubject(cwd).trim();
+  const reviewNoteFirstLine = (task.reviewNote ?? "").split(/\r?\n/)[0].trim();
+  const taskFirstLine = (task.task ?? branch).split(/\r?\n/)[0].trim();
+  const title = (commitSubject || reviewNoteFirstLine || taskFirstLine).slice(0, 100);
+  const pushBranch = deps.pushBranch ?? defaultPushBranch;
+  const createPr = deps.createPr ?? defaultCreatePr;
+  pushBranch(cwd, branch);
+  const prUrl = createPr(cwd, { base, branch, title, body });
+  await deps.call({
+    kind: "event",
+    project,
+    event: { type: "task.done", id: task.id, resultRef: "", message: `Approved \u2014 PR opened: ${prUrl}`, source: "approve" }
+  });
+  return prUrl;
+}
 function addControlPlaneCrewCommands(crew) {
   crew.command("dispatch <project> <task>").description("Dispatch a crew task via the control-plane daemon").requiredOption("--provider <p>", "claude|opencode|codex (gemini: experimental, headless not supported)").option("--mode <m>", "headless|interactive", "interactive").option("--cwd <dir>", "working dir for the crew (project/worktree); required for codex to edit code").action(async (project, task, opts) => {
     const req = buildDispatchRequest({ project, task, provider: opts.provider, mode: opts.mode, cwd: opts.cwd });
@@ -11476,9 +11660,9 @@ function addControlPlaneCrewCommands(crew) {
     }
     process.exit(0);
   });
-  crew.command("signal <state>").description("Emit explicit terminal signal from a crew session: done|blocked|failed (reads SQUADRANT_CREW_* env, or --task-id/--project for codex)").option("--message <m>", "Summary written to resultRef (done)").option("--question <q>", "Question to surface to captain (blocked)").option("--error <e>", "Error message (failed)").option("--task-id <id>", "Explicit task id (codex; overrides SQUADRANT_CREW_TASK_ID env)").option("--project <p>", "Explicit project (codex; overrides SQUADRANT_CREW_PROJECT env)").action(async (state, opts) => {
-    if (state !== "done" && state !== "blocked" && state !== "failed") {
-      process.stderr.write(`unknown signal '${state}' (expected: done|blocked|failed)
+  crew.command("signal <state>").description("Emit explicit terminal/review signal from a crew session: done|blocked|failed|review (reads SQUADRANT_CREW_* env, or --task-id/--project for codex)").option("--message <m>", "Summary written to resultRef (done), or review summary (review)").option("--question <q>", "Question to surface to captain (blocked)").option("--error <e>", "Error message (failed)").option("--task-id <id>", "Explicit task id (codex; overrides SQUADRANT_CREW_TASK_ID env)").option("--project <p>", "Explicit project (codex; overrides SQUADRANT_CREW_PROJECT env)").action(async (state, opts) => {
+    if (state !== "done" && state !== "blocked" && state !== "failed" && state !== "review") {
+      process.stderr.write(`unknown signal '${state}' (expected: done|blocked|failed|review)
 `);
       process.exit(2);
     }
@@ -11494,6 +11678,17 @@ function addControlPlaneCrewCommands(crew) {
       process.exit(0);
     } catch (e) {
       process.stderr.write(`${e.message}
+`);
+      process.exit(1);
+    }
+  });
+  crew.command("approve <project> <crew>").description("Approve a crew's reviewed work: push crew/<name> + open a PR, then terminalize DONE (#599)").action(async (project, crewName) => {
+    try {
+      const prUrl = await runCrewApprove(project, crewName, { call: squadrantdCall });
+      process.stdout.write(`\u2714 Approved ${crewBranch(crewName)} \u2014 pushed + PR opened: ${prUrl}
+`);
+    } catch (e) {
+      process.stderr.write(`${e.message}
 `);
       process.exit(1);
     }
@@ -11651,6 +11846,199 @@ crewCommand.command("close").description("Shutdown a crew session (closes its ta
   }
 });
 
+// packages/cli/src/commands/diff.ts
+init_dist();
+init_dist3();
+import { Command as Command10 } from "commander";
+import chalk10 from "chalk";
+import { execFileSync as execFileSync7 } from "child_process";
+import readline2 from "readline";
+function resolveDiffTarget(tasks, crew, projectPath) {
+  const matches = tasks.filter((t) => t.name === crew);
+  if (matches.length === 0) return null;
+  const task = matches.reduce((a, b) => (b.createdAt ?? 0) > (a.createdAt ?? 0) ? b : a);
+  const cwd = task.cwd ?? projectPath;
+  return { cwd, isShared: cwd === projectPath };
+}
+function resolveDiffSources(opts) {
+  if (opts.working) return ["unstaged", "staged"];
+  if (opts.staged) return ["staged"];
+  if (opts.unstaged) return ["unstaged"];
+  return [];
+}
+function resolveDiffMode(crew, opts) {
+  const requestedModes = [crew !== void 0, opts.pr !== void 0, opts.base !== void 0 || opts.head !== void 0 || opts.against !== void 0];
+  if (requestedModes.filter(Boolean).length > 1) {
+    throw new Error(
+      "squadrant diff: a crew argument, --pr, and --base/--head/--against are mutually exclusive."
+    );
+  }
+  if (opts.against !== void 0 && (opts.base !== void 0 || opts.head !== void 0)) {
+    throw new Error("squadrant diff: --against cannot be combined with --base/--head.");
+  }
+  if (crew !== void 0) return { mode: "crew", crew };
+  if (opts.pr !== void 0) return { mode: "pr", pr: opts.pr };
+  if (opts.against !== void 0) return { mode: "refs", base: opts.against, head: "HEAD" };
+  if (opts.base !== void 0 || opts.head !== void 0) {
+    if (opts.base === void 0 || opts.head === void 0) {
+      throw new Error(
+        "squadrant diff: --base and --head must be used together (or use --against <ref> to diff against HEAD)."
+      );
+    }
+    return { mode: "refs", base: opts.base, head: opts.head };
+  }
+  return { mode: "pick" };
+}
+function buildCrewDiffStats(tasks, projectPath, base, getStat) {
+  const live = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    if (!t.name || TERMINAL_STATES.has(t.state)) continue;
+    const prev = live.get(t.name);
+    if (!prev || (t.createdAt ?? 0) > (prev.createdAt ?? 0)) live.set(t.name, t);
+  }
+  return [...live.values()].map((t) => {
+    const cwd = t.cwd ?? projectPath;
+    return { name: t.name, cwd, stat: getStat(cwd, base).trim() };
+  });
+}
+function parseCrewPick(raw, stats) {
+  const trimmed = raw.trim();
+  const idx = Number(trimmed);
+  if (Number.isInteger(idx) && idx >= 1 && idx <= stats.length) {
+    return stats[idx - 1].name;
+  }
+  const byName = stats.find((s) => s.name === trimmed);
+  if (byName) return byName.name;
+  throw new Error(`Invalid selection '${raw}'. Enter a number 1-${stats.length} or a crew name.`);
+}
+function promptLine2(question) {
+  return new Promise((resolve3) => {
+    const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve3(answer);
+    });
+  });
+}
+function getPrDiff(projectPath, pr) {
+  try {
+    return execFileSync7("gh", ["pr", "diff", pr], { cwd: projectPath, encoding: "utf-8" });
+  } catch (e) {
+    throw new Error(`Could not fetch PR #${pr} diff (gh pr diff failed): ${e.message}`);
+  }
+}
+function getRefsDiff(projectPath, base, head) {
+  try {
+    return execFileSync7("git", ["-C", projectPath, "diff", `${base}...${head}`], { encoding: "utf-8" });
+  } catch (e) {
+    throw new Error(`Could not diff ${base}...${head}: ${e.message}`);
+  }
+}
+async function openCrewDiff(project, proj, crew, opts, runtime, workspaceId) {
+  const tasks = await squadrantdCall({ kind: "list", project });
+  const target = resolveDiffTarget(tasks, crew, proj.path);
+  if (!target) {
+    throw new Error(`Crew '${crew}' not found for ${project}. Run 'squadrant crew list ${project}'.`);
+  }
+  const base = resolveWorktreeBase(proj.path);
+  const branchLabel = crewBranch(crew);
+  if (!runtime.showDiff) {
+    throw new Error(`Runtime '${runtime.name}' has no native diff viewer yet \u2014 Phase 1 supports cmux only.`);
+  }
+  const sources = resolveDiffSources(opts);
+  if (sources.length > 0) {
+    let opened = 0;
+    for (const source of sources) {
+      const statArgs = source === "staged" ? ["diff", "--stat", "--cached"] : ["diff", "--stat"];
+      const stat2 = execFileSync7("git", ["-C", target.cwd, ...statArgs], { encoding: "utf-8" }).trim();
+      if (!stat2) continue;
+      await runtime.showDiff({
+        workspaceId,
+        cwd: target.cwd,
+        base,
+        title: `${branchLabel} \u2014 ${source}`,
+        layout: opts.layout,
+        focus: opts.focus,
+        source
+      });
+      opened++;
+    }
+    if (opened === 0) {
+      const label = sources.length > 1 ? "staged or unstaged" : sources[0];
+      console.log(`No ${label} changes on ${branchLabel}.`);
+    } else {
+      console.log(chalk10.dim(`Opened ${opened} working-tree diff(s) (${sources.join(", ")}) for ${branchLabel}.`));
+    }
+    return;
+  }
+  const diffStat = execFileSync7(
+    "git",
+    ["-C", target.cwd, "diff", "--stat", `${base}...HEAD`],
+    { encoding: "utf-8" }
+  ).trim();
+  if (!diffStat) {
+    console.log(`No changes on ${branchLabel} vs ${base}.`);
+    return;
+  }
+  await runtime.showDiff({
+    workspaceId,
+    cwd: target.cwd,
+    base,
+    title: `${branchLabel} vs ${base}`,
+    layout: opts.layout,
+    focus: opts.focus,
+    lastTurn: opts.lastTurn,
+    source: "branch"
+  });
+  console.log(chalk10.dim(`Opened ${branchLabel} vs ${base} in cmux diff.`));
+}
+async function runDiff(project, crewArg, opts) {
+  const config = loadConfig();
+  const proj = config.projects[project];
+  if (!proj) {
+    throw new Error(`Project '${project}' not found. Run 'squadrant projects list'.`);
+  }
+  const mode = resolveDiffMode(crewArg, opts);
+  const { runtime, workspaceId } = await resolveCaptainWorkspace(project);
+  if (mode.mode === "pr" || mode.mode === "refs") {
+    if (!runtime.showPatch) {
+      throw new Error(`Runtime '${runtime.name}' has no native patch viewer yet \u2014 Phase 1 supports cmux only.`);
+    }
+    const title = mode.mode === "pr" ? `PR #${mode.pr}` : `${mode.base}...${mode.head}`;
+    const patch = mode.mode === "pr" ? getPrDiff(proj.path, mode.pr) : getRefsDiff(proj.path, mode.base, mode.head);
+    if (!patch.trim()) {
+      console.log(`No changes in ${title}.`);
+      return;
+    }
+    await runtime.showPatch({ workspaceId, patch, title, layout: opts.layout, focus: opts.focus });
+    console.log(chalk10.dim(`Opened ${title} in cmux diff.`));
+    return;
+  }
+  let crew;
+  if (mode.mode === "pick") {
+    const tasks = await squadrantdCall({ kind: "list", project });
+    const base = resolveWorktreeBase(proj.path);
+    const stats = buildCrewDiffStats(tasks, proj.path, base, (cwd, b) => {
+      try {
+        return execFileSync7("git", ["-C", cwd, "diff", "--stat", `${b}...HEAD`], { encoding: "utf-8" });
+      } catch {
+        return "";
+      }
+    });
+    if (stats.length === 0) {
+      throw new Error(`No live crews for ${project}. Run 'squadrant crew list ${project}' to check, or 'squadrant crew spawn' one.`);
+    }
+    console.log(`Live crews for ${project} (vs ${base}):`);
+    stats.forEach((s, i) => console.log(`  ${i + 1}. ${s.name} \u2014 ${s.stat || "no changes"}`));
+    const raw = await promptLine2("Pick a crew to diff (number or name): ");
+    crew = parseCrewPick(raw, stats);
+  } else {
+    crew = mode.crew;
+  }
+  await openCrewDiff(project, proj, crew, opts, runtime, workspaceId);
+}
+var diffCommand = new Command10("diff").description("Open a crew's branch diff, a PR, or a ref comparison in cmux's native diff viewer \u2014 no VSCode required (#596/#604)").argument("<project>", "Project name (must be registered)").argument("[crew]", "Crew name (e.g. crew-1); omit with no other flags to pick from live crews").option("--pr <n>", "Review a PR: wraps `gh pr diff <n>` (mutually exclusive with crew/--base/--head)").option("--base <ref>", "Base ref for a --head ref comparison (merge-base diff)").option("--head <ref>", "Head ref for a --base ref comparison").option("--against <ref>", "Alias: diff <ref>...HEAD (mutually exclusive with --base/--head)").option("--layout <mode>", "split (default) or unified", "split").option("--last-turn", "diff only changes since the crew's last agent turn", false).option("--no-focus", "open the diff pane without stealing focus").option("--staged", "show only staged (index) changes \u2014 VSCode's 'Staged Changes' panel (#599)", false).option("--unstaged", "show only unstaged working-tree changes \u2014 VSCode's 'Changes' panel (#599)", false).option("--working", "show both staged and unstaged changes (mid-task working-tree review, #599)", false).action(runDiff);
+
 // packages/cli/src/commands/side.ts
 init_dist();
 init_dist3();
@@ -11658,11 +12046,11 @@ init_dist4();
 init_dist3();
 init_dist();
 init_dist2();
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 import fs20 from "fs";
 import path22 from "path";
 import os12 from "os";
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 var TEMPLATES_DIR3 = path22.join(os12.homedir(), ".config", "squadrant", "templates");
 async function runSideSpawn2(input) {
   const config = loadConfig();
@@ -11724,7 +12112,7 @@ async function runSideClose2(project, name) {
     config.defaults.worktreeDir ?? ".worktrees"
   );
 }
-var sideCommand = new Command10("side").description(
+var sideCommand = new Command11("side").description(
   "Spawn and manage side-sessions (research/debug) \u2014 fresh-context tabs off the daemon lifecycle"
 );
 sideCommand.command("spawn").description(
@@ -11749,9 +12137,9 @@ sideCommand.command("spawn").description(
         direction: opts.direction,
         agent: opts.agent
       });
-      console.log(chalk10.green(`\u2714 Side session '${pane.title}' spawned (${pane.surfaceId})`));
+      console.log(chalk11.green(`\u2714 Side session '${pane.title}' spawned (${pane.surfaceId})`));
     } catch (err) {
-      console.error(chalk10.red(err.message));
+      console.error(chalk11.red(err.message));
       process.exit(1);
     }
   }
@@ -11760,14 +12148,14 @@ sideCommand.command("list").description("List live side-sessions for a project")
   try {
     const sessions = await runSideList2(project);
     if (sessions.length === 0) {
-      console.log(chalk10.yellow(`No live side-sessions for ${project}.`));
+      console.log(chalk11.yellow(`No live side-sessions for ${project}.`));
       return;
     }
     for (const s of sessions) {
       console.log(`  ${s.name}  (${s.surfaceId})`);
     }
   } catch (err) {
-    console.error(chalk10.red(err.message));
+    console.error(chalk11.red(err.message));
     process.exit(1);
   }
 });
@@ -11780,9 +12168,9 @@ sideCommand.command("send").description("Send a follow-up message to an existing
         label: "message"
       });
       await runSideSend2(project, name, resolvedMessage);
-      console.log(chalk10.green(`\u2714 Sent to ${project}:${name}`));
+      console.log(chalk11.green(`\u2714 Sent to ${project}:${name}`));
     } catch (err) {
-      console.error(chalk10.red(err.message));
+      console.error(chalk11.red(err.message));
       process.exit(1);
     }
   }
@@ -11790,9 +12178,9 @@ sideCommand.command("send").description("Send a follow-up message to an existing
 sideCommand.command("close").description("Close a side-session (closes its tab)").argument("<project>", "Project name").argument("<name>", "Session name").action(async (project, name) => {
   try {
     await runSideClose2(project, name);
-    console.log(chalk10.green(`\u2714 Closed ${project}:${name}`));
+    console.log(chalk11.green(`\u2714 Closed ${project}:${name}`));
   } catch (err) {
-    console.error(chalk10.red(err.message));
+    console.error(chalk11.red(err.message));
     process.exit(1);
   }
 });
@@ -11800,15 +12188,15 @@ sideCommand.command("close").description("Close a side-session (closes its tab)"
 // packages/cli/src/commands/dashboard.ts
 init_dist();
 init_dist3();
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 import { execSync as execSync10 } from "child_process";
 import { homedir as homedir18 } from "os";
 import { join as join23 } from "path";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 
 // packages/web/dist/read-status.js
 function deriveState(tasks) {
-  if (tasks.some((t) => t.state === "blocked" || t.state === "awaiting-input"))
+  if (tasks.some((t) => t.state === "blocked" || t.state === "awaiting-input" || t.state === "review"))
     return "blocked";
   if (tasks.some((t) => t.state === "failed" || t.state === "stalled"))
     return "errored";
@@ -11823,14 +12211,14 @@ function deriveRowState(tasks, captainState) {
 }
 function buildExcerpt(tasks) {
   const working = tasks.filter((t) => t.state === "working").length;
-  const blocked = tasks.filter((t) => t.state === "blocked" || t.state === "awaiting-input").length;
+  const blocked = tasks.filter((t) => t.state === "blocked" || t.state === "awaiting-input" || t.state === "review").length;
   const parts = [];
   if (working > 0)
     parts.push(`${working} working`);
   if (blocked > 0)
     parts.push(`${blocked} blocked`);
   const summary = parts.length > 0 ? parts.join(", ") : "idle";
-  const active = tasks.filter((t) => ["working", "blocked", "awaiting-input", "submitted"].includes(t.state));
+  const active = tasks.filter((t) => ["working", "blocked", "awaiting-input", "review", "submitted"].includes(t.state));
   const titles = active.slice(0, 3).map((t) => {
     const firstLine2 = t.task ? t.task.split("\n")[0] : "";
     return t.name ?? (firstLine2 || t.id.slice(0, 8));
@@ -11881,14 +12269,14 @@ async function readAllStatuses(deps) {
 }
 
 // packages/web/dist/render.js
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 var ICON = {
-  idle: chalk11.green,
-  busy: chalk11.cyan,
-  blocked: chalk11.yellow,
-  errored: chalk11.red,
-  offline: chalk11.dim,
-  unknown: chalk11.gray
+  idle: chalk12.green,
+  busy: chalk12.cyan,
+  blocked: chalk12.yellow,
+  errored: chalk12.red,
+  offline: chalk12.dim,
+  unknown: chalk12.gray
 };
 var ICON_CHAR = {
   idle: "\u25CF",
@@ -11931,10 +12319,10 @@ function renderDashboard(rows, opts) {
   const width = opts.width ?? 100;
   const lines = [];
   lines.push("");
-  lines.push("  " + chalk11.bold("\u{1F4CA} Squadrant Dashboard") + "  " + chalk11.dim(opts.now));
+  lines.push("  " + chalk12.bold("\u{1F4CA} Squadrant Dashboard") + "  " + chalk12.dim(opts.now));
   lines.push("");
   if (rows.length === 0) {
-    lines.push("  " + chalk11.yellow("No projects registered. Add one with: squadrant projects add <name> <path>"));
+    lines.push("  " + chalk12.yellow("No projects registered. Add one with: squadrant projects add <name> <path>"));
     lines.push("");
     return lines.join("\n");
   }
@@ -11945,14 +12333,14 @@ function renderDashboard(rows, opts) {
   const excerptW = Math.max(20, width - FIXED);
   for (const r of rows) {
     const icon = ICON[r.state](ICON_CHAR[r.state]);
-    const name = chalk11.cyan(pad(r.project, NAME_W));
+    const name = chalk12.cyan(pad(r.project, NAME_W));
     const state = ICON[r.state](pad(r.state, STATE_W));
     const age = pad(formatAge(r.lastChecked, opts.now), AGE_W);
-    const excerpt = chalk11.dim(truncate(firstLine(r.excerpt), excerptW));
+    const excerpt = chalk12.dim(truncate(firstLine(r.excerpt), excerptW));
     lines.push(`  ${icon} ${name} ${state} ${age} \u2502 ${excerpt}`);
   }
   lines.push("");
-  lines.push(chalk11.dim("  Refreshes every 10s \xB7 Ctrl+C to exit"));
+  lines.push(chalk12.dim("  Refreshes every 10s \xB7 Ctrl+C to exit"));
   lines.push("");
   return lines.join("\n");
 }
@@ -13075,10 +13463,10 @@ async function runDashboardWeb(input) {
     sockPath: SOCK3,
     runners: defaultProbeRunners()
   });
-  console.log(chalk12.green(`\u2714 Squadrant system dashboard \u2192 http://127.0.0.1:${handle.port}`));
-  console.log(chalk12.dim(`  polling the daemon every ${input.interval}s \xB7 localhost only \xB7 read-only \xB7 Ctrl-C to stop`));
+  console.log(chalk13.green(`\u2714 Squadrant system dashboard \u2192 http://127.0.0.1:${handle.port}`));
+  console.log(chalk13.dim(`  polling the daemon every ${input.interval}s \xB7 localhost only \xB7 read-only \xB7 Ctrl-C to stop`));
 }
-var dashboardCommand = new Command11("dashboard").description("Live status grid of all projects (derived from daemon task state)").option("--once", "Print one snapshot and exit (used by --pane's refresh loop)").option("--pane", "Open a refreshing sidebar pane in the current cmux workspace").option("--web", "Serve the live system-health web dashboard on 127.0.0.1 (HTTP + SSE)").option("--port <port>", "Port for --web (default 7878)", (v) => parseInt(v, 10), 7878).option("--direction <dir>", "Pane split direction (right|left|up|down)", "right").option("--interval <seconds>", "Daemon poll interval for --web (default 5); refresh interval for --pane (default 10)", (v) => parseInt(v, 10)).action(async (opts) => {
+var dashboardCommand = new Command12("dashboard").description("Live status grid of all projects (derived from daemon task state)").option("--once", "Print one snapshot and exit (used by --pane's refresh loop)").option("--pane", "Open a refreshing sidebar pane in the current cmux workspace").option("--web", "Serve the live system-health web dashboard on 127.0.0.1 (HTTP + SSE)").option("--port <port>", "Port for --web (default 7878)", (v) => parseInt(v, 10), 7878).option("--direction <dir>", "Pane split direction (right|left|up|down)", "right").option("--interval <seconds>", "Daemon poll interval for --web (default 5); refresh interval for --pane (default 10)", (v) => parseInt(v, 10)).action(async (opts) => {
   try {
     if (opts.web) {
       await runDashboardWeb({ port: opts.port, interval: opts.interval ?? 5 });
@@ -13086,12 +13474,12 @@ var dashboardCommand = new Command11("dashboard").description("Live status grid
     }
     if (opts.pane) {
       const pane = await runDashboardPane({ direction: opts.direction, interval: opts.interval ?? 10 });
-      console.log(chalk12.green(`\u2714 Dashboard pane opened in ${pane.workspaceId} ${pane.surfaceId}`));
+      console.log(chalk13.green(`\u2714 Dashboard pane opened in ${pane.workspaceId} ${pane.surfaceId}`));
       return;
     }
     await runDashboardOnce();
   } catch (err) {
-    console.error(chalk12.red(err.message));
+    console.error(chalk13.red(err.message));
     process.exit(1);
   }
 });
@@ -13102,12 +13490,12 @@ dashboardCommand.command("sync-hub").description("Mirror each spoke status.md in
     return;
   }
   if (results.length === 0) {
-    console.log(chalk12.dim("\n  No mirrors written (no projects with usable status.md, or hubVault unset).\n"));
+    console.log(chalk13.dim("\n  No mirrors written (no projects with usable status.md, or hubVault unset).\n"));
     return;
   }
-  console.log(chalk12.bold("\n  \u{1F4CA} Hub mirror sync\n"));
+  console.log(chalk13.bold("\n  \u{1F4CA} Hub mirror sync\n"));
   for (const r of results) {
-    console.log(`  ${chalk12.green("\u2714")} ${chalk12.cyan(r.project.padEnd(16))} \u2192 ${chalk12.dim(r.hubPath)}`);
+    console.log(`  ${chalk13.green("\u2714")} ${chalk13.cyan(r.project.padEnd(16))} \u2192 ${chalk13.dim(r.hubPath)}`);
   }
   console.log("");
 });
@@ -13117,12 +13505,12 @@ init_dist();
 init_dist4();
 init_dist3();
 init_dist2();
-import { Command as Command12 } from "commander";
+import { Command as Command13 } from "commander";
 import { execSync as execSync11 } from "child_process";
 import fs22 from "fs";
 import path24 from "path";
 import os13 from "os";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 
 // packages/cli/src/commands/launch-interactive.ts
 import checkbox, { Separator } from "@inquirer/checkbox";
@@ -13203,16 +13591,16 @@ var TEMPLATES_DIR4 = path24.join(os13.homedir(), ".config", "squadrant", "templa
 var SESSIONS_PATH2 = path24.join(os13.homedir(), ".config", "squadrant", "sessions.json");
 function ensureCmuxReady(headless) {
   if (headless || isInsideCmux()) return;
-  console.log(chalk13.yellow("\n  Not running inside cmux. Opening cmux app...\n"));
+  console.log(chalk14.yellow("\n  Not running inside cmux. Opening cmux app...\n"));
   execSync11(`open "${CMUX_APP}"`, { stdio: "inherit" });
-  console.log(chalk13.bold("  Run `squadrant launch` from inside a cmux workspace.\n"));
+  console.log(chalk14.bold("  Run `squadrant launch` from inside a cmux workspace.\n"));
   process.exit(0);
 }
-var launchCommand = new Command12("launch").description(
+var launchCommand = new Command13("launch").description(
   "Launch a project captain (with project arg) or all captains (--all). Use `squadrant command` for one-shot Command tasks."
 ).argument("[project]", "Project name to launch captain for").option("--fresh", "Start a new session instead of resuming the last one").option("--keep", "Resume the latest session even on a new day / after a template change").option("--all", "Launch all captain workspaces").option("--headless", "Skip the interactive cmux-app requirement (used by the daemon to boot captains without a terminal)").action(async (project, opts) => {
   if (opts.fresh && opts.keep) {
-    console.error(chalk13.red("\n  \u2718 --fresh and --keep are mutually exclusive\n"));
+    console.error(chalk14.red("\n  \u2718 --fresh and --keep are mutually exclusive\n"));
     process.exit(1);
   }
   const config = loadConfig();
@@ -13260,29 +13648,29 @@ var launchCommand = new Command12("launch").description(
             return null;
           }
         },
-        onFreshReason: (reason) => console.log(chalk13.cyan(`  \u21BB ${reason}`)),
-        onStoppingStale: (name) => console.log(chalk13.yellow(`  Closing stale workspace '${name}' for fresh start`)),
-        onAlreadyExists: (name) => console.log(chalk13.yellow(`  Workspace '${name}' already exists \u2014 switching to it`)),
-        onCreated: (name) => console.log(chalk13.green(`  \u2714 Workspace '${name}' created`))
+        onFreshReason: (reason) => console.log(chalk14.cyan(`  \u21BB ${reason}`)),
+        onStoppingStale: (name) => console.log(chalk14.yellow(`  Closing stale workspace '${name}' for fresh start`)),
+        onAlreadyExists: (name) => console.log(chalk14.yellow(`  Workspace '${name}' already exists \u2014 switching to it`)),
+        onCreated: (name) => console.log(chalk14.green(`  \u2714 Workspace '${name}' created`))
       });
     } catch (err) {
-      console.error(chalk13.red(`  \u2718 Failed: ${err.message}`));
+      console.error(chalk14.red(`  \u2718 Failed: ${err.message}`));
       hadFailure = true;
     }
   }
   if (opts.all) {
     const hubPath = resolveHome(config.hubVault);
     fs22.mkdirSync(hubPath, { recursive: true });
-    console.log(chalk13.bold("\nLaunching all captain workspaces\n"));
+    console.log(chalk14.bold("\nLaunching all captain workspaces\n"));
     for (const [name, proj] of Object.entries(config.projects)) {
       const projPath = resolveHome(proj.path);
       const spokePath = resolveHome(proj.spokeVault);
       if (!fs22.existsSync(spokePath)) {
         const spokeDriver = new WorkspaceRegistry({ obsidian: createObsidianDriver }).forProject(name, config);
         await ensureSpokeLayout(spokeDriver);
-        console.log(chalk13.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
+        console.log(chalk14.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
       }
-      console.log(chalk13.bold(`
+      console.log(chalk14.bold(`
   Captain: ${proj.captainName} (${name})`));
       await launchOne(proj.captainName, "captain", projPath, config.defaults.permissions?.captain || "auto", false, true, name);
     }
@@ -13290,7 +13678,7 @@ var launchCommand = new Command12("launch").description(
   } else if (!project) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
       console.error(
-        chalk13.red(
+        chalk14.red(
           "\n  \u2718 Specify a project name, or pass --all to launch every captain.\n    For one-shot Command tasks, use `squadrant command --task <briefing|learnings-review|wiki-aggregate>`.\n"
         )
       );
@@ -13305,10 +13693,10 @@ var launchCommand = new Command12("launch").description(
     }));
     const selected = await selectCaptainsInteractive(entries);
     if (selected.length === 0) {
-      console.log(chalk13.yellow("\n  No captains selected.\n"));
+      console.log(chalk14.yellow("\n  No captains selected.\n"));
       return;
     }
-    console.log(chalk13.bold(`
+    console.log(chalk14.bold(`
 Launching ${selected.length} captain workspace(s) in parallel
 `));
     await Promise.all(selected.map(async (name) => {
@@ -13318,9 +13706,9 @@ Launching ${selected.length} captain workspace(s) in parallel
       if (!fs22.existsSync(spokePath)) {
         const spokeDriver = new WorkspaceRegistry({ obsidian: createObsidianDriver }).forProject(name, config);
         await ensureSpokeLayout(spokeDriver);
-        console.log(chalk13.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
+        console.log(chalk14.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
       }
-      console.log(chalk13.bold(`
+      console.log(chalk14.bold(`
   Captain: ${proj.captainName} (${name})`));
       await launchOne(proj.captainName, "captain", projPath, config.defaults.permissions?.captain || "auto", false, true, name);
     }));
@@ -13328,7 +13716,7 @@ Launching ${selected.length} captain workspace(s) in parallel
   } else {
     if (!config.projects[project]) {
       console.error(
-        chalk13.red(
+        chalk14.red(
           `
   \u2718 Project '${project}' not found. Run 'squadrant projects list' to see registered projects.
 `
@@ -13342,10 +13730,10 @@ Launching ${selected.length} captain workspace(s) in parallel
     if (!fs22.existsSync(spokePath)) {
       const spokeDriver = new WorkspaceRegistry({ obsidian: createObsidianDriver }).forProject(project, config);
       await ensureSpokeLayout(spokeDriver);
-      console.log(chalk13.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
+      console.log(chalk14.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
     }
     console.log(
-      chalk13.bold(
+      chalk14.bold(
         `
 Launching captain workspace for '${project}' (${proj.captainName})
 `
@@ -13359,8 +13747,8 @@ Launching captain workspace for '${project}' (${proj.captainName})
 // packages/cli/src/commands/shutdown.ts
 init_dist();
 init_dist3();
-import { Command as Command13 } from "commander";
-import chalk14 from "chalk";
+import { Command as Command14 } from "commander";
+import chalk15 from "chalk";
 init_dist();
 function nameVariants(name) {
   const stripped = name.replace(/^⚓\s+/, "").trim();
@@ -13373,23 +13761,23 @@ async function closeMatching(runtime, variants, label) {
   const failed = [];
   if (matches.length === 0) {
     console.log(
-      chalk14.yellow(`  \u26A0 Workspace '${label}' not found \u2014 already closed?`)
+      chalk15.yellow(`  \u26A0 Workspace '${label}' not found \u2014 already closed?`)
     );
     return { closed, failed };
   }
   for (const ws of matches) {
     try {
       await runtime.stop(ws.id);
-      console.log(chalk14.green(`  \u2714 Closed: ${ws.name}`));
+      console.log(chalk15.green(`  \u2714 Closed: ${ws.name}`));
       closed.push(ws.name);
     } catch {
-      console.log(chalk14.red(`  \u2718 Failed to close: ${ws.name}`));
+      console.log(chalk15.red(`  \u2718 Failed to close: ${ws.name}`));
       failed.push(ws.name);
     }
   }
   return { closed, failed };
 }
-var shutdownCommand = new Command13("shutdown").description(
+var shutdownCommand = new Command14("shutdown").description(
   "Shutdown command + all captain workspaces (no args) or one captain workspace"
 ).argument("[project]", "Project name to shut down captain for").action(async (project) => {
   const config = loadConfig();
@@ -13405,11 +13793,11 @@ var shutdownCommand = new Command13("shutdown").description(
     const allVariants = /* @__PURE__ */ new Set([...captainVariants, ...commandVariants]);
     const squadrantWorkspaces = workspaces.filter((w) => allVariants.has(w.name));
     if (squadrantWorkspaces.length === 0) {
-      console.log(chalk14.yellow("\nNo squadrant workspaces found to close.\n"));
+      console.log(chalk15.yellow("\nNo squadrant workspaces found to close.\n"));
       return;
     }
     console.log(
-      chalk14.bold(
+      chalk15.bold(
         `
 Shutting down ${squadrantWorkspaces.length} workspace(s)...
 `
@@ -13429,9 +13817,9 @@ Shutting down ${squadrantWorkspaces.length} workspace(s)...
     for (const ws of squadrantWorkspaces) {
       try {
         await globalRuntime.stop(ws.id);
-        console.log(chalk14.green(`  \u2714 Closed: ${ws.name}`));
+        console.log(chalk15.green(`  \u2714 Closed: ${ws.name}`));
       } catch {
-        console.log(chalk14.red(`  \u2718 Failed to close: ${ws.name}`));
+        console.log(chalk15.red(`  \u2718 Failed to close: ${ws.name}`));
       }
     }
     console.log("");
@@ -13439,7 +13827,7 @@ Shutting down ${squadrantWorkspaces.length} workspace(s)...
   }
   if (!config.projects[project]) {
     console.error(
-      chalk14.red(
+      chalk15.red(
         `
   \u2718 Project '${project}' not found. Run 'squadrant projects list' to see registered projects.
 `
@@ -13450,7 +13838,7 @@ Shutting down ${squadrantWorkspaces.length} workspace(s)...
   const captainName = config.projects[project].captainName;
   const runtime = runtimes.forProject(project, config);
   console.log(
-    chalk14.bold(`
+    chalk15.bold(`
 Shutting down captain workspace for '${project}'...
 `)
   );
@@ -13474,13 +13862,13 @@ Shutting down captain workspace for '${project}'...
 
 // packages/cli/src/commands/feedback.ts
 init_dist();
-import { Command as Command14 } from "commander";
+import { Command as Command15 } from "commander";
 import fs23 from "fs";
 import os14 from "os";
 import path25 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { execSync as execSync12 } from "child_process";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 var REPO_URL = "https://github.com/tu11aa/squadrant";
 function readPkgVersion() {
   try {
@@ -13528,21 +13916,21 @@ function buildIssueUrl(metrics, squadrantVersion) {
   });
   return `${REPO_URL}/issues/new?${params.toString()}`;
 }
-var feedbackCommand = new Command14("feedback").description("Open a pre-filled GitHub issue for feedback or bug reports").action(() => {
+var feedbackCommand = new Command15("feedback").description("Open a pre-filled GitHub issue for feedback or bug reports").action(() => {
   const config = loadConfig();
   const metricsPath = config.metrics?.path || path25.join(os14.homedir(), ".config", "squadrant", "metrics.json");
   const metrics = readMetrics(metricsPath);
   const version = readStamp(config) ?? readPkgVersion();
   const issueUrl = buildIssueUrl(metrics, version);
-  console.log(chalk15.bold("\nOpening feedback issue in browser...\n"));
-  console.log(chalk15.dim(`  URL: ${issueUrl.substring(0, 80)}...
+  console.log(chalk16.bold("\nOpening feedback issue in browser...\n"));
+  console.log(chalk16.dim(`  URL: ${issueUrl.substring(0, 80)}...
 `));
   try {
     execSync12(`open "${issueUrl}"`, { stdio: "ignore" });
-    console.log(chalk15.green("  \u2714 Browser opened\n"));
+    console.log(chalk16.green("  \u2714 Browser opened\n"));
   } catch {
-    console.log(chalk15.yellow("  \u26A0 Could not open browser automatically."));
-    console.log(`  Open manually: ${chalk15.cyan(issueUrl)}
+    console.log(chalk16.yellow("  \u26A0 Could not open browser automatically."));
+    console.log(`  Open manually: ${chalk16.cyan(issueUrl)}
 `);
   }
 });
@@ -13551,10 +13939,10 @@ var feedbackCommand = new Command14("feedback").description("Open a pre-filled G
 init_dist();
 init_dist();
 init_dist3();
-import { Command as Command15 } from "commander";
+import { Command as Command16 } from "commander";
 import fs24 from "fs";
 import path26 from "path";
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 import matter3 from "gray-matter";
 function getDateStr(yesterday) {
   return iso(daysAgo(yesterday ? 1 : 0));
@@ -13584,7 +13972,7 @@ function formatStandup(standups, dateStr, raw) {
   const lines = [];
   const header = `Standup \u2014 ${dateStr}`;
   if (!raw) {
-    lines.push(chalk16.bold(`
+    lines.push(chalk17.bold(`
 ${header}
 `));
   } else {
@@ -13597,12 +13985,12 @@ ${header}
     const tasksTotal = s.status.tasks_total ?? 0;
     const tasksInProgress = s.status.tasks_in_progress ?? 0;
     if (!raw) {
-      lines.push(chalk16.cyan.bold(`## ${s.name}`));
+      lines.push(chalk17.cyan.bold(`## ${s.name}`));
     } else {
       lines.push(`## ${s.name}`);
     }
     if (s.gitCommits.length > 0 || tasksDone > 0) {
-      lines.push(!raw ? chalk16.green("Done:") : "**Done:**");
+      lines.push(!raw ? chalk17.green("Done:") : "**Done:**");
       for (const commit of s.gitCommits) {
         lines.push(`  - ${commit}`);
       }
@@ -13611,7 +13999,7 @@ ${header}
       }
     }
     if (tasksInProgress > 0) {
-      lines.push(!raw ? chalk16.yellow("In Progress:") : "**In Progress:**");
+      lines.push(!raw ? chalk17.yellow("In Progress:") : "**In Progress:**");
       lines.push(`  - ${tasksInProgress} task(s) active`);
     }
     if (s.dailyLog) {
@@ -13621,7 +14009,7 @@ ${header}
         if (match) {
           const items = match[1].trim().split("\n").filter((l) => l.trim().startsWith("-"));
           if (items.length > 0 && section === "Tomorrow") {
-            lines.push(!raw ? chalk16.blue("Next:") : "**Next:**");
+            lines.push(!raw ? chalk17.blue("Next:") : "**Next:**");
             for (const item of items) lines.push(`  ${item.trim()}`);
           }
         }
@@ -13629,20 +14017,20 @@ ${header}
     }
     if (s.blockers.length > 0) {
       hasBlockers = true;
-      lines.push(!raw ? chalk16.red("Blocked:") : "**Blocked:**");
+      lines.push(!raw ? chalk17.red("Blocked:") : "**Blocked:**");
       for (const b of s.blockers) {
         lines.push(`  - ${b}`);
       }
     }
     if (s.gitCommits.length === 0 && tasksDone === 0 && !s.dailyLog) {
-      lines.push(!raw ? chalk16.dim("  (no activity)") : "  (no activity)");
+      lines.push(!raw ? chalk17.dim("  (no activity)") : "  (no activity)");
     }
     lines.push("");
   }
   const totalCommits = standups.reduce((sum, s) => sum + s.gitCommits.length, 0);
   const totalDone = standups.reduce((sum, s) => sum + (s.status.tasks_completed ?? 0), 0);
   if (!raw) {
-    lines.push(chalk16.dim(`--- ${totalCommits} commits, ${totalDone} tasks done${hasBlockers ? ", HAS BLOCKERS" : ""} ---
+    lines.push(chalk17.dim(`--- ${totalCommits} commits, ${totalDone} tasks done${hasBlockers ? ", HAS BLOCKERS" : ""} ---
 `));
   } else {
     lines.push(`---
@@ -13651,12 +14039,12 @@ ${header}
   }
   return lines.join("\n");
 }
-var standupCommand = new Command15("standup").description("Generate daily standup report from spoke vault data and git logs (zero tokens)").option("-p, --project <name>", "Show standup for a specific project only").option("-a, --all", "Show all projects (default)").option("-y, --yesterday", "Show yesterday's standup instead of today").option("-r, --raw", "Output raw markdown (for pasting into Slack/chat)").action(async (opts) => {
+var standupCommand = new Command16("standup").description("Generate daily standup report from spoke vault data and git logs (zero tokens)").option("-p, --project <name>", "Show standup for a specific project only").option("-a, --all", "Show all projects (default)").option("-y, --yesterday", "Show yesterday's standup instead of today").option("-r, --raw", "Output raw markdown (for pasting into Slack/chat)").action(async (opts) => {
   const config = loadConfig();
   const registry = new WorkspaceRegistry({ obsidian: createObsidianDriver });
   const projects = Object.entries(config.projects);
   if (projects.length === 0) {
-    console.log(chalk16.yellow("\nNo projects registered. Use: squadrant projects add <name> <path>\n"));
+    console.log(chalk17.yellow("\nNo projects registered. Use: squadrant projects add <name> <path>\n"));
     return;
   }
   const dateStr = getDateStr(!!opts.yesterday);
@@ -13665,7 +14053,7 @@ var standupCommand = new Command15("standup").description("Generate daily standu
   if (opts.project) {
     const match = projects.find(([name]) => name === opts.project);
     if (!match) {
-      console.error(chalk16.red(`Project "${opts.project}" not found.`));
+      console.error(chalk17.red(`Project "${opts.project}" not found.`));
       process.exit(1);
     }
     targets = [match];
@@ -13683,10 +14071,10 @@ var standupCommand = new Command15("standup").description("Generate daily standu
 init_dist();
 init_dist();
 init_dist3();
-import { Command as Command16 } from "commander";
+import { Command as Command17 } from "commander";
 import fs25 from "fs";
 import path27 from "path";
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 import matter4 from "gray-matter";
 function readStatus(spokeVault) {
   const statusFile = path27.join(spokeVault, "status.md");
@@ -13756,7 +14144,7 @@ function formatRetro(retros, fromStr, toStr, raw) {
   const lines = [];
   const header = `Retro \u2014 ${fromStr} \u2192 ${toStr}`;
   lines.push(raw ? `# ${header}
-` : chalk17.bold(`
+` : chalk18.bold(`
 ${header}
 `));
   let totalCommits = 0;
@@ -13766,39 +14154,39 @@ ${header}
     totalCommits += r.commits.length;
     totalPRs += r.mergedPRs.length;
     totalShipped += r.shipped.length;
-    lines.push(raw ? `## ${r.name}` : chalk17.cyan.bold(`## ${r.name}`));
-    renderList(lines, r.shipped, raw, "Shipped", chalk17.green);
+    lines.push(raw ? `## ${r.name}` : chalk18.cyan.bold(`## ${r.name}`));
+    renderList(lines, r.shipped, raw, "Shipped", chalk18.green);
     if (r.mergedPRs.length > 0) {
-      lines.push(raw ? `**PRs merged:**` : chalk17.green("PRs merged:"));
+      lines.push(raw ? `**PRs merged:**` : chalk18.green("PRs merged:"));
       for (const pr of r.mergedPRs) lines.push(`  - ${pr}`);
     }
-    renderList(lines, r.inProgress, raw, "In Progress", chalk17.yellow);
-    renderList(lines, r.blocked, raw, "Blocked", chalk17.red);
-    renderList(lines, r.decisions, raw, "Key Decisions", chalk17.magenta);
+    renderList(lines, r.inProgress, raw, "In Progress", chalk18.yellow);
+    renderList(lines, r.blocked, raw, "Blocked", chalk18.red);
+    renderList(lines, r.decisions, raw, "Key Decisions", chalk18.magenta);
     const metricBits = [
       `${r.commits.length} commits`,
       `${r.mergedPRs.length} PRs merged`,
       `${r.shipped.length} shipped`
     ];
-    lines.push(raw ? `*${metricBits.join(" \xB7 ")}*` : chalk17.dim(`  ${metricBits.join(" \xB7 ")}`));
+    lines.push(raw ? `*${metricBits.join(" \xB7 ")}*` : chalk18.dim(`  ${metricBits.join(" \xB7 ")}`));
     if (r.shipped.length === 0 && r.commits.length === 0 && r.mergedPRs.length === 0 && r.inProgress.length === 0 && r.blocked.length === 0) {
-      lines.push(raw ? "_(no activity in this window)_" : chalk17.dim("  (no activity in this window)"));
+      lines.push(raw ? "_(no activity in this window)_" : chalk18.dim("  (no activity in this window)"));
     }
     lines.push("");
   }
   const summary = `${totalShipped} items shipped \xB7 ${totalCommits} commits \xB7 ${totalPRs} PRs merged`;
   lines.push(raw ? `---
 *${summary}*
-` : chalk17.dim(`--- ${summary} ---
+` : chalk18.dim(`--- ${summary} ---
 `));
   return lines.join("\n");
 }
-var retroCommand = new Command16("retro").description("Generate a retro (weekly/sprint summary) from daily logs and git (zero tokens)").option("-w, --week", "Trailing 7 days (default)").option("-s, --sprint [days]", "Custom window of N days (default 14 if N omitted)").option("-p, --project <name>", "Retro for a single project").option("-a, --all", "All projects (default)").option("-r, --raw", "Raw markdown output (for pasting into Slack/Obsidian)").action(async (opts) => {
+var retroCommand = new Command17("retro").description("Generate a retro (weekly/sprint summary) from daily logs and git (zero tokens)").option("-w, --week", "Trailing 7 days (default)").option("-s, --sprint [days]", "Custom window of N days (default 14 if N omitted)").option("-p, --project <name>", "Retro for a single project").option("-a, --all", "All projects (default)").option("-r, --raw", "Raw markdown output (for pasting into Slack/Obsidian)").action(async (opts) => {
   const config = loadConfig();
   const registry = new WorkspaceRegistry({ obsidian: createObsidianDriver });
   const projects = Object.entries(config.projects);
   if (projects.length === 0) {
-    console.log(chalk17.yellow("\nNo projects registered. Use: squadrant projects add <name> <path>\n"));
+    console.log(chalk18.yellow("\nNo projects registered. Use: squadrant projects add <name> <path>\n"));
     return;
   }
   let windowDays = 7;
@@ -13815,7 +14203,7 @@ var retroCommand = new Command16("retro").description("Generate a retro (weekly/
   if (opts.project) {
     const match = projects.find(([name]) => name === opts.project);
     if (!match) {
-      console.error(chalk17.red(`Project "${opts.project}" not found.`));
+      console.error(chalk18.red(`Project "${opts.project}" not found.`));
       process.exit(1);
     }
     targets = [match];
@@ -13831,8 +14219,8 @@ var retroCommand = new Command16("retro").description("Generate a retro (weekly/
 // packages/cli/src/commands/runtime.ts
 init_dist();
 init_dist3();
-import { Command as Command17 } from "commander";
-import chalk18 from "chalk";
+import { Command as Command18 } from "commander";
+import chalk19 from "chalk";
 function buildRegistry() {
   return new RuntimeRegistry({
     cmux: createCmuxDriver()
@@ -13864,7 +14252,7 @@ async function needRef(resolved) {
   }
   return ref.id;
 }
-var runtimeCommand = new Command17("runtime").description("Interact with the runtime layer (workspaces). Bridges bash scripts to the RuntimeDriver.");
+var runtimeCommand = new Command18("runtime").description("Interact with the runtime layer (workspaces). Bridges bash scripts to the RuntimeDriver.");
 runtimeCommand.command("status").description("Print 'running' or 'stopped' for a target; exit 0 if running, 1 if not").argument("[target]", "Project name").option("--command", "Target the command workspace instead of a project captain").action(async (target, opts) => {
   const config = loadConfig();
   const registry = buildRegistry();
@@ -13879,7 +14267,7 @@ runtimeCommand.command("status").description("Print 'running' or 'stopped' for a
       process.exit(1);
     }
   } catch (err) {
-    console.error(chalk18.red(err.message));
+    console.error(chalk19.red(err.message));
     process.exit(2);
   }
 });
@@ -13926,9 +14314,9 @@ async function runRuntimeSend(arg1, arg2, opts, confirmOpts) {
 runtimeCommand.command("send").description("Send a message to a target workspace AND commit with Enter. With --command, the first positional is the message.").argument("<arg1>", "Project name, or the message when --command is used").argument("[arg2]", "Message (when target is a project). Omit when using --command.").option("--command", "Target the command workspace").action(async (arg1, arg2, opts) => {
   try {
     await runRuntimeSend(arg1, arg2, opts);
-    console.log(chalk18.green("\u2714 Delivered (confirmed)"));
+    console.log(chalk19.green("\u2714 Delivered (confirmed)"));
   } catch (err) {
-    console.error(chalk18.red(err.message));
+    console.error(chalk19.red(err.message));
     process.exit(1);
   }
 });
@@ -13954,7 +14342,7 @@ runtimeCommand.command("read-screen").description("Print a terminal snapshot of
     const screen = await resolved.driver.readScreen(ref);
     process.stdout.write(screen);
   } catch (err) {
-    console.error(chalk18.red(err.message));
+    console.error(chalk19.red(err.message));
     process.exit(1);
   }
 });
@@ -13965,13 +14353,13 @@ runtimeCommand.command("stop").description("Stop a target workspace").argument("
     const resolved = resolveTarget(registry, config, target, !!opts.command);
     const ref = await resolved.driver.status(resolved.workspaceName);
     if (!ref) {
-      console.log(chalk18.yellow(`Workspace '${resolved.workspaceName}' already stopped`));
+      console.log(chalk19.yellow(`Workspace '${resolved.workspaceName}' already stopped`));
       return;
     }
     await resolved.driver.stop(ref.id);
-    console.log(chalk18.green(`\u2714 Stopped ${resolved.workspaceName}`));
+    console.log(chalk19.green(`\u2714 Stopped ${resolved.workspaceName}`));
   } catch (err) {
-    console.error(chalk18.red(err.message));
+    console.error(chalk19.red(err.message));
     process.exit(1);
   }
 });
@@ -13979,8 +14367,8 @@ runtimeCommand.command("stop").description("Stop a target workspace").argument("
 // packages/cli/src/commands/workspace.ts
 init_dist();
 init_dist3();
-import { Command as Command18 } from "commander";
-import chalk19 from "chalk";
+import { Command as Command19 } from "commander";
+import chalk20 from "chalk";
 function buildRegistry2() {
   return new WorkspaceRegistry({
     obsidian: createObsidianDriver
@@ -13998,7 +14386,7 @@ async function readStdin() {
   }
   return Buffer.concat(chunks).toString("utf-8");
 }
-var workspaceCommand = new Command18("workspace").description("Interact with the workspace layer (vault storage). Bridges bash scripts to the WorkspaceDriver.");
+var workspaceCommand = new Command19("workspace").description("Interact with the workspace layer (vault storage). Bridges bash scripts to the WorkspaceDriver.");
 function resolveTargetAndPath(arg1, arg2, useHub) {
   if (useHub) {
     if (arg2 !== void 0) {
@@ -14020,7 +14408,7 @@ workspaceCommand.command("read").description("Print the contents of a scope-rela
     const content = await driver.read(path30);
     process.stdout.write(content);
   } catch (err) {
-    console.error(chalk19.red(err.message));
+    console.error(chalk20.red(err.message));
     process.exit(1);
   }
 });
@@ -14050,7 +14438,7 @@ workspaceCommand.command("write").description("Write content to a scope-relative
     const payload = rawContent === "-" ? await readStdin() : rawContent;
     await driver.write(path30, payload);
   } catch (err) {
-    console.error(chalk19.red(err.message));
+    console.error(chalk20.red(err.message));
     process.exit(1);
   }
 });
@@ -14063,7 +14451,7 @@ workspaceCommand.command("list").description("List entries in a scope-relative d
     const entries = await driver.list(path30);
     for (const entry of entries) console.log(entry);
   } catch (err) {
-    console.error(chalk19.red(err.message));
+    console.error(chalk20.red(err.message));
     process.exit(1);
   }
 });
@@ -14076,7 +14464,7 @@ workspaceCommand.command("exists").description("Exit 0 if path exists, 1 if not"
     const ok2 = await driver.exists(path30);
     process.exit(ok2 ? 0 : 1);
   } catch (err) {
-    console.error(chalk19.red(err.message));
+    console.error(chalk20.red(err.message));
     process.exit(2);
   }
 });
@@ -14088,7 +14476,7 @@ workspaceCommand.command("mkdir").description("Recursively create a scope-relati
     const driver = resolveDriver(registry, config, projectTarget, !!opts.hub);
     await driver.mkdir(path30);
   } catch (err) {
-    console.error(chalk19.red(err.message));
+    console.error(chalk20.red(err.message));
     process.exit(1);
   }
 });
@@ -14096,8 +14484,8 @@ workspaceCommand.command("mkdir").description("Recursively create a scope-relati
 // packages/cli/src/commands/notify.ts
 init_dist();
 init_dist3();
-import { Command as Command19 } from "commander";
-import chalk20 from "chalk";
+import { Command as Command20 } from "commander";
+import chalk21 from "chalk";
 async function readStdin2() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -14105,7 +14493,7 @@ async function readStdin2() {
   }
   return Buffer.concat(chunks).toString("utf-8");
 }
-var notifyCommand = new Command19("notify").description("Send a message to the user via the configured notifier").argument("<message>", "Message to send (use '-' to read from stdin)").action(async (message) => {
+var notifyCommand = new Command20("notify").description("Send a message to the user via the configured notifier").argument("<message>", "Message to send (use '-' to read from stdin)").action(async (message) => {
   const config = loadConfig();
   const registry = new NotifierRegistry({ cmux: createCmuxNotifier });
   try {
@@ -14113,7 +14501,7 @@ var notifyCommand = new Command19("notify").description("Send a message to the u
     if (!payload) throw new Error("Empty message");
     await registry.get(config).notify(payload);
   } catch (err) {
-    console.error(chalk20.red(err.message));
+    console.error(chalk21.red(err.message));
     process.exit(1);
   }
 });
@@ -14123,8 +14511,8 @@ init_dist();
 init_dist4();
 init_dist3();
 init_dist();
-import { Command as Command20 } from "commander";
-import chalk21 from "chalk";
+import { Command as Command21 } from "commander";
+import chalk22 from "chalk";
 import fs26 from "fs";
 import path28 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -14171,17 +14559,17 @@ async function runEmit(opts) {
     for (const dest of emitter.destinations(scope, projectRoot)) {
       const result = await emitter.emit(source, dest, { dryRun: opts.dryRun });
       if (opts.dryRun) {
-        console.log(chalk21.cyan(`[${emitter.name}] ${dest.path}`));
+        console.log(chalk22.cyan(`[${emitter.name}] ${dest.path}`));
         console.log(result.diff ?? "(no diff)");
       } else if (result.written) {
         console.log(
-          chalk21.green(
+          chalk22.green(
             `\u2714 ${emitter.name} \u2192 ${dest.path} (${result.bytesWritten} bytes)`
           )
         );
         emittedCount.written++;
       } else {
-        console.log(chalk21.gray(`- ${emitter.name} \u2192 ${dest.path} (skipped)`));
+        console.log(chalk22.gray(`- ${emitter.name} \u2192 ${dest.path} (skipped)`));
         emittedCount.skipped++;
       }
     }
@@ -14204,14 +14592,14 @@ async function runEmit(opts) {
             `Unknown project '${projectName}'. Available: ${Object.keys(cfg.projects).join(", ") || "(none)"}`
           );
         }
-        console.error(chalk21.yellow(`\u26A0 unknown project: ${projectName}`));
+        console.error(chalk22.yellow(`\u26A0 unknown project: ${projectName}`));
         continue;
       }
       const source = await readProjectLevelSource(
         createObsidianDriver({ root: proj.path })
       );
       if (!source) {
-        console.log(chalk21.gray(`- ${projectName}: no AGENTS.md, skipping`));
+        console.log(chalk22.gray(`- ${projectName}: no AGENTS.md, skipping`));
         continue;
       }
       for (const name of targets) {
@@ -14221,21 +14609,21 @@ async function runEmit(opts) {
   }
   if (!opts.dryRun) {
     console.log(
-      chalk21.bold(
+      chalk22.bold(
         `
 Projection complete \u2014 ${emittedCount.written} written, ${emittedCount.skipped} skipped.`
       )
     );
   }
 }
-var projectionCommand = new Command20("projection").description(
+var projectionCommand = new Command21("projection").description(
   "Project squadrant instructions and skills to supported agent formats"
 );
 projectionCommand.command("emit").description("Emit projections to disk").option("--scope <scope>", "user or project", parseScope).option("--project <name>", "managed project name").option("--target <name>", "single target (cursor, codex, gemini, opencode)").option("--all", "emit user-level + every managed project").action(async (opts) => {
   try {
     await runEmit({ ...opts, dryRun: false });
   } catch (err) {
-    console.error(chalk21.red(err.message));
+    console.error(chalk22.red(err.message));
     process.exit(1);
   }
 });
@@ -14243,7 +14631,7 @@ projectionCommand.command("diff").description("Preview changes without writing")
   try {
     await runEmit({ ...opts, dryRun: true });
   } catch (err) {
-    console.error(chalk21.red(err.message));
+    console.error(chalk22.red(err.message));
     process.exit(1);
   }
 });
@@ -14253,7 +14641,7 @@ projectionCommand.command("list").description("List registered projection target
     const emitter = registry.get(name);
     const userDests = emitter.destinations("user").map((d) => d.path);
     const projectDests = emitter.destinations("project", "<project>").map((d) => d.path);
-    console.log(chalk21.bold(name));
+    console.log(chalk22.bold(name));
     console.log(`  user:    ${userDests.join(", ") || "(none)"}`);
     console.log(`  project: ${projectDests.join(", ") || "(none)"}`);
   }
@@ -14261,9 +14649,9 @@ projectionCommand.command("list").description("List registered projection target
 
 // packages/cli/src/commands/codex-chat-smoke.ts
 init_dist4();
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 import { resolve as resolve2 } from "path";
-var codexChatSmokeCommand = new Command21("codex-chat-smoke").description("Phase 1 gate: prove the codex app-server JSON-RPC path works end-to-end.").option("--cwd <dir>", "working dir for the codex thread", process.cwd()).option("--model <m>", "model id (optional)").option(
+var codexChatSmokeCommand = new Command22("codex-chat-smoke").description("Phase 1 gate: prove the codex app-server JSON-RPC path works end-to-end.").option("--cwd <dir>", "working dir for the codex thread", process.cwd()).option("--model <m>", "model id (optional)").option(
   "--approval",
   "include the approval round-trip (Phase 1 PASS requires this)",
   false
@@ -14332,11 +14720,11 @@ init_dist();
 init_dist();
 init_dist();
 init_dist2();
-import { Command as Command22 } from "commander";
+import { Command as Command23 } from "commander";
 import fs27 from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { dirname as dirname6, join as join25 } from "path";
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 function runConfigCheck(opts) {
   const raw = JSON.parse(fs27.readFileSync(opts.configPath, "utf-8"));
   const def = getDefaultConfig();
@@ -14391,14 +14779,14 @@ function runConfigSet(key, value, configPath = DEFAULT_CONFIG_PATH) {
 }
 function printRestartOutcome(outcome) {
   if (outcome === "skipped-not-running") {
-    console.log(chalk22.dim("(daemon not running \u2014 change applies on next start)"));
+    console.log(chalk23.dim("(daemon not running \u2014 change applies on next start)"));
   } else if (outcome === "skipped-opt-out") {
-    console.log(chalk22.dim("(run 'squadrant heal daemon' to apply)"));
+    console.log(chalk23.dim("(run 'squadrant heal daemon' to apply)"));
   }
 }
 function runConfigSetAction(opts) {
   runConfigSet(opts.key, opts.value, opts.configPath);
-  console.log(chalk22.green(`\u2714 set ${opts.key} = ${opts.value}`));
+  console.log(chalk23.green(`\u2714 set ${opts.key} = ${opts.value}`));
   if (isDaemonCachedKey(opts.key)) {
     const doRestart = opts.doRestart ?? restartDaemonIfRunning;
     const outcome = doRestart({ reason: `config ${opts.key}`, noRestart: opts.noRestart });
@@ -14406,9 +14794,9 @@ function runConfigSetAction(opts) {
   }
 }
 var SEV_COLOR = {
-  info: chalk22.green,
-  advisory: chalk22.yellow,
-  warn: chalk22.red
+  info: chalk23.green,
+  advisory: chalk23.yellow,
+  warn: chalk23.red
 };
 var KIND_GLYPH = {
   missing: "+",
@@ -14420,14 +14808,14 @@ function printItems(items) {
   for (const i of items) {
     const color = SEV_COLOR[i.severity] ?? ((s) => s);
     const detail = i.note ? `  (${i.note})` : i.suggested !== void 0 ? `  \u2192 ${JSON.stringify(i.suggested)}` : "";
-    console.log("  " + color(`${KIND_GLYPH[i.kind]} ${i.kind}: ${i.path}`) + chalk22.dim(detail));
+    console.log("  " + color(`${KIND_GLYPH[i.kind]} ${i.kind}: ${i.path}`) + chalk23.dim(detail));
   }
 }
-var configCommand = new Command22("config").description("Inspect and reconcile squadrant config");
+var configCommand = new Command23("config").description("Inspect and reconcile squadrant config");
 configCommand.command("check").description("Detect config drift vs the current default schema").option("--fix", "Apply the safe tier (add missing, remove deprecated)", false).option("--accept", "Stamp the current version without changing config (dismiss advisories)", false).option("--json", "Output drift items as JSON", false).action((opts) => {
   const pkgVersion = readPkgVersion2();
   if (!fs27.existsSync(DEFAULT_CONFIG_PATH)) {
-    console.log(chalk22.yellow("No config found \u2014 run `squadrant init` first."));
+    console.log(chalk23.yellow("No config found \u2014 run `squadrant init` first."));
     return;
   }
   const res = runConfigCheck({ configPath: DEFAULT_CONFIG_PATH, pkgVersion, fix: opts.fix, accept: opts.accept });
@@ -14436,21 +14824,21 @@ configCommand.command("check").description("Detect config drift vs the current d
     return;
   }
   if (res.items.length === 0) {
-    console.log(chalk22.green("\u2714 Config is in sync with the current schema."));
+    console.log(chalk23.green("\u2714 Config is in sync with the current schema."));
     return;
   }
-  console.log(chalk22.bold("\nConfig drift:\n"));
+  console.log(chalk23.bold("\nConfig drift:\n"));
   printItems(res.items);
   if (opts.fix && res.applied.length) {
-    console.log(chalk22.green(`
+    console.log(chalk23.green(`
 \u2714 Applied ${res.applied.length} safe item(s): ${res.applied.join(", ")}`));
   }
   const judgment = res.remaining.filter((i) => i.kind === "changed-default" || i.kind === "invalid");
   if (judgment.length) {
-    console.log(chalk22.yellow(`
+    console.log(chalk23.yellow(`
 ${judgment.length} item(s) need review \u2014 run the config-doctor skill, or \`squadrant config check --accept\` to keep your values.`));
   } else if (res.stamped) {
-    console.log(chalk22.green("\n\u2714 Config reconciled and stamped."));
+    console.log(chalk23.green("\n\u2714 Config reconciled and stamped."));
   }
 });
 configCommand.command("get").description("Read a config value by dotted key (e.g. defaults.effort)").argument("<key>", "dotted config key").action((key) => {
@@ -14458,7 +14846,7 @@ configCommand.command("get").description("Read a config value by dotted key (e.g
     const value = runConfigGet(key);
     console.log(typeof value === "string" ? value : JSON.stringify(value));
   } catch (e) {
-    console.error(chalk22.red(e.message));
+    console.error(chalk23.red(e.message));
     process.exit(1);
   }
 });
@@ -14466,7 +14854,7 @@ configCommand.command("set").description("Write a config value by dotted key (e.
   try {
     runConfigSetAction({ key, value, noRestart: opts.restart === false });
   } catch (e) {
-    console.error(chalk22.red(e.message));
+    console.error(chalk23.red(e.message));
     process.exit(1);
   }
 });
@@ -14476,8 +14864,8 @@ function readPkgVersion2() {
 }
 
 // packages/cli/src/commands/heal.ts
-import { Command as Command23 } from "commander";
-import chalk23 from "chalk";
+import { Command as Command24 } from "commander";
+import chalk24 from "chalk";
 init_dist2();
 init_dist2();
 function buildHealStatus(components) {
@@ -14518,15 +14906,15 @@ async function runHealStatus(opts) {
     return result.healthy ? 0 : 2;
   }
   if (result.healthy) {
-    stdout.write(chalk23.green("\u2714 all components healthy\n"));
+    stdout.write(chalk24.green("\u2714 all components healthy\n"));
     return 0;
   }
-  stdout.write(chalk23.bold("Unhealthy components:\n\n"));
+  stdout.write(chalk24.bold("Unhealthy components:\n\n"));
   for (const c of result.components) {
     if (c.healCmd) {
-      stdout.write(`  ${chalk23.red("\u2718")} ${c.kind.padEnd(8)} ${c.ref.padEnd(16)} ${chalk23.red(c.state.padEnd(8))} ${c.project}
+      stdout.write(`  ${chalk24.red("\u2718")} ${c.kind.padEnd(8)} ${c.ref.padEnd(16)} ${chalk24.red(c.state.padEnd(8))} ${c.project}
 `);
-      stdout.write(`      heal: ${chalk23.cyan(c.healCmd)}
+      stdout.write(`      heal: ${chalk24.cyan(c.healCmd)}
 `);
     }
   }
@@ -14537,7 +14925,7 @@ async function runHealDaemon(opts) {
   stdout.write("restarting squadrantd via launchd kickstart...\n");
   try {
     opts.ensureDaemon();
-    stdout.write(chalk23.green("\u2714 daemon kickstart complete\n"));
+    stdout.write(chalk24.green("\u2714 daemon kickstart complete\n"));
     return 0;
   } catch (e) {
     stderr.write(`heal daemon failed: ${e.message}
@@ -14545,8 +14933,8 @@ async function runHealDaemon(opts) {
     return 1;
   }
 }
-var healCommand = new Command23("heal").description("Targeted, idempotent remediation for squadrant components (daemon, health)").addHelpText("after", "\nDeferred: 'squadrant heal crew <id>' (re-attach) \u2014 see issue #100.").addCommand(
-  new Command23("status").description("Dry-run: print unhealthy components and the exact heal command for each").option("-p, --project <project>", "scope to one project").option("--json", "output machine-readable JSON (exit 0=healthy, 1=error, 2=unhealthy)").action(async (opts) => {
+var healCommand = new Command24("heal").description("Targeted, idempotent remediation for squadrant components (daemon, health)").addHelpText("after", "\nDeferred: 'squadrant heal crew <id>' (re-attach) \u2014 see issue #100.").addCommand(
+  new Command24("status").description("Dry-run: print unhealthy components and the exact heal command for each").option("-p, --project <project>", "scope to one project").option("--json", "output machine-readable JSON (exit 0=healthy, 1=error, 2=unhealthy)").action(async (opts) => {
     const code = await runHealStatus({
       project: opts.project,
       json: opts.json ?? false,
@@ -14557,7 +14945,7 @@ var healCommand = new Command23("heal").description("Targeted, idempotent remedi
     process.exit(code);
   })
 ).addCommand(
-  new Command23("daemon").description("Restart squadrantd via the idempotent launchd kickstart path").action(async () => {
+  new Command24("daemon").description("Restart squadrantd via the idempotent launchd kickstart path").action(async () => {
     const code = await runHealDaemon({
       ensureDaemon: () => restartDaemonIfRunning({ reason: "heal", isRunning: () => true }),
       stdout: process.stdout,
@@ -14568,15 +14956,15 @@ var healCommand = new Command23("heal").description("Targeted, idempotent remedi
 );
 
 // packages/cli/src/commands/group.ts
-import { Command as Command25 } from "commander";
-import chalk25 from "chalk";
+import { Command as Command26 } from "commander";
+import chalk26 from "chalk";
 
 // packages/cli/src/commands/dispatch.ts
 init_dist();
 init_dist2();
-import { Command as Command24 } from "commander";
+import { Command as Command25 } from "commander";
 import { execSync as execSync13 } from "child_process";
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 async function runDispatch(toProject, task, opts) {
   const fromProject = resolveCurrentProject(loadConfig());
   if (!fromProject) {
@@ -14601,21 +14989,21 @@ async function runDispatch(toProject, task, opts) {
 async function dispatchAction(toProject, task, opts) {
   try {
     const result = await runDispatch(toProject, task, opts);
-    console.log(chalk24.green(`\u2714 Dispatched to '${toProject}' (task ${result.id.slice(0, 8)})`));
-    console.log(chalk24.dim(`  originProject: ${result.originProject ?? "none"}`));
-    console.log(chalk24.dim("  You will be notified when the task settles (done/blocked/failed)."));
+    console.log(chalk25.green(`\u2714 Dispatched to '${toProject}' (task ${result.id.slice(0, 8)})`));
+    console.log(chalk25.dim(`  originProject: ${result.originProject ?? "none"}`));
+    console.log(chalk25.dim("  You will be notified when the task settles (done/blocked/failed)."));
   } catch (e) {
-    console.error(chalk24.red(`\u2718 ${e.message}`));
+    console.error(chalk25.red(`\u2718 ${e.message}`));
     process.exit(1);
   }
 }
-var dispatchCommand = new Command24("dispatch").description("Dispatch a task to any registered project (tracked, reports back on settle)").argument("<project>", "Target project name").argument("<task>", "Task description to dispatch").option("--provider <p>", "claude|opencode|codex", "claude").option("--mode <m>", "headless|interactive", "headless").option("--warmup-timeout <s>", "seconds to wait for target captain to boot (same-group only; default: 120)", (v) => parseInt(v, 10) * 1e3).action(dispatchAction);
+var dispatchCommand = new Command25("dispatch").description("Dispatch a task to any registered project (tracked, reports back on settle)").argument("<project>", "Target project name").argument("<task>", "Task description to dispatch").option("--provider <p>", "claude|opencode|codex", "claude").option("--mode <m>", "headless|interactive", "headless").option("--warmup-timeout <s>", "seconds to wait for target captain to boot (same-group only; default: 120)", (v) => parseInt(v, 10) * 1e3).action(dispatchAction);
 
 // packages/cli/src/commands/group.ts
 init_dist2();
-var groupCommand = new Command25("group").description("Cross-project intra-group operations (Phase 1: dispatch)").addCommand(
-  new Command25("dispatch").description("[DEPRECATED \u2014 use 'squadrant dispatch'] Dispatch a task to a sibling project in the same group").argument("<to-project>", "Target project name").argument("<task>", "Task description to dispatch").option("--provider <p>", "claude|opencode|codex", "claude").option("--mode <m>", "headless|interactive", "headless").option("--warmup-timeout <s>", "seconds to wait for target captain to boot (default: 120)", (v) => parseInt(v, 10) * 1e3).action(async (toProject, task, opts) => {
-    console.error(chalk25.yellow(
+var groupCommand = new Command26("group").description("Cross-project intra-group operations (Phase 1: dispatch)").addCommand(
+  new Command26("dispatch").description("[DEPRECATED \u2014 use 'squadrant dispatch'] Dispatch a task to a sibling project in the same group").argument("<to-project>", "Target project name").argument("<task>", "Task description to dispatch").option("--provider <p>", "claude|opencode|codex", "claude").option("--mode <m>", "headless|interactive", "headless").option("--warmup-timeout <s>", "seconds to wait for target captain to boot (default: 120)", (v) => parseInt(v, 10) * 1e3).action(async (toProject, task, opts) => {
+    console.error(chalk26.yellow(
       `\u26A0 'squadrant group dispatch' is deprecated \u2014 use 'squadrant dispatch <project> "<task>"' instead.`
     ));
     await dispatchAction(toProject, task, opts);
@@ -14626,8 +15014,8 @@ var groupCommand = new Command25("group").description("Cross-project intra-group
 init_dist();
 init_dist2();
 import { join as join26, dirname as dirname7 } from "path";
-import { Command as Command26 } from "commander";
-import chalk26 from "chalk";
+import { Command as Command27 } from "commander";
+import chalk27 from "chalk";
 init_require_daemon();
 async function runPing(project, message) {
   const config = loadConfig();
@@ -14643,20 +15031,20 @@ async function runPing(project, message) {
     source: "cli"
   });
 }
-var pingCommand = new Command26("ping").description("Fire-and-forget: deliver a message into a registered project's captain pane (no tracked task, no report-back)").argument("<project>", "Target project name (must be registered)").argument("<message>", "Message to deliver").action(async (project, message) => {
+var pingCommand = new Command27("ping").description("Fire-and-forget: deliver a message into a registered project's captain pane (no tracked task, no report-back)").argument("<project>", "Target project name (must be registered)").argument("<message>", "Message to deliver").action(async (project, message) => {
   try {
     await runPing(project, message);
-    console.log(chalk26.green(`\u2714 Pinged '${project}'`));
+    console.log(chalk27.green(`\u2714 Pinged '${project}'`));
   } catch (err) {
-    console.error(chalk26.red(err.message));
+    console.error(chalk27.red(err.message));
     process.exit(1);
   }
 });
 
 // packages/cli/src/commands/cmux.ts
 init_dist();
-import { Command as Command27 } from "commander";
-import chalk27 from "chalk";
+import { Command as Command28 } from "commander";
+import chalk28 from "chalk";
 async function runCmuxAutoconfig(opts) {
   const { json, stdout, stderr } = opts;
   let r;
@@ -14675,19 +15063,19 @@ async function runCmuxAutoconfig(opts) {
     stdout.write(`wrote cmux automation config \u2192 ${r.configPath}
 `);
   } else {
-    stdout.write(chalk27.dim(`cmux automation config already in place (${r.configPath})
+    stdout.write(chalk28.dim(`cmux automation config already in place (${r.configPath})
 `));
   }
   if (r.verdict === "reachable") {
-    stdout.write(chalk27.green("\u2714 daemon-direct delivery is reachable \u2014 cmux control socket accepts the daemon\n"));
+    stdout.write(chalk28.green("\u2714 daemon-direct delivery is reachable \u2014 cmux control socket accepts the daemon\n"));
     return 0;
   }
   if (r.needsRestart) {
     stdout.write(
-      chalk27.yellow("\u26A0 cmux is still on the old socket mode \u2014 restart cmux to enable daemon-direct delivery.\n")
+      chalk28.yellow("\u26A0 cmux is still on the old socket mode \u2014 restart cmux to enable daemon-direct delivery.\n")
     );
     if (r.promptedThisRun) {
-      stdout.write(chalk27.dim("  (one-time prompt \u2014 you won't be nagged again)\n"));
+      stdout.write(chalk28.dim("  (one-time prompt \u2014 you won't be nagged again)\n"));
     }
     return 2;
   }
@@ -14696,8 +15084,8 @@ async function runCmuxAutoconfig(opts) {
   );
   return 1;
 }
-var cmuxCommand = new Command27("cmux").description("cmux integration helpers").addCommand(
-  new Command27("autoconfig").description(
+var cmuxCommand = new Command28("cmux").description("cmux integration helpers").addCommand(
+  new Command28("autoconfig").description(
     "Write the cmux automation socket config and probe whether daemon-direct\ndelivery is reachable. Idempotent; prompts once if a cmux restart is needed."
   ).option("--json", "output machine-readable JSON (exit 0=reachable, 1=unknown, 2=restart-needed)").action(async (opts) => {
     const code = await runCmuxAutoconfig({
@@ -14714,8 +15102,8 @@ init_dist();
 init_dist2();
 import fs28 from "fs";
 import path29 from "path";
-import { Command as Command28 } from "commander";
-import chalk28 from "chalk";
+import { Command as Command29 } from "commander";
+import chalk29 from "chalk";
 var VALID_EFFORTS = ["max", "balance", "low"];
 var EFFORT_MEANING = {
   max: "tokens are plentiful \u2014 bias crew spawns toward claude/opus",
@@ -14780,29 +15168,29 @@ async function notifyCaptainsOfEffort(effort, config, driver, cwd = process.cwd(
     }
   }
 }
-var effortCommand = new Command28("effort").description("Get or set the crew tokenomics dial (max | balance | low) \u2014 global by default, or per-project with --project").argument("[value]", "effort level to set: max | balance | low").option("--project <name>", "target a specific project (get: show its resolved effort; set: write a per-project override)").action(async (value, options) => {
+var effortCommand = new Command29("effort").description("Get or set the crew tokenomics dial (max | balance | low) \u2014 global by default, or per-project with --project").argument("[value]", "effort level to set: max | balance | low").option("--project <name>", "target a specific project (get: show its resolved effort; set: write a per-project override)").action(async (value, options) => {
   if (value === void 0) {
     let result;
     try {
       result = runEffortGet(void 0, options.project);
     } catch (err) {
-      console.error(chalk28.red(err.message));
+      console.error(chalk29.red(err.message));
       process.exit(1);
     }
     const label = options.project ? `${options.project} project` : "global";
-    console.log(chalk28.bold(`Current effort (${label}):`), chalk28.cyan(result.effort));
-    console.log(chalk28.dim(EFFORT_MEANING[result.effort]));
+    console.log(chalk29.bold(`Current effort (${label}):`), chalk29.cyan(result.effort));
+    console.log(chalk29.dim(EFFORT_MEANING[result.effort]));
     return;
   }
   try {
     runEffortSet(value, void 0, options.project);
   } catch (err) {
-    console.error(chalk28.red(err.message));
+    console.error(chalk29.red(err.message));
     process.exit(1);
   }
   const effort = value;
-  console.log(chalk28.green(`\u2714 effort \u2192 ${effort} (${effortScopeLabel(options.project)})`));
-  console.log(chalk28.dim(EFFORT_MEANING[effort]));
+  console.log(chalk29.green(`\u2714 effort \u2192 ${effort} (${effortScopeLabel(options.project)})`));
+  console.log(chalk29.dim(EFFORT_MEANING[effort]));
   try {
     const { createCmuxDriver: createCmuxDriver2, RuntimeRegistry: RuntimeRegistry2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
     const config = loadConfig();
@@ -14812,7 +15200,7 @@ var effortCommand = new Command28("effort").description("Get or set the crew tok
     const append = (project, text) => appendCaptainMessage({ stateRoot, project, text, source: "daemon" });
     await notifyCaptainsOfEffort(effort, config, driver, process.cwd(), append, options.project);
   } catch {
-    console.log(chalk28.dim("(no running captain detected \u2014 change applies on next launch)"));
+    console.log(chalk29.dim("(no running captain detected \u2014 change applies on next launch)"));
   }
 });
 
@@ -14821,8 +15209,8 @@ init_dist();
 init_dist2();
 import { join as join27, dirname as dirname8 } from "path";
 import { emitKeypressEvents } from "readline";
-import { Command as Command29 } from "commander";
-import chalk29 from "chalk";
+import { Command as Command30 } from "commander";
+import chalk30 from "chalk";
 function defaultStateRoot() {
   return join27(dirname8(DEFAULT_CONFIG_PATH), "state");
 }
@@ -14869,11 +15257,11 @@ async function questionYesNo(prompt) {
     });
   });
 }
-var telegramCommand = new Command29("telegram").description("Two-way Telegram integration: push crew events to a topic and reply into the captain pane");
+var telegramCommand = new Command30("telegram").description("Two-way Telegram integration: push crew events to a topic and reply into the captain pane");
 telegramCommand.command("status").description("Show Telegram config and linked projects").action(() => {
   const { tokenSet, supergroupId, links } = runTelegramStatus({ config: loadConfig(), stateRoot: defaultStateRoot() });
-  console.log(`token: ${tokenSet ? chalk29.green("set") : chalk29.yellow("unset")}`);
-  console.log(`supergroup: ${supergroupId ?? chalk29.yellow("unset")}`);
+  console.log(`token: ${tokenSet ? chalk30.green("set") : chalk30.yellow("unset")}`);
+  console.log(`supergroup: ${supergroupId ?? chalk30.yellow("unset")}`);
   if (links.length === 0) {
     console.log("no projects linked");
     return;
@@ -14883,32 +15271,32 @@ telegramCommand.command("status").description("Show Telegram config and linked p
 telegramCommand.command("link").argument("<project>", "project to bind to a Telegram topic").description("Create (or reuse) a forum topic for a project and bind it").action(async (project) => {
   const cfg = loadConfig().telegram;
   if (!cfg) {
-    console.error(chalk29.red("telegram config absent \u2014 add a `telegram` block to ~/.config/squadrant/config.json"));
+    console.error(chalk30.red("telegram config absent \u2014 add a `telegram` block to ~/.config/squadrant/config.json"));
     process.exit(1);
   }
   const token = cfg.botToken ?? process.env.TELEGRAM_BOT_TOKEN;
   if (!token) {
-    console.error(chalk29.red("no botToken in config and TELEGRAM_BOT_TOKEN is unset"));
+    console.error(chalk30.red("no botToken in config and TELEGRAM_BOT_TOKEN is unset"));
     process.exit(1);
   }
   const client = createTelegramClient({ token });
   const { topicId, created } = await runTelegramLink({ project, cfg, client, stateRoot: defaultStateRoot() });
-  console.log(chalk29.green(`${created ? "linked" : "already linked"}: ${project} \u2192 topic ${topicId}`));
+  console.log(chalk30.green(`${created ? "linked" : "already linked"}: ${project} \u2192 topic ${topicId}`));
 });
 telegramCommand.command("setup").description("Interactive wizard \u2014 bot token, validate, auto-detect supergroup, write config").option("--reset-token", "force re-entry of the bot token even if one already exists").option("--redetect", "force group re-detection even when a supergroup is already configured").option("--user-id <id>", "allowlist user-id \u2014 enables remote control on a re-run without getUpdates detection", (v) => parseInt(v, 10)).action(async (opts) => {
   if (!process.stdin.isTTY) {
-    console.error(chalk29.red("setup requires a TTY \u2014 pipe input is not supported"));
+    console.error(chalk30.red("setup requires a TTY \u2014 pipe input is not supported"));
     process.exit(1);
   }
   console.log();
-  console.log(chalk29.bold("Telegram setup") + " \u2014 connect squadrant to a Telegram bot for notifications + remote control");
+  console.log(chalk30.bold("Telegram setup") + " \u2014 connect squadrant to a Telegram bot for notifications + remote control");
   console.log();
   console.log("Before you start you need:");
   console.log("  1. A bot token from @BotFather (send /newbot)");
   console.log("  2. A forum supergroup with the bot added as an admin (Topics enabled)");
   console.log("  3. Bot privacy mode set to OFF (@BotFather \u2192 /setprivacy \u2192 Disable)");
   console.log();
-  console.log(chalk29.bold("Step 1/3 \u2014 Bot token"));
+  console.log(chalk30.bold("Step 1/3 \u2014 Bot token"));
   const existingCfg = loadConfig().telegram;
   const existingToken = existingCfg?.botToken ?? process.env.TELEGRAM_BOT_TOKEN;
   const decision = resolveSetupToken(existingToken, { resetToken: opts.resetToken ?? false });
@@ -14920,67 +15308,67 @@ telegramCommand.command("setup").description("Interactive wizard \u2014 bot toke
     try {
       botUser = await client.getMe();
       token = existingToken;
-      console.log(chalk29.green(`Using existing bot token (@${botUser.username})`));
+      console.log(chalk30.green(`Using existing bot token (@${botUser.username})`));
       console.log();
     } catch {
-      console.log(chalk29.yellow("Existing token is invalid \u2014 please enter a new one."));
+      console.log(chalk30.yellow("Existing token is invalid \u2014 please enter a new one."));
       console.log("Paste your bot token then press Enter (input is hidden):");
       token = await questionMasked();
       if (!token) {
-        console.error(chalk29.red("token required"));
+        console.error(chalk30.red("token required"));
         process.exit(1);
       }
       client = createTelegramClient({ token });
       try {
         botUser = await client.getMe();
       } catch (e) {
-        console.error(chalk29.red(`token rejected: ${e.message}`));
+        console.error(chalk30.red(`token rejected: ${e.message}`));
         process.exit(1);
       }
-      console.log(chalk29.green(`Connected as @${botUser.username}`));
+      console.log(chalk30.green(`Connected as @${botUser.username}`));
       console.log();
     }
   } else {
     console.log("Paste your bot token then press Enter (input is hidden):");
     token = await questionMasked();
     if (!token) {
-      console.error(chalk29.red("token required"));
+      console.error(chalk30.red("token required"));
       process.exit(1);
     }
     client = createTelegramClient({ token });
     try {
       botUser = await client.getMe();
     } catch (e) {
-      console.error(chalk29.red(`token rejected: ${e.message}`));
+      console.error(chalk30.red(`token rejected: ${e.message}`));
       process.exit(1);
     }
-    console.log(chalk29.green(`Connected as @${botUser.username}`));
+    console.log(chalk30.green(`Connected as @${botUser.username}`));
     console.log();
   }
-  console.log(chalk29.bold("Step 2/3 \u2014 Supergroup"));
+  console.log(chalk30.bold("Step 2/3 \u2014 Supergroup"));
   const groupDecision = resolveSetupGroup(existingCfg?.supergroupId, { redetect: opts.redetect ?? false });
   let supergroupId;
   let detectedUserId;
   if (groupDecision === "reuse") {
     supergroupId = existingCfg.supergroupId;
-    console.log(chalk29.green(`Using existing group: ${supergroupId}`));
+    console.log(chalk30.green(`Using existing group: ${supergroupId}`));
     console.log();
   } else {
     console.log("Add the bot to your forum supergroup, then send any message in it.");
-    console.log(chalk29.dim("Waiting for a message (up to 60s)\u2026"));
+    console.log(chalk30.dim("Waiting for a message (up to 60s)\u2026"));
     try {
       ({ supergroupId, userId: detectedUserId } = await detectGroupAndUser(client, { timeoutMs: 6e4 }));
     } catch {
-      console.error(chalk29.red("Timed out \u2014 no supergroup message received within 60s."));
-      console.error(chalk29.yellow("Check: bot is an admin in the group \xB7 privacy mode is OFF \xB7 Topics enabled"));
+      console.error(chalk30.red("Timed out \u2014 no supergroup message received within 60s."));
+      console.error(chalk30.yellow("Check: bot is an admin in the group \xB7 privacy mode is OFF \xB7 Topics enabled"));
       process.exit(1);
     }
-    console.log(chalk29.green(`Found group: ${supergroupId}`));
+    console.log(chalk30.green(`Found group: ${supergroupId}`));
     console.log();
   }
-  console.log(chalk29.bold("Step 3/3 \u2014 Remote control + Save"));
-  console.log(chalk29.dim("Remote control enables auto-launching captains and the General command channel"));
-  console.log(chalk29.dim("from your phone \u2014 gated to your Telegram user-id only (fail-closed)."));
+  console.log(chalk30.bold("Step 3/3 \u2014 Remote control + Save"));
+  console.log(chalk30.dim("Remote control enables auto-launching captains and the General command channel"));
+  console.log(chalk30.dim("from your phone \u2014 gated to your Telegram user-id only (fail-closed)."));
   const finalUserId = resolveSetupUserId(opts.userId, detectedUserId, defaultStateRoot());
   let users;
   let remoteControl;
@@ -14994,32 +15382,32 @@ telegramCommand.command("setup").description("Interactive wizard \u2014 bot toke
       remoteControl = true;
     }
   } else if (groupDecision === "detect") {
-    console.log(chalk29.yellow("Could not read your user-id from that message \u2014 skipping remote control."));
-    console.log(chalk29.yellow("Re-run with --user-id <id> to enable, or edit telegram.users in config manually."));
+    console.log(chalk30.yellow("Could not read your user-id from that message \u2014 skipping remote control."));
+    console.log(chalk30.yellow("Re-run with --user-id <id> to enable, or edit telegram.users in config manually."));
     printedRemoteControlState = true;
   } else {
     const existingUsers = existingCfg?.users;
     if (existingUsers && existingUsers.length > 0) {
-      console.log(chalk29.dim(`Remote control: already configured (user-id ${existingUsers[0]}). Use --user-id to update.`));
+      console.log(chalk30.dim(`Remote control: already configured (user-id ${existingUsers[0]}). Use --user-id to update.`));
     } else {
-      console.log(chalk29.dim("Remote control: off. Re-run with --user-id <id> to enable."));
+      console.log(chalk30.dim("Remote control: off. Re-run with --user-id <id> to enable."));
     }
     printedRemoteControlState = true;
   }
   writeTelegramConfig(DEFAULT_CONFIG_PATH, { token, supergroupId, users, remoteControl });
-  console.log(chalk29.green(`Wrote telegram config \u2014 token: ${maskToken(token)}  group: ${supergroupId}`));
+  console.log(chalk30.green(`Wrote telegram config \u2014 token: ${maskToken(token)}  group: ${supergroupId}`));
   if (!printedRemoteControlState) {
     if (remoteControl) {
-      console.log(chalk29.green(`Remote control: ON (allowlisted user-id ${users[0]})`));
+      console.log(chalk30.green(`Remote control: ON (allowlisted user-id ${users[0]})`));
     } else {
-      console.log(chalk29.dim("Remote control: off (default). Re-run with --user-id <id> to enable."));
+      console.log(chalk30.dim("Remote control: off (default). Re-run with --user-id <id> to enable."));
     }
   }
   try {
     await runRegisterCommands({ client });
-    console.log(chalk29.dim("Registered the /command menu."));
+    console.log(chalk30.dim("Registered the /command menu."));
   } catch (e) {
-    console.log(chalk29.yellow(`command-menu registration skipped: ${e.message}`));
+    console.log(chalk30.yellow(`command-menu registration skipped: ${e.message}`));
   }
   const topics = loadState(defaultStateRoot()).topics;
   const topicEntries = Object.entries(topics);
@@ -15028,28 +15416,28 @@ telegramCommand.command("setup").description("Interactive wizard \u2014 bot toke
       const project = key.slice(0, key.indexOf("::"));
       return `${project}\u2192${id}`;
     }).join(", ");
-    console.log(chalk29.dim(`Existing topics: ${summary} (already created \u2014 not recreated)`));
+    console.log(chalk30.dim(`Existing topics: ${summary} (already created \u2014 not recreated)`));
   } else {
-    console.log(chalk29.dim("No project topics yet \u2014 they're created on first delivery or via: squadrant telegram link <project>"));
+    console.log(chalk30.dim("No project topics yet \u2014 they're created on first delivery or via: squadrant telegram link <project>"));
   }
   runTelegramPostSetup({});
   console.log();
-  console.log(`Next: ${chalk29.cyan("squadrant telegram link <project>")}`);
+  console.log(`Next: ${chalk30.cyan("squadrant telegram link <project>")}`);
 });
 telegramCommand.command("register-commands").description("Register (or re-register) the bot's / command menu with Telegram").action(async () => {
   const cfg = loadConfig().telegram;
   if (!cfg) {
-    console.error(chalk29.red("telegram config absent \u2014 run: squadrant telegram setup"));
+    console.error(chalk30.red("telegram config absent \u2014 run: squadrant telegram setup"));
     process.exit(1);
   }
   const token = cfg.botToken ?? process.env.TELEGRAM_BOT_TOKEN;
   if (!token) {
-    console.error(chalk29.red("no botToken in config and TELEGRAM_BOT_TOKEN is unset"));
+    console.error(chalk30.red("no botToken in config and TELEGRAM_BOT_TOKEN is unset"));
     process.exit(1);
   }
   const client = createTelegramClient({ token });
   await runRegisterCommands({ client });
-  console.log(chalk29.green(`registered ${BOT_COMMANDS.length} bot commands`));
+  console.log(chalk30.green(`registered ${BOT_COMMANDS.length} bot commands`));
 });
 telegramCommand.command("notify").argument("[project]", "project to toggle").argument("[state]", "on | off | crew | cap").argument("[value]", "tier for crew (all|alert_only|done_only|none) or on|off for cap").option("--status", "list notification state for all projects").description("Live on|off (state), or crew <tier> / cap <on|off> preference (per-project config)").action(async (project, state, value, opts) => {
   const stateRoot = defaultStateRoot();
@@ -15060,7 +15448,7 @@ telegramCommand.command("notify").argument("[project]", "project to toggle").arg
       return;
     }
     for (const r of rows) {
-      console.log(`  ${r.project}: ${r.active ? chalk29.green("on") : chalk29.dim("off (muted)")}`);
+      console.log(`  ${r.project}: ${r.active ? chalk30.green("on") : chalk30.dim("off (muted)")}`);
     }
     return;
   }
@@ -15069,53 +15457,53 @@ telegramCommand.command("notify").argument("[project]", "project to toggle").arg
   const token = tgCfg?.botToken ?? process.env.TELEGRAM_BOT_TOKEN;
   if (state === "crew" || state === "cap") {
     if (value === void 0) {
-      console.error(chalk29.red(`usage: squadrant telegram notify <project> ${state} <value>`));
+      console.error(chalk30.red(`usage: squadrant telegram notify <project> ${state} <value>`));
       process.exit(1);
     }
     const resolved2 = resolveNotify(globalNotify, loadProjectOverride(project));
     const before2 = { ...resolved2, active: isNotifyActive(stateRoot, project) };
     const res = runTelegramNotifyPref({ project, dimension: state, value });
     if (!res.ok) {
-      console.error(chalk29.red(res.message));
+      console.error(chalk30.red(res.message));
       process.exit(1);
     }
-    console.log(chalk29.green(`${project} ${state} = ${value}`));
+    console.log(chalk30.green(`${project} ${state} = ${value}`));
     const after2 = state === "crew" ? { ...before2, crew: value } : { ...before2, cap: value === "on" };
     if (tgCfg && token) {
       const client = createTelegramClient({ token });
       const sent = await runNotifyConfirmation({ project, before: before2, after: after2, cfg: tgCfg, client, stateRoot });
-      if (sent) console.log(chalk29.dim(`\u2192 notified ${project} topic`));
+      if (sent) console.log(chalk30.dim(`\u2192 notified ${project} topic`));
     }
     return;
   }
   if (state !== "on" && state !== "off") {
-    console.error(chalk29.red("usage: squadrant telegram notify <project> <on|off|crew <tier>|cap <on|off>>"));
+    console.error(chalk30.red("usage: squadrant telegram notify <project> <on|off|crew <tier>|cap <on|off>>"));
     process.exit(1);
   }
   const resolved = resolveNotify(globalNotify, loadProjectOverride(project));
   const before = { ...resolved, active: isNotifyActive(stateRoot, project) };
   const after = { ...before, active: state === "on" };
   runTelegramNotifySet({ project, active: state === "on", stateRoot });
-  console.log(chalk29.green(`${project} notifications ${state === "on" ? "ON" : "OFF"}`));
+  console.log(chalk30.green(`${project} notifications ${state === "on" ? "ON" : "OFF"}`));
   if (tgCfg && token) {
     const client = createTelegramClient({ token });
     const sent = await runNotifyConfirmation({ project, before, after, cfg: tgCfg, client, stateRoot });
-    if (sent) console.log(chalk29.dim(`\u2192 notified ${project} topic`));
+    if (sent) console.log(chalk30.dim(`\u2192 notified ${project} topic`));
   }
 });
 telegramCommand.command("send").argument("<project>", "project whose topic receives the message").argument("[message...]", "message text (omit to read from stdin)").description("Send a message to a project's linked Telegram topic").action(async (project, messageParts) => {
   const cfg = loadConfig().telegram;
   if (!cfg) {
-    console.error(chalk29.red("telegram config absent \u2014 add a `telegram` block to ~/.config/squadrant/config.json"));
+    console.error(chalk30.red("telegram config absent \u2014 add a `telegram` block to ~/.config/squadrant/config.json"));
     process.exit(1);
   }
   const token = cfg.botToken ?? process.env.TELEGRAM_BOT_TOKEN;
   if (!token) {
-    console.error(chalk29.red("no botToken in config and TELEGRAM_BOT_TOKEN is unset"));
+    console.error(chalk30.red("no botToken in config and TELEGRAM_BOT_TOKEN is unset"));
     process.exit(1);
   }
   if (!capAllowed(project, cfg.notify)) {
-    console.log(chalk29.dim(`${project}: captain messages muted (cap=off) \u2014 not sent`));
+    console.log(chalk30.dim(`${project}: captain messages muted (cap=off) \u2014 not sent`));
     return;
   }
   let message;
@@ -15128,19 +15516,19 @@ telegramCommand.command("send").argument("<project>", "project whose topic recei
     for await (const line of rl) lines.push(line);
     message = lines.join("\n").trimEnd();
     if (!message) {
-      console.error(chalk29.red("no message provided (stdin was empty)"));
+      console.error(chalk30.red("no message provided (stdin was empty)"));
       process.exit(1);
     }
   } else {
-    console.error(chalk29.red("message required \u2014 pass as argument or pipe via stdin"));
+    console.error(chalk30.red("message required \u2014 pass as argument or pipe via stdin"));
     process.exit(1);
   }
   const client = createTelegramClient({ token });
   try {
     const { chatId, topicId } = await runTelegramSend({ project, message, cfg, client, stateRoot: defaultStateRoot() });
-    console.log(chalk29.green(`sent to group ${chatId} topic ${topicId}`));
+    console.log(chalk30.green(`sent to group ${chatId} topic ${topicId}`));
   } catch (e) {
-    console.error(chalk29.red(e.message));
+    console.error(chalk30.red(e.message));
     process.exit(1);
   }
 });
@@ -15148,7 +15536,7 @@ telegramCommand.command("send").argument("<project>", "project whose topic recei
 // packages/cli/src/commands/hooks.ts
 init_dist2();
 init_dist4();
-import { Command as Command30 } from "commander";
+import { Command as Command31 } from "commander";
 import { join as join28 } from "path";
 import { homedir as homedir20 } from "os";
 var SOCK4 = join28(homedir20(), ".config", "squadrant", "squadrant.sock");
@@ -15175,7 +15563,7 @@ function mapHookSub(sub, payload, taskId) {
   }
 }
 function hooksCommand() {
-  const hooks = new Command30("hooks").description("(internal) receive lifecycle hook events from agent processes");
+  const hooks = new Command31("hooks").description("(internal) receive lifecycle hook events from agent processes");
   hooks.command("claude <sub>", { hidden: true }).description("internal: bridge a NativeHookSource claude hook to squadrantd").action(async (sub) => {
     const taskId = process.env.SQUADRANT_CREW_TASK_ID;
     const project = process.env.SQUADRANT_CREW_PROJECT;
@@ -15246,7 +15634,7 @@ if (process.argv[2] !== "config") {
 if (!process.env.SQUADRANT_DAEMON_SKIP) {
   ensureDaemon();
 }
-var program = new Command31();
+var program = new Command32();
 program.name("squadrant").description("Multi-project orchestration for your coding agents (Claude, Codex, opencode, Gemini)").version(pkg.version);
 program.addCommand(doctorCommand);
 program.addCommand(initCommand);
@@ -15255,6 +15643,7 @@ program.addCommand(statusCommand);
 addControlPlaneCrewCommands(crewCommand);
 program.addCommand(crewCommand);
 program.addCommand(sideCommand);
+program.addCommand(diffCommand);
 program.addCommand(commandCommand);
 program.addCommand(dashboardCommand);
 program.addCommand(launchCommand);