bosun 0.33.5 → 0.33.6

package/agent-endpoint.mjs

@@ -161,11 +161,16 @@ function extractTaskId(pathname) {
 }
 
 function isAlreadyExitedProcessError(err) {
-  const detail = String(err?.stderr || err?.message || "").toLowerCase();
+  const detail = [err?.stderr, err?.stdout, err?.message]
+    .map((part) => String(part || ""))
+    .join("\n")
+    .toLowerCase();
   return (
     detail.includes("no running instance of the task") ||
-    detail.includes("not found") ||
-    detail.includes("no such process")
+    detail.includes("no running instance") ||
+    detail.includes("no such process") ||
+    detail.includes("cannot find the process") ||
+    detail.includes("esrch")
   );
 }
 

package/agent-hooks.mjs

@@ -366,7 +366,7 @@ export function loadHooks(configPath) {
  *
  * @example
  * const id = registerHook("PrePush", {
- *   command: "scripts/agent-preflight.ps1",
+ *   command: "node preflight.mjs",
  *   blocking: true,
  *   timeout: 300000,
  * });
@@ -610,8 +610,7 @@ export async function executeBlockingHooks(event, context = {}) {
  * that run regardless of config file contents.
  *
  * Built-in hooks:
- *   - **PrePush** — Runs `scripts/agent-preflight.ps1` (Windows) or
- *     `scripts/agent-preflight.sh` (Unix) to validate quality gates.
+ *   - **PrePush** — Runs `node preflight.mjs` to validate quality gates.
  *   - **TaskComplete** — Runs a basic acceptance-criteria check via git log.
  */
 export function registerBuiltinHooks(options = {}) {
@@ -644,9 +643,7 @@ export function registerBuiltinHooks(options = {}) {
 
   // ── PrePush: agent preflight quality gate ──
   if (!skipPrePush) {
-    const preflightScript = IS_WINDOWS
-      ? "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/agent-preflight.ps1"
-      : "bash scripts/agent-preflight.sh";
+    const preflightScript = "node preflight.mjs";
 
     registerHook("PrePush", {
       id: "builtin-prepush-preflight",

package/monitor.mjs

@@ -20,6 +20,7 @@ import { clearLine, createInterface, cursorTo } from "node:readline";
 import net from "node:net";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isMainThread } from "node:worker_threads";
 
 // Node.js Happy Eyeballs (RFC 8305) tries IPv6 first with a 250ms timeout
 // before falling back to IPv4.  On networks where IPv6 is unreachable, the
@@ -566,7 +567,9 @@ let githubReconcile = githubReconcileConfig || {
 // trusted git directory, preventing "Not inside a trusted directory" errors.
 // Prefer agentRepoRoot (workspace-aware) over raw repoRoot.
 const effectiveRepoRoot = agentRepoRoot || repoRoot;
-if (effectiveRepoRoot && process.cwd() !== effectiveRepoRoot) {
+if (!isMainThread) {
+  // Worker threads cannot call process.chdir(); skip to avoid noisy warnings.
+} else if (effectiveRepoRoot && process.cwd() !== effectiveRepoRoot) {
   try {
     process.chdir(effectiveRepoRoot);
     console.log(`[monitor] changed CWD to repo root: ${effectiveRepoRoot}`);
@@ -11849,16 +11852,32 @@ function attemptSelfRestartAfterQuiet() {
   const protection = getRuntimeRestartProtection();
   if (protection.defer) {
     pendingSelfRestart = filename;
-    // Track how many times we've deferred. Never force-restart when internal
-    // task agents are active; just keep retrying with periodic reminders.
     const deferCount = (selfRestartDeferCount =
       (selfRestartDeferCount || 0) + 1);
     const retrySec = Math.round(SELF_RESTART_RETRY_MS / 1000);
-    if (deferCount >= 20) {
+
+    // Hard cap: after many deferrals the active agent is likely stuck.
+    // Force-stop the task executor and proceed with the restart so the
+    // monitor doesn't hang forever (or crash from resource exhaustion).
+    const SELF_RESTART_DEFER_HARD_CAP = Number(
+      process.env.SELF_RESTART_DEFER_HARD_CAP || "50",
+    );
+    if (deferCount >= SELF_RESTART_DEFER_HARD_CAP) {
       console.warn(
-        `[monitor] self-restart deferred ${deferCount} times — still waiting for ${protection.reason}; continuing to defer`,
+        `[monitor] self-restart deferred ${deferCount} times (hard cap ${SELF_RESTART_DEFER_HARD_CAP}) — force-stopping active agents and restarting`,
       );
+      if (internalTaskExecutor) {
+        internalTaskExecutor.stop().catch(() => {});
+      }
       selfRestartDeferCount = 0;
+      selfRestartForSourceChange(filename);
+      return;
+    }
+
+    if (deferCount % 20 === 0) {
+      console.warn(
+        `[monitor] self-restart deferred ${deferCount} times — still waiting for ${protection.reason}; continuing to defer`,
+      );
     }
     console.log(
       `[monitor] deferring self-restart (${filename}) — ${protection.reason}; retrying in ${retrySec}s (defer #${deferCount})`,
@@ -12456,6 +12475,15 @@ process.on("unhandledRejection", (reason) => {
 
 // ── Singleton guard: prevent ghost monitors ─────────────────────────────────
 if (!process.env.VITEST && !acquireMonitorLock(config.cacheDir)) {
+  // During source-change self-restart, the previous monitor can still be
+  // shutting down and holding the lock briefly. Ask cli.mjs to retry instead
+  // of treating this as a hard crash.
+  if (isSelfRestart) {
+    console.warn(
+      "[monitor] self-restart lock handoff still busy — retrying startup",
+    );
+    process.exit(SELF_RESTART_EXIT_CODE);
+  }
   process.exit(1);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.33.5",
+  "version": "0.33.6",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, 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/session-tracker.mjs

@@ -750,12 +750,22 @@ export class SessionTracker {
     if (!event || !event.type) return null;
 
     const ts = new Date().toISOString();
+    const toText = (value) => {
+      if (value == null) return "";
+      if (typeof value === "string") return value;
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    };
 
     // ── Codex SDK events ──
     if (event.type === "item.completed" && event.item) {
       const item = event.item;
+      const itemType = String(item.type || "").toLowerCase();
 
-      if (item.type === "agent_message" && item.text) {
+      if (itemType === "agent_message" && item.text) {
         return {
           type: "agent_message",
           content: item.text.slice(0, MAX_MESSAGE_CHARS),
@@ -763,7 +773,7 @@ export class SessionTracker {
         };
       }
 
-      if (item.type === "function_call") {
+      if (itemType === "function_call") {
         return {
           type: "tool_call",
           content: `${item.name}(${(item.arguments || "").slice(0, 500)})`,
@@ -772,7 +782,7 @@ export class SessionTracker {
         };
       }
 
-      if (item.type === "function_call_output") {
+      if (itemType === "function_call_output") {
         return {
           type: "tool_result",
           content: (item.output || "").slice(0, MAX_MESSAGE_CHARS),
@@ -780,9 +790,108 @@ export class SessionTracker {
         };
       }
 
+      if (itemType === "command_execution" || itemType === "commandexecution") {
+        const command = toText(item.command || item.input || "").trim();
+        const exitCode = Number.isFinite(Number(item.exit_code)) ? Number(item.exit_code) : null;
+        const status = toText(item.status || "").trim();
+        const statusParts = [];
+        if (status) statusParts.push(status);
+        if (exitCode !== null) statusParts.push(`exit=${exitCode}`);
+        const statusLabel = statusParts.length ? ` [${statusParts.join(", ")}]` : "";
+        const output = toText(
+          item.aggregated_output || item.output || item.stderr || item.stdout || "",
+        ).trim();
+        const content = output
+          ? `${command || "(command)"}${statusLabel}
+${output}`
+          : `${command || "(command)"}${statusLabel}`;
+        return {
+          type: "tool_call",
+          content: content.slice(0, MAX_MESSAGE_CHARS),
+          timestamp: ts,
+          meta: { toolName: "command_execution" },
+        };
+      }
+
+      if (itemType === "reasoning") {
+        const detail = toText(item.text || item.summary || "");
+        if (!detail) return null;
+        return {
+          type: "system",
+          content: detail.slice(0, MAX_MESSAGE_CHARS),
+          timestamp: ts,
+        };
+      }
+
+      if (itemType === "file_change") {
+        const changes = Array.isArray(item.changes)
+          ? item.changes
+              .map((change) => {
+                const kind = toText(change?.kind || "update").trim();
+                const filePath = toText(change?.path || change?.file || "").trim();
+                return filePath ? `${kind} ${filePath}` : kind;
+              })
+              .filter(Boolean)
+          : [];
+        const summary = changes.length
+          ? `file changes: ${changes.slice(0, 5).join(", ")}`
+          : "file changes detected";
+        return {
+          type: "system",
+          content: summary.slice(0, MAX_MESSAGE_CHARS),
+          timestamp: ts,
+        };
+      }
+
+      if (itemType === "todo_list") {
+        const items = Array.isArray(item.items)
+          ? item.items
+              .map((entry) => {
+                const detail = toText(entry?.text || "").trim();
+                if (!detail) return "";
+                return `${entry?.completed ? "[x]" : "[ ]"} ${detail}`;
+              })
+              .filter(Boolean)
+          : [];
+        const summary = items.length ? `todo:
+${items.join("\n")}` : "todo updated";
+        return {
+          type: "system",
+          content: summary.slice(0, MAX_MESSAGE_CHARS),
+          timestamp: ts,
+        };
+      }
+
+      if (item.text || item.content) {
+        const fallback = toText(item.text || item.content);
+        if (fallback) {
+          return {
+            type: "system",
+            content: fallback.slice(0, MAX_MESSAGE_CHARS),
+            timestamp: ts,
+          };
+        }
+      }
+
       return null; // Skip other item types
     }
 
+    if (event.type === "assistant.message" && event.data?.content) {
+      return {
+        type: "agent_message",
+        content: toText(event.data.content).slice(0, MAX_MESSAGE_CHARS),
+        timestamp: ts,
+      };
+    }
+
+    if (event.type === "assistant.message_delta" && event.data?.deltaContent) {
+      return {
+        type: "agent_message",
+        content: toText(event.data.deltaContent).slice(0, MAX_MESSAGE_CHARS),
+        timestamp: ts,
+      };
+    }
+
     // ── Copilot SDK events ──
     if (event.type === "message" && event.content) {
       return {

package/task-claims.mjs

@@ -868,7 +868,15 @@ export async function renewClaim(opts = {}) {
         state.repoRoot
       );
       if (!sharedResult.success) {
-        console.info(`[task-claims] Shared state heartbeat renewal warning for ${taskId}: ${sharedResult.reason}`);
+        const reason = sharedResult.reason || "unknown";
+        // Token mismatch in shared state means another orchestrator has taken
+        // over — surface as a fatal claim renewal failure so the task-executor
+        // can abort the now-orphaned agent instead of letting it run forever.
+        if (reason === "attempt_token_mismatch" || reason === "owner_mismatch") {
+          console.warn(`[task-claims] Shared state heartbeat FATAL for ${taskId}: ${reason} — surfacing as claim failure`);
+          return { success: false, error: reason };
+        }
+        console.info(`[task-claims] Shared state heartbeat renewal warning for ${taskId}: ${reason}`);
       }
     } catch (err) {
       console.warn(`[task-claims] Shared state heartbeat renewal failed for ${taskId}: ${err.message}`);

package/task-executor.mjs

@@ -109,6 +109,11 @@ const FATAL_CLAIM_RENEW_ERRORS = new Set([
   "task_claimed_by_different_instance",
   "claim_token_mismatch",
   "task_not_claimed",
+  // Shared-state token mismatches — another orchestrator instance has taken
+  // over the task in the shared state registry.  Treat exactly the same as a
+  // direct claim-token mismatch: abort the now-orphaned local agent.
+  "attempt_token_mismatch",
+  "owner_mismatch",
 ]);
 const CODEX_TASK_LABELS = (() => {
   const raw = String(

package/ui/app.js

@@ -1643,7 +1643,6 @@ function App() {
     setSidebarDrawerOpen(false);
     setInspectorDrawerOpen(false);
   }, []);
-  const sidebarToggleLabel = sidebarDrawerOpen ? "Close sidebar" : "Open sidebar";
   const inspectorToggleLabel = inspectorDrawerOpen
     ? "Close inspector"
     : "Open inspector";
@@ -1664,9 +1663,9 @@ function App() {
         <button
           class="btn btn-ghost btn-sm tablet-toggle"
           onClick=${toggleMore}
-          aria-label=${isMoreOpen ? "Close more menu" : "Open more menu"}
+          aria-label=${isMoreOpen ? "Close navigation menu" : "Open navigation menu"}
         >
-          ⋯ More
+          ⋯ Navigation
         </button>
       `
     : null;
@@ -1726,13 +1725,6 @@ function App() {
           ${showDrawerToggles
             ? html`
                 <div class="tablet-action-bar">
-                  <button
-                    class="btn btn-ghost btn-sm tablet-toggle"
-                    onClick=${toggleSidebar}
-                    aria-label=${sidebarToggleLabel}
-                  >
-                    ☰ Navigation
-                  </button>
                   ${inspectorToggleButton}
                   ${moreToggleButton}
                 </div>

package/ui/tabs/workflows.js

@@ -786,7 +786,7 @@ const COMMAND_PRESETS = {
     { label: "Push", cmd: "git push --set-upstream origin HEAD", icon: "rocket" },
   ],
   github: [
-    { label: "Check CI", cmd: "gh pr checks --json name,state,conclusion", icon: "search" },
+    { label: "Check CI", cmd: "gh pr checks --json name,state", icon: "search" },
     { label: "Merge PR (squash)", cmd: "gh pr merge --auto --squash", icon: "git" },
     { label: "Close PR", cmd: 'gh pr close --comment "{{reason}}"', icon: "ban" },
     { label: "PR Diff", cmd: "gh pr diff --stat", icon: "chart" },

package/ui-server.mjs

@@ -250,6 +250,7 @@ async function handleVendor(req, res, url) {
 }
 const statusPath = resolve(repoRoot, ".cache", "ve-orchestrator-status.json");
 const logsDir = resolve(__dirname, "logs");
+const monitorMonitorLogsDir = resolve(repoRoot, ".cache", "monitor-monitor-logs");
 const agentLogsDirCandidates = [
   resolve(__dirname, "logs", "agents"),
   resolve(repoRoot, ".cache", "agent-logs"),
@@ -2255,15 +2256,55 @@ function normalizeAgentLogName(name) {
   return basename(String(name || "")).trim();
 }
 
+async function listDirFilesWithMtime(dir, predicate = () => true) {
+  const names = await readdir(dir).catch(() => []);
+  const entries = await Promise.all(
+    names
+      .filter((name) => predicate(name))
+      .map(async (name) => {
+        const fullPath = resolve(dir, name);
+        const info = await stat(fullPath).catch(() => null);
+        if (!info?.isFile?.()) return null;
+        return {
+          name,
+          path: fullPath,
+          mtimeMs: Number(info.mtimeMs || 0),
+        };
+      }),
+  );
+  return entries.filter(Boolean);
+}
+
+async function resolvePreferredSystemLogPath() {
+  const rootLogEntries = await listDirFilesWithMtime(
+    logsDir,
+    (name) => name.endsWith(".log"),
+  );
+  const nonDaemonEntries = rootLogEntries.filter((entry) => entry.name !== "daemon.log");
+
+  const monitorPromptEntries = await listDirFilesWithMtime(
+    monitorMonitorLogsDir,
+    (name) =>
+      name.startsWith("monitor-monitor-") &&
+      (name.endsWith(".prompt.md") || name.endsWith(".md")),
+  );
+
+  const preferredEntries = [...nonDaemonEntries, ...monitorPromptEntries].sort(
+    (a, b) => b.mtimeMs - a.mtimeMs,
+  );
+  if (preferredEntries.length > 0) return preferredEntries[0].path;
+
+  const daemonEntry = rootLogEntries.find((entry) => entry.name === "daemon.log");
+  return daemonEntry ? daemonEntry.path : null;
+}
+
 /**
  * Resolve the log file path for a given logType and optional query.
  * Returns null if no matching file found.
  */
 async function resolveLogPath(logType, query) {
   if (logType === "system") {
-    const files = await readdir(logsDir).catch(() => []);
-    const logFile = files.filter((f) => f.endsWith(".log")).sort().pop();
-    return logFile ? resolve(logsDir, logFile) : null;
+    return resolvePreferredSystemLogPath();
   }
   if (logType === "agent") {
     const agentLogsDir = await resolveAgentLogsDir();
@@ -3252,17 +3293,10 @@ function normalizeBranchInput(input) {
 }
 
 async function getLatestLogTail(lineCount) {
-  const files = await readdir(logsDir).catch(() => []);
-  const logFile = files
-    .filter((f) => f.endsWith(".log"))
-    .sort()
-    .pop();
-  if (!logFile) return { file: null, lines: [] };
-  const logPath = resolve(logsDir, logFile);
-  const content = await readFile(logPath, "utf8");
-  const lines = content.split("\n").filter(Boolean);
-  const tail = lines.slice(-lineCount);
-  return { file: logFile, lines: tail };
+  const logPath = await resolvePreferredSystemLogPath();
+  if (!logPath) return { file: null, lines: [] };
+  const tail = await tailFile(logPath, lineCount);
+  return { file: basename(logPath), lines: tail.lines || [] };
 }
 
 async function tailFile(filePath, lineCount, maxBytes = 1_000_000) {

package/update-check.mjs

@@ -26,6 +26,11 @@ import os from "node:os";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_NAME = "bosun";
 const CACHE_FILE = resolve(__dirname, "logs", ".update-check-cache.json");
+const AUTO_UPDATE_STATE_FILE = resolve(__dirname, ".cache", "auto-update-state.json");
+const AUTO_UPDATE_FAILURE_LIMIT =
+  Number(process.env.BOSUN_AUTO_UPDATE_FAILURE_LIMIT) || 3;
+const AUTO_UPDATE_DISABLE_WINDOW_MS =
+  Number(process.env.BOSUN_AUTO_UPDATE_DISABLE_WINDOW_MS) || 24 * 60 * 60 * 1000;
 const STARTUP_CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour (startup notice)
 const AUTO_UPDATE_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes (polling loop)
 
@@ -111,6 +116,79 @@ async function writeCache(data) {
   }
 }
 
+const defaultAutoUpdateState = {
+  failureCount: 0,
+  lastFailureReason: null,
+  disabledUntil: 0,
+  lastNotifiedAt: 0,
+};
+
+async function readAutoUpdateState() {
+  try {
+    const raw = await readFile(AUTO_UPDATE_STATE_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    return { ...defaultAutoUpdateState, ...parsed };
+  } catch {
+    return { ...defaultAutoUpdateState };
+  }
+}
+
+async function writeAutoUpdateState(state) {
+  try {
+    await mkdir(dirname(AUTO_UPDATE_STATE_FILE), { recursive: true });
+    await writeFile(
+      AUTO_UPDATE_STATE_FILE,
+      JSON.stringify({ ...defaultAutoUpdateState, ...state }, null, 2),
+    );
+  } catch {
+    // non-critical
+  }
+}
+
+async function resetAutoUpdateState() {
+  await writeAutoUpdateState({ ...defaultAutoUpdateState });
+  return { ...defaultAutoUpdateState };
+}
+
+function classifyInstallError(err) {
+  const message = err?.message || String(err || "");
+  const code = err?.code || "";
+  if (code === "EINVAL" || message.includes("EINVAL")) return "EINVAL";
+  if (code) return code;
+  return message.slice(0, 160) || "unknown";
+}
+
+async function recordAutoUpdateFailure(state, reason) {
+  const now = Date.now();
+  const next = {
+    ...defaultAutoUpdateState,
+    ...state,
+    failureCount: (state?.failureCount || 0) + 1,
+    lastFailureReason: reason,
+  };
+
+  if (!next.disabledUntil && next.failureCount >= AUTO_UPDATE_FAILURE_LIMIT) {
+    next.disabledUntil = now + AUTO_UPDATE_DISABLE_WINDOW_MS;
+    next.lastNotifiedAt = 0;
+  }
+
+  await writeAutoUpdateState(next);
+  return next;
+}
+
+function isAutoUpdateDisabled(state, now = Date.now()) {
+  return Boolean(state?.disabledUntil && now < state.disabledUntil);
+}
+
+function buildDisableNotice(state) {
+  const hours = Math.round(AUTO_UPDATE_DISABLE_WINDOW_MS / (60 * 60 * 1000));
+  const reason = state?.lastFailureReason || "unknown";
+  return [
+    `[auto-update] ⛔ Disabled for ${hours}h after ${state?.failureCount || 0} failures (last: ${reason}).`,
+    "Recovery: set BOSUN_SKIP_AUTO_UPDATE=1 or delete .cache/auto-update-state.json then restart.",
+  ].join(' ');
+}
+
 // ── Registry query ───────────────────────────────────────────────────────────
 
 async function fetchLatestVersion() {
@@ -324,6 +402,7 @@ export function startAutoUpdateLoop(opts = {}) {
     `[auto-update] Polling every ${Math.round(intervalMs / 1000 / 60)} min for upstream changes`,
   );
 
+
   async function poll() {
     // Safety check: Is parent process still alive?
     if (!isParentAlive()) {
@@ -336,17 +415,34 @@ export function startAutoUpdateLoop(opts = {}) {
 
     if (autoUpdateRunning) return;
     autoUpdateRunning = true;
+
+    let state = await readAutoUpdateState();
+    const now = Date.now();
+
     try {
+      if (isAutoUpdateDisabled(state, now)) {
+        if (!state.lastNotifiedAt) {
+          const notice = buildDisableNotice(state);
+          onNotify(notice);
+          console.log(notice);
+          state = { ...state, lastNotifiedAt: now };
+          await writeAutoUpdateState(state);
+        }
+        return;
+      }
+
+      if (state.disabledUntil && now >= state.disabledUntil) {
+        state = await resetAutoUpdateState();
+      }
+
       const currentVersion = getCurrentVersion();
       const latest = await fetchLatestVersion();
 
       if (!latest) {
-        autoUpdateRunning = false;
         return; // registry unreachable — try again next cycle
       }
 
       if (!isNewer(latest, currentVersion)) {
-        autoUpdateRunning = false;
         return; // already up to date
       }
 
@@ -364,7 +460,19 @@ export function startAutoUpdateLoop(opts = {}) {
         const errMsg = `[auto-update] ❌ Install failed: ${installErr.message || installErr}`;
         console.error(errMsg);
         onNotify(errMsg);
-        autoUpdateRunning = false;
+
+        const updatedState = await recordAutoUpdateFailure(
+          state,
+          classifyInstallError(installErr),
+        );
+
+        if (updatedState.disabledUntil && !updatedState.lastNotifiedAt) {
+          const notice = buildDisableNotice(updatedState);
+          onNotify(notice);
+          console.log(notice);
+          updatedState.lastNotifiedAt = Date.now();
+          await writeAutoUpdateState(updatedState);
+        }
         return;
       }
 
@@ -374,11 +482,11 @@ export function startAutoUpdateLoop(opts = {}) {
         const errMsg = `[auto-update] ⚠️ Install ran but version unchanged (${newVersion}). Skipping restart.`;
         console.warn(errMsg);
         onNotify(errMsg);
-        autoUpdateRunning = false;
         return;
       }
 
       await writeCache({ lastCheck: Date.now(), latestVersion: latest });
+      await resetAutoUpdateState();
 
       const successMsg = `[auto-update] ✅ Updated to v${latest}. Restarting...`;
       console.log(successMsg);
@@ -519,3 +627,17 @@ function promptConfirm(question) {
     });
   });
 }
+
+
+export const __autoUpdateTestHooks = {
+  readAutoUpdateState,
+  writeAutoUpdateState,
+  resetAutoUpdateState,
+  recordAutoUpdateFailure,
+  isAutoUpdateDisabled,
+  classifyInstallError,
+  buildDisableNotice,
+  AUTO_UPDATE_STATE_FILE,
+  AUTO_UPDATE_FAILURE_LIMIT,
+  AUTO_UPDATE_DISABLE_WINDOW_MS,
+};

package/workflow-templates/github.mjs

@@ -39,7 +39,7 @@ export const PR_MERGE_STRATEGY_TEMPLATE = {
     }, { x: 400, y: 50 }),
 
     node("check-ci", "validation.build", "Check CI Status", {
-      command: "gh pr checks {{prNumber}} --json name,state,conclusion",
+      command: "gh pr checks {{prNumber}} --json name,state",
     }, { x: 150, y: 200 }),
 
     node("get-diff", "action.run_command", "Get Diff Stats", {
@@ -47,7 +47,8 @@ export const PR_MERGE_STRATEGY_TEMPLATE = {
     }, { x: 650, y: 200 }),
 
     node("ci-passed", "condition.expression", "CI Passed?", {
-      expression: "$ctx.getNodeOutput('check-ci')?.passed === true",
+      expression:
+        "(() => { const out = $ctx.getNodeOutput('check-ci'); if (!out || out.passed !== true) return false; let checks = []; try { checks = JSON.parse(out.output || '[]'); } catch { return false; } if (!Array.isArray(checks) || checks.length === 0) return false; const ok = new Set(['SUCCESS', 'PASSED', 'PASS', 'COMPLETED', 'NEUTRAL', 'SKIPPED']); return checks.every((c) => ok.has(String(c?.state || '').toUpperCase())); })()",
     }, { x: 150, y: 350, outputs: ["yes", "no"] }),
 
     node("wait-for-ci", "action.delay", "Wait for CI", {
@@ -294,7 +295,7 @@ Only fix conflicts, do NOT change any logic. Keep changes minimal.`,
     }, { x: 200, y: 500 }),
 
     node("verify-ci", "action.run_command", "Verify CI Green", {
-      command: "gh pr checks --json name,state,conclusion | head -20",
+      command: "gh pr checks --json name,state",
     }, { x: 200, y: 660 }),
 
     node("auto-merge", "condition.expression", "CI Passed?", {

package/workflow-templates/reliability.mjs

@@ -301,17 +301,17 @@ export const HEALTH_CHECK_TEMPLATE = {
     }, { x: 150, y: 200 }),
 
     node("check-git", "action.run_command", "Check Git State", {
-      command: "git status --porcelain && git worktree list --porcelain | grep -c worktree",
+      command: "node -e \"const cp=require('node:child_process');const status=cp.execSync('git status --porcelain',{encoding:'utf8'});const wt=cp.execSync('git worktree list --porcelain',{encoding:'utf8'});const count=(wt.match(/^worktree /gm)||[]).length;process.stdout.write(status + (status.endsWith('\\\\n') ? '' : '\\\\n') + count + '\\\\n');\"",
       continueOnError: true,
     }, { x: 400, y: 200 }),
 
     node("check-agents", "action.run_command", "Check Agent Status", {
-      command: "bosun --daemon-status 2>/dev/null || echo 'daemon not running'",
+      command: "node -e \"const cp=require('node:child_process');try{process.stdout.write(cp.execSync('bosun --daemon-status',{encoding:'utf8'}));}catch{process.stdout.write('daemon not running\\\\n');}\"",
       continueOnError: true,
     }, { x: 650, y: 200 }),
 
     node("has-issues", "condition.expression", "Any Issues?", {
-      expression: "($ctx.getNodeOutput('check-config')?.output || '').includes('ERROR') || ($ctx.getNodeOutput('check-config')?.output || '').includes('CRITICAL')",
+      expression: "($ctx.getNodeOutput('check-config')?.success === false) || (($ctx.getNodeOutput('check-config')?.output || '').includes('ERROR')) || (($ctx.getNodeOutput('check-config')?.output || '').includes('CRITICAL')) || ($ctx.getNodeOutput('check-git')?.success === false) || ($ctx.getNodeOutput('check-agents')?.success === false)",
     }, { x: 400, y: 380 }),
 
     node("alert", "notify.telegram", "Alert Issues Found", {
@@ -349,4 +349,3 @@ export const HEALTH_CHECK_TEMPLATE = {
     },
   },
 };
-