squadrant 0.19.4 → 0.19.5

package/dist/index.js

@@ -1587,6 +1587,11 @@ function reduce(rec, ev, now) {
       return stampAttempt(base, { resumeRef: ev.resumeRef }, now);
     case "task.turn.started":
       return { ...stampAttempt(base, {}, now), state: "working", pendingTool: void 0, pendingMonitor: void 0 };
+    case "task.turn.failed":
+    // #763: a crew's turn died on an API error (StopFailure hook). Anti-#2576:
+    // NOT task.failed — a hook may never terminalize a task. Falls through to
+    // the exact same turn-boundary transition as task.turn.completed below;
+    // only the notify message (reduce.ts formatMessage) differs.
     case "task.turn.completed":
       if (isStickyAttention(rec.state))
         return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
@@ -1702,6 +1707,9 @@ function formatMessage(rec, event) {
       return `CREW STALLED ${tag}: no heartbeat in ${rec.heartbeatBudgetMs}ms`;
     }
     case "awaiting-input":
+      if (event?.type === "task.turn.failed") {
+        return `CREW TURN FAILED ${tag}: API error ended the turn (not a stall) \u2014 ${event.error}`;
+      }
       return `CREW IDLE ${tag}: turn ended, awaiting your reply.`;
     default:
       return null;
@@ -2111,6 +2119,7 @@ var init_reduce = __esm({
       "task.session",
       "task.turn.started",
       "task.turn.completed",
+      "task.turn.failed",
       "task.delta",
       "task.input.requested",
       "task.approval.requested",
@@ -9219,6 +9228,10 @@ function mapSubToLifecycle(sub) {
       return "needsInput";
     case "ask-question":
       return "needsInput";
+    case "permission-request":
+      return "needsInput";
+    case "stop-failure":
+      return "idle";
     case "session-end":
       return "session-end";
     default:
@@ -9260,7 +9273,13 @@ var init_native_hook_source = __esm({
       ["Stop", "stop"],
       ["Notification", "notification"],
       ["PreToolUse", "ask-question", "AskUserQuestion"],
-      ["SessionEnd", "session-end"]
+      ["SessionEnd", "session-end"],
+      // #760: fires ~6s before the matching Notification, carrying tool_name +
+      // tool_input directly — a strictly better task.blocked source.
+      ["PermissionRequest", "permission-request"],
+      // #763: the turn died on an API error — today squadrant has no source for
+      // this at all; without it the watchdog reports a plain stall (wrong story).
+      ["StopFailure", "stop-failure"]
     ];
     DEFAULT_HOOK_CMD = "squadrant hooks";
     NativeHookSource = class {
@@ -9625,12 +9644,12 @@ function createClaudeDriver() {
       if (opts.settingsPath) {
         cmd += ` --settings ${opts.settingsPath}`;
       }
-      if (opts.messagingSocketPath) {
-        cmd += ` --messaging-socket-path ${opts.messagingSocketPath}`;
-      }
       const pluginSubdir = opts.role === "crew" ? "plugin-crew" : "plugin";
       const pluginDir = `${process.env.HOME}/.config/squadrant/${pluginSubdir}`;
       cmd += ` --plugin-dir ${pluginDir}`;
+      if (opts.messagingSocketPath) {
+        cmd += ` --messaging-socket-path ${opts.messagingSocketPath}`;
+      }
       if (!opts.interactive) {
         cmd += ` -p "${opts.prompt.replace(/"/g, '\\"')}"`;
       }
@@ -11389,6 +11408,70 @@ function decideCaptainMemoryWrite(toolName, toolInput, env, homeDir) {
     return { decision: "allow" };
   return { decision: "deny", reason: DENY_REASON };
 }
+function resolveTurnId(payload) {
+  const id = payload?.prompt_id;
+  return typeof id === "string" && id.trim() ? id : "hook-stop";
+}
+function logStopPermissionMode(payload, taskId) {
+  const mode = payload?.permission_mode;
+  if (typeof mode === "string" && mode) {
+    console.error(`[squadrant] hook: Stop permission_mode=${mode} task=${taskId}`);
+  }
+}
+function classifyNotification(payload) {
+  const p = payload;
+  const msg = typeof p?.message === "string" ? p.message : "";
+  const notificationType = typeof p?.notification_type === "string" ? p.notification_type : null;
+  if (notificationType === "permission_prompt" || notificationType === "worker_permission_prompt") {
+    return { kind: "blocked", question: msg || "crew awaiting permission" };
+  }
+  if (notificationType === "agent_needs_input") {
+    return { kind: "input-requested", question: msg || "crew needs input" };
+  }
+  if (notificationType != null) {
+    return { kind: "progress" };
+  }
+  if (msg && isPermissionNotification(msg)) {
+    return { kind: "blocked", question: msg };
+  }
+  return { kind: "progress" };
+}
+function summarizeToolInput(toolName, toolInput) {
+  if (typeof toolName !== "string" || !toolName)
+    return "a tool call";
+  const input = toolInput;
+  if (!input || typeof input !== "object")
+    return toolName;
+  const hintField = FILE_PATH_FIELD_BY_TOOL[toolName] ?? (toolName === "Bash" ? "command" : void 0);
+  const raw = hintField ? input[hintField] : void 0;
+  if (typeof raw === "string" && raw) {
+    const short = raw.length > TOOL_INPUT_HINT_LEN ? `${raw.slice(0, TOOL_INPUT_HINT_LEN)}\u2026` : raw;
+    return `${toolName}(${short})`;
+  }
+  return toolName;
+}
+function formatPermissionRequestQuestion(payload) {
+  const p = payload;
+  return `crew needs permission to run ${summarizeToolInput(p?.tool_name, p?.tool_input)}`;
+}
+function hasActiveBackgroundWork(payload) {
+  const p = payload;
+  const tasks = p?.background_tasks;
+  if (Array.isArray(tasks) && tasks.length > 0)
+    return true;
+  const crons = p?.session_crons;
+  if (Array.isArray(crons) && crons.length > 0)
+    return true;
+  return false;
+}
+function redactApiError(error) {
+  if (typeof error !== "string" || !error.trim())
+    return "unknown API error";
+  let scrubbed = error.trim();
+  for (const re of SECRET_PATTERNS)
+    scrubbed = scrubbed.replace(re, "[redacted]");
+  return scrubbed.length > MAX_API_ERROR_LEN ? `${scrubbed.slice(0, MAX_API_ERROR_LEN)}\u2026` : scrubbed;
+}
 function mapClaudeHookToEvent(event, payload, taskId) {
   switch (event) {
     case "PreToolUse": {
@@ -11396,7 +11479,7 @@ function mapClaudeHookToEvent(event, payload, taskId) {
       if (toolName !== "AskUserQuestion")
         return null;
       const question = formatAskUserQuestionPrompt(payload?.tool_input) ?? "crew opened an AskUserQuestion prompt (options unavailable)";
-      return { type: "task.input.requested", id: taskId, requestId: nextAskUserQuestionRequestId++, question };
+      return { type: "task.input.requested", id: taskId, requestId: nextHookRequestId++, question };
     }
     case "Stop": {
       const text = resolveLastAssistantText(payload);
@@ -11404,15 +11487,36 @@ function mapClaudeHookToEvent(event, payload, taskId) {
       if (question) {
         return { type: "task.blocked", id: taskId, reason: "crew asked a question (auto-detected)", question };
       }
-      return { type: "task.turn.completed", id: taskId, turnId: "hook-stop" };
+      if (hasActiveBackgroundWork(payload)) {
+        return { type: "task.progress", id: taskId, note: "stop-background-work" };
+      }
+      logStopPermissionMode(payload, taskId);
+      return { type: "task.turn.completed", id: taskId, turnId: resolveTurnId(payload) };
     }
+    case "StopFailure":
+      return {
+        type: "task.turn.failed",
+        id: taskId,
+        turnId: resolveTurnId(payload),
+        error: redactApiError(payload?.error)
+      };
     case "Notification": {
-      const msg = payload?.message;
-      if (typeof msg === "string" && isPermissionNotification(msg)) {
-        return { type: "task.blocked", id: taskId, reason: "crew awaiting permission (notification hook)", question: msg };
+      const cls = classifyNotification(payload);
+      if (cls.kind === "blocked") {
+        return { type: "task.blocked", id: taskId, reason: "crew awaiting permission (notification hook)", question: cls.question };
+      }
+      if (cls.kind === "input-requested") {
+        return { type: "task.input.requested", id: taskId, requestId: nextHookRequestId++, question: cls.question };
       }
       return { type: "task.progress", id: taskId, note: "notification" };
     }
+    case "PermissionRequest":
+      return {
+        type: "task.blocked",
+        id: taskId,
+        reason: "crew awaiting permission (permission-request hook)",
+        question: formatPermissionRequestQuestion(payload)
+      };
     case "SessionEnd":
       return { type: "task.session.ended", id: taskId };
     case "SubagentStop":
@@ -11424,14 +11528,14 @@ function mapClaudeHookToEvent(event, payload, taskId) {
       return null;
   }
 }
-var EVENTS, MATCHED_EVENTS, nextAskUserQuestionRequestId, CAPTAIN_MEMORY_PATH_RE, DENY_REASON, FILE_PATH_FIELD_BY_TOOL, claudeInteractive;
+var EVENTS, MATCHED_EVENTS, nextHookRequestId, CAPTAIN_MEMORY_PATH_RE, DENY_REASON, FILE_PATH_FIELD_BY_TOOL, TOOL_INPUT_HINT_LEN, SECRET_PATTERNS, MAX_API_ERROR_LEN, claudeInteractive;
 var init_claude3 = __esm({
   "packages/agents/dist/interactive/claude.js"() {
-    EVENTS = ["Stop", "SubagentStop", "SessionEnd", "PostToolUse", "Notification", "UserPromptSubmit"];
+    EVENTS = ["Stop", "SubagentStop", "SessionEnd", "PostToolUse", "Notification", "UserPromptSubmit", "PermissionRequest", "StopFailure"];
     MATCHED_EVENTS = [
       ["PreToolUse", "AskUserQuestion"]
     ];
-    nextAskUserQuestionRequestId = Date.now();
+    nextHookRequestId = Date.now();
     CAPTAIN_MEMORY_PATH_RE = /\.claude\/projects\/.*\/memory\//;
     DENY_REASON = "Crews do not write captain memory. Put the finding in your done/blocked message; the captain decides what is durable (#556).";
     FILE_PATH_FIELD_BY_TOOL = {
@@ -11440,6 +11544,16 @@ var init_claude3 = __esm({
       MultiEdit: "file_path",
       NotebookEdit: "notebook_path"
     };
+    TOOL_INPUT_HINT_LEN = 80;
+    SECRET_PATTERNS = [
+      /sk-ant-[A-Za-z0-9_-]{10,}/g,
+      // Anthropic API key
+      /gh[pousr]_[A-Za-z0-9]{10,}/g,
+      // GitHub token
+      /\b\d{6,}:[A-Za-z0-9_-]{20,}\b/g
+      // Telegram bot token shape
+    ];
+    MAX_API_ERROR_LEN = 300;
     claudeInteractive = {
       provider: "claude",
       tier: "strong",
@@ -12403,6 +12517,7 @@ __export(dist_exports4, {
   buildAgentCmd: () => buildAgentCmd,
   buildCodexDeveloperInstructions: () => buildCodexDeveloperInstructions,
   buildUserEnvelope: () => buildUserEnvelope,
+  classifyNotification: () => classifyNotification,
   classifyPaneTail: () => classifyPaneTail2,
   claudeInteractive: () => claudeInteractive,
   createClaudeDriver: () => createClaudeDriver,
@@ -12419,8 +12534,10 @@ __export(dist_exports4, {
   deriveTranscriptPath: () => deriveTranscriptPath,
   detectTrailingQuestion: () => detectTrailingQuestion2,
   formatAskUserQuestionPrompt: () => formatAskUserQuestionPrompt,
+  formatPermissionRequestQuestion: () => formatPermissionRequestQuestion,
   getHeadlessAdapter: () => getHeadlessAdapter,
   getInteractiveAdapter: () => getInteractiveAdapter,
+  hasActiveBackgroundWork: () => hasActiveBackgroundWork,
   isPermissionNotification: () => isPermissionNotification,
   mapClaudeHookToEvent: () => mapClaudeHookToEvent,
   mergeClaudeHooks: () => mergeClaudeHooks,
@@ -12431,6 +12548,8 @@ __export(dist_exports4, {
   readClaudeStatus: () => readClaudeStatus,
   readClaudeStatusByCwd: () => readClaudeStatusByCwd,
   readClaudeStatusBySocketPath: () => readClaudeStatusBySocketPath,
+  redactApiError: () => redactApiError,
+  resolveTurnId: () => resolveTurnId,
   runHeadless: () => runHeadless,
   shouldReattachCodex: () => shouldReattachCodex,
   toLifecycleSnapshot: () => toLifecycleSnapshot,
@@ -18921,10 +19040,14 @@ function mapHookSub(sub, payload, taskId) {
       return { type: "task.first-turn.confirmed", id: taskId };
     case "stop":
       return mapClaudeHookToEvent("Stop", payload, taskId);
+    case "stop-failure":
+      return mapClaudeHookToEvent("StopFailure", payload, taskId);
     case "notification":
       return mapClaudeHookToEvent("Notification", payload, taskId);
     case "ask-question":
       return mapClaudeHookToEvent("PreToolUse", payload, taskId);
+    case "permission-request":
+      return mapClaudeHookToEvent("PermissionRequest", payload, taskId);
     case "session-end":
       return mapClaudeHookToEvent("SessionEnd", payload, taskId);
     default: