akm-cli 0.9.0-rc.0 → 0.9.0-rc.1

package/dist/indexer/walk/matchers.js

@@ -11,6 +11,8 @@
 import { defaultRendererRegistry } from "../../core/asset/asset-registry.js";
 import { SCRIPT_EXTENSIONS } from "../../core/asset/asset-spec.js";
 import { looksLikeWorkflow } from "../../workflows/parser.js";
+import { looksLikeWorkflowProgram } from "../../workflows/program/parser.js";
+import { WORKFLOW_PROGRAM_RENDERER_NAME } from "../../workflows/program/project.js";
 import { registerMatcher } from "./file-context.js";
 // ---------------------------------------------------------------------------
 // Private data
@@ -178,6 +180,35 @@ function classifyBySmartMd(ctx) {
     }
     return { type: "knowledge", specificity: 5 };
 }
+/** YAML workflow *programs* (redesign addendum, R1): `.yaml`/`.yml` files. */
+const WORKFLOW_PROGRAM_EXTENSIONS = new Set([".yaml", ".yml"]);
+/**
+ * Classify YAML workflow programs. Two claims, mirroring the markdown rules:
+ *
+ *   - any `.yaml`/`.yml` under a `workflows/` dir (the directory rule —
+ *     specificity 15 when `workflows` is the immediate parent, 10 for a
+ *     deeper ancestor, same ladder as `matchDirectoryHint`);
+ *   - anywhere else, a content probe via `looksLikeWorkflowProgram`
+ *     (`version: 1` + `steps:` at column 0) at specificity 19, the same
+ *     level as `classifyBySmartMd`'s `looksLikeWorkflow` claim.
+ *
+ * The fact does NOT go through `toMatchResult` — the workflow TYPE maps to
+ * the markdown renderer by default, so this classifier names the
+ * `workflow-program-yaml` renderer on its result directly.
+ */
+function classifyByWorkflowProgram(ctx) {
+    if (!WORKFLOW_PROGRAM_EXTENSIONS.has(ctx.ext))
+        return null;
+    if (isTypedDirDocFile(ctx.fileName))
+        return null;
+    if (ctx.parentDir === "workflows")
+        return { type: "workflow", specificity: 15 };
+    if (ctx.ancestorDirs.includes("workflows"))
+        return { type: "workflow", specificity: 10 };
+    if (looksLikeWorkflowProgram(ctx.content()))
+        return { type: "workflow", specificity: 19 };
+    return null;
+}
 function classifyByWiki(ctx) {
     if (ctx.ext !== ".md")
         return null;
@@ -223,12 +254,20 @@ export function smartMdMatcher(ctx) {
 export function wikiMatcher(ctx) {
     return toMatchResult(ctx, classifyByWiki);
 }
+export function workflowProgramMatcher(ctx) {
+    const fact = classifyByWorkflowProgram(ctx);
+    if (!fact)
+        return null;
+    // Named directly (not via rendererNameFor) — see classifyByWorkflowProgram.
+    return { type: fact.type, specificity: fact.specificity, renderer: WORKFLOW_PROGRAM_RENDERER_NAME };
+}
 const builtinMatchers = [
     extensionMatcher,
     directoryMatcher,
     parentDirHintMatcher,
     smartMdMatcher,
     wikiMatcher,
+    workflowProgramMatcher,
 ];
 export function registerBuiltinMatchers() {
     for (const matcher of builtinMatchers) {

package/dist/integrations/agent/builders.js

@@ -77,11 +77,13 @@ const BUILTIN_BUILDERS = (() => {
  * A *custom* profile (unknown platform) falls back to the default builder —
  * that generic `--system-prompt`/`--model`/`--` shape is the documented
  * contract for user-defined wrappers. A *known built-in agent CLI* with no
- * dedicated builder (codex, gemini, aider + their `-headless` variants) is a
- * loud `ConfigError` instead: the default flag shape is wrong for those CLIs
- * (aider, for one, treats positionals as file names), so the old silent
- * fallback produced a broken command that "ran" and failed downstream.
- * Custom builders injected via tests can be passed as `registry`.
+ * dedicated builder is a loud `ConfigError` instead: the default flag shape
+ * is wrong for those CLIs (aider, for one, treats positionals as file names),
+ * so the old silent fallback produced a broken command that "ran" and failed
+ * downstream. As of the P2 harness-adapter integration every built-in profile
+ * has a registry-derived builder, so this branch only fires if a future
+ * builtin profile ships without one. Custom builders injected via tests can
+ * be passed as `registry`.
  */
 export function getCommandBuilder(platform, registry = BUILTIN_BUILDERS) {
     const found = registry[platform];

package/dist/integrations/agent/model-aliases.js

@@ -11,6 +11,15 @@
  *               always resolve to the full name for determinism)
  */
 const BUILTIN_ALIASES = [
+    {
+        // Anthropic's Mythos-class tier above Opus — the recommended resolution
+        // target for the `deep` workflow tier (see docs/features/workflows.md).
+        alias: "fable",
+        platforms: {
+            claude: "claude-fable-5",
+            opencode: "opencode/claude-fable-5",
+        },
+    },
     {
         alias: "opus",
         platforms: {

package/dist/integrations/agent/profiles.js

@@ -9,9 +9,10 @@
 // every lane's read-back (GRR). It is a provenance tag, never a secret.
 const COMMON_PASSTHROUGH = ["HOME", "PATH", "USER", "LANG", "LC_ALL", "TERM", "TMPDIR", "AKM_EVENT_SOURCE"];
 /**
- * Built-in profiles for the five agent CLIs the v1 spec calls out
- * explicitly. The fields here are conservative defaults — every value is
- * overridable from user config.
+ * Built-in profiles for the agent CLIs akm knows out of the box: the five the
+ * v1 spec calls out explicitly, plus the P2 harness adapters (copilot, pi,
+ * amazonq, openhands — plan §"Capability matrix"). The fields here are
+ * conservative defaults — every value is overridable from user config.
  *
  * For headless/automation use (propose, reflect, tasks), use the '-headless' variant.
  */
@@ -56,9 +57,42 @@ const BUILTINS = {
         envPassthrough: [...COMMON_PASSTHROUGH, "OPENAI_API_KEY", "ANTHROPIC_API_KEY"],
         parseOutput: "text",
     },
+    // ── P2 harness-adapter profiles (plan §"Capability matrix") ────────────────
+    copilot: {
+        name: "copilot",
+        bin: "copilot",
+        args: [],
+        stdio: "interactive",
+        envPassthrough: [...COMMON_PASSTHROUGH, "GH_TOKEN", "GITHUB_TOKEN"],
+        parseOutput: "text",
+    },
+    pi: {
+        name: "pi",
+        bin: "pi",
+        args: [],
+        stdio: "interactive",
+        envPassthrough: [...COMMON_PASSTHROUGH, "PI_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY"],
+        parseOutput: "text",
+    },
+    amazonq: {
+        name: "amazonq",
+        bin: "q",
+        args: [],
+        stdio: "interactive",
+        envPassthrough: [...COMMON_PASSTHROUGH, "AWS_PROFILE", "AWS_REGION"],
+        parseOutput: "text",
+    },
+    openhands: {
+        name: "openhands",
+        bin: "openhands",
+        args: [],
+        stdio: "interactive",
+        envPassthrough: [...COMMON_PASSTHROUGH, "LLM_MODEL", "LLM_API_KEY", "LLM_BASE_URL"],
+        parseOutput: "text",
+    },
 };
 /**
- * Headless variants of the five base profiles for automation use (propose, reflect, tasks).
+ * Headless variants of the base profiles for automation use (propose, reflect, tasks).
  *
  * These profiles use `stdio: "captured"` and `parseOutput: "json"` so the
  * agent's response can be read from stdout. They share the same `bin` and
@@ -110,9 +144,42 @@ const HEADLESS_BUILTINS = {
         envPassthrough: [...COMMON_PASSTHROUGH, "OPENAI_API_KEY", "ANTHROPIC_API_KEY"],
         parseOutput: "json",
     },
+    // ── P2 harness-adapter headless variants (plan §"Capability matrix") ───────
+    "copilot-headless": {
+        name: "copilot-headless",
+        bin: "copilot",
+        args: [],
+        stdio: "captured",
+        envPassthrough: [...COMMON_PASSTHROUGH, "GH_TOKEN", "GITHUB_TOKEN"],
+        parseOutput: "json",
+    },
+    "pi-headless": {
+        name: "pi-headless",
+        bin: "pi",
+        args: [],
+        stdio: "captured",
+        envPassthrough: [...COMMON_PASSTHROUGH, "PI_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY"],
+        parseOutput: "json",
+    },
+    "amazonq-headless": {
+        name: "amazonq-headless",
+        bin: "q",
+        args: [],
+        stdio: "captured",
+        envPassthrough: [...COMMON_PASSTHROUGH, "AWS_PROFILE", "AWS_REGION"],
+        parseOutput: "json",
+    },
+    "openhands-headless": {
+        name: "openhands-headless",
+        bin: "openhands",
+        args: [],
+        stdio: "captured",
+        envPassthrough: [...COMMON_PASSTHROUGH, "LLM_MODEL", "LLM_API_KEY", "LLM_BASE_URL"],
+        parseOutput: "json",
+    },
 };
 /**
- * Names of the five primary built-in profiles. Stable, sorted. Does NOT
+ * Names of the primary built-in profiles. Stable, sorted. Does NOT
  * include the `-headless` variants (those are resolvable by name but are
  * excluded from detection/enumeration flows).
  */

package/dist/integrations/agent/runner-dispatch.js

@@ -28,8 +28,32 @@
  * (X2) can wrap `executeRunner` without changing this contract.
  */
 import { assertNever } from "../../core/assert.js";
-import { runOpencodeSdk } from "../harnesses/opencode-sdk/index.js";
+import { closeServer as disposeOpencodeSdkServers, runOpencodeSdk } from "../harnesses/opencode-sdk/index.js";
 import { runAgent } from "./spawn.js";
+/**
+ * Release every long-lived resource the dispatch runners CACHE for reuse, so a
+ * one-shot process (the CLI) can exit cleanly once dispatching is done.
+ *
+ * The `sdk` runner keeps a per-env registry of `opencode serve` CHILD
+ * PROCESSES (see `opencode-sdk/sdk-runner.ts`), started lazily and reused
+ * across units within a process. Each live child is an OS handle that keeps
+ * Bun's event loop open — and the registry's own teardown is wired ONLY to
+ * `process.once('exit')`, which never fires while such a child holds the loop
+ * open. That is a deadlock: a successful `akm workflow run` that dispatched via
+ * the SDK path would hang the CLI (owner finding 4) because the process is
+ * never idle enough for the exit hook to run and close the children it is
+ * waiting on.
+ *
+ * The engine therefore calls this in its run `finally` (every exit path —
+ * success, gate rejection, failure, abort) to drain the registry deterministically
+ * BEFORE relying on the event loop to drain. The close is synchronous and
+ * idempotent; when no SDK server was ever started it is a no-op, so the `agent`
+ * / `llm` dispatch paths pay nothing. Servers are re-created lazily on the next
+ * dispatch, so calling this between independent dispatch invocations is safe.
+ */
+export function disposeDispatchResources() {
+    disposeOpencodeSdkServers();
+}
 /**
  * Dispatch a {@link RunnerSpec} to its runner and return the raw
  * {@link AgentRunResult}. `opts` is the {@link RunAgentOptions} for the profile

package/dist/integrations/agent/spawn.js

@@ -143,21 +143,93 @@ function buildChildEnv(profile, options) {
     }
     return env;
 }
+const STREAM_READ_TIMEOUT = Symbol("stream-read-timeout");
 async function readStream(stream, opts) {
     if (!stream)
-        return "";
-    const readPromise = new Response(stream).text().catch(() => "");
-    if (!opts?.timeoutMs)
-        return readPromise;
+        return { text: "", timedOut: false };
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let text = "";
+    if (!opts?.timeoutMs) {
+        try {
+            while (true) {
+                const chunk = await reader.read();
+                if (chunk.done)
+                    break;
+                text += decoder.decode(chunk.value, { stream: true });
+            }
+            text += decoder.decode();
+            return { text, timedOut: false };
+        }
+        catch (error) {
+            return { text, timedOut: false, error };
+        }
+        finally {
+            try {
+                reader.releaseLock();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
     // Race the stream read against a timeout so a process that is killed via
     // SIGTERM/SIGKILL but whose pipe endpoints stay open (e.g. background
     // threads still holding the fd) cannot block the caller indefinitely.
-    // On timeout we return whatever we received so far (empty string here since
-    // `readPromise` is all-or-nothing with `Response.text()`).
+    // On timeout we return whatever was decoded before the pipe stopped draining.
+    const setTimeoutImpl = opts.setTimeoutFn ?? setTimeout;
+    const clearTimeoutImpl = opts.clearTimeoutFn ?? clearTimeout;
+    let timer;
     const timeoutPromise = new Promise((resolve) => {
-        setTimeout(() => resolve(""), opts.timeoutMs);
+        timer = setTimeoutImpl(() => {
+            timer = undefined;
+            resolve(STREAM_READ_TIMEOUT);
+        }, opts.timeoutMs);
+        if (typeof timer !== "number")
+            timer.unref?.();
     });
-    return Promise.race([readPromise, timeoutPromise]);
+    try {
+        while (true) {
+            const chunk = await Promise.race([reader.read(), timeoutPromise]);
+            if (chunk === STREAM_READ_TIMEOUT) {
+                void reader.cancel().catch(() => { });
+                return { text, timedOut: true };
+            }
+            if (chunk.done)
+                break;
+            text += decoder.decode(chunk.value, { stream: true });
+        }
+        text += decoder.decode();
+        return { text, timedOut: false };
+    }
+    catch (error) {
+        return { text, timedOut: false, error };
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeoutImpl(timer);
+        }
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+function streamFailureMessage(profileName, stdout, stderr) {
+    const failures = [];
+    if (stdout.error)
+        failures.push(`stdout read failed: ${stdout.error instanceof Error ? stdout.error.message : String(stdout.error)}`);
+    if (stderr.error)
+        failures.push(`stderr read failed: ${stderr.error instanceof Error ? stderr.error.message : String(stderr.error)}`);
+    if (stdout.timedOut)
+        failures.push("stdout drain timed out");
+    if (stderr.timedOut)
+        failures.push("stderr drain timed out");
+    if (failures.length === 0)
+        return undefined;
+    return `agent CLI "${profileName}" output capture failed: ${failures.join("; ")}`;
 }
 /**
  * Spawn the agent CLI described by `profile` with `prompt` (forwarded as
@@ -184,6 +256,17 @@ export async function runAgent(profile, prompt, options = {}) {
     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; fall back to the legacy positional-prompt form otherwise.
     let builtArgv;
@@ -247,6 +330,10 @@ export async function runAgent(profile, prompt, options = {}) {
             error: err instanceof Error ? err.message : String(err),
         };
     }
+    emitSpawnEvent("spawn_start", {
+        profile: profile.name,
+        ...(typeof proc.pid === "number" ? { pid: proc.pid } : {}),
+    });
     // Hard timeout. We prefer SIGTERM, then SIGKILL if SIGTERM is ignored,
     // but the subprocess only exposes a single .kill() — one signal is enough
     // for the structured-failure contract.
@@ -267,11 +354,13 @@ export async function runAgent(profile, prompt, options = {}) {
             timedOut = true;
             killGroup(proc, "SIGTERM");
             // Follow up with SIGKILL after 5 s in case the process ignores SIGTERM.
-            setTimeoutImpl(() => {
+            const sigkillTimer = setTimeoutImpl(() => {
                 if (!proc || proc.exitCode !== null)
                     return;
                 killGroup(proc, "SIGKILL");
             }, 5000);
+            if (typeof sigkillTimer !== "number")
+                sigkillTimer.unref?.();
         }, timeoutMs);
     }
     // Cooperative cancel: same SIGTERM→SIGKILL discipline as the timeout, but
@@ -308,11 +397,19 @@ export async function runAgent(profile, prompt, options = {}) {
     // When there is no kill timer, allow up to 30 s for streams to drain.
     const streamDrainTimeoutMs = timeoutMs !== null ? timeoutMs + 2_000 : 30_000;
     const stdoutPromise = stdioMode === "captured"
-        ? readStream(proc.stdout ?? null, { timeoutMs: streamDrainTimeoutMs })
-        : Promise.resolve("");
+        ? readStream(proc.stdout ?? null, {
+            timeoutMs: streamDrainTimeoutMs,
+            setTimeoutFn: setTimeoutImpl,
+            clearTimeoutFn: clearTimeoutImpl,
+        })
+        : Promise.resolve({ text: "", timedOut: false });
     const stderrPromise = stdioMode === "captured"
-        ? readStream(proc.stderr ?? null, { timeoutMs: streamDrainTimeoutMs })
-        : Promise.resolve("");
+        ? readStream(proc.stderr ?? null, {
+            timeoutMs: streamDrainTimeoutMs,
+            setTimeoutFn: setTimeoutImpl,
+            clearTimeoutFn: clearTimeoutImpl,
+        })
+        : Promise.resolve({ text: "", timedOut: false });
     // Optional stdin payload (captured mode only).
     //
     // BUG-H1: race the stdin write/close against `proc.exited` and the
@@ -352,6 +449,12 @@ export async function runAgent(profile, prompt, options = {}) {
         // will not block indefinitely.
         await Promise.allSettled([stdoutPromise, stderrPromise]);
         const durationMs = Date.now() - start;
+        emitSpawnEvent("spawn_exit", {
+            profile: profile.name,
+            ...(typeof proc.pid === "number" ? { pid: proc.pid } : {}),
+            exitCode: null,
+            status: "spawn_failed",
+        });
         return {
             ok: false,
             exitCode: null,
@@ -364,7 +467,15 @@ export async function runAgent(profile, prompt, options = {}) {
     }
     clearTimeoutImpl(timer);
     abortSignal?.removeEventListener("abort", onAbort);
-    const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+    emitSpawnEvent("spawn_exit", {
+        profile: profile.name,
+        ...(typeof proc.pid === "number" ? { pid: proc.pid } : {}),
+        exitCode,
+        status: aborted ? "aborted" : timedOut ? "timeout" : exitCode !== 0 ? "non_zero_exit" : "ok",
+    });
+    const [stdoutRead, stderrRead] = await Promise.all([stdoutPromise, stderrPromise]);
+    const stdout = stdoutRead.text;
+    const stderr = stderrRead.text;
     const durationMs = Date.now() - start;
     if (aborted) {
         return {
@@ -388,6 +499,18 @@ export async function runAgent(profile, prompt, options = {}) {
             error: `agent CLI "${profile.name}" timed out after ${timeoutMs ?? 0}ms`,
         };
     }
+    const captureFailure = streamFailureMessage(profile.name, stdoutRead, stderrRead);
+    if (captureFailure) {
+        return {
+            ok: false,
+            exitCode,
+            stdout,
+            stderr,
+            durationMs,
+            reason: "spawn_failed",
+            error: captureFailure,
+        };
+    }
     if (exitCode !== 0) {
         return {
             ok: false,

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

@@ -0,0 +1,113 @@
+// 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/.
+/**
+ * Aider 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 `aider` CLI expects. Per the capability matrix the
+ * headless invocation is:
+ *
+ *   aider -m "<p>" --yes-always
+ *
+ * with `--model <m>` for model selection, NO structured-output mode (Aider is
+ * the "none" tier — prompt-injected schema + embedded-JSON extraction), and
+ * NO session flag (resume is chat-history files, not an id).
+ *
+ * Platform-specific mapping decisions (all localized here, per the adapter
+ * contract):
+ *
+ * - **prompt** — `--message` is Aider's one-shot non-interactive mode (the
+ *   matrix's `-m`; the long form is used for self-documenting argv). Unlike
+ *   claude/codex/pi there is NO positional prompt and NO `--` end-of-options
+ *   separator to hide behind: the prompt is a *flag value*. The glued
+ *   `--message=<payload>` form is therefore used so a payload that begins
+ *   with `-`/`--` binds to the flag lexically and can never be parsed as a
+ *   separate option by Aider's argument parser.
+ * - **--yes-always** — always emitted: auto-confirms every interactive
+ *   prompt (create file? run command? …), which is what makes a captured,
+ *   unattended run possible. This is the matrix's documented headless shape.
+ * - **--no-pretty** — always emitted: disables colored/pretty terminal
+ *   rendering so captured stdout is clean text for `./result-extractor.ts`
+ *   (the same "dispatch is the captured path" reasoning as the Claude
+ *   builder's unconditional `--print` and Codex's unconditional `--json`).
+ * - **systemPrompt** — Aider has no system-prompt flag (its nearest concept
+ *   is conventions files via `--read`, which take a path, not text). Folded
+ *   into the message payload — system text first, blank line, then the task —
+ *   mirroring the codex builder's treatment.
+ * - **schema** — the matrix places Aider in the "via prompt+validate" tier
+ *   with *no* structured output mode at all (plan §"Structured-output
+ *   normalization", tier "none"): there is no schema flag and no JSON output
+ *   flag, so the JSON Schema is injected into the message payload using the
+ *   exact directive wording of the engine's prompt assembly
+ *   (`step-work.ts` `buildUnitPrompt`) and the pi builder, so all
+ *   dispatch paths speak one dialect. Downstream, embedded-JSON extraction +
+ *   the engine's shared retry-until-valid loop supply the validation Aider
+ *   lacks. No temp schema file is written — that is Codex's native-schema
+ *   mechanism (`--output-schema`), which Aider does not have.
+ * - **tools** — deliberately unconsumed. Aider has no per-tool allowlist
+ *   flag; tool-ish behaviour is governed by its own switches (`--yes-always`,
+ *   git integration, shell-command confirmation). A restrictive policy is
+ *   therefore dropped rather than approximated — never silently widened.
+ * - **resume/session** — NOT expressible: Aider persists context in
+ *   chat-history files (`.aider.chat.history.md`), not session ids, so there
+ *   is no flag-shaped `HarnessResumeSupport` to export and the extractor
+ *   never yields a `sessionId`. akm's `workflow_run_units` remains the
+ *   durable source of truth; resume works even against a harness with no
+ *   session model (plan §"Session, MCP, and identity across harnesses" —
+ *   Aider is the plan's named example).
+ * - **effort** — stays unconsumed (reserved; the shared request contract's
+ *   "no builder consumes it yet" note stays true).
+ *
+ * NOT registered anywhere: `builders.ts` / `harnesses/index.ts` wiring is a
+ * follow-up integration task (as is the registry entry declaring
+ * `structuredOutput: "none"` and no `resume`). Exported standalone so that
+ * task only adds a registry entry.
+ */
+import { assertNotFlag } from "../../agent/builder-shared.js";
+import { resolveModel } from "../../agent/model-aliases.js";
+/** Canonical harness/platform id used for model-alias resolution. */
+export const AIDER_PLATFORM = "aider";
+/**
+ * Assemble the `--message` payload: optional system text, the task prompt,
+ * and — when a schema is requested — the same schema directive the workflow
+ * engine's prompt assembly uses (Aider has no native structured output, so
+ * the prompt is the only channel; plan §"Structured-output normalization",
+ * tier "none").
+ */
+function buildMessagePayload(req) {
+    const sections = [];
+    if (req.systemPrompt)
+        sections.push(req.systemPrompt);
+    sections.push(req.prompt);
+    if (req.schema) {
+        sections.push(`Respond with ONLY a JSON value matching this JSON Schema (no prose, no code fences):\n${JSON.stringify(req.schema)}`);
+    }
+    return sections.join("\n\n");
+}
+/**
+ * Aider builder.
+ * Command shape:
+ *   aider [--model <m>] --yes-always --no-pretty --message=<[system\n\n]prompt[\n\nschema directive]>
+ */
+export const aiderBuilder = {
+    platform: AIDER_PLATFORM,
+    build(profile, req) {
+        assertNotFlag(req.systemPrompt, "systemPrompt");
+        assertNotFlag(req.model, "model");
+        const args = [...profile.args];
+        if (req.model) {
+            const resolved = resolveModel(req.model, AIDER_PLATFORM, profile.modelAliases, profile.globalModelAliases);
+            args.push("--model", resolved);
+        }
+        // Headless essentials (matrix shape): auto-confirm everything, and keep
+        // captured stdout free of pretty/ANSI rendering for the extractor.
+        args.push("--yes-always");
+        args.push("--no-pretty");
+        // Glued form: the payload is a flag VALUE (no positional prompt exists),
+        // so `=` binding keeps a dash-leading payload from parsing as an option.
+        args.push(`--message=${buildMessagePayload(req)}`);
+        return { argv: [profile.bin, ...args] };
+    },
+};

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

@@ -0,0 +1,58 @@
+// 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/.
+/**
+ * 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.
+ */
+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";
+function caps(c) {
+    return {
+        sessionLogs: false,
+        agentDispatch: false,
+        detection: false,
+        configImport: false,
+        runtimeIdentity: false,
+        v1Migration: false,
+        ...c,
+    };
+}
+/**
+ * Aider.
+ *
+ * Canonical id is `'aider'`; no alias or distinct runtime identity.
+ */
+export class AiderHarness extends BaseHarness {
+    id = "aider";
+    displayName = "Aider";
+    aliases = [];
+    agentBuilder = aiderBuilder;
+    resultExtractor = aiderResultExtractor;
+    // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
+    // akm spawns the `aider` CLI locally per unit ⇒ local-runner.
+    pattern = "local-runner";
+    // No structured-output mode at all (the matrix's "none — parse output"):
+    // akm injects the schema into the prompt and extracts embedded JSON.
+    structuredOutput = "none";
+    // No `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,
+    });
+}