@tokenfactory/acc-runner 0.29.4 → 0.33.0

package/dist/engines/claude-code.js

@@ -0,0 +1,95 @@
+/**
+ * M2 (ENGINE-EXTRACT): the `claude-code` engine — the only entry in the Wave 1
+ * registry and the default. Its methods are lifted VERBATIM from the inline
+ * logic that used to live in task-runner.ts (`buildClaudeArgs`,
+ * `defaultSpawnClaude`, `defaultHealthProbe`) and reviewer.ts
+ * (`defaultSpawnClaude`), plus the shared `classifyClaudeExit` /
+ * `parseClaudeJson` calls. Output is byte-identical to pre-refactor — the
+ * golden tests in tests/engines-claude-code.test.ts lock that.
+ */
+import { execa } from "execa";
+import { withAnthropicAuth } from "../provider-auth.js";
+import { classifyClaudeExit } from "../failure-classifier.js";
+import { parseClaudeJson } from "../cost-pricing.js";
+const BINARY = "claude";
+/**
+ * v0.6.0 REG-296: build the argv for `claude --print`. modelId is forwarded as
+ * `--model <id>` when non-empty (whitespace counts as empty); otherwise omitted
+ * so claude uses the operator's default model.
+ */
+export function buildClaudeArgs(modelId) {
+    const args = ["--print", "--dangerously-skip-permissions", "--output-format=json"];
+    const trimmed = (modelId ?? "").trim();
+    if (trimmed)
+        args.push("--model", trimmed);
+    return args;
+}
+/** withAnthropicAuth forwards ANTHROPIC_API_KEY (trimmed) when set — see src/provider-auth.ts. */
+function claudeCodeEnv(base = process.env) {
+    return withAnthropicAuth(base);
+}
+function spawnClaudeCode(opts) {
+    // --dangerously-skip-permissions: bypass claude's per-edit approval prompts.
+    // The runner is non-interactive (no TTY for human approval) and the
+    // permission boundary is enforced one level up — see the "Runner sandbox"
+    // section in packages/acc-runner/README.md.
+    // --output-format=json: emit a structured object so we can parse the usage
+    // block for cost tracking. parseResult falls back to plain text when older
+    // claude versions emit markdown directly.
+    // --model: forwarded when the task pins a model (REG-296).
+    const { cwd, modelId, baseEnv } = opts;
+    return execa(BINARY, buildClaudeArgs(modelId), {
+        ...(cwd !== undefined ? { cwd } : {}),
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+        reject: false,
+        env: claudeCodeEnv(baseEnv),
+    });
+}
+/**
+ * v0.63 T-63-1: default claude health probe. A silent instant-empty exit is
+ * ambiguous — it can be a broken host OR a momentarily-unavailable claude.
+ * `claude --version` is a cheap, deterministic answer to "is the binary/host
+ * actually broken?": if it returns 0 the host is fine (the exit was transient
+ * → claude_unavailable, retry), and any spawn failure / non-zero exit / timeout
+ * means the binary or its dynamic deps are genuinely broken (→ env_broken,
+ * quarantine). Short timeout so a probe never wedges the run.
+ */
+async function claudeCodeHealthProbe() {
+    try {
+        const res = await execa(BINARY, ["--version"], {
+            reject: false,
+            timeout: 5_000,
+            env: process.env,
+        });
+        if (res.exitCode === 0) {
+            return { ok: true, detail: (res.stdout || "").trim().slice(0, 200) || "claude --version ok" };
+        }
+        return {
+            ok: false,
+            detail: `claude --version exited ${res.exitCode ?? "signal"}: ${(res.stderr || "").trim().slice(0, 200)}`,
+        };
+    }
+    catch (err) {
+        return { ok: false, detail: `claude --version spawn failed: ${err.message}` };
+    }
+}
+function classifyClaudeCodeFailure(exitCode, stderr, stdout, durationMs) {
+    return classifyClaudeExit(exitCode, stderr, stdout, durationMs);
+}
+function parseClaudeCodeResult(stdout) {
+    return parseClaudeJson(stdout);
+}
+export const claudeCodeEngine = {
+    id: "claude-code",
+    binary: BINARY,
+    authMode: "api-key-or-oauth",
+    buildArgs: buildClaudeArgs,
+    env: claudeCodeEnv,
+    spawn: spawnClaudeCode,
+    parseResult: parseClaudeCodeResult,
+    classifyFailure: classifyClaudeCodeFailure,
+    healthProbe: claudeCodeHealthProbe,
+};
+//# sourceMappingURL=claude-code.js.map

package/dist/engines/claude-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code.js","sourceRoot":"","sources":["../../src/engines/claude-code.ts"],"names":[],"mappings":"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"}

package/dist/engines/codex.d.ts

@@ -0,0 +1,27 @@
+import { type CodexAuthMode } from "../provider-auth.js";
+import type { AgentEngine } from "./types.js";
+/**
+ * Feature flag: `engines.codex_enabled`. DEFAULT OFF. Truthy env forms only
+ * ("1"/"true"/"yes"/"on"). Kept as an env read (config.ts is out of this
+ * track's scope) so the engine stays fully self-contained and dead-until-wired.
+ */
+export declare function codexEngineEnabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Build the argv for a headless one-shot `codex exec`. `--json` emits the
+ * structured event stream parseResult reads; the approvals/sandbox bypass is
+ * the codex analog of claude's `--dangerously-skip-permissions` — the runner is
+ * non-interactive and enforces the permission boundary one level up (worktree
+ * isolation + prepr-gate scope + zero-diff guard), so codex must not block on
+ * its own approval prompts. `--model <id>` is forwarded only when non-blank.
+ */
+export declare function buildCodexArgs(modelId?: string | null): string[];
+/**
+ * Resolve the auth channel a codex spawn should START in from the environment:
+ * `ACC_CODEX_AUTH_PREFERENCE` (`subscription_first` default) + whether an
+ * OPENAI_API_KEY is present. The subscription→api-key SPILL on a cap-hit is
+ * driven by the (M5) task-runner, which re-invokes env()/spawn() with the mode
+ * pinned to "api-key" — so this only decides the first attempt.
+ */
+export declare function resolveCodexSpawnMode(base?: NodeJS.ProcessEnv): CodexAuthMode;
+export declare const codexEngine: AgentEngine;
+//# sourceMappingURL=codex.d.ts.map

package/dist/engines/codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/engines/codex.ts"],"names":[],"mappings":"AAqBA,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,WAAW,EAAoC,MAAM,YAAY,CAAC;AAIhF;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAGhF;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,EAAE,CAKhE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,GAAE,MAAM,CAAC,UAAwB,GAAG,aAAa,CAG1F;AAiHD,eAAO,MAAM,WAAW,EAAE,WAUzB,CAAC"}

package/dist/engines/codex.js

@@ -0,0 +1,178 @@
+/**
+ * M4 (ENGINE-CODEX): the `codex` engine — the first non-Anthropic build
+ * engine, driving the OpenAI Codex CLI (`codex exec --json`). This is the
+ * HIGHEST-RISK track in the multi-model program: a mis-mapped OpenAI quota
+ * error would re-create the capacity pause-loop deadlock with a new provider
+ * (plan §0.1.5 / §3.3), so the failure classification (classifyCodexExit in
+ * failure-classifier.ts) is the P0 surface and is exhaustively fixture-tested.
+ *
+ * SHIPS FLAG-OFF. `codexEngineEnabled()` defaults false and the engine is NOT
+ * registered in engines/registry.ts, so the default fleet is byte-for-byte
+ * unaffected. Wiring the flag into the registry + the subscription→api-key
+ * spill orchestration is M5 (dispatch); this track only ships the engine, its
+ * classification, its auth resolution, and doctor validation.
+ *
+ * Flags/output are pinned to Codex CLI v0.44+; parseResult is deliberately
+ * TOLERANT (the v0.44 tolerant-parser lesson) so a point-release event-shape
+ * drift degrades to best-effort extraction rather than a hard failure.
+ */
+import { execa } from "execa";
+import { classifyCodexExit } from "../failure-classifier.js";
+import { openaiApiKey, resolveCodexAuthPreference, initialCodexAuthMode, withOpenAiAuth, } from "../provider-auth.js";
+const BINARY = "codex";
+/**
+ * Feature flag: `engines.codex_enabled`. DEFAULT OFF. Truthy env forms only
+ * ("1"/"true"/"yes"/"on"). Kept as an env read (config.ts is out of this
+ * track's scope) so the engine stays fully self-contained and dead-until-wired.
+ */
+export function codexEngineEnabled(env = process.env) {
+    const v = (env.ACC_ENGINE_CODEX_ENABLED ?? "").trim().toLowerCase();
+    return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+/**
+ * Build the argv for a headless one-shot `codex exec`. `--json` emits the
+ * structured event stream parseResult reads; the approvals/sandbox bypass is
+ * the codex analog of claude's `--dangerously-skip-permissions` — the runner is
+ * non-interactive and enforces the permission boundary one level up (worktree
+ * isolation + prepr-gate scope + zero-diff guard), so codex must not block on
+ * its own approval prompts. `--model <id>` is forwarded only when non-blank.
+ */
+export function buildCodexArgs(modelId) {
+    const args = ["exec", "--json", "--dangerously-bypass-approvals-and-sandbox"];
+    const trimmed = (modelId ?? "").trim();
+    if (trimmed)
+        args.push("--model", trimmed);
+    return args;
+}
+/**
+ * Resolve the auth channel a codex spawn should START in from the environment:
+ * `ACC_CODEX_AUTH_PREFERENCE` (`subscription_first` default) + whether an
+ * OPENAI_API_KEY is present. The subscription→api-key SPILL on a cap-hit is
+ * driven by the (M5) task-runner, which re-invokes env()/spawn() with the mode
+ * pinned to "api-key" — so this only decides the first attempt.
+ */
+export function resolveCodexSpawnMode(base = process.env) {
+    const preference = resolveCodexAuthPreference(base.ACC_CODEX_AUTH_PREFERENCE);
+    return initialCodexAuthMode(preference, openaiApiKey(base).length > 0);
+}
+/** Augment the env for the resolved (first-attempt) auth channel. */
+function codexEnv(base = process.env) {
+    return withOpenAiAuth(resolveCodexSpawnMode(base), base);
+}
+function spawnCodex(opts) {
+    const { cwd, modelId, baseEnv } = opts;
+    return execa(BINARY, buildCodexArgs(modelId), {
+        ...(cwd !== undefined ? { cwd } : {}),
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+        reject: false,
+        env: codexEnv(baseEnv),
+    });
+}
+function asRecord(v) {
+    return typeof v === "object" && v !== null ? v : null;
+}
+/** First non-empty string among `obj[key]` for the given candidate keys. */
+function pickString(obj, keys) {
+    for (const k of keys) {
+        const v = obj[k];
+        if (typeof v === "string" && v.trim())
+            return v;
+    }
+    return null;
+}
+/** Map a codex/OpenAI usage object onto the shared ClaudeUsage shape. */
+function pickUsage(obj) {
+    const u = asRecord(obj.usage);
+    if (!u)
+        return null;
+    const inTok = u.input_tokens ?? u.prompt_tokens;
+    const outTok = u.output_tokens ?? u.completion_tokens;
+    const usage = {};
+    if (typeof inTok === "number")
+        usage.input_tokens = inTok;
+    if (typeof outTok === "number")
+        usage.output_tokens = outTok;
+    return usage.input_tokens !== undefined || usage.output_tokens !== undefined ? usage : null;
+}
+/**
+ * Tolerant parse of `codex exec --json` output into the shared result envelope.
+ * Codex emits a JSONL event STREAM (unlike claude's single object), so we scan
+ * every parseable line and keep the LAST assistant-message text, model, and
+ * usage seen — the final turn's values. A single-object output (older/newer
+ * codex) is handled by the same scan. Returns null when nothing is parseable so
+ * the caller falls back to plain-text extraction, exactly like parseClaudeJson.
+ */
+function parseCodexResult(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        return null;
+    const out = {};
+    for (const line of trimmed.split(/\r?\n/)) {
+        const s = line.trim();
+        if (!s.startsWith("{"))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(s);
+        }
+        catch {
+            continue;
+        }
+        const obj = asRecord(parsed);
+        if (!obj)
+            continue;
+        // The message text can live at the top level or nested under item/msg/response.
+        const nested = asRecord(obj.item) ?? asRecord(obj.msg) ?? asRecord(obj.response);
+        const text = pickString(obj, ["result", "text", "message", "content"]) ??
+            (nested ? pickString(nested, ["text", "message", "content", "output_text"]) : null);
+        if (text)
+            out.result = text;
+        const model = pickString(obj, ["model"]) ?? (nested ? pickString(nested, ["model"]) : null);
+        if (model)
+            out.model = model;
+        const usage = pickUsage(obj) ?? (nested ? pickUsage(nested) : null);
+        if (usage)
+            out.usage = usage;
+    }
+    return out.result !== undefined || out.model !== undefined || out.usage !== undefined
+        ? out
+        : null;
+}
+function classifyCodexFailure(exitCode, stderr, stdout, durationMs) {
+    return classifyCodexExit(exitCode, stderr, stdout, durationMs);
+}
+/**
+ * Cheap health check: `codex --version`. Same contract as the claude probe —
+ * exit 0 means the binary/host is fine (a silent instant-empty exit was
+ * transient → engine_unavailable, retry), any spawn failure / non-zero exit /
+ * timeout means the binary or its deps are genuinely broken (→ env_broken).
+ */
+async function codexHealthProbe() {
+    try {
+        const res = await execa(BINARY, ["--version"], { reject: false, timeout: 5_000, env: process.env });
+        if (res.exitCode === 0) {
+            return { ok: true, detail: (res.stdout || "").trim().slice(0, 200) || "codex --version ok" };
+        }
+        return {
+            ok: false,
+            detail: `codex --version exited ${res.exitCode ?? "signal"}: ${(res.stderr || "").trim().slice(0, 200)}`,
+        };
+    }
+    catch (err) {
+        return { ok: false, detail: `codex --version spawn failed: ${err.message}` };
+    }
+}
+export const codexEngine = {
+    id: "codex",
+    binary: BINARY,
+    authMode: "api-key-or-subscription",
+    buildArgs: buildCodexArgs,
+    env: codexEnv,
+    spawn: spawnCodex,
+    parseResult: parseCodexResult,
+    classifyFailure: classifyCodexFailure,
+    healthProbe: codexHealthProbe,
+};
+//# sourceMappingURL=codex.js.map

package/dist/engines/codex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.js","sourceRoot":"","sources":["../../src/engines/codex.ts"],"names":[],"mappings":"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"}

package/dist/engines/registry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * M2 (ENGINE-EXTRACT): the engine registry keyed by id. Wave 1 registers a
+ * single engine — `claude-code` — which is also the default. `getEngine()`
+ * with no id (or a blank id) returns the default, so the existing call sites
+ * that never selected an engine keep their exact behavior.
+ */
+import type { AgentEngine } from "./types.js";
+/** The default engine id used when a caller does not pin one. */
+export declare const DEFAULT_ENGINE_ID: string;
+/**
+ * Resolve an engine by id. A null/blank id resolves to the default. Throws on
+ * an unknown id — no Wave 1 call site passes one, so this is a guard for
+ * future multi-engine wiring, never a live path.
+ */
+export declare function getEngine(id?: string | null): AgentEngine;
+export declare function hasEngine(id: string): boolean;
+export declare function engineIds(): string[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/engines/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/engines/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAO9C,iEAAiE;AACjE,eAAO,MAAM,iBAAiB,QAAsB,CAAC;AAErD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,WAAW,CAOzD;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,wBAAgB,SAAS,IAAI,MAAM,EAAE,CAEpC"}

package/dist/engines/registry.js

@@ -0,0 +1,26 @@
+import { claudeCodeEngine } from "./claude-code.js";
+const ENGINES = {
+    [claudeCodeEngine.id]: claudeCodeEngine,
+};
+/** The default engine id used when a caller does not pin one. */
+export const DEFAULT_ENGINE_ID = claudeCodeEngine.id;
+/**
+ * Resolve an engine by id. A null/blank id resolves to the default. Throws on
+ * an unknown id — no Wave 1 call site passes one, so this is a guard for
+ * future multi-engine wiring, never a live path.
+ */
+export function getEngine(id) {
+    const key = (id ?? "").trim() || DEFAULT_ENGINE_ID;
+    const engine = ENGINES[key];
+    if (!engine) {
+        throw new Error(`unknown agent engine: ${key} (known: ${Object.keys(ENGINES).join(", ")})`);
+    }
+    return engine;
+}
+export function hasEngine(id) {
+    return id in ENGINES;
+}
+export function engineIds() {
+    return Object.keys(ENGINES);
+}
+//# sourceMappingURL=registry.js.map

package/dist/engines/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/engines/registry.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,OAAO,GAAgC;IAC3C,CAAC,gBAAgB,CAAC,EAAE,CAAC,EAAE,gBAAgB;CACxC,CAAC;AAEF,iEAAiE;AACjE,MAAM,CAAC,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,EAAE,CAAC;AAErD;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,EAAkB;IAC1C,MAAM,GAAG,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,iBAAiB,CAAC;IACnD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5B,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,YAAY,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9F,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,EAAU;IAClC,OAAO,EAAE,IAAI,OAAO,CAAC;AACvB,CAAC;AAED,MAAM,UAAU,SAAS;IACvB,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC9B,CAAC"}

package/dist/engines/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * M2 (ENGINE-EXTRACT): the `AgentEngine` interface abstracts the coding /
+ * review subprocess a runner drives — how to build its argv, augment its
+ * environment, spawn it, parse its structured result envelope, classify a
+ * failure into the shared class taxonomy, and probe whether the binary/host
+ * is healthy.
+ *
+ * Wave 1 ships exactly one implementation, `claude-code`, whose behavior is
+ * byte-identical to the pre-refactor inline logic that used to live in
+ * task-runner.ts and reviewer.ts. The interface + registry exist so a later
+ * wave can register additional engines without touching the drive loops.
+ *
+ * This is a PURE refactor: no DB value, telemetry value, or runner-protocol
+ * message shape changes. `failure-classifier.ts` remains the single shared
+ * class-mapper every engine's `classifyFailure` calls into.
+ */
+import type { ExecaChildProcess } from "execa";
+import type { ClassifiedExit, ClaudeExitClass } from "../failure-classifier.js";
+import type { ClaudeJsonOutput } from "../cost-pricing.js";
+/**
+ * How an engine authenticates. Documentation + future gating.
+ * - claude-code: "api-key-or-oauth" (ANTHROPIC_API_KEY else interactive OAuth).
+ * - codex (M4):  "api-key-or-subscription" — OPENAI_API_KEY (api-key channel)
+ *                OR a stored ChatGPT login (subscription channel); the
+ *                `subscription_first` preference tries subscription, then
+ *                spills to api-key on a cap-hit (see src/provider-auth.ts).
+ */
+export type EngineAuthMode = "api-key-or-oauth" | "api-key-or-subscription" | "api-key" | "oauth" | "subscription" | "none";
+/**
+ * The engine-agnostic failure taxonomy is `ClaudeExitClass` verbatim so the
+ * DB/telemetry values stay frozen. The claude-code class `claude_unavailable`
+ * is the engine's spelling of the generic "engine momentarily unavailable"
+ * class (aliased below); the emitted string value never changes.
+ */
+export type EngineFailureClass = ClaudeExitClass;
+/** The low-level parse of the engine's structured stdout envelope (null = not the JSON form). */
+export type EngineResult = ClaudeJsonOutput | null;
+export interface EngineSpawnOptions {
+    /** Working directory for the child (task-runner sets the worktree; reviewer omits it → cwd unchanged). */
+    cwd?: string;
+    /** Model to pin via the engine's model flag; omitted/blank uses the operator default. */
+    modelId?: string | null;
+    /** Base environment to augment via env(); defaults to process.env. */
+    baseEnv?: NodeJS.ProcessEnv;
+}
+export interface AgentEngine {
+    /** Registry key + DB/telemetry id. */
+    readonly id: string;
+    /** Executable name resolved on PATH. */
+    readonly binary: string;
+    /** How the engine authenticates (documentation + future gating). */
+    readonly authMode: EngineAuthMode;
+    /** Build the CLI argv for a one-shot `--print` run (model pinned when non-blank). */
+    buildArgs(modelId?: string | null): string[];
+    /** Augment a base environment (default process.env) with the engine's auth channel. */
+    env(base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+    /** Spawn the engine as a piped child (stdin/stdout/stderr = pipe, reject = false). */
+    spawn(opts: EngineSpawnOptions): ExecaChildProcess;
+    /** Parse the structured result envelope from stdout (null when not the JSON form). */
+    parseResult(stdout: string): EngineResult;
+    /**
+     * Classify a non-zero (or 429-on-zero) exit into the shared class taxonomy.
+     * Delegates to failure-classifier — the one shared class-mapper all engines
+     * call into — so the DB class values stay frozen and backward-compatible.
+     */
+    classifyFailure(exitCode: number | null, stderr: string, stdout: string, durationMs?: number): ClassifiedExit;
+    /** Cheap health check: is the binary/host actually working? */
+    healthProbe(): Promise<{
+        ok: boolean;
+        detail: string;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/engines/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/engines/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GACtB,kBAAkB,GAClB,yBAAyB,GACzB,SAAS,GACT,OAAO,GACP,cAAc,GACd,MAAM,CAAC;AAEX;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAEjD,iGAAiG;AACjG,MAAM,MAAM,YAAY,GAAG,gBAAgB,GAAG,IAAI,CAAC;AAEnD,MAAM,WAAW,kBAAkB;IACjC,0GAA0G;IAC1G,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yFAAyF;IACzF,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAC7B;AAED,MAAM,WAAW,WAAW;IAC1B,sCAAsC;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAElC,qFAAqF;IACrF,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,EAAE,CAAC;IAE7C,uFAAuF;IACvF,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;IAEjD,sFAAsF;IACtF,KAAK,CAAC,IAAI,EAAE,kBAAkB,GAAG,iBAAiB,CAAC;IAEnD,sFAAsF;IACtF,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAAC;IAE1C;;;;OAIG;IACH,eAAe,CACb,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,cAAc,CAAC;IAElB,+DAA+D;IAC/D,WAAW,IAAI,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACzD"}

package/dist/engines/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/engines/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/engines/types.ts"],"names":[],"mappings":""}

package/dist/failure-classifier.d.ts

@@ -42,7 +42,7 @@
  * instead (capacity until a reset time, claude_unavailable with an
  * exponential backoff).
  */
-export type ClaudeExitClass = "capacity_exhausted" | "claude_unavailable" | "usage_limit" | "auth_expired" | "env_broken" | "task_error";
+export type ClaudeExitClass = "capacity_exhausted" | "subscription_exhausted" | "claude_unavailable" | "usage_limit" | "auth_expired" | "env_broken" | "task_error";
 export interface ClassifiedExit {
     exitCode: number | null;
     class: ClaudeExitClass;
@@ -75,6 +75,21 @@ export interface ClassifiedExit {
  * classifier stays a pure (strings) → class function for unit tests.
  */
 export declare function parseApiErrorStatus(stdout: string): number | null;
+/**
+ * v0.58 (T-5058, FH-1a): the capacity-exhaustion predicate, factored out of
+ * `classifyClaudeExit` so callers can detect a spent capacity window WITHOUT a
+ * non-zero exit code to key on. Claude's `--output-format=json` envelope can
+ * report `{ is_error: true, api_error_status: 429 }` while the CLI still exits
+ * 0 (the exit code and the JSON error are set independently, and the code is
+ * version-dependent). The exit-code path in the task-runner only classifies on
+ * a non-zero exit, so a 0-exit-with-429 would otherwise be mistaken for a
+ * successful build — pushing a partial worktree and opening a PR that burns the
+ * scarce reviewer capacity this class exists to protect. The authoritative
+ * signal is the JSON `api_error_status` 429; CAPACITY_PATTERNS is the
+ * plain-text fallback. Kept disjoint from USAGE_LIMIT_PATTERNS (hard billing
+ * walls that stay quarantine-worthy), exactly as `classifyClaudeExit` is.
+ */
+export declare function isCapacityExhausted(stdout: string, stderr?: string): boolean;
 /**
  * v0.56 (T-56-1): parse the reset time Claude states when it pauses a
  * session ("...resets 3:20pm (Asia/Calcutta)") into an absolute epoch
@@ -109,4 +124,20 @@ export declare function classifyClaudeExit(exitCode: number | null, stderr: stri
  * since the collision is transient and the task re-provisions cleanly on retry.
  */
 export declare function isGitProvisionContention(message: string): boolean;
+/**
+ * M4: parse a retry-after hint from a codex rate-limit message ("Please try
+ * again in 20s" / "retry-after: 1500ms"). Returns the delay in MILLISECONDS,
+ * or null when no hint is present — the caller then applies a fixed default
+ * pause (pause-till-reset semantics). Bare numbers are read as seconds, matching
+ * OpenAI's Retry-After header contract.
+ */
+export declare function extractCodexRetryAfterMs(text: string): number | null;
+/**
+ * M4 (ENGINE-CODEX): classify a codex CLI exit into the shared taxonomy. Same
+ * signature contract as `classifyClaudeExit` (the AgentEngine.classifyFailure
+ * shape) so the drive loop is engine-agnostic. See the block comment above for
+ * the ordering rationale — the billing-before-rate-limit order is the guard
+ * against the pause-loop deadlock.
+ */
+export declare function classifyCodexExit(exitCode: number | null, stderr: string, stdout: string, durationMs?: number): ClassifiedExit;
 //# sourceMappingURL=failure-classifier.d.ts.map

package/dist/failure-classifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"failure-classifier.d.ts","sourceRoot":"","sources":["../src/failure-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,MAAM,MAAM,eAAe,GACvB,oBAAoB,GACpB,oBAAoB,GACpB,aAAa,GACb,cAAc,GACd,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AA0ED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYjE;AA2DD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,MAAM,GAAG,IAAI,CAiCtF;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,cAAc,CAqFhB;AAwBD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGjE"}
+{"version":3,"file":"failure-classifier.d.ts","sourceRoot":"","sources":["../src/failure-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AA2BH,MAAM,MAAM,eAAe,GACvB,oBAAoB,GACpB,wBAAwB,GACxB,oBAAoB,GACpB,aAAa,GACb,cAAc,GACd,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AA0ED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,SAAK,GAAG,OAAO,CAGxE;AA2DD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,MAAM,GAAG,IAAI,CAiCtF;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,cAAc,CAqFhB;AAwBD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGjE;AAwFD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUpE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,cAAc,CA2EhB"}