squadrant 0.16.4 → 0.16.6

package/dist/squadrantd.js

@@ -490,6 +490,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 };
@@ -497,6 +500,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 };
@@ -513,20 +521,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" };
@@ -534,8 +545,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 };
@@ -546,19 +562,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":
@@ -579,15 +595,22 @@ function reduce(rec, ev, now) {
 
 // packages/core/dist/watchdog.js
 var TOOL_STALL_BUDGET_MS = 10 * 60 * 1e3;
-function evaluateStall(rec, now, toolStallMs = TOOL_STALL_BUDGET_MS) {
+var MONITOR_STALL_BUDGET_MS = 60 * 60 * 1e3;
+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)
@@ -597,7 +620,7 @@ 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 };
 }
 
 // packages/core/dist/daemon/reduce.js
@@ -606,8 +629,8 @@ var DEFAULT_FIRST_TURN_RESEND_COOLDOWN_MS = 6e4;
 var DEFAULT_TASK_TIMEOUT_MS = 8 * 60 * 60 * 1e3;
 var TERMINAL_RECORD_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var TERMINAL_RECORD_KEEP_PER_PROJECT = 20;
-var ATTENTION_STATES = /* @__PURE__ */ new Set(["done", "blocked", "failed", "stalled", "awaiting-input"]);
-var REAPABLE_SURFACE_STATES = /* @__PURE__ */ new Set(["working", "stalled", "awaiting-input", "blocked"]);
+var ATTENTION_STATES = /* @__PURE__ */ new Set(["done", "blocked", "review", "failed", "stalled", "awaiting-input"]);
+var REAPABLE_SURFACE_STATES = /* @__PURE__ */ new Set(["working", "stalled", "awaiting-input", "blocked", "review"]);
 var IDLE_DEBOUNCE_MS = 12e3;
 function shortId(id) {
   return id.slice(0, 8);
@@ -629,6 +652,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": {
@@ -699,6 +726,7 @@ var KNOWN_EVENT_TYPES = /* @__PURE__ */ new Set([
   "task.progress",
   "heartbeat",
   "task.blocked",
+  "task.review",
   "task.done",
   "task.failed",
   "task.session",
@@ -899,7 +927,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;
@@ -944,7 +972,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;
         }
@@ -2074,9 +2102,11 @@ function buildSurfaceProbe(ctx, probes, daemonCmux) {
 // packages/core/dist/delivery/defer-delivery.js
 var 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";
   }
 };
@@ -2094,6 +2124,7 @@ var CaptainDelivery = class {
   deferCounts = /* @__PURE__ */ new Map();
   lastContent = /* @__PURE__ */ new Map();
   stableCounts = /* @__PURE__ */ new Map();
+  lastReason = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.opts = opts;
   }
@@ -2116,29 +2147,40 @@ var CaptainDelivery = class {
       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 };
   }
 };
 
@@ -2238,6 +2280,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,
@@ -2327,16 +2373,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);
@@ -2841,8 +2890,12 @@ var REGISTRY = {
     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]",
@@ -3027,6 +3080,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":
@@ -3223,6 +3279,7 @@ var DONE_ONLY = /* @__PURE__ */ new Set(["task.done", "task.failed"]);
 var ALERTS = /* @__PURE__ */ new Set([
   ...DONE_ONLY,
   "task.blocked",
+  "task.review",
   "task.approval.requested",
   "task.input.requested",
   "task.timeout"
@@ -4658,6 +4715,18 @@ function cmux(args) {
     );
   });
 }
+function cmuxStdin(args, input) {
+  return new Promise((resolve2, 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;
+      }
+      resolve2(stdout.trim());
+    });
+    child.stdin.end(input);
+  });
+}
 function parseList(output) {
   let parsed;
   try {
@@ -5016,9 +5085,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;
@@ -5059,6 +5128,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 {
@@ -5648,6 +5748,7 @@ function installClaudeHooks(opts = {}) {
   });
   let settings = {};
   const raw = readFile6(settingsPath);
+  const hadExistingSettings = raw !== void 0;
   if (raw) {
     try {
       settings = JSON.parse(raw);
@@ -5660,6 +5761,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] = [];
@@ -5671,6 +5773,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) {
@@ -5707,9 +5829,9 @@ var NativeHookSource = class {
   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;
@@ -6021,7 +6143,7 @@ function startSquadrantd(opts = {}) {
     log
   });
   const cmuxStoreSource = new CmuxStoreSource({ log });
-  const nativeHookSource = new NativeHookSource({ log });
+  const nativeHookSource = new NativeHookSource({ log, hookInstall: { claudeEnv: loadConfig().defaults.claudeEnv } });
   ctx.codexDriver = codexDriver;
   ctx.opencodeBridge = opencodeBridge;
   ctx.cmuxEventsBridge = cmuxEventsBridge;