akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/integrations/harnesses/amazonq/agent-builder.js

@@ -1,138 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Amazon Q Developer CLI agent command builder (P2, plan §"The adapter
- * contract" step 2 / §"Capability matrix").
- *
- * Translates a platform-agnostic {@link AgentDispatchRequest} into the exact
- * headless argv the `q` CLI expects. Per the capability matrix the headless
- * invocation is:
- *
- *   q chat --no-interactive --trust-all-tools "<prompt>"
- *
- * with `--model <m>` for model selection and `--resume` for resume — NOTE:
- * unlike every other harness's resume, Q's `--resume` is a bare flag that
- * replays the previous conversation *of the working directory*; it takes no
- * session id. There is nothing to thread from `workflow_run_units` — akm's own
- * unit rows remain the durable resume source of truth regardless (plan
- * §"Session, MCP, and identity across harnesses").
- *
- * Platform-specific mapping decisions (all localized here, per the adapter
- * contract):
- *
- * - **subcommand** — headless dispatch is the `chat` subcommand. The builder
- *   prepends `chat` itself (mirroring the codex builder's `exec` handling); a
- *   user profile that already pins `chat` as its first arg is not doubled.
- * - **prompt** — the trailing positional `[INPUT]` argument of `q chat`,
- *   preceded by the `--` end-of-options separator (mirroring the
- *   claude/codex/pi builders) so a prompt whose text begins with `-`/`--` can
- *   never be parsed as flags. `--no-interactive` makes Q print the response
- *   and exit instead of opening the REPL.
- * - **systemPrompt** — `q chat` has no system-prompt flag (persona/context
- *   comes from Q's own agent config files), so the system prompt is folded
- *   into the positional payload ahead of the task prompt, separated by a
- *   blank line.
- * - **schema** — the matrix places Q in the NO-structured-output tier
- *   ("via prompt+validate": *(none documented)* — there is no `--json` or
- *   `--output-format` to ask for). The JSON Schema therefore reaches it only
- *   as the instruction the shared request lowering appends to the prompt.
- *   Stdout stays plain text; `./result-extractor.ts` strips terminal framing
- *   and the engine's shared embedded-JSON parse + retry-until-valid loop does
- *   the rest. No schema temp file is written — that seam is codex-only
- *   (`--output-schema`); inventing a flag here would produce a silently
- *   broken command.
- * - **tools** — a string/array tool policy maps to Q's documented
- *   `--trust-tools=<t1,t2>` allowlist flag (equals-joined, per `q chat
- *   --help`). With no policy at all, headless runs need autonomy, so
- *   `--trust-all-tools` is emitted per the matrix. A *structured* policy
- *   object is NOT expressible as Q flags; it is deliberately dropped without
- *   falling back to `--trust-all-tools` (never silently widen a restriction)
- *   — Q then refuses untrusted tool actions in non-interactive mode, which is
- *   the conservative failure mode.
- * - **inference** — not translated: the shared lowering reports each field of
- *   the request's inference as untranslated.
- *
- * Registered: `amazonqBuilder` is `AmazonqHarness.agentBuilder`
- * (`./index.ts`), one of the ten harnesses `HARNESS_REGISTRY` constructs
- * (`harnesses/index.ts`); `agent/builders.ts` derives `BUILTIN_BUILDERS` from
- * that registry, so this builder is reachable under the `"amazonq"` platform
- * name without any further wiring.
- */
-import { resolveDispatchModel } from "../../agent/builder-shared.js";
-import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
-/** Canonical harness/platform id used for model-alias resolution. */
-export const AMAZONQ_PLATFORM = "amazonq";
-/**
- * Split a tool policy into individual tool names for `--trust-tools`.
- * Strings are comma-separated lists; arrays are taken as-is. Structured
- * policy objects return `undefined` (not expressible as Q flags — see
- * module doc).
- */
-function toolPolicyEntries(tools) {
-    if (typeof tools === "string") {
-        return tools
-            .split(",")
-            .map((t) => t.trim())
-            .filter(Boolean);
-    }
-    if (Array.isArray(tools)) {
-        return tools.map((t) => t.trim()).filter(Boolean);
-    }
-    return undefined;
-}
-/** Assemble the positional prompt payload: optional system prompt, then the task prompt. */
-function buildPromptPayload(req) {
-    const sections = [];
-    if (req.systemPrompt)
-        sections.push(req.systemPrompt);
-    sections.push(req.prompt);
-    return sections.join("\n\n");
-}
-/**
- * Amazon Q Developer CLI builder.
- * Command shape:
- *   q chat --no-interactive (--trust-all-tools | --trust-tools=<t1,t2>)
- *          [--model <m>] -- "<systemPrompt?\n\nprompt>"
- */
-export const amazonqBuilder = {
-    platform: AMAZONQ_PLATFORM,
-    personaChannel: "prompt",
-    lower: createAgentRequestLowerer({
-        adapter: AMAZONQ_PLATFORM,
-        personaChannel: "prompt",
-        tools: "flat",
-    }),
-    build(profile, req) {
-        // Built-in q profiles would ship `args: []`; headless dispatch is the
-        // `chat` subcommand. Don't double it when a user profile already pins it.
-        const extra = profile.args[0] === "chat" ? profile.args.slice(1) : [...profile.args];
-        const args = ["chat", ...extra];
-        // Print the response and exit — required for captured dispatch.
-        args.push("--no-interactive");
-        if (req.tools) {
-            // Structured policy objects (entries === undefined) emit NO trust
-            // flags: dropping a restriction must never widen to --trust-all-tools.
-            const entries = toolPolicyEntries(req.tools);
-            if (entries !== undefined) {
-                // Q's documented allowlist form is equals-joined and comma-separated
-                // (`--trust-tools=fs_read,fs_write`); an empty list trusts no tools.
-                args.push(`--trust-tools=${entries.join(",")}`);
-            }
-        }
-        else {
-            // Headless default per the capability matrix: units must run without
-            // interactive tool-approval prompts.
-            args.push("--trust-all-tools");
-        }
-        if (req.model) {
-            const resolved = resolveDispatchModel(req, profile, AMAZONQ_PLATFORM);
-            args.push("--model", resolved);
-        }
-        // No system-prompt flag exists on `q chat` — it travels in the positional
-        // payload, after the end-of-options separator.
-        args.push("--");
-        args.push(buildPromptPayload(req));
-        return { argv: [profile.bin, ...args] };
-    },
-};

package/dist/integrations/harnesses/amazonq/result-extractor.js

@@ -1,48 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-const ESC = "\u001B";
-const BEL = "\u0007";
-/**
- * Matches ANSI CSI sequences (colors, cursor movement, erase-line) and OSC
- * sequences (title, hyperlink) terminated by BEL or ST. Built via the RegExp
- * constructor so the control characters live in named string constants
- * instead of regex-literal escapes.
- */
-const ANSI_SEQUENCE = new RegExp(`${ESC}\\[[0-9;?]*[ -/]*[@-~]` + `|${ESC}\\][^${BEL}${ESC}]*(?:${BEL}|${ESC}\\\\)`, "g");
-/**
- * Resolve carriage-return overwrites within one physical line: a terminal
- * would redraw from column 0 at each `\r`, so only the segment after the last
- * `\r` survives (spinner frames like "⠋ Thinking..." disappear exactly as
- * they do on screen). A trailing bare `\r` (CRLF line endings) is handled by
- * splitting on `\r?\n` before this runs.
- */
-function resolveCarriageReturns(line) {
-    const lastCr = line.lastIndexOf("\r");
-    return lastCr === -1 ? line : line.slice(lastCr + 1);
-}
-/** Strip terminal framing from raw captured stdout. See module doc, rule 1. */
-export function stripTerminalFraming(raw) {
-    const lines = raw.split(/\r?\n/).map((line) => resolveCarriageReturns(line).replace(ANSI_SEQUENCE, ""));
-    // Drop Q's "> " response marker from the first non-empty line only — deeper
-    // occurrences may be legitimate content (markdown blockquotes).
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? "";
-        if (line.trim().length === 0)
-            continue;
-        if (line.startsWith("> "))
-            lines[i] = line.slice(2);
-        break;
-    }
-    return lines.join("\n").trim();
-}
-/**
- * Normalize a raw Amazon Q run result into `{ text, sessionId? }`.
- * See the module doc for the rules.
- */
-export const amazonqResultExtractor = (result) => {
-    const sessionId = result.sessionId;
-    // Rule 2: a pre-parsed whole-stdout JSON *string* is the answer itself.
-    const text = typeof result.parsed === "string" ? result.parsed.trim() : stripTerminalFraming(result.stdout);
-    return { text, ...(sessionId ? { sessionId } : {}) };
-};

package/dist/integrations/harnesses/claude/agent-builder.js

@@ -1,106 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Claude Code agent command builder (migrated from `agent/builders.ts`, #563).
- *
- * Translates a platform-agnostic {@link AgentDispatchRequest} into the exact
- * argv the `claude` CLI expects. This is the Claude-specific slice of the
- * builder strategy; the shared infrastructure (`AgentCommandBuilder`,
- * `getCommandBuilder`, the OpenCode/default builders, flag/tool helpers) stays
- * in `agent/builders.ts`, which imports this builder back into
- * `BUILTIN_BUILDERS`.
- *
- * ## Structured output
- *
- * For a schema-bearing request this builder emits `--output-format json`,
- * which wraps the run in a RESULT ENVELOPE
- * (`{"type":"result","result":"<final answer>","session_id":"…", …}`); the
- * shared request lowering has already appended the schema instruction to the
- * prompt. The envelope is unwrapped by `./result-extractor.ts`, and the
- * engine's shared `runStructured` retry-until-valid loop validates the
- * extracted text against the schema (hinted output is trusted but verified).
- * Without a schema the argv carries no output flag.
- *
- * Claude Code 2.1.283 also has `--json-schema <schema>` (JSON Schema for
- * structured output validation, with `--print`). akm does not pass it; the
- * instruction and the validation loop above are what enforce a schema.
- *
- * The builder's `platform` stays `'claude'` (the canonical harness id).
- */
-import { modelFromArgs, normalizeTools, resolveDispatchModel, } from "../../agent/builder-shared.js";
-import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
-/** The model-work tool policy on Claude Code: read, edit in the working directory, `akm search`, `akm show`. */
-export const MODEL_WORK_CLAUDE_FLAGS = Object.freeze([
-    "--restricted",
-    "--strict-mcp-config",
-    "--tools",
-    "Read,Edit,Bash",
-    "--allowedTools",
-    "Read,Edit,Bash(akm search *),Bash(akm show *)",
-    "--permission-mode",
-    "dontAsk",
-]);
-/**
- * Claude Code builder.
- * Command shape:
- *   claude [--agent <name>] [--system-prompt "..."] [--model <m>] [--allowedTools <t>]
- *          [--output-format json] --print -- "<prompt>"
- *
- * --print switches Claude Code to non-interactive captured output mode.
- *
- * The model-work tool policy lowers to {@link MODEL_WORK_CLAUDE_FLAGS} in place
- * of the engine's `args` and `--allowedTools`, verified against Claude Code
- * 2.1.283 and a local stub:
- *   - `--restricted` ignores the user, project and local settings files (whose
- *     allow rules would otherwise pre-approve any command or path) and confines
- *     the file tools to the working directory;
- *   - `--strict-mcp-config` starts no MCP server, and `--tools` offers only
- *     Read, Edit and Bash;
- *   - `--allowedTools` pre-approves Read, Edit, `akm search` and `akm show`,
- *     and `--permission-mode dontAsk` denies everything else instead of
- *     prompting, including a compound, redirected or substituted command.
- * The engine's `args` are left out because `--add-dir`, `--settings` or a
- * second `--allowedTools` would widen that. Only the model they name is kept.
- */
-export const claudeBuilder = {
-    platform: "claude",
-    personaChannel: "native",
-    lower: createAgentRequestLowerer({
-        adapter: "claude",
-        personaChannel: "native",
-        tools: "all",
-    }),
-    build(profile, req) {
-        const modelWork = req.modelWork === true;
-        const args = modelWork ? [...MODEL_WORK_CLAUDE_FLAGS] : [...profile.args];
-        if (req.agent) {
-            args.push("--agent", req.agent);
-        }
-        if (req.systemPrompt) {
-            args.push("--system-prompt", req.systemPrompt);
-        }
-        if (req.model) {
-            const resolved = resolveDispatchModel(req, profile, "claude");
-            args.push("--model", resolved);
-        }
-        else if (modelWork) {
-            const model = modelFromArgs(profile.args);
-            if (model)
-                args.push("--model", model);
-        }
-        if (req.tools) {
-            args.push("--allowedTools", normalizeTools(req.tools));
-        }
-        if (req.schema) {
-            // Structured unit: request the documented JSON result envelope so
-            // `./result-extractor.ts` can pull the final answer + session id.
-            args.push("--output-format", "json");
-        }
-        // --print = non-interactive, outputs to stdout — required for captured mode
-        args.push("--print");
-        args.push("--");
-        args.push(req.prompt);
-        return { argv: [profile.bin, ...args] };
-    },
-};

package/dist/integrations/harnesses/claude/config-import.js

@@ -1,67 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Claude Code LLM-config importer (migrated from `setup/harness-config-import.ts`,
- * #563).
- *
- * Detects a Claude Code installation (filesystem only, no network) and reads
- * its config to extract LLM connection details. API key VALUES are never
- * stored — only the env var name that holds them. `ClaudeHarness` declares it
- * as its `configImporter`.
- *
- * Behaviour-preserving relocation.
- */
-import fs from "node:fs";
-import path from "node:path";
-import { homeDir } from "../shared.js";
-/**
- * Imports LLM config from a Claude Code installation.
- *
- * Claude Code stores settings in `~/.claude/settings.json` or `~/.claude.json`.
- * The model field may appear at the root or under `env.ANTHROPIC_MODEL`.
- * The API key is always `ANTHROPIC_API_KEY`.
- */
-export const claudeCodeImporter = {
-    harnessName: "Claude Code",
-    detect() {
-        const home = homeDir();
-        // Claude Code is installed if the ~/.claude/ directory exists
-        return fs.existsSync(path.join(home, ".claude"));
-    },
-    importConfig() {
-        const home = homeDir();
-        // Try ~/.claude/settings.json, then ~/.claude.json
-        const candidates = [path.join(home, ".claude", "settings.json"), path.join(home, ".claude.json")];
-        for (const filePath of candidates) {
-            try {
-                if (!fs.existsSync(filePath))
-                    continue;
-                const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
-                // Claude Code settings: model may be at root or nested under env
-                const envBlock = raw.env;
-                const model = typeof raw.model === "string"
-                    ? raw.model
-                    : typeof envBlock?.ANTHROPIC_MODEL === "string"
-                        ? String(envBlock.ANTHROPIC_MODEL)
-                        : undefined;
-                return {
-                    harnessName: "Claude Code",
-                    provider: "anthropic",
-                    model: model ?? "claude-sonnet-4-5",
-                    apiKeyEnvVar: "ANTHROPIC_API_KEY",
-                };
-            }
-            catch {
-                // try next candidate
-            }
-        }
-        // ~/.claude exists but no readable settings — still return basic Anthropic config
-        return {
-            harnessName: "Claude Code",
-            provider: "anthropic",
-            model: "claude-sonnet-4-5",
-            apiKeyEnvVar: "ANTHROPIC_API_KEY",
-        };
-    },
-};

package/dist/integrations/harnesses/claude/result-extractor.js

@@ -1,67 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Claude Code CLI result extractor (Codex round-3 finding A; plan §"The adapter
- * contract" step 3 / §"Structured-output normalization", tier "native-json").
- *
- * Normalizes one raw {@link AgentRunResult} from a headless `claude -p` run into
- * `{ text, sessionId? }` — the {@link AgentResultExtraction} seam. The engine's
- * shared schema-validation / retry-until-valid loop runs *after* this; the
- * extractor only strips transport framing.
- *
- * A schema-bearing unit is dispatched with `--output-format json` (see
- * `./agent-builder.ts`), so stdout is Claude Code's documented RESULT ENVELOPE —
- * a single JSON object:
- *
- *   {"type":"result","subtype":"success","is_error":false,
- *    "result":"<final answer>","session_id":"<uuid>","total_cost_usd":…,"usage":…}
- *
- * The final answer the model produced lives in `result` (a string); the
- * harness-native session id in `session_id`, stored opportunistically on the
- * unit row for `claude --resume <id>` (akm never depends on it —
- * `workflow_run_units` stays the source of truth).
- *
- * A SCHEMALESS unit is dispatched WITHOUT `--output-format json`, so stdout is
- * plain text — passed through verbatim (untrimmed) so the schemaless dispatch
- * path is byte-identical to the pre-extractor behaviour. Only a genuine result
- * envelope (a `type: "result"` object, or one carrying both a string `result`
- * and a `session_id`) is unwrapped; anything else degrades to raw pass-through,
- * so a point-release envelope rename fails soft (the engine's embedded-JSON
- * parsing still runs downstream for schema units) rather than hard.
- */
-import { asNonEmptyString, isRecord, tryParseJson } from "../../../core/common.js";
-/**
- * Is this parsed object Claude Code's `--output-format json` RESULT ENVELOPE
- * (rather than a bare JSON answer a schema unit produced without the flag)? A
- * genuine envelope declares `type: "result"`, or carries the two envelope-only
- * fields together (a string `result` AND a `session_id`). A bare structured
- * answer — `{"result":"ok"}` — carries neither marker, so it is passed through
- * raw and the engine's schema validator sees the whole object.
- */
-function isResultEnvelope(value) {
-    if (value.type === "result")
-        return true;
-    return typeof value.result === "string" && asNonEmptyString(value.session_id) !== undefined;
-}
-/**
- * Normalize a raw claude run result into `{ text, sessionId? }`. See the module
- * doc for the two stdout shapes (JSON result envelope vs plain text).
- */
-export const claudeResultExtractor = (result) => {
-    const fallbackSessionId = result.sessionId;
-    const raw = result.stdout;
-    const trimmed = raw.trim();
-    // Only attempt an envelope parse when stdout looks like a single JSON object
-    // (`--output-format json`). A plain-text run is passed through UNCHANGED
-    // (untrimmed) so schemaless dispatch stays byte-identical to today.
-    if (trimmed.startsWith("{")) {
-        const whole = result.parsed !== undefined ? result.parsed : tryParseJson(trimmed);
-        if (isRecord(whole) && isResultEnvelope(whole)) {
-            const text = typeof whole.result === "string" ? whole.result : trimmed;
-            const sessionId = asNonEmptyString(whole.session_id) ?? fallbackSessionId;
-            return { text, ...(sessionId ? { sessionId } : {}) };
-        }
-    }
-    return { text: raw, ...(fallbackSessionId ? { sessionId: fallbackSessionId } : {}) };
-};

package/dist/integrations/harnesses/codex/agent-builder.js

@@ -1,150 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * OpenAI Codex CLI agent command builder (P2, plan §"The adapter contract" /
- * §"Capability matrix").
- *
- * Translates a platform-agnostic {@link AgentDispatchRequest} into the exact
- * headless argv the `codex` CLI expects:
- *
- *   codex exec --sandbox workspace-write [--model <m>] --json [--output-schema <file>] -- "<prompt>"
- *
- * Capability-matrix facts this builder encodes (July 2026 research):
- *   - Headless invocation is the `exec` subcommand (`codex exec "<p>"`), not a
- *     flag. The built-in codex profiles carry `args: []`, so the builder
- *     prepends `exec` itself; a user profile that already pins `exec` as its
- *     first arg is not doubled.
- *   - `--json` switches stdout to a JSONL event stream — the input contract of
- *     `./result-extractor.ts`. Always emitted, mirroring how the Claude builder
- *     always emits `--print`: dispatch is the captured, non-interactive path.
- *   - Codex is the NATIVE-SCHEMA tier (plan §"Structured-output
- *     normalization"): `req.schema` is written to a file and passed via
- *     `--output-schema <file>`. The file is named by the hash of the schema
- *     and lives in akm's cache dir, so a schema is written once however many
- *     units dispatch with it: `BuiltCommand` has no post-run hook, and the
- *     spawned process reads the file after `build()` returns, so a file per
- *     dispatch could only leak (#1051). The engine still validates the output
- *     defensively (the constrained output is trusted but verified).
- *   - `codex exec` has no system-prompt flag; `req.systemPrompt` is folded
- *     into the prompt payload (system text first, blank line, then the task),
- *     after the `--` end-of-options separator so it can never be parsed as a
- *     flag.
- *   - Tool policy is omitted, but the builder DOES inject `--sandbox
- *     workspace-write` so dispatched units can write to their working
- *     directory.  `codex exec` defaults to a read-only sandbox that silently
- *     blocks file writes; without this flag the unit returns "workspace is
- *     read-only" and the engine marks the step complete with no real mutation.
- *     `--ask-for-approval` is NOT injected — that flag only exists on the
- *     interactive `codex` command, not on `codex exec`, and exec mode is
- *     already non-approval-blocking.  Profile-supplied `--sandbox` flags
- *     (long or short form) are preserved (not duplicated).
- *   - Resume is the `codex exec resume <id>` SUBCOMMAND, not a flag, so it is
- *     not expressible through `AgentDispatchRequest` (which has no session
- *     field yet); {@link codexResumeArgs} exposes the argv prefix for the
- *     integration task that wires session-id reuse from `workflow_run_units`.
- *   - The request's inference is not translated: the shared lowering reports
- *     each field as untranslated. codex would take `reasoningEffort` as
- *     `-c model_reasoning_effort=<v>`, which is left to the integration task.
- *
- * Registered: `codexBuilder` is `CodexHarness.agentBuilder` (`./index.ts`),
- * one of the ten harnesses `HARNESS_REGISTRY` constructs
- * (`harnesses/index.ts`); `agent/builders.ts` derives `BUILTIN_BUILDERS` from
- * that registry, so this builder is reachable under the `"codex"` platform
- * name without any further wiring.
- */
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { writeFileAtomic } from "../../../core/common.js";
-import { getCacheDir } from "../../../core/paths.js";
-import { sha256Hex } from "../../../runtime.js";
-import { resolveDispatchModel } from "../../agent/builder-shared.js";
-import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
-/**
- * Write a node's JSON Schema to a file for `--output-schema`, named by the hash
- * of its text, in akm's cache dir. Returns the absolute file path (the value
- * handed to the flag).
- *
- * The same schema is the same file, so concurrent fan-out units share it, and
- * the atomic rename makes a write of identical bytes safe under a reader: no
- * unit can see a half-written schema, and none removes it from another. Nothing
- * is cleaned up, because nothing accumulates but one file per distinct schema.
- */
-export function writeCodexOutputSchemaFile(schema) {
-    const text = `${JSON.stringify(schema, null, 2)}\n`;
-    const dir = join(getCacheDir(), "codex-output-schemas");
-    mkdirSync(dir, { recursive: true });
-    const file = join(dir, `${sha256Hex(text)}.json`);
-    writeFileAtomic(file, text);
-    return file;
-}
-/**
- * Argv prefix that resumes a previous codex session: `exec resume <id>`.
- * Codex resume is a subcommand chain, not a flag. The harness-native session
- * id comes from the unit row (stored opportunistically by the result
- * extractor); akm never depends on it (plan §"Session, MCP, and identity").
- */
-export function codexResumeArgs(sessionId) {
-    return ["exec", "resume", sessionId];
-}
-/**
- * Return `base` plus the `--sandbox workspace-write` flag that makes `codex exec`
- * able to write to its working directory.  `codex exec` defaults to a read-only
- * sandbox that silently blocks file writes — without this flag the unit returns
- * "workspace is read-only" and the engine marks the step complete with no real
- * mutation.  If the profile already pins `--sandbox` (long or short form) the
- * default is not duplicated.
- *
- * Note: `--ask-for-approval` is an *interactive* codex flag only — `codex exec`
- * does not accept it (it errors with "unexpected argument").  Non-interactive
- * exec mode is implicitly non-approval-blocking; `--sandbox workspace-write`
- * alone is sufficient for dispatched units.
- */
-function ensureSandboxFlags(base) {
-    const out = [...base];
-    if (!out.includes("--sandbox") && !out.includes("-s")) {
-        out.push("--sandbox", "workspace-write");
-    }
-    return out;
-}
-/**
- * OpenAI Codex builder.
- * Command shape: codex exec --sandbox workspace-write [--model <m>] --json [--output-schema <file>] -- "<prompt>"
- */
-export const codexBuilder = {
-    platform: "codex",
-    personaChannel: "prompt",
-    lower: createAgentRequestLowerer({
-        adapter: "codex",
-        personaChannel: "prompt",
-        tools: "none",
-    }),
-    build(profile, req) {
-        // Built-in codex profiles ship `args: []`; headless dispatch is the `exec`
-        // subcommand. Don't double it when a user profile already pins it.
-        const extra = profile.args[0] === "exec" ? profile.args.slice(1) : [...profile.args];
-        // `codex exec` defaults to a read-only sandbox that silently blocks file
-        // writes — dispatched units would return "workspace is read-only" and the
-        // engine would mark them complete with no real mutation.  Force
-        // `workspace-write` (writes scoped to cwd) unless the profile already pins
-        // its own --sandbox flag (`--ask-for-approval` is not injectable here —
-        // see ensureSandboxFlags).
-        const sandboxArgs = ensureSandboxFlags(extra);
-        const args = ["exec", ...sandboxArgs];
-        if (req.model) {
-            const resolved = resolveDispatchModel(req, profile, "codex");
-            args.push("--model", resolved);
-        }
-        // JSONL event stream on stdout — the codex result extractor's input.
-        args.push("--json");
-        if (req.schema) {
-            // Native-schema tier: pass the node schema straight through.
-            args.push("--output-schema", writeCodexOutputSchemaFile(req.schema));
-        }
-        // No system-prompt flag exists on `codex exec` — fold it into the prompt.
-        const prompt = req.systemPrompt ? `${req.systemPrompt}\n\n${req.prompt}` : req.prompt;
-        args.push("--");
-        args.push(prompt);
-        return { argv: [profile.bin, ...args] };
-    },
-};