akm-cli 0.9.24 → 0.9.25-alpha.1

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,64 @@
  * 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 { isModelWorkTools } from "../../../execution/source.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)>"
+ *   claude [--agent <name>] [--system-prompt "..."] [--model <m>] [--effort <level>]
+ *          [--allowedTools <t>] [--output-format json] --print -- "<prompt>"
  *
  * --print switches Claude Code to non-interactive captured output mode.
+ *
+ * `--effort` carries the request's `reasoningEffort` as the harness's own
+ * level (`low`, `medium`, `high`, `xhigh` or `max` in 2.1.283), passed through
+ * as given: a value Claude Code rejects fails the dispatch. It is the only
+ * inference field Claude Code takes on its command line, so the others are
+ * reported as untranslated.
+ *
+ * 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 +78,12 @@ export const claudeBuilder = {
         personaChannel: "native",
         nativeAgentSelector: true,
         tools: "all",
-        outputSchema: true,
+        modelWorkTools: true,
+        inference: ["reasoningEffort"],
     }),
     build(profile, req) {
-        const args = [...profile.args];
+        const modelWork = isModelWorkTools(req.tools);
+        const args = modelWork ? [...MODEL_WORK_CLAUDE_FLAGS] : [...profile.args];
         if (req.agent) {
             args.push("--agent", req.agent);
         }
@@ -79,7 +94,15 @@ export const claudeBuilder = {
             const resolved = resolveDispatchModel(req, profile, "claude");
             args.push("--model", resolved);
         }
-        if (req.tools) {
+        else if (modelWork) {
+            const model = modelFromArgs(profile.args);
+            if (model)
+                args.push("--model", model);
+        }
+        const effort = req.inference?.reasoningEffort;
+        if (typeof effort === "string" && effort.length > 0)
+            args.push("--effort", effort);
+        if (req.tools && !modelWork) {
             args.push("--allowedTools", normalizeTools(req.tools));
         }
         if (req.schema) {
@@ -90,7 +113,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,10 @@
  *     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 (`inference` in `harnesses/ids.ts` lists none
+ *     for codex). 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 +111,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

@@ -1,17 +1,19 @@
 // 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/.
+/** What opencode carries on a model; see `harnesses/opencode/model-config.ts`. */
+const OPENCODE_INFERENCE = ["temperature", "maxTokens", "contextLength", "enableThinking", "reasoningEffort"];
 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, inference: OPENCODE_INFERENCE },
+    { id: "claude", agentDispatch: true, enforcesModelWorkTools: true, inference: ["reasoningEffort"] },
+    { id: "opencode-sdk", agentDispatch: true, enforcesModelWorkTools: true, inference: OPENCODE_INFERENCE },
+    { id: "codex", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
+    { id: "copilot", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
+    { id: "pi", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
+    { id: "gemini", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
+    { id: "aider", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
+    { id: "amazonq", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
+    { id: "openhands", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
 ];
 /**
  * Canonical, ordered list of valid harness / platform ids — the
@@ -22,3 +24,9 @@ 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));
+/** The inference keys an agent engine on `platform` may set; none for a platform that is not registered. */
+export function harnessInferenceKeys(platform) {
+    return HARNESS_ID_TABLE.find((h) => h.id === platform)?.inference ?? [];
+}

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

@@ -14,26 +14,68 @@
  * pre-migration `opencodeBuilder`. The builder's `platform` stays `'opencode'`
  * (the canonical harness id).
  */
-import { resolveDispatchModel } from "../../agent/builder-shared.js";
+import { isModelWorkTools } from "../../../execution/source.js";
+import { modelFromArgs, resolveDispatchModel } from "../../agent/builder-shared.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
+import { opencodeCarriedKeys, opencodeInferenceConfig, opencodeModelConfig, splitOpencodeModel } from "./model-config.js";
+import { MODEL_WORK_OPENCODE_AGENT, modelWorkOpencodeConfig } 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.
+ *
+ * Inference reaches the run the same way (`./model-config.ts`): the model it
+ * names gets an entry in the injected config, which merges over the user's own
+ * config for that model, and model work's agent carries the options, whether
+ * or not a model is named. A dispatch whose request carries no translatable
+ * inference injects nothing, so its argv and env are as they were.
  */
 export const opencodeBuilder = {
     platform: "opencode",
-    personaChannel: "native",
+    personaChannel: "prompt",
     lower: createAgentRequestLowerer({
         adapter: "opencode",
-        personaChannel: "native",
+        personaChannel: "prompt",
         nativeAgentSelector: true,
         tools: "none",
-        outputSchema: false,
+        modelWorkTools: true,
+        inference: (profile, request) => {
+            const model = request.model?.resolved ?? modelFromArgs(profile.args);
+            return opencodeCarriedKeys(model !== undefined && splitOpencodeModel(model) !== undefined, request.inference, isModelWorkTools(request.tools));
+        },
     }),
     build(profile, req) {
+        const model = req.model ?? modelFromArgs(profile.args);
+        const modelWork = isModelWorkTools(req.tools);
+        // What goes on the model needs a `provider/model` to go on; model work's agent options do not.
+        const { entry, agentOptions } = opencodeInferenceConfig(req.inference, modelWork);
+        const modelConfig = opencodeModelConfig(model, entry);
+        if (modelWork) {
+            return {
+                argv: [
+                    profile.bin,
+                    "run",
+                    "--agent",
+                    MODEL_WORK_OPENCODE_AGENT,
+                    ...(model ? ["--model", model] : []),
+                    "--",
+                    req.prompt,
+                ],
+                env: { OPENCODE_CONFIG_CONTENT: JSON.stringify({ ...modelWorkOpencodeConfig(agentOptions), ...modelConfig }) },
+            };
+        }
         const args = req.model ? [] : [...profile.args];
         if (req.model) {
             for (let index = 0; index < profile.args.length; index += 1) {
@@ -48,9 +90,6 @@ export const opencodeBuilder = {
                 }
             }
         }
-        if (req.systemPrompt) {
-            args.push("--system-prompt", req.systemPrompt);
-        }
         if (req.agent) {
             args.push("--agent", req.agent);
         }
@@ -60,6 +99,9 @@ export const opencodeBuilder = {
         }
         args.push("--");
         args.push(req.prompt);
-        return { argv: [profile.bin, ...args] };
+        return {
+            argv: [profile.bin, ...args],
+            ...(modelConfig ? { env: { OPENCODE_CONFIG_CONTENT: JSON.stringify(modelConfig) } } : {}),
+        };
     },
 };

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();

package/dist/integrations/harnesses/opencode/model-config.js

@@ -0,0 +1,80 @@
+// 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 isPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
+/**
+ * What opencode carries of `inference`, and the keys that covers. A key it
+ * cannot carry is left out: one of the wrong type, or `maxTokens` or
+ * `contextLength` without the other. An explicit `null` clears a field, so it
+ * is carried as nothing.
+ */
+export function carriedInference(inference) {
+    const carried = {};
+    const { temperature, reasoningEffort, enableThinking, maxTokens, contextLength } = inference ?? {};
+    if (typeof temperature === "number" && Number.isFinite(temperature))
+        carried.temperature = temperature;
+    if (typeof reasoningEffort === "string" && reasoningEffort.length > 0)
+        carried.reasoningEffort = reasoningEffort;
+    if (typeof enableThinking === "boolean")
+        carried.enableThinking = enableThinking;
+    const limit = isPositiveInteger(maxTokens) && isPositiveInteger(contextLength);
+    if (limit)
+        carried.limit = { context: contextLength, output: maxTokens };
+    const keys = [
+        ["temperature", carried.temperature !== undefined, temperature],
+        ["reasoningEffort", carried.reasoningEffort !== undefined, reasoningEffort],
+        ["enableThinking", carried.enableThinking !== undefined, enableThinking],
+        ["maxTokens", limit, maxTokens],
+        ["contextLength", limit, contextLength],
+    ]
+        .filter(([, isCarried, value]) => isCarried || value === null)
+        .map(([key]) => key);
+    return { carried, keys };
+}
+/** opencode's own split of `provider/model`: at the first slash, so a model id may contain slashes. */
+export function splitOpencodeModel(model) {
+    const slash = model.indexOf("/");
+    if (slash <= 0 || slash === model.length - 1)
+        return undefined;
+    return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
+}
+/**
+ * The inference keys opencode carries for a dispatch. With a model to attach
+ * them to (`attachable`) it carries all of them. Without one it carries only
+ * what the model-work agent can, which is every option but the limit; any
+ * other dispatch carries nothing.
+ */
+export function opencodeCarriedKeys(attachable, inference, modelWork) {
+    const { keys } = carriedInference(inference);
+    if (attachable)
+        return keys;
+    return modelWork ? keys.filter((key) => key !== "maxTokens" && key !== "contextLength") : [];
+}
+/** Split `inference` between the model and, for model work, the confined agent (see the module comment). */
+export function opencodeInferenceConfig(inference, modelWork) {
+    const { carried } = carriedInference(inference);
+    const options = {};
+    if (carried.temperature !== undefined)
+        options.temperature = carried.temperature;
+    if (carried.reasoningEffort !== undefined)
+        options.reasoningEffort = carried.reasoningEffort;
+    if (carried.enableThinking !== undefined) {
+        options.chat_template_kwargs = { enable_thinking: carried.enableThinking };
+        options.enable_thinking = carried.enableThinking;
+    }
+    const hasOptions = Object.keys(options).length > 0;
+    return {
+        entry: {
+            ...(hasOptions && !modelWork ? { options } : {}),
+            ...(carried.limit ? { limit: { ...carried.limit } } : {}),
+        },
+        ...(hasOptions && modelWork ? { agentOptions: options } : {}),
+    };
+}
+/** The config that gives `model` (`provider/model`) `entry`: undefined when the model cannot be split or `entry` is empty. */
+export function opencodeModelConfig(model, entry) {
+    const target = model === undefined ? undefined : splitOpencodeModel(model);
+    if (!target || Object.keys(entry).length === 0)
+        return undefined;
+    return { provider: { [target.providerID]: { models: { [target.modelID]: entry } } } };
+}