@indigoai-us/hq-cli 5.345.174 → 5.345.176

package/dist/lib/bot/run.js

@@ -50,6 +50,7 @@ import { ownerContextBlock } from "./owner-context.js";
 import { randomUUID } from "node:crypto";
 import { hasPromotionHold } from "./promotion-hold.js";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { fullJitterDelayMs } from "../mesh/live/backoff.js";
 import { acquirePidLock, defaultPidLockDeps, releasePidLock } from "../mesh/live/daemon/pid-lock.js";
@@ -82,14 +83,15 @@ import { resolveRoomMentionsForBot, roomPostHasMentionTokens, } from "./room-men
 import { buildJobTurnPrompt, isCatchUpRun, isJobItem, jobReportHeader, jobRunOutput, machineTimeZone, planJobRuns, stripJobHeader, SUPERSEDED_DISPOSITION } from "./job-run.js";
 import { botJobQuietOptionEnabled } from "./job-quiet-flag.js";
 import { clearPendingJobCompletion, isCompletionDue, isCompletionExpired, isCompletionForOtherAgent, readPendingJobCompletions, recordPendingJobCompletion } from "./job-completions.js";
-import { SIGN_IN_RETRY_MS, signInNeededText } from "./runtime-sign-in.js";
+import { SIGN_IN_CHECK_FRESH_MS, SIGN_IN_CHECK_MS, SIGN_IN_RETRY_MS, signInNeededText, signedOutExcerpt, } from "./runtime-sign-in.js";
+import { checkRuntimeSignIn } from "./runtime-sign-in-check.js";
 import { classifyRuntimeError, classifyRuntimeFailure, runtimeDidNotFinishText, runtimeFailureReason, runtimeFailureText, runtimeRepairNotice, withRetrySuggestion, } from "./runtime-failure.js";
 import { HQ_BOT_AGENT_UID_ENV } from "../../commands/onboard-bot-membership.js";
 import { captureHeartbeatIdentityMismatch, identityMismatchMessage, isHeartbeatIdentityMismatch, } from "../heartbeat-identity.js";
 import { clearBotSession, ensureBotCompanyScope, readBotSession, writeBotSession } from "./session.js";
 import { defaultBotStatus, patchBotStatus, readBotStatus } from "./status.js";
 import { CLI_VERSION } from "../../cli-version.js";
-import { CLI_UPDATE_RESTART_EXIT_CODE } from "./cli-update.js";
+import { CLI_UPDATE_RESTART_EXIT_CODE, describeCliUpdate } from "./cli-update.js";
 import { createInboxMqttWakeFlagReader, createInboxPollBackoffFlagReader, safeErrorClass } from "./inbox-poll-backoff-flag.js";
 import { createInboxWakeWatcher } from "./inbox-wake.js";
 import { workMeshRoot } from "../mesh/live/paths.js";
@@ -129,6 +131,8 @@ export const FAILURE_WINDOW_MS = 10 * 60 * 1000;
 export const FAILURE_LIMIT = 5;
 /** Resumed-session failures with the model CLI's unknown error, in a row, before the session is cleared. */
 export const RESUMED_UNKNOWN_ERROR_LIMIT = 2;
+/** Wait before the one automatic re-run of a turn whose runtime crashed before it started. */
+export const RUNTIME_CRASH_RETRY_DELAY_MS = 3_000;
 /** The model CLI's own message, exactly; "Unexpected token" in a stack trace is not it. */
 const RESUMED_UNKNOWN_ERROR = /an unknown error occurred \(unexpected\)/i;
 export const MAX_ATTEMPTS_PER_MESSAGE = 3;
@@ -193,6 +197,29 @@ export function turnEnv(base, kind, agentUid, companySlug) {
     }
     return env;
 }
+/** The account name this process runs as, or null when the OS cannot say. */
+export function osUserName() {
+    try {
+        const name = os.userInfo().username?.trim();
+        return name || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Claude Code keys its macOS Keychain login on `$USER` (falling back to the
+ * literal "unknown"), so a tool spawned from an environment without USER
+ * reads a different Keychain item than the owner's terminal and is signed
+ * out. launchd and the HQ app's launcher may leave it unset; fill it (and
+ * LOGNAME) from the account this process runs as. Never overrides a USER
+ * already set. Pure.
+ */
+export function withOsUser(env, name = osUserName()) {
+    if (env.USER?.trim() || !name)
+        return env;
+    return { ...env, USER: name, ...(env.LOGNAME?.trim() ? {} : { LOGNAME: name }) };
+}
 /** The core worker HQ's setup bot runs. */
 export const SETUP_WORKER_ID = SETUP_BOT_WORKER_ID;
 /**
@@ -493,7 +520,7 @@ export async function runBot(deps) {
         cliUpdatePending = update;
         stopping = true;
         const busy = running.size;
-        log("info", `hq-cli updated ${update.from} -> ${update.to}; restarting to load it${busy ? ` after ${busy} running turn${busy === 1 ? "" : "s"} finish${busy === 1 ? "es" : ""}` : ""}`);
+        log("info", `${describeCliUpdate(update)}${busy ? ` after ${busy} running turn${busy === 1 ? "" : "s"} finish${busy === 1 ? "es" : ""}` : ""}`);
         return true;
     };
     // ── Preflight: creds, pid lock, owner verification ─────────────────────────
@@ -693,7 +720,7 @@ export async function runBot(deps) {
         // nothing while their next messages wait out the hold.
         if (tell) {
             try {
-                await tell(holdNoticeText(modelHoldMs, messagePending, cls ? runtimeFailureText(cls, runtime.id) : undefined));
+                await tell(holdNoticeText(modelHoldMs, messagePending, cls ? runtimeFailureText(cls, runtime.id, "message", config.name) : undefined));
             }
             catch (err) {
                 log("warn", `could not say that turns are on hold: ${err instanceof Error ? err.message : String(err)}`);
@@ -712,14 +739,17 @@ export async function runBot(deps) {
     /** Conversations already told this time that the bot needs a sign-in. */
     const toldAboutSignIn = new Set();
     const isSignInFailure = (excerpt) => classifyRuntimeFailure(excerpt) === "signed-out";
-    const markSignInBroken = (excerpt) => {
-        nextSignInRetryAt = now().getTime() + signInRetryMs;
+    const markSignInBroken = (excerpt, state = "expired", bump = true) => {
+        if (bump)
+            nextSignInRetryAt = now().getTime() + signInRetryMs;
         modelHealth = "degraded";
         if (signInIssue)
             return;
-        signInIssue = { state: "expired", runtime: config.runtime, since: now().toISOString() };
+        signInIssue = { state, runtime: config.runtime, since: now().toISOString() };
         setStatus({ runtimeSignIn: signInIssue, lastError: excerpt.slice(0, 400) });
-        log("warn", `${runtime.id} needs to sign in again on this computer; holding turns and retrying every ${Math.round(signInRetryMs / 1000)}s`);
+        log("warn", state === "signed-out"
+            ? `${runtime.id} is not signed in on this computer (its own check); holding turns and checking every ${Math.round(signInCheckMs / 1000)}s`
+            : `${runtime.id} needs to sign in again on this computer; holding turns and retrying every ${Math.round(signInRetryMs / 1000)}s`);
     };
     const markSignInWorks = () => {
         if (!signInIssue)
@@ -729,6 +759,70 @@ export async function runBot(deps) {
         setStatus({ runtimeSignIn: null });
         log("info", `${runtime.id} sign-in works again; resuming`);
     };
+    // ── The bot's own sign-in check ────────────────────────────────────────────
+    // The tool is asked in the turn's environment (not the owner's shell): at
+    // start, before a turn, and on a timer while it says signed out, so a
+    // message is never spent on a turn that cannot start and the app can read
+    // the answer before it sends a job.
+    const signInCheckMs = Math.max(0, deps.signInCheckMs ?? SIGN_IN_CHECK_MS);
+    const checkSignIn = deps.checkSignIn ?? ((env) => checkRuntimeSignIn({ runtime, env, cwd: turnCwd, now }));
+    let lastSignInCheck = null;
+    let nextSignInCheckAt = 0;
+    /** Ask the tool; record the answer in status.json; return it. */
+    const runSignInCheck = async (reason) => {
+        const env = withOsUser(turnEnv(process.env, kind, config.agentUid, companySlug));
+        let check;
+        try {
+            check = await checkSignIn(env);
+        }
+        catch (err) {
+            check = { signedIn: null, checkedAt: now().toISOString(), detail: err instanceof Error ? err.message : String(err) };
+        }
+        lastSignInCheck = check;
+        nextSignInCheckAt = now().getTime() + signInCheckMs;
+        setStatus({ runtimeSignInCheck: check });
+        if (check.signedIn === false) {
+            // A repeat "no" while already held does not push the retry out again:
+            // the hold's own timer decides when a real turn gets to disagree.
+            markSignInBroken(signedOutExcerpt(runtime.id), "signed-out", signInIssue == null);
+        }
+        else if (check.signedIn === true) {
+            if (signInIssue) {
+                // The tool answers for itself now: the held messages run at once.
+                nextSignInRetryAt = 0;
+                markSignInWorks();
+            }
+        }
+        else if (check.detail) {
+            log("debug", `sign-in check (${reason}) could not tell: ${check.detail}`);
+        }
+        return check;
+    };
+    /** When a real turn last ran despite the tool saying "signed out". */
+    let lastTurnDespiteSignedOutAt = now().getTime();
+    /**
+     * Before a turn: a fresh "signed in" stands; anything else is asked again.
+     * The tool's status command only knows about its own account sign-in, so a
+     * tool that works some other way (an API key, Bedrock, Vertex) says "no"
+     * and would be held forever. Once per retry window a real turn runs anyway
+     * and its outcome decides: success clears the hold, a sign-in failure
+     * keeps it.
+     */
+    const signedOutBeforeTurn = async () => {
+        const fresh = lastSignInCheck?.signedIn === true && now().getTime() - new Date(lastSignInCheck.checkedAt).getTime() < SIGN_IN_CHECK_FRESH_MS;
+        if (fresh)
+            return false;
+        const check = await runSignInCheck("turn");
+        if (check.signedIn !== false)
+            return false;
+        const t = now().getTime();
+        if (signInRetryMs > 0 && t - lastTurnDespiteSignedOutAt >= signInRetryMs) {
+            lastTurnDespiteSignedOutAt = t;
+            log("info", `${runtime.id} still says it is not signed in; letting one turn try so a tool signed in another way is not held forever`);
+            return false;
+        }
+        return true;
+    };
     /** Say once per conversation that the bot cannot work until its tool signs in. */
     const tellSignInNeeded = async (conversation, post, kickoff = false, retryOf) => {
         if (toldAboutSignIn.has(conversation))
@@ -739,7 +833,7 @@ export async function runBot(deps) {
                 runtime: config.runtime,
                 botName: config.name,
                 context: kickoff ? "kickoff" : "message",
-                text: signInNeededText(config.runtime, kickoff),
+                text: signInNeededText(config.runtime, kickoff, signInIssue?.state ?? "expired"),
                 ...(retryOf ? { retryOf } : {}),
             }));
             toldAboutSignIn.add(conversation);
@@ -953,7 +1047,7 @@ export async function runBot(deps) {
             // resets). Claude gets the full hook set via its payload session id;
             // Codex/Grok only see HQ_SESSION_ID.
             const sid = session?.sessionId ?? randomUUID();
-            const env = turnEnv(process.env, kind, config.agentUid, companySlug);
+            const env = withOsUser(turnEnv(process.env, kind, config.agentUid, companySlug));
             let bind = { env };
             if (companySlug) {
                 try {
@@ -964,6 +1058,12 @@ export async function runBot(deps) {
                 }
                 bind = { newSessionId: sid, env: { ...env, HQ_SESSION_ID: sid } };
             }
+            // The tool's own word first: a turn on a signed-out tool cannot start,
+            // and its failure text varies by version (on 2026-10-28 it was a bare
+            // "unknown error" that read as a crash). Held like any sign-in failure.
+            if (await signedOutBeforeTurn()) {
+                throw new RuntimeError(`${runtime.id} is not signed in on this computer`, signedOutExcerpt(runtime.id), 1, { started: false, durationMs: 0 });
+            }
             const tTurnStart = now().getTime();
             // Model and thinking level are read fresh each turn, so a change from the
             // bot's profile (`hq bot set`) applies to the next message without a restart.
@@ -1018,6 +1118,14 @@ export async function runBot(deps) {
                 setStatus({ runtimeModelFallback: null });
             }
             log("info", `model turn done in ${Math.round((now().getTime() - tTurnStart) / 1000)}s (${Math.round((tTurnStart - tReceived) / 1000)}s before it)`);
+            // Clears a reported runtime crash (runtimeCrashSinceStart): the tool works again.
+            // Stamped with when the turn STARTED, so a long turn begun before a crash
+            // that finishes after it does not clear the crash for turns that follow.
+            // Never moves backwards: two turns run side by side, and an older one
+            // finishing last must not bring back a crash a newer turn already cleared.
+            const prevOk = Date.parse(readStatus()?.lastTurnOkAt ?? "");
+            if (!Number.isFinite(prevOk) || tTurnStart > prevOk)
+                setStatus({ lastTurnOkAt: new Date(tTurnStart).toISOString() });
             // A brief job's session is one run long; nothing resumes it.
             if (turn.sessionId && !isBriefJobSessionScope(sessionScope)) {
                 writeBotSession(dir, {
@@ -1039,16 +1147,35 @@ export async function runBot(deps) {
             }
             return turn;
         };
-        const session = readBotSession(dir, config.runtime, sessionScope);
+        const attemptOnce = async () => {
+            const session = readBotSession(dir, config.runtime, sessionScope);
+            try {
+                return await runAttempt(session, await composePrompt(session));
+            }
+            catch (err) {
+                if (!missingResumedSession(err))
+                    throw err;
+                clearBotSession(dir, sessionScope);
+                log("warn", "saved model session is gone; starting a new one with recent DM history");
+                return await runAttempt(null, await composePrompt(null));
+            }
+        };
         try {
-            return await runAttempt(session, await composePrompt(session));
+            return await attemptOnce();
         }
         catch (err) {
-            if (!missingResumedSession(err))
+            // The coding tool's process died before the turn started (Bun's
+            // "error: An unknown error occurred (Unexpected)" after a long idle,
+            // October 2026). A fresh process usually works: wait a moment and run
+            // the same turn once more. If that fails too, the caller's normal
+            // failure path tells the person (with the Heal bot card).
+            if (stream.signal?.aborted || classifyRuntimeError(err) !== "runtime-crashed")
                 throw err;
-            clearBotSession(dir, sessionScope);
-            log("warn", "saved model session is gone; starting a new one with recent DM history");
-            return await runAttempt(null, await composePrompt(null));
+            log("info", "runtime crashed before the turn started; retrying once");
+            await sleep(RUNTIME_CRASH_RETRY_DELAY_MS, stream.signal);
+            if (stream.signal?.aborted)
+                throw err;
+            return await attemptOnce();
         }
     };
     /** Failure bookkeeping shared by every model turn: window, health, status, log, stale session. */
@@ -1059,7 +1186,20 @@ export async function runBot(deps) {
         const count = failures.record(now().getTime());
         modelHealth = count >= FAILURE_LIMIT ? "failed" : "degraded";
         setStatus({ restarts: (readStatus()?.restarts ?? 0) + 1, recentFailures: count, lastError: excerpt.slice(0, 400) });
-        log("error", `model turn failed (${count}/${FAILURE_LIMIT} in window, ${classifyRuntimeError(err)}): ${excerpt}`);
+        const cls = classifyRuntimeError(err);
+        log("error", `model turn failed (${count}/${FAILURE_LIMIT} in window, ${cls}): ${excerpt}`);
+        if (cls === "runtime-crashed" && err instanceof RuntimeError) {
+            const stderr = (err.stderrFull ?? err.stderrExcerpt).slice(0, 2000);
+            log("error", `runtime crash evidence: exit ${err.exitCode ?? "?"}, lived ${err.durationMs ?? "?"} ms, binary ${err.binaryPath ?? runtime.binary}; stderr: ${JSON.stringify(stderr)}; stdout head: ${JSON.stringify((err.stdoutHead ?? "").slice(0, 300))}`);
+            setStatus({
+                lastCrash: {
+                    at: now().toISOString(),
+                    code: err.exitCode,
+                    ...(err.durationMs !== undefined ? { durationMs: err.durationMs } : {}),
+                    stderr,
+                },
+            });
+        }
         // A resumed session that no longer exists must not poison every turn: the
         // next turn starts fresh with the recent DM history prepended. The model
         // CLI's "An unknown error occurred (Unexpected)" (every turn of a
@@ -1683,7 +1823,7 @@ export async function runBot(deps) {
                 runtime: runtime.id,
                 botName: config.name,
                 context: "kickoff",
-                ...(outcome.started && poster.postedCount > 0 ? { text: runtimeDidNotFinishText(cls, runtime.id, true) } : {}),
+                ...(outcome.started && poster.postedCount > 0 ? { text: runtimeDidNotFinishText(cls, runtime.id, true, config.name) } : {}),
             });
         try {
             await postRepair(target, notice);
@@ -1852,7 +1992,7 @@ export async function runBot(deps) {
             }
             // A missing tool does not come back between retries: say so now.
             if (attempt >= MAX_ATTEMPTS_PER_MESSAGE || cls === "not-installed") {
-                const plain = runtimeFailureText(cls, runtime.id);
+                const plain = runtimeFailureText(cls, runtime.id, "message", config.name);
                 await sendToPerson(`I couldn't run this one. ${plain}`).catch(() => undefined);
                 await completeJobRun(jobId, id, { status: "failed", output: jobRunOutput(plain), disposition: `${runtime.id} could not be started` });
                 markReported("failed");
@@ -1872,12 +2012,12 @@ export async function runBot(deps) {
         // reports and says this real reason, not "the bot was restarted".
         // What the cloud stores as the run's output: plain words, never the raw
         // runtime text (that is in the bot log and status.json).
-        const jobOutput = outcome.aborted ? `${STOPPED_BY_OWNER_REASON}.` : runtimeFailureText(failureClass(outcome), runtime.id);
+        const jobOutput = outcome.aborted ? `${STOPPED_BY_OWNER_REASON}.` : runtimeFailureText(failureClass(outcome), runtime.id, "message", config.name);
         patchInflight(dir, id, { jobFailure: { reason, output: jobOutput } });
         try {
             await sendToPerson(outcome.aborted
                 ? didNotFinishText(reason, poster.postedCount > 0)
-                : runtimeDidNotFinishText(failureClass(outcome), runtime.id, poster.postedCount > 0));
+                : runtimeDidNotFinishText(failureClass(outcome), runtime.id, poster.postedCount > 0, config.name));
         }
         catch (err) {
             // Leave it un-acked with the marker: the next poll reports it.
@@ -2381,7 +2521,7 @@ export async function runBot(deps) {
                     runtime: runtime.id,
                     botName: config.name,
                     context: "message",
-                    text: runtimeDidNotFinishText(cls, runtime.id, poster.postedCount > 0),
+                    text: runtimeDidNotFinishText(cls, runtime.id, poster.postedCount > 0, config.name),
                     retryOf: item.eventId ?? id,
                 }), item.rootEventId);
             }
@@ -2397,6 +2537,10 @@ export async function runBot(deps) {
         attempts.delete(id);
         log("error", `turn on ${id} ${outcome.aborted ? "stopped by the owner" : "failed"} after it started; told the owner, not re-run`);
     };
+    // The bot's first look at its tool's sign-in, so `hq bot status` and the
+    // app know before any message arrives. A tool that cannot be asked changes
+    // nothing; the first turn then reports for itself.
+    await runSignInCheck("start");
     // The kickoff runs alongside the heartbeat, before the first inbox poll, so
     // an owner message sent meanwhile is answered after it in the same session.
     const kickoff = kickoffAfterIntro
@@ -2498,6 +2642,13 @@ export async function runBot(deps) {
             }
             if (modelHoldUntil)
                 liftModelHold();
+            // While the tool says it is signed out, ask it again on a timer (cheap,
+            // no turn): the moment it is signed in, the held messages run.
+            if (signInIssue && busyLanes.size === 0 && now().getTime() >= nextSignInCheckAt) {
+                await runSignInCheck("watch");
+                if (!signInIssue)
+                    pump();
+            }
             // A kickoff held for a sign-in retries on the same timer as messages.
             if (busyLanes.size === 0 &&
                 (!signInIssue || now().getTime() >= nextSignInRetryAt) &&
@@ -2628,7 +2779,7 @@ export async function runBot(deps) {
         catch (err) {
             log("warn", `could not record the update restart: ${err instanceof Error ? err.message : String(err)}`);
         }
-        void finish("stopped", CLI_UPDATE_RESTART_EXIT_CODE, `hq-cli updated ${update.from} -> ${update.to}; restarting to load it`, () => deps.onCliUpdateRestart?.(update, log));
+        void finish("stopped", CLI_UPDATE_RESTART_EXIT_CODE, describeCliUpdate(update), () => deps.onCliUpdateRestart?.(update, log));
     });
     return { stop, done, status: readStatus, idle: () => pending.size === 0 };
 }

package/dist/lib/bot/runtime/claude.d.ts

@@ -15,7 +15,7 @@
  * carries the final text and session_id.
  * Verified against Claude Code 2.1.258 on 2026-09-12 (fixtures/claude-stream.ndjson).
  */
-import type { BotRuntime } from "./types.js";
+import type { BotRuntime, SpawnResult } from "./types.js";
 export declare const CLAUDE_PERMISSION_MODE_ENV = "HQ_BOT_CLAUDE_PERMISSION_MODE";
 export declare const DEFAULT_CLAUDE_PERMISSION_MODE = "bypassPermissions";
 export declare const GATED_CLAUDE_PERMISSION_MODE = "acceptEdits";
@@ -84,4 +84,10 @@ export interface ClaudeRuntimeOptions {
     systemBinDirs?: readonly string[];
 }
 export declare function createClaudeRuntime(env?: NodeJS.ProcessEnv, opts?: ClaudeRuntimeOptions): BotRuntime;
+/**
+ * `claude auth status --json` prints `{"loggedIn": true|false, ...}` and
+ * exits 0 either way. Null when the output is not that (an older CLI, or a
+ * tool that could not run at all).
+ */
+export declare function parseClaudeAuthStatus(result: SpawnResult): boolean | null;
 //# sourceMappingURL=claude.d.ts.map

package/dist/lib/bot/runtime/claude.js

@@ -230,6 +230,35 @@ export function createClaudeRuntime(env = process.env, opts = {}) {
         failureReason(stdout) {
             return messagesStreamFailure(stdout);
         },
+        signInStatus: { args: ["auth", "status", "--json"], parse: parseClaudeAuthStatus },
     };
 }
+/**
+ * `claude auth status --json` prints `{"loggedIn": true|false, ...}` and
+ * exits 0 either way. Null when the output is not that (an older CLI, or a
+ * tool that could not run at all).
+ */
+export function parseClaudeAuthStatus(result) {
+    const text = result.stdout ?? "";
+    const start = text.indexOf("{");
+    if (start >= 0) {
+        try {
+            const parsed = JSON.parse(text.slice(start));
+            if (typeof parsed.loggedIn === "boolean")
+                return parsed.loggedIn;
+        }
+        catch {
+            /* fall through to the loose match */
+        }
+    }
+    const m = /"loggedIn"\s*:\s*(true|false)/.exec(text);
+    if (m)
+        return m[1] === "true";
+    const plain = `${text}\n${result.stderr ?? ""}`;
+    if (/\bnot logged in\b/i.test(plain))
+        return false;
+    if (/\blogged in\b/i.test(plain))
+        return true;
+    return null;
+}
 //# sourceMappingURL=claude.js.map

package/dist/lib/bot/runtime/codex.d.ts

@@ -90,5 +90,10 @@ export declare function bundledCodexBin(homeDir?: string, isExecutable?: IsExecu
  * usual "codex is not installed or not on PATH" error.
  */
 export declare function resolveCodexBinary(env: NodeJS.ProcessEnv, homeDir?: string, platform?: NodeJS.Platform, cwd?: string, isExecutable?: IsExecutableFile): string;
+/**
+ * `codex login status` prints "Logged in using ChatGPT" (exit 0) or "Not
+ * logged in" (exit 1). Null when it said neither.
+ */
+export declare function parseCodexLoginStatus(result: SpawnResult): boolean | null;
 export declare function createCodexRuntime(): BotRuntime;
 //# sourceMappingURL=codex.d.ts.map

package/dist/lib/bot/runtime/codex.js

@@ -270,11 +270,24 @@ export function resolveCodexBinary(env, homeDir, platform = process.platform, cw
     // `||`, not `??`: an empty HOME must not turn ~/Applications into a relative path.
     return bundledCodexBin(homeDir || env.HOME || os.homedir(), isExecutable) ?? "codex";
 }
+/**
+ * `codex login status` prints "Logged in using ChatGPT" (exit 0) or "Not
+ * logged in" (exit 1). Null when it said neither.
+ */
+export function parseCodexLoginStatus(result) {
+    const text = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+    if (/\bnot logged in\b/i.test(text))
+        return false;
+    if (/\blogged in\b/i.test(text))
+        return true;
+    return null;
+}
 export function createCodexRuntime() {
     return {
         id: "codex",
         binary: "codex",
         resolveBinary: (env, cwd, platform) => resolveCodexBinary(env, undefined, platform ?? process.platform, cwd),
+        signInStatus: { args: ["login", "status"], parse: parseCodexLoginStatus },
         buildArgs(input, scratch) {
             const promptArg = input.platform === "win32" ? "-" : codexPrompt(input);
             const common = ["--json", "--skip-git-repo-check", "-o", scratch.outputFile];

package/dist/lib/bot/runtime/index.js

@@ -394,12 +394,15 @@ export async function runRuntimeTurn(runtime, input, deps = {}) {
     let modelFallback = remembered ? { from: remembered.from, to: remembered.to } : undefined;
     /** The retries on supported models failed too: report the first failure (its cause is the old CLI). */
     let fallbackFailure;
+    let spawnedAt = nowMs();
     try {
         result = await spawnImpl(binary, args, spawnOptions);
         if (runtime.id === "grok" && result.code !== 0 && !input.signal?.aborted) {
             const retryArgs = grokRetryArgsAfterInvalidOutputFormat(args, result.stderr);
-            if (retryArgs)
+            if (retryArgs) {
+                spawnedAt = nowMs();
                 result = await spawnImpl(binary, retryArgs, spawnOptions);
+            }
         }
         if (remembered) {
             // A turn on the remembered model: it either still works or the memo is wrong.
@@ -439,6 +442,7 @@ export async function runRuntimeTurn(runtime, input, deps = {}) {
                         continue;
                     tried.push(to);
                     const retryArgs = runtime.buildArgs({ ...turnInput, model: to }, { outputFile, newSessionId });
+                    spawnedAt = nowMs();
                     const retry = await spawnImpl(binary, retryArgs, spawnOptions);
                     if (input.signal?.aborted) {
                         // The owner stopped it: report the stop, remember nothing.
@@ -493,6 +497,11 @@ export async function runRuntimeTurn(runtime, input, deps = {}) {
         }
     }
     if (result.code !== 0 || result.signal) {
+        const durationMs = Math.max(0, nowMs() - spawnedAt);
+        const sawStreamEvent = result.stdout.split("\n").some((line) => {
+            const ev = parseJsonLine(line);
+            return ev !== null && (ev.type === "system" || ev.type === "assistant" || ev.type === "result");
+        });
         const reason = runtime.failureReason?.(result.stdout, result.stderr);
         // Streaming runtimes write JSON events to stdout: never show those to a
         // person as the reason. stderr, then a plain description, instead.
@@ -505,7 +514,14 @@ export async function runRuntimeTurn(runtime, input, deps = {}) {
                 : result.signal
                     ? `the ${runtime.binary} process was killed (${result.signal})`
                     : `${runtime.binary} exited with code ${result.code}`;
-        throw new RuntimeError(`${runtime.binary} exited with ${result.code ?? `signal ${result.signal}`}${reason ? `: ${reason.slice(0, 200)}` : ""}${fallbackFailure ? ` (${fallbackFailure})` : ""}`, reason ? reason.slice(0, 400) : fallback, result.code, !reason && stdoutTail ? { excerptIsOutputTail: true } : {});
+        throw new RuntimeError(`${runtime.binary} exited with ${result.code ?? `signal ${result.signal}`}${reason ? `: ${reason.slice(0, 200)}` : ""}${fallbackFailure ? ` (${fallbackFailure})` : ""}`, reason ? reason.slice(0, 400) : fallback, result.code, {
+            ...(!reason && stdoutTail ? { excerptIsOutputTail: true } : {}),
+            durationMs,
+            sawStreamEvent,
+            binaryPath: binary,
+            stderrFull: result.stderr.slice(0, 2000),
+            stdoutHead: result.stdout.slice(0, 300),
+        });
     }
     const parsed = runtime.parseOutput(result.stdout, { outputFile, outputFileText });
     // A turn that ran on the requested model and succeeded: nothing to remember.

package/dist/lib/bot/runtime/types.d.ts

@@ -128,10 +128,23 @@ export declare class RuntimeError extends Error {
      * must never decide what went wrong; only the message may.
      */
     readonly excerptIsOutputTail: boolean;
+    /** How long the runtime process lived, in ms, when known. */
+    readonly durationMs: number | undefined;
+    /** True when stdout carried at least one stream event (`system`, `assistant`, `result`): the turn started. */
+    readonly sawStreamEvent: boolean;
+    /** Crash evidence for the bot log: the binary spawned, full stderr and the head of stdout (bounded). */
+    readonly binaryPath: string | undefined;
+    readonly stderrFull: string | undefined;
+    readonly stdoutHead: string | undefined;
     constructor(message: string, stderrExcerpt: string, exitCode: number | null, opts?: {
         started?: boolean;
         aborted?: boolean;
         excerptIsOutputTail?: boolean;
+        durationMs?: number;
+        sawStreamEvent?: boolean;
+        binaryPath?: string;
+        stderrFull?: string;
+        stdoutHead?: string;
     });
 }
 export interface BotRuntime {
@@ -189,6 +202,16 @@ export interface BotRuntime {
         requestedModel: string | undefined;
         run: (args: string[]) => Promise<SpawnResult>;
     }): Promise<string[]>;
+    /**
+     * Optional: the tool's own "am I signed in?" command (`claude auth status
+     * --json`, `codex login status`), run in the bot's environment before a turn
+     * and at start. `parse` reads its answer: true/false, or null when the
+     * output does not say. Pure; needs no network.
+     */
+    signInStatus?: {
+        args: string[];
+        parse(result: SpawnResult): boolean | null;
+    };
 }
 /**
  * Turns have no time limit: a turn runs until the model process exits (the

package/dist/lib/bot/runtime/types.js

@@ -19,6 +19,14 @@ export class RuntimeError extends Error {
      * must never decide what went wrong; only the message may.
      */
     excerptIsOutputTail;
+    /** How long the runtime process lived, in ms, when known. */
+    durationMs;
+    /** True when stdout carried at least one stream event (`system`, `assistant`, `result`): the turn started. */
+    sawStreamEvent;
+    /** Crash evidence for the bot log: the binary spawned, full stderr and the head of stdout (bounded). */
+    binaryPath;
+    stderrFull;
+    stdoutHead;
     constructor(message, stderrExcerpt, exitCode, opts = {}) {
         super(message);
         this.stderrExcerpt = stderrExcerpt;
@@ -27,6 +35,11 @@ export class RuntimeError extends Error {
         this.started = opts.started ?? true;
         this.aborted = opts.aborted ?? false;
         this.excerptIsOutputTail = opts.excerptIsOutputTail ?? false;
+        this.durationMs = opts.durationMs;
+        this.sawStreamEvent = opts.sawStreamEvent ?? false;
+        this.binaryPath = opts.binaryPath;
+        this.stderrFull = opts.stderrFull;
+        this.stdoutHead = opts.stdoutHead;
     }
 }
 /**

package/dist/lib/bot/runtime-failure.d.ts

@@ -27,16 +27,27 @@ export type RuntimeFailureClass =
  | "transient"
 /** The tool is not installed (or not on PATH) on this computer. */
  | "not-installed"
+/** The tool's process exited before the turn started (e.g. Bun's "error: ... (Unexpected)"). A restart heals it. */
+ | "runtime-crashed"
 /** Anything else. Neutral copy; never blames the sign-in. */
  | "unknown";
-/** The four classes that get a repair card in the DM. */
-export type RuntimeRepairClass = Extract<RuntimeFailureClass, "signed-out" | "cli-outdated" | "model-unsupported" | "transient">;
+/** The classes that get a repair card in the DM. */
+export type RuntimeRepairClass = Extract<RuntimeFailureClass, "signed-out" | "cli-outdated" | "model-unsupported" | "transient" | "runtime-crashed">;
 /** The one thing the person can do about it. The desktop maps each to a button. */
-export type RuntimeRepairAction = "signIn" | "update" | "switchModel" | "tryAgain";
+export type RuntimeRepairAction = "signIn" | "update" | "switchModel" | "tryAgain" | "restart";
 export declare const RUNTIME_REPAIR_ACTIONS: Record<RuntimeRepairClass, RuntimeRepairAction>;
 export declare function isRuntimeRepairClass(cls: RuntimeFailureClass): cls is RuntimeRepairClass;
 /** Sort a runtime's failure text into one class. Order matters: most specific first. */
 export declare function classifyRuntimeFailure(text: string | undefined | null): RuntimeFailureClass;
+export declare function isBunProcessError(text: string | undefined | null): boolean;
+/** A process that exits non-zero this soon, with no stream event, never started its turn. */
+export declare const RUNTIME_CRASH_MAX_MS = 5000;
+/**
+ * True when the coding tool's process exited before the turn started: a
+ * non-zero exit code, not stopped by the owner, no stream event on stdout,
+ * and either Bun's process error shape on stderr or a life under 5 s.
+ */
+export declare function isRuntimeCrash(err: unknown): boolean;
 /**
  * Class of a failed turn's error. A RuntimeError's excerpt (the runtime's own
  * reported error: failureReason, turn.failed, stderr) is the better evidence;
@@ -57,11 +68,11 @@ export type RuntimeFailureContext = "kickoff" | "message";
  */
 export declare function runtimeFailureReason(cls: RuntimeFailureClass, runtime: BotRuntimeId | string): string;
 /** The one next step, as a full sentence. */
-export declare function runtimeFailureNextStep(cls: RuntimeFailureClass, runtime: BotRuntimeId | string, context?: RuntimeFailureContext): string;
+export declare function runtimeFailureNextStep(cls: RuntimeFailureClass, runtime: BotRuntimeId | string, context?: RuntimeFailureContext, botName?: string): string;
 /** "My Codex app is out of date. Update Codex, then send me any message." */
-export declare function runtimeFailureText(cls: RuntimeFailureClass, runtime: BotRuntimeId | string, context?: RuntimeFailureContext): string;
+export declare function runtimeFailureText(cls: RuntimeFailureClass, runtime: BotRuntimeId | string, context?: RuntimeFailureContext, botName?: string): string;
 /** A failure after the model started (and maybe posted part of the answer). */
-export declare function runtimeDidNotFinishText(cls: RuntimeFailureClass, runtime: BotRuntimeId | string, progressPosted: boolean): string;
+export declare function runtimeDidNotFinishText(cls: RuntimeFailureClass, runtime: BotRuntimeId | string, progressPosted: boolean, botName?: string): string;
 /**
  * The machine-readable repair payload a failure DM carries. The DM transport
  * (POST /v1/notify/dm) stores structured data only in `richContent`