akm-cli 0.9.24 → 0.9.25-alpha.2

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

@@ -0,0 +1,33 @@
+// 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/.
+/** The inference keys model work's agent carries as options. */
+export const MODEL_WORK_AGENT_INFERENCE = ["temperature", "reasoningEffort", "enableThinking"];
+const isPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
+/**
+ * Split `inference` into opencode config: `entry` for a model (its options, and
+ * its limit), and for model work `agentOptions` for the confined agent in place
+ * of the entry's options. A value of the wrong type is left out.
+ */
+export function opencodeInferenceConfig(inference, modelWork) {
+    const { temperature, reasoningEffort, enableThinking, maxTokens, contextLength } = inference ?? {};
+    const options = {};
+    if (typeof temperature === "number" && Number.isFinite(temperature))
+        options.temperature = temperature;
+    if (typeof reasoningEffort === "string" && reasoningEffort.length > 0)
+        options.reasoningEffort = reasoningEffort;
+    if (typeof enableThinking === "boolean") {
+        options.chat_template_kwargs = { enable_thinking: enableThinking };
+        options.enable_thinking = enableThinking;
+    }
+    const hasOptions = Object.keys(options).length > 0;
+    return {
+        entry: {
+            ...(hasOptions && !modelWork ? { options } : {}),
+            ...(isPositiveInteger(maxTokens) && isPositiveInteger(contextLength)
+                ? { limit: { context: contextLength, output: maxTokens } }
+                : {}),
+        },
+        ...(hasOptions && modelWork ? { agentOptions: options } : {}),
+    };
+}

package/dist/integrations/harnesses/opencode/model-work-agent.js

@@ -0,0 +1,115 @@
+// 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/.
+/**
+ * The opencode agent that runs unattended model work under the model-work
+ * tool policy (`MODEL_WORK_POLICY_ID`). The CLI builder injects it through
+ * `OPENCODE_CONFIG_CONTENT` and selects it with `--agent`; the SDK runner adds
+ * it to its server config and names it in the prompt body.
+ *
+ * What opencode 1.18.25 confines, checked against a local stub:
+ *   - read, grep and glob work in the session directory and akm's primary
+ *     stash, and nowhere else. edit works in the session directory only: the
+ *     stash is denied, by its path without the leading slash, because opencode
+ *     matches edit patterns root-relative (to the git root, when the session
+ *     directory is in a repository). Write is part of the edit permission.
+ *   - `akm_search` and `akm_show` are the akm-opencode plugin's read tools; its
+ *     other three are denied. bash is denied: opencode matches a bash rule
+ *     against the command's words only, so `akm show x > ~/stash/asset.md`
+ *     would pass an `akm show *` rule and write anywhere.
+ *   - every other tool is denied, `doom_loop` included (its default, `ask`,
+ *     would hang a headless server). Each permission opencode knows is named,
+ *     so a same-named agent in the user's config cannot re-allow one through
+ *     opencode's config merge, and `*` covers the rest.
+ * The same rules also go in the top-level `permission`, so an opencode that
+ * falls back to its default agent is confined too.
+ *
+ * The agent also keeps opencode's coding-assistant defaults out of model work:
+ *   - its own short `prompt` replaces the provider's coding prompt, which
+ *     tells the model to search extensively; opencode appends a request's
+ *     system text after it and never substitutes it;
+ *   - it sets no `steps`. At its step limit opencode sends a "maximum steps"
+ *     text as a trailing assistant message, which a qwen chat template (LM
+ *     Studio, llama-server) renders as the start of the model's reply: LM
+ *     Studio then returns nothing and llama-server returns that text as the
+ *     answer. The dispatch timeout bounds a run instead;
+ *   - automatic compaction is off, so a long run cannot summarize the task
+ *     away.
+ */
+import path from "node:path";
+import { resolveStashDir } from "../../../core/common.js";
+import { getStateDir } from "../../../core/paths.js";
+export const MODEL_WORK_OPENCODE_AGENT = "akm-model-work";
+const MODEL_WORK_PROMPT = "You do one bounded task for akm. Use tools only to check what the task needs, never repeat a tool call, and reply with exactly what the task asks for.";
+function modelWorkPermission(stash) {
+    return {
+        "*": "deny",
+        read: "allow",
+        grep: "allow",
+        glob: "allow",
+        edit: { "*": "allow", ...(stash ? { [`${stash.slice(1)}/*`]: "deny" } : {}) },
+        external_directory: {
+            ...(stash ? { [`${stash}/*`]: "allow" } : {}),
+            "~/.local/share/opencode/tool-output/*": "deny",
+        },
+        akm_search: "allow",
+        akm_show: "allow",
+        akm_feedback: "deny",
+        akm_remember: "deny",
+        akm_curate: "deny",
+        bash: "deny",
+        doom_loop: "deny",
+        list: "deny",
+        lsp: "deny",
+        question: "deny",
+        skill: "deny",
+        task: "deny",
+        todowrite: "deny",
+        webfetch: "deny",
+        websearch: "deny",
+    };
+}
+/**
+ * What an opencode model-work dispatch gives the akm-opencode plugin (it comes from the user's opencode config and gives
+ * the model `akm_search` and `akm_show`): its own switches off, and its state in akm's state directory, the same for every
+ * dispatch because an SDK server outlives its dispatch. win32 has no /bin/true, so the plugin keeps its CLI there.
+ */
+export function modelWorkPluginEnv() {
+    return {
+        AKM_AUTO_CURATE: "0",
+        AKM_AUTO_LEARNING: "0",
+        AKM_AUTO_SKILL_PROPOSALS: "0",
+        AKM_WRITE_GATE: "off",
+        XDG_STATE_HOME: path.join(getStateDir(), "opencode-model-work"),
+        ...(process.platform === "win32" ? {} : { AKM_OPENCODE_CLI: "/bin/true" }),
+    };
+}
+/**
+ * The opencode config fragment that defines and confines the model-work agent.
+ * The agent carries the request's inference options (`model-config.ts`), which
+ * apply to its calls only: opencode's own calls on the same model, a title for
+ * the session, keep the model's defaults.
+ */
+export function modelWorkOpencodeConfig(options) {
+    let stash;
+    try {
+        stash = resolveStashDir();
+    }
+    catch {
+        // akm has no stash here, so the agent is given no path into one.
+    }
+    const permission = modelWorkPermission(stash);
+    return {
+        permission: { ...permission },
+        compaction: { auto: false },
+        agent: {
+            [MODEL_WORK_OPENCODE_AGENT]: {
+                mode: "primary",
+                description: "akm unattended model work: read and edit inside its working directory only.",
+                prompt: MODEL_WORK_PROMPT,
+                ...(options ? { options } : {}),
+                permission: { ...permission },
+            },
+        },
+    };
+}

package/dist/integrations/harnesses/opencode-sdk/harness.js

@@ -22,6 +22,7 @@
  * breaks the cycle.
  */
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
+import { MODEL_WORK_AGENT_INFERENCE } from "../opencode/model-config.js";
 import { caps } from "../shared.js";
 import { BaseHarness } from "../types.js";
 /**
@@ -33,12 +34,6 @@ export class OpencodeSdkHarness extends BaseHarness {
     id = "opencode-sdk";
     displayName = "OpenCode SDK";
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // Embedded-SDK dispatch on this machine ⇒ local-runner (the matrix's
-    // "local (sdk/cli)" row, SDK half).
-    pattern = "local-runner";
-    // `session.prompt` returns structured SDK events/messages; akm extracts the
-    // final message then validates against the node schema ⇒ native-json tier.
-    structuredOutput = "native-json";
     executionLowerer = {
         platform: "opencode-sdk",
         personaChannel: "native",
@@ -47,7 +42,7 @@ export class OpencodeSdkHarness extends BaseHarness {
             personaChannel: "native",
             nativeAgentSelector: true,
             tools: "sdk",
-            outputSchema: false,
+            inference: MODEL_WORK_AGENT_INFERENCE,
         }),
     };
     // No flag-shaped resume: session reuse is programmatic — the SDK session id is

package/dist/integrations/harnesses/opencode-sdk/sdk-runner.js

@@ -92,8 +92,11 @@
  */
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { COMMON_SPAWN_ENV_PASSTHROUGH, spawnEnvNamesFor } from "../../../core/spawn-env.js";
+import { isRecord } from "../../../core/common.js";
+import { COMMON_SPAWN_ENV_PASSTHROUGH, spawnEnvNamesFor, XDG_BASE_DIR_ENV_PASSTHROUGH } from "../../../core/spawn-env.js";
 import { DEFAULT_AGENT_TIMEOUT_MS } from "../../agent/config.js";
+import { opencodeInferenceConfig } from "../opencode/model-config.js";
+import { MODEL_WORK_OPENCODE_AGENT, modelWorkOpencodeConfig, modelWorkPluginEnv } from "../opencode/model-work-agent.js";
 // Server registry — one server per complete server-material signature. Caller
 // deadlines race the shared promise independently; they never become startup
 // configuration inherited by later callers.
@@ -232,21 +235,45 @@ function toolsToSdkAllowlist(tools) {
         out[n] = true;
     return out;
 }
+/** The inference a fallback LLM connection carries, which opencode can take. */
+function fallbackInference(llmConfig) {
+    const out = {};
+    for (const key of ["temperature", "maxTokens", "contextLength", "enableThinking", "reasoningEffort"]) {
+        if (llmConfig?.[key] !== undefined)
+            out[key] = llmConfig[key];
+    }
+    return out;
+}
 /**
  * Assemble the OpenCode SDK server config from the profile + LLM fallback.
  * Pure and exported for tests. `profile.model` is already exact because model
- * aliases resolve once before harness lowering.
+ * aliases resolve once before harness lowering. A server for model work also
+ * defines the confined model-work agent (`../opencode/model-work-agent`).
+ *
+ * The model the config routes through `akm-custom` is declared in full, with
+ * the dispatch's inference (`../opencode/model-config`): the fallback LLM
+ * engine's, under `requestInference`, the request's own. For model work the
+ * options go on the confined agent instead of the model, which needs no model
+ * named: it runs whichever model opencode picks. A model the user's own opencode
+ * config provides carries none: set inference there.
  */
-export function buildSdkConfig(profile, llmConfig) {
+export function buildSdkConfig(profile, llmConfig, modelWork = false, requestInference) {
     const endpoint = llmConfig?.endpoint;
     const apiKey = llmConfig?.apiKey;
     const profileModel = profile.model;
     const model = profileModel ?? llmConfig?.model;
+    const inference = requestInference === null ? undefined : { ...fallbackInference(llmConfig), ...requestInference };
+    const { entry, agentOptions } = opencodeInferenceConfig(inference, modelWork);
     const sdkConfig = {};
     if (model)
         sdkConfig.model = model;
     if (endpoint || apiKey) {
-        // Configure a custom OpenAI-compatible provider
+        // The first path segment selects the OpenCode provider. Model IDs may
+        // themselves contain slashes, but still belong to this custom endpoint.
+        const modelId = model?.startsWith("akm-custom/") ? model.slice("akm-custom/".length) : model;
+        // Configure a custom OpenAI-compatible provider. OpenCode registers only
+        // the models a custom provider lists, so the routed model is declared
+        // (#1015: without it every dispatch failed with ProviderModelNotFoundError).
         sdkConfig.provider = {
             "akm-custom": {
                 npm: "@ai-sdk/openai-compatible",
@@ -254,14 +281,13 @@ export function buildSdkConfig(profile, llmConfig) {
                     baseURL: canonicalProviderBase(endpoint) ?? undefined,
                     ...(apiKey ? { apiKey } : {}),
                 },
+                ...(modelId ? { models: { [modelId]: entry } } : {}),
             },
         };
-        // The first path segment selects the OpenCode provider. Model IDs may
-        // themselves contain slashes, but still belong to this custom endpoint.
-        if (model)
-            sdkConfig.model = model.startsWith("akm-custom/") ? model : `akm-custom/${model}`;
+        if (modelId)
+            sdkConfig.model = `akm-custom/${modelId}`;
     }
-    return sdkConfig;
+    return modelWork ? { ...sdkConfig, ...modelWorkOpencodeConfig(agentOptions) } : sdkConfig;
 }
 /** Digest the executable and exact environment received by the child. */
 function serverRegistryKey(profile, env) {
@@ -270,11 +296,23 @@ function serverRegistryKey(profile, env) {
         .update(JSON.stringify(canonicalize(material)))
         .digest("hex");
 }
-/** @internal Exact environment allowlist used to start the OpenCode SDK server. */
+/**
+ * @internal Exact environment allowlist used to start the OpenCode SDK server:
+ * the common baseline, the XDG base-directory variables opencode resolves its
+ * config, data, cache and state from, and the profile's own names. The XDG names
+ * are the server's, not the profile's: profile `envPassthrough` is frozen into
+ * workflow plans, and an SDK profile's list has always been empty.
+ */
 export function opencodeSdkServerEnvironmentNames(profile) {
-    return [...new Set([...spawnEnvNamesFor(COMMON_SPAWN_ENV_PASSTHROUGH), ...(profile.envPassthrough ?? [])])];
+    return [
+        ...new Set([
+            ...spawnEnvNamesFor(COMMON_SPAWN_ENV_PASSTHROUGH),
+            ...XDG_BASE_DIR_ENV_PASSTHROUGH,
+            ...(profile.envPassthrough ?? []),
+        ]),
+    ];
 }
-function buildServerEnv(profile, config, bindings, envSource) {
+function buildServerEnv(profile, config, bindings, envSource, modelWork) {
     const env = {};
     for (const key of opencodeSdkServerEnvironmentNames(profile)) {
         const value = envSource[key];
@@ -283,6 +321,8 @@ function buildServerEnv(profile, config, bindings, envSource) {
     }
     for (const [key, value] of Object.entries(bindings ?? {}))
         env[key] = value;
+    if (modelWork)
+        Object.assign(env, modelWorkPluginEnv());
     env.OPENCODE_CONFIG_CONTENT = JSON.stringify(config);
     return env;
 }
@@ -550,11 +590,11 @@ async function startServer(profile, sdkConfig, env, registryKey, startupSignal)
  * start (the registry stores the in-flight promise). A failed start is
  * evicted so the next call can retry instead of caching the error forever.
  */
-function getOrStartServer(profile, llmConfig, env, envSource = process.env) {
+function getOrStartServer(profile, llmConfig, env, envSource = process.env, modelWork = false, inference) {
     if (_testServer)
         return { promise: Promise.resolve(_testServer), release() { } };
-    const sdkConfig = buildSdkConfig(profile, llmConfig);
-    const serverEnv = buildServerEnv(profile, sdkConfig, env, envSource);
+    const sdkConfig = buildSdkConfig(profile, llmConfig, modelWork, inference);
+    const serverEnv = buildServerEnv(profile, sdkConfig, env, envSource, modelWork);
     const key = serverRegistryKey(profile, serverEnv);
     let entry = _servers.get(key);
     if (!entry) {
@@ -665,6 +705,25 @@ function errorText(err) {
 function appendStderr(stderr, message) {
     return stderr ? `${stderr}\n${message}` : message;
 }
+/**
+ * Map an SDK `{ error }` result or a reply's `info.error` onto a failure
+ * (#1015). Both are opencode NamedErrors, `{ name, data: { message } }`. An
+ * aborted message is `aborted`, a reply cut off at the output limit is
+ * `parse_error`, and every other error (auth, API, unknown, an HTTP error
+ * body) is `non_zero_exit`.
+ */
+function sdkErrorFailure(error) {
+    if (!isRecord(error) || typeof error.name !== "string") {
+        return { reason: "non_zero_exit", message: typeof error === "string" ? error : JSON.stringify(error) };
+    }
+    const detail = isRecord(error.data) ? error.data.message : undefined;
+    const message = typeof detail === "string" ? `${error.name}: ${detail}` : error.name;
+    if (error.name === "MessageAbortedError")
+        return { reason: "aborted", message };
+    if (error.name === "MessageOutputLengthError")
+        return { reason: "parse_error", message };
+    return { reason: "non_zero_exit", message };
+}
 async function deleteSessionBestEffort(client, sessionId, query, setTimeoutFn, clearTimeoutFn) {
     try {
         const deleted = await raceSdkOperation(client.session.delete({ path: { id: sessionId }, ...(query ? { query } : {}) }), {
@@ -681,6 +740,10 @@ async function deleteSessionBestEffort(client, sessionId, query, setTimeoutFn, c
         return `OpenCode session cleanup failed: ${errorText(err)}`;
     }
 }
+/** Stop a server-side session that the dispatch has given up on, so it stops calling the model. */
+function abortSessionBestEffort(client, sessionId, query) {
+    void client.session.abort?.({ path: { id: sessionId }, ...(query ? { query } : {}) }).catch(() => { });
+}
 function abortedBeforeSdkStart(profile) {
     return {
         ok: false,
@@ -701,12 +764,13 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
     const clearTimeoutImpl = opts.clearTimeoutFn ?? clearTimeout;
     if (opts.signal?.aborted)
         return abortedBeforeSdkStart(profile);
+    const modelWork = opts.dispatch?.modelWork === true;
     let client;
     if (_testServer) {
         client = _testServer.client;
     }
     else {
-        const startupHandle = getOrStartServer(profile, llmConfig, opts.env, opts.envSource);
+        const startupHandle = getOrStartServer(profile, llmConfig, opts.env, opts.envSource, modelWork, opts.dispatch?.inference);
         try {
             const startup = await raceSdkOperation(startupHandle.promise, {
                 timeoutMs: remainingTimeoutMs(),
@@ -830,8 +894,9 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
     // dispatch request. Both were previously accepted on AgentDispatchRequest but
     // silently dropped on the SDK path, so SDK-mode dispatch ignored agent-asset
     // system prompts and tool policies entirely (the CLI path honours both).
+    // Model work runs the confined agent its server config defines; its tools are that agent's.
     const dispatch = opts.dispatch;
-    const agent = dispatch?.agent;
+    const agent = modelWork ? MODEL_WORK_OPENCODE_AGENT : dispatch?.agent;
     const system = dispatch?.systemPrompt;
     const tools = toolsToSdkAllowlist(dispatch?.tools);
     const body = { parts: [{ type: "text", text: prompt }] };
@@ -852,6 +917,10 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
                 void deleteSessionBestEffort(client, sessionId, query, setTimeoutImpl, clearTimeoutImpl);
             },
         });
+        // A session the dispatch stops early is aborted on the server too.
+        if (prompted === SDK_OPERATION_ABORTED || prompted === SDK_OPERATION_TIMED_OUT) {
+            abortSessionBestEffort(client, sessionId, query);
+        }
         if (prompted === SDK_OPERATION_ABORTED) {
             result = {
                 ok: false,
@@ -878,21 +947,38 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
         }
         else {
             const parts = prompted.data?.parts ?? [];
-            const textPart = parts.find((p) => p.type === "text");
-            const stdout = textPart?.text ?? "";
+            // The last text part is the answer; earlier ones narrate the steps before it.
+            const stdout = parts.filter((p) => p.type === "text").at(-1)?.text ?? "";
             // Token accounting from the AssistantMessage (previously discarded) —
             // the seam that makes workflow budget.maxTokens meterable on the
             // default sdk runner.
             const usage = extractUsage(prompted.data?.info);
-            result = {
-                ok: true,
-                stdout,
-                stderr: "",
-                durationMs: Date.now() - start,
-                exitCode: 0,
-                sessionId,
-                ...(usage ? { usage } : {}),
-            };
+            const sdkError = prompted.error ?? prompted.data?.info?.error;
+            if (sdkError) {
+                const failure = sdkErrorFailure(sdkError);
+                result = {
+                    ok: false,
+                    stdout,
+                    stderr: failure.message,
+                    durationMs: Date.now() - start,
+                    exitCode: failure.reason === "aborted" ? null : 1,
+                    reason: failure.reason,
+                    error: failure.message,
+                    sessionId,
+                    ...(usage ? { usage } : {}),
+                };
+            }
+            else {
+                result = {
+                    ok: true,
+                    stdout,
+                    stderr: "",
+                    durationMs: Date.now() - start,
+                    exitCode: 0,
+                    sessionId,
+                    ...(usage ? { usage } : {}),
+                };
+            }
         }
     }
     catch (err) {

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

@@ -44,10 +44,8 @@
  * - **schema** — the matrix places OpenHands in the "via prompt+validate"
  *   tier (plan §"Structured-output normalization", tier "native-json"): no
  *   Codex-style `--output-schema` flag exists, so NO temp schema file is
- *   written; the JSON Schema is injected into the task payload using the
- *   exact directive wording of the engine's prompt assembly
- *   (`step-work.ts` `buildUnitPrompt`) and the pi/aider builders, so
- *   all dispatch paths speak one dialect. Downstream, the extractor pulls the
+ *   written; the JSON Schema reaches it as the instruction the shared request
+ *   lowering appends to the prompt. Downstream, the extractor pulls the
  *   final message out of the JSONL stream and the engine's shared
  *   retry-until-valid loop performs the actual validation.
  * - **tools** — deliberately unconsumed. OpenHands has no per-tool allowlist
@@ -60,16 +58,14 @@
  *   conversation/session id opportunistically when the stream reveals one;
  *   akm's `workflow_run_units` remains the durable source of truth either way
  *   (plan §"Session, MCP, and identity across harnesses").
- * - **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: `openhandsBuilder` is `OpenhandsHarness.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 `"openhands"`
- * platform name without any further wiring. The registry entry also declares
- * `pattern: "local-runner"`, `structuredOutput: "native-json"` alongside it
- * (`./index.ts`).
+ * platform name without any further wiring.
  */
 import { resolveDispatchModel } from "../../agent/builder-shared.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
@@ -82,27 +78,18 @@ export const OPENHANDS_PLATFORM = "openhands";
  * share the one constant.
  */
 export const OPENHANDS_MODEL_ENV = "LLM_MODEL";
-/**
- * Assemble the `--task` payload: optional system text, the task prompt, and —
- * when a schema is requested — the same schema directive the workflow
- * engine's prompt assembly uses (OpenHands has no native schema flag, so the
- * prompt is the schema's only channel; plan §"Structured-output
- * normalization").
- */
+/** Assemble the `--task` payload: optional system text, then the task prompt. */
 function buildTaskPayload(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");
 }
 /**
  * OpenHands builder.
  * Command shape:
- *   openhands --headless --json --task=<[system\n\n]prompt[\n\nschema directive]>
+ *   openhands --headless --json --task=<[system\n\n]prompt>
  * with the resolved model (if any) carried on env as LLM_MODEL.
  */
 export const openhandsBuilder = {
@@ -112,7 +99,6 @@ export const openhandsBuilder = {
         adapter: OPENHANDS_PLATFORM,
         personaChannel: "prompt",
         tools: "none",
-        outputSchema: true,
     }),
     build(profile, req) {
         const args = [...profile.args];

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

@@ -29,11 +29,6 @@ export class OpenhandsHarness extends BaseHarness {
     agentBuilder = openhandsBuilder;
     resultExtractor = openhandsResultExtractor;
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // akm spawns `openhands --headless` locally per unit ⇒ local-runner.
-    pattern = "local-runner";
-    // `--json` emits a documented JSONL event stream akm parses, then validates
-    // against the node schema ⇒ native-json tier.
-    structuredOutput = "native-json";
     // No flag-shaped resume: per the matrix OpenHands resumes from workspace state, not a
     // session-id flag. The extractor still captures a conversation id
     // opportunistically; akm's `workflow_run_units` remains the durable source

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

@@ -27,10 +27,9 @@
  * - **systemPrompt** — passed via `--system-prompt` (Pi follows the Claude
  *   Code flag conventions).
  * - **schema** — the matrix places Pi 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 prompt
- *   payload, and `--mode json` is emitted so stdout is the documented JSONL
+ *   native `--output-schema` equivalent, unlike Codex), so the JSON Schema
+ *   reaches it as the instruction the shared request lowering appends to the
+ *   prompt, and `--mode json` is emitted so stdout is the documented JSONL
  *   event stream that `./result-extractor.ts` normalizes. The engine's shared
  *   retry-until-valid loop performs the actual validation. Without a schema
  *   the argv matches the matrix's bare headless shape (`pi -p "<p>"`) and the
@@ -40,8 +39,8 @@
  *   there is no documented per-tool allowlist flag, and inventing one would
  *   produce a silently broken command. A restrictive policy is therefore
  *   dropped rather than approximated — never silently widened.
- * - **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: `piBuilder` is `PiHarness.agentBuilder` (`./index.ts`), one of
  * the ten harnesses `HARNESS_REGISTRY` constructs (`harnesses/index.ts`);
@@ -54,22 +53,10 @@ 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 PI_PLATFORM = "pi";
-/**
- * Assemble the positional prompt payload: 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.
- */
-function buildPromptPayload(req) {
-    const sections = [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");
-}
 /**
  * Pi builder.
  * Command shape:
- *   pi [--system-prompt "..."] [--model <m>] [--mode json] -p -- "<prompt[\n\nschema directive]>"
+ *   pi [--system-prompt "..."] [--model <m>] [--mode json] -p -- "<prompt>"
  */
 export const piBuilder = {
     platform: PI_PLATFORM,
@@ -78,7 +65,6 @@ export const piBuilder = {
         adapter: PI_PLATFORM,
         personaChannel: "native",
         tools: "none",
-        outputSchema: true,
     }),
     build(profile, req) {
         const args = [...profile.args];
@@ -97,7 +83,7 @@ export const piBuilder = {
         // -p = non-interactive print mode; prompt is the trailing positional.
         args.push("-p");
         args.push("--");
-        args.push(buildPromptPayload(req));
+        args.push(req.prompt);
         return { argv: [profile.bin, ...args] };
     },
 };

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

@@ -29,11 +29,6 @@ export class PiHarness extends BaseHarness {
     agentBuilder = piBuilder;
     resultExtractor = piResultExtractor;
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // akm spawns the `pi` CLI locally per unit ⇒ local-runner.
-    pattern = "local-runner";
-    // `--mode json` emits a documented JSONL event stream akm parses, then
-    // validates against the node schema ⇒ native-json tier.
-    structuredOutput = "native-json";
     // Session-id env marker only — the matrix's bare PI_* presence vars must
     // not stamp identity onto manual runs (see `AkmHarness.identityEnv`).
     identityEnv = ["PI_SESSION_ID"];

package/dist/llm/client.js

@@ -412,6 +412,11 @@ async function chatCompletionAttemptOnce(config, messages, options, timeoutMs, i
         catch {
             throw new LlmCallError(`LLM response was not valid JSON ${config.endpoint}: ${redactSensitiveText(redactErrorBody(rawOkBody), resolvedKey ? [resolvedKey] : [])}`, "parse_error", response.status);
         }
+        // A 2xx can still carry a provider failure. OpenRouter answers a provider
+        // that fails after the headers with a body holding only `error`.
+        if (json.error !== undefined && json.error !== null && !json.choices?.length) {
+            throw new LlmCallError(`LLM provider error (${response.status}) ${config.endpoint}: ${redactSensitiveText(redactErrorBody(rawOkBody), resolvedKey ? [resolvedKey] : [])}`, "provider_error", response.status);
+        }
         const responseModel = typeof json.model === "string" && json.model.trim().length > 0 ? json.model : undefined;
         terminalFields = {
             model: responseModel ?? config.model,