akm-cli 0.10.261017-beta → 0.10.261019

package/CHANGELOG.md

@@ -6,6 +6,57 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.10.261019] - 2026-10-29
+
+The first stable release of the 0.10 line, published to npm `latest`. Its
+changes are in the 0.10 sections below; the upgrade from 0.9 is in
+[the 0.9 to 0.10 migration guide](docs/migration/v0.9-to-v0.10.md) and
+`akm help migrate 0.10.261019`.
+
+## [0.10.261018] - 2026-10-29
+
+### Fixed
+
+- A run on akm's own runtime whose model makes the same tool call and gets the
+  same result three turns in a row now tells the model so, in a message that
+  names the tool and asks it to use the result it has or take a different
+  approach, in a request that raises a connection's temperature below 0.7 to
+  0.7 (that one request only; every other keeps the connection's settings, and
+  a connection that sets no temperature sends none), and fails with a message
+  that names the tool only if the model makes the call again, instead of
+  running to its deadline or, with no `timeoutMs`, for ever. Each session of a
+  run, a subagent's too, is told for itself. OpenCode has no check of its own
+  for this. The runtime
+  moves from OpenCode 2.1.4 to 2.2.0 with it: the next agent run fetches the
+  binary again, into `<akm cache dir>/opencode/2.2.0/`.
+- Agent work on akm's own runtime runs in the directory it is given: the one
+  `akm agent --cwd` names, and the bundle root for a workflow's agent units.
+  It ran in the directory akm was started from, because OpenCode takes its
+  directory from `PWD`, which akm now sets for the run.
+- A harness run in a directory (`akm agent --cwd`, a harness's `workspace`, the
+  scratch directory of model work) now has `PWD` naming that directory, as it
+  does for a program started after `cd`. OpenCode takes its directory from
+  `PWD`, not the working directory, so an `opencode` harness ran its shell and
+  file tools in the directory akm was started in. The spawn every harness
+  shares sets it, so any program that reads `PWD` gets the directory it runs in.
+- OpenCode model work leaves out OpenCode's built-in browser plugin. From
+  OpenCode 2.2.0 its rules kept the `skill` tool listed for the read-only
+  `akm-model-work` agent (a call to it was refused).
+- `akm migrate apply` keeps agent engines. 0.10.261014 to 0.10.261017 dropped
+  every `opencode-sdk` engine, so agent work moved from the user's own OpenCode
+  and model to akm's own runtime, and `harness:` selectors naming them failed.
+  An `opencode-sdk` engine with no `llmEngine` now becomes an `opencode` harness
+  with its `model`, `bin`, `workspace`, `agent` and `timeoutMs`; one over an
+  `llmEngine` stays akm's own runtime. A harness engine's own `model` stands
+  over `models.json`, and the notes say where agent work ran with no
+  `defaults.engine`, where a gate's judge ran and runs now, and, with no
+  `defaults.llmEngine` and no connection, that model work (improve, index
+  passes, extraction, judges) now runs on the default harness where 0.9 ran
+  none, and how to turn that off with `modelWork: false`. An `opencode-sdk`
+  engine's `args`, which 0.9 did not pass, are dropped with a note. A
+  config a beta already migrated is repaired from its pre-migration copy in
+  `<cache dir>/config-backups/` (migration guide, step 5).
+
 ## [0.10.261017] - 2026-10-27
 
 ### Changed

package/dist/assets/opencode/akm-plugin.js

@@ -18,6 +18,13 @@
 //     transport sends them. OpenCode sizes every request's output cap from the model's limit and sends it as
 //     `max_tokens` or `max_completion_tokens`; that is its own accounting, not a cap anyone asked for, so it is
 //     dropped, and the connection's fields carry a cap only when the connection writes one.
+//   - A run that has stopped getting anywhere: when the model has made the same tool calls three turns in a row and
+//     been given the same results each time, the next request carries a message from the user that says so and asks it to
+//     use the result it has or take another route, and a temperature it carries below 0.7 is raised to 0.7, because a
+//     model that is sampled greedily answers the same thing to the same context however it is asked; if the model then
+//     makes the same calls again, the run fails with a message that says so, before the next model request is sent.
+//     OpenCode has no such check of its own (its `doom_loop` setting is read and ignored), and a run that never ends has
+//     nothing else to stop it when the connection sets no `timeoutMs`.
 
 import { execFile } from "node:child_process";
 
@@ -128,6 +135,69 @@ function withFields(base, over) {
   return merged;
 }
 
+/** How many turns in a row may make the same tool calls and get the same results before the model is told so. */
+const REPEATED_TURNS = 3;
+
+/**
+ * The temperature the one request that tells the model it is repeating itself is raised to, when it is sent at a lower
+ * one. A Qwen 27B model sampled greedily (temperature 0) gave the same call again to every wording of the message in
+ * every try (0 of 16 replays of a captured request); sampled at 0.7 it left the repeat in about half of them (22 of 44).
+ * A request that carries no temperature is left to the endpoint's default: some endpoints refuse any temperature but
+ * their own (OpenAI's reasoning models answer anything but 1 with a 400).
+ */
+const RECOVERY_TEMPERATURE = 0.7;
+
+/**
+ * A tool result as the check compares it. OpenCode saves an output too long to send whole to a file of its own for each
+ * call and names that file in the result (`[showing … of …; full output saved to <file>]`), so the name is left out:
+ * the same long output is the same result.
+ */
+const comparable = (content) =>
+  JSON.stringify(content).replace(/full output saved to [^\]]*\]/g, "full output saved to <file>]");
+
+/**
+ * What the last turns of a chat request repeat, when REPEATED_TURNS or more of them in a row made the same calls (the
+ * same name and arguments, ids ignored, parallel calls as a set) and were answered with the same results, else
+ * undefined: how many turns, the names of the tools called, the calls and results themselves (`signature`) and the id
+ * of the first call of the oldest turn (`since`), which tells one run of repeats from the next. A model that does this
+ * has settled on one answer to what it is told and does not leave it; a call whose result changes (a poll) is not
+ * repeated.
+ */
+function repeatedToolCalls(messages) {
+  if (!Array.isArray(messages)) return undefined;
+  const turns = [];
+  let names = [];
+  let since;
+  let results = new Map();
+  // From the newest message back: the tool results, then the assistant message that made the calls they answer.
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role === "tool") {
+      results.set(message.tool_call_id, comparable(message.content));
+      continue;
+    }
+    if (message?.role !== "assistant" || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0) break;
+    const calls = message.tool_calls.map((call) => [
+      call?.function?.name,
+      call?.function?.arguments,
+      results.get(call?.id),
+    ]);
+    if (calls.some(([name, , result]) => name === undefined || result === undefined)) break;
+    const turn = calls
+      .map((call) => JSON.stringify(call))
+      .sort()
+      .join("\n");
+    if (turns.length > 0 && turn !== turns[0]) break;
+    if (turns.length === 0) names = [...new Set(calls.map(([name]) => name))];
+    turns.push(turn);
+    since = message.tool_calls[0]?.id;
+    results = new Map();
+  }
+  return turns.length >= REPEATED_TURNS ? { turns: turns.length, names, signature: turns[0], since } : undefined;
+}
+
+const quoted = (names) => names.map((name) => `\`${name}\``).join(", ");
+
 export default {
   id: "akm",
   setup: async (ctx) => {
@@ -161,6 +231,9 @@ export default {
     }
 
     const fields = ctx.options?.requestFields;
+    // The repeats the model has been told about, by session and what they repeat: where they began and how many turns
+    // there were. One process runs a run's every session (a subagent's too), and each session's model is told for itself.
+    const told = new Map();
     await ctx.session.hook("http.request", async (event) => {
       const request = event.request;
       if (request.body === null) return;
@@ -172,12 +245,41 @@ export default {
       }
       if (!isObject(body)) return;
       const { max_tokens: _own, max_completion_tokens: _ownCompletion, ...kept } = body;
+      const stuck = repeatedToolCalls(body.messages);
+      if (stuck) {
+        const key = `${event.sessionID}\n${stuck.signature}`;
+        const was = told.get(key);
+        // The model has been told about these calls and made them again, or has come back to them since.
+        if (was && (was.since !== stuck.since || stuck.turns > was.turns)) {
+          // Measured on OpenCode 2.2.0: an error thrown from this hook fails the run's turn before the request is sent,
+          // and `opencode run` exits 1 with the error's message (an unknown error in the session, which akm reports as
+          // a non-zero exit). Answering the request with a 4xx instead also ends the run, but only after the request
+          // has gone to the model.
+          throw new Error(
+            `akm stopped this run: the model called ${quoted(stuck.names)} with the same input ${stuck.turns} times in a row and got the same result each time, although it had been told it was repeating itself.`,
+          );
+        }
+        // A request that is sent again unchanged (a retry) is told again, the same way.
+        told.set(key, { since: stuck.since, turns: stuck.turns });
+        // OpenCode keeps no trace of this message: it does not store what a request's body is changed to.
+        kept.messages = [
+          ...kept.messages,
+          {
+            role: "user",
+            content: `You have called ${quoted(stuck.names)} with the same input ${stuck.turns} times in a row and got the same result each time, so calling it again will not give you anything new. Use the result you already have, or take a different approach to finish the task. If you call it again with the same input, this run will be stopped.`,
+          },
+        ];
+      }
+      const forwarded = isObject(fields) ? withFields(kept, fields) : kept;
+      if (stuck && typeof forwarded.temperature === "number" && forwarded.temperature < RECOVERY_TEMPERATURE) {
+        forwarded.temperature = RECOVERY_TEMPERATURE;
+      }
       const headers = new Headers(request.headers);
       headers.delete("content-length");
       event.request = new Request(request.url, {
         method: request.method,
         headers,
-        body: JSON.stringify(isObject(fields) ? withFields(kept, fields) : kept),
+        body: JSON.stringify(forwarded),
         signal: request.signal,
       });
     });

package/dist/core/config/convert-engine-references.js

@@ -85,14 +85,30 @@ export function improveStrategyDefault(out, defaults, improve) {
     out.improve = { ...(isRecord(improve) ? improve : {}) };
     out.improve.strategy ??= defaults.improveStrategy;
 }
-/** `workflow.judgeEngine`: a gate's judge is the default connection or harness now. */
-export function dropJudgeEngine(out, conversion) {
+/**
+ * `workflow.judgeEngine`, else `defaults.engine`, is where 0.9 ran a gate's judge. It is model work now and runs where
+ * model work does, `judge`: the default connection, else the default harness. `workflow.judgeEngine` is dropped, and
+ * a note says whether the judge moves.
+ */
+export function dropJudgeEngine(out, conversion, target, defaultEngine, judge) {
     const workflow = out.workflow;
-    if (!isRecord(workflow) || !("judgeEngine" in workflow))
-        return;
-    delete workflow.judgeEngine;
-    conversion.changed = true;
-    conversion.notes.push("workflow.judgeEngine: a gate's judge is the default connection or harness now; it is dropped.");
+    const named = isRecord(workflow) && "judgeEngine" in workflow;
+    const engine = named ? str(workflow.judgeEngine) : defaultEngine;
+    if (named) {
+        delete workflow.judgeEngine;
+        conversion.changed = true;
+    }
+    const became = engine === undefined ? undefined : target(engine);
+    const stays = became !== undefined && judge !== undefined && isDeepStrictEqual(became, judge);
+    const kind = judge === undefined ? undefined : "connection" in judge ? "connection" : "harness";
+    if (named) {
+        conversion.notes.push(stays
+            ? `workflow.judgeEngine: "${engine}" is the default ${kind}, where a gate's judge runs now; the setting is dropped.`
+            : `workflow.judgeEngine${engine === undefined ? "" : ` "${engine}"`}: dropped. A gate's judge runs on the default connection, else the default harness, so a judge that ran on another engine has moved; to keep it, make that engine the default.`);
+    }
+    else if (became !== undefined && judge !== undefined && !stays) {
+        conversion.notes.push(`workflow: with no workflow.judgeEngine, a gate's judge ran on the default engine "${engine}"; it is model work now and runs on the default ${kind}, "${"connection" in judge ? judge.connection : judge.harness}".`);
+    }
 }
 /** `index.defaults.*` and `index.<pass>.engine`: `index.*` and `connection`; a harness cannot run an index pass. */
 export function convertIndexEngines(out, conversion, retarget) {

package/dist/core/config/convert-engines.js

@@ -55,17 +55,32 @@ function implicitKeyVariables(name, defaults) {
     return name === str(defaults.llmEngine) ? [own, "AKM_LLM_API_KEY"] : [own];
 }
 // ── engines → connections / harnesses ────────────────────────────────────────
-/** `engines.<name>` with `kind: "agent"` and `platform: "opencode-sdk"`: akm's own runtime has no entry of its own. */
-function runtimeEngine(name, engine, converted, conversion) {
-    converted.runtimes.set(name, str(engine.llmEngine));
-    conversion.notes.push(`engines.${name}: opencode-sdk is akm's own runtime now, with no entry of its own; its model, timeout and workspace are dropped.`);
+/**
+ * `engines.<name>` with `kind: "agent"` and `platform: "opencode-sdk"` over an `llmEngine`: OpenCode ran over
+ * akm's own connection, which is what akm's own runtime is now, so it has no entry of its own.
+ */
+function runtimeEngine(name, engine, llmEngine, converted, conversion) {
+    converted.runtimes.set(name, llmEngine);
+    const dropped = ["model", "timeoutMs", "workspace", "bin", "agent"].filter((key) => engine[key] !== undefined);
+    const gone = dropped.length === 0 ? "" : `; its ${dropped.join(", ")} ${dropped.length === 1 ? "is" : "are"} dropped`;
+    conversion.notes.push(`engines.${name}: opencode-sdk over llmEngine "${llmEngine}" is akm's own runtime over connection "${llmEngine}" now, with no entry of its own${gone}.`);
 }
-/** `engines.<name>` with `kind: "agent"`, any other platform: `harnesses.<name>`. */
-function agentEngineToHarness(name, engine, converted) {
-    const harness = { platform: engine.platform };
+/**
+ * `engines.<name>` with `kind: "agent"`: `harnesses.<name>`. An `opencode-sdk` engine with no `llmEngine` ran the
+ * user's own OpenCode (provider, model and login from its configuration), which the `opencode` harness runs now.
+ */
+function agentEngineToHarness(name, engine, converted, conversion) {
+    const sdk = engine.platform === "opencode-sdk";
+    const harness = { platform: sdk ? "opencode" : engine.platform };
+    if (sdk)
+        converted.sdkHarnesses.add(name);
+    // 0.9 started `opencode serve` without an engine's `args`; the harness would pass them in place of `run`.
     for (const key of ["bin", "args", "workspace", "agent", "timeoutMs"])
-        if (engine[key] !== undefined)
+        if (engine[key] !== undefined && !(sdk && key === "args"))
             harness[key] = engine[key];
+    if (sdk && engine.args !== undefined) {
+        conversion.notes.push(`engines.${name}: args is dropped. 0.9 did not pass it to OpenCode, and the opencode harness would pass it in place of \`run\`.`);
+    }
     const model = str(engine.model);
     if (model !== undefined)
         converted.ownModelOf.push({ kind: "harnesses", engine: name, model });
@@ -123,6 +138,7 @@ function convertEngines(engines, defaults, env, conversion) {
         connections: {},
         harnesses: {},
         runtimes: new Map(),
+        sdkHarnesses: new Set(),
         keyHolders: [],
         ownModelOf: [],
     };
@@ -132,12 +148,13 @@ function convertEngines(engines, defaults, env, conversion) {
         const unknown = Object.keys(engine).filter((k) => !(engine.kind === "agent" ? AGENT_ENGINE_KEYS : LLM_ENGINE_KEYS).has(k));
         if (unknown.length > 0)
             conversion.notes.push(`engines.${name}: dropped ${unknown.join(", ")}, which akm does not read.`);
+        const llmEngine = str(engine.llmEngine);
         if (engine.kind !== "agent")
             llmEngineToConnection(name, engine, defaults, env, converted, conversion);
-        else if (engine.platform === "opencode-sdk")
-            runtimeEngine(name, engine, converted, conversion);
+        else if (engine.platform === "opencode-sdk" && llmEngine !== undefined)
+            runtimeEngine(name, engine, llmEngine, converted, conversion);
         else
-            agentEngineToHarness(name, engine, converted);
+            agentEngineToHarness(name, engine, converted, conversion);
     }
     return converted;
 }
@@ -161,12 +178,37 @@ function renameMap(names, taken, from) {
     }
     return (name) => moved.get(name) ?? name;
 }
+/** The entry the loader reads as the default: the one called `default`, else the only one. */
+const defaultName = (entries) => "default" in entries ? "default" : Object.keys(entries).length === 1 ? Object.keys(entries)[0] : undefined;
+/**
+ * The engine 0.9 ran agent work on when `defaults.engine` named none and OpenCode was installed: the one called
+ * `opencode-sdk`, else a bare OpenCode of the user's own.
+ */
+const IMPLICIT_AGENT_ENGINE = "opencode-sdk";
+/**
+ * Where agent work ran when `defaults.engine` named no harness, if that is not where it runs now. A runtime was akm's
+ * own; with no `defaults.engine` it was the user's OpenCode, whenever it was installed.
+ */
+function agentWorkMoved(defaultEngine, runtimes, harness) {
+    if (defaultEngine !== undefined) {
+        return runtimes.has(defaultEngine) && harness !== undefined
+            ? `Agent work ran on akm's own runtime (engines.${defaultEngine}); with the harness "${harness}" configured it now runs there. Remove that harness to keep agent work on akm's runtime.`
+            : undefined;
+    }
+    const ran = "Without defaults.engine, agent work ran on your own OpenCode (the implicit fallback), when it was installed";
+    return harness !== undefined
+        ? `${ran}; with the harness "${harness}" configured it now runs there.`
+        : `${ran}; it now runs on akm's own runtime. To keep it on your OpenCode, enable the harness: \`akm setup --harness opencode\`.`;
+}
 /** `defaults.llmEngine`, else `defaults.engine`: that connection is `default`; `defaults.engine` naming one of several harnesses: that harness is. */
 function nameDefaults(defaults, converted, conversion, written) {
-    const { connections, harnesses, runtimes, keyHolders } = converted;
-    const defaultEngine = str(defaults.engine);
+    const { connections, harnesses, runtimes, sdkHarnesses, keyHolders } = converted;
+    const implicit = sdkHarnesses.has(IMPLICIT_AGENT_ENGINE) || runtimes.has(IMPLICIT_AGENT_ENGINE);
+    const defaultEngine = str(defaults.engine) ?? (implicit ? IMPLICIT_AGENT_ENGINE : undefined);
+    const modelWorkEngine = str(defaults.llmEngine);
     const runtimeLlm = defaultEngine === undefined ? undefined : runtimes.get(defaultEngine);
-    const defaultConnection = [str(defaults.llmEngine), defaultEngine, runtimeLlm].find((n) => n !== undefined && n in connections);
+    const modelWorkRuntimeLlm = modelWorkEngine === undefined ? undefined : runtimes.get(modelWorkEngine);
+    const defaultConnection = [modelWorkEngine, modelWorkRuntimeLlm, defaultEngine, runtimeLlm].find((n) => n !== undefined && n in connections);
     const defaultHarness = defaultEngine !== undefined && defaultEngine in harnesses && Object.keys(harnesses).length > 1
         ? defaultEngine
         : undefined;
@@ -177,13 +219,18 @@ function nameDefaults(defaults, converted, conversion, written) {
         connections: renamed(connections, connectionName),
         harnesses: renamed(harnesses, harnessName),
     };
-    const defaultHarnessName = "default" in named.harnesses
-        ? "default"
-        : Object.keys(named.harnesses).length === 1
-            ? Object.keys(named.harnesses)[0]
-            : undefined;
-    if (defaultHarnessName !== undefined && (defaultEngine === undefined || runtimes.has(defaultEngine))) {
-        conversion.notes.push(`Agent work ran on akm's own runtime${defaultEngine === undefined ? "" : ` (engines.${defaultEngine})`}; with the harness "${defaultHarnessName}" configured it now runs there. Remove that harness to keep agent work on akm's runtime.`);
+    const defaultHarnessName = defaultName(named.harnesses);
+    const hasEngines = Object.keys(connections).length + Object.keys(harnesses).length + runtimes.size > 0;
+    const moved = hasEngines ? agentWorkMoved(defaultEngine, runtimes, defaultHarnessName) : undefined;
+    if (moved !== undefined)
+        conversion.notes.push(moved);
+    // `defaults.llmEngine` could name an agent engine, which then ran akm's model work; model work runs on the default
+    // connection, else the default harness, whichever engine that was.
+    if (modelWorkEngine !== undefined && modelWorkEngine in harnesses) {
+        const now = harnessName(modelWorkEngine);
+        if (defaultName({ ...named.connections, ...written.connections }) !== undefined || defaultHarnessName !== now) {
+            conversion.notes.push(`defaults.llmEngine "${modelWorkEngine}" named an agent engine, which ran akm's model work. Model work now runs on the default connection, else the default harness; to keep it on the harness "${now}", set improve.harness to it.`);
+        }
     }
     for (const [kind, rename] of [
         ["connections", connectionName],
@@ -195,10 +242,9 @@ function nameDefaults(defaults, converted, conversion, written) {
         conversion.notes.push(`engines.default is now ${kind}.${aside}, and "default" names another engine: an engine: default key is rewritten by \`akm migrate apply\` where it can be, but a script or scheduled command that passes --engine default now reaches the new "default"; change it to the name ${aside}.`);
     }
     const target = (engine) => {
-        if (runtimes.has(engine)) {
-            const runtime = runtimes.get(engine);
-            return runtime !== undefined && runtime in connections ? { connection: connectionName(runtime) } : undefined;
-        }
+        const runtime = runtimes.get(engine);
+        if (runtime !== undefined)
+            return runtime in connections ? { connection: connectionName(runtime) } : undefined;
         if (engine in harnesses)
             return { harness: harnessName(engine) };
         if (engine in connections)
@@ -210,7 +256,7 @@ function nameDefaults(defaults, converted, conversion, written) {
         connection: connectionName(engine),
         field,
     }));
-    return { defaultConnection, defaultHarness, connectionName, harnessName, ...named, keys, target };
+    return { defaultEngine, defaultConnection, defaultHarness, connectionName, harnessName, ...named, keys, target };
 }
 /** What the file writes under `connections` / `harnesses` itself, read with the converted entries: the written entry wins field by field. */
 function mergeWritten(out, naming) {
@@ -230,6 +276,24 @@ function ownModelsOf(converted, naming) {
     }
     return ownModels;
 }
+/**
+ * Where a gate's judge and akm's other model work run now when nothing names a place: the default connection, else
+ * the default harness. With no `defaults.llmEngine`, 0.9 ran none of that work unless a setting named an engine, so
+ * a default harness that takes it now gets a note saying so and how to turn it off.
+ */
+function modelWorkTarget(defaults, naming, merged, inherited, conversion) {
+    const connection = defaultName({ ...inherited?.connections, ...merged.connections });
+    if (connection !== undefined)
+        return { connection };
+    const harness = defaultName({ ...inherited?.harnesses, ...merged.harnesses });
+    const entry = harness === undefined ? undefined : merged.harnesses[harness];
+    if (harness === undefined || !isRecord(entry))
+        return undefined;
+    if (str(defaults.llmEngine) === undefined && harness in naming.harnesses && entry.modelWork === undefined) {
+        conversion.notes.push(`harnesses.${harness}: akm's own model work (improve, index passes, extraction, judges) now runs on this harness, the default for it with no connection. Without defaults.llmEngine, 0.9 ran none of it unless a setting named an engine (a workflow gate's judge ran on defaults.engine). To keep the 0.9 behaviour, set \`modelWork: false\` on this harness: a call that names it still runs there, but a workflow gate's judge then needs a connection (\`akm setup --endpoint URL\`).`);
+    }
+    return entry.modelWork === false ? undefined : { harness };
+}
 // ── the whole conversion ─────────────────────────────────────────────────────
 export function convertEngineConfig(raw, options = {}) {
     const out = structuredClone(raw);
@@ -254,8 +318,9 @@ export function convertEngineConfig(raw, options = {}) {
         inherited: { connections: options.inherited?.connections ?? {}, harnesses: options.inherited?.harnesses ?? {} },
         renamed: {
             runtime: [...converted.runtimes.values()]
-                .filter((name) => name !== undefined && name in converted.connections)
+                .filter((name) => name in converted.connections)
                 .map((name) => naming.connectionName(name)),
+            sdkHarness: [...converted.sdkHarnesses].map((name) => naming.harnessName(name)),
             connection: (engine) => (engine in converted.connections ? naming.connectionName(engine) : undefined),
         },
     });
@@ -265,7 +330,8 @@ export function convertEngineConfig(raw, options = {}) {
     if (isRecord(improve))
         moveStrategyExecution(improve, conversion, retarget);
     improveStrategyDefault(out, defaults, improve);
-    dropJudgeEngine(out, conversion);
+    const judge = modelWorkTarget(defaults, naming, merged, options.inherited, conversion);
+    dropJudgeEngine(out, conversion, naming.target, naming.defaultEngine, judge);
     convertIndexEngines(out, conversion, retarget);
     // Assemble, keeping the file's key order.
     const config = {};

package/dist/core/config/convert-models-overlay.js

@@ -44,6 +44,7 @@ function overlayRows(modelsOverlay) {
 /**
  * `models.json`: an alias is set by, nearest first, the config's own `models`, models.json's column for that
  * connection or harness, models.json's `*` column (and the flat shorthand, which is that), the engine's own model.
+ * The exception is a harness engine's own model: it ran when a request named none, so it stands over every column.
  */
 export function foldModelsOverlay(modelsOverlay, fold) {
     const { conversion, merged, written, inherited, ownModels, renamed } = fold;
@@ -57,6 +58,10 @@ export function foldModelsOverlay(modelsOverlay, fold) {
     /** Whether the config itself, the file or its base, already names a model for the alias. */
     const configNames = (own, base, name, alias) => hasModel(own[name], alias) || hasModel(base[name], alias);
     const platformOf = (name) => String((mergedHarnesses[name] ?? inheritedHarnesses[name])?.platform ?? name);
+    /** The column of models.json that named a harness: an `opencode-sdk` engine's was `opencode-sdk`, not its platform's. */
+    const columnOf = (name) => (renamed.sdkHarness.includes(name) ? "opencode-sdk" : platformOf(name));
+    /** Harnesses whose engine had a `model` of its own, which names every alias and so stands over the column (noted once each). */
+    const notedOwn = new Set();
     let folded = false;
     for (const { alias, column, profile } of overlayRows(modelsOverlay)) {
         const p = typeof profile === "string" ? { model: profile } : isRecord(profile) ? profile : {};
@@ -76,7 +81,7 @@ export function foldModelsOverlay(modelsOverlay, fold) {
                     : column in writtenConnections || column in inheritedConnections
                         ? [column]
                         : [];
-        const harnessNamed = [...new Set([...Object.keys(mergedHarnesses), ...Object.keys(inheritedHarnesses)])].filter((name) => platformOf(name) === column);
+        const harnessNamed = [...new Set([...Object.keys(mergedHarnesses), ...Object.keys(inheritedHarnesses)])].filter((name) => columnOf(name) === column);
         if (candidates.length === 0 && harnessNamed.length === 0) {
             notes.push(`${where}: names no configured connection or harness, so it is not carried over.`);
             continue;
@@ -84,7 +89,14 @@ export function foldModelsOverlay(modelsOverlay, fold) {
         // The config's own choice stands, and `*` leaves what an explicit column already set.
         const connectionNames = candidates.filter((name) => !configNames(writtenConnections, inheritedConnections, name, alias) &&
             !(column === "*" && hasModel(mergedConnections[name], alias)));
-        const harnessNames = harnessNamed.filter((name) => !configNames(writtenHarnesses, inheritedHarnesses, name, alias));
+        const unnamed = harnessNamed.filter((name) => !configNames(writtenHarnesses, inheritedHarnesses, name, alias));
+        // The model a harness engine named is what ran when a request named none, and a harness runs its first model then,
+        // so it stands over the column, which would put the column's models first.
+        const harnessNames = unnamed.filter((name) => !ownModels.harnesses.has(name));
+        for (const name of unnamed.filter((n) => ownModels.harnesses.has(n) && !notedOwn.has(`${column}:${n}`))) {
+            notedOwn.add(`${column}:${name}`);
+            notes.push(`models.json (${column === "*" ? "all" : column}): harness "${name}" has a model of its own, which names every alias, so the column is not carried over.`);
+        }
         if (connectionNames.length === 0 && harnessNames.length === 0) {
             // Only the config's own choice is worth a note; an explicit column that came first is the overlay's own.
             const keptByConfig = candidates.some((name) => configNames(writtenConnections, inheritedConnections, name, alias)) ||

package/dist/integrations/agent/spawn.js

@@ -14,6 +14,7 @@
  * The command comes from the harness (`harness.build`); this module never
  * touches a model. Agents are reachable only via shell-out.
  */
+import path from "node:path";
 import { ConfigError } from "../../core/errors.js";
 import { childProcessEnv } from "../../core/paths.js";
 import { runManagedSubprocess, streamCaptureFailure } from "../../core/subprocess.js";
@@ -86,10 +87,14 @@ export async function runBuiltCommand(label, { argv, env, stdin }, options, stdi
     // and the optional stdin payload. This keeps the agent-specific surface:
     // the failure taxonomy.
     const start = Date.now();
+    // A program started after `cd <dir>` has PWD equal to <dir>, and OpenCode takes its directory from PWD before its
+    // own working directory: the PWD akm inherits names where akm was started, so a run given a directory names it. One
+    // path is both, so they agree even where the kernel would resolve a `..` after a symbolic link elsewhere.
+    const cwd = options.cwd ? path.resolve(options.cwd) : undefined;
     const result = await runManagedSubprocess([...argv], {
         capture: stdioMode === "captured",
-        env: { ...env },
-        ...(options.cwd ? { cwd: options.cwd } : {}),
+        env: { ...env, ...(cwd ? { PWD: cwd } : {}) },
+        ...(cwd ? { cwd } : {}),
         ...(stdin !== undefined ? { stdin } : {}),
         timeoutMs,
         ...(options.signal ? { signal: options.signal } : {}),

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

@@ -60,9 +60,17 @@ const MODEL_WORK_AGENT_DEFINITION = {
     ],
 };
 const CONFIG_CONTENT_ENV = "OPENCODE_CONFIG_CONTENT";
+/**
+ * OpenCode's built-in browser plugin, removed from model work (a `-` entry in `plugins` removes a plugin, OpenCode 2.0.0
+ * and later). From 2.2.0 it appends a deny of its own skill after every agent's rules, and a rule on one skill keeps
+ * the `skill` tool listed for an agent that denies every tool; without the plugin, the `*` deny removes the tool again.
+ * Model work denies the browser anyway.
+ */
+const WITHOUT_BROWSER_PLUGIN = "-opencode.browser";
 /**
  * The inline config model work runs with: the user's own `OPENCODE_CONFIG_CONTENT` as it is, with akm's agent set on
- * `agents.akm-model-work`, the one key akm's definition wins. OpenCode 2 reads that native `agents` map over the
+ * `agents.akm-model-work`, the one key akm's definition wins, and {@link WITHOUT_BROWSER_PLUGIN} after the user's
+ * `plugins`. OpenCode 2 reads that native `agents` map over the
  * legacy `agent` one, so a same-named entry the user keeps in `agent` is left out rather than left to conflict. The
  * child's value is built from the parent's, so a provider, model or key the user keeps only there stays. It is read as
  * OpenCode reads it, as JSONC (comments and trailing commas), and written back as JSON; content that reads only once
@@ -78,6 +86,7 @@ function modelWorkConfig() {
     }
     const config = {
         ...user,
+        plugins: [...(Array.isArray(user?.plugins) ? user.plugins : []), WITHOUT_BROWSER_PLUGIN],
         agents: { ...asRecord(user?.agents), [MODEL_WORK_AGENT]: MODEL_WORK_AGENT_DEFINITION },
     };
     const legacy = asRecord(user?.agent);

package/dist/integrations/harnesses/opencode/runtime/binary.js

@@ -25,10 +25,13 @@ import { info } from "../../../../core/warn.js";
  * The OpenCode release akm's own runtime runs. It is pinned because the runtime depends on things no OpenCode release
  * promises: the inline config's shape, the `--standalone` flag, the plugin API, the text `run` prints, and the
  * `opencode.db` tables that `../session-log-v2.ts` reads. To move it, change this version and `PACKAGES` if the release
- * adds or drops a platform package, then run `tests/integration/opencode-runtime-sessions.test.ts` against the new
- * binary (it fetches it) and read `docs/reference/configuration.md` ("Without a harness") for what the version changes.
+ * adds or drops a platform package, then run `tests/integration/opencode-runtime-sessions.test.ts` and
+ * `tests/integration/opencode-runtime-loop-guard.test.ts` against the new binary (they fetch it; the plugin ends a
+ * looping run by throwing from a hook, which OpenCode might one day handle differently, and tells the model by changing
+ * the body of a request, which it might one day stop letting a plugin do) and read
+ * `docs/reference/configuration.md` ("Without a harness") for what the version changes.
  */
-export const OPENCODE_RUNTIME_VERSION = "2.1.4";
+export const OPENCODE_RUNTIME_VERSION = "2.2.0";
 /** The platform packages of `@opencode/cli` at {@link OPENCODE_RUNTIME_VERSION}. */
 const PACKAGES = new Set([
     "@opencode/cli-linux-x64",

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

@@ -23,7 +23,7 @@ import { openDatabase } from "../../../../storage/database.js";
 import { resolveAkmInvocation } from "../../../../tasks/resolve-akm-bin.js";
 import { buildChildEnv, runBuiltCommand, } from "../../../agent/spawn.js";
 import { akmOpencodeDatabasePath, akmRuntimeDir } from "../roots.js";
-import { v2SessionTokens } from "../session-log-v2.js";
+import { v2SessionFailure, v2SessionTokens } from "../session-log-v2.js";
 import { ensureRuntimeBinary, OPENCODE_RUNTIME_VERSION, runtimeBinaryPath } from "./binary.js";
 import { runtimeArgv, runtimeConfig, runtimeEnv, runtimePrepareArgv } from "./command.js";
 /**
@@ -61,10 +61,11 @@ function installPlugin(directory) {
 /**
  * OpenCode makes and migrates its database when a process starts, and two processes doing that to one database break
  * each other (one fails with "Standalone server exited before reporting readiness"; on 2.1.4 two runs started together
- * on a fresh directory lose one of them every time). So the first start of this OpenCode version is a preparing run of
- * its own, under a lock file in the runtime directory that every run, of this akm process or another, waits on, and it
- * leaves a marker naming the version; a run that finds the marker and the database starts at once. A dead holder's
- * lock is reclaimed. The run itself reports anything the preparation does not.
+ * on a fresh directory lose one of them every time; on 2.2.0, 4 of 24 starts in groups of eight failed). So the first
+ * start of this OpenCode version is a preparing run of its own, under a lock file in the runtime directory that every
+ * run, of this akm process or another, waits on, and it leaves a marker naming the version; a run that finds the marker
+ * and the database starts at once. A dead holder's lock is reclaimed. The run itself reports anything the preparation
+ * does not.
  */
 async function prepareDatabase(directory, command, opts) {
     const marker = path.join(directory, `prepared-${OPENCODE_RUNTIME_VERSION}`);
@@ -100,9 +101,9 @@ async function prepareDatabase(directory, command, opts) {
     }
 }
 /**
- * The run's session as OpenCode recorded it, read once the process has ended: its id and the tokens its turn used,
- * which a workflow's `budget.max_tokens` and the unit journal count. Nothing when the run made no session. Accounting
- * is best-effort: a database that cannot be read leaves the run's result as it is.
+ * The run's session as OpenCode recorded it, read once the process has ended: its id, the tokens its turn used, which a
+ * workflow's `budget.max_tokens` and the unit journal count, and the message its turn failed with, if it did. Nothing
+ * when the run made no session. Best-effort: a database that cannot be read leaves the run's result as it is.
  */
 function sessionRecord(sessionId) {
     try {
@@ -111,9 +112,11 @@ function sessionRecord(sessionId) {
             const tokens = v2SessionTokens(db, sessionId);
             if (!tokens)
                 return {};
+            const failure = v2SessionFailure(db, sessionId);
             return {
                 sessionId,
                 usage: { inputTokens: tokens.input, outputTokens: tokens.output, reasoningTokens: tokens.reasoning },
+                ...(failure ? { failure } : {}),
             };
         }
         finally {
@@ -160,7 +163,13 @@ export const opencodeRuntime = {
                     writeKeyFile(keyFile, connection.apiKey);
                 await prepareDatabase(directory, { argv: runtimePrepareArgv(binary), env }, opts);
                 const result = await runBuiltCommand(label, { argv: runtimeArgv(connection, dispatch, binary, session), env, stdin: dispatch.prompt }, opts, "captured");
-                return { ...result, ...sessionRecord(session) };
+                const { failure, ...record } = sessionRecord(session);
+                return {
+                    ...result,
+                    ...record,
+                    // OpenCode prints why the turn failed on stderr, which a workflow does not keep; the error carries it.
+                    ...(result.reason === "non_zero_exit" && failure ? { error: `${result.error}: ${failure}` } : {}),
+                };
             }
             finally {
                 fs.rmSync(keyFile, { force: true });