squadrant 0.16.3 → 0.16.5

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 };
@@ -518,7 +521,7 @@ function reduce(rec, ev, now) {
       };
     case "task.progress": {
       const pendingTool = nextPendingTool(rec.pendingTool, ev, now);
-      if (rec.state === "blocked")
+      if (isStickyAttention(rec.state))
         return { ...rec, lastHeartbeat: now, lastEvent: ev.type, pendingTool };
       const b = { ...base, pendingTool };
       if (rec.state === "awaiting-input" || rec.state === "stalled")
@@ -526,7 +529,7 @@ function reduce(rec, ev, now) {
       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" };
@@ -535,7 +538,12 @@ function reduce(rec, ev, now) {
       if (rec.state === "blocked")
         return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
       return { ...base, state: "blocked", question: ev.question, pendingTool: void 0 };
+    case "task.review":
+      return { ...base, state: "review", reviewNote: ev.message, pendingTool: 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 };
@@ -548,7 +556,7 @@ function reduce(rec, ev, now) {
     case "task.turn.started":
       return { ...stampAttempt(base, {}, now), state: "working", pendingTool: void 0 };
     case "task.turn.completed":
-      if (rec.state === "blocked")
+      if (isStickyAttention(rec.state))
         return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
       if (rec.pendingTool)
         return stampAttempt(base, {}, now);
@@ -606,8 +614,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 +637,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 +711,7 @@ var KNOWN_EVENT_TYPES = /* @__PURE__ */ new Set([
   "task.progress",
   "heartbeat",
   "task.blocked",
+  "task.review",
   "task.done",
   "task.failed",
   "task.session",
@@ -1457,13 +1470,14 @@ function projectHealth(input) {
   const { project, now, captainName, captainStopped, commandPresent, crews } = input;
   const out = [];
   const captainState = input.captainState ?? (captainStopped === true ? "stopped" : captainStopped === false ? "alive" : "unknown");
+  const deferral = input.captainDeferral;
   out.push({
     kind: "captain",
     project,
     ref: captainName,
     state: captainState,
     lastSeenMs: null,
-    detail: captainState === "stopped" ? "captain workspace closed \u2014 crews reaped; delivery paused" : captainState === "gone" ? "captain process died (crash) \u2014 crews reaped" : void 0
+    detail: captainState === "stopped" ? "captain workspace closed \u2014 crews reaped; delivery paused" : captainState === "gone" ? "captain process died (crash) \u2014 crews reaped" : deferral?.stuck ? `\u26A0\uFE0F delivery stuck (${deferral.maxDeferCount}+ retries) \u2014 draft/ghost text blocking captain pane; input never touched, delivers automatically once cleared` : void 0
   });
   if (commandPresent !== null) {
     out.push({
@@ -1797,6 +1811,8 @@ function buildContext(opts) {
     opencodeBridge: null,
     cmuxEventsBridge: null,
     telegramBridge: void 0,
+    notifyFault: opts.notifyFault ?? (() => {
+    }),
     lifecycleSources: opts.lifecycleSources ?? [],
     broadcast: () => {
     },
@@ -2107,7 +2123,7 @@ var CaptainDelivery = class {
     const seq = entry.seq;
     const deferCount = this.deferCounts.get(seq) ?? 0;
     const stable = (this.stableCounts.get(seq) ?? 0) >= this.opts.stableProbePolls;
-    const probe = stable || deferCount >= this.opts.maxDefers;
+    const probe = stable;
     try {
       await send(msg, probe ? { probe: true } : void 0);
       this.deferCounts.delete(seq);
@@ -2231,7 +2247,9 @@ async function runLivenessTick(deps) {
   }
 }
 function createDelivery(ctx, daemonCmux) {
-  const { stateRoot, store, log, livenessRegistry, isPidAlive, opts } = ctx;
+  const { stateRoot, store, log, livenessRegistry, isPidAlive, opts, telegramBridge } = ctx;
+  const notifyFault = ctx.notifyFault ?? (() => {
+  });
   const defaultNotify = async (args) => {
     try {
       await appendToMailbox({
@@ -2254,6 +2272,7 @@ function createDelivery(ctx, daemonCmux) {
   const cfg = loadConfig();
   const deliveries = /* @__PURE__ */ new Map();
   const deliveryStats = (project) => deliveries.get(project)?.stats();
+  const stuckNotified = /* @__PURE__ */ new Set();
   const sessionStartMs = Date.now();
   let delivering = false;
   const deliveryCore = async () => {
@@ -2325,6 +2344,18 @@ function createDelivery(ctx, daemonCmux) {
           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.`;
+        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);
+      } else if (!stuck && stuckNotified.has(project)) {
+        stuckNotified.delete(project);
+      }
     }
   };
   const deliveryTick = async () => {
@@ -2575,7 +2606,12 @@ function startDaemon(ctx, opts, pkgVersion) {
         captainStopped: null,
         captainState: deriveCaptainState(capEntry),
         commandPresent: null,
-        crews: store.list(project)
+        crews: store.list(project),
+        // #579/#484 Gap 3: surface the same deferral stats already exposed to
+        // the snapshot (line ~135 below) on the health row too, so `squadrant
+        // doctor` / `squadrant status --detailed` show a stuck delivery with
+        // zero configuration.
+        captainDeferral: deliveryStats(project)
       }));
     }
     return out;
@@ -2818,8 +2854,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]",
@@ -3004,6 +3044,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":
@@ -3200,6 +3243,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"
@@ -3259,6 +3303,14 @@ function createTelegramBridge(opts) {
     s.offset = next;
     saveState(stateRoot, s);
   }
+  async function sendToTopic(project, text) {
+    let threadId = loadState(stateRoot).topics[topicKey(project)];
+    if (threadId === void 0) {
+      threadId = await client.createForumTopic(cfg.supergroupId, topicName(project));
+      setTopic(stateRoot, project, threadId);
+    }
+    await client.sendMessage(cfg.supergroupId, threadId, text);
+  }
   async function deliverOutbound(project, ev) {
     const resolved = resolveNotify(cfg.notify, loadProjectOverride(project, configRoot));
     const live = loadState(stateRoot).notify[project];
@@ -3267,12 +3319,10 @@ function createTelegramBridge(opts) {
       return;
     if (!tierIncludes(resolved.crew, ev.type))
       return;
-    let threadId = loadState(stateRoot).topics[topicKey(project)];
-    if (threadId === void 0) {
-      threadId = await client.createForumTopic(cfg.supergroupId, topicName(project));
-      setTopic(stateRoot, project, threadId);
-    }
-    await client.sendMessage(cfg.supergroupId, threadId, formatLifecycle(project, ev));
+    await sendToTopic(project, formatLifecycle(project, ev));
+  }
+  async function deliverRawOutbound(project, text) {
+    await sendToTopic(project, text);
   }
   function resolveLiveNotify(project) {
     const resolved = resolveNotify(cfg.notify, loadProjectOverride(project, configRoot));
@@ -3580,6 +3630,11 @@ function createTelegramBridge(opts) {
         log(`telegram outbound failed project=${project}: ${e.message}`);
       });
     },
+    pushRaw(project, text) {
+      void deliverRawOutbound(project, text).catch((e) => {
+        log(`telegram raw push failed project=${project}: ${e.message}`);
+      });
+    },
     health() {
       return { polling: running, lastSuccessfulPollAt, lastError, lastErrorAt };
     }
@@ -4624,6 +4679,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 {
@@ -5025,6 +5092,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 {
@@ -5090,7 +5188,60 @@ var RuntimeRegistry = class {
 };
 
 // packages/workspaces/dist/notifiers/cmux.js
-import { execFileSync as execFileSync6, execSync as execSync7 } from "child_process";
+import { execFile as execFileCb, execSync as execSync7 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFile3 = promisify2(execFileCb);
+function createCmuxNotifier(_scope) {
+  return {
+    name: "cmux",
+    async probe() {
+      try {
+        execSync7("squadrant runtime status --command", { encoding: "utf-8", stdio: "pipe" });
+        return { installed: true, reachable: true };
+      } catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+          return { installed: false, reachable: false };
+        }
+        return { installed: true, reachable: false };
+      }
+    },
+    async notify(message) {
+      await execFile3("squadrant", ["runtime", "send", "--command", message], { encoding: "utf-8", timeout: CMUX_TIMEOUT });
+    }
+  };
+}
+
+// packages/workspaces/dist/notifiers/registry.js
+var DEFAULT_NOTIFIER = "cmux";
+var NotifierRegistry = class {
+  factories;
+  constructor(factories) {
+    this.factories = factories;
+  }
+  get(config) {
+    const name = config.notifier ?? DEFAULT_NOTIFIER;
+    return this.getFactory(name)({});
+  }
+  getFactory(name) {
+    const factory = this.factories[name];
+    if (!factory) {
+      throw new Error(`Unknown notifier provider '${name}' \u2014 no factory registered`);
+    }
+    return factory;
+  }
+  async probeAll() {
+    const results = {};
+    for (const [name, factory] of Object.entries(this.factories)) {
+      try {
+        results[name] = await factory({}).probe();
+      } catch {
+        results[name] = { installed: false, reachable: false };
+      }
+    }
+    return results;
+  }
+};
 
 // packages/workspaces/dist/workspaces/obsidian.js
 import fs16 from "fs/promises";
@@ -5868,6 +6019,16 @@ function buildTelegramBridge(cfg, stateRoot, log) {
     sendReply
   });
 }
+function buildNotifyFault(log) {
+  const registry = new NotifierRegistry({ cmux: createCmuxNotifier });
+  return async (project, text) => {
+    try {
+      await registry.get(loadConfig()).notify(`[${project}] ${text}`);
+    } catch (e) {
+      log(`fault notify failed project=${project}: ${e.message}`);
+    }
+  };
+}
 function startSquadrantd(opts = {}) {
   const ctx = buildContext(opts);
   const { stateRoot, store, log, spawn: spawn2, writeResult, inFlightHeadlessIds, activeHeadlessKills } = ctx;
@@ -5931,6 +6092,8 @@ function startSquadrantd(opts = {}) {
   ctx.lifecycleSources = [cmuxStoreSource, nativeHookSource, codexAppServerSource];
   const tgCfg = loadConfig().telegram;
   ctx.telegramBridge = opts.telegramBridge ?? (tgCfg && !process.env.VITEST ? buildTelegramBridge(tgCfg, stateRoot, log) : void 0);
+  if (opts.notifyFault) ctx.notifyFault = opts.notifyFault;
+  else if (!process.env.VITEST) ctx.notifyFault = buildNotifyFault(log);
   ctx.daemonCmux = opts.daemonCmux ?? (opts.makeDaemonCmux ?? (() => new DaemonCmux(createCmuxDriver())))();
   const resendRuntime = createCmuxDriver();
   ctx.resendFirstTurn = opts.resendFirstTurn ?? (async (rec) => {