squadrant 0.14.2 → 0.14.3

package/dist/squadrantd.js

@@ -588,6 +588,8 @@ function recoverStall(rec, now) {
 }
 
 // packages/core/dist/daemon/reduce.js
+var DEFAULT_FIRST_TURN_UNDELIVERED_BUDGET_MS = 12e4;
+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;
@@ -708,6 +710,71 @@ function createDaemon(deps) {
   const { store, now } = deps;
   const lastCaptainTurnAt = /* @__PURE__ */ new Map();
   const quietNotifiedAt = /* @__PURE__ */ new Map();
+  const resendAttemptedAt = /* @__PURE__ */ new Map();
+  const firstTurnUndeliveredBudgetMs = deps.firstTurnUndeliveredBudgetMs ?? DEFAULT_FIRST_TURN_UNDELIVERED_BUDGET_MS;
+  const firstTurnResendCooldownMs = deps.firstTurnResendCooldownMs ?? DEFAULT_FIRST_TURN_RESEND_COOLDOWN_MS;
+  async function applyEvent(project, event) {
+    if (!KNOWN_EVENT_TYPES.has(event.type)) {
+      throw new Error(`unknown event type '${event.type}' \u2014 not a valid ControlEvent`);
+    }
+    const cur = store.get(project, event.id);
+    if (!cur)
+      throw new Error(`unknown task ${event.id}`);
+    if (event.type === "task.started")
+      lastCaptainTurnAt.set(event.id, now());
+    if (event.type === "task.session.ended" && !TERMINAL_STATES.has(cur.state)) {
+      const liveness = deps.isSurfaceAlive ? await deps.isSurfaceAlive(cur) : "unknown";
+      if (liveness !== "gone")
+        return cur;
+    }
+    const next = reduce(cur, event, now());
+    if (next !== cur) {
+      store.put(next);
+      firePush(deps, project, cur.state, next, event, lastCaptainTurnAt.get(next.id));
+    }
+    return next;
+  }
+  async function attemptFirstTurnRecovery(r, undeliveredMs) {
+    const lastAttempt = resendAttemptedAt.get(r.id);
+    if (lastAttempt != null && now() - lastAttempt < firstTurnResendCooldownMs)
+      return;
+    resendAttemptedAt.set(r.id, now());
+    const fresh = store.get(r.project, r.id);
+    if (!fresh || fresh.firstTurnConfirmedAt)
+      return;
+    const tag = crewTag(fresh);
+    const fireNotify = (message) => {
+      if (!deps.notify)
+        return;
+      const synthEvent = { type: "task.quiet", id: fresh.id, quietMs: undeliveredMs };
+      try {
+        const p = deps.notify({ project: fresh.project, message, record: store.get(fresh.project, fresh.id) ?? fresh, event: synthEvent });
+        if (p && typeof p.catch === "function")
+          p.catch(() => {
+          });
+      } catch {
+      }
+    };
+    if (!deps.resendFirstTurn) {
+      fireNotify(`\u26A0\uFE0F CREW UNDELIVERED ${tag}: first turn may not have landed (0 activity) \u2014 re-send the task or check the spawn.`);
+      return;
+    }
+    let result;
+    try {
+      result = await deps.resendFirstTurn(fresh);
+    } catch {
+      result = { delivered: false };
+    }
+    if (result.delivered) {
+      try {
+        await applyEvent(fresh.project, { type: "task.first-turn.confirmed", id: fresh.id });
+      } catch {
+      }
+      fireNotify(`\u{1F501} CREW FIRST-TURN AUTO-RESENT ${tag}: first turn had not landed after ${Math.round(undeliveredMs / 1e3)}s \u2014 re-sent automatically.`);
+    } else {
+      fireNotify(`\u26A0\uFE0F CREW UNDELIVERED ${tag}: first turn may not have landed \u2014 auto-resend attempted but the pane wasn't ready; will retry.`);
+    }
+  }
   return {
     async handle(req) {
       switch (req.kind) {
@@ -754,22 +821,7 @@ function createDaemon(deps) {
           if (!KNOWN_EVENT_TYPES.has(req.event.type)) {
             throw new Error(`unknown event type '${req.event.type}' \u2014 not a valid ControlEvent`);
           }
-          const cur = store.get(req.project, req.event.id);
-          if (!cur)
-            throw new Error(`unknown task ${req.event.id}`);
-          if (req.event.type === "task.started")
-            lastCaptainTurnAt.set(req.event.id, now());
-          if (req.event.type === "task.session.ended" && !TERMINAL_STATES.has(cur.state)) {
-            const liveness = deps.isSurfaceAlive ? await deps.isSurfaceAlive(cur) : "unknown";
-            if (liveness !== "gone")
-              return cur;
-          }
-          const next = reduce(cur, req.event, now());
-          if (next !== cur) {
-            store.put(next);
-            firePush(deps, req.project, cur.state, next, req.event, lastCaptainTurnAt.get(next.id));
-          }
-          return next;
+          return applyEvent(req.project, req.event);
         }
         case "status": {
           const r = store.get(req.project, req.id);
@@ -828,6 +880,7 @@ function createDaemon(deps) {
           store.delete(r.project, r.id);
         }
       }
+      const recoveryPromises = [];
       for (const r of store.listAll()) {
         if (TERMINAL_STATES.has(r.state) && t - r.lastHeartbeat > TERMINAL_RECORD_TTL_MS) {
           store.delete(r.project, r.id);
@@ -869,21 +922,9 @@ function createDaemon(deps) {
           }
         }
         if (r.mode === "interactive" && r.state === "submitted" && !r.firstTurnConfirmedAt) {
-          const elapsed = t - r.lastHeartbeat;
-          if (elapsed > r.heartbeatBudgetMs) {
-            if (deps.notify && quietNotifiedAt.get(r.id) !== r.lastHeartbeat) {
-              quietNotifiedAt.set(r.id, r.lastHeartbeat);
-              const tag = crewTag(r);
-              const synthEvent = { type: "task.quiet", id: r.id, quietMs: elapsed };
-              const message = `\u26A0\uFE0F CREW UNDELIVERED ${tag}: first turn may not have landed (crew never started) \u2014 re-send the task or check the spawn.`;
-              try {
-                const p = deps.notify({ project: r.project, message, record: r, event: synthEvent });
-                if (p && typeof p.catch === "function")
-                  p.catch(() => {
-                  });
-              } catch {
-              }
-            }
+          const undeliveredMs = t - r.createdAt;
+          if (undeliveredMs > firstTurnUndeliveredBudgetMs) {
+            recoveryPromises.push(attemptFirstTurnRecovery(r, undeliveredMs));
             continue;
           }
         }
@@ -894,7 +935,14 @@ function createDaemon(deps) {
           firePush(deps, r.project, r.state, idle, synthEvent, lastCaptainTurnAt.get(r.id));
           continue;
         }
-        if (r.mode === "interactive" && r.state === "working" && !r.pendingTool) {
+        if (r.mode === "interactive" && r.state === "working" && !r.pendingTool && !r.firstTurnConfirmedAt) {
+          const undeliveredMs = t - r.createdAt;
+          if (undeliveredMs > firstTurnUndeliveredBudgetMs) {
+            recoveryPromises.push(attemptFirstTurnRecovery(r, undeliveredMs));
+            continue;
+          }
+        }
+        if (r.mode === "interactive" && r.state === "working" && !r.pendingTool && r.firstTurnConfirmedAt) {
           const liveness = r.attempts.at(-1)?.lastHeartbeatAt ?? r.lastHeartbeat;
           const quiet = t - liveness;
           if (quiet > r.heartbeatBudgetMs) {
@@ -902,13 +950,8 @@ function createDaemon(deps) {
               quietNotifiedAt.set(r.id, liveness);
               const tag = crewTag(r);
               const synthEvent = { type: "task.quiet", id: r.id, quietMs: quiet };
-              let message;
-              if (!r.firstTurnConfirmedAt) {
-                message = `\u26A0\uFE0F CREW UNDELIVERED ${tag}: first turn may not have landed (0 activity) \u2014 re-send the task or check the spawn.`;
-              } else {
-                const mins = Math.max(1, Math.round(quiet / 6e4));
-                message = `CREW QUIET ${tag}: working ~${mins}min with no tool activity \u2014 likely deep thinking (no reply expected yet).`;
-              }
+              const mins = Math.max(1, Math.round(quiet / 6e4));
+              const message = `CREW QUIET ${tag}: working ~${mins}min with no tool activity \u2014 likely deep thinking (no reply expected yet).`;
               try {
                 const p = deps.notify({ project: r.project, message, record: r, event: synthEvent });
                 if (p && typeof p.catch === "function")
@@ -926,6 +969,7 @@ function createDaemon(deps) {
         if (recovered && t - r.lastHeartbeat <= r.heartbeatBudgetMs)
           store.put(recovered);
       }
+      await Promise.all(recoveryPromises);
     },
     async reconcile() {
       const alive = deps.isPidAlive ?? (() => true);
@@ -1639,6 +1683,7 @@ function buildContext(opts) {
     activeHeadlessKills: /* @__PURE__ */ new Set(),
     captainMissingStreak: /* @__PURE__ */ new Map(),
     stoppedProjects: /* @__PURE__ */ new Set(),
+    resendFirstTurn: opts.resendFirstTurn,
     // Late-bound — start.ts fills these before first use:
     d: null,
     notify: null,
@@ -2309,6 +2354,7 @@ function startDaemon(ctx, opts, pkgVersion) {
     notify,
     taskTimeoutMs,
     isSurfaceAlive: surfaceProbe,
+    resendFirstTurn: ctx.resendFirstTurn,
     launchHeadless: opts.launchHeadless,
     isHeadlessInFlight: (id) => inFlightHeadlessIds.has(id),
     launchInteractive: async (rec) => {
@@ -2549,6 +2595,21 @@ import crypto from "crypto";
 import fs8 from "fs";
 import path7 from "path";
 
+// packages/core/dist/crew-protocol.js
+function buildCompletionProtocol(taskId, project) {
+  return [
+    "---",
+    "COMPLETION PROTOCOL (required): When this task is fully complete, your FINAL action MUST be to run exactly:",
+    `  squadrant crew signal done --task-id ${taskId} --project ${project} --message "<one-line summary>"`,
+    "Run it as a discrete final step AFTER you report your results. If you are blocked or need a decision, instead run:",
+    `  squadrant crew signal blocked --task-id ${taskId} --project ${project} --question "<your question>"`,
+    "If this task failed because of a defect in squadrant itself (not an API/infra blip, a config/user error, or an expected failure), say so in your signal done/blocked message so the captain can check tu11aa/squadrant and file it. Don't file issues from the crew."
+  ].join("\n");
+}
+function titleFor(project, name) {
+  return `\u{1F527} ${project}:${name}`;
+}
+
 // packages/core/dist/crew-lifecycle.js
 import { exec as nodeExec } from "child_process";
 
@@ -4079,7 +4140,7 @@ var OpencodeSseBridge = class {
     const fetchImpl = this.deps.fetchImpl ?? fetch;
     const sleep3 = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     const reconnectMs = this.deps.reconnectMs ?? 500;
-    const maxBoot = this.deps.maxBootAttempts ?? 60;
+    const maxBoot = this.deps.maxBootAttempts ?? 240;
     const url = `http://127.0.0.1:${port}/event`;
     let booted = false;
     let bootAttempts = 0;
@@ -4433,6 +4494,27 @@ function parseDraftFromScreen(screen) {
   }
   return "";
 }
+function hasCCInputBox(screen) {
+  if (!screen)
+    return false;
+  const lines = screen.split(/\r?\n/);
+  const HR_RE = /^\s*─{10,}\s*$/;
+  let bottomHR = -1;
+  let topHR = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (HR_RE.test(lines[i])) {
+      if (bottomHR === -1)
+        bottomHR = i;
+      else {
+        topHR = i;
+        break;
+      }
+    }
+  }
+  if (topHR === -1)
+    return false;
+  return lines.slice(topHR + 1, bottomHR).some((l) => /[>❯]/.test(l));
+}
 function hasModalOptionList(screen) {
   if (!screen)
     return false;
@@ -4483,6 +4565,15 @@ function readInputBoxRaw(screen, opts) {
   const joined = parts.join("");
   return opts?.trim === false ? joined : joined.replace(/\s+$/, "");
 }
+var CC_INITIALIZED_RE = /⏵⏵|Ctx Used|for shortcuts|accept edits/i;
+var CC_WORKING_RE = /↓\s*[\d.]+\s*k?\s*tokens?\b|esc to interrupt|\bshell still running\b|·\s*\d+\s*shell\b|\(\d+m?\s*\d*s\b/i;
+function classifyStartupSurface(screen) {
+  if (CC_WORKING_RE.test(screen))
+    return "working";
+  if (CC_INITIALIZED_RE.test(screen))
+    return "idle";
+  return "loading";
+}
 function sendDebugEnabled() {
   return !!process.env.SQUADRANT_DEBUG_SEND;
 }
@@ -5315,6 +5406,67 @@ function defaultWriteFile(path17, content) {
 
 // packages/workspaces/dist/crew-pane.js
 import net from "net";
+var POST_SEND_CHECK_MS = 750;
+var SETTLE_POLL_MS = 400;
+var SETTLE_MAX_POLLS = 8;
+var SUBMIT_RETRY_LIMIT = 4;
+async function settleInputBox(runtime, pane) {
+  let prev = await runtime.readPaneScreen(pane) ?? "";
+  let sawContent = parseDraftFromScreen(prev) !== "" && parseDraftFromScreen(prev) !== null;
+  for (let i = 0; i < SETTLE_MAX_POLLS; i++) {
+    await new Promise((r) => setTimeout(r, SETTLE_POLL_MS));
+    const cur = await runtime.readPaneScreen(pane) ?? "";
+    const draft = parseDraftFromScreen(cur);
+    if (draft !== "" && draft !== null)
+      sawContent = true;
+    if (cur === prev)
+      return sawContent;
+    prev = cur;
+  }
+  return sawContent;
+}
+async function confirmedSendToPane(runtime, pane, message) {
+  const preSendScreen = await runtime.readPaneScreen(pane) ?? "";
+  await runtime.pasteToPane(pane, message);
+  let sawDraft = await settleInputBox(runtime, pane);
+  await runtime.sendKeyToPane(pane, "Enter");
+  let repasted = false;
+  for (let attempt = 0; attempt < SUBMIT_RETRY_LIMIT; attempt++) {
+    await new Promise((r) => setTimeout(r, POST_SEND_CHECK_MS));
+    const afterScreen = await runtime.readPaneScreen(pane) ?? "";
+    const draft = parseDraftFromScreen(afterScreen);
+    if (draft !== "" && draft !== null)
+      sawDraft = true;
+    if (draft === "" && sawDraft)
+      return { delivered: true };
+    if (draft === null && afterScreen !== preSendScreen && sawDraft)
+      return { delivered: true };
+    const settled = await settleInputBox(runtime, pane);
+    if (settled)
+      sawDraft = true;
+    if (!sawDraft && !repasted) {
+      repasted = true;
+      await runtime.pasteToPane(pane, message);
+    }
+    await runtime.sendKeyToPane(pane, "Enter");
+  }
+  return { delivered: false };
+}
+async function resendCrewFirstTurn(runtime, captainName, project, name, message) {
+  const captain = await runtime.status(captainName);
+  if (!captain)
+    return { delivered: false };
+  const surfaces = await runtime.listSurfaces(captain.id);
+  const want = titleFor(project, name);
+  const pane = surfaces.find((s) => s.title === want);
+  if (!pane)
+    return { delivered: false };
+  const screen = await runtime.readPaneScreen(pane) ?? "";
+  if (!hasCCInputBox(screen) || classifyStartupSurface(screen) !== "idle") {
+    return { delivered: false };
+  }
+  return confirmedSendToPane(runtime, pane, message);
+}
 
 // packages/cli/src/squadrantd.ts
 var SELF_PATH2 = fileURLToPath3(import.meta.url);
@@ -5418,6 +5570,16 @@ function startSquadrantd(opts = {}) {
   const tgCfg = loadConfig().telegram;
   ctx.telegramBridge = opts.telegramBridge ?? (tgCfg && !process.env.VITEST ? buildTelegramBridge(tgCfg, stateRoot, log) : void 0);
   ctx.daemonCmux = opts.daemonCmux ?? (opts.makeDaemonCmux ?? (() => new DaemonCmux(createCmuxDriver())))();
+  const resendRuntime = createCmuxDriver();
+  ctx.resendFirstTurn = opts.resendFirstTurn ?? (async (rec) => {
+    if (rec.provider !== "claude" || !rec.name) return { delivered: false };
+    const proj = loadConfig().projects[rec.project];
+    const captainName = proj?.captainName ?? `${rec.project}-captain`;
+    const message = `${rec.task}
+
+${buildCompletionProtocol(rec.id, rec.project)}`;
+    return resendCrewFirstTurn(resendRuntime, captainName, rec.project, rec.name, message);
+  });
   const launchHeadless = opts.launchHeadless ?? (async (rec) => {
     const ingest = (e) => void ctx.d.handle({ kind: "event", project: rec.project, event: e });
     const handle = runHeadless({