bosun 0.41.3 → 0.41.4

package/agent/agent-pool.mjs

@@ -2846,6 +2846,10 @@ function isPoisonedCodexResumeError(errorValue) {
   );
 }
 
+function isCodexResumeTimeoutError(errorValue) {
+  return String(errorValue || "").toLowerCase().includes("codex resume timeout");
+}
+
 /**
  * Resume an existing Codex thread and run a follow-up prompt.
  * Uses `codex.resumeThread(threadId)` from @openai/codex-sdk.
@@ -3017,6 +3021,7 @@ async function resumeCodexThread(threadId, prompt, cwd, timeoutMs, extra = {}) {
         : `Thread resume error: ${err.message}`,
       sdk: "codex",
       threadId: null,
+      staleResumeState: isTimeout,
       poisonedResumeState:
         !isTimeout && isPoisonedCodexResumeError(err.message),
     };
@@ -3194,10 +3199,12 @@ export async function launchOrResumeThread(
         // Resume failed — fall through to fresh launch
         if (
           result.poisonedResumeState ||
-          isPoisonedCodexResumeError(result.error)
+          result.staleResumeState ||
+          isPoisonedCodexResumeError(result.error) ||
+          isCodexResumeTimeoutError(result.error)
         ) {
           console.warn(
-            `${TAG} resume failed for task "${taskKey}" with corrupted state: ${result.error}. Dropping cached thread metadata and starting fresh.`,
+            `${TAG} resume failed for task "${taskKey}" with stale or corrupted state: ${result.error}. Dropping cached thread metadata and starting fresh.`,
           );
           threadRegistry.delete(taskKey);
         } else {

package/agent/agent-supervisor.mjs

@@ -30,6 +30,12 @@
  */
 
 const TAG = "[agent-supervisor]";
+const API_ERROR_CONTINUE_COOLDOWNS_MS = Object.freeze([
+  3 * 60_000,
+  5 * 60_000,
+  5 * 60_000,
+]);
+const API_ERROR_RECOVERY_RESET_MS = 15 * 60_000;
 
 // ── Situation Types (30+ edge cases) ────────────────────────────────────────
 
@@ -140,7 +146,7 @@ const INTERVENTION_LADDER = {
   [SITUATION.PRE_PUSH_FAILURE]:   [INTERVENTION.INJECT_PROMPT, INTERVENTION.INJECT_PROMPT, INTERVENTION.FORCE_NEW_THREAD, INTERVENTION.BLOCK_AND_NOTIFY],
 
   [SITUATION.RATE_LIMITED]:       [INTERVENTION.COOLDOWN, INTERVENTION.COOLDOWN, INTERVENTION.PAUSE_EXECUTOR],
-  [SITUATION.API_ERROR]:          [INTERVENTION.COOLDOWN, INTERVENTION.COOLDOWN, INTERVENTION.BLOCK_AND_NOTIFY],
+  [SITUATION.API_ERROR]:          [INTERVENTION.FORCE_NEW_THREAD, INTERVENTION.REDISPATCH_TASK, INTERVENTION.BLOCK_AND_NOTIFY],
   [SITUATION.TOKEN_OVERFLOW]:     [INTERVENTION.FORCE_NEW_THREAD, INTERVENTION.FORCE_NEW_THREAD, INTERVENTION.BLOCK_AND_NOTIFY],
   [SITUATION.SESSION_EXPIRED]:    [INTERVENTION.FORCE_NEW_THREAD, INTERVENTION.FORCE_NEW_THREAD, INTERVENTION.BLOCK_AND_NOTIFY],
   [SITUATION.MODEL_ERROR]:        [INTERVENTION.BLOCK_AND_NOTIFY],       // Not retryable — wrong model name
@@ -443,13 +449,15 @@ export class AgentSupervisor {
     const signals = this._gatherSignals(taskId, context);
     const situation = this._diagnose(signals, context);
     const healthScore = this._computeHealthScore(signals);
+    const recoveryOverride = this._selectRecoveryIntervention(taskId, situation, context, state);
     const attemptIndex = Math.min(
       state.interventionCount,
       (INTERVENTION_LADDER[situation] || [INTERVENTION.NONE]).length - 1,
     );
-    const intervention = (INTERVENTION_LADDER[situation] || [INTERVENTION.NONE])[attemptIndex];
+    const intervention = recoveryOverride?.intervention
+      || (INTERVENTION_LADDER[situation] || [INTERVENTION.NONE])[attemptIndex];
     const prompt = this._buildPrompt(situation, taskId, context);
-    const reason = this._buildReason(situation, signals, context);
+    const reason = recoveryOverride?.reason || this._buildReason(situation, signals, context);
 
     // Record
     state.situationHistory.push({ situation, ts: Date.now() });
@@ -485,6 +493,9 @@ export class AgentSupervisor {
           break;
 
         case INTERVENTION.CONTINUE_SIGNAL:
+          if (situation === SITUATION.API_ERROR) {
+            this._recordApiErrorContinue(taskId);
+          }
           if (this._sendContinueSignal) {
             this._sendContinueSignal(taskId);
           }
@@ -725,6 +736,12 @@ export class AgentSupervisor {
       qualityScore: state.qualityScore,
       reviewVerdict: state.reviewVerdict,
       reviewIssueCount: state.reviewIssues?.length || 0,
+      apiErrorRecovery: state.apiErrorRecovery
+        ? {
+            ...state.apiErrorRecovery,
+            cooldownRemainingMs: Math.max(0, Number(state.apiErrorRecovery.cooldownUntil || 0) - Date.now()),
+          }
+        : null,
       recentSituations: state.situationHistory.slice(-10),
     };
   }
@@ -789,11 +806,104 @@ export class AgentSupervisor {
         qualityScore: null,
         reviewVerdict: null,
         reviewIssues: null,
+        apiErrorRecovery: null,
       });
     }
     return this._taskState.get(taskId);
   }
 
+  _normalizeApiErrorSignature(context) {
+    const raw = String(context?.error || context?.output || "").trim().toLowerCase();
+    if (!raw) return "api_error";
+    return raw
+      .replace(/\s+/g, " ")
+      .replace(/\b\d{2,}\b/g, "#")
+      .slice(0, 240);
+  }
+
+  _selectRecoveryIntervention(taskId, situation, context, state) {
+    if (situation !== SITUATION.API_ERROR) {
+      if (state?.apiErrorRecovery) state.apiErrorRecovery = null;
+      return null;
+    }
+
+    const now = Date.now();
+    const signature = this._normalizeApiErrorSignature(context);
+    const current = state.apiErrorRecovery || {
+      signature,
+      continueAttempts: 0,
+      lastErrorAt: 0,
+      cooldownUntil: 0,
+    };
+
+    const shouldReset =
+      current.signature !== signature ||
+      (current.lastErrorAt > 0 && now - current.lastErrorAt > API_ERROR_RECOVERY_RESET_MS);
+
+    const nextState = shouldReset
+      ? {
+          signature,
+          continueAttempts: 0,
+          lastErrorAt: now,
+          cooldownUntil: 0,
+        }
+      : {
+          ...current,
+          signature,
+          lastErrorAt: now,
+        };
+
+    state.apiErrorRecovery = nextState;
+
+    if (Number(nextState.cooldownUntil || 0) > now) {
+      const remainingMs = Math.max(0, nextState.cooldownUntil - now);
+      return {
+        intervention: INTERVENTION.COOLDOWN,
+        reason: `Transient API failure on cooldown for ${Math.ceil(remainingMs / 60000)} minute(s) before retrying the same thread.`,
+      };
+    }
+
+    if (nextState.continueAttempts < API_ERROR_CONTINUE_COOLDOWNS_MS.length) {
+      const cooldownMs = API_ERROR_CONTINUE_COOLDOWNS_MS[nextState.continueAttempts];
+      return {
+        intervention: INTERVENTION.CONTINUE_SIGNAL,
+        reason: `Transient API failure — continue the current thread and back off for ${Math.ceil(cooldownMs / 60000)} minute(s) if it repeats.`,
+      };
+    }
+
+    const ladder = INTERVENTION_LADDER[SITUATION.API_ERROR] || [INTERVENTION.BLOCK_AND_NOTIFY];
+    const escalationIndex = Math.min(
+      nextState.continueAttempts - API_ERROR_CONTINUE_COOLDOWNS_MS.length,
+      ladder.length - 1,
+    );
+    const escalation = ladder[escalationIndex];
+    const escalationReason = escalation === INTERVENTION.FORCE_NEW_THREAD
+      ? "Repeated API failures survived 3 continue attempts — forcing a fresh thread."
+      : escalation === INTERVENTION.REDISPATCH_TASK
+        ? "Repeated API failures survived continue attempts and a fresh thread — redispatching the task."
+        : "Repeated API failures survived all automated recovery attempts — blocking for human review.";
+    return {
+      intervention: escalation,
+      reason: escalationReason,
+    };
+  }
+
+  _recordApiErrorContinue(taskId) {
+    const state = this._getTaskState(taskId);
+    if (!state?.apiErrorRecovery) return;
+    const attemptIndex = Math.min(
+      state.apiErrorRecovery.continueAttempts,
+      API_ERROR_CONTINUE_COOLDOWNS_MS.length - 1,
+    );
+    const cooldownMs = API_ERROR_CONTINUE_COOLDOWNS_MS[attemptIndex] || 0;
+    state.apiErrorRecovery = {
+      ...state.apiErrorRecovery,
+      continueAttempts: Number(state.apiErrorRecovery.continueAttempts || 0) + 1,
+      cooldownUntil: cooldownMs > 0 ? Date.now() + cooldownMs : 0,
+      lastErrorAt: Date.now(),
+    };
+  }
+
   _getTaskState(taskId) {
     return this._taskState.get(taskId) || null;
   }

package/infra/monitor.mjs

@@ -724,6 +724,13 @@ async function ensureWorkflowAutomationEngine() {
           );
         }
       }
+
+      // Resume runs paused by a previous monitor shutdown after services are wired.
+      if (typeof engine.resumeInterruptedRuns === "function") {
+        engine.resumeInterruptedRuns().catch((err) => {
+          console.warn(`[workflows] Failed to resume interrupted runs: ${err?.message || err}`);
+        });
+      }
       workflowAutomationInitDone = true;
       return engine;
     } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.41.3",
+  "version": "0.41.4",
   "description": "Bosun Autonomous Engineering — manages AI agent executors with failover, extremely powerful workflow builder, and a massive amount of included default workflow templates for autonomous engineering, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache-2.0",

package/server/setup-web-server.mjs

@@ -39,6 +39,61 @@ function trimTrailingSlashes(value) {
   return out;
 }
 
+function isAzureOpenAIHost(value) {
+  try {
+    const parsed = value instanceof URL ? value : new URL(String(value || "").trim());
+    const host = String(parsed.hostname || "").toLowerCase();
+    return host === "openai.azure.com" || host.endsWith(".openai.azure.com");
+  } catch {
+    return false;
+  }
+}
+
+function buildModelsProbeRequest({ apiKey = "", baseUrl = "" } = {}) {
+  const trimmedBase = String(baseUrl || "").trim();
+  const fallbackBase = "https://api.openai.com";
+  const headers = { "Content-Type": "application/json" };
+
+  try {
+    const parsed = new URL(trimmedBase || fallbackBase);
+    const pathname = trimTrailingSlashes(parsed.pathname || "");
+    const lowerPath = pathname.toLowerCase();
+    const isAzure = isAzureOpenAIHost(parsed);
+
+    if (apiKey) {
+      if (isAzure) headers["api-key"] = apiKey;
+      else headers.Authorization = `Bearer ${apiKey}`;
+    }
+
+    if (lowerPath.endsWith("/models")) {
+      return { endpoint: parsed.toString(), headers };
+    }
+
+    if (isAzure || lowerPath === "/openai" || lowerPath.startsWith("/openai/")) {
+      parsed.pathname = "/openai/models";
+      if (!parsed.searchParams.has("api-version")) {
+        parsed.searchParams.set("api-version", "2024-10-21");
+      }
+      return { endpoint: parsed.toString(), headers };
+    }
+
+    const v1Match = lowerPath.match(/^(.*\/v1)(?:\/.*)?$/);
+    if (v1Match) {
+      parsed.pathname = `${v1Match[1]}/models`;
+      parsed.search = "";
+      return { endpoint: parsed.toString(), headers };
+    }
+
+    parsed.pathname = `${pathname || ""}/v1/models`;
+    parsed.search = "";
+    return { endpoint: parsed.toString(), headers };
+  } catch {
+    const resolvedBase = trimTrailingSlashes(trimmedBase || fallbackBase);
+    if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+    return { endpoint: `${resolvedBase}/v1/models`, headers };
+  }
+}
+
 
 // ── Vendor file serving (hoisting-safe) ───────────────────────────────────────────
 // Resolution order:
@@ -1750,13 +1805,9 @@ async function handleModelsProbe(body) {
   }
 
   // For OpenAI / compatible endpoints, try GET /v1/models
-  const resolvedBase = trimTrailingSlashes(baseUrl || "https://api.openai.com");
-  const endpoint = `${resolvedBase}/v1/models`;
+  const { endpoint, headers } = buildModelsProbeRequest({ apiKey, baseUrl });
 
   try {
-    const headers = { "Content-Type": "application/json" };
-    if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
-
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 8000);
 
@@ -3008,7 +3059,9 @@ export async function startSetupServer(options = {}) {
 export {
   applyTelegramMiniAppSetupEnv,
   applyNonBlockingSetupEnvDefaults,
+  buildModelsProbeRequest,
   handleTelegramChatIdLookup,
+  isAzureOpenAIHost,
   normalizeWorkflowTemplateOverrides,
   normalizeTelegramUiPort,
   normalizeRepoConfigEntry,

package/server/ui-server.mjs

@@ -7032,13 +7032,58 @@ function extractSafeErrorMessage(payload) {
   return "Internal server error";
 }
 
+function createRequestDiagnosticId() {
+  return `req_${randomBytes(6).toString("hex")}`;
+}
+
+function ensureResponseDiagnosticId(res) {
+  if (!res || typeof res !== "object") return createRequestDiagnosticId();
+  if (!res.__bosunDiagnosticId) {
+    res.__bosunDiagnosticId = createRequestDiagnosticId();
+  }
+  return res.__bosunDiagnosticId;
+}
+
+function describePayloadForErrorLog(payload, depth = 0) {
+  if (payload instanceof Error) {
+    const described = {
+      name: String(payload.name || "Error"),
+      message: String(payload.message || ""),
+    };
+    if (payload.stack) described.stack = String(payload.stack);
+    if (payload.code != null) described.code = String(payload.code);
+    if (depth < 3 && payload.cause) {
+      described.cause = describePayloadForErrorLog(payload.cause, depth + 1);
+    }
+    return described;
+  }
+  return makeJsonSafe(payload, { maxDepth: 6 });
+}
+
+function logJsonFailure(res, statusCode, payload, diagnosticId) {
+  const requestContext = res?.__bosunRequestContext || {};
+  console.error("[ui-server] request failed", {
+    diagnosticId,
+    statusCode,
+    method: requestContext.method || null,
+    path: requestContext.path || null,
+    query: requestContext.query || "",
+    payload: describePayloadForErrorLog(payload),
+  });
+}
+
 function jsonResponse(res, statusCode, payload) {
+  const diagnosticId = statusCode >= 500 ? ensureResponseDiagnosticId(res) : null;
+  if (statusCode >= 500) {
+    logJsonFailure(res, statusCode, payload, diagnosticId);
+  }
   const normalizedPayload = normalizeJsonResponsePayload(payload);
   const safePayload =
     statusCode >= 500
       ? {
           ok: false,
           error: extractSafeErrorMessage(normalizedPayload),
+          diagnosticId,
         }
       : normalizedPayload;
   const body = JSON.stringify(safePayload, null, 2);
@@ -7890,6 +7935,129 @@ function withTaskRuntimeSnapshot(task) {
   };
 }
 
+function normalizeTaskDiagnosticText(value) {
+  const text = String(value || "").trim();
+  return text ? text.replace(/\s+/g, " ") : "";
+}
+
+function buildTaskStableCause(task, supervisorDiagnostics = null) {
+  const lastError = normalizeTaskDiagnosticText(task?.lastError || "");
+  const blockedReason = normalizeTaskDiagnosticText(task?.blockedReason || "");
+  const errorPattern = String(task?.errorPattern || "").trim().toLowerCase();
+  const apiErrorRecovery = supervisorDiagnostics?.apiErrorRecovery || null;
+  const apiSignature = normalizeTaskDiagnosticText(apiErrorRecovery?.signature || "");
+  const lastErrorLower = lastError.toLowerCase();
+  const blockedReasonLower = blockedReason.toLowerCase();
+
+  if (lastErrorLower.includes("codex resume timeout")) {
+    return {
+      code: "codex_resume_timeout",
+      title: "Codex resume timed out",
+      severity: "warning",
+      summary: "Bosun timed out while resuming a cached Codex thread and will start fresh on the next attempt.",
+    };
+  }
+  if (
+    lastErrorLower.includes("invalid_encrypted_content") ||
+    lastErrorLower.includes("state db missing rollout path") ||
+    lastErrorLower.includes("could not be verified") ||
+    lastErrorLower.includes("tool_call_id")
+  ) {
+    return {
+      code: "codex_resume_corrupted_state",
+      title: "Codex resume state is corrupted",
+      severity: "error",
+      summary: "Bosun detected poisoned Codex thread metadata and will discard the cached resume state.",
+    };
+  }
+  if (errorPattern === "rate_limit") {
+    return {
+      code: "agent_rate_limit",
+      title: "Agent is rate limited",
+      severity: "warning",
+      summary: "The assigned agent hit a rate limit and Bosun is waiting before retrying.",
+    };
+  }
+  if (errorPattern === "token_overflow") {
+    return {
+      code: "token_overflow",
+      title: "Context window exhausted",
+      severity: "error",
+      summary: "The current task exceeded the model context budget and needs a smaller prompt or a fresh session.",
+    };
+  }
+  if (errorPattern === "api_error" || apiErrorRecovery) {
+    return {
+      code: Number(apiErrorRecovery?.cooldownUntil || 0) > Date.now()
+        ? "api_error_cooldown"
+        : "api_error_recovery",
+      title: "Transient API failure",
+      severity: "warning",
+      summary: "Bosun detected a backend API failure and is applying the task-level recovery ladder before escalating.",
+    };
+  }
+  if (blockedReason && blockedReasonLower.includes("dependency")) {
+    return {
+      code: "dependency_blocked",
+      title: "Dependency is still blocked",
+      severity: "warning",
+      summary: "Bosun is holding this task until one or more dependencies finish.",
+    };
+  }
+  if (blockedReason) {
+    return {
+      code: "task_blocked",
+      title: "Task is blocked",
+      severity: "warning",
+      summary: "Bosun recorded a blocking condition for this task and will not dispatch it until the condition clears.",
+    };
+  }
+  if (lastError || apiSignature) {
+    return {
+      code: "agent_runtime_error",
+      title: "Agent runtime error",
+      severity: "error",
+      summary: "Bosun recorded an agent-side runtime failure for this task.",
+    };
+  }
+  return null;
+}
+
+function buildTaskDiagnostics(task, supervisorDiagnostics = null) {
+  if (!task || typeof task !== "object") return null;
+  const apiErrorRecovery = supervisorDiagnostics?.apiErrorRecovery
+    ? makeJsonSafe(supervisorDiagnostics.apiErrorRecovery, { maxDepth: 4 })
+    : null;
+  const diagnostics = {
+    stableCause: buildTaskStableCause(task, supervisorDiagnostics),
+    lastError: normalizeTaskDiagnosticText(task?.lastError || "") || null,
+    errorPattern: normalizeTaskDiagnosticText(task?.errorPattern || "") || null,
+    blockedReason: normalizeTaskDiagnosticText(task?.blockedReason || "") || null,
+    cooldownUntil: task?.cooldownUntil || apiErrorRecovery?.cooldownUntil || null,
+    supervisor: supervisorDiagnostics
+      ? {
+          interventionCount: Number(supervisorDiagnostics.interventionCount || 0),
+          lastIntervention: supervisorDiagnostics.lastIntervention || null,
+          lastDecision: supervisorDiagnostics.lastDecision
+            ? makeJsonSafe(supervisorDiagnostics.lastDecision, { maxDepth: 3 })
+            : null,
+          apiErrorRecovery,
+        }
+      : null,
+  };
+  if (
+    !diagnostics.stableCause &&
+    !diagnostics.lastError &&
+    !diagnostics.errorPattern &&
+    !diagnostics.blockedReason &&
+    !diagnostics.cooldownUntil &&
+    !diagnostics.supervisor
+  ) {
+    return null;
+  }
+  return diagnostics;
+}
+
 async function maybeStartTaskFromLifecycleAction({
   taskId,
   updatedTask,
@@ -11364,6 +11532,12 @@ async function handleApi(req, res, url) {
           reqUrl: url,
           adapter,
         });
+        const supervisor = typeof uiDeps.getAgentSupervisor === "function"
+          ? uiDeps.getAgentSupervisor()
+          : null;
+        const supervisorDiagnostics = typeof supervisor?.getTaskDiagnostics === "function"
+          ? supervisor.getTaskDiagnostics(detailTask.id)
+          : null;
 
         const sprintId = resolveTaskSprintId(detailTask);
         const sprintDag = includeDag && sprintId ? await getSprintDagData(sprintId) : null;
@@ -11373,6 +11547,7 @@ async function handleApi(req, res, url) {
           workflowRuns: mergedWorkflowRuns,
           workspaceDir: workspaceContext?.workspaceDir || repoRoot,
         });
+        const diagnostics = buildTaskDiagnostics(detailTask, supervisorDiagnostics);
 
         detailTask.meta = {
           ...(detailTask.meta || {}),
@@ -11381,6 +11556,7 @@ async function handleApi(req, res, url) {
           timelineCount: Array.isArray(detailTask.timeline) ? detailTask.timeline.length : 0,
           canStart,
           blockedContext,
+          ...(diagnostics ? { diagnostics } : {}),
           ...(sprintId ? { sprintId } : {}),
           ...(sprintDag ? { sprintDag: sprintDag.data } : {}),
           ...(globalDag ? { dagOfDags: globalDag.data } : {}),
@@ -11389,6 +11565,7 @@ async function handleApi(req, res, url) {
         if (globalDag) detailTask.dagOfDags = globalDag.data;
         detailTask.canStart = canStart;
         detailTask.blockedContext = blockedContext;
+        if (diagnostics) detailTask.diagnostics = diagnostics;
         detailTask = withTaskRuntimeSnapshot(detailTask);
       }
       jsonResponse(res, 200, { ok: true, data: detailTask });
@@ -19169,8 +19346,16 @@ export async function startTelegramUiServer(options = {}) {
       req.url || "/",
       `http://${req.headers.host || "localhost"}`,
     );
+    res.__bosunRequestContext = {
+      diagnosticId: ensureResponseDiagnosticId(res),
+      method: String(req?.method || "GET").toUpperCase(),
+      path: url.pathname,
+      query: url.search || "",
+    };
     const webhookPath = getGitHubWebhookPath();
 
+    try {
+
     // Token exchange: ?token=<hex> → set session cookie and redirect to clean URL
     const qToken = url.searchParams.get("token");
     if (qToken && sessionToken) {
@@ -19312,6 +19497,21 @@ export async function startTelegramUiServer(options = {}) {
       }
     }
     await handleStatic(req, res, url);
+    } catch (err) {
+      if (res.headersSent) {
+        console.error("[ui-server] unhandled request failure after headers sent", {
+          diagnosticId: ensureResponseDiagnosticId(res),
+          payload: describePayloadForErrorLog(err),
+        });
+        try {
+          res.destroy?.(err);
+        } catch {
+          /* best effort */
+        }
+        return;
+      }
+      jsonResponse(res, 500, err);
+    }
   };
 
   try {

package/tools/syntax-check.mjs

@@ -54,7 +54,14 @@ function validateModuleSyntax(filePath) {
 function validateBrowserModuleSyntax(filePath) {
   const source = readFileSync(filePath, "utf8");
   const mod = new vm.SourceTextModule(source, { identifier: filePath });
-  if (typeof mod.hasTopLevelAwait === "function" && mod.hasTopLevelAwait()) {
+  let hasTLA = false;
+  const tlaProp = mod.hasTopLevelAwait;
+  if (typeof tlaProp === "function") {
+    hasTLA = !!tlaProp.call(mod);
+  } else if (typeof tlaProp === "boolean") {
+    hasTLA = tlaProp;
+  }
+  if (hasTLA) {
     throw new Error(
       "Top-level await is not allowed in browser-served modules because embedded WebViews can fail with 'Unexpected reserved word'.",
     );

package/ui/demo-defaults.js

@@ -17877,7 +17877,7 @@
             "command": "node",
             "args": [
               "-e",
-              "\n        import(\"./kanban-adapter.mjs\")\n          .then(k => k.listTasks(undefined, { status: \"todo\" }))\n          .then(tasks => {\n            const filtered = (tasks || []).filter((task) => {\n              const repository = typeof task?.repository === \"string\" ? task.repository.trim() : \"\";\n              const workspace = typeof task?.workspace === \"string\" ? task.workspace.trim() : \"\";\n              return task && task.status === \"todo\" && !task.draft && repository.length > 0 && workspace.length > 0;\n            });\n            const batch = filtered.slice(0, parseInt(process.env.MAX_BATCH || \"5\"));\n            console.log(JSON.stringify(batch.map(t => ({\n              taskId: t.id,\n              taskTitle: t.title || t.id,\n              branch: t.branch || t.metadata?.branch || null,\n              repository: t.repository || null,\n              workspace: t.workspace || null,\n            }))));\n          })\n          .catch(e => { console.error(e.message); process.exit(1); });\n      "
+              "\n        const fs = require(\"node:fs\");\n        const path = require(\"node:path\");\n        const { pathToFileURL } = require(\"node:url\");\n        const cwd = process.cwd();\n        const mirrorMarker = (path.sep + \".bosun\" + path.sep + \"workspaces\" + path.sep).toLowerCase();\n        let repoRoot = cwd;\n        if (cwd.toLowerCase().includes(mirrorMarker)) {\n          const sourceRepoRoot = path.resolve(cwd, \"..\", \"..\", \"..\", \"..\");\n          if (fs.existsSync(path.join(sourceRepoRoot, \"kanban\", \"kanban-adapter.mjs\"))) repoRoot = sourceRepoRoot;\n        }\n        const kanbanModuleUrl = pathToFileURL(path.join(repoRoot, \"kanban\", \"kanban-adapter.mjs\")).href;\n        import(kanbanModuleUrl)\n          .then(k => k.listTasks(undefined, { status: \"todo\" }))\n          .then(tasks => {\n            const filtered = (tasks || []).filter((task) => {\n              const repository = typeof task?.repository === \"string\" ? task.repository.trim() : \"\";\n              const workspace = typeof task?.workspace === \"string\" ? task.workspace.trim() : \"\";\n              return task && task.status === \"todo\" && !task.draft && repository.length > 0 && workspace.length > 0;\n            });\n            const batch = filtered.slice(0, parseInt(process.env.MAX_BATCH || \"5\"));\n            console.log(JSON.stringify(batch.map(t => ({\n              taskId: t.id,\n              taskTitle: t.title || t.id,\n              branch: t.branch || t.metadata?.branch || null,\n              repository: t.repository || null,\n              workspace: t.workspace || null,\n            }))));\n          })\n          .catch(e => { console.error(e.message); process.exit(1); });\n      "
             ],
             "env": {
               "MAX_BATCH": "{{maxBatchSize}}"
@@ -18231,7 +18231,7 @@
             "command": "node",
             "args": [
               "-e",
-              "\n        import(\"./kanban-adapter.mjs\")\n          .then(k => k.listTasks(undefined, { status: \"todo\" }))\n          .then(tasks => {\n            const filtered = (tasks || []).filter((task) => {\n              const repository = typeof task?.repository === \"string\" ? task.repository.trim() : \"\";\n              const workspace = typeof task?.workspace === \"string\" ? task.workspace.trim() : \"\";\n              return task && task.status === \"todo\" && !task.draft && repository.length > 0 && workspace.length > 0;\n            });\n            const batch = filtered.slice(0, parseInt(process.env.MAX_BATCH || \"10\"));\n            console.log(JSON.stringify(batch.map(t => ({\n              taskId: t.id,\n              taskTitle: t.title || t.id,\n              status: t.status,\n              branch: t.branch || t.metadata?.branch || null,\n              scope: t.scope || t.metadata?.scope || null,\n              repository: typeof t?.repository === \"string\" ? t.repository.trim() : null,\n              workspace: typeof t?.workspace === \"string\" ? t.workspace.trim() : null,\n            }))));\n          })\n          .catch(e => { console.error(e.message); process.exit(1); });\n      "
+              "\n        const fs = require(\"node:fs\");\n        const path = require(\"node:path\");\n        const { pathToFileURL } = require(\"node:url\");\n        const cwd = process.cwd();\n        const mirrorMarker = (path.sep + \".bosun\" + path.sep + \"workspaces\" + path.sep).toLowerCase();\n        let repoRoot = cwd;\n        if (cwd.toLowerCase().includes(mirrorMarker)) {\n          const sourceRepoRoot = path.resolve(cwd, \"..\", \"..\", \"..\", \"..\");\n          if (fs.existsSync(path.join(sourceRepoRoot, \"kanban\", \"kanban-adapter.mjs\"))) repoRoot = sourceRepoRoot;\n        }\n        const kanbanModuleUrl = pathToFileURL(path.join(repoRoot, \"kanban\", \"kanban-adapter.mjs\")).href;\n        import(kanbanModuleUrl)\n          .then(k => k.listTasks(undefined, { status: \"todo\" }))\n          .then(tasks => {\n            const filtered = (tasks || []).filter((task) => {\n              const repository = typeof task?.repository === \"string\" ? task.repository.trim() : \"\";\n              const workspace = typeof task?.workspace === \"string\" ? task.workspace.trim() : \"\";\n              return task && task.status === \"todo\" && !task.draft && repository.length > 0 && workspace.length > 0;\n            });\n            const batch = filtered.slice(0, parseInt(process.env.MAX_BATCH || \"10\"));\n            console.log(JSON.stringify(batch.map(t => ({\n              taskId: t.id,\n              taskTitle: t.title || t.id,\n              status: t.status,\n              branch: t.branch || t.metadata?.branch || null,\n              scope: t.scope || t.metadata?.scope || null,\n              repository: typeof t?.repository === \"string\" ? t.repository.trim() : null,\n              workspace: typeof t?.workspace === \"string\" ? t.workspace.trim() : null,\n            }))));\n          })\n          .catch(e => { console.error(e.message); process.exit(1); });\n      "
             ],
             "env": {
               "MAX_BATCH": "{{maxBatchSize}}"
@@ -37687,7 +37687,7 @@
             "command": "node",
             "args": [
               "-e",
-              "\n        import(\"./kanban-adapter.mjs\")\n          .then(k => k.listTasks(undefined, { status: \"todo\" }))\n          .then(tasks => {\n            const filtered = (tasks || []).filter((task) => {\n              const repository = typeof task?.repository === \"string\" ? task.repository.trim() : \"\";\n              const workspace = typeof task?.workspace === \"string\" ? task.workspace.trim() : \"\";\n              return task && task.status === \"todo\" && !task.draft && repository.length > 0 && workspace.length > 0;\n            });\n            const batch = filtered.slice(0, parseInt(process.env.MAX_BATCH || \"5\"));\n            console.log(JSON.stringify(batch.map(t => ({\n              taskId: t.id,\n              taskTitle: t.title || t.id,\n              branch: t.branch || t.metadata?.branch || null,\n              repository: t.repository || null,\n              workspace: t.workspace || null,\n            }))));\n          })\n          .catch(e => { console.error(e.message); process.exit(1); });\n      "
+              "\n        const fs = require(\"node:fs\");\n        const path = require(\"node:path\");\n        const { pathToFileURL } = require(\"node:url\");\n        const cwd = process.cwd();\n        const mirrorMarker = (path.sep + \".bosun\" + path.sep + \"workspaces\" + path.sep).toLowerCase();\n        let repoRoot = cwd;\n        if (cwd.toLowerCase().includes(mirrorMarker)) {\n          const sourceRepoRoot = path.resolve(cwd, \"..\", \"..\", \"..\", \"..\");\n          if (fs.existsSync(path.join(sourceRepoRoot, \"kanban\", \"kanban-adapter.mjs\"))) repoRoot = sourceRepoRoot;\n        }\n        const kanbanModuleUrl = pathToFileURL(path.join(repoRoot, \"kanban\", \"kanban-adapter.mjs\")).href;\n        import(kanbanModuleUrl)\n          .then(k => k.listTasks(undefined, { status: \"todo\" }))\n          .then(tasks => {\n            const filtered = (tasks || []).filter((task) => {\n              const repository = typeof task?.repository === \"string\" ? task.repository.trim() : \"\";\n              const workspace = typeof task?.workspace === \"string\" ? task.workspace.trim() : \"\";\n              return task && task.status === \"todo\" && !task.draft && repository.length > 0 && workspace.length > 0;\n            });\n            const batch = filtered.slice(0, parseInt(process.env.MAX_BATCH || \"5\"));\n            console.log(JSON.stringify(batch.map(t => ({\n              taskId: t.id,\n              taskTitle: t.title || t.id,\n              branch: t.branch || t.metadata?.branch || null,\n              repository: t.repository || null,\n              workspace: t.workspace || null,\n            }))));\n          })\n          .catch(e => { console.error(e.message); process.exit(1); });\n      "
             ],
             "env": {
               "MAX_BATCH": "{{maxBatchSize}}"
@@ -38029,7 +38029,7 @@
             "command": "node",
             "args": [
               "-e",
-              "\n        import(\"./kanban-adapter.mjs\")\n          .then(k => k.listTasks(undefined, { status: \"todo\" }))\n          .then(tasks => {\n            const filtered = (tasks || []).filter((task) => {\n              const repository = typeof task?.repository === \"string\" ? task.repository.trim() : \"\";\n              const workspace = typeof task?.workspace === \"string\" ? task.workspace.trim() : \"\";\n              return task && task.status === \"todo\" && !task.draft && repository.length > 0 && workspace.length > 0;\n            });\n            const batch = filtered.slice(0, parseInt(process.env.MAX_BATCH || \"10\"));\n            console.log(JSON.stringify(batch.map(t => ({\n              taskId: t.id,\n              taskTitle: t.title || t.id,\n              status: t.status,\n              branch: t.branch || t.metadata?.branch || null,\n              scope: t.scope || t.metadata?.scope || null,\n              repository: typeof t?.repository === \"string\" ? t.repository.trim() : null,\n              workspace: typeof t?.workspace === \"string\" ? t.workspace.trim() : null,\n            }))));\n          })\n          .catch(e => { console.error(e.message); process.exit(1); });\n      "
+              "\n        const fs = require(\"node:fs\");\n        const path = require(\"node:path\");\n        const { pathToFileURL } = require(\"node:url\");\n        const cwd = process.cwd();\n        const mirrorMarker = (path.sep + \".bosun\" + path.sep + \"workspaces\" + path.sep).toLowerCase();\n        let repoRoot = cwd;\n        if (cwd.toLowerCase().includes(mirrorMarker)) {\n          const sourceRepoRoot = path.resolve(cwd, \"..\", \"..\", \"..\", \"..\");\n          if (fs.existsSync(path.join(sourceRepoRoot, \"kanban\", \"kanban-adapter.mjs\"))) repoRoot = sourceRepoRoot;\n        }\n        const kanbanModuleUrl = pathToFileURL(path.join(repoRoot, \"kanban\", \"kanban-adapter.mjs\")).href;\n        import(kanbanModuleUrl)\n          .then(k => k.listTasks(undefined, { status: \"todo\" }))\n          .then(tasks => {\n            const filtered = (tasks || []).filter((task) => {\n              const repository = typeof task?.repository === \"string\" ? task.repository.trim() : \"\";\n              const workspace = typeof task?.workspace === \"string\" ? task.workspace.trim() : \"\";\n              return task && task.status === \"todo\" && !task.draft && repository.length > 0 && workspace.length > 0;\n            });\n            const batch = filtered.slice(0, parseInt(process.env.MAX_BATCH || \"10\"));\n            console.log(JSON.stringify(batch.map(t => ({\n              taskId: t.id,\n              taskTitle: t.title || t.id,\n              status: t.status,\n              branch: t.branch || t.metadata?.branch || null,\n              scope: t.scope || t.metadata?.scope || null,\n              repository: typeof t?.repository === \"string\" ? t.repository.trim() : null,\n              workspace: typeof t?.workspace === \"string\" ? t.workspace.trim() : null,\n            }))));\n          })\n          .catch(e => { console.error(e.message); process.exit(1); });\n      "
             ],
             "env": {
               "MAX_BATCH": "{{maxBatchSize}}"

package/ui/modules/state.js

@@ -102,11 +102,31 @@ function synthesizeTaskDescription(task) {
   return `Implementation notes for "${title}". Include scope, key files, risks, and acceptance checks before dispatch.`;
 }
 
+function normalizeTaskDiagnosticsForUi(diagnostics) {
+  if (!diagnostics || typeof diagnostics !== "object") return diagnostics;
+  const stableCause = diagnostics.stableCause && typeof diagnostics.stableCause === "object"
+    ? {
+        ...diagnostics.stableCause,
+        code: sanitizeTaskText(diagnostics.stableCause.code || ""),
+        title: sanitizeTaskText(diagnostics.stableCause.title || ""),
+        summary: sanitizeTaskText(diagnostics.stableCause.summary || ""),
+      }
+    : diagnostics.stableCause;
+  return {
+    ...diagnostics,
+    stableCause,
+    lastError: sanitizeTaskText(diagnostics.lastError || "") || null,
+    errorPattern: sanitizeTaskText(diagnostics.errorPattern || "") || null,
+    blockedReason: sanitizeTaskText(diagnostics.blockedReason || "") || null,
+  };
+}
+
 function normalizeTaskForUi(task) {
   if (!task || typeof task !== "object") return task;
   const title = sanitizeTaskText(task.title || "");
   const rawDescription = sanitizeTaskText(task.description || "");
   const description = isPlaceholderTaskDescription(rawDescription) ? "" : rawDescription;
+  const diagnostics = normalizeTaskDiagnosticsForUi(task.diagnostics);
   const meta = task.meta && typeof task.meta === "object"
     ? {
         ...task.meta,
@@ -117,12 +137,14 @@ function normalizeTaskForUi(task) {
               ? ""
               : sanitizeTaskText(task.meta.description))
             : task.meta.description,
+        diagnostics: normalizeTaskDiagnosticsForUi(task.meta.diagnostics),
       }
     : task.meta;
   return {
     ...task,
     title,
     description: description || synthesizeTaskDescription({ ...task, title }),
+    diagnostics,
     meta,
   };
 }

package/ui/tabs/tasks.js

@@ -2702,6 +2702,17 @@ export function TaskDetailModal({ task, onClose, onStart, presentation = "modal"
     task?.assignees,
     task?.meta,
   ]);
+  const taskDiagnostics = task?.diagnostics || task?.meta?.diagnostics || null;
+  const stableCause = taskDiagnostics?.stableCause || null;
+  const apiRecovery = taskDiagnostics?.supervisor?.apiErrorRecovery || null;
+  const hasDiagnostics = Boolean(
+    stableCause ||
+    taskDiagnostics?.lastError ||
+    taskDiagnostics?.errorPattern ||
+    taskDiagnostics?.blockedReason ||
+    taskDiagnostics?.cooldownUntil ||
+    apiRecovery,
+  );
   const canStartInfo = task?.canStart || task?.meta?.canStart || null;
   const blockedContext = task?.blockedContext || task?.meta?.blockedContext || null;
   const blockedBy = Array.isArray(blockedContext?.blockedBy)
@@ -3539,6 +3550,58 @@ export function TaskDetailModal({ task, onClose, onStart, presentation = "modal"
           </div>
         `}
 
+        ${hasDiagnostics && html`
+          <div class="task-section">
+            <div class="task-section-title">Diagnostics</div>
+            <div class="task-section-body">
+              ${stableCause && html`
+                <div class="task-blocked-banner" data-category=${stableCause.severity || "diagnostic"}>
+                  <div class="task-blocked-banner-title">${stableCause.title || "Task diagnostics available"}</div>
+                  <div class="task-blocked-banner-copy">${stableCause.summary || "Bosun recorded a stable failure cause for this task."}</div>
+                  ${stableCause.code && html`
+                    <div class="task-blocked-banner-copy">Stable cause: ${stableCause.code}</div>
+                  `}
+                </div>
+              `}
+
+              <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(170px,1fr));gap:10px;margin-top:12px;">
+                ${taskDiagnostics?.errorPattern && html`
+                  <div class="task-comment-item">
+                    <div class="task-comment-meta">Error pattern</div>
+                    <div class="task-comment-body">${taskDiagnostics.errorPattern}</div>
+                  </div>
+                `}
+                ${taskDiagnostics?.cooldownUntil && html`
+                  <div class="task-comment-item">
+                    <div class="task-comment-meta">Cooldown until</div>
+                    <div class="task-comment-body">${formatRelative(taskDiagnostics.cooldownUntil)}</div>
+                  </div>
+                `}
+                ${apiRecovery && html`
+                  <div class="task-comment-item">
+                    <div class="task-comment-meta">Continue attempts</div>
+                    <div class="task-comment-body">${Number(apiRecovery.continueAttempts || 0).toLocaleString("en-US")}</div>
+                  </div>
+                `}
+                ${taskDiagnostics?.blockedReason && html`
+                  <div class="task-comment-item">
+                    <div class="task-comment-meta">Blocked reason</div>
+                    <div class="task-comment-body">${taskDiagnostics.blockedReason}</div>
+                  </div>
+                `}
+              </div>
+
+              ${taskDiagnostics?.lastError && html`
+                <div class="task-comments-list" style=${{ marginTop: "12px" }}>
+                  <div class="task-comment-item">
+                    <div class="task-comment-meta">Last backend error</div>
+                    <div class="task-comment-body">${taskDiagnostics.lastError}</div>
+                  </div>
+                </div>
+              `}
+            </div>
+          </div>
+        `}
         ${/* Description */ ""}
         <div class="task-section">
           <div class="task-section-title">Description</div>
@@ -7695,4 +7758,3 @@ function CreateTaskModalInline({ onClose, initialValues = null, sprintOptions =
 
 
 
-

package/workflow/workflow-nodes.mjs

@@ -2977,11 +2977,19 @@ registerBuiltinNodeType("action.run_command", {
     type: "object",
     properties: {
       command: { type: "string", description: "Shell command to run" },
+      args: {
+        description: "Optional argv passed to the command without shell interpolation",
+        oneOf: [
+          { type: "array", items: { type: ["string", "number", "boolean"] } },
+          { type: "string" },
+        ],
+      },
       cwd: { type: "string", description: "Working directory" },
       env: { type: "object", description: "Environment variables passed to the command (supports templates)", additionalProperties: true },
       timeoutMs: { type: "number", default: 300000 },
       shell: { type: "string", default: "auto", enum: ["auto", "bash", "pwsh", "cmd"] },
       captureOutput: { type: "boolean", default: true },
+      parseJson: { type: "boolean", default: false, description: "Parse JSON output automatically" },
       failOnError: { type: "boolean", default: false, description: "Throw on non-zero exit status (enables workflow retries)" },
     },
     required: ["command"],
@@ -3005,28 +3013,63 @@ registerBuiltinNodeType("action.run_command", {
     }
 
     const timeout = node.config?.timeoutMs || 300000;
+    const resolvedArgsConfig = resolveWorkflowNodeValue(node.config?.args ?? [], ctx);
+    const commandArgs = Array.isArray(resolvedArgsConfig)
+      ? resolvedArgsConfig.map((value) => String(value))
+      : typeof resolvedArgsConfig === "string" && resolvedArgsConfig.trim()
+        ? [resolvedArgsConfig]
+        : [];
+    const shouldParseJson = node.config?.parseJson === true;
+    const parseOutput = (rawOutput) => {
+      const trimmed = rawOutput?.trim?.() ?? "";
+      if (!shouldParseJson || !trimmed) return trimmed;
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        const lines = String(trimmed)
+          .split(/\r?\n/)
+          .map((line) => line.trim())
+          .filter(Boolean);
+        const candidate = lines.length > 0 ? lines[lines.length - 1] : trimmed;
+        try {
+          return JSON.parse(candidate);
+        } catch {
+          return trimmed;
+        }
+      }
+    };
+    const usedArgv = commandArgs.length > 0;
 
     if (command !== resolvedCommand) {
       ctx.log(node.id, `Normalized legacy command for portability: ${command}`);
     }
-    ctx.log(node.id, `Running: ${command}`);
+    ctx.log(node.id, `Running: ${usedArgv ? `${command} ${commandArgs.join(" ")}`.trim() : command}`);
     try {
-      const output = execSync(command, {
-        cwd,
-        timeout,
-        encoding: "utf8",
-        maxBuffer: 10 * 1024 * 1024,
-        stdio: node.config?.captureOutput !== false ? "pipe" : "inherit",
-        env: commandEnv,
-      });
+      const output = usedArgv
+        ? execFileSync(command, commandArgs, {
+            cwd,
+            timeout,
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024,
+            stdio: node.config?.captureOutput !== false ? "pipe" : "inherit",
+            env: commandEnv,
+          })
+        : execSync(command, {
+            cwd,
+            timeout,
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024,
+            stdio: node.config?.captureOutput !== false ? "pipe" : "inherit",
+            env: commandEnv,
+          });
       ctx.log(node.id, `Command succeeded`);
-      return { success: true, output: output?.trim(), exitCode: 0 };
+      return { success: true, output: parseOutput(output), exitCode: 0 };
     } catch (err) {
       const output = err.stdout?.toString() || "";
       const stderr = err.stderr?.toString() || "";
       const result = {
         success: false,
-        output,
+        output: parseOutput(output),
         stderr,
         exitCode: err.status,
         error: err.message,

package/workflow-templates/task-batch.mjs

@@ -66,7 +66,18 @@ export const TASK_BATCH_PROCESSOR_TEMPLATE = {
     node("query-tasks", "action.run_command", "Query Task Backlog", {
       command: "node",
       args: ["-e", `
-        import("./kanban-adapter.mjs")
+        const fs = require("node:fs");
+        const path = require("node:path");
+        const { pathToFileURL } = require("node:url");
+        const cwd = process.cwd();
+        const mirrorMarker = (path.sep + ".bosun" + path.sep + "workspaces" + path.sep).toLowerCase();
+        let repoRoot = cwd;
+        if (cwd.toLowerCase().includes(mirrorMarker)) {
+          const sourceRepoRoot = path.resolve(cwd, "..", "..", "..", "..");
+          if (fs.existsSync(path.join(sourceRepoRoot, "kanban", "kanban-adapter.mjs"))) repoRoot = sourceRepoRoot;
+        }
+        const kanbanModuleUrl = pathToFileURL(path.join(repoRoot, "kanban", "kanban-adapter.mjs")).href;
+        import(kanbanModuleUrl)
           .then(k => k.listTasks(undefined, { status: "todo" }))
           .then(tasks => {
             const filtered = (tasks || []).filter((task) => {
@@ -181,7 +192,18 @@ export const TASK_BATCH_PR_TEMPLATE = {
     node("query-tasks", "action.run_command", "List Todo Tasks", {
       command: "node",
       args: ["-e", `
-        import("./kanban-adapter.mjs")
+        const fs = require("node:fs");
+        const path = require("node:path");
+        const { pathToFileURL } = require("node:url");
+        const cwd = process.cwd();
+        const mirrorMarker = (path.sep + ".bosun" + path.sep + "workspaces" + path.sep).toLowerCase();
+        let repoRoot = cwd;
+        if (cwd.toLowerCase().includes(mirrorMarker)) {
+          const sourceRepoRoot = path.resolve(cwd, "..", "..", "..", "..");
+          if (fs.existsSync(path.join(sourceRepoRoot, "kanban", "kanban-adapter.mjs"))) repoRoot = sourceRepoRoot;
+        }
+        const kanbanModuleUrl = pathToFileURL(path.join(repoRoot, "kanban", "kanban-adapter.mjs")).href;
+        import(kanbanModuleUrl)
           .then(k => k.listTasks(undefined, { status: "todo" }))
           .then(tasks => {
             const filtered = (tasks || []).filter((task) => {