harnery 0.8.0 → 0.9.0

package/dist/core/workflow/engine.js

@@ -0,0 +1,340 @@
+/**
+ * Workflow engine: loads a workflow script (plain JS, `export default
+ * async (ctx) => …`), injects the ctx API, enforces the caps, journals every
+ * step to `.harnery/workflows/<run-id>/journal.jsonl`, and returns a RunReport.
+ *
+ * Guarantees the engine makes (the pitch, in code):
+ *   - **Bounded**: hard total-agent ceiling + bounded parallel() concurrency.
+ *     A runaway loop hits `maxAgents` and the run fails loud, not silently.
+ *   - **Terminating**: the run is over when the script's default export
+ *     returns. There is no recursive self-spawning path: subagents are leaf
+ *     processes; only the top-level script can spawn.
+ *   - **Schema-gated**: with `schema`, an agent's reply must strict-parse and
+ *     validate; failures re-prompt with the validation errors appended, up to
+ *     `maxAttempts`, then throw. Routing decisions read validated fields, so
+ *     the deterministic script — not a model — decides what runs next.
+ *   - **Journaled**: every stage/agent start+end lands in the run journal with
+ *     cost, duration, and child session id (the resume + web-UI substrate).
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createHash, randomBytes } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { probeBilling } from "./billing.js";
+import { parseStageOutput, validateAgainstSchema } from "./validate.js";
+const DEFAULT_MAX_AGENTS = 50;
+const DEFAULT_CONCURRENCY = 4;
+const DEFAULT_MAX_ATTEMPTS = 2;
+const DEFAULT_TIMEOUT_MS = 300_000;
+const DEFAULT_MAX_TURNS = 25;
+export async function runWorkflow(scriptPath, opts) {
+    const absScript = isAbsolute(scriptPath) ? scriptPath : resolve(process.cwd(), scriptPath);
+    const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(absScript).href)));
+    if (typeof mod.default !== "function") {
+        throw new Error(`${scriptPath}: workflow script must \`export default async (ctx) => …\``);
+    }
+    const name = mod.meta?.name ?? scriptPath.replace(/^.*\//, "").replace(/\.[cm]?js$/, "");
+    const runId = `wf-${new Date().toISOString().replace(/[:.]/g, "-")}-${randomBytes(3).toString("hex")}`;
+    const runDir = join(opts.coordRoot, ".harnery", "workflows", runId);
+    mkdirSync(runDir, { recursive: true });
+    const journalPath = join(runDir, "journal.jsonl");
+    const maxAgents = opts.maxAgents ?? DEFAULT_MAX_AGENTS;
+    const concurrency = opts.concurrency ?? DEFAULT_CONCURRENCY;
+    const cwd = opts.cwd ?? opts.coordRoot;
+    const log = opts.onLog ?? ((line) => process.stderr.write(`${line}\n`));
+    const defaultHarness = opts.defaultHarness ?? "claude-code";
+    // Per-child fixed context overhead: children spawn in `cwd` and load its
+    // repo-instructions file into their system prompt, cache-writing it once
+    // per child. A fan-out multiplies this, so surface it BEFORE the burn.
+    const contextTokensPerChildEstimate = estimateInstructionTokens(cwd);
+    if (contextTokensPerChildEstimate > 0) {
+        log(`[context] each child cache-writes ~${Math.round(contextTokensPerChildEstimate / 1000)}K tokens of repo ` +
+            `instructions from ${cwd}; a fan-out multiplies this per agent`);
+    }
+    // Resume: journaled results of a prior run, keyed by agent-call identity.
+    const resumeCache = opts.resumeFrom
+        ? loadResumeCache(opts.coordRoot, opts.resumeFrom)
+        : new Map();
+    let agentsSpawned = 0;
+    let agentsCached = 0;
+    let costUsd = 0;
+    let currentStage = "";
+    let agentSeq = 0;
+    const billingProbed = new Map();
+    const journal = (event, data) => {
+        const line = JSON.stringify({
+            ts: new Date().toISOString(),
+            event,
+            stage: currentStage,
+            ...data,
+        });
+        appendFileSync(journalPath, `${line}\n`, "utf8");
+    };
+    // Bounded concurrency gate shared by every spawn in the run — direct
+    // `agent()` calls and `parallel()` thunks draw from the same slot pool, so
+    // the cap holds even when a script nests parallel() inside loops.
+    let inFlight = 0;
+    const waiters = [];
+    const acquire = async () => {
+        if (inFlight < concurrency) {
+            inFlight++;
+            return;
+        }
+        await new Promise((res) => waiters.push(res));
+        inFlight++;
+    };
+    const release = () => {
+        inFlight--;
+        waiters.shift()?.();
+    };
+    const agent = async (prompt, agentOpts = {}) => {
+        const harness = agentOpts.harness ?? defaultHarness;
+        const spawner = opts.spawners[harness];
+        if (!spawner) {
+            throw new Error(`no spawner registered for harness "${harness}" (registered: ${Object.keys(opts.spawners).join(", ") || "none"})`);
+        }
+        const id = `a${++agentSeq}`;
+        const label = agentOpts.label ?? `${prompt.slice(0, 60).replace(/\s+/g, " ")}…`;
+        const maxAttempts = agentOpts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+        // Call identity for resume: same stage + harness + model + turns + schema
+        // + ORIGINAL prompt → same key. Retry-mutated prompts never enter the key.
+        const key = agentCallKey(currentStage, harness, agentOpts, prompt);
+        const cached = resumeCache.get(key);
+        if (cached) {
+            agentsCached++;
+            journal("agent.cached", { id, label, key, kind: cached.kind });
+            log(`[${name}] ${currentStage || "(no stage)"} → ${id} ${label} (cached from ${opts.resumeFrom})`);
+            return cached.value;
+        }
+        // Billing safeguard: on a harness's FIRST spawn this run, classify which
+        // auth its children will use and refuse the silent-override state (an
+        // exported API key shadowing a stored subscription login) unless the
+        // caller explicitly opted into API billing. Cached agents never reach
+        // this — no spawn, no billing.
+        if (!billingProbed.has(harness)) {
+            const probe = (opts.probeBilling ?? probeBilling)(harness);
+            billingProbed.set(harness, probe);
+            journal("billing.probe", {
+                harness,
+                mode: opts.subscriptionOnly ? "subscription" : probe.mode,
+                api_key_source: probe.apiKeySource,
+                login: probe.login,
+                subscription_only: Boolean(opts.subscriptionOnly),
+            });
+            if (opts.subscriptionOnly) {
+                if (probe.login === "absent") {
+                    throw new Error(`subscription-only: no stored login detected for ${harness}; ` +
+                        `log the harness CLI in (or drop --subscription-only for a key-only host)`);
+                }
+                log(`[billing] ${harness}: subscription-only (API-key vars scrubbed from child env)`);
+            }
+            else if (probe.mode === "api-key-override" && !opts.allowApiBilling) {
+                throw new Error(`${probe.apiKeySource} is set AND a stored ${harness} login exists — the key silently ` +
+                    `overrides your subscription auth, so children would bill per-token API rates. ` +
+                    `Either unset ${probe.apiKeySource}, run with --subscription-only to scrub it from ` +
+                    `child envs, or pass --allow-api-billing if API billing is intended`);
+            }
+            else if (probe.mode === "api-key") {
+                log(`[billing] ${harness}: API-key billing (${probe.apiKeySource}; no stored login detected) — ` +
+                    `children bill per-token rates`);
+            }
+            else if (probe.mode === "api-key-override") {
+                log(`[billing] ${harness}: API-key billing (--allow-api-billing; key overrides stored login)`);
+            }
+            else {
+                log(`[billing] ${harness}: subscription login`);
+            }
+        }
+        if (agentsSpawned >= maxAgents) {
+            throw new Error(`workflow agent cap reached (${maxAgents}); raise --max-agents deliberately if the fan-out is intended`);
+        }
+        agentsSpawned++;
+        await acquire();
+        try {
+            journal("agent.start", { id, label, key, harness, model: agentOpts.model ?? null });
+            log(`[${name}] ${currentStage || "(no stage)"} → ${id} [${harness}] ${label}`);
+            let attemptPrompt = prompt;
+            let last = null;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                last = await spawner({
+                    prompt: attemptPrompt,
+                    model: agentOpts.model,
+                    timeoutMs: agentOpts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+                    maxTurns: agentOpts.maxTurns ?? DEFAULT_MAX_TURNS,
+                    cwd,
+                    runId,
+                    subscriptionOnly: opts.subscriptionOnly,
+                });
+                costUsd += last.costUsd ?? 0;
+                if (!last.ok) {
+                    journal("agent.attempt_failed", { id, attempt, error: last.error });
+                    continue; // spawn-level failure: retry with the original prompt
+                }
+                if (!agentOpts.schema) {
+                    journal("agent.end", {
+                        id,
+                        key,
+                        attempts: attempt,
+                        cost_usd: last.costUsd,
+                        duration_ms: last.durationMs,
+                        session_id: last.sessionId,
+                        result_kind: "text",
+                        result: last.text,
+                    });
+                    return last.text;
+                }
+                const parsed = parseStageOutput(last.text);
+                const problems = parsed.error !== undefined
+                    ? [parsed.error]
+                    : validateAgainstSchema(parsed.value, agentOpts.schema);
+                if (problems.length === 0) {
+                    journal("agent.end", {
+                        id,
+                        key,
+                        attempts: attempt,
+                        cost_usd: last.costUsd,
+                        duration_ms: last.durationMs,
+                        session_id: last.sessionId,
+                        result_kind: "json",
+                        result: parsed.value,
+                    });
+                    return parsed.value;
+                }
+                journal("agent.schema_retry", { id, attempt, problems });
+                // Feed the validation failure back verbatim — the retry prompt carries
+                // exactly what was wrong, which is what makes bounded retry converge.
+                attemptPrompt =
+                    `${prompt}\n\nYour previous reply failed validation:\n` +
+                        `${problems.map((p) => `  - ${p}`).join("\n")}\n` +
+                        `Reply with ONLY the corrected JSON object. No prose, no code fences.`;
+            }
+            const reason = last?.ok
+                ? `schema validation failed after ${maxAttempts} attempt(s)`
+                : (last?.error ?? "spawn failed");
+            journal("agent.failed", { id, error: reason });
+            throw new Error(`agent ${id} (${label}): ${reason}`);
+        }
+        finally {
+            release();
+        }
+    };
+    const parallel = async (thunks) => {
+        // Fire everything; the shared slot pool inside agent() bounds real
+        // concurrency. A rejected thunk lands as null so one bad item can't kill
+        // the batch — the script filters and routes.
+        return Promise.all(thunks.map((t) => t().catch((err) => {
+            journal("parallel.item_failed", { error: err.message });
+            return null;
+        })));
+    };
+    const stage = (title) => {
+        currentStage = title;
+        journal("stage.start", { title });
+        log(`[${name}] ── stage: ${title}`);
+    };
+    const ctx = { agent, parallel, stage, log };
+    const t0 = Date.now();
+    journal("run.start", { name, script: absScript, max_agents: maxAgents, concurrency });
+    try {
+        const result = await mod.default(ctx);
+        const report = {
+            runId,
+            name,
+            result,
+            agentsSpawned,
+            agentsCached,
+            costUsd: round4(costUsd),
+            durationMs: Date.now() - t0,
+            journalPath,
+            contextTokensPerChildEstimate,
+            billing: Array.from(billingProbed.values()).map((p) => ({
+                harness: p.harness,
+                mode: opts.subscriptionOnly ? "subscription" : p.mode,
+            })),
+        };
+        journal("run.end", {
+            ok: true,
+            agents: agentsSpawned,
+            cached: agentsCached,
+            cost_usd: report.costUsd,
+            duration_ms: report.durationMs,
+        });
+        return report;
+    }
+    catch (err) {
+        journal("run.end", {
+            ok: false,
+            error: err.message,
+            agents: agentsSpawned,
+            cached: agentsCached,
+            cost_usd: round4(costUsd),
+        });
+        throw err;
+    }
+}
+/** Stable identity for one agent() call, for the resume cache. The ORIGINAL
+ * prompt (never a retry-mutated one) plus everything that changes behavior. */
+function agentCallKey(stage, harness, agentOpts, prompt) {
+    const basis = JSON.stringify([
+        stage,
+        harness,
+        agentOpts.model ?? null,
+        agentOpts.maxTurns ?? DEFAULT_MAX_TURNS,
+        agentOpts.schema ?? null,
+        prompt,
+    ]);
+    return createHash("sha256").update(basis).digest("hex").slice(0, 16);
+}
+/** Per-child fixed context overhead: the repo-instructions file at the child
+ * cwd (CLAUDE.md preferred, AGENTS.md fallback) is loaded into every child's
+ * system prompt. bytes/4 token heuristic; 0 when neither file exists. */
+function estimateInstructionTokens(cwd) {
+    for (const f of ["CLAUDE.md", "AGENTS.md"]) {
+        const p = join(cwd, f);
+        if (existsSync(p)) {
+            try {
+                return Math.round(statSync(p).size / 4);
+            }
+            catch {
+                return 0;
+            }
+        }
+    }
+    return 0;
+}
+/** Load a prior run's journal into a key → result map. Only `agent.end`
+ * entries (completed, validated) are resumable; failed or retried-out agents
+ * re-run live. Unreadable journal → error (a typo'd run id should fail loud,
+ * not silently run everything fresh). */
+function loadResumeCache(coordRoot, resumeFrom) {
+    const path = join(coordRoot, ".harnery", "workflows", resumeFrom, "journal.jsonl");
+    if (!existsSync(path)) {
+        throw new Error(`--resume-from ${resumeFrom}: no journal at ${path}`);
+    }
+    const cache = new Map();
+    for (const line of readFileSync(path, "utf8").split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (e.event === "agent.end" && e.key && e.result_kind !== undefined) {
+                cache.set(e.key, { kind: e.result_kind, value: e.result });
+            }
+        }
+        catch {
+            /* skip malformed */
+        }
+    }
+    return cache;
+}
+function round4(n) {
+    return Math.round(n * 10_000) / 10_000;
+}

package/dist/core/workflow/harnesses.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Per-harness CLI metadata: binary names plus install/login hints, shared by
+ * the spawn adapters (a not-found error should say how to fix it, not just
+ * that it happened) and `harn doctor`'s workflow-harness checks.
+ *
+ * Install commands are the vendors' official one-liners; they drift rarely
+ * but they do drift — keep this module the single place they live.
+ */
+import type { HarnessName } from "./types.js";
+export declare const HARNESS_BINARIES: Record<HarnessName, string>;
+export declare const HARNESS_INSTALL_HINTS: Record<HarnessName, string>;
+/** How to authenticate each CLI with a subscription login (the billing
+ * default — see billing.ts). */
+export declare const HARNESS_LOGIN_HINTS: Record<HarnessName, string>;
+/** One-line "it's missing, here's the fix" string for spawn adapters. */
+export declare function notFoundError(harness: HarnessName): string;
+//# sourceMappingURL=harnesses.d.ts.map

package/dist/core/workflow/harnesses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harnesses.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/harnesses.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAIxD,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAI7D,CAAC;AAEF;gCACgC;AAChC,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAI3D,CAAC;AAEF,yEAAyE;AACzE,wBAAgB,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAK1D"}

package/dist/core/workflow/harnesses.js

@@ -0,0 +1,30 @@
+/**
+ * Per-harness CLI metadata: binary names plus install/login hints, shared by
+ * the spawn adapters (a not-found error should say how to fix it, not just
+ * that it happened) and `harn doctor`'s workflow-harness checks.
+ *
+ * Install commands are the vendors' official one-liners; they drift rarely
+ * but they do drift — keep this module the single place they live.
+ */
+export const HARNESS_BINARIES = {
+    "claude-code": "claude",
+    codex: "codex",
+    cursor: "cursor-agent",
+};
+export const HARNESS_INSTALL_HINTS = {
+    "claude-code": "npm install -g @anthropic-ai/claude-code",
+    codex: "npm install -g @openai/codex",
+    cursor: "curl https://cursor.com/install -fsS | bash",
+};
+/** How to authenticate each CLI with a subscription login (the billing
+ * default — see billing.ts). */
+export const HARNESS_LOGIN_HINTS = {
+    "claude-code": "run `claude` and use /login",
+    codex: "codex login",
+    cursor: "cursor-agent login",
+};
+/** One-line "it's missing, here's the fix" string for spawn adapters. */
+export function notFoundError(harness) {
+    return (`${HARNESS_BINARIES[harness]} CLI not found on PATH; ` +
+        `install: ${HARNESS_INSTALL_HINTS[harness]}  then authenticate: ${HARNESS_LOGIN_HINTS[harness]}`);
+}

package/dist/core/workflow/spawn-claude.d.ts

@@ -0,0 +1,22 @@
+/**
+ * claude-code spawn adapter: runs one subagent as a headless `claude -p`
+ * subprocess with `--output-format json` and unwraps the result envelope.
+ *
+ * Two hard-won rules from the Phase 1 spike, both load-bearing:
+ *
+ * 1. **Scrub inherited `CLAUDE*` env vars — delete, don't blank.** A workflow
+ *    launched from inside a Claude Code session inherits session env that makes
+ *    the nested CLI exit 1 with empty output. Setting a var to "" still reads
+ *    as set; only deletion works.
+ * 2. **Mark the child as a workflow child instead of disabling hooks.** With
+ *    the host repo's hooks active, the coordination Stop hook blocks a headless
+ *    child for skipping the end-of-turn ritual (observed: num_turns burned on
+ *    re-prompts → error_max_turns). `--settings '{"disableAllHooks":true}'`
+ *    fixes that but also kills the coord capture that makes workflow children
+ *    visible to peers — the point of running them under harnery. So the child
+ *    gets HARNERY_WORKFLOW_CHILD=1 and the stop-hook rule exempts it
+ *    (stop-hook.ts), keeping heartbeats + events on.
+ */
+import type { Spawner } from "./types.js";
+export declare const claudeCodeSpawner: Spawner;
+//# sourceMappingURL=spawn-claude.d.ts.map

package/dist/core/workflow/spawn-claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-claude.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-claude.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,OAAO,EAA6B,MAAM,YAAY,CAAC;AAYrE,eAAO,MAAM,iBAAiB,EAAE,OA+D/B,CAAC"}

package/dist/core/workflow/spawn-claude.js

@@ -0,0 +1,82 @@
+/**
+ * claude-code spawn adapter: runs one subagent as a headless `claude -p`
+ * subprocess with `--output-format json` and unwraps the result envelope.
+ *
+ * Two hard-won rules from the Phase 1 spike, both load-bearing:
+ *
+ * 1. **Scrub inherited `CLAUDE*` env vars — delete, don't blank.** A workflow
+ *    launched from inside a Claude Code session inherits session env that makes
+ *    the nested CLI exit 1 with empty output. Setting a var to "" still reads
+ *    as set; only deletion works.
+ * 2. **Mark the child as a workflow child instead of disabling hooks.** With
+ *    the host repo's hooks active, the coordination Stop hook blocks a headless
+ *    child for skipping the end-of-turn ritual (observed: num_turns burned on
+ *    re-prompts → error_max_turns). `--settings '{"disableAllHooks":true}'`
+ *    fixes that but also kills the coord capture that makes workflow children
+ *    visible to peers — the point of running them under harnery. So the child
+ *    gets HARNERY_WORKFLOW_CHILD=1 and the stop-hook rule exempts it
+ *    (stop-hook.ts), keeping heartbeats + events on.
+ */
+import { exec } from "../../lib/exec.js";
+import { buildChildEnv } from "./child-env.js";
+import { notFoundError } from "./harnesses.js";
+export const claudeCodeSpawner = async (req) => {
+    const t0 = Date.now();
+    const argv = [
+        "claude",
+        "-p",
+        req.prompt,
+        "--output-format",
+        "json",
+        "--max-turns",
+        String(req.maxTurns),
+    ];
+    if (req.model)
+        argv.push("--model", req.model);
+    const r = await exec(argv, {
+        cwd: req.cwd,
+        env: buildChildEnv(req.runId, { subscriptionOnly: req.subscriptionOnly }),
+        timeout: req.timeoutMs,
+    });
+    const durationMs = Date.now() - t0;
+    if (r.exitCode === 127) {
+        return { ok: false, text: "", durationMs, error: notFoundError("claude-code") };
+    }
+    if (r.exitCode !== 0) {
+        return {
+            ok: false,
+            text: "",
+            durationMs,
+            error: `claude exited ${r.exitCode}: ${(r.stderr || r.stdout).slice(0, 500)}`,
+        };
+    }
+    let envelope;
+    try {
+        envelope = JSON.parse(r.stdout);
+    }
+    catch {
+        return {
+            ok: false,
+            text: "",
+            durationMs,
+            error: `result envelope was not JSON: ${r.stdout.slice(0, 300)}`,
+        };
+    }
+    if (envelope.is_error) {
+        return {
+            ok: false,
+            text: String(envelope.result ?? ""),
+            sessionId: envelope.session_id,
+            costUsd: envelope.total_cost_usd,
+            durationMs,
+            error: `harness error (${envelope.subtype ?? "unknown"}): ${(envelope.errors ?? []).join("; ") || "see envelope"}`,
+        };
+    }
+    return {
+        ok: true,
+        text: String(envelope.result ?? ""),
+        sessionId: envelope.session_id,
+        costUsd: envelope.total_cost_usd,
+        durationMs,
+    };
+};

package/dist/core/workflow/spawn-codex.d.ts

@@ -0,0 +1,19 @@
+/**
+ * codex spawn adapter: runs one subagent as a headless `codex exec`
+ * subprocess.
+ *
+ * Contract notes (LIVE-VERIFIED 2026-07-16 against codex-cli 0.144.5: flags
+ * present, schema-gated triage + text stages round-trip via `--harness codex`):
+ * - `codex exec "<prompt>"` is the non-interactive mode.
+ * - The final assistant message is captured via `--output-last-message <file>`
+ *   (a temp file), which is far more drift-tolerant than parsing the
+ *   experimental `--json` JSONL event stream.
+ * - `--skip-git-repo-check` keeps non-repo cwds working; `--sandbox
+ *   workspace-write` matches workflow-stage expectations (children may edit).
+ * - No per-run cost or session-id surface in this mode → both left undefined.
+ * - No max-turns equivalent → `maxTurns` is accepted and ignored (documented
+ *   in the CLI docs page).
+ */
+import type { Spawner } from "./types.js";
+export declare const codexSpawner: Spawner;
+//# sourceMappingURL=spawn-codex.d.ts.map

package/dist/core/workflow/spawn-codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-codex.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-codex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AASH,OAAO,KAAK,EAAE,OAAO,EAA6B,MAAM,YAAY,CAAC;AAErE,eAAO,MAAM,YAAY,EAAE,OA+C1B,CAAC"}

package/dist/core/workflow/spawn-codex.js

@@ -0,0 +1,66 @@
+/**
+ * codex spawn adapter: runs one subagent as a headless `codex exec`
+ * subprocess.
+ *
+ * Contract notes (LIVE-VERIFIED 2026-07-16 against codex-cli 0.144.5: flags
+ * present, schema-gated triage + text stages round-trip via `--harness codex`):
+ * - `codex exec "<prompt>"` is the non-interactive mode.
+ * - The final assistant message is captured via `--output-last-message <file>`
+ *   (a temp file), which is far more drift-tolerant than parsing the
+ *   experimental `--json` JSONL event stream.
+ * - `--skip-git-repo-check` keeps non-repo cwds working; `--sandbox
+ *   workspace-write` matches workflow-stage expectations (children may edit).
+ * - No per-run cost or session-id surface in this mode → both left undefined.
+ * - No max-turns equivalent → `maxTurns` is accepted and ignored (documented
+ *   in the CLI docs page).
+ */
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { exec } from "../../lib/exec.js";
+import { buildChildEnv } from "./child-env.js";
+import { notFoundError } from "./harnesses.js";
+export const codexSpawner = async (req) => {
+    const t0 = Date.now();
+    const outFile = join(tmpdir(), `harnery-codex-${process.pid}-${randomBytes(4).toString("hex")}.txt`);
+    const argv = [
+        "codex",
+        "exec",
+        req.prompt,
+        "--output-last-message",
+        outFile,
+        "--skip-git-repo-check",
+        "--sandbox",
+        "workspace-write",
+    ];
+    if (req.model)
+        argv.push("--model", req.model);
+    try {
+        const r = await exec(argv, {
+            cwd: req.cwd,
+            env: buildChildEnv(req.runId, { subscriptionOnly: req.subscriptionOnly }),
+            timeout: req.timeoutMs,
+        });
+        const durationMs = Date.now() - t0;
+        if (r.exitCode === 127) {
+            return { ok: false, text: "", durationMs, error: notFoundError("codex") };
+        }
+        if (r.exitCode !== 0) {
+            return {
+                ok: false,
+                text: "",
+                durationMs,
+                error: `codex exited ${r.exitCode}: ${(r.stderr || r.stdout).slice(0, 500)}`,
+            };
+        }
+        if (!existsSync(outFile)) {
+            // Exit 0 but no last-message file: fall back to stdout (contract drift guard).
+            return { ok: true, text: r.stdout, durationMs };
+        }
+        return { ok: true, text: readFileSync(outFile, "utf8").trim(), durationMs };
+    }
+    finally {
+        rmSync(outFile, { force: true });
+    }
+};

package/dist/core/workflow/spawn-cursor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * cursor spawn adapter: runs one subagent as a headless `cursor-agent -p`
+ * subprocess with `--output-format json`.
+ *
+ * Contract notes (LIVE-VERIFIED 2026-07-17 against cursor-agent
+ * 2026.07.16-899851b: schema-gated triage + text stages round-trip via
+ * `--harness cursor`, session_id parses from the envelope):
+ * - `cursor-agent -p "<prompt>" --output-format json` prints a single result
+ *   envelope modeled on Claude Code's (`{type: "result", is_error, result,
+ *   session_id, …}`).
+ * - `--trust` is required: headless runs refuse untrusted workspaces (exit 1,
+ *   "Workspace Trust Required") — see the argv comment below.
+ * - Envelope drift guard: when stdout doesn't parse as JSON but the process
+ *   exited 0, the raw stdout is returned as the reply text.
+ * - No per-run cost surface → undefined. No max-turns equivalent → `maxTurns`
+ *   accepted and ignored (documented in the CLI docs page).
+ */
+import type { Spawner } from "./types.js";
+/** Exported for unit tests (no live binary to test against). */
+export declare function parseCursorOutput(stdout: string): {
+    text: string;
+    sessionId?: string;
+    isError: boolean;
+};
+export declare const cursorSpawner: Spawner;
+//# sourceMappingURL=spawn-cursor.d.ts.map

package/dist/core/workflow/spawn-cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-cursor.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/spawn-cursor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,KAAK,EAAE,OAAO,EAA6B,MAAM,YAAY,CAAC;AASrE,gEAAgE;AAChE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB,CAWA;AAED,eAAO,MAAM,aAAa,EAAE,OAwC3B,CAAC"}