@kilogent/runner-dev 0.1.2 → 0.1.4

package/dist/cli.js

@@ -4,7 +4,9 @@
 import { Command } from "commander";
 
 // src/daemon.ts
-import os4 from "node:os";
+import fs9 from "node:fs";
+import os5 from "node:os";
+import path11 from "node:path";
 import {
   collection as collection8,
   deleteField as deleteField2,
@@ -24,6 +26,8 @@ import {
 var CLAUDE_ENGINE = {
   id: "claude",
   label: "Claude Code",
+  vendor: "Anthropic",
+  accountLabel: "Claude account",
   models: [
     { id: "sonnet", label: "Sonnet", rates: { input: 3, cachedInput: 0.3, output: 15 } },
     { id: "opus", label: "Opus", rates: { input: 15, cachedInput: 1.5, output: 75 } }
@@ -41,6 +45,8 @@ var CLAUDE_ENGINE = {
       key: "claudeToken",
       label: "Claude setup-token",
       hint: "Run `claude setup-token` on any machine signed in to Claude Code.",
+      flow: "paste",
+      setupCommand: "claude setup-token",
       // `claude setup-token` emits `sk-ant-oat01-…`, around 100 characters. The floor is set
       // well below that on purpose: it exists to catch a half-copied token, not to pin a format
       // Anthropic is free to change.
@@ -58,9 +64,50 @@ var CLAUDE_ENGINE = {
   }
 };
 
+// ../shared/dist/engines/codex.js
+var CODEX_ENGINE = {
+  id: "codex",
+  label: "Codex CLI",
+  vendor: "OpenAI",
+  accountLabel: "ChatGPT account",
+  models: [
+    { id: "gpt-5.5", label: "GPT-5.5", rates: { input: 5, cachedInput: 0.5, output: 30 } },
+    { id: "gpt-5.4", label: "GPT-5.4", rates: { input: 2.5, cachedInput: 0.25, output: 15 } },
+    { id: "gpt-5.4-mini", label: "GPT-5.4 mini", rates: { input: 0.75, cachedInput: 0.075, output: 4.5 } },
+    { id: "gpt-5.6-terra", label: "GPT-5.6 Terra", rates: { input: 2, cachedInput: 0.2, output: 12 } },
+    { id: "gpt-5.6-luna", label: "GPT-5.6 Luna", rates: { input: 0.2, cachedInput: 0.02, output: 1.2 } }
+  ],
+  defaultModelId: "gpt-5.5",
+  capabilities: {
+    mcp: true,
+    bash: true,
+    webSearch: false,
+    reportsCost: false,
+    reportsCache: true
+  },
+  requiredSecrets: [
+    {
+      key: "codexHome",
+      label: "ChatGPT sign-in (Codex)",
+      hint: "Sign one of this Ship's machines in from Settings \u203A AI credentials \u2014 the login never leaves it.",
+      flow: "machine-login",
+      // What `codex login --device-auth` prints: four characters, a dash, five. Display only.
+      codePattern: "^[A-Z0-9]{4}-[A-Z0-9]{5}$"
+    }
+  ],
+  usageWindows: {
+    label: "5-hour window",
+    // ChatGPT plans meter Codex on a rolling 5-hour window with a weekly cap on top — the same two
+    // walls Claude has, and the same reason the fallback is the SHORT one: the wall text does not
+    // say which was hit, and parking a Ship for a week on a guess is the worse mistake.
+    fallbackMs: 5 * 60 * 60 * 1e3
+  }
+};
+
 // ../shared/dist/engines/index.js
 var ENGINES = {
-  claude: CLAUDE_ENGINE
+  claude: CLAUDE_ENGINE,
+  codex: CODEX_ENGINE
 };
 var DEFAULT_ENGINE_ID = "claude";
 function listEngines() {
@@ -87,6 +134,10 @@ function estimateCostUsd(engineId, modelId, tokens) {
 }
 var AGENT_ENGINE_IDS = Object.freeze(listEngines().map((e) => e.id));
 var AGENT_MODEL_IDS = Object.freeze(listEngines().flatMap((e) => e.models.map((m) => m.id)));
+var MACHINE_LOGIN_ENGINE_IDS = Object.freeze(listEngines().filter((e) => e.requiredSecrets.some((r) => r.flow === "machine-login")).map((e) => e.id));
+function isMachineLoginEngine(id) {
+  return !!id && MACHINE_LOGIN_ENGINE_IDS.includes(id);
+}
 
 // ../shared/dist/agent.js
 var DEFAULT_AGENT_TOOLS = {
@@ -553,7 +604,7 @@ var COLLECTIONS = {
    * ROOT: `crewAdmins/{uid}` — one document per PLATFORM ADMIN, the people who may operate the
    * admin console.
    *
-   * DENY-ALL to every client in packages/crew/firestore.rules, in both directions. `crewAdmin`
+   * DENY-ALL to every client in packages/crew/firestore.rules, in both directions. `kilogentAdmin`
    * resolves the caller and reads this with the Admin SDK, which bypasses rules — so no browser
    * ever needs a verb here, and a collection nobody may read cannot leak who the operators are.
    *
@@ -571,7 +622,7 @@ var COLLECTIONS = {
   /**
    * ROOT: `adminAudit/{entryId}` — what an admin did, with both sides of the change.
    *
-   * Deny-all to clients; read back through `crewAdmin`. Its second job is what earns it a
+   * Deny-all to clients; read back through `kilogentAdmin`. Its second job is what earns it a
    * collection: it is the ONLY history `crewConfig/assistant` has. That document is overwritten in
    * place, so without this a bad prompt pushed to every workspace could not be rolled back to the
    * exact text that preceded it.
@@ -600,6 +651,14 @@ var COLLECTIONS = {
    * catch a forgotten credential-bearing collection.
    */
   credentials: "credentials",
+  /**
+   * `ships/{shipId}/credential_logins/{credId}` — the device-code half of a MACHINE-HELD credential
+   * while it is being signed in (PRD §15.81; see credentials.ts). Readable only by the captain who
+   * asked for it: the one-time code inside is a pairing secret for fifteen minutes, and a member
+   * who saw it could sign their own account onto the Ship's machine. Snake_case for the reason
+   * `mcp_servers` gives.
+   */
+  credentialLogins: "credential_logins",
   /** `ships/{shipId}/integrations/{docId}` — 3rd-party connectors (GitHub App; see github.ts). */
   integrations: "integrations",
   /**
@@ -732,12 +791,26 @@ function autonomyRule(agent) {
 var ASK_GUIDANCE = "If the task says who should approve \u2014 in its description, or because a particular person owns that area \u2014 name them in the request's `ask` so it reaches them rather than everyone.";
 
 // ../shared/dist/credentials.js
+var MACHINE_LOGIN_TTL_MS = 20 * 60 * 1e3;
+function isCredentialReady(c) {
+  return c.status === void 0 || c.status === "ready";
+}
+function isMachineHeldCredential(c) {
+  return typeof c.runnerId === "string" && c.runnerId.length > 0;
+}
+function machineLoginPending(c, now) {
+  if (c.status !== "pending" || !c.login)
+    return null;
+  if (c.login.requestedAt <= (c.login.answeredAt ?? 0))
+    return null;
+  return now - c.login.requestedAt < MACHINE_LOGIN_TTL_MS ? "start" : "expire";
+}
 function resolveAgentCredential(agent, credentials, defaultEngine) {
   const engine = agent.engine ?? defaultEngine;
   if (agent.credentialId) {
     return credentials.find((c) => c.id === agent.credentialId) ?? null;
   }
-  const forEngine = credentials.filter((c) => c.engine === engine);
+  const forEngine = credentials.filter((c) => c.engine === engine && isCredentialReady(c));
   const oldest = [...forEngine].sort((a, b) => a.createdAt - b.createdAt)[0];
   return oldest ?? void 0;
 }
@@ -814,9 +887,9 @@ function str(input, key) {
   const value = input[key];
   return typeof value === "string" && value.trim() ? value : void 0;
 }
-function basename(path9) {
-  const parts = path9.split(/[\\/]/).filter(Boolean);
-  return parts[parts.length - 1] ?? path9;
+function basename(path13) {
+  const parts = path13.split(/[\\/]/).filter(Boolean);
+  return parts[parts.length - 1] ?? path13;
 }
 function hostOf(url) {
   try {
@@ -904,8 +977,8 @@ function builtinDetail(tool, input) {
     case "Write":
     case "Edit":
     case "MultiEdit": {
-      const path9 = str(input, "file_path");
-      return path9 ? basename(path9) : void 0;
+      const path13 = str(input, "file_path");
+      return path13 ? basename(path13) : void 0;
     }
     case "Glob":
     case "Grep":
@@ -1099,6 +1172,10 @@ function firstStatusIn(statuses, category) {
 var RUNNER_OFFLINE_AFTER_MS = 2 * 60 * 1e3;
 
 // ../shared/dist/secrets.js
+function engineSecret(secrets, key) {
+  const value = secrets?.[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 function missingSecretsFor(engineId, secrets) {
   const bag = secrets;
   return getEngine(engineId).requiredSecrets.filter((req) => !bag?.[req.key]).map((req) => req.label);
@@ -1169,7 +1246,7 @@ import os from "node:os";
 import path from "node:path";
 
 // src/version.ts
-var RUNNER_VERSION = true ? "0.1.2" : "0.0.0-dev";
+var RUNNER_VERSION = true ? "0.1.4" : "0.0.0-dev";
 var RUNNER_PACKAGE = true ? "@kilogent/runner-dev" : "@kilogent/runner-dev";
 var RUNNER_BIN = true ? "kilogent-runner-dev" : "kilogent-runner-dev";
 
@@ -1301,8 +1378,8 @@ function functionsBaseUrlFor(projectId) {
   return process.env.CREW_FUNCTIONS_URL?.replace(/\/$/, "") || `https://us-central1-${projectId}.cloudfunctions.net`;
 }
 var CallableError = class extends Error {
-  constructor(status, message2) {
-    super(message2);
+  constructor(status, message3) {
+    super(message3);
     this.status = status;
   }
   status;
@@ -1335,8 +1412,8 @@ async function request(baseUrl, group, op, data, headers) {
 
 // src/auth.ts
 var AuthError = class extends Error {
-  constructor(message2, gone = false) {
-    super(message2);
+  constructor(message3, gone = false) {
+    super(message3);
     this.gone = gone;
   }
   gone;
@@ -1675,8 +1752,8 @@ function isTransientFirestoreError(error) {
   if (code === "unavailable" || code === "deadline-exceeded" || code === "internal" || code === "cancelled" || code === "aborted" || code === "resource-exhausted") {
     return true;
   }
-  const message2 = error?.message;
-  return typeof message2 === "string" && message2.toLowerCase().includes("client is offline");
+  const message3 = error?.message;
+  return typeof message3 === "string" && message3.toLowerCase().includes("client is offline");
 }
 async function withFirestoreRetry(read, sleep2 = (ms) => new Promise((r) => setTimeout(r, ms)), delays = FIRESTORE_RETRY_DELAYS_MS) {
   for (let i = 0; ; i++) {
@@ -2336,36 +2413,68 @@ async function resolveJobSecrets(input) {
   if (resolved === void 0) {
     return {
       secrets: null,
+      kind: "no-credential",
       problem: `This workspace has no AI credential for ${engineId}. Add one in Settings \u203A AI credentials and the crew starts taking work again.`
     };
   }
   if (resolved === null) {
     return {
       secrets: null,
+      kind: "orphaned",
       problem: `This agent is set to an AI credential that no longer exists on the Ship. Point it at another one in Settings \u203A AI credentials, or add the credential back.`
     };
   }
+  const requirement = getEngine(engineId).requiredSecrets[0];
+  const key = requirement?.key;
+  if (!key) return { secrets: null, credentialId: resolved.id };
+  const bag = (value) => ({
+    updatedAt: resolved.updatedAt,
+    updatedBy: resolved.createdBy,
+    [key]: value,
+    [`${key}Tail`]: resolved.tail
+  });
+  if (requirement.flow === "machine-login") {
+    if (!input.machine || resolved.runnerId !== input.machine.runnerId) {
+      return {
+        secrets: null,
+        kind: "other-machine",
+        credentialId: resolved.id,
+        problem: `The AI credential "${resolved.label}" is held by another machine on this Ship, so this machine cannot run jobs on it.`
+      };
+    }
+    if (!isCredentialReady(resolved)) {
+      return {
+        secrets: null,
+        kind: "not-ready",
+        credentialId: resolved.id,
+        problem: `The AI credential "${resolved.label}" is not signed in yet \u2014 finish the sign-in in Settings \u203A AI credentials.`
+      };
+    }
+    const home = input.machine.localLogin(engineId, resolved.id);
+    if (!home) {
+      return {
+        secrets: null,
+        kind: "login-missing",
+        credentialId: resolved.id,
+        problem: `This machine no longer holds the sign-in for the AI credential "${resolved.label}". Delete it in Settings \u203A AI credentials and add it again.`
+      };
+    }
+    return { secrets: bag(home), credentialId: resolved.id };
+  }
   const token = await loadCredentialToken(input.db, input.shipId, resolved.id);
   if (!token) {
     return {
       secrets: null,
+      kind: "no-token",
+      credentialId: resolved.id,
       problem: `The AI credential "${resolved.label}" has no token stored. Erase it in Settings \u203A AI credentials and add it again.`
     };
   }
-  const key = getEngine(engineId).requiredSecrets[0]?.key;
-  if (!key) return { secrets: null };
-  return {
-    secrets: {
-      updatedAt: resolved.updatedAt,
-      updatedBy: resolved.createdBy,
-      [key]: token,
-      [`${key}Tail`]: resolved.tail
-    }
-  };
+  return { secrets: bag(token), credentialId: resolved.id };
 }
 
 // src/jobs/assistantCredential.ts
-async function resolveAssistantCredential(db, shipId) {
+async function resolveAssistantCredential(db, shipId, machine) {
   const shipSnap = await getDoc5(doc5(db, COLLECTIONS.ships, shipId));
   const settings = shipSnap.data()?.settings;
   const credentialId = settings?.assistant?.credentialId ?? settings?.defaultCredentialId;
@@ -2377,7 +2486,8 @@ async function resolveAssistantCredential(db, shipId) {
     shipId,
     // The synthetic agent: two fields, both of which this module has just decided.
     agent: { engine, credentialId },
-    credentials
+    credentials,
+    machine
   });
   return {
     secrets,
@@ -2394,12 +2504,20 @@ import fs3 from "node:fs";
 import os2 from "node:os";
 import path3 from "node:path";
 
+// src/engines/binary.ts
+function engineBinaryEnvVar(engineId) {
+  return `CREW_${engineId.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_BIN`;
+}
+function engineBinary(engineId, defaultName) {
+  return process.env[engineBinaryEnvVar(engineId)] || defaultName;
+}
+
 // src/engines/claudeEvents.ts
 function stepsFromClaudeEvent(event, opts) {
   const type = typeof event?.type === "string" ? event.type : "";
   if (type === "assistant") {
-    const message2 = event.message;
-    const content = Array.isArray(message2?.content) ? message2.content : [];
+    const message3 = event.message;
+    const content = Array.isArray(message3?.content) ? message3.content : [];
     const steps = [];
     for (const block of content) {
       if (!block || typeof block !== "object") continue;
@@ -2416,11 +2534,14 @@ function stepsFromClaudeEvent(event, opts) {
   if (type === "result") return [{ kind: "done", label: "Finished" }];
   return [];
 }
-
-// src/engines/mcpHealth.ts
-var CONSECUTIVE_LIMIT = 2;
-var AUTH_MARKER = /\b401\b|unauthoriz|invalid[_ ]token|token .{0,20}expired|expired .{0,20}token|protected resource/i;
-var WORKSPACE_TOOL_PREFIX = `mcp__${WORKSPACE_MCP_KEY}__`;
+var MCP_TOOL_PREFIX = "mcp__";
+function createClaudeToolPairing() {
+  return { names: /* @__PURE__ */ new Map() };
+}
+function blocksOf(event) {
+  const message3 = event.message;
+  return Array.isArray(message3?.content) ? message3.content : [];
+}
 function resultText(block) {
   const content = block.content;
   if (typeof content === "string") return content;
@@ -2431,43 +2552,67 @@ function resultText(block) {
   }
   return "";
 }
-function blocksOf(event) {
-  const message2 = event.message;
-  return Array.isArray(message2?.content) ? message2.content : [];
+function mcpCallsFromClaudeEvent(event, pairing) {
+  const type = typeof event?.type === "string" ? event.type : "";
+  if (type === "assistant") {
+    for (const block of blocksOf(event)) {
+      if (!block || typeof block !== "object") continue;
+      if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+        pairing.names.set(block.id, block.name);
+      }
+    }
+    return [];
+  }
+  if (type !== "user") return [];
+  const calls = [];
+  for (const block of blocksOf(event)) {
+    if (!block || typeof block !== "object") continue;
+    if (block.type !== "tool_result" || typeof block.tool_use_id !== "string") continue;
+    const name = pairing.names.get(block.tool_use_id);
+    if (!name) continue;
+    const server = name.startsWith(MCP_TOOL_PREFIX) ? name.slice(MCP_TOOL_PREFIX.length).split("__")[0] ?? "" : "";
+    calls.push({ server, ok: !block.is_error, text: resultText(block) });
+  }
+  return calls;
 }
+
+// src/engines/githubEnv.ts
+function githubSessionEnv(token) {
+  if (!token) return {};
+  return {
+    GH_TOKEN: token,
+    GITHUB_TOKEN: token,
+    GIT_CONFIG_COUNT: "1",
+    GIT_CONFIG_KEY_0: "url.https://x-access-token:" + token + "@github.com/.insteadOf",
+    GIT_CONFIG_VALUE_0: "https://github.com/"
+  };
+}
+
+// src/engines/limitWindow.ts
+var MAX_LIMIT_MS = 7 * 24 * 60 * 60 * 1e3 + 60 * 60 * 1e3;
+function saneResetAt(reported, now, maxMs = MAX_LIMIT_MS) {
+  return Number.isFinite(reported) && reported > now && reported <= now + maxMs;
+}
+
+// src/engines/mcpHealth.ts
+var CONSECUTIVE_LIMIT = 2;
+var AUTH_MARKER = /\b401\b|unauthoriz|invalid[_ ]token|token .{0,20}expired|expired .{0,20}token|protected resource/i;
 function createWorkspaceMcpWatch() {
-  const toolNames = /* @__PURE__ */ new Map();
   let consecutive = 0;
   let reported = false;
   return {
-    observe(event) {
-      if (reported) return null;
-      const type = typeof event?.type === "string" ? event.type : "";
-      if (type === "assistant") {
-        for (const block of blocksOf(event)) {
-          if (!block || typeof block !== "object") continue;
-          if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
-            toolNames.set(block.id, block.name);
-          }
-        }
+    observe(call) {
+      if (reported || !call || typeof call !== "object") return null;
+      if (call.server !== WORKSPACE_MCP_KEY) return null;
+      const text2 = typeof call.text === "string" ? call.text : "";
+      if (call.ok || !AUTH_MARKER.test(text2)) {
+        consecutive = 0;
         return null;
       }
-      if (type !== "user") return null;
-      for (const block of blocksOf(event)) {
-        if (!block || typeof block !== "object") continue;
-        if (block.type !== "tool_result" || typeof block.tool_use_id !== "string") continue;
-        const name = toolNames.get(block.tool_use_id);
-        if (!name || !name.startsWith(WORKSPACE_TOOL_PREFIX)) continue;
-        if (!block.is_error || !AUTH_MARKER.test(resultText(block))) {
-          consecutive = 0;
-          continue;
-        }
-        consecutive += 1;
-        if (consecutive < CONSECUTIVE_LIMIT) continue;
-        reported = true;
-        return `The Workspace MCP ("${WORKSPACE_MCP_KEY}") stopped accepting this session's credential part-way through the run: ${CONSECUTIVE_LIMIT} consecutive calls came back refused ("${resultText(block).slice(0, 160).trim()}"). Everything after that point would have run with none of this Ship's tools \u2014 no task_comment, no run_report, no chat_send \u2014 so the session was stopped rather than allowed to finish blind. The run is retried with a fresh credential.`;
-      }
-      return null;
+      consecutive += 1;
+      if (consecutive < CONSECUTIVE_LIMIT) return null;
+      reported = true;
+      return `The Workspace MCP ("${WORKSPACE_MCP_KEY}") stopped accepting this session's credential part-way through the run: ${CONSECUTIVE_LIMIT} consecutive calls came back refused ("${text2.slice(0, 160).trim()}"). Everything after that point would have run with none of this Ship's tools \u2014 no task_comment, no run_report, no chat_send \u2014 so the session was stopped rather than allowed to finish blind. The run is retried with a fresh credential.`;
     }
   };
 }
@@ -2507,12 +2652,11 @@ function normalizeClaudeUsage(resultEvent, model, fallbackDurationS) {
 }
 var LIMIT_RE = /usage limit (?:reached|exceeded|has been reached)/i;
 var LIMIT_RESET_RE = /\|\s*(\d{10})\b/;
-var MAX_LIMIT_MS = 7 * 24 * 60 * 60 * 1e3 + 60 * 60 * 1e3;
 function detectClaudeLimit(text2, now, fallbackMs) {
   if (!text2 || !LIMIT_RE.test(text2)) return void 0;
   const match = LIMIT_RESET_RE.exec(text2);
   const reported = match ? Number(match[1]) * 1e3 : NaN;
-  const sane = Number.isFinite(reported) && reported > now && reported <= now + MAX_LIMIT_MS;
+  const sane = saneResetAt(reported, now);
   return {
     resetsAt: sane ? reported : now + fallbackMs,
     resetsAtReported: sane,
@@ -2625,7 +2769,7 @@ function cleanupSessionDirs(dirs) {
   fs3.rmSync(dirs.configDir, { recursive: true, force: true });
 }
 async function runClaudeSession(input) {
-  const bin = process.env.CREW_CLAUDE_BIN || "claude";
+  const bin = claudeBinary();
   if (input.signal?.aborted) {
     return {
       ok: false,
@@ -2657,7 +2801,7 @@ async function runSession(input, bin, dirs) {
     "--allowedTools",
     allowedTools(input.agent, input.extraMcpServers ?? []).join(",")
   ];
-  const claudeToken = input.secrets?.claudeToken;
+  const claudeToken = engineSecret(input.secrets, CLAUDE_SECRET_KEY);
   const env = {
     ...process.env,
     // THE INIT EVENT MUST BE TRUTHFUL, and one inherited variable is enough to make it lie.
@@ -2676,16 +2820,7 @@ async function runSession(input, bin, dirs) {
     MCP_CONNECTION_NONBLOCKING: void 0,
     MCP_SERVER_CONNECTION_BATCH_SIZE: void 0,
     ...claudeToken ? { CLAUDE_CODE_OAUTH_TOKEN: claudeToken } : {},
-    ...input.githubToken ? {
-      GH_TOKEN: input.githubToken,
-      GITHUB_TOKEN: input.githubToken,
-      // Per-process git auth so bare `git clone https://github.com/o/r` works WITHOUT
-      // touching the machine's ~/.gitconfig. A GitHub App installation token authenticates
-      // as `x-access-token:<token>`; a classic PAT works the same way here.
-      GIT_CONFIG_COUNT: "1",
-      GIT_CONFIG_KEY_0: "url.https://x-access-token:" + input.githubToken + "@github.com/.insteadOf",
-      GIT_CONFIG_VALUE_0: "https://github.com/"
-    } : {}
+    ...githubSessionEnv(input.githubToken)
   };
   const mcpNames = {};
   for (const s of input.extraMcpServers ?? []) mcpNames[s.key] = s.name || s.key;
@@ -2698,6 +2833,7 @@ async function runSession(input, bin, dirs) {
   const expectedServers = expectedMcpServers(input.agent, input.extraMcpServers ?? []);
   const mcpFailed = [];
   const mcpWatch = createWorkspaceMcpWatch();
+  const pairing = createClaudeToolPairing();
   const exitCode = await new Promise((resolve) => {
     const child = spawn3(bin, args, { cwd: dirs.workdir, env, stdio: ["ignore", "pipe", "pipe"] });
     const killTimer = setTimeout(() => {
@@ -2744,7 +2880,9 @@ async function runSession(input, bin, dirs) {
             }
           }
           if (workspaceRequired && !mcpProblem) {
-            stopBlindSession(mcpWatch.observe(event));
+            for (const call of mcpCallsFromClaudeEvent(event, pairing)) {
+              stopBlindSession(mcpWatch.observe(call));
+            }
           }
           if (input.onStep) {
             for (const step2 of stepsFromClaudeEvent(event, { mcpNames })) input.onStep(step2);
@@ -2776,9 +2914,9 @@ async function runSession(input, bin, dirs) {
   const durationS = Math.round((Date.now() - startedAt) / 1e3);
   const { usage, result } = normalizeClaudeUsage(resultEvent, input.agent.model, durationS);
   const ok2 = !mcpProblem && exitCode === 0 && !!resultEvent && !result.is_error;
-  const resultText2 = mcpProblem ?? result.result ?? (ok2 ? "" : `Session ended with exit code ${exitCode}${resultEvent ? "" : " and no result event"}.`);
+  const resultText3 = mcpProblem ?? result.result ?? (ok2 ? "" : `Session ended with exit code ${exitCode}${resultEvent ? "" : " and no result event"}.`);
   const limit4 = ok2 ? void 0 : detectClaudeLimit(
-    `${resultText2}
+    `${resultText3}
 ${stderrLines.slice(-20).join("\n")}`,
     Date.now(),
     engineUsageWindows(CLAUDE_DRIVER_ID)?.fallbackMs ?? 5 * 60 * 60 * 1e3
@@ -2788,12 +2926,17 @@ ${stderrLines.slice(-20).join("\n")}`,
     transcript: `${lines.join("\n")}
 `,
     usage,
-    resultText: resultText2,
+    resultText: resultText3,
     ...limit4 ? { limit: limit4 } : {},
     ...mcpFailed.length ? { mcpFailed } : {}
   };
 }
 var CLAUDE_DRIVER_ID = "claude";
+var CLAUDE_SECRET_KEY = "claudeToken";
+var CLAUDE_SECRET_PATTERNS = Object.freeze([/sk-ant-[A-Za-z0-9_-]{8,}/g]);
+function claudeBinary() {
+  return engineBinary(CLAUDE_DRIVER_ID, "claude");
+}
 function emptyUsage() {
   return {
     engine: CLAUDE_DRIVER_ID,
@@ -2806,7 +2949,7 @@ function emptyUsage() {
   };
 }
 async function claudeHealthCheck() {
-  const bin = process.env.CREW_CLAUDE_BIN || "claude";
+  const bin = claudeBinary();
   return new Promise((resolve) => {
     let settled = false;
     const done = (health) => {
@@ -2828,7 +2971,7 @@ async function claudeHealthCheck() {
       done({
         ok: false,
         detail: `\`${bin}\` not found on PATH`,
-        fix: "Install the Claude CLI (https://claude.com/claude-code), or set CREW_CLAUDE_BIN to its path."
+        fix: `Install the Claude CLI (https://claude.com/claude-code), or set ${engineBinaryEnvVar(CLAUDE_DRIVER_ID)} to its path.`
       });
     });
     child.on("close", (code) => {
@@ -2847,12 +2990,533 @@ async function claudeHealthCheck() {
 var claudeDriver = {
   engineId: CLAUDE_DRIVER_ID,
   run: runClaudeSession,
-  healthCheck: claudeHealthCheck
+  healthCheck: claudeHealthCheck,
+  binary: claudeBinary,
+  secretValues: (secrets) => {
+    const token = engineSecret(secrets, CLAUDE_SECRET_KEY);
+    return token ? [token] : [];
+  },
+  secretPatterns: CLAUDE_SECRET_PATTERNS
+};
+
+// src/engines/codex.ts
+import { spawn as spawn4 } from "node:child_process";
+import fs4 from "node:fs";
+import os3 from "node:os";
+import path4 from "node:path";
+
+// src/engines/ansi.ts
+var ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
+function stripAnsi(text2) {
+  return text2.replace(ANSI_RE, "");
+}
+
+// src/engines/codexEvents.ts
+function itemOf(event) {
+  const item = event.item;
+  return item && typeof item === "object" ? item : null;
+}
+function stepsFromCodexEvent(event, opts) {
+  const type = typeof event?.type === "string" ? event.type : "";
+  if (type === "turn.completed") return [{ kind: "done", label: "Finished" }];
+  const item = itemOf(event);
+  if (!item) return [];
+  if (type === "item.started") {
+    switch (item.type) {
+      case "command_execution":
+        return [describeToolUse("Bash", { command: item.command })];
+      case "mcp_tool_call":
+        if (typeof item.server === "string" && typeof item.tool === "string") {
+          return [describeToolUse(`mcp__${item.server}__${item.tool}`, item.arguments, { mcpNames: opts?.mcpNames })];
+        }
+        return [];
+      case "reasoning":
+        return [{ kind: "thinking", label: "Thinking" }];
+      case "web_search":
+        return [describeToolUse("WebSearch", { query: item.query })];
+      case "todo_list":
+        return [describeToolUse("TodoWrite", {})];
+      default:
+        return [];
+    }
+  }
+  if (type === "item.completed") {
+    switch (item.type) {
+      case "agent_message":
+        return typeof item.text === "string" && item.text.trim() ? [describeAssistantText(item.text)] : [];
+      case "file_change":
+        return (item.changes ?? []).filter((c) => c && typeof c === "object" && typeof c.path === "string").map((c) => describeToolUse("Edit", { file_path: c.path }));
+      // A reasoning item that only ever completes (no started line) still deserves its label.
+      case "reasoning":
+        return [];
+      default:
+        return [];
+    }
+  }
+  return [];
+}
+function mcpCallFromCodexEvent(event) {
+  if (event?.type !== "item.completed") return null;
+  const item = itemOf(event);
+  if (!item || item.type !== "mcp_tool_call" || typeof item.server !== "string") return null;
+  const error = item.error;
+  const errorText = typeof error === "string" ? error : error && typeof error === "object" && typeof error.message === "string" ? error.message : "";
+  const failed = !!error || item.status === "failed";
+  const text2 = failed ? errorText || `status "${item.status ?? "unknown"}"` : resultText2(item.result);
+  return { server: item.server, ok: !failed, text: text2 };
+}
+function resultText2(result) {
+  if (typeof result === "string") return result.slice(0, 400);
+  if (result && typeof result === "object") {
+    const content = result.content;
+    if (Array.isArray(content)) {
+      return content.map(
+        (part) => part && typeof part === "object" && typeof part.text === "string" ? part.text : ""
+      ).join(" ").slice(0, 400);
+    }
+    try {
+      return JSON.stringify(result).slice(0, 400);
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+
+// src/engines/codex.ts
+var CODEX_DRIVER_ID = "codex";
+var CODEX_SECRET_KEY = "codexHome";
+var WORKSPACE_TOKEN_ENV = "CREW_MCP_TOKEN";
+var AUTH_FILE = "auth.json";
+var MCP_STARTUP_TIMEOUT_S = 60;
+var MCP_TOOL_TIMEOUT_S = 120;
+var MCP_TOOL_APPROVAL = "approve";
+function codexBinary() {
+  return engineBinary(CODEX_DRIVER_ID, "codex");
+}
+function codexSandbox(agent) {
+  return agent.autonomy <= 1 ? "read-only" : "workspace-write";
+}
+function tomlInline(value) {
+  if (typeof value === "string") return tomlString(value);
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value)) return `[${value.map(tomlInline).join(", ")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+    return `{${entries.map(([k, v]) => `${tomlKey(k)} = ${tomlInline(v)}`).join(", ")}}`;
+  }
+  throw new Error(`cannot express ${typeof value} in TOML`);
+}
+function tomlString(s) {
+  let out = '"';
+  for (const ch of s) {
+    const code = ch.charCodeAt(0);
+    if (ch === '"') out += '\\"';
+    else if (ch === "\\") out += "\\\\";
+    else if (ch === "\n") out += "\\n";
+    else if (ch === "\r") out += "\\r";
+    else if (ch === "	") out += "\\t";
+    else if (code < 32 || code === 127) out += `\\u${code.toString(16).padStart(4, "0")}`;
+    else out += ch;
+  }
+  return out + '"';
+}
+function tomlKey(k) {
+  return /^[A-Za-z0-9_-]+$/.test(k) ? k : tomlString(k);
+}
+function codexMcpOverrides(input) {
+  const overrides = [];
+  const add = (key, table) => {
+    overrides.push("-c", `mcp_servers.${tomlKey(key)}=${tomlInline(table)}`);
+  };
+  add(WORKSPACE_MCP_KEY, {
+    url: input.mcpUrl,
+    required: true,
+    bearer_token_env_var: WORKSPACE_TOKEN_ENV,
+    startup_timeout_sec: MCP_STARTUP_TIMEOUT_S,
+    tool_timeout_sec: MCP_TOOL_TIMEOUT_S,
+    default_tools_approval_mode: MCP_TOOL_APPROVAL,
+    http_headers: {
+      "X-Crew-Ship-Id": input.shipId,
+      // Sent for the audit trail; on the runner path the server keys on the job id and reads the
+      // acting agent and task off the job's own document (see the Claude driver's headers note).
+      "X-Crew-Agent-Id": input.agent.id,
+      "X-Crew-Job-Id": input.job.id,
+      // Exactly one of these — a chat job has no task and a task job no chat.
+      ...input.job.taskId ? { "X-Crew-Task-Id": input.job.taskId } : {},
+      ...input.job.chatId ? { "X-Crew-Chat-Id": input.job.chatId } : {}
+    }
+  });
+  for (const s of input.extraServers ?? []) {
+    if (s.key === WORKSPACE_MCP_KEY) continue;
+    const tools = s.tools?.length ? { enabled_tools: s.tools } : {};
+    if (s.transport === "stdio") {
+      add(s.key, {
+        command: s.command,
+        ...s.args?.length ? { args: s.args } : {},
+        ...s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {},
+        required: false,
+        default_tools_approval_mode: MCP_TOOL_APPROVAL,
+        ...tools
+      });
+      continue;
+    }
+    add(s.key, {
+      url: s.url,
+      ...s.headers && Object.keys(s.headers).length > 0 ? { http_headers: s.headers } : {},
+      required: false,
+      default_tools_approval_mode: MCP_TOOL_APPROVAL,
+      ...tools
+    });
+  }
+  return overrides;
+}
+function codexArgs(input) {
+  const granted = effectiveAgentTools(input.agent);
+  const sandbox = codexSandbox(input.agent);
+  return [
+    "exec",
+    "--json",
+    "--color",
+    "never",
+    "--ephemeral",
+    "--ignore-user-config",
+    "--skip-git-repo-check",
+    "-C",
+    input.workdir,
+    "-s",
+    sandbox,
+    "-m",
+    input.agent.model,
+    // Never a prompt for approval: there is nobody at this terminal. Anything the sandbox refuses
+    // is refused, and the model works around it or reports it.
+    "-c",
+    'approval_policy="never"',
+    // A writing agent that works on GitHub needs the network for `git`; a drafts-only one does
+    // not get it, because it does not get a shell that writes either.
+    ...sandbox === "workspace-write" && (granted.github.enabled || granted.bash) ? ["-c", "sandbox_workspace_write.network_access=true"] : [],
+    ...codexMcpOverrides(input),
+    input.prompt
+  ];
+}
+function normalizeCodexUsage(usage, model, durationS) {
+  const n = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+  const inputTokens = n(usage?.input_tokens);
+  const cachedInputTokens = Math.min(inputTokens, n(usage?.cached_input_tokens));
+  const outputTokens = n(usage?.output_tokens);
+  return {
+    engine: CODEX_DRIVER_ID,
+    inputTokens,
+    cachedInputTokens,
+    outputTokens,
+    costUsd: estimateCostUsd(CODEX_DRIVER_ID, model, { inputTokens, cachedInputTokens, outputTokens }),
+    costReported: false,
+    model,
+    durationS,
+    ...usage ? { raw: { ...usage } } : {}
+  };
+}
+var LIMIT_RE2 = /hit your usage limit|usage limit reached|usage_limit_(?:reached|exceeded)|rate_limit_exceeded/i;
+var LIMIT_RESET_RE2 = /resets?_at["'\s:=]+(\d{10,13})\b/;
+function detectCodexLimit(text2, now, fallbackMs) {
+  if (!text2 || !LIMIT_RE2.test(text2)) return void 0;
+  const match = LIMIT_RESET_RE2.exec(text2);
+  const raw = match ? Number(match[1]) : NaN;
+  const reported = Number.isFinite(raw) ? raw < 1e12 ? raw * 1e3 : raw : NaN;
+  const sane = saneResetAt(reported, now);
+  return {
+    resetsAt: sane ? reported : now + fallbackMs,
+    resetsAtReported: sane,
+    detail: text2.trim().slice(0, 300)
+  };
+}
+function requiredMcpFailures(stderr, expected) {
+  const m = /required MCP servers failed to initialize:\s*(.+)$/im.exec(stderr);
+  if (!m) return [];
+  const out = [];
+  for (const e of expected) {
+    const re = new RegExp(`(?:^|[\\s,])${e.key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:\\s*([^\\n]*)`);
+    const hit = re.exec(m[1]);
+    if (hit) out.push({ key: e.key, label: e.label, detail: hit[1].trim().slice(0, 300) || "no reason given" });
+  }
+  return out;
+}
+function codexWorkspaceRefusal(failure) {
+  return `The Codex CLI did not load ${failure.label} ("${failure.key}"): ${failure.detail}. The session would have had none of this Ship's tools \u2014 no task_comment, no run_report, no chat_send \u2014 so it was stopped instead of run blind. If this keeps happening, update the daemon and the Codex CLI on this machine.`;
+}
+var LOGIN_LOST_RE = /not logged in|login required|refresh_token_reused|could not be refreshed|please (?:try )?sign(?:ing)? in again/i;
+function detectLoginLost(stderr) {
+  const line = stderr.split("\n").find((l) => LOGIN_LOST_RE.test(l));
+  return line ? `This machine's ChatGPT sign-in is no longer usable: ${line.trim().slice(0, 200)}` : void 0;
+}
+var GUIDANCE_URL_RE = /https:\/\/auth\.openai\.com\/[^\s"'<>]+/;
+var GUIDANCE_CODE_RE = /\b[A-Z0-9]{4}-[A-Z0-9]{5}\b/;
+function decodeJwtPayload(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+  try {
+    return JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+var codexLogin = {
+  spawnArgs: () => ["login", "--device-auth"],
+  logoutArgs: () => ["logout"],
+  statusArgs: () => ["login", "status"],
+  env: (home) => ({ CODEX_HOME: home }),
+  isSignedIn: (home) => fs4.existsSync(path4.join(home, AUTH_FILE)),
+  parseGuidance(text2) {
+    const clean = stripAnsi(text2);
+    const url = GUIDANCE_URL_RE.exec(clean)?.[0];
+    const code = GUIDANCE_CODE_RE.exec(clean)?.[0];
+    if (!url && !code) return null;
+    return { ...url ? { url } : {}, ...code ? { code } : {} };
+  },
+  /**
+   * The account behind a completed sign-in, off the id token's claims — decoded, NOT verified,
+   * because nothing here trusts it for authorization: it names whose plan the credential row
+   * shows. The refresh and access tokens are never read.
+   */
+  readAccount(home) {
+    let parsed;
+    try {
+      parsed = JSON.parse(fs4.readFileSync(path4.join(home, AUTH_FILE), "utf8"));
+    } catch {
+      return null;
+    }
+    const idToken = parsed.tokens?.id_token;
+    const claims = typeof idToken === "string" ? decodeJwtPayload(idToken) : null;
+    const auth = claims?.["https://api.openai.com/auth"] ?? {};
+    const accountId = typeof auth.chatgpt_account_id === "string" && auth.chatgpt_account_id || typeof parsed.tokens?.account_id === "string" && parsed.tokens.account_id || "";
+    const activeUntilRaw = auth.chatgpt_subscription_active_until;
+    const activeUntil = typeof activeUntilRaw === "string" && !Number.isNaN(Date.parse(activeUntilRaw)) ? Date.parse(activeUntilRaw) : typeof activeUntilRaw === "number" ? activeUntilRaw < 1e12 ? activeUntilRaw * 1e3 : activeUntilRaw : void 0;
+    return {
+      ...typeof claims?.email === "string" ? { email: claims.email } : {},
+      ...typeof claims?.name === "string" ? { name: claims.name } : {},
+      ...typeof auth.chatgpt_plan_type === "string" ? { plan: auth.chatgpt_plan_type } : {},
+      ...activeUntil !== void 0 ? { activeUntil } : {},
+      ...accountId ? { accountIdTail: accountId.slice(-4) } : {}
+    };
+  }
+};
+function emptyUsage2() {
+  return {
+    engine: CODEX_DRIVER_ID,
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
+    costUsd: 0,
+    costReported: false,
+    durationS: 0
+  };
+}
+function refused(resultText3, extra = {}) {
+  return { ok: false, transcript: "", usage: emptyUsage2(), resultText: resultText3, ...extra };
+}
+async function runCodexSession(input) {
+  const bin = codexBinary();
+  if (input.signal?.aborted) {
+    return refused("Session cancelled before it started (runner shutting down).");
+  }
+  const home = engineSecret(input.secrets, CODEX_SECRET_KEY);
+  if (!home) {
+    return refused("This machine holds no ChatGPT sign-in for this credential.");
+  }
+  if (!codexLogin.isSignedIn(home)) {
+    return refused(
+      "This machine's ChatGPT sign-in is gone \u2014 delete the credential in Settings and add it again.",
+      { credentialLost: "The sign-in directory on this machine no longer holds a login." }
+    );
+  }
+  const workdir = fs4.mkdtempSync(path4.join(os3.tmpdir(), `crew-job-${input.job.id}-`));
+  try {
+    return await runSession2(input, bin, home, workdir);
+  } finally {
+    fs4.rmSync(workdir, { recursive: true, force: true });
+  }
+}
+async function runSession2(input, bin, home, workdir) {
+  const args = codexArgs({ ...input, extraServers: input.extraMcpServers, workdir });
+  const env = {
+    ...process.env,
+    ...codexLogin.env(home),
+    [WORKSPACE_TOKEN_ENV]: input.idToken,
+    ...githubSessionEnv(input.githubToken)
+  };
+  const mcpNames = {};
+  for (const s of input.extraMcpServers ?? []) mcpNames[s.key] = s.name || s.key;
+  const startedAt = Date.now();
+  const lines = [];
+  const stderrLines = [];
+  const seen = {
+    completed: null,
+    failed: null,
+    lastMessage: ""
+  };
+  let mcpProblem = null;
+  const workspaceRequired = effectiveAgentTools(input.agent).workspaceMcp;
+  const expected = [
+    ...workspaceRequired ? [{ key: WORKSPACE_MCP_KEY, label: "the Workspace MCP" }] : [],
+    ...(input.extraMcpServers ?? []).map((s) => ({ key: s.key, label: s.name || s.key }))
+  ];
+  const mcpFailed = [];
+  const mcpWatch = createWorkspaceMcpWatch();
+  const exitCode = await new Promise((resolve) => {
+    const child = spawn4(bin, args, { cwd: workdir, env, stdio: ["ignore", "pipe", "pipe"] });
+    const killTimer = setTimeout(() => {
+      input.log(`Session timeout after ${Math.round(input.timeoutMs / 6e4)} min \u2014 killing.`);
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 1e4).unref();
+    }, input.timeoutMs);
+    const onAbort = () => {
+      input.log("Daemon shutting down \u2014 stopping the session.");
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 3e3).unref();
+    };
+    input.signal?.addEventListener("abort", onAbort, { once: true });
+    const detachAbort = () => input.signal?.removeEventListener("abort", onAbort);
+    const stopBlindSession = (problem) => {
+      if (!problem) return;
+      mcpProblem = problem;
+      input.log(problem);
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 3e3).unref();
+    };
+    let buffer = "";
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      for (; ; ) {
+        const nl = buffer.indexOf("\n");
+        if (nl < 0) break;
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (!line) continue;
+        lines.push(line);
+        try {
+          const event = JSON.parse(line);
+          if (event.type === "turn.completed") seen.completed = event;
+          if (event.type === "turn.failed") seen.failed = event;
+          const item = event.item;
+          if (event.type === "item.completed" && item?.type === "agent_message" && typeof item.text === "string") {
+            seen.lastMessage = item.text;
+          }
+          if (workspaceRequired && !mcpProblem) {
+            stopBlindSession(mcpWatch.observe(mcpCallFromCodexEvent(event)));
+          }
+          if (input.onStep) {
+            for (const step2 of stepsFromCodexEvent(event, { mcpNames })) input.onStep(step2);
+          }
+        } catch {
+        }
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      const text2 = chunk.toString("utf8").trim();
+      if (text2) {
+        lines.push(JSON.stringify({ type: "stderr", text: text2 }));
+        stderrLines.push(text2);
+        input.log(`codex stderr: ${text2.slice(0, 200)}`);
+      }
+    });
+    child.on("error", (e) => {
+      lines.push(JSON.stringify({ type: "stderr", text: `spawn error: ${e.message}` }));
+      stderrLines.push(`spawn error: ${e.message}`);
+      clearTimeout(killTimer);
+      detachAbort();
+      resolve(127);
+    });
+    child.on("close", (code) => {
+      clearTimeout(killTimer);
+      detachAbort();
+      resolve(code ?? 1);
+    });
+  });
+  const durationS = Math.round((Date.now() - startedAt) / 1e3);
+  const stderr = stderrLines.join("\n");
+  const usage = normalizeCodexUsage(seen.completed?.usage ?? null, input.agent.model, durationS);
+  for (const failure of requiredMcpFailures(stderr, expected)) {
+    if (failure.key === WORKSPACE_MCP_KEY) {
+      if (!mcpProblem) mcpProblem = codexWorkspaceRefusal(failure);
+    } else if (!mcpFailed.includes(failure.key)) {
+      input.log(`MCP connection "${failure.key}" did not load: ${failure.detail}.`);
+      mcpFailed.push(failure.key);
+    }
+  }
+  const failedError = seen.failed?.error;
+  const failedMessage = typeof failedError?.message === "string" ? failedError.message : "";
+  const ok2 = exitCode === 0 && seen.completed !== null && seen.failed === null && !mcpProblem;
+  const transcript = lines.join("\n") + "\n";
+  if (mcpProblem) {
+    return { ok: false, transcript, usage, resultText: mcpProblem, ...mcpFailed.length ? { mcpFailed } : {} };
+  }
+  const failureText = [failedMessage, stderr.slice(-2e3)].filter(Boolean).join("\n");
+  const windows = engineUsageWindows(CODEX_DRIVER_ID);
+  const limit4 = !ok2 && windows ? detectCodexLimit(failureText, Date.now(), windows.fallbackMs) : void 0;
+  const credentialLost = !ok2 && !limit4 ? detectLoginLost(stderr) : void 0;
+  const resultText3 = ok2 ? seen.lastMessage : failedMessage || stderr.trim().split("\n").slice(-3).join("\n") || `Codex exited ${exitCode}`;
+  return {
+    ok: ok2,
+    transcript,
+    usage,
+    resultText: resultText3.slice(0, 2e4),
+    ...limit4 ? { limit: limit4 } : {},
+    ...credentialLost ? { credentialLost } : {},
+    ...mcpFailed.length ? { mcpFailed } : {}
+  };
+}
+async function codexHealthCheck() {
+  const bin = codexBinary();
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (health) => {
+      if (settled) return;
+      settled = true;
+      resolve({ ...health, binary: bin });
+    };
+    let stdout = "";
+    const child = spawn4(bin, ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      done({ ok: false, detail: `\`${bin} --version\` timed out`, fix: "Check the Codex CLI install." });
+    }, 1e4);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      done({
+        ok: false,
+        detail: `\`${bin}\` not found on PATH`,
+        fix: `Install the Codex CLI (https://developers.openai.com/codex), or set ${engineBinaryEnvVar(CODEX_DRIVER_ID)} to its path.`
+      });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const version = stdout.trim().split("\n")[0] || "(no version reported)";
+      done(
+        code === 0 ? { ok: true, detail: `${bin} \u2014 ${version}` } : { ok: false, detail: `\`${bin} --version\` exited ${code}`, fix: "Reinstall or repair the Codex CLI." }
+      );
+    });
+  });
+}
+var codexDriver = {
+  engineId: CODEX_DRIVER_ID,
+  run: runCodexSession,
+  healthCheck: codexHealthCheck,
+  binary: codexBinary,
+  // The value is a DIRECTORY, not a secret: nothing to redact, and redacting a path would scrub
+  // every transcript line that mentioned the workdir's parent.
+  secretValues: (_secrets) => [],
+  secretPatterns: Object.freeze([]),
+  login: codexLogin
 };
 
 // src/engines/index.ts
 var DRIVERS = {
-  claude: claudeDriver
+  claude: claudeDriver,
+  codex: codexDriver
 };
 function getDriver(engineId) {
   return engineId && Object.hasOwn(DRIVERS, engineId) ? DRIVERS[engineId] : DRIVERS[DEFAULT_ENGINE_ID];
@@ -2976,7 +3640,7 @@ function mcpSecretsToRedact(servers) {
 }
 
 // src/jobs/localProbe.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 var PROBE_TIMEOUT_MS = 15e3;
 var PROTOCOL_VERSION = "2024-11-05";
 async function probeAndReport(input) {
@@ -3018,7 +3682,7 @@ async function probe(server) {
   }
 }
 async function probeStdio(server) {
-  const child = spawn4(server.command ?? "", server.args ?? [], {
+  const child = spawn5(server.command ?? "", server.args ?? [], {
     // The parent's environment PLUS the Ship's, not the Ship's alone: a program started with no
     // PATH cannot find node, and `npx` cannot find anything at all. The Ship's values win, which is
     // what lets a connection override a variable the operator happens to have set.
@@ -3209,6 +3873,276 @@ function serversNeedingProbe(servers) {
   );
 }
 
+// src/jobs/credentialGate.ts
+function credentialGate(agent, credentials, runnerId, busyCredentialIds, defaultEngine) {
+  if (!agent) return "ok";
+  const resolved = resolveAgentCredential(agent, [...credentials], defaultEngine);
+  if (!resolved || !isMachineHeldCredential(resolved)) return "ok";
+  if (resolved.runnerId !== runnerId) return "other-machine";
+  if (!isCredentialReady(resolved)) return "not-ready";
+  if (busyCredentialIds.has(resolved.id)) return "busy";
+  return "ok";
+}
+
+// src/jobs/engineHome.ts
+import path5 from "node:path";
+var SEGMENT = /^[A-Za-z0-9_-]+$/;
+function engineCredentialHome(root, engineId, shipId, credentialId) {
+  for (const segment of [engineId, shipId, credentialId]) {
+    if (!SEGMENT.test(segment)) throw new Error(`not a valid path segment: ${JSON.stringify(segment)}`);
+  }
+  return path5.join(root, "engines", engineId, shipId, credentialId);
+}
+
+// src/jobs/engineLogin.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import fs5 from "node:fs";
+import path6 from "node:path";
+var DEVICE_CODE_TTL_MS = 15 * 60 * 1e3;
+function machineLoginTimeoutMs() {
+  const override = Number(process.env.CREW_MACHINE_LOGIN_TIMEOUT_MS);
+  return Number.isFinite(override) && override > 0 ? override : DEVICE_CODE_TTL_MS + 60 * 1e3;
+}
+var GUIDANCE_SETTLE_MS = 2e3;
+function credentialsNeedingLogin(credentials, runnerId, now) {
+  const start = [];
+  const expire = [];
+  for (const c of credentials) {
+    if (c.runnerId !== runnerId || !isMachineLoginEngine(c.engine)) continue;
+    const verdict = machineLoginPending(c, now);
+    if (verdict === "start") start.push(c);
+    else if (verdict === "expire") expire.push(c);
+  }
+  return { start, expire };
+}
+function credentialsToForget(previouslyHeld, current) {
+  const live = new Set(current.map((c) => c.id));
+  return [...previouslyHeld].filter((id) => !live.has(id));
+}
+function orphanHomes(root, shipId, liveIds) {
+  const enginesDir = path6.join(root, "engines");
+  let engines = [];
+  try {
+    engines = fs5.readdirSync(enginesDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const engineId of engines) {
+    const shipDir = path6.join(enginesDir, engineId, shipId);
+    let creds = [];
+    try {
+      creds = fs5.readdirSync(shipDir);
+    } catch {
+      continue;
+    }
+    for (const credId of creds) if (!liveIds.has(credId)) out.push(path6.join(shipDir, credId));
+  }
+  return out;
+}
+async function runMachineLogin(input) {
+  const spawn8 = input.spawn ?? nodeSpawn;
+  if (input.signal?.aborted) return { phase: "failed", error: "The runner was stopping." };
+  try {
+    fs5.mkdirSync(input.home, { recursive: true, mode: 448 });
+  } catch (e) {
+    return { phase: "failed", error: `Could not create the sign-in directory: ${message2(e)}` };
+  }
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn8(input.bin, input.driver.spawnArgs(), {
+        env: { ...process.env, ...input.driver.env(input.home) },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (e) {
+      resolve({ phase: "failed", error: notInstalled(input.engineId, input.bin, message2(e)) });
+      return;
+    }
+    let settled = false;
+    let text2 = "";
+    let stderr = "";
+    let guided = false;
+    let settleTimer = null;
+    let expired = false;
+    const finish = (outcome) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      if (settleTimer) clearTimeout(settleTimer);
+      input.signal?.removeEventListener("abort", onAbort);
+      resolve(outcome);
+    };
+    const guide = () => {
+      if (guided || !text2.trim()) return;
+      guided = true;
+      if (settleTimer) clearTimeout(settleTimer);
+      const parsed = input.driver.parseGuidance(text2) ?? {};
+      try {
+        input.onGuidance({ text: text2, ...parsed });
+      } catch (e) {
+        input.log(`sign-in guidance callback failed: ${message2(e)}`);
+      }
+    };
+    const onOutput = (chunk, isErr) => {
+      const clean = stripAnsi(chunk.toString("utf8"));
+      if (isErr) stderr += clean;
+      text2 += clean;
+      if (guided) return;
+      if (input.driver.parseGuidance(text2)) guide();
+      else if (!settleTimer) settleTimer = setTimeout(guide, GUIDANCE_SETTLE_MS);
+    };
+    child.stdout?.on("data", (c) => onOutput(c, false));
+    child.stderr?.on("data", (c) => onOutput(c, true));
+    const deadline = setTimeout(() => {
+      expired = true;
+      input.log("Sign-in did not complete before the code expired \u2014 stopping it.");
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 5e3).unref();
+    }, input.timeoutMs);
+    const onAbort = () => {
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 3e3).unref();
+    };
+    input.signal?.addEventListener("abort", onAbort, { once: true });
+    child.on("error", (e) => {
+      finish({
+        phase: "failed",
+        error: e.code === "ENOENT" ? notInstalled(input.engineId, input.bin, e.message) : `Could not start the sign-in: ${e.message}`
+      });
+    });
+    child.on("close", (code) => {
+      if (expired) {
+        finish({ phase: "expired" });
+        return;
+      }
+      if (input.signal?.aborted) {
+        finish({ phase: "failed", error: "The runner stopped before the sign-in completed." });
+        return;
+      }
+      if (code === 0 && input.driver.isSignedIn(input.home)) {
+        finish({ phase: "ready", account: input.driver.readAccount(input.home) });
+        return;
+      }
+      const tail2 = stderr.trim().split("\n").slice(-3).join(" ").trim() || text2.trim().split("\n").slice(-2).join(" ").trim();
+      finish({
+        phase: "failed",
+        error: code === 0 ? "The sign-in finished but left no login behind." : `The sign-in exited ${code}${tail2 ? `: ${tail2}` : "."}`
+      });
+    });
+  });
+}
+function notInstalled(engineId, bin, detail) {
+  return `\`${bin}\` is not installed on this machine (${detail}). Install the engine's CLI, or set ${engineBinaryEnvVar(engineId)} to its path.`;
+}
+async function logoutAndRemove(input) {
+  const spawn8 = input.spawn ?? nodeSpawn;
+  if (fs5.existsSync(input.home)) {
+    await new Promise((resolve) => {
+      let child;
+      try {
+        child = spawn8(input.bin, input.driver.logoutArgs(), {
+          env: { ...process.env, ...input.driver.env(input.home) },
+          stdio: "ignore"
+        });
+      } catch {
+        resolve();
+        return;
+      }
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        resolve();
+      }, 15e3);
+      child.on("error", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      child.on("close", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+  try {
+    fs5.rmSync(input.home, { recursive: true, force: true });
+  } catch (e) {
+    input.log(`Could not remove the sign-in directory ${input.home}: ${message2(e)}`);
+  }
+}
+async function reportLogin(input) {
+  try {
+    await callFunction(functionsBaseUrl(input.config), input.idToken, "crewShips", "reportCredentialLogin", {
+      shipId: input.shipId,
+      credentialId: input.credentialId,
+      ...input.report
+    });
+  } catch (e) {
+    input.log(`Could not report the sign-in (${input.report.phase}) for ${input.credentialId}: ${message2(e)}`);
+  }
+}
+async function machineLoginAndReport(input) {
+  const { credential, shipId } = input;
+  const driver = getDriver(credential.engine);
+  const say2 = (report4) => input.idToken().then((idToken) => reportLogin({ config: input.config, idToken, shipId, credentialId: credential.id, report: report4, log: input.log })).catch((e) => input.log(`Could not mint a token to report the sign-in: ${message2(e)}`));
+  if (!driver.login) {
+    await say2({ phase: "failed", error: `Engine "${credential.engine}" does not sign in from a machine.` });
+    return;
+  }
+  let home;
+  try {
+    home = engineCredentialHome(input.root, credential.engine, shipId, credential.id);
+  } catch (e) {
+    await say2({ phase: "failed", error: message2(e) });
+    return;
+  }
+  input.log(`Signing this machine in for "${credential.label}" (${credential.engine}) \u2014 a captain asked.`);
+  const outcome = await runMachineLogin({
+    driver: driver.login,
+    engineId: credential.engine,
+    bin: driver.binary(),
+    home,
+    timeoutMs: machineLoginTimeoutMs(),
+    signal: input.signal,
+    spawn: input.spawn,
+    log: input.log,
+    onGuidance: (guidance) => {
+      void say2({
+        phase: "code",
+        text: guidance.text,
+        ...guidance.code ? { code: guidance.code } : {},
+        ...guidance.url ? { url: guidance.url } : {},
+        expiresAt: Date.now() + DEVICE_CODE_TTL_MS
+      });
+    }
+  });
+  if (outcome.phase === "ready") {
+    const a = outcome.account;
+    input.log(`Signed in for "${credential.label}"${a?.email ? ` as ${a.email}` : ""}.`);
+    await say2({
+      phase: "ready",
+      ...a ? { account: { ...a.email ? { email: a.email } : {}, ...a.plan ? { plan: a.plan } : {}, ...a.activeUntil ? { activeUntil: a.activeUntil } : {} } } : {},
+      ...a?.accountIdTail ? { accountIdTail: a.accountIdTail } : {}
+    });
+    return;
+  }
+  if (outcome.phase === "expired") {
+    input.log(`The sign-in for "${credential.label}" expired before it was approved.`);
+    try {
+      fs5.rmSync(home, { recursive: true, force: true });
+    } catch {
+    }
+    await say2({ phase: "expired" });
+    return;
+  }
+  input.log(`The sign-in for "${credential.label}" failed: ${outcome.error}`);
+  try {
+    fs5.rmSync(home, { recursive: true, force: true });
+  } catch {
+  }
+  await say2({ phase: "failed", error: outcome.error });
+}
+var message2 = (e) => e instanceof Error ? e.message : String(e);
+
 // src/jobs/engineLimits.ts
 import {
   collection as collection6,
@@ -3352,30 +4286,34 @@ import {
   where as where3
 } from "firebase/firestore";
 import { ref as storageRef, uploadBytes } from "firebase/storage";
-function redactTranscript(transcript, knownSecrets) {
+function redactTranscript(transcript, knownSecrets, patterns = []) {
   let out = transcript;
   for (const secret of knownSecrets) {
     if (secret && secret.length >= 8) out = out.split(secret).join("[REDACTED]");
   }
-  out = out.replace(/sk-ant-[A-Za-z0-9_-]{8,}/g, "[REDACTED]");
+  for (const pattern of patterns) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g";
+    out = out.replace(new RegExp(pattern.source, flags), "[REDACTED]");
+  }
   out = out.replace(/gh[pousr]_[A-Za-z0-9]{20,}/g, "[REDACTED]");
   out = out.replace(/github_pat_[A-Za-z0-9_]{20,}/g, "[REDACTED]");
   out = out.replace(/ya29\.[A-Za-z0-9_-]{20,}/g, "[REDACTED]");
   out = out.replace(/crewmcp_[A-Za-z0-9]+_[a-f0-9]{64}/g, "[REDACTED]");
+  out = out.replace(/eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}/g, "[REDACTED]");
   return out;
 }
 async function uploadTranscript(storage, shipId, jobId, redacted) {
-  const path9 = `crew/${shipId}/transcripts/${jobId}.jsonl`;
-  await uploadBytes(storageRef(storage, path9), new TextEncoder().encode(redacted), {
+  const path13 = `crew/${shipId}/transcripts/${jobId}.jsonl`;
+  await uploadBytes(storageRef(storage, path13), new TextEncoder().encode(redacted), {
     contentType: "application/x-ndjson"
   });
-  return path9;
+  return path13;
 }
 function utcDay(millis) {
   return new Date(millis).toISOString().slice(0, 10);
 }
-function backstopReportContent(resultText2) {
-  const text2 = resultText2.trim();
+function backstopReportContent(resultText3) {
+  const text2 = resultText3.trim();
   if (!text2) {
     const none = "This run ended without writing a report, and left no final text to fall back on.";
     return { report: none, summary: none };
@@ -3589,8 +4527,8 @@ function stripSessionNarration(text2) {
   if (dropped === 0 || dropped === paragraphs.length) return text2;
   return text2.slice(paragraphs[dropped].start).trim();
 }
-function backstopReplyContent(resultText2) {
-  const text2 = stripSessionNarration(resultText2.trim());
+function backstopReplyContent(resultText3) {
+  const text2 = stripSessionNarration(resultText3.trim());
   if (!text2) {
     return "I finished that run without writing a reply. Write again to start a fresh one.";
   }
@@ -3598,7 +4536,7 @@ function backstopReplyContent(resultText2) {
   const marker = "\n\n\u2026(truncated)";
   return `${text2.slice(0, MAX_CHAT_MESSAGE_CHARS - marker.length)}${marker}`;
 }
-async function ensureChatReply(db, shipId, job, resultText2) {
+async function ensureChatReply(db, shipId, job, resultText3) {
   const chatRef = doc8(db, COLLECTIONS.ships, shipId, COLLECTIONS.chats, job.chatId);
   const messagesCol = collection7(chatRef, COLLECTIONS.chatMessages);
   const snap = await getDocs6(
@@ -3614,7 +4552,7 @@ async function ensureChatReply(db, shipId, job, resultText2) {
     return author?.type === "agent" && author.id === job.agentId;
   });
   if (replied) return "agent-replied";
-  const content = backstopReplyContent(resultText2);
+  const content = backstopReplyContent(resultText3);
   await addDoc(messagesCol, {
     author: { type: "agent", id: job.agentId },
     content,
@@ -3622,17 +4560,17 @@ async function ensureChatReply(db, shipId, job, resultText2) {
     createdAt: Date.now(),
     jobId: job.id
   });
-  return resultText2.trim() ? "posted-final-text" : "posted-silence-note";
+  return resultText3.trim() ? "posted-final-text" : "posted-silence-note";
 }
 
 // src/jobs/progress.ts
 var PROGRESS_FLUSH_MS = 3e3;
 var PROGRESS_DENIALS_BEFORE_PROBE = 2;
-function redactStep(step2, secrets) {
-  const label = clampStepText(redactTranscript(step2.label, secrets), MAX_STEP_LABEL);
+function redactStep(step2, secrets, patterns = []) {
+  const label = clampStepText(redactTranscript(step2.label, secrets, patterns), MAX_STEP_LABEL);
   const base = { at: step2.at, kind: step2.kind, label };
   if (step2.detail === void 0) return base;
-  const detail = clampStepText(redactTranscript(step2.detail, secrets), MAX_STEP_DETAIL);
+  const detail = clampStepText(redactTranscript(step2.detail, secrets, patterns), MAX_STEP_DETAIL);
   return detail ? { ...base, detail } : base;
 }
 function errorCode(error) {
@@ -3664,7 +4602,8 @@ function createProgressWriter(deps) {
     }
     if (closed || inFlight || pending.length === 0) return;
     const secrets = deps.secrets();
-    for (const step2 of pending) progress = pushJobStep(progress, redactStep(step2, secrets));
+    const patterns = deps.patterns?.() ?? [];
+    for (const step2 of pending) progress = pushJobStep(progress, redactStep(step2, secrets, patterns));
     pending = [];
     lastWriteAt = now();
     inFlight = true;
@@ -3728,9 +4667,9 @@ function createProgressWriter(deps) {
 
 // src/service.ts
 import { spawnSync } from "node:child_process";
-import fs4 from "node:fs";
-import os3 from "node:os";
-import path4 from "node:path";
+import fs6 from "node:fs";
+import os4 from "node:os";
+import path7 from "node:path";
 import { fileURLToPath } from "node:url";
 var SERVICE_LABEL = `com.kilogent.${RUNNER_BIN.replace(/^kilogent-/, "")}`;
 var LINUX_UNIT = `${RUNNER_BIN}.service`;
@@ -3758,10 +4697,10 @@ function uid() {
   return String(process.getuid?.() ?? 0);
 }
 function launchAgentPath() {
-  return path4.join(os3.homedir(), "Library/LaunchAgents", `${SERVICE_LABEL}.plist`);
+  return path7.join(os4.homedir(), "Library/LaunchAgents", `${SERVICE_LABEL}.plist`);
 }
 function systemdUnitPath() {
-  return path4.join(os3.homedir(), ".config/systemd/user", LINUX_UNIT);
+  return path7.join(os4.homedir(), ".config/systemd/user", LINUX_UNIT);
 }
 function serviceEnv() {
   const env = { PATH: process.env.PATH ?? "" };
@@ -3779,19 +4718,19 @@ function removeLegacyService() {
   for (const old of RETIRED_SERVICES) {
     if (old.label === SERVICE_LABEL) continue;
     if (process.platform === "darwin") {
-      const unitPath = path4.join(os3.homedir(), "Library/LaunchAgents", `${old.label}.plist`);
-      if (fs4.existsSync(unitPath)) {
+      const unitPath = path7.join(os4.homedir(), "Library/LaunchAgents", `${old.label}.plist`);
+      if (fs6.existsSync(unitPath)) {
         run("launchctl", ["bootout", `gui/${uid()}/${old.label}`]);
-        fs4.rmSync(unitPath, { force: true });
+        fs6.rmSync(unitPath, { force: true });
         removed.push(unitPath);
       }
       continue;
     }
     if (process.platform === "linux") {
-      const unitPath = path4.join(os3.homedir(), ".config/systemd/user", old.unit);
-      if (fs4.existsSync(unitPath)) {
+      const unitPath = path7.join(os4.homedir(), ".config/systemd/user", old.unit);
+      if (fs6.existsSync(unitPath)) {
         run("systemctl", ["--user", "disable", "--now", old.unit]);
-        fs4.rmSync(unitPath, { force: true });
+        fs6.rmSync(unitPath, { force: true });
         run("systemctl", ["--user", "daemon-reload"]);
         removed.push(unitPath);
       }
@@ -3855,9 +4794,9 @@ function plistXml() {
 ${envEntries}
   </dict>
   <key>StandardOutPath</key>
-  <string>${escapeXml(path4.join(logDir(), "service.out.log"))}</string>
+  <string>${escapeXml(path7.join(logDir(), "service.out.log"))}</string>
   <key>StandardErrorPath</key>
-  <string>${escapeXml(path4.join(logDir(), "service.err.log"))}</string>
+  <string>${escapeXml(path7.join(logDir(), "service.err.log"))}</string>
 </dict>
 </plist>
 `;
@@ -3903,14 +4842,14 @@ function parseSystemdCliPath(unit) {
 function execFacts(unitPath, parse, parseEnv) {
   let text2;
   try {
-    text2 = fs4.readFileSync(unitPath, "utf8");
+    text2 = fs6.readFileSync(unitPath, "utf8");
   } catch {
     return {};
   }
   const unitEnv = parseEnv(text2);
   const execPath = parse(text2);
-  if (!execPath || !path4.isAbsolute(execPath)) return { ...unitEnv ? { unitEnv } : {} };
-  return { execPath, execMissing: !fs4.existsSync(execPath), ...unitEnv ? { unitEnv } : {} };
+  if (!execPath || !path7.isAbsolute(execPath)) return { ...unitEnv ? { unitEnv } : {} };
+  return { execPath, execMissing: !fs6.existsSync(execPath), ...unitEnv ? { unitEnv } : {} };
 }
 function systemdUnit() {
   const env = serviceEnv();
@@ -3936,7 +4875,7 @@ WantedBy=default.target
 function serviceStatus() {
   if (process.platform === "darwin") {
     const unitPath = launchAgentPath();
-    if (!fs4.existsSync(unitPath)) return { state: "not-installed", detail: "No LaunchAgent installed." };
+    if (!fs6.existsSync(unitPath)) return { state: "not-installed", detail: "No LaunchAgent installed." };
     const exec = execFacts(unitPath, parsePlistCliPath, parsePlistEnv);
     const printed = run("launchctl", ["print", `gui/${uid()}/${SERVICE_LABEL}`]);
     if (!printed.ok) {
@@ -3952,7 +4891,7 @@ function serviceStatus() {
   }
   if (process.platform === "linux") {
     const unitPath = systemdUnitPath();
-    if (!fs4.existsSync(unitPath)) return { state: "not-installed", detail: "No systemd user unit installed." };
+    if (!fs6.existsSync(unitPath)) return { state: "not-installed", detail: "No systemd user unit installed." };
     const active = run("systemctl", ["--user", "is-active", LINUX_UNIT]);
     return {
       state: active.out === "active" ? "running" : "installed",
@@ -3974,14 +4913,14 @@ function serviceStatus() {
 }
 function installService() {
   const notes = [];
-  fs4.mkdirSync(logDir(), { recursive: true, mode: 448 });
+  fs6.mkdirSync(logDir(), { recursive: true, mode: 448 });
   for (const unit of removeLegacyService()) {
     notes.push(`Removed the previous crew-runner service (${unit}).`);
   }
   if (process.platform === "darwin") {
     const unitPath = launchAgentPath();
-    fs4.mkdirSync(path4.dirname(unitPath), { recursive: true });
-    fs4.writeFileSync(unitPath, plistXml());
+    fs6.mkdirSync(path7.dirname(unitPath), { recursive: true });
+    fs6.writeFileSync(unitPath, plistXml());
     run("launchctl", ["bootout", `gui/${uid()}/${SERVICE_LABEL}`]);
     const boot = retryWhileTransient(
       () => run("launchctl", ["bootstrap", `gui/${uid()}`, unitPath]),
@@ -3992,16 +4931,16 @@ function installService() {
   }
   if (process.platform === "linux") {
     const unitPath = systemdUnitPath();
-    fs4.mkdirSync(path4.dirname(unitPath), { recursive: true });
-    fs4.writeFileSync(unitPath, systemdUnit());
+    fs6.mkdirSync(path7.dirname(unitPath), { recursive: true });
+    fs6.writeFileSync(unitPath, systemdUnit());
     const reload = run("systemctl", ["--user", "daemon-reload"]);
     if (!reload.ok) throw new ServiceError(`systemctl daemon-reload failed: ${reload.out}`);
     const enable = run("systemctl", ["--user", "enable", "--now", LINUX_UNIT]);
     if (!enable.ok) throw new ServiceError(`systemctl enable failed: ${enable.out}`);
-    const linger = run("loginctl", ["show-user", os3.userInfo().username, "--property=Linger"]);
+    const linger = run("loginctl", ["show-user", os4.userInfo().username, "--property=Linger"]);
     if (!linger.out.includes("Linger=yes")) {
       notes.push(
-        `Run \`sudo loginctl enable-linger ${os3.userInfo().username}\` so the daemon survives logout and starts at boot.`
+        `Run \`sudo loginctl enable-linger ${os4.userInfo().username}\` so the daemon survives logout and starts at boot.`
       );
     }
     return { unitPath, notes };
@@ -4032,12 +4971,12 @@ function uninstallService() {
   removeLegacyService();
   if (process.platform === "darwin") {
     run("launchctl", ["bootout", `gui/${uid()}/${SERVICE_LABEL}`]);
-    fs4.rmSync(launchAgentPath(), { force: true });
+    fs6.rmSync(launchAgentPath(), { force: true });
     return;
   }
   if (process.platform === "linux") {
     run("systemctl", ["--user", "disable", "--now", LINUX_UNIT]);
-    fs4.rmSync(systemdUnitPath(), { force: true });
+    fs6.rmSync(systemdUnitPath(), { force: true });
     run("systemctl", ["--user", "daemon-reload"]);
     return;
   }
@@ -4068,7 +5007,7 @@ function restartService() {
 }
 
 // src/update/plan.ts
-import path5 from "node:path";
+import path8 from "node:path";
 
 // src/update/semver.ts
 var DEV_VERSION = "0.0.0-dev";
@@ -4158,16 +5097,16 @@ function reconcile(state, current) {
   return { action: "keep", state };
 }
 function packageRootFrom(cliPath2) {
-  return path5.dirname(path5.dirname(cliPath2));
+  return path8.dirname(path8.dirname(cliPath2));
 }
 function globalPrefixFrom(cliPath2) {
   const root = packageRootFrom(cliPath2);
-  const parts = root.split(path5.sep);
+  const parts = root.split(path8.sep);
   const i = parts.lastIndexOf("node_modules");
   if (i < 1) return null;
   const before = parts.slice(0, i);
   if (before[before.length - 1] === "lib") before.pop();
-  const prefix = before.join(path5.sep);
+  const prefix = before.join(path8.sep);
   return prefix || null;
 }
 function decideUpdate(f) {
@@ -4249,15 +5188,15 @@ async function fetchDistTags(options = {}) {
 }
 
 // src/update/state.ts
-import fs5 from "node:fs";
-import path6 from "node:path";
+import fs7 from "node:fs";
+import path9 from "node:path";
 var UPDATE_STATE_FILE = "update.json";
 function updateStatePath() {
-  return path6.join(configDir(), UPDATE_STATE_FILE);
+  return path9.join(configDir(), UPDATE_STATE_FILE);
 }
 function readUpdateState() {
   try {
-    const parsed = JSON.parse(fs5.readFileSync(updateStatePath(), "utf8"));
+    const parsed = JSON.parse(fs7.readFileSync(updateStatePath(), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -4266,8 +5205,8 @@ function readUpdateState() {
 }
 function writeUpdateState(state) {
   try {
-    fs5.mkdirSync(configDir(), { recursive: true, mode: 448 });
-    fs5.writeFileSync(updateStatePath(), `${JSON.stringify(state, null, 2)}
+    fs7.mkdirSync(configDir(), { recursive: true, mode: 448 });
+    fs7.writeFileSync(updateStatePath(), `${JSON.stringify(state, null, 2)}
 `, { mode: 384 });
     return true;
   } catch {
@@ -4276,15 +5215,15 @@ function writeUpdateState(state) {
 }
 function clearUpdateState() {
   try {
-    fs5.rmSync(updateStatePath(), { force: true });
+    fs7.rmSync(updateStatePath(), { force: true });
   } catch {
   }
 }
 
 // src/update/install.ts
-import { spawn as spawn5, spawnSync as spawnSync2 } from "node:child_process";
-import fs6 from "node:fs";
-import path7 from "node:path";
+import { spawn as spawn6, spawnSync as spawnSync2 } from "node:child_process";
+import fs8 from "node:fs";
+import path10 from "node:path";
 var INSTALL_TIMEOUT_MS = 5 * 6e4;
 var STDERR_KEEP = 400;
 function npmPresent() {
@@ -4306,7 +5245,7 @@ async function installGlobal(target, cliPath2, options = {}) {
   return new Promise((resolve) => {
     let child;
     try {
-      child = spawn5("npm", args, { stdio: ["ignore", "ignore", "pipe"] });
+      child = spawn6("npm", args, { stdio: ["ignore", "ignore", "pipe"] });
     } catch (e) {
       resolve({ ok: false, detail: e instanceof Error ? e.message : String(e) });
       return;
@@ -4339,7 +5278,7 @@ async function installGlobal(target, cliPath2, options = {}) {
 function installedVersionAt(cliPath2) {
   try {
     const pkg = JSON.parse(
-      fs6.readFileSync(path7.join(packageRootFrom(cliPath2), "package.json"), "utf8")
+      fs8.readFileSync(path10.join(packageRootFrom(cliPath2), "package.json"), "utf8")
     );
     const version = pkg?.version;
     return typeof version === "string" ? version : null;
@@ -4390,6 +5329,13 @@ async function startDaemon() {
   console.log(
     bannerIds.length <= 1 ? `Runner ${bannerIds[0] ?? config2.runnerId} serving ${serving.size} Ship(s): ${[...serving].join(", ")}` : `Runner ${bannerIds.length} identities serving ${serving.size} Ship(s): ` + sessions.map((s) => `${s.shipId} as ${s.runnerId}`).join(", ")
   );
+  const machineLookup = (shipId) => ({
+    runnerId: sess(shipId).runnerId,
+    localLogin: (engineId, credentialId) => {
+      const home = engineCredentialHome(configDir(), engineId, shipId, credentialId);
+      return getDriver(engineId).login?.isSignedIn(home) ? home : null;
+    }
+  });
   const logLines = [];
   const log2 = (line) => {
     const stamped = `${(/* @__PURE__ */ new Date()).toISOString()} ${line}`;
@@ -4444,7 +5390,7 @@ async function startDaemon() {
           await setDoc2(
             shipRunnerRef(shipId),
             {
-              hostname: os4.hostname(),
+              hostname: os5.hostname(),
               version: RUNNER_VERSION,
               status: "online",
               lastSeenAt: now,
@@ -4503,6 +5449,10 @@ async function startDaemon() {
   const engineLimits = /* @__PURE__ */ new Map();
   const claimBackoff = /* @__PURE__ */ new Map();
   const agentEngines = /* @__PURE__ */ new Map();
+  const agentCredentials = /* @__PURE__ */ new Map();
+  const shipCredentials = /* @__PURE__ */ new Map();
+  const heldCredentialIds = /* @__PURE__ */ new Map();
+  const loginsInFlight = /* @__PURE__ */ new Map();
   const unsubsByShip = /* @__PURE__ */ new Map();
   const listenerError = (shipId, what) => (e) => {
     if (isEnrolmentGone(e)) {
@@ -4539,7 +5489,9 @@ async function startDaemon() {
         collection8(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.agents),
         (snap) => {
           for (const d of snap.docs) {
-            agentEngines.set(`${shipId}/${d.id}`, agentEngine(d.data()));
+            const agent = d.data();
+            agentEngines.set(`${shipId}/${d.id}`, agentEngine(agent));
+            agentCredentials.set(`${shipId}/${d.id}`, { engine: agent.engine, credentialId: agent.credentialId });
           }
           poke();
         },
@@ -4594,6 +5546,93 @@ async function startDaemon() {
          */
         (e) => console.error(`mcp connections listener error (${shipId}):`, e.message)
       ),
+      /**
+       * AI credentials (PRD §15.81), for two things only this machine can answer.
+       *
+       * The CLAIM GATE: a machine-held credential lives on one machine, so a queued job on it is
+       * that machine's job — `credentialGate` reads this list before any claim. And the SIGN-IN: a
+       * captain asks, through a callable, for THIS machine to sign in for a new credential; the
+       * document turns `pending` bound to this runner, and the only thing in the world that can
+       * answer is a process on this machine. §15.40's probe listener, with two more steps.
+       *
+       * `credentialsNeedingLogin` deliberately acts on nothing this machine has already answered,
+       * and reports an old unanswered request STALE rather than starting it: a device code lives
+       * fifteen minutes, and a machine that was off when the captain clicked would otherwise show
+       * a code nobody is watching. Startup is the same case, so a daemon coming up does not sign
+       * in to anything on its own.
+       *
+       * A credential that VANISHES from the list is a sign-in to forget: the callable deleted the
+       * row, and the token on this disk is the only copy left. The first snapshot also sweeps the
+       * directories no live credential explains — the deletions that happened while it was off.
+       */
+      onSnapshot2(
+        collection8(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.credentials),
+        (snap) => {
+          const list = snap.docs.map((d) => ({ id: d.id, ...d.data() }));
+          const runnerId = sess(shipId).runnerId;
+          shipCredentials.set(shipId, list);
+          const now = Date.now();
+          const held = heldCredentialIds.get(shipId) ?? /* @__PURE__ */ new Set();
+          const gone = credentialsToForget(held, list);
+          for (const id of gone) {
+            held.delete(id);
+            loginsInFlight.get(id)?.abort();
+            for (const dir of orphanHomes(configDir(), shipId, new Set(list.map((c) => c.id)))) {
+              if (!dir.endsWith(`${path11.sep}${id}`)) continue;
+              const engineId = path11.basename(path11.dirname(path11.dirname(dir)));
+              const driver = getDriver(engineId);
+              if (!driver.login) continue;
+              void logoutAndRemove({ driver: driver.login, bin: driver.binary(), home: dir, log: log2 }).then(
+                () => log2(`Forgot the sign-in for credential ${id} \u2014 the credential was deleted from Ship ${shipId}.`)
+              );
+            }
+          }
+          if (!heldCredentialIds.has(shipId)) {
+            for (const dir of orphanHomes(configDir(), shipId, new Set(list.map((c) => c.id)))) {
+              const engineId = path11.basename(path11.dirname(path11.dirname(dir)));
+              const driver = getDriver(engineId);
+              if (!driver.login) continue;
+              void logoutAndRemove({ driver: driver.login, bin: driver.binary(), home: dir, log: log2 }).then(
+                () => log2(`Removed a stale sign-in directory for Ship ${shipId}: ${dir}`)
+              );
+            }
+          }
+          for (const c of list) if (c.runnerId === runnerId) held.add(c.id);
+          heldCredentialIds.set(shipId, held);
+          const { start, expire } = credentialsNeedingLogin(list, runnerId, now);
+          for (const credential of expire) {
+            void sess(shipId).user.getIdToken().then(
+              (idToken) => reportLogin({
+                config: config2,
+                idToken,
+                shipId,
+                credentialId: credential.id,
+                report: { phase: "expired", error: "This machine was offline when the sign-in was requested. Ask again." },
+                log: log2
+              })
+            ).catch((e) => log2(`Could not report a stale sign-in request: ${e instanceof Error ? e.message : e}`));
+          }
+          for (const credential of start) {
+            if (loginsInFlight.has(credential.id)) continue;
+            const abort = new AbortController();
+            loginsInFlight.set(credential.id, abort);
+            void machineLoginAndReport({
+              config: config2,
+              idToken: () => sess(shipId).user.getIdToken(),
+              shipId,
+              credential,
+              root: configDir(),
+              signal: abort.signal,
+              log: log2
+            }).catch((e) => log2(`Sign-in for ${credential.id} ended abnormally: ${e instanceof Error ? e.message : e}`)).finally(() => loginsInFlight.delete(credential.id));
+          }
+          poke();
+        },
+        // ITS OWN ERROR HANDLER, not `listenerError`, for the reason the mcp_servers listener
+        // gives: `credentials` is `isShipReader`, which a REVOKED machine fails, and revocation is
+        // a state to sit through, not a removal.
+        (e) => console.error(`credentials listener error (${shipId}):`, e.message)
+      ),
       // Exhausted usage windows. The FIRST snapshot is the startup seed: a restarted daemon —
       // and a second daemon on this Ship — inherits the pause instead of running a doomed
       // session to rediscover it.
@@ -4632,6 +5671,20 @@ async function startDaemon() {
     for (const key of [...agentEngines.keys()]) {
       if (key.startsWith(`${shipId}/`)) agentEngines.delete(key);
     }
+    for (const key of [...agentCredentials.keys()]) {
+      if (key.startsWith(`${shipId}/`)) agentCredentials.delete(key);
+    }
+    shipCredentials.delete(shipId);
+    heldCredentialIds.delete(shipId);
+    for (const engineId of (() => {
+      try {
+        return fs9.readdirSync(path11.join(configDir(), "engines"));
+      } catch {
+        return [];
+      }
+    })()) {
+      fs9.rmSync(path11.join(configDir(), "engines", engineId, shipId), { recursive: true, force: true });
+    }
     approved.delete(shipId);
     warnedUnapproved.delete(shipId);
     needsRefill.delete(shipId);
@@ -4658,6 +5711,17 @@ async function startDaemon() {
     }
   }
   const engineForJob = (shipId, job) => agentEngines.get(`${shipId}/${job.agentId}`) ?? DEFAULT_ENGINE_ID;
+  const credentialVerdict = (shipId, job) => {
+    const busy = /* @__PURE__ */ new Set();
+    for (const r of running.values()) if (r.credentialId) busy.add(r.credentialId);
+    return credentialGate(
+      agentCredentials.get(`${shipId}/${job.agentId}`),
+      shipCredentials.get(shipId) ?? [],
+      sess(shipId).runnerId,
+      busy,
+      DEFAULT_ENGINE_ID
+    );
+  };
   let dispatching = false;
   let pokeRequested = false;
   let shuttingDown = false;
@@ -4732,7 +5796,9 @@ async function startDaemon() {
           // the limit map is keyed by (Ship, engine) and the engine comes from the registry via
           // the agent, so the job loop still knows nothing about Claude. Skipped entries STAY in
           // `pending`, which is what lets a reset resume them with only a poke.
-          eligible: (p) => approved.get(p.shipId) === true && !isLimited(engineLimits, p.shipId, engineForJob(p.shipId, p.job), now) && // The connection cooldown. Same "skip, don't stop" shape as the limit gate above, and
+          eligible: (p) => approved.get(p.shipId) === true && !isLimited(engineLimits, p.shipId, engineForJob(p.shipId, p.job), now) && // §15.81: a job on a machine-held credential is that machine's job. Skipped entries
+          // STAY in `pending`; the credentials listener pokes when the sign-in lands.
+          credentialVerdict(p.shipId, p.job) === "ok" && // The connection cooldown. Same "skip, don't stop" shape as the limit gate above, and
           // skipped entries STAY in `pending` for the same reason — `sweepBackoff` resumes them
           // with a poke. Without this the `transient` release below re-claims what it just put
           // down, every three seconds, forever (jobs/claimBackoff.ts).
@@ -4763,7 +5829,9 @@ async function startDaemon() {
     });
   }
   async function claim(shipId, job) {
-    if (isLimited(engineLimits, shipId, engineForJob(shipId, job), Date.now())) {
+    if (isLimited(engineLimits, shipId, engineForJob(shipId, job), Date.now()) || // Same second gate for the credential: a sibling session on the same machine sign-in can
+    // have started between selection and here.
+    credentialVerdict(shipId, job) !== "ok") {
       pending.set(`${shipId}/${job.id}`, { shipId, job });
       return null;
     }
@@ -4857,10 +5925,11 @@ async function startDaemon() {
     let failure = null;
     let terminal = false;
     let transient = false;
+    let misrouted = false;
     let sessionLimit = null;
     let engineId = DEFAULT_ENGINE_ID;
     let transcript = "";
-    let resultText2 = "";
+    let resultText3 = "";
     let mcpConnected = [];
     let usage = {
       engine: DEFAULT_ENGINE_ID,
@@ -4880,6 +5949,8 @@ async function startDaemon() {
         progress: p
       }),
       secrets: () => knownSecrets,
+      // Read late for the same reason: the engine is only known once the agent is.
+      patterns: () => getDriver(engineId).secretPatterns,
       // Two consecutive DENIALS mean this job is no longer ours to write — a force-stop took it, or
       // the machine was revoked. The §15.30 door: the news arrives as `permission-denied`.
       //
@@ -4908,7 +5979,7 @@ async function startDaemon() {
     try {
       let secrets = null;
       const forAssistant = isAssistantId(job.agentId);
-      const assistantCredential = forAssistant ? await resolveAssistantCredential(sess(shipId).fb.db, shipId) : null;
+      const assistantCredential = forAssistant ? await resolveAssistantCredential(sess(shipId).fb.db, shipId, machineLookup(shipId)) : null;
       const packed = forAssistant && target.kind === "chat" ? {
         kind: "assistant",
         ctx: await loadAssistantContext(
@@ -4931,14 +6002,17 @@ async function startDaemon() {
         db: sess(shipId).fb.db,
         shipId,
         agent,
-        credentials: await loadShipCredentials(sess(shipId).fb.db, shipId).catch(() => [])
+        credentials: await loadShipCredentials(sess(shipId).fb.db, shipId).catch(() => []),
+        machine: machineLookup(shipId)
       });
+      slot.credentialId = resolvedSecrets.credentialId;
       if (resolvedSecrets.problem) {
+        misrouted = resolvedSecrets.kind === "other-machine" || resolvedSecrets.kind === "not-ready";
         throw new Error(resolvedSecrets.problem);
       }
       secrets = resolvedSecrets.secrets;
       const missing = missingSecretsFor(engineId, secrets);
-      if (missing.length > 0 && !process.env.CREW_CLAUDE_BIN) {
+      if (missing.length > 0) {
         throw new Error(
           `Runner credentials are not configured for this Ship \u2014 a captain must save the following in Ship Settings: ${missing.join(", ")}.`
         );
@@ -5006,7 +6080,8 @@ async function startDaemon() {
       if (slot.abort.signal.aborted) throw new Error("Stopped before the session started.");
       knownSecrets = [
         idToken,
-        secrets?.claudeToken,
+        // The engine's own values, named by the driver — the job loop knows no engine's key.
+        ...getDriver(engineId).secretValues(secrets),
         githubToken,
         // §15.31. BOTH the composed header value and the bare credential — see
         // `mcpSecretsToRedact` for why one of them is not enough.
@@ -5030,7 +6105,29 @@ async function startDaemon() {
         // swallows everything.
         onStep: (step2) => progress.push(step2)
       });
-      transcript = redactTranscript(session.transcript, knownSecrets);
+      transcript = redactTranscript(
+        session.transcript,
+        knownSecrets,
+        getDriver(engineId).secretPatterns
+      );
+      if (session.credentialLost) {
+        terminal = true;
+        log2(`Credential unusable on this machine: ${session.credentialLost}`);
+        const lostId = slot.credentialId;
+        if (lostId) {
+          void sess(shipId).user.getIdToken().then(
+            (idToken2) => reportLogin({
+              config: config2,
+              idToken: idToken2,
+              shipId,
+              credentialId: lostId,
+              report: { phase: "failed", error: session.credentialLost ?? "The sign-in is no longer usable." },
+              log: log2
+            })
+          ).catch(() => {
+          });
+        }
+      }
       usage = session.usage;
       if (session.limit && getEngine(engineId).usageWindows) {
         sessionLimit = session.limit;
@@ -5043,7 +6140,7 @@ async function startDaemon() {
         });
         armLimitTimer();
       }
-      resultText2 = session.resultText;
+      resultText3 = session.resultText;
       const failed = new Set(session.mcpFailed ?? []);
       mcpConnected = extraMcpServers.map((s) => s.key).filter((k) => !failed.has(k));
       if (!session.ok) failure = session.resultText || "Session failed.";
@@ -5068,7 +6165,7 @@ async function startDaemon() {
           // §15.41. A stopped run is the case that needs the backstop MOST: it was cut off
           // mid-thought, so it almost certainly never reached `run_report` — and whatever it had
           // got to is what the next run on this task would otherwise have to rediscover.
-          resultText: resultText2,
+          resultText: resultText3,
           mcpServers: mcpConnected
         });
         const by = slot.stop.by;
@@ -5118,7 +6215,7 @@ async function startDaemon() {
           transcriptPath,
           // §15.41. Only used when the session never called `run_report` — the ordinary path is
           // that it did, and a real report always wins inside the transaction.
-          resultText: resultText2,
+          resultText: resultText3,
           mcpServers: mcpConnected
         });
         log2(`Job ${job.id} done (${usage.inputTokens}in/${usage.outputTokens}out tokens).`);
@@ -5129,7 +6226,7 @@ async function startDaemon() {
               sess(shipId).fb.db,
               shipId,
               { ...job, chatId: target.chatId },
-              resultText2
+              resultText3
             );
             if (delivery === "posted-final-text") {
               log2(
@@ -5150,6 +6247,13 @@ async function startDaemon() {
           "Crew job finished",
           target.kind === "task" ? `Task ${target.taskId} is done.` : delivery === "agent-replied" ? "Agent replied in a chat." : "Agent finished a chat run without replying \u2014 its answer was posted for it."
         );
+      } else if (misrouted) {
+        const held = noteTransientRelease(claimBackoff, job.id, Date.now());
+        await releaseJob(sess(shipId).fb.db, shipId, job, `Not this machine's job: ${failure.slice(0, 160)}`);
+        armBackoffTimer();
+        log2(
+          `Job ${job.id} released \u2014 ${failure.slice(0, 160)} Attempt ${job.attempt} preserved; not re-claiming it here for ${Math.round((held.eligibleAt - Date.now()) / 1e3)}s.`
+        );
       } else if (transient) {
         const held = noteTransientRelease(claimBackoff, job.id, Date.now());
         await releaseJob(
@@ -5175,7 +6279,7 @@ async function startDaemon() {
           // §15.41. A failed run still did work, and the retry — or the next run after the retry
           // is spent — starts from the context pack alone. `error` is the tail for a human; this
           // is the continuity for the next session, and they are read by different readers.
-          resultText: resultText2,
+          resultText: resultText3,
           mcpServers: mcpConnected
         });
         if (target.kind === "chat") {
@@ -5209,6 +6313,7 @@ async function startDaemon() {
     if (limitTimer) clearTimeout(limitTimer);
     if (updateDrainTimer) clearTimeout(updateDrainTimer);
     for (const shipUnsubs of unsubsByShip.values()) shipUnsubs.forEach((u) => u());
+    for (const abort of loginsInFlight.values()) abort.abort();
     const inFlight = [...running.values()];
     if (inFlight.length > 0) {
       log2(
@@ -5387,8 +6492,8 @@ async function startDaemon() {
 import * as clack from "@clack/prompts";
 import { createColors } from "picocolors";
 var CliError = class extends Error {
-  constructor(message2, exitCode = 1) {
-    super(message2);
+  constructor(message3, exitCode = 1) {
+    super(message3);
     this.exitCode = exitCode;
     this.name = "CliError";
   }
@@ -5433,30 +6538,30 @@ var say = {
   intro(title) {
     if (!jsonMode) clack.intro(pc.bgCyan(pc.black(` ${title} `)));
   },
-  outro(message2) {
-    if (!jsonMode) clack.outro(message2);
+  outro(message3) {
+    if (!jsonMode) clack.outro(message3);
   },
-  info(message2) {
-    if (!jsonMode) clack.log.info(message2);
+  info(message3) {
+    if (!jsonMode) clack.log.info(message3);
   },
-  success(message2) {
-    if (!jsonMode) clack.log.success(message2);
+  success(message3) {
+    if (!jsonMode) clack.log.success(message3);
   },
-  warn(message2) {
-    if (!jsonMode) clack.log.warn(message2);
+  warn(message3) {
+    if (!jsonMode) clack.log.warn(message3);
   },
-  error(message2) {
-    if (!jsonMode) clack.log.error(message2);
+  error(message3) {
+    if (!jsonMode) clack.log.error(message3);
   },
-  step(message2) {
-    if (!jsonMode) clack.log.step(message2);
+  step(message3) {
+    if (!jsonMode) clack.log.step(message3);
   },
   note(body, title) {
     if (!jsonMode) clack.note(body, title);
   },
   /** Raw line straight to stdout — for `logs`, where the content IS the output. */
-  line(message2) {
-    process.stdout.write(`${message2}
+  line(message3) {
+    process.stdout.write(`${message3}
 `);
   }
 };
@@ -5716,8 +6821,8 @@ function setParallel(config2, value, ship2) {
 
 // src/cli/commands/doctor.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import fs7 from "node:fs";
-import path8 from "node:path";
+import fs10 from "node:fs";
+import path12 from "node:path";
 import { collection as collection9, doc as doc10, getDoc as getDoc9, getDocs as getDocs8 } from "firebase/firestore";
 
 // src/cli/session.ts
@@ -5793,7 +6898,7 @@ function serviceBinaryCheckFrom(input) {
   if (status.state === "not-installed" || status.state === "unsupported") return null;
   const pathValue = status.unitEnv?.PATH;
   if (pathValue === void 0) return null;
-  const relative = [...new Set(binaries)].filter((b) => !path8.isAbsolute(b));
+  const relative = [...new Set(binaries)].filter((b) => !path12.isAbsolute(b));
   if (relative.length === 0) return null;
   const missing = relative.filter((b) => !resolves(b, pathValue));
   const id = "service:path";
@@ -5809,10 +6914,10 @@ function serviceBinaryCheckFrom(input) {
   );
 }
 function resolvesOnPath(binary, pathValue) {
-  for (const dir of pathValue.split(path8.delimiter)) {
+  for (const dir of pathValue.split(path12.delimiter)) {
     if (!dir) continue;
     try {
-      fs7.accessSync(path8.join(dir, binary), fs7.constants.X_OK);
+      fs10.accessSync(path12.join(dir, binary), fs10.constants.X_OK);
       return true;
     } catch {
     }
@@ -5975,6 +7080,25 @@ async function checkShips(config2) {
         )
       );
     }
+    try {
+      const credentials = await loadShipCredentials(session.fb.db, shipId).catch(() => []);
+      for (const cred of credentials) {
+        if (!isMachineHeldCredential(cred) || cred.runnerId !== session.runnerId) continue;
+        if (!isMachineLoginEngine(cred.engine)) continue;
+        const driver = getDriver(cred.engine);
+        const login = driver.login;
+        if (!login) continue;
+        const home = engineCredentialHome(configDir(), cred.engine, shipId, cred.id);
+        const dirPresent = login.isSignedIn(home);
+        const statusExit = dirPresent ? spawnSync3(driver.binary(), login.statusArgs(), {
+          env: { ...process.env, ...login.env(home) },
+          stdio: "ignore",
+          timeout: 1e4
+        }).status ?? 1 : 1;
+        checks.push(machineCredentialCheckFrom(shipId, cred, { dirPresent, statusExit }));
+      }
+    } catch {
+    }
     try {
       const snap = await getDocs8(
         collection9(session.fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.mcpServers)
@@ -5989,6 +7113,35 @@ async function checkShips(config2) {
   }
   return { checks, engines, needsGithub };
 }
+function machineCredentialCheckFrom(shipId, cred, facts) {
+  const id = `login:${shipId}:${cred.id}`;
+  const label = `Ship ${shipId} \u2014 sign-in "${cred.label}"`;
+  if (cred.status && cred.status !== "ready") {
+    return warn(
+      id,
+      label,
+      `The sign-in is ${cred.status.replace("-", " ")}.`,
+      cred.status === "failed" || cred.status === "expired" ? "Retry it in Ship Settings \u2192 AI credentials." : "Finish it in Ship Settings \u2192 AI credentials."
+    );
+  }
+  if (!facts.dirPresent) {
+    return fail(
+      id,
+      label,
+      "This machine no longer holds the sign-in.",
+      "Delete the credential in Ship Settings \u2192 AI credentials and add it again from this machine."
+    );
+  }
+  if (facts.statusExit !== 0) {
+    return fail(
+      id,
+      label,
+      "The engine no longer accepts the stored sign-in.",
+      "Delete the credential in Ship Settings \u2192 AI credentials and add it again from this machine."
+    );
+  }
+  return ok(id, label, `Signed in${cred.account?.email ? ` as ${cred.account.email}` : ""}.`);
+}
 async function runDoctor() {
   const checks = [checkNode()];
   const config2 = loadConfig();
@@ -6079,8 +7232,8 @@ function report2(checks) {
 }
 
 // src/cli/commands/login.ts
-import { spawn as spawn6 } from "node:child_process";
-import os5 from "node:os";
+import { spawn as spawn7 } from "node:child_process";
+import os6 from "node:os";
 import { signInWithCustomToken as signInWithCustomToken2 } from "firebase/auth";
 function buildLoginResult(approved, existing, fallbackProjectId, mcpUrl2) {
   const approvedShips = approved.approvedShips ?? Object.keys(approved.shipKeys ?? {});
@@ -6121,7 +7274,7 @@ function buildLoginResult(approved, existing, fallbackProjectId, mcpUrl2) {
 function openBrowser(url) {
   const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
   try {
-    const child = spawn6(command, args, { stdio: "ignore", detached: true });
+    const child = spawn7(command, args, { stdio: "ignore", detached: true });
     child.on("error", () => {
     });
     child.unref();
@@ -6140,7 +7293,7 @@ async function loginWithDeviceFlow(options) {
   const baseUrl = functionsBaseUrlFor(projectId);
   const candidates = existingConfig ? configRunnerIdentities(existingConfig).map((i) => i.runnerId) : [];
   const start = await callPublicFunction(baseUrl, "crewRunnerAuth", "startRunnerLogin", {
-    hostname: os5.hostname(),
+    hostname: os6.hostname(),
     // The singular field stays, always: it is what an older deployment reads, and dropping it
     // would silently turn every re-login into a new enrolment for the length of a rollout.
     ...existingConfig?.runnerId ? { runnerId: existingConfig.runnerId } : {},
@@ -6389,20 +7542,20 @@ async function runServiceStatus() {
 }
 
 // src/cli/commands/uninstall.ts
-import fs8 from "node:fs";
+import fs11 from "node:fs";
 async function runUninstall(options) {
   const before = serviceStatus();
   const dir = configDir();
   const hadService = before.state !== "not-installed" && before.state !== "unsupported";
   if (hadService) uninstallService();
   let purged = false;
-  if (options.purge && fs8.existsSync(dir)) {
+  if (options.purge && fs11.existsSync(dir)) {
     const confirmed = await promptConfirm({
       message: `Delete ${dir}? This machine loses its identity \u2014 a captain has to approve it again after reinstalling.`,
       initialValue: false
     });
     if (confirmed) {
-      fs8.rmSync(dir, { recursive: true, force: true });
+      fs11.rmSync(dir, { recursive: true, force: true });
       purged = true;
     }
   }
@@ -6834,10 +7987,10 @@ function action(handler) {
     try {
       process.exitCode = await handler(...args);
     } catch (error) {
-      const message2 = error instanceof Error ? error.message : String(error);
-      if (isJson()) process.stderr.write(`${JSON.stringify({ error: message2 })}
+      const message3 = error instanceof Error ? error.message : String(error);
+      if (isJson()) process.stderr.write(`${JSON.stringify({ error: message3 })}
 `);
-      else say.error(message2);
+      else say.error(message3);
       process.exitCode = error instanceof CliError ? error.exitCode : 1;
     } finally {
       await closeFirebase();