akm-cli 0.9.25-alpha.1 → 0.9.25-alpha.2

package/dist/integrations/harnesses/ids.js

@@ -1,19 +1,17 @@
 // 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, 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: [] },
+    { id: "opencode", agentDispatch: true, enforcesModelWorkTools: true },
+    { id: "claude", agentDispatch: true, enforcesModelWorkTools: true },
+    { id: "opencode-sdk", agentDispatch: true, enforcesModelWorkTools: true },
+    { id: "codex", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "copilot", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "pi", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "gemini", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "aider", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "amazonq", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "openhands", agentDispatch: true, enforcesModelWorkTools: false },
 ];
 /**
  * Canonical, ordered list of valid harness / platform ids — the
@@ -26,7 +24,3 @@ export const VALID_HARNESS_IDS = Object.freeze(HARNESS_ID_TABLE.map((h) => h.id)
 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,11 +14,10 @@
  * pre-migration `opencodeBuilder`. The builder's `platform` stays `'opencode'`
  * (the canonical harness id).
  */
-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";
+import { MODEL_WORK_AGENT_INFERENCE, opencodeInferenceConfig } from "./model-config.js";
+import { MODEL_WORK_OPENCODE_AGENT, modelWorkOpencodeConfig, modelWorkPluginEnv } from "./model-work-agent.js";
 /**
  * OpenCode builder.
  * Command shape: opencode run [--agent <name>] [--model <m>] -- "<prompt>"
@@ -36,11 +35,9 @@ import { MODEL_WORK_OPENCODE_AGENT, modelWorkOpencodeConfig } from "./model-work
  * 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.
+ * Model work's agent carries the request's inference options
+ * (`./model-config.ts`). Any other dispatch injects nothing and carries none, so
+ * the model's own opencode config applies: set inference there.
  */
 export const opencodeBuilder = {
     platform: "opencode",
@@ -50,19 +47,12 @@ export const opencodeBuilder = {
         personaChannel: "prompt",
         nativeAgentSelector: true,
         tools: "none",
-        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));
-        },
+        inference: MODEL_WORK_AGENT_INFERENCE,
     }),
     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) {
+        if (req.modelWork) {
+            const model = req.model ?? modelFromArgs(profile.args);
+            const { agentOptions } = opencodeInferenceConfig(req.inference, true);
             return {
                 argv: [
                     profile.bin,
@@ -73,7 +63,10 @@ export const opencodeBuilder = {
                     "--",
                     req.prompt,
                 ],
-                env: { OPENCODE_CONFIG_CONTENT: JSON.stringify({ ...modelWorkOpencodeConfig(agentOptions), ...modelConfig }) },
+                env: {
+                    ...modelWorkPluginEnv(),
+                    OPENCODE_CONFIG_CONTENT: JSON.stringify(modelWorkOpencodeConfig(agentOptions)),
+                },
             };
         }
         const args = req.model ? [] : [...profile.args];
@@ -99,9 +92,6 @@ export const opencodeBuilder = {
         }
         args.push("--");
         args.push(req.prompt);
-        return {
-            argv: [profile.bin, ...args],
-            ...(modelConfig ? { env: { OPENCODE_CONFIG_CONTENT: JSON.stringify(modelConfig) } } : {}),
-        };
+        return { argv: [profile.bin, ...args] };
     },
 };

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

@@ -1,80 +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;
 /**
- * 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.
+ * 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 carriedInference(inference) {
-    const carried = {};
+export function opencodeInferenceConfig(inference, modelWork) {
     const { temperature, reasoningEffort, enableThinking, maxTokens, contextLength } = inference ?? {};
+    const options = {};
     if (typeof temperature === "number" && Number.isFinite(temperature))
-        carried.temperature = temperature;
+        options.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;
+        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 } : {}),
-            ...(carried.limit ? { limit: { ...carried.limit } } : {}),
+            ...(isPositiveInteger(maxTokens) && isPositiveInteger(contextLength)
+                ? { limit: { context: contextLength, output: maxTokens } }
+                : {}),
         },
         ...(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 } } } };
-}

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

@@ -3,18 +3,20 @@
 // 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_TOOLS`). The CLI builder injects it through
+ * 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 and edit stay inside the session directory (`external_directory`
- *     is denied). Write is part of opencode's edit permission, so it is
- *     confined the same way and cannot be denied on its own.
- *   - bash is denied, so `akm search` and `akm show` are not granted: 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.
+ *   - 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
@@ -26,36 +28,62 @@
  *   - 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;
- *   - `steps` bounds the agentic loop. opencode only asks the model to stop
- *     at the limit, so the SDK runner also aborts the session a little past
- *     it (`MODEL_WORK_STEP_GRACE`); on the CLI the dispatch timeout bounds 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";
-/** The agentic iterations a model-work run may take: a judge answers in one, a generator in a few. */
-export const MODEL_WORK_STEPS = 8;
-/** Steps past {@link MODEL_WORK_STEPS} after which the SDK runner aborts the session. */
-export const MODEL_WORK_STEP_GRACE = 2;
 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.";
-const MODEL_WORK_PERMISSION = {
-    "*": "deny",
-    read: "allow",
-    edit: "allow",
-    external_directory: "deny",
-    bash: "deny",
-    doom_loop: "deny",
-    glob: "deny",
-    grep: "deny",
-    list: "deny",
-    lsp: "deny",
-    question: "deny",
-    skill: "deny",
-    task: "deny",
-    todowrite: "deny",
-    webfetch: "deny",
-    websearch: "deny",
-};
+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
@@ -63,17 +91,24 @@ const MODEL_WORK_PERMISSION = {
  * 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: { ...MODEL_WORK_PERMISSION },
+        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,
-                steps: MODEL_WORK_STEPS,
                 ...(options ? { options } : {}),
-                permission: { ...MODEL_WORK_PERMISSION },
+                permission: { ...permission },
             },
         },
     };

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

@@ -21,9 +21,8 @@
  * Importing the descriptor from this leaf keeps the registry a config-leaf and
  * breaks the cycle.
  */
-import { isModelWorkTools } from "../../../execution/source.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
-import { opencodeCarriedKeys } from "../opencode/model-config.js";
+import { MODEL_WORK_AGENT_INFERENCE } from "../opencode/model-config.js";
 import { caps } from "../shared.js";
 import { BaseHarness } from "../types.js";
 /**
@@ -43,10 +42,7 @@ export class OpencodeSdkHarness extends BaseHarness {
             personaChannel: "native",
             nativeAgentSelector: true,
             tools: "sdk",
-            modelWorkTools: true,
-            // The server config gives the routed model its inference entry, so the request must name a model, except
-            // that model work's agent carries its options whichever model opencode picks.
-            inference: (_profile, request) => opencodeCarriedKeys(Boolean(request.model?.resolved), request.inference, isModelWorkTools(request.tools)),
+            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

@@ -93,11 +93,10 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { isRecord } from "../../../core/common.js";
-import { COMMON_SPAWN_ENV_PASSTHROUGH, spawnEnvNamesFor } from "../../../core/spawn-env.js";
-import { isModelWorkTools } from "../../../execution/source.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, opencodeModelConfig } from "../opencode/model-config.js";
-import { MODEL_WORK_OPENCODE_AGENT, MODEL_WORK_STEP_GRACE, MODEL_WORK_STEPS, modelWorkOpencodeConfig, } from "../opencode/model-work-agent.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.
@@ -251,12 +250,12 @@ function fallbackInference(llmConfig) {
  * aliases resolve once before harness lowering. A server for model work also
  * defines the confined model-work agent (`../opencode/model-work-agent`).
  *
- * The routed model carries the dispatch's inference (`../opencode/model-config`):
- * the fallback LLM engine's, under `requestInference`, the request's own. A
- * model the config routes through `akm-custom` is declared in full; any other
- * model's entry merges over the user's own opencode config for it. 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.
+ * 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, modelWork = false, requestInference) {
     const endpoint = llmConfig?.endpoint;
@@ -288,11 +287,6 @@ export function buildSdkConfig(profile, llmConfig, modelWork = false, requestInf
         if (modelId)
             sdkConfig.model = `akm-custom/${modelId}`;
     }
-    else {
-        const modelConfig = opencodeModelConfig(model, entry);
-        if (modelConfig)
-            Object.assign(sdkConfig, modelConfig);
-    }
     return modelWork ? { ...sdkConfig, ...modelWorkOpencodeConfig(agentOptions) } : sdkConfig;
 }
 /** Digest the executable and exact environment received by the child. */
@@ -302,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];
@@ -315,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;
 }
@@ -586,7 +594,7 @@ function getOrStartServer(profile, llmConfig, env, envSource = process.env, mode
     if (_testServer)
         return { promise: Promise.resolve(_testServer), release() { } };
     const sdkConfig = buildSdkConfig(profile, llmConfig, modelWork, inference);
-    const serverEnv = buildServerEnv(profile, sdkConfig, env, envSource);
+    const serverEnv = buildServerEnv(profile, sdkConfig, env, envSource, modelWork);
     const key = serverRegistryKey(profile, serverEnv);
     let entry = _servers.get(key);
     if (!entry) {
@@ -736,51 +744,6 @@ async function deleteSessionBestEffort(client, sessionId, query, setTimeoutFn, c
 function abortSessionBestEffort(client, sessionId, query) {
     void client.session.abort?.({ path: { id: sessionId }, ...(query ? { query } : {}) }).catch(() => { });
 }
-/** How often a model-work session's messages are polled for its step count. */
-const MODEL_WORK_STEP_POLL_MS = 1_000;
-/**
- * Count a model-work session's steps, its `step-start` parts, once a second
- * and abort the session once they pass `MODEL_WORK_STEPS` +
- * `MODEL_WORK_STEP_GRACE`: opencode 1.18.25 only asks the model to stop at the
- * agent's `steps`. Polled rather than read from the server's event stream,
- * because the SDK's stream cannot be closed mid-read without an unhandled
- * AbortError (its abort handler drops the promise `reader.cancel()` returns),
- * which the CLI turns into a crash. Best effort: the dispatch timeout still
- * bounds the session.
- */
-function watchModelWorkSteps(client, sessionId, query, timers) {
-    let steps = 0;
-    let timer;
-    let stopped = false;
-    const poll = async () => {
-        const listed = await client.session.messages?.({ path: { id: sessionId }, ...(query ? { query } : {}) });
-        if (stopped)
-            return;
-        steps = (listed?.data ?? [])
-            .flatMap((message) => message.parts ?? [])
-            .filter((p) => p.type === "step-start").length;
-        if (steps > MODEL_WORK_STEPS + MODEL_WORK_STEP_GRACE)
-            abortSessionBestEffort(client, sessionId, query);
-        else
-            schedule();
-    };
-    const schedule = () => {
-        if (stopped || !client.session.messages)
-            return;
-        timer = timers.setTimeoutFn(() => void poll().catch(() => schedule()), MODEL_WORK_STEP_POLL_MS);
-        if (typeof timer !== "number")
-            timer.unref?.();
-    };
-    schedule();
-    return {
-        steps: () => steps,
-        stop: () => {
-            stopped = true;
-            if (timer !== undefined)
-                timers.clearTimeoutFn(timer);
-        },
-    };
-}
 function abortedBeforeSdkStart(profile) {
     return {
         ok: false,
@@ -801,7 +764,7 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
     const clearTimeoutImpl = opts.clearTimeoutFn ?? clearTimeout;
     if (opts.signal?.aborted)
         return abortedBeforeSdkStart(profile);
-    const modelWork = isModelWorkTools(opts.dispatch?.tools);
+    const modelWork = opts.dispatch?.modelWork === true;
     let client;
     if (_testServer) {
         client = _testServer.client;
@@ -935,7 +898,7 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
     const dispatch = opts.dispatch;
     const agent = modelWork ? MODEL_WORK_OPENCODE_AGENT : dispatch?.agent;
     const system = dispatch?.systemPrompt;
-    const tools = modelWork ? undefined : toolsToSdkAllowlist(dispatch?.tools);
+    const tools = toolsToSdkAllowlist(dispatch?.tools);
     const body = { parts: [{ type: "text", text: prompt }] };
     if (agent)
         body.agent = agent;
@@ -944,9 +907,6 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
     if (tools)
         body.tools = tools;
     let result;
-    const steps = modelWork
-        ? watchModelWorkSteps(client, sessionId, query, { setTimeoutFn: setTimeoutImpl, clearTimeoutFn: clearTimeoutImpl })
-        : undefined;
     try {
         const prompted = await raceSdkOperation(client.session.prompt({ path: { id: sessionId }, body, ...(query ? { query } : {}) }), {
             timeoutMs: remainingTimeoutMs(),
@@ -957,8 +917,8 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
                 void deleteSessionBestEffort(client, sessionId, query, setTimeoutImpl, clearTimeoutImpl);
             },
         });
-        // A model-work session the dispatch stops early is aborted on the server too.
-        if (modelWork && (prompted === SDK_OPERATION_ABORTED || prompted === SDK_OPERATION_TIMED_OUT)) {
+        // 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) {
@@ -994,22 +954,7 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
             // default sdk runner.
             const usage = extractUsage(prompted.data?.info);
             const sdkError = prompted.error ?? prompted.data?.info?.error;
-            const overSteps = steps !== undefined && steps.steps() > MODEL_WORK_STEPS + MODEL_WORK_STEP_GRACE;
-            if (overSteps) {
-                const message = `opencode-sdk agent "${profile.name}" ran past the ${MODEL_WORK_STEPS}-step limit for model work; akm aborted the session.`;
-                result = {
-                    ok: false,
-                    stdout,
-                    stderr: message,
-                    durationMs: Date.now() - start,
-                    exitCode: 1,
-                    reason: "parse_error",
-                    error: message,
-                    sessionId,
-                    ...(usage ? { usage } : {}),
-                };
-            }
-            else if (sdkError) {
+            if (sdkError) {
                 const failure = sdkErrorFailure(sdkError);
                 result = {
                     ok: false,
@@ -1048,9 +993,6 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
             sessionId,
         };
     }
-    finally {
-        steps?.stop();
-    }
     // Clean up session to prevent disk accumulation in ~/.local/share/opencode/.
     // Failures are non-fatal to the agent result but must not be invisible.
     const cleanupWarning = await deleteSessionBestEffort(client, sessionId, query, setTimeoutImpl, clearTimeoutImpl);

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

@@ -59,8 +59,7 @@
  *   akm's `workflow_run_units` remains the durable source of truth either way
  *   (plan §"Session, MCP, and identity across harnesses").
  * - **inference** — not translated: the shared lowering reports each field of
- *   the request's inference as untranslated (`inference` in `harnesses/ids.ts`
- *   lists none for this harness).
+ *   the request's inference as untranslated.
  *
  * Registered: `openhandsBuilder` is `OpenhandsHarness.agentBuilder`
  * (`./index.ts`), one of the ten harnesses `HARNESS_REGISTRY` constructs

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

@@ -40,8 +40,7 @@
  *   produce a silently broken command. A restrictive policy is therefore
  *   dropped rather than approximated — never silently widened.
  * - **inference** — not translated: the shared lowering reports each field of
- *   the request's inference as untranslated (`inference` in `harnesses/ids.ts`
- *   lists none for this harness).
+ *   the request's inference as untranslated.
  *
  * Registered: `piBuilder` is `PiHarness.agentBuilder` (`./index.ts`), one of
  * the ten harnesses `HARNESS_REGISTRY` constructs (`harnesses/index.ts`);

package/dist/llm/feature-gate.js

@@ -1,6 +1,7 @@
 // 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/.
+import { DEFAULT_LLM_TIMEOUT_MS } from "../integrations/agent/config.js";
 /**
  * For each feature key, return the effective enabled state by reading the
  * 0.9.0 config shape.
@@ -37,10 +38,6 @@ export function isLlmFeatureEnabled(config, feature, improveEnabled) {
         return false;
     return resolver(config);
 }
-/**
- * Default hard timeout for every bounded in-tree LLM call.
- */
-const DEFAULT_TIMEOUT_MS = 600_000;
 /**
  * Run `fn()` only if `isLlmFeatureEnabled(config, feature)` is `true`. On
  * disablement, throw, or timeout, return `fallback` (or — if it is a
@@ -53,7 +50,7 @@ export async function tryLlmFeature(feature, config, fn, fallback, opts) {
         opts?.onFallback?.({ feature, reason: "disabled" });
         return resolveFallback();
     }
-    const timeoutMs = opts && Object.hasOwn(opts, "timeoutMs") ? (opts.timeoutMs ?? null) : DEFAULT_TIMEOUT_MS;
+    const timeoutMs = opts && Object.hasOwn(opts, "timeoutMs") ? (opts.timeoutMs ?? null) : DEFAULT_LLM_TIMEOUT_MS;
     try {
         if (timeoutMs === null || timeoutMs <= 0) {
             return await fn(new AbortController().signal);