akm-cli 0.9.24 → 0.9.25-alpha.2

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

@@ -39,13 +39,11 @@
  * - **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.
+ *   flag, so the JSON Schema reaches it only as the instruction the shared
+ *   request lowering appends to the prompt. 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
@@ -57,41 +55,31 @@
  *   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).
+ * - **inference** — not translated: the shared lowering reports each field of
+ *   the request's inference as untranslated.
  *
  * Registered: `aiderBuilder` is `AiderHarness.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 `"aider"` platform
- * name without any further wiring. The registry entry also declares
- * `structuredOutput: "none"` alongside it (`./index.ts`).
+ * 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 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").
- */
+/** Assemble the `--message` payload: optional system text, then the task prompt. */
 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]>
+ *   aider [--model <m>] --yes-always --no-pretty --message=<[system\n\n]prompt>
  */
 export const aiderBuilder = {
     platform: AIDER_PLATFORM,
@@ -100,7 +88,6 @@ export const aiderBuilder = {
         adapter: AIDER_PLATFORM,
         personaChannel: "prompt",
         tools: "none",
-        outputSchema: true,
     }),
     build(profile, req) {
         const args = [...profile.args];

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

@@ -29,11 +29,6 @@ export class AiderHarness extends BaseHarness {
     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 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

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

@@ -35,9 +35,8 @@
  *   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 is therefore passed
- *   through the prompt: a directive matching the engine's wording
- *   (`step-work.ts` `buildUnitPrompt`) is appended to the payload.
+ *   `--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
@@ -51,16 +50,14 @@
  *   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.
- * - **effort** — stays unconsumed (reserved; the shared request contract's
- *   "no builder consumes it yet" note stays true).
+ * - **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. The registry-side capability entry —
- * pattern `local-runner`, structuredOutput `none` — is declared alongside it
- * (`./index.ts`).
+ * name without any further wiring.
  */
 import { resolveDispatchModel } from "../../agent/builder-shared.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
@@ -84,27 +81,19 @@ function toolPolicyEntries(tools) {
     }
     return undefined;
 }
-/**
- * Assemble the positional prompt payload: optional system prompt, the task
- * prompt, and — when a schema is requested — the same schema directive the
- * workflow engine's prompt assembly uses, so both dispatch paths speak one
- * dialect.
- */
+/** 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);
-    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");
 }
 /**
  * Amazon Q Developer CLI builder.
  * Command shape:
  *   q chat --no-interactive (--trust-all-tools | --trust-tools=<t1,t2>)
- *          [--model <m>] -- "<systemPrompt?\n\nprompt\n\nschema directive?>"
+ *          [--model <m>] -- "<systemPrompt?\n\nprompt>"
  */
 export const amazonqBuilder = {
     platform: AMAZONQ_PLATFORM,
@@ -113,7 +102,6 @@ export const amazonqBuilder = {
         adapter: AMAZONQ_PLATFORM,
         personaChannel: "prompt",
         tools: "flat",
-        outputSchema: true,
     }),
     build(profile, req) {
         // Built-in q profiles would ship `args: []`; headless dispatch is the
@@ -141,8 +129,8 @@ export const amazonqBuilder = {
             const resolved = resolveDispatchModel(req, profile, AMAZONQ_PLATFORM);
             args.push("--model", resolved);
         }
-        // No system-prompt / schema flags exist on `q chat` — both travel in the
-        // positional payload, after the end-of-options separator.
+        // 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/index.js

@@ -30,11 +30,6 @@ export class AmazonqHarness extends BaseHarness {
     agentBuilder = amazonqBuilder;
     resultExtractor = amazonqResultExtractor;
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // akm spawns `q chat` locally per unit ⇒ local-runner.
-    pattern = "local-runner";
-    // No documented structured output: akm injects the schema into the prompt
-    // and extracts embedded JSON from plain-text stdout.
-    structuredOutput = "none";
     // No `identityEnv`: the matrix lists Q's identity markers as uncertain, and
     // Q stamps no session var onto child processes.
     capabilities = caps({

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

@@ -11,51 +11,57 @@
  * in `agent/builders.ts`, which imports this builder back into
  * `BUILTIN_BUILDERS`.
  *
- * ## Structured output (Codex round-3 finding A)
+ * ## Structured output
  *
- * The headless `claude -p` (`--print`) CLI has NO native output-SCHEMA flag
- * (unlike Codex's `--output-schema <file>`). Its documented structured path is
- * `--output-format json`, which wraps the run in a RESULT ENVELOPE
- * (`{"type":"result","result":"<final answer>","session_id":"…", …}`) — the
- * "native-json" tier, NOT "native-schema". (The registry's earlier
- * `native-schema` claim described Claude Code's IN-HARNESS `Workflow`/`agent()`
- * tool-input-schema path, which is a different execution surface than the
- * agentBuilder dispatch akm's local-runner uses; the descriptor is aligned to
- * `native-json` to match this builder honestly.)
+ * 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.
  *
- * So for a schema-bearing unit this builder emits `--output-format json` and
- * appends the SAME schema directive the engine's prompt assembly uses
- * (`step-work.ts` `buildUnitPrompt`) so a direct (non-workflow) dispatch is
- * self-sufficient — matching the copilot/gemini native-json builders. The
- * result envelope is unwrapped by `./result-extractor.ts`, and the engine's
- * shared `runStructured` retry-until-valid loop still validates the extracted
- * text against the node schema (constrained/hinted output is trusted but
- * verified). Without a schema the argv is byte-identical to the pre-fix shape.
+ * 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 { normalizeTools, resolveDispatchModel, } from "../../agent/builder-shared.js";
+import { modelFromArgs, normalizeTools, resolveDispatchModel, } from "../../agent/builder-shared.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
-/**
- * Assemble the positional prompt: the task prompt and — when a schema is
- * requested — the same schema directive the workflow engine's prompt assembly
- * uses (`step-work.ts` `buildUnitPrompt`), so both dispatch paths speak one
- * dialect. Claude Code takes the system prompt as a `--system-prompt` FLAG (it
- * has one, unlike copilot/gemini), so only the schema directive is folded in
- * here.
- */
-function buildPromptPayload(req) {
-    if (!req.schema)
-        return req.prompt;
-    return `${req.prompt}\n\nRespond with ONLY a JSON value matching this JSON Schema (no prose, no code fences):\n${JSON.stringify(req.schema)}`;
-}
+/** 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 (+ schema directive)>"
+ *          [--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",
@@ -65,10 +71,10 @@ export const claudeBuilder = {
         personaChannel: "native",
         nativeAgentSelector: true,
         tools: "all",
-        outputSchema: true,
     }),
     build(profile, req) {
-        const args = [...profile.args];
+        const modelWork = req.modelWork === true;
+        const args = modelWork ? [...MODEL_WORK_CLAUDE_FLAGS] : [...profile.args];
         if (req.agent) {
             args.push("--agent", req.agent);
         }
@@ -79,6 +85,11 @@ export const claudeBuilder = {
             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));
         }
@@ -90,7 +101,7 @@ export const claudeBuilder = {
         // --print = non-interactive, outputs to stdout — required for captured mode
         args.push("--print");
         args.push("--");
-        args.push(buildPromptPayload(req));
+        args.push(req.prompt);
         return { argv: [profile.bin, ...args] };
     },
 };

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

@@ -24,20 +24,6 @@ export class ClaudeHarness extends BaseHarness {
     agentBuilder = claudeBuilder;
     resultExtractor = claudeResultExtractor;
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // Claude Code is the in-harness pattern: the orchestrating session itself
-    // drives units via the `akm workflow` gate spine (`claude -p` headless
-    // dispatch also exists via `agentBuilder`, but the pattern classification
-    // follows the matrix row).
-    pattern = "in-harness";
-    // Structured output tier for the AGENT-DISPATCH (`claude -p`) path akm's
-    // local runner uses (Codex round-3 finding A). The headless CLI has NO
-    // output-schema flag — its documented structured path is `--output-format
-    // json`, a RESULT ENVELOPE akm parses (`./result-extractor.ts`) and then
-    // validates against the node schema ⇒ the "native-json" tier. (Claude Code's
-    // in-harness `Workflow`/`agent()` tool-input-schema path IS native-schema,
-    // but that is a different surface than the dispatch builder — the descriptor
-    // is aligned to what the builder honestly does.)
-    structuredOutput = "native-json";
     // 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"];

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

@@ -42,9 +42,9 @@
  *     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`.
- *   - `req.effort` stays unconsumed (reserved; codex would take it as
- *     `-c model_reasoning_effort=<v>` — left to the integration task so the
- *     shared request contract's "no builder consumes it yet" note stays true).
+ *   - 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
@@ -110,7 +110,6 @@ export const codexBuilder = {
         adapter: "codex",
         personaChannel: "prompt",
         tools: "none",
-        outputSchema: true,
     }),
     build(profile, req) {
         // Built-in codex profiles ship `args: []`; headless dispatch is the `exec`

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

@@ -29,10 +29,6 @@ export class CodexHarness extends BaseHarness {
     agentBuilder = codexBuilder;
     resultExtractor = codexResultExtractor;
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // akm spawns `codex exec` locally per unit ⇒ local-runner.
-    pattern = "local-runner";
-    // `--output-schema <file>` enforces a caller-supplied JSON schema natively.
-    structuredOutput = "native-schema";
     // 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

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

@@ -24,9 +24,8 @@
  *   blank line.
  * - **schema** — the matrix places Copilot in the "via prompt+validate" tier
  *   (no native `--output-schema` equivalent, unlike Codex), so the JSON
- *   Schema is passed through the prompt: a directive matching the engine's
- *   wording (`step-work.ts` `buildUnitPrompt`) is appended to the `-p`
- *   payload, and `--output-format json` is emitted so stdout is the
+ *   Schema reaches it as the instruction the shared request lowering appends
+ *   to the prompt, and `--output-format json` is emitted so stdout is the
  *   documented JSON envelope the copilot result extractor normalizes. The
  *   engine's shared retry-until-valid loop performs the actual validation.
  * - **tools** — a string/array tool policy maps to repeated
@@ -66,26 +65,19 @@ function toolPolicyEntries(tools) {
     }
     return undefined;
 }
-/**
- * Assemble the `-p` payload: optional system prompt, the task prompt, and —
- * when a schema is requested — the same schema directive the workflow
- * engine's prompt assembly uses, so both dispatch paths speak one dialect.
- */
+/** Assemble the `-p` payload: optional system prompt, then the task prompt. */
 function buildPromptPayload(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");
 }
 /**
  * GitHub Copilot CLI builder.
  * Command shape:
  *   copilot [--model <m>] (--allow-all-tools | --allow-tool <t> ...)
- *           [--output-format json] -p "<systemPrompt?\n\nprompt\n\nschema?>"
+ *           [--output-format json] -p "<systemPrompt?\n\nprompt>"
  */
 export const copilotBuilder = {
     platform: COPILOT_PLATFORM,
@@ -94,7 +86,6 @@ export const copilotBuilder = {
         adapter: COPILOT_PLATFORM,
         personaChannel: "prompt",
         tools: "flat",
-        outputSchema: true,
     }),
     build(profile, req) {
         const args = [...profile.args];

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

@@ -10,8 +10,8 @@
  *
  * It also defines {@link CopilotHarness}, the {@link AkmHarness} descriptor
  * that `HARNESS_REGISTRY` registers. This is the LOCAL Copilot CLI
- * (`copilot -p …`); the cloud "Copilot coding agent" is the plan's
- * cloud-delegate pattern and is a separate, future descriptor.
+ * (`copilot -p …`); the cloud "Copilot coding agent" is a separate, future
+ * descriptor.
  */
 import { caps } from "../shared.js";
 import { BaseHarness } from "../types.js";
@@ -30,11 +30,6 @@ export class CopilotHarness extends BaseHarness {
     agentBuilder = copilotBuilder;
     resultExtractor = copilotResultExtractor;
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // akm spawns the `copilot` CLI locally per unit ⇒ local-runner.
-    pattern = "local-runner";
-    // `--output-format json` emits a documented JSON envelope akm parses, then
-    // validates against the node schema ⇒ native-json tier.
-    structuredOutput = "native-json";
     // Session-id env marker only. The matrix's other candidates (GH_TOKEN,
     // bare COPILOT_* presence vars) are credential/presence flags that would
     // stamp identity onto manual runs, so they are deliberately NOT registered

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

@@ -26,9 +26,8 @@
  *   prompt, separated by a blank line.
  * - **schema** — the matrix places Gemini in the "via prompt+validate" tier
  *   (no native `--output-schema` equivalent, unlike Codex — so no temp-file
- *   plumbing here), so the JSON Schema is passed through the prompt: a
- *   directive matching the engine's wording (`step-work.ts`
- *   `buildUnitPrompt`) is appended to the `-p` payload, and
+ *   plumbing here), so the JSON Schema reaches it as the instruction the
+ *   shared request lowering appends to the prompt, and
  *   `--output-format json` is emitted so stdout is the documented JSON
  *   envelope the gemini result extractor normalizes. The engine's shared
  *   retry-until-valid loop performs the actual validation.
@@ -69,26 +68,19 @@ function toolPolicyEntries(tools) {
     }
     return undefined;
 }
-/**
- * Assemble the `-p` payload: optional system prompt, the task prompt, and —
- * when a schema is requested — the same schema directive the workflow
- * engine's prompt assembly uses, so both dispatch paths speak one dialect.
- */
+/** Assemble the `-p` payload: optional system prompt, then the task prompt. */
 function buildPromptPayload(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");
 }
 /**
  * Gemini CLI builder.
  * Command shape:
  *   gemini [--model <m>] [--allowed-tools <t> ...]
- *          [--output-format json] -p "<systemPrompt?\n\nprompt\n\nschema?>"
+ *          [--output-format json] -p "<systemPrompt?\n\nprompt>"
  */
 export const geminiBuilder = {
     platform: GEMINI_PLATFORM,
@@ -97,7 +89,6 @@ export const geminiBuilder = {
         adapter: GEMINI_PLATFORM,
         personaChannel: "prompt",
         tools: "flat",
-        outputSchema: true,
     }),
     build(profile, req) {
         const args = [...profile.args];

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

@@ -29,11 +29,6 @@ export class GeminiHarness extends BaseHarness {
     agentBuilder = geminiBuilder;
     resultExtractor = geminiResultExtractor;
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // akm spawns the `gemini` CLI locally per unit ⇒ local-runner.
-    pattern = "local-runner";
-    // `--output-format json` emits a documented JSON envelope akm parses, then
-    // validates against the node schema ⇒ native-json tier.
-    structuredOutput = "native-json";
     // The matrix's identity marker: Gemini CLI stamps GEMINI_CLI=1 only on
     // processes it spawns, so it genuinely means "running under gemini" (it is
     // not a user-profile config var) — but its VALUE ("1") is a bare flag, not

package/dist/integrations/harnesses/ids.js

@@ -2,16 +2,16 @@
 // 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/.
 export const HARNESS_ID_TABLE = [
-    { id: "opencode", agentDispatch: true },
-    { id: "claude", agentDispatch: true },
-    { id: "opencode-sdk", agentDispatch: true },
-    { id: "codex", agentDispatch: true },
-    { id: "copilot", agentDispatch: true },
-    { id: "pi", agentDispatch: true },
-    { id: "gemini", agentDispatch: true },
-    { id: "aider", agentDispatch: true },
-    { id: "amazonq", agentDispatch: true },
-    { id: "openhands", agentDispatch: true },
+    { id: "opencode", agentDispatch: true, enforcesModelWorkTools: true },
+    { id: "claude", agentDispatch: true, enforcesModelWorkTools: true },
+    { id: "opencode-sdk", agentDispatch: true, enforcesModelWorkTools: true },
+    { id: "codex", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "copilot", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "pi", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "gemini", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "aider", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "amazonq", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "openhands", agentDispatch: true, enforcesModelWorkTools: false },
 ];
 /**
  * Canonical, ordered list of valid harness / platform ids — the
@@ -22,3 +22,5 @@ export const HARNESS_ID_TABLE = [
 export const VALID_HARNESS_IDS = Object.freeze(HARNESS_ID_TABLE.map((h) => h.id));
 /** Harness ids whose `capabilities.agentDispatch` is `true`. */
 export const HARNESS_AGENT_DISPATCH_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.agentDispatch).map((h) => h.id));
+/** Harness ids that confine the model-work tool policy, so unattended model work may run on them. */
+export const HARNESS_MODEL_WORK_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.enforcesModelWorkTools).map((h) => h.id));

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

@@ -14,26 +14,61 @@
  * pre-migration `opencodeBuilder`. The builder's `platform` stays `'opencode'`
  * (the canonical harness id).
  */
-import { resolveDispatchModel } from "../../agent/builder-shared.js";
+import { modelFromArgs, resolveDispatchModel } from "../../agent/builder-shared.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
+import { MODEL_WORK_AGENT_INFERENCE, opencodeInferenceConfig } from "./model-config.js";
+import { MODEL_WORK_OPENCODE_AGENT, modelWorkOpencodeConfig, modelWorkPluginEnv } from "./model-work-agent.js";
 /**
  * OpenCode builder.
- * Command shape: opencode run [--system-prompt "..."] [--agent <name>] [--model <m>] "<prompt>"
+ * Command shape: opencode run [--agent <name>] [--model <m>] -- "<prompt>"
+ *
+ * `opencode run` has no system-prompt option (1.18.25 prints its usage and
+ * exits 1 on `--system-prompt`), so the shared lowerer composes a persona
+ * into the prompt.
  *
  * Tool policy is omitted — opencode manages tool access through its own agent
- * config files, not via CLI flags.
+ * config files, not via CLI flags. The one exception is the model-work tool
+ * policy: the builder injects its confined agent through
+ * `OPENCODE_CONFIG_CONTENT` and selects it with `--agent`. That command is
+ * akm's own (`opencode run --agent akm-model-work`): the engine's `args` are
+ * left out, because one such as `--attach` or `--dir` would move the run out
+ * of the injected config or the scratch working directory. Only the model they
+ * name is kept.
+ *
+ * Model work's agent carries the request's inference options
+ * (`./model-config.ts`). Any other dispatch injects nothing and carries none, so
+ * the model's own opencode config applies: set inference there.
  */
 export const opencodeBuilder = {
     platform: "opencode",
-    personaChannel: "native",
+    personaChannel: "prompt",
     lower: createAgentRequestLowerer({
         adapter: "opencode",
-        personaChannel: "native",
+        personaChannel: "prompt",
         nativeAgentSelector: true,
         tools: "none",
-        outputSchema: false,
+        inference: MODEL_WORK_AGENT_INFERENCE,
     }),
     build(profile, req) {
+        if (req.modelWork) {
+            const model = req.model ?? modelFromArgs(profile.args);
+            const { agentOptions } = opencodeInferenceConfig(req.inference, true);
+            return {
+                argv: [
+                    profile.bin,
+                    "run",
+                    "--agent",
+                    MODEL_WORK_OPENCODE_AGENT,
+                    ...(model ? ["--model", model] : []),
+                    "--",
+                    req.prompt,
+                ],
+                env: {
+                    ...modelWorkPluginEnv(),
+                    OPENCODE_CONFIG_CONTENT: JSON.stringify(modelWorkOpencodeConfig(agentOptions)),
+                },
+            };
+        }
         const args = req.model ? [] : [...profile.args];
         if (req.model) {
             for (let index = 0; index < profile.args.length; index += 1) {
@@ -48,9 +83,6 @@ export const opencodeBuilder = {
                 }
             }
         }
-        if (req.systemPrompt) {
-            args.push("--system-prompt", req.systemPrompt);
-        }
         if (req.agent) {
             args.push("--agent", req.agent);
         }

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

@@ -21,14 +21,6 @@ export class OpencodeHarness extends BaseHarness {
     setupDetectionDir = ".config/opencode";
     agentBuilder = opencodeBuilder;
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // This entry is the CLI spawn path (`opencode run …`): akm launches the
-    // harness locally per unit ⇒ local-runner. (The SDK path is the separate
-    // `opencode-sdk` harness.)
-    pattern = "local-runner";
-    // The CLI path emits plain text — no JSON stream akm consumes — so the
-    // engine uses the prompt-injected schema + embedded-JSON extraction tier
-    // (the matrix's "via prompt+validate"). The SDK entry is native-json.
-    structuredOutput = "none";
     // Session-id env marker for run attribution.
     identityEnv = ["OPENCODE_SESSION_ID"];
     sessionLogProvider = () => new OpenCodeProvider();