akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/integrations/agent/spawn.js

@@ -2,239 +2,114 @@
 // 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/.
 /**
- * Agent CLI spawn wrapper (v1 spec §12.2).
+ * Agent CLI spawn wrapper.
  *
  * Single helper that owns:
  *   • Process spawn (Bun's subprocess API).
  *   • Captured vs interactive stdio.
  *   • Hard timeout (per-call override or profile default).
- *   • Structured failure reasons — `timeout`, `spawn_failed`,
- *     `non_zero_exit`, `parse_error`.
+ *   • Structured failure reasons — `timeout`, `aborted`, `spawn_failed`,
+ *     `non_zero_exit`.
  *
- * NEVER imports an LLM SDK. Agents are reachable only via shell-out;
- * this is a pre-emptive guarantee against the #222 invariant.
+ * The command comes from the harness (`harness.build`); this module never
+ * touches a model. Agents are reachable only via shell-out.
  */
-import { parseEmbeddedJsonResponse } from "../../core/parse.js";
-import { collectAllowlistedEnv } from "../../core/spawn-env.js";
-import { runManagedSubprocess, streamCaptureFailure, } from "../../core/subprocess.js";
-import { getCommandBuilder } from "./builders.js";
+import { ConfigError } from "../../core/errors.js";
+import { childProcessEnv } from "../../core/paths.js";
+import { runManagedSubprocess, streamCaptureFailure } from "../../core/subprocess.js";
+import { getHarness } from "../harnesses/index.js";
 import { DEFAULT_AGENT_TIMEOUT_MS } from "./config.js";
 /**
- * Build the child env. Starts empty and copies through:
- *   • Every name in `profile.envPassthrough` (via the shared
- *     {@link collectAllowlistedEnv}, which also supplements PATH for
- *     scheduler contexts where the inherited PATH is stripped).
- *   • Every entry in `profile.env`.
- *   • Every entry in `options.env` (highest precedence).
+ * The child's env, lowest precedence first: the environment akm runs in with the
+ * directories this akm resolved set over it, so a child that runs `akm` uses the
+ * same installation ({@link childProcessEnv}); then the call's `env`. The one
+ * environment policy for anything an agent run starts: a CLI harness's child, and
+ * the shell of an embedded session.
  */
-function buildChildEnv(profile, options) {
-    const env = collectAllowlistedEnv(profile.envPassthrough, options.envSource ?? process.env);
-    if (profile.env) {
-        for (const [k, v] of Object.entries(profile.env))
-            env[k] = v;
-    }
-    if (options.env) {
-        for (const [k, v] of Object.entries(options.env))
-            env[k] = v;
-    }
-    return env;
+export function buildChildEnv(options) {
+    return { ...childProcessEnv(), ...options.env };
 }
 /**
  * This path's phrasing of the SHARED incomplete-capture verdict
  * ({@link streamCaptureFailure} in `core/subprocess.ts`). The classification
  * lives in the primitive so the agent path and the workflow `exec` path cannot
  * drift apart on what "the capture did not complete" means; only the sentence
- * naming the profile is local. Message text is unchanged from the inlined copy.
+ * naming what ran is local.
  */
-function streamFailureMessage(profileName, stdout, stderr) {
+function streamFailureMessage(label, stdout, stderr) {
     const failures = streamCaptureFailure(stdout, stderr);
-    return failures === undefined ? undefined : `agent CLI "${profileName}" output capture failed: ${failures}`;
+    return failures === undefined ? undefined : `${label} output capture failed: ${failures}`;
+}
+function failed(reason, error, rest = {}) {
+    return { ok: false, exitCode: null, stdout: "", stderr: "", durationMs: 0, reason, error, ...rest };
 }
 /**
- * Spawn the agent CLI described by `profile` with `prompt` (forwarded as
- * the last positional arg by default) and return a structured result.
- *
- * The `prompt` argument is appended to `profile.args` (and `options.args`)
- * unless it is `undefined`. Pass `prompt = ""` to forward an explicit
- * empty positional, or pass extra args via `options.args`.
+ * Spawn the agent CLI `profile` names, with the command its harness builds from
+ * `options.dispatch`, and return a structured result.
  *
  * Failure modes (see {@link AgentFailureReason}):
  *
- *   • `spawn_failed`  — the spawn call threw synchronously.
+ *   • `spawn_failed`  — the spawn call threw, or its output could not be captured.
  *   • `timeout`       — exceeded the resolved timeout.
+ *   • `aborted`       — the caller's signal fired.
  *   • `non_zero_exit` — child exited with a non-zero code.
- *   • `parse_error`   — `parseOutput === "json"` and stdout was not JSON.
  *
- * `ok === true` requires exit code 0 and (if `parseOutput === "json"`)
- * a successful `JSON.parse`.
+ * `ok === true` requires exit code 0.
+ */
+export async function runAgent(profile, options = {}) {
+    const platform = profile.platform ?? profile.name;
+    const harness = getHarness(platform);
+    if (!harness) {
+        throw new ConfigError(`Agent platform "${platform}" has no registered command builder.`, "INVALID_CONFIG_FILE", "Select a canonical agent platform in harnesses.<name>.platform.");
+    }
+    const built = harness.build(profile, options.dispatch ?? {});
+    const command = { argv: built.argv, env: { ...buildChildEnv(options), ...built.env }, stdin: built.stdin };
+    return runBuiltCommand(`agent CLI "${profile.name}"`, command, options, options.stdio ?? profile.stdio);
+}
+/**
+ * Run a command that is already built and return a structured result: the part
+ * of {@link runAgent} that does not depend on which harness built the command,
+ * which akm's own runtime (`harnesses/opencode/runtime/`) shares. `label` names
+ * what ran in the failure messages.
  */
-export async function runAgent(profile, prompt, options = {}) {
-    const stdioMode = options.stdio ?? profile.stdio;
+export async function runBuiltCommand(label, { argv, env, stdin }, options, stdioMode = options.stdio ?? "captured") {
     // null = explicitly disabled (no kill timer). undefined = runtime default.
     const timeoutMs = options.timeoutMs !== undefined ? options.timeoutMs : DEFAULT_AGENT_TIMEOUT_MS;
-    const parseOutput = options.parseOutput ?? profile.parseOutput;
-    const setTimeoutImpl = options.setTimeoutFn ?? setTimeout;
-    const clearTimeoutImpl = options.clearTimeoutFn ?? clearTimeout;
-    // Observability seam — ids/status only, best-effort (see RunAgentOptions.onEvent).
-    const emitSpawnEvent = (type, data) => {
-        if (!options.onEvent)
-            return;
-        try {
-            options.onEvent({ type, data });
-        }
-        catch {
-            // Observability must never break the dispatch.
-        }
-    };
-    // Build argv via the platform-specific builder when dispatch params are
-    // provided; otherwise use the direct positional-prompt form.
-    let builtArgv;
-    let builtEnv;
-    if (options.dispatch !== undefined) {
-        const builder = getCommandBuilder(profile.platform ?? profile.name, options.builderRegistry);
-        const built = builder.build(profile, options.dispatch);
-        builtArgv = built.argv;
-        builtEnv = built.env;
-    }
-    else {
-        const positionalArgs = [...profile.args, ...(options.args ?? [])];
-        if (prompt !== undefined)
-            positionalArgs.push(prompt);
-        builtArgv = [profile.bin, ...positionalArgs];
-    }
-    // Extra args (e.g. forwarded CLI positionals) are appended after the builder output.
-    const finalArgv = [...builtArgv, ...(options.dispatch ? (options.args ?? []) : [])];
-    const env = { ...buildChildEnv(profile, options), ...(builtEnv ?? {}) };
-    const start = Date.now();
     // Cooperative cancel: refuse to spawn at all when the caller's signal is
     // already aborted (e.g. the run's budget was exhausted before this unit).
     if (options.signal?.aborted) {
-        return {
-            ok: false,
-            exitCode: null,
-            stdout: "",
-            stderr: "",
-            durationMs: 0,
-            reason: "aborted",
-            error: `agent CLI "${profile.name}" not started: caller signal already aborted`,
-        };
+        return failed("aborted", `${label} not started: caller signal already aborted`);
     }
     // Spawn/timeout/abort/capture are owned by the managed-subprocess primitive
     // (src/core/subprocess.ts): process-GROUP spawn (detached in captured mode),
-    // the SIGTERM→SIGKILL kill ladder on timeout/abort, bounded output capture,
-    // and the optional stdin payload. runAgent keeps its agent-specific surface —
-    // the onEvent observability seam, the failure taxonomy, and JSON parsing.
-    //
-    // `onSpawn` fires spawn_start once the child is live (never for a pre-spawn
-    // abort or a synchronous spawn failure), and captures the proc so spawn_exit
-    // can carry the same pid.
-    let spawnedProc;
-    const result = await runManagedSubprocess(finalArgv, {
+    // the SIGINT→SIGTERM→SIGKILL kill ladder on timeout/abort, bounded output capture,
+    // and the optional stdin payload. This keeps the agent-specific surface:
+    // the failure taxonomy.
+    const start = Date.now();
+    const result = await runManagedSubprocess([...argv], {
         capture: stdioMode === "captured",
-        env,
+        env: { ...env },
         ...(options.cwd ? { cwd: options.cwd } : {}),
-        ...(options.stdin !== undefined ? { stdin: options.stdin } : {}),
+        ...(stdin !== undefined ? { stdin } : {}),
         timeoutMs,
         ...(options.signal ? { signal: options.signal } : {}),
-        ...(options.spawn ? { spawnFn: options.spawn } : {}),
-        setTimeoutFn: setTimeoutImpl,
-        clearTimeoutFn: clearTimeoutImpl,
-        onSpawn: (proc) => {
-            spawnedProc = proc;
-            emitSpawnEvent("spawn_start", {
-                profile: profile.name,
-                ...(typeof proc.pid === "number" ? { pid: proc.pid } : {}),
-            });
-        },
     });
-    const pidField = spawnedProc && typeof spawnedProc.pid === "number" ? { pid: spawnedProc.pid } : {};
     const durationMs = Date.now() - start;
-    // Spawn/exit failure. A synchronous spawn throw never reached a live child
-    // (no spawn_start fired, so no spawn_exit either); a rejected proc.exited did
-    // (spawn_start already fired, so it emits a spawn_exit with status spawn_failed).
-    if (result.spawnError) {
-        if (spawnedProc) {
-            emitSpawnEvent("spawn_exit", { profile: profile.name, ...pidField, exitCode: null, status: "spawn_failed" });
-        }
-        return {
-            ok: false,
-            exitCode: null,
-            stdout: "",
-            stderr: "",
-            durationMs,
-            reason: "spawn_failed",
-            error: result.spawnError.message,
-        };
+    if (result.spawnError)
+        return failed("spawn_failed", result.spawnError.message, { durationMs });
+    const { exitCode, stdout, stderr } = result;
+    const output = { exitCode, stdout, stderr, durationMs };
+    if (result.aborted) {
+        return failed("aborted", `${label} aborted by caller signal`, output);
     }
-    const { exitCode, timedOut, aborted, stdout, stderr } = result;
-    emitSpawnEvent("spawn_exit", {
-        profile: profile.name,
-        ...pidField,
-        exitCode,
-        status: aborted ? "aborted" : timedOut ? "timeout" : exitCode !== 0 ? "non_zero_exit" : "ok",
-    });
-    if (aborted) {
-        return {
-            ok: false,
-            exitCode,
-            stdout,
-            stderr,
-            durationMs,
-            reason: "aborted",
-            error: `agent CLI "${profile.name}" aborted by caller signal`,
-        };
-    }
-    if (timedOut) {
-        return {
-            ok: false,
-            exitCode,
-            stdout,
-            stderr,
-            durationMs,
-            reason: "timeout",
-            error: `agent CLI "${profile.name}" timed out after ${timeoutMs ?? 0}ms`,
-        };
-    }
-    const captureFailure = streamFailureMessage(profile.name, result.stdoutRead, result.stderrRead);
-    if (captureFailure) {
-        return {
-            ok: false,
-            exitCode,
-            stdout,
-            stderr,
-            durationMs,
-            reason: "spawn_failed",
-            error: captureFailure,
-        };
+    if (result.timedOut) {
+        return failed("timeout", `${label} timed out after ${timeoutMs ?? 0}ms`, output);
     }
+    const captureFailure = streamFailureMessage(label, result.stdoutRead, result.stderrRead);
+    if (captureFailure)
+        return failed("spawn_failed", captureFailure, output);
     if (exitCode !== 0) {
-        return {
-            ok: false,
-            exitCode,
-            stdout,
-            stderr,
-            durationMs,
-            reason: "non_zero_exit",
-            error: `agent CLI "${profile.name}" exited with code ${exitCode}`,
-        };
-    }
-    if (parseOutput === "json" && stdioMode === "captured") {
-        // Strip <think> blocks and code fences, then parse with embedded-JSON
-        // fallback for local LLMs that emit prose around the payload. Handles
-        // both top-level `{…}` and `[…]` structures.
-        const parsed = parseEmbeddedJsonResponse(stdout);
-        if (parsed === undefined) {
-            return {
-                ok: false,
-                exitCode,
-                stdout,
-                stderr,
-                durationMs,
-                reason: "parse_error",
-                error: "no JSON structure found in agent output",
-            };
-        }
-        return { ok: true, exitCode, stdout, stderr, durationMs, parsed };
+        return failed("non_zero_exit", `${label} exited with code ${exitCode}`, output);
     }
-    return { ok: true, exitCode, stdout, stderr, durationMs };
+    return { ok: true, ...output };
 }

package/dist/integrations/harnesses/aider/index.js

@@ -2,46 +2,26 @@
 // 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/.
 /**
- * Aider CLI harness (P2 integration, plan §"The adapter contract").
- *
- * Per-harness barrel gathering the Aider integration surfaces:
- *   - agent command builder → ./agent-builder.ts    (aiderBuilder)
- *   - result extractor      → ./result-extractor.ts (aiderResultExtractor)
- *
- * It also defines {@link AiderHarness}, the {@link AkmHarness} descriptor that
- * `HARNESS_REGISTRY` registers. Dispatch-only: no native session-log reader or
- * config importer yet.
+ * Aider (`aider`). `--message` is its one-shot mode, `--yes-always` confirms every
+ * prompt so an unattended run does not stop, and `--no-pretty` keeps ANSI
+ * rendering out of the captured reply. The message is a flag value, with no
+ * positional prompt and no `--` to hide behind, so it is glued on with `=`: a
+ * prompt that starts with `-` then binds to the flag and is never read as an option.
  */
-import { caps } from "../shared.js";
-import { BaseHarness } from "../types.js";
-import { aiderBuilder } from "./agent-builder.js";
-import { aiderResultExtractor } from "./result-extractor.js";
-export { AIDER_PLATFORM, aiderBuilder } from "./agent-builder.js";
-export { aiderResultExtractor } from "./result-extractor.js";
-/**
- * Aider.
- *
- * Canonical id is `'aider'`; no alias or distinct runtime identity.
- */
-export class AiderHarness extends BaseHarness {
+import { withoutModelFlag, } from "../harness.js";
+export class AiderHarness {
     id = "aider";
     displayName = "Aider";
-    agentBuilder = aiderBuilder;
-    profile = {
-        bin: "aider",
-        args: ["--no-auto-commits"],
-        envPassthrough: ["OPENAI_API_KEY", "ANTHROPIC_API_KEY"],
-    };
-    resultExtractor = aiderResultExtractor;
-    // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // No flag-shaped resume: Aider persists context in chat-history files
-    // (`.aider.chat.history.md`), not session ids — the plan's named example of
-    // a harness with no session model. akm's `workflow_run_units` remains the
-    // durable resume source of truth.
-    // No `identityEnv`: the matrix lists Aider's identity markers as uncertain,
-    // and Aider stamps no session var onto child processes.
-    capabilities = caps({
-        agentDispatch: true,
-        detection: true,
-    });
+    profile = { bin: "aider", args: [] };
+    systemPrompt = false;
+    nativeAgent = false;
+    confinable = false;
+    build({ bin, args }, req) {
+        const argv = [bin, ...(req.model ? withoutModelFlag(args) : args)];
+        if (req.model)
+            argv.push("--model", req.model);
+        if (req.prompt !== undefined)
+            argv.push("--yes-always", "--no-pretty", `--message=${req.prompt}`);
+        return { argv };
+    }
 }

package/dist/integrations/harnesses/amazonq/index.js

@@ -2,39 +2,24 @@
 // 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 harness (P2 integration, plan §"The adapter
- * contract").
- *
- * Per-harness barrel gathering the Amazon Q integration surfaces:
- *   - agent command builder → ./agent-builder.ts    (amazonqBuilder)
- *   - result extractor      → ./result-extractor.ts (amazonqResultExtractor)
- *
- * It also defines {@link AmazonqHarness}, the {@link AkmHarness} descriptor
- * that `HARNESS_REGISTRY` registers. Dispatch-only: no native session-log
- * reader or config importer yet.
+ * Amazon Q Developer CLI (`q`). Headless is `q chat --no-interactive`, which
+ * prints the reply and exits; `--trust-all-tools` stops it asking before each
+ * tool. The prompt is the trailing positional, after `--`.
  */
-import { caps } from "../shared.js";
-import { BaseHarness } from "../types.js";
-import { amazonqBuilder } from "./agent-builder.js";
-import { amazonqResultExtractor } from "./result-extractor.js";
-export { AMAZONQ_PLATFORM, amazonqBuilder } from "./agent-builder.js";
-export { amazonqResultExtractor, stripTerminalFraming } from "./result-extractor.js";
-/**
- * Amazon Q Developer CLI (`q`).
- *
- * Canonical id is `'amazonq'`; no alias or distinct runtime identity.
- */
-export class AmazonqHarness extends BaseHarness {
+import { withoutLeading, withoutModelFlag, } from "../harness.js";
+export class AmazonqHarness {
     id = "amazonq";
     displayName = "Amazon Q Developer CLI";
-    agentBuilder = amazonqBuilder;
-    profile = { bin: "q", args: [], envPassthrough: ["AWS_PROFILE", "AWS_REGION"] };
-    resultExtractor = amazonqResultExtractor;
-    // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // No `identityEnv`: the matrix lists Q's identity markers as uncertain, and
-    // Q stamps no session var onto child processes.
-    capabilities = caps({
-        agentDispatch: true,
-        detection: true,
-    });
+    profile = { bin: "q", args: [] };
+    systemPrompt = false;
+    nativeAgent = false;
+    confinable = false;
+    build({ bin, args }, req) {
+        const authored = withoutLeading(args, "chat");
+        const base = [bin, "chat", ...(req.model ? withoutModelFlag(authored) : authored)];
+        const model = req.model ? ["--model", req.model] : [];
+        if (req.prompt === undefined)
+            return { argv: [...base, ...model] };
+        return { argv: [...base, "--no-interactive", "--trust-all-tools", ...model, "--", req.prompt] };
+    }
 }

package/dist/integrations/harnesses/claude/index.js

@@ -1,42 +1,73 @@
 // 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/.
-import { caps } from "../shared.js";
-import { BaseHarness } from "../types.js";
-import { claudeBuilder } from "./agent-builder.js";
-import { claudeCodeImporter } from "./config-import.js";
-import { claudeResultExtractor } from "./result-extractor.js";
+import { modelFromArgs, withoutModelFlag, } from "../harness.js";
 import { ClaudeCodeProvider } from "./session-log.js";
-export { claudeBuilder } from "./agent-builder.js";
-export { claudeCodeImporter } from "./config-import.js";
-export { claudeResultExtractor } from "./result-extractor.js";
 export { ClaudeCodeProvider } from "./session-log.js";
 /**
- * Claude Code.
- *
- * `claude` is the sole runtime and persisted id.
+ * The model-work tool policy on Claude Code, verified against 2.1.283:
+ *   - `--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
+ *     and Bash: no Edit;
+ *   - `--allowedTools` pre-approves Read and `akm search`, `akm show` and
+ *     `akm curate`, and `--permission-mode dontAsk` denies everything else instead
+ *     of prompting, including a compound, redirected or substituted command;
+ *   - `--no-session-persistence` keeps the run out of Claude Code's transcripts,
+ *     which `akm extract` would otherwise harvest as the user's own sessions.
+ * The config's `args` are left out of a model-work run, because `--add-dir`,
+ * `--settings` or a second `--allowedTools` would widen the policy; only the model
+ * they name is kept.
  */
-export class ClaudeHarness extends BaseHarness {
+export const MODEL_WORK_CLAUDE_FLAGS = Object.freeze([
+    "--restricted",
+    "--strict-mcp-config",
+    "--tools",
+    "Read,Bash",
+    "--allowedTools",
+    "Read,Bash(akm search *),Bash(akm show *),Bash(akm curate *)",
+    "--permission-mode",
+    "dontAsk",
+    "--no-session-persistence",
+]);
+export class ClaudeHarness {
     id = "claude";
     displayName = "Claude Code";
     // Home-relative config dir scanned by `akm setup` (#567). Claude Code has a
     // session-log provider, so offering it as a stash source is functional.
     setupDetectionDir = ".claude";
-    agentBuilder = claudeBuilder;
-    profile = { bin: "claude", args: [], envPassthrough: ["ANTHROPIC_API_KEY", "CLAUDE_CONFIG"] };
-    resultExtractor = claudeResultExtractor;
-    configImporter = claudeCodeImporter;
-    // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // Session-id env marker: presence of a concrete session id (not the bare
-    // "running under Claude Code" flag) attributes a run to this harness.
-    identityEnv = ["CLAUDE_SESSION_ID"];
+    profile = { bin: "claude", args: [] };
+    models = {
+        fast: "claude-haiku-4-5-20251001",
+        balanced: "claude-sonnet-4-6",
+        reasoning: "claude-opus-4-7",
+    };
+    // Claude Code exports its session id to the commands it runs. Only a concrete id
+    // attributes a run to this harness, not the bare "running under Claude Code" fact.
+    identityEnv = ["CLAUDE_CODE_SESSION_ID"];
     sessionLogProvider = () => new ClaudeCodeProvider();
-    capabilities = caps({
-        sessionLogs: true,
-        agentDispatch: true,
-        detection: true,
-        modelWork: true,
-        nativeAgent: true,
-        configImport: true,
-    });
+    systemPrompt = true;
+    nativeAgent = true;
+    confinable = true;
+    build({ bin, args }, req) {
+        const argv = [bin];
+        let model = req.model;
+        if (req.modelWork) {
+            argv.push(...MODEL_WORK_CLAUDE_FLAGS);
+            model ??= modelFromArgs(args);
+        }
+        else {
+            argv.push(...(model ? withoutModelFlag(args) : args));
+        }
+        if (req.agent)
+            argv.push("--agent", req.agent);
+        if (req.systemPrompt)
+            argv.push("--append-system-prompt", req.systemPrompt);
+        if (model)
+            argv.push("--model", model);
+        if (req.prompt === undefined)
+            return { argv };
+        return { argv: [...argv, "-p"], stdin: req.prompt };
+    }
 }

package/dist/integrations/harnesses/claude/session-log.js

@@ -7,17 +7,19 @@ import path from "node:path";
 import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
 import { AbstractSessionLogProvider } from "../../session-logs/provider-base.js";
 /**
- * Root directory holding Claude Code's per-project JSONL session logs.
+ * Root directory holding Claude Code's per-project JSONL session logs: the
+ * `projects` folder of its config directory (`CLAUDE_CONFIG_DIR`, else `~/.claude`).
  *
- * Resolved per call (not memoized at module load) so the `AKM_CLAUDE_PROJECTS_DIR`
- * override can be set after import. The override exists so tests — and the
- * isolated-storage sandbox — can point the scan at an empty fixture directory
+ * Resolved per call (not memoized at module load) so the environment can be set
+ * after import. `AKM_CLAUDE_PROJECTS_DIR` overrides it so tests, and the
+ * isolated-storage sandbox, can point the scan at an empty fixture directory
  * instead of the real `~/.claude/projects`, which on an actively-used machine
  * holds many large session files and would make `akm health` (which scans it
  * synchronously) slow and non-hermetic.
  */
 function claudeProjectsDir() {
-    return process.env.AKM_CLAUDE_PROJECTS_DIR ?? path.join(os.homedir(), ".claude", "projects");
+    return (process.env.AKM_CLAUDE_PROJECTS_DIR ??
+        path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"), "projects"));
 }
 /**
  * Directory Claude Code writes a session's subagent transcripts into, as

package/dist/integrations/harnesses/codex/index.js

@@ -1,43 +1,31 @@
 // 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/.
-import { caps } from "../shared.js";
-import { BaseHarness } from "../types.js";
-import { codexBuilder } from "./agent-builder.js";
-import { codexResultExtractor } from "./result-extractor.js";
+import { modelFromArgs, withoutLeading, withoutModelFlag, } from "../harness.js";
 import { CodexProvider } from "./session-log.js";
-export { codexBuilder, codexResumeArgs, writeCodexOutputSchemaFile } from "./agent-builder.js";
-export { codexResultExtractor } from "./result-extractor.js";
 export { CodexProvider } from "./session-log.js";
-/**
- * OpenAI Codex CLI.
- *
- * Canonical id is `'codex'`; no alias or distinct runtime identity.
- */
-export class CodexHarness extends BaseHarness {
+export class CodexHarness {
     id = "codex";
     displayName = "OpenAI Codex CLI";
     // No `setupDetectionDir`: `~/.codex` holds credentials and session rollouts,
     // not assets, so `akm setup` must not offer it as a stash source.
-    agentBuilder = codexBuilder;
-    profile = { bin: "codex", args: [], envPassthrough: ["OPENAI_API_KEY", "CODEX_CONFIG"] };
-    resultExtractor = codexResultExtractor;
-    // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // No flag-shaped resume: codex resume is the `exec resume <id>` SUBCOMMAND
-    // chain (see `codexResumeArgs` in ./agent-builder.ts).
-    // Presence flag: CODEX_SANDBOX is stamped only on processes codex itself
-    // spawns inside its sandbox, so it genuinely means "running under codex" —
-    // but its VALUE (e.g. "seatbelt") is a sandbox mode, not a session id, so it
-    // is registered as `presenceEnv` (harness inference only), never
-    // `identityEnv` (whose values persist as agent_session_id). CODEX_HOME (the
-    // matrix's other candidate) is deliberately NOT registered anywhere: it is a
-    // user config-dir var commonly exported in shell profiles, so it would stamp
-    // identity onto manual runs (see `AkmHarness.presenceEnv`).
+    profile = { bin: "codex", args: [] };
+    // CODEX_SANDBOX is stamped only on processes codex itself spawns inside its sandbox, so it
+    // means "running under codex"; its value (e.g. "seatbelt") is a sandbox mode, not a session id.
     presenceEnv = ["CODEX_SANDBOX"];
     sessionLogProvider = () => new CodexProvider();
-    capabilities = caps({
-        sessionLogs: true,
-        agentDispatch: true,
-        detection: true,
-    });
+    systemPrompt = false;
+    nativeAgent = false;
+    confinable = true;
+    build({ bin, args }, req) {
+        const authored = withoutLeading(args, "exec");
+        // Model work drops the config's args (a `--sandbox` among them would widen the policy), keeping the model they name.
+        const extra = req.modelWork ? [] : req.model ? withoutModelFlag(authored) : authored;
+        const model = req.model ?? (req.modelWork ? modelFromArgs(authored) : undefined);
+        const modelFlag = model ? ["--model", model] : [];
+        if (req.prompt === undefined)
+            return { argv: [bin, ...extra, ...modelFlag] };
+        const sandbox = req.modelWork ? ["--sandbox", "read-only"] : [];
+        return { argv: [bin, "exec", ...extra, ...sandbox, "--skip-git-repo-check", ...modelFlag, "--", req.prompt] };
+    }
 }