@kal-elsam/kairo-runtime 0.15.0 → 0.17.0

package/src/global/observability/opencode-models.js

@@ -0,0 +1,101 @@
+import { spawn as defaultSpawn } from "node:child_process";
+
+// Real per-provider model catalog via `opencode models <provider> --verbose`
+// — covers both OpenCode Go (provider "opencode-go") and OpenCode Zen
+// (provider "opencode"), the two providers Kairo actually routes through.
+// Same fail-closed contract as codex-models.js: any spawn/parse error or
+// empty catalog yields `unknown`, never a fabricated model list.
+const DEFAULT_TIMEOUT_MS = 8_000;
+
+function unknown(provider, error = null) {
+  return { status: "unknown", source: `opencode models ${provider} --verbose`, provider, models: [], error: error ? String(error) : null };
+}
+
+/**
+ * Parses `opencode models <provider> --verbose` output: a "provider/model"
+ * header line followed by a pretty-printed JSON object, repeated per model.
+ * Strips the header lines and brace-matches the remaining text into
+ * complete JSON objects — robust to the exact indentation/whitespace the
+ * CLI uses, since it never assumes a fixed line count per model.
+ */
+export function parseOpenCodeModelsVerbose(text) {
+  const lines = String(text ?? "").split("\n");
+  const jsonText = lines.filter((line) => !/^[\w.-]+\/[\w.-]+$/.test(line.trim())).join("\n");
+  const models = [];
+  let depth = 0;
+  let start = -1;
+  for (let i = 0; i < jsonText.length; i += 1) {
+    const char = jsonText[i];
+    if (char === "{") {
+      if (depth === 0) start = i;
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0 && start !== -1) {
+        try { models.push(JSON.parse(jsonText.slice(start, i + 1))); } catch { /* skip an unparseable entry, don't fail the whole catalog */ }
+        start = -1;
+      }
+    }
+  }
+  return models;
+}
+
+function normalizeModel(entry) {
+  return {
+    id: entry.id,
+    providerID: entry.providerID,
+    displayName: entry.name ?? entry.id,
+    status: entry.status ?? "unknown",
+    costInputPerMTok: entry.cost?.input ?? null,
+    costOutputPerMTok: entry.cost?.output ?? null,
+    contextWindow: entry.limit?.context ?? null,
+    maxOutput: entry.limit?.output ?? null,
+    supportsReasoning: entry.capabilities?.reasoning === true,
+    supportsToolCall: entry.capabilities?.toolcall === true
+  };
+}
+
+/**
+ * Reads the real, currently-listed model catalog for one OpenCode provider
+ * ("opencode-go" or "opencode" for Zen). Requires the `opencode` CLI to be
+ * installed and authenticated — same as the rest of the OpenCode adapter.
+ */
+export async function readOpenCodeModels({
+  provider,
+  spawn = defaultSpawn,
+  cwd = process.cwd(),
+  env = process.env,
+  timeoutMs = DEFAULT_TIMEOUT_MS
+} = {}) {
+  if (!provider) return unknown("unknown", "provider is required");
+
+  let child;
+  try {
+    child = spawn("opencode", ["models", provider, "--verbose"], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+  } catch (error) {
+    return unknown(provider, error?.message ?? error);
+  }
+
+  return new Promise((resolve) => {
+    let stdout = "";
+    let finished = false;
+    const timer = setTimeout(() => finish(unknown(provider, "opencode models timed out")), timeoutMs);
+
+    function finish(result) {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      try { child.kill?.(); } catch { /* best effort */ }
+      resolve(result);
+    }
+
+    child.stdout?.on("data", (chunk) => { stdout += chunk; });
+    child.once?.("error", (error) => finish(unknown(provider, error?.message ?? error)));
+    child.once?.("close", (code) => {
+      if (code !== 0 && !stdout.trim()) return finish(unknown(provider, `opencode models exited with code ${code}`));
+      const models = parseOpenCodeModelsVerbose(stdout).map(normalizeModel);
+      if (models.length === 0) return finish(unknown(provider, "no models parsed"));
+      finish({ status: "measured", source: `opencode models ${provider} --verbose`, provider, models, error: null });
+    });
+  });
+}

package/src/global/observability/opencode-usage.js

@@ -0,0 +1,162 @@
+import { spawn as defaultSpawn } from "node:child_process";
+import { join } from "node:path";
+import { resolveHomeDir } from "../paths.js";
+
+const GO_URL = "https://opencode.ai/zen/go/v1/usage";
+const DEFAULT_TIMEOUT_MS = 4000;
+// `opencode stats` scans local session history and can take several seconds on
+// larger databases. It runs at most once per five-minute cache window.
+const STATS_TIMEOUT_MS = 20_000;
+
+function unknown(error = null, source = "opencode usage") {
+  return { status: "unknown", source, windows: [], error: error ? String(error).replace(/(key|token|secret|authorization)[^\s]*/ig, "$1=[redacted]") : null };
+}
+
+function clamp(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.max(0, Math.min(100, n)) : null;
+}
+
+export function normalizeOpenCodeGoUsage(payload) {
+  const usage = payload?.usage;
+  if (!usage || typeof usage !== "object") return null;
+  const windows = [];
+  for (const [name, value] of Object.entries(usage)) {
+    const percent = clamp(value?.percent);
+    if (percent == null) continue;
+    windows.push({
+      name,
+      usedPercent: percent,
+      remainingPercent: 100 - percent,
+      resetsAt: typeof value.resetsAt === "string" ? value.resetsAt : null,
+      status: value.status === "rate-limited" ? "rate-limited" : "ok"
+    });
+  }
+  if (!windows.length) return null;
+  return {
+    status: windows.some((window) => window.status === "rate-limited") ? "rate-limited" : "measured",
+    source: GO_URL,
+    windows,
+    primary: windows.find((window) => window.name === "rolling") ?? null,
+    secondary: windows.find((window) => window.name === "weekly") ?? null,
+    monthly: windows.find((window) => window.name === "monthly") ?? null
+  };
+}
+
+async function readGoUsage({ readFile, fetchImpl = globalThis.fetch, authPath, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  let auth;
+  try { auth = JSON.parse(await readFile(authPath, "utf8")); } catch (error) { return unknown(error?.code === "ENOENT" ? "OpenCode Go auth not found" : "invalid OpenCode auth", GO_URL); }
+  const credential = auth?.["opencode-go"] ?? (auth?.type === "api" ? auth : null);
+  const key = credential?.type === "api" && typeof credential.key === "string" ? credential.key : null;
+  if (!key) return unknown("OpenCode Go credential unavailable", GO_URL);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(GO_URL, { method: "GET", headers: { Authorization: `Bearer ${key}` }, signal: controller.signal });
+    if (!response?.ok) return unknown(`OpenCode Go usage HTTP ${response?.status ?? "error"}`, GO_URL);
+    const parsed = await response.json();
+    return normalizeOpenCodeGoUsage(parsed) ?? unknown("unusable OpenCode Go usage", GO_URL);
+  } catch (error) { return unknown(error?.name === "AbortError" ? "OpenCode Go usage timeout" : "OpenCode Go usage request failed", GO_URL); }
+  finally { clearTimeout(timer); }
+}
+
+/** Parse only rows explicitly belonging to OpenCode providers; this is local history, not billing. */
+export function parseOpenCodeStats(text) {
+  const stripAnsi = (value) => String(value).replace(/\x1b\[[0-?]*[ -\/]*[@-~]/g, "");
+  const parseAmount = (value) => {
+    const match = String(value).replace(/,/g, "").match(/([\d.]+)\s*([KMB])?/i);
+    if (!match) return null;
+    const multiplier = { K: 1e3, M: 1e6, B: 1e9 }[String(match[2] ?? "").toUpperCase()] ?? 1;
+    return Number(match[1]) * multiplier;
+  };
+  const records = [];
+  let current = null;
+  const push = () => {
+    if (!current) return;
+    current.tokens = (current.inputTokens ?? 0) + (current.outputTokens ?? 0)
+      + (current.cacheRead ?? 0) + (current.cacheWrite ?? 0) || null;
+    if (current.cost != null || current.tokens != null) records.push(current);
+    current = null;
+  };
+  for (const rawLine of String(text ?? "").split(/\r?\n/)) {
+    const line = stripAnsi(rawLine);
+    const model = line.match(/(?:│|\|)?\s*((?:opencode-go|opencode)\/[^\s│|]+)/i)?.[1];
+    if (model) {
+      push();
+      current = { model, provider: model.startsWith("opencode-go/") ? "opencode-go" : "opencode", cost: null, inputTokens: null, outputTokens: null, cacheRead: null, cacheWrite: null };
+      continue;
+    }
+    if (!current) continue;
+    const input = line.match(/Input Tokens\s+([\d.,]+\s*[KMB]?)/i)?.[1];
+    const output = line.match(/Output Tokens\s+([\d.,]+\s*[KMB]?)/i)?.[1];
+    const cost = line.match(/Cost\s+\$\s*([\d.,]+\s*[KMB]?)/i)?.[1];
+    if (input) current.inputTokens = parseAmount(input);
+    if (output) current.outputTokens = parseAmount(output);
+    const cacheRead = line.match(/Cache Read\s+([\d.,]+\s*[KMB]?)/i)?.[1];
+    const cacheWrite = line.match(/Cache Write\s+([\d.,]+\s*[KMB]?)/i)?.[1];
+    if (cacheRead) current.cacheRead = parseAmount(cacheRead);
+    if (cacheWrite) current.cacheWrite = parseAmount(cacheWrite);
+    if (cost) current.cost = parseAmount(cost);
+  }
+  push();
+  const zenRecords = records.filter((record) => record.provider === "opencode");
+  if (!zenRecords.length) return null;
+  return {
+    status: "local_recorded",
+    source: "opencode stats --days 7 --models",
+    billing: "PAYG",
+    balance: "unknown",
+    autoReload: "unknown",
+    kairoPolicy: "PAYG blocked",
+    days: 7,
+    records: zenRecords,
+    goRecords: records.filter((record) => record.provider === "opencode-go"),
+    totalCost: zenRecords.reduce((sum, record) => sum + (record.cost ?? 0), 0),
+    totalTokens: zenRecords.reduce((sum, record) => sum + (record.tokens ?? 0), 0)
+  };
+}
+
+function readStats({ spawn = defaultSpawn, timeoutMs = STATS_TIMEOUT_MS } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try { child = spawn("opencode", ["stats", "--days", "7", "--models"], { stdio: ["ignore", "pipe", "pipe"] }); }
+    catch { resolve(unknown("OpenCode stats unavailable", "opencode stats --days 7 --models")); return; }
+    let output = "";
+    let settled = false;
+    const timer = setTimeout(() => finish(unknown("OpenCode stats timeout", "opencode stats --days 7 --models")), timeoutMs);
+    const finish = (value) => { if (settled) return; settled = true; clearTimeout(timer); try { child.kill?.(); } catch {} resolve(value); };
+    child.stdout?.on("data", (chunk) => { output += String(chunk).slice(0, 100_000 - output.length); });
+    child.once?.("error", () => finish(unknown("OpenCode stats failed", "opencode stats --days 7 --models")));
+    child.once?.("close", () => finish(parseOpenCodeStats(output) ?? unknown("unparseable OpenCode stats", "opencode stats --days 7 --models")));
+  });
+}
+
+export async function readOpenCodeGoUsage({
+  readFile = (path, encoding) => import("node:fs/promises").then((fs) => fs.readFile(path, encoding)),
+  fetchImpl = globalThis.fetch,
+  homeDir = resolveHomeDir(),
+  authPath = join(homeDir, ".local/share/opencode/auth.json"),
+  timeoutMs = DEFAULT_TIMEOUT_MS
+} = {}) {
+  return readGoUsage({ readFile, fetchImpl, authPath, timeoutMs });
+}
+
+export async function readOpenCodeStats({ spawn = defaultSpawn, timeoutMs = STATS_TIMEOUT_MS } = {}) {
+  return readStats({ spawn, timeoutMs });
+}
+
+export async function readOpenCodeUsage({
+  readFile = (path, encoding) => import("node:fs/promises").then((fs) => fs.readFile(path, encoding)),
+  fetchImpl = globalThis.fetch,
+  spawn = defaultSpawn,
+  homeDir = resolveHomeDir(),
+  authPath = join(homeDir, ".local/share/opencode/auth.json"),
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  statsTimeoutMs = STATS_TIMEOUT_MS
+} = {}) {
+  const [go, zen] = await Promise.all([
+    readOpenCodeGoUsage({ readFile, fetchImpl, authPath, homeDir, timeoutMs }),
+    readOpenCodeStats({ spawn, timeoutMs: statsTimeoutMs })
+  ]);
+  return { go, zen };
+}

package/src/global/paths.js

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { isAbsolute, join, relative } from "node:path";
 
 export const HARNESS_DIR_NAME = ".harness";
 
@@ -24,7 +24,11 @@ export function harnessHomePaths(homeDir) {
     monitorStatePath: join(root, "monitor", "state.json"),
     coreDir: join(root, "core"),
     backupsDir: join(root, "backups"),
-    sessionsDir: join(root, "sessions")
+    sessionsDir: join(root, "sessions"),
+    worktreesDir: join(root, "worktrees"),
+    usageDir: join(root, "usage"),
+    modelIntelligencePath: join(root, "model-intelligence.json"),
+    huggingfaceLeaderboardPath: join(root, "huggingface-leaderboard.json")
   };
 }
 
@@ -39,3 +43,46 @@ export function runPaths(homeDir, runId) {
     transcriptPath: join(runDir, "transcript.jsonl")
   };
 }
+
+/**
+ * The exact shape createWorktreeId() (execution-worktree-types.js)
+ * produces — `wt_` plus two base36 segments. Enforced here, at the one
+ * real boundary every worktree path gets built from, rather than trusted
+ * by each caller separately: an unvalidated id (e.g. "../../escape")
+ * would otherwise let `join()` resolve outside worktreesDir entirely.
+ */
+export function assertWorktreeId(worktreeId) {
+  if (typeof worktreeId !== "string" || !/^wt_[a-z0-9]{1,20}_[a-z0-9]{1,20}$/.test(worktreeId)) {
+    throw new Error(`Invalid worktree id "${worktreeId ?? ""}".`);
+  }
+  return worktreeId;
+}
+
+/**
+ * Every real path an execution worktree needs — the real checked-out git
+ * worktree itself (`treePath`, never the project's own directory) plus its
+ * own metadata, all scoped under this one worktreeDir so a single
+ * `rm -rf` (see execution-worktree-manager.js's rollback) fully undoes an
+ * incomplete creation. `worktreeId` is validated here, the one real
+ * boundary every consumer of this function goes through — never trusted
+ * or re-validated ad hoc by callers.
+ */
+export function worktreePaths(homeDir, worktreeId) {
+  assertWorktreeId(worktreeId);
+  const { worktreesDir } = harnessHomePaths(homeDir);
+  const worktreeDir = join(worktreesDir, worktreeId);
+  // Defense in depth alongside the regex above — the same real containment
+  // check architect-store.js's taskPaths already applies to task ids.
+  const rel = relative(worktreesDir, worktreeDir);
+  const isInside = rel !== "" && !isAbsolute(rel) && rel !== ".." && !rel.startsWith("../");
+  if (!isInside) {
+    throw new Error(`Worktree path escapes worktreesDir for id "${worktreeId}".`);
+  }
+
+  return {
+    worktreeDir,
+    treePath: join(worktreeDir, "tree"),
+    statePath: join(worktreeDir, "state.json"),
+    checkpointsPath: join(worktreeDir, "checkpoints.jsonl")
+  };
+}

package/src/global/profile.js

@@ -5,6 +5,7 @@ import { harnessHomePaths } from "./paths.js";
 import { AGENT_CAPABILITY_IDS } from "./agent-capabilities/index.js";
 import { classifyCustomBaseUrl, isValidEnvironmentName } from "./intelligence/custom-url.js";
 import { validateRuntimeProfile, RUNTIME_PROFILE_KEYS } from "./runtime/run-profile.js";
+import { EXECUTION_ADAPTER_IDS } from "./runtime/execution-adapters/index.js";
 
 export const PROFILE_KEYS = new Set([
   "coordinator",
@@ -17,6 +18,7 @@ export const PROFILE_KEYS = new Set([
   "tokenBudget",
   "stableContextBudget",
   "requestContextBudget",
+  "providerTokenBudgets",
   "customProviders",
   ...RUNTIME_PROFILE_KEYS
 ]);
@@ -32,6 +34,7 @@ export const DEFAULT_PROFILE = {
   tokenBudget: null,
   stableContextBudget: null,
   requestContextBudget: null,
+  providerTokenBudgets: {},
   customProviders: [],
   agentAliases: {},
   modelAliases: {},
@@ -112,6 +115,7 @@ export function buildProfileJson(resolved) {
     tokenBudget: profile.tokenBudget,
     stableContextBudget: profile.stableContextBudget,
     requestContextBudget: profile.requestContextBudget,
+    providerTokenBudgets: profile.providerTokenBudgets ?? {},
     customProviders: sanitizeCustomProviders(profile.customProviders),
     agentAliases: profile.agentAliases ?? {},
     modelAliases: profile.modelAliases ?? {},
@@ -191,6 +195,8 @@ function validateProfile(profile) {
     }
   }
 
+  validateProviderTokenBudgets(profile.providerTokenBudgets);
+
   if (profile.preferredBackend != null && typeof profile.preferredBackend !== "string") {
     throw new Error("Profile preferredBackend must be a string or null.");
   }
@@ -213,7 +219,8 @@ const SECRET_KEY_ALLOWLIST = new Set([
   "api_key_env",
   "token_budget",
   "stable_context_budget",
-  "request_context_budget"
+  "request_context_budget",
+  "provider_token_budgets"
 ]);
 const SECRET_VALUE_PATTERN = /^(sk-[A-Za-z0-9]|sk-or-|gh[pousr]_|xox[baprs]-|AKIA[0-9A-Z]{16}\b|Bearer\s+\S+|eyJ[A-Za-z0-9_-]+\.)|-----BEGIN [A-Z ]*PRIVATE KEY-----/i;
 
@@ -265,6 +272,21 @@ function walkForSecrets(value) {
   }
 }
 
+function validateProviderTokenBudgets(budgets) {
+  if (budgets == null) return;
+  if (typeof budgets !== "object" || Array.isArray(budgets)) {
+    throw new Error("Profile providerTokenBudgets must be an object mapping provider id to a positive number.");
+  }
+  for (const [provider, budget] of Object.entries(budgets)) {
+    if (!EXECUTION_ADAPTER_IDS.includes(provider)) {
+      throw new Error(`Unknown provider "${provider}" in providerTokenBudgets. Use ${EXECUTION_ADAPTER_IDS.join(", ")}.`);
+    }
+    if (!Number.isFinite(budget) || budget < 1) {
+      throw new Error(`Profile providerTokenBudgets.${provider} must be a positive number.`);
+    }
+  }
+}
+
 function validateCustomProviders(providers) {
   if (providers == null) return;
   if (!Array.isArray(providers)) {

package/src/global/runtime/execution-adapters/claude.js

@@ -1,40 +1,77 @@
 import { createExecutionAdapter, parseNdjsonLine, buildPermissionsArgs } from "./create-execution-adapter.js";
+import {
+  ReviewExecError, assertBoundedProcessOk, runBoundedProcess
+} from "../review/review-exec.js";
 
 const EXECUTABLE = "claude";
+const AUTH_TIMEOUT_MS = 10_000;
+const AUTH_OUTPUT_LIMIT = 16_384;
+const SAFE_ENV_KEYS = Object.freeze([
+  "PATH", "HOME", "USER", "LOGNAME", "SHELL", "LANG", "LC_ALL", "LC_CTYPE",
+  "TMPDIR", "TERM", "CLAUDE_CONFIG_DIR", "HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY",
+  "http_proxy", "https_proxy", "no_proxy", "NODE_EXTRA_CA_CERTS"
+]);
+const SUBSCRIPTION_TYPE = /^(?:pro|max|team|enterprise)(?:[-_ ].*)?$/i;
 
-function buildClaudeLaunch({ task, cwd, model, permissions = [] }) {
-  const args = [
-    "-p",
-    "--output-format",
-    "stream-json",
-    ...buildPermissionsArgs(permissions),
-    task
-  ];
+export const CLAUDE_AUTH_ERRORS = Object.freeze({
+  SUBSCRIPTION_REQUIRED: "claude_subscription_required",
+  INVALID_STATUS: "claude_auth_status_invalid"
+});
 
-  if (model) {
-    args.unshift("--model", model);
+export function buildClaudeExecutionEnv(sourceEnv = process.env) {
+  const env = Object.create(null);
+  for (const key of SAFE_ENV_KEYS) {
+    if (sourceEnv[key] != null && sourceEnv[key] !== "") env[key] = sourceEnv[key];
   }
+  return env;
+}
 
-  return {
+export async function verifyClaudeSubscriptionAuth({
+  env = process.env, runProcess = runBoundedProcess
+} = {}) {
+  const result = await runProcess({
     command: EXECUTABLE,
-    args,
-    cwd,
-    env: process.env
-  };
+    args: ["auth", "status"],
+    env: buildClaudeExecutionEnv(env),
+    stdin: null,
+    timeoutMs: AUTH_TIMEOUT_MS,
+    stdoutLimit: AUTH_OUTPUT_LIMIT,
+    stderrLimit: AUTH_OUTPUT_LIMIT
+  });
+  assertBoundedProcessOk(result);
+  let status;
+  try { status = JSON.parse(String(result.stdout ?? "").trim()); }
+  catch {
+    throw new ReviewExecError("Claude auth status did not return valid JSON.", {
+      code: CLAUDE_AUTH_ERRORS.INVALID_STATUS
+    });
+  }
+  if (status?.loggedIn !== true || status?.authMethod !== "claude.ai"
+    || status?.apiProvider !== "firstParty" || !SUBSCRIPTION_TYPE.test(status?.subscriptionType ?? "")) {
+    throw new ReviewExecError(
+      "Claude execution requires a first-party claude.ai Pro, Max, Team, or Enterprise subscription.",
+      { code: CLAUDE_AUTH_ERRORS.SUBSCRIPTION_REQUIRED }
+    );
+  }
+  return { mode: "subscription", subscriptionType: status.subscriptionType };
+}
+
+export function buildClaudeLaunch({ task, cwd, model, permissions = [], env = process.env }) {
+  const unsafeArgs = buildPermissionsArgs(permissions);
+  const permissionArgs = unsafeArgs.length > 0
+    ? unsafeArgs
+    : ["--permission-mode", "auto", "--permission-prompts", "none"];
+  const args = ["-p", "--output-format", "stream-json", ...permissionArgs, task];
+  if (model) args.unshift("--model", model);
+  return { command: EXECUTABLE, args, cwd, env: buildClaudeExecutionEnv(env) };
 }
 
 function parseClaudeEventLine(line) {
   const parsed = parseNdjsonLine(line);
   if (!parsed || typeof parsed !== "object") return null;
-
   if (parsed.type === "tool_use" || parsed.type === "tool_call") {
-    return {
-      type: "tool_call",
-      tool_name: parsed.name ?? parsed.tool ?? "unknown",
-      status: parsed.status ?? "started"
-    };
+    return { type: "tool_call", tool_name: parsed.name ?? parsed.tool ?? "unknown", status: parsed.status ?? "started" };
   }
-
   if (parsed.type === "usage" || parsed.usage) {
     const usage = parsed.usage ?? parsed;
     return {
@@ -45,7 +82,6 @@ function parseClaudeEventLine(line) {
       cost: usage.cost ?? null
     };
   }
-
   return parsed;
 }
 
@@ -54,13 +90,10 @@ export default createExecutionAdapter({
   label: "Claude Code",
   executable: EXECUTABLE,
   capabilities: {
-    structuredEvents: true,
-    tokens: true,
-    diff: false,
-    cancel: true,
-    transcript: true,
-    permissionModes: ["force", "yolo"]
+    structuredEvents: true, tokens: true, diff: false, cancel: true, transcript: true,
+    permissionModes: ["safe", "force", "yolo"]
   },
   buildLaunch: buildClaudeLaunch,
-  parseEventLine: parseClaudeEventLine
+  parseEventLine: parseClaudeEventLine,
+  preflight: verifyClaudeSubscriptionAuth
 });

package/src/global/runtime/execution-adapters/codex.js

@@ -1,4 +1,5 @@
 import { createExecutionAdapter, parseNdjsonLine } from "./create-execution-adapter.js";
+import { verifyCodexSubscriptionAuth } from "../../architect/architect-codex.js";
 
 const EXECUTABLE = "codex";
 
@@ -13,7 +14,12 @@ function buildCodexPermissionsArgs(permissions = []) {
     return ["--dangerously-bypass-approvals-and-sandbox"];
   }
 
-  return [];
+  // Safe headless default: sandboxed to the workspace, with approval
+  // requests auto-reviewed instead of blocking forever on a human who
+  // can't respond in a non-interactive run — mirrors claude.js's
+  // `--permission-mode auto --permission-prompts none`. Without this,
+  // `codex exec` hangs on its default on-request approval policy.
+  return ["--sandbox", "workspace-write", "--approve-for-me"];
 }
 
 function buildCodexLaunch({ task, cwd, model, permissions = [] }) {
@@ -76,5 +82,6 @@ export default createExecutionAdapter({
     permissionModes: ["yolo"]
   },
   buildLaunch: buildCodexLaunch,
-  parseEventLine: parseCodexEventLine
+  parseEventLine: parseCodexEventLine,
+  preflight: verifyCodexSubscriptionAuth
 });

package/src/global/runtime/execution-adapters/create-execution-adapter.js

@@ -11,7 +11,8 @@ export function createExecutionAdapter({
   buildLaunch,
   parseEventLine = null,
   checkAvailability = null,
-  launchable = null
+  launchable = null,
+  preflight = null
 }) {
   return {
     id,
@@ -63,6 +64,10 @@ export function createExecutionAdapter({
       return buildLaunch(options);
     },
 
+    async preflight(context = {}) {
+      return preflight ? preflight(context) : { ok: true };
+    },
+
     parseEventLine(line, context = {}) {
       if (!parseEventLine) return null;
       return parseEventLine(line, context);