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

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/integrations/harnesses/types.js

@@ -34,14 +34,14 @@ export function isSessionLogHarness(h) {
  * `HarnessCapabilities` union type here, and each subclass narrows it to a
  * literal `sessionLogs: true`/`false` variant via `caps({...})`.
  * `sessionLogProvider` is intentionally NOT declared here at all (not even
- * optional): the 8 non-session-log subclasses simply never declare it, which
+ * optional): the 7 non-session-log subclasses simply never declare it, which
  * satisfies `NonSessionLogHarness`'s `sessionLogProvider?: undefined` (an
  * absent optional property satisfies an `undefined`-typed optional); had this
  * class declared it as `sessionLogProvider?: () => SessionLogHarness`
  * instead, every non-session-log subclass would inherit that (function |
  * undefined) type and fail to satisfy `NonSessionLogHarness` at the
- * `HARNESS_REGISTRY` `satisfies` check. The two session-log subclasses
- * (Claude, OpenCode) declare their own required `sessionLogProvider`.
+ * `HARNESS_REGISTRY` `satisfies` check. The three session-log subclasses
+ * (Claude, Codex, OpenCode) declare their own required `sessionLogProvider`.
  */
 export class BaseHarness {
     setupDetectionDir;

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

package/dist/llm/index-passes.js

@@ -2,7 +2,6 @@
 // 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 { cloneExecutionJsonObject } from "../execution/json.js";
-import { MODEL_WORK_TOOLS } from "../execution/source.js";
 import { buildExecution, resolveExecution } from "../integrations/agent/execution.js";
 const NO_LOWERING_NOTICES = Object.freeze([]);
 function own(value, key) {
@@ -43,7 +42,8 @@ export function resolveIndexPassExecution(passName, config) {
         content: "",
         config,
         invocationDefaults,
-        current: { ...indexExecutionDefaults(pass), tools: MODEL_WORK_TOOLS },
+        current: indexExecutionDefaults(pass),
+        modelWork: true,
     });
     const lowered = buildExecution(prepared.request, prepared.runner);
     return Object.freeze({ runner: lowered.runner, notices: lowered.notices });

package/dist/llm/structured-call.js

@@ -2,8 +2,7 @@
 // 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 { ConfigError } from "../core/errors.js";
-import { MODEL_WORK_TOOLS } from "../execution/source.js";
-import { DEFAULT_MODEL_WORK_TIMEOUT_MS } from "../integrations/agent/config.js";
+import { DEFAULT_LLM_TIMEOUT_MS } from "../integrations/agent/config.js";
 import { buildExecution, resolveExecution } from "../integrations/agent/execution.js";
 import { runExecution } from "../integrations/agent/runner-dispatch.js";
 import { isContextSizeError, LlmCallError } from "./client.js";
@@ -27,7 +26,7 @@ function own(value, key) {
 /**
  * @internal Exact request-to-cascade projection, exported for presence-semantics contracts.
  * Model work is bounded: with no timeout from the request or the runner, it
- * gets {@link DEFAULT_MODEL_WORK_TIMEOUT_MS} on every runner kind.
+ * gets {@link DEFAULT_LLM_TIMEOUT_MS} on every runner kind.
  */
 export function resolveStructuredCurrent(current, request, runner) {
     const out = current ? { ...current } : {};
@@ -53,7 +52,7 @@ export function resolveStructuredCurrent(current, request, runner) {
     if (own(request, "timeoutMs"))
         out.timeout = request?.timeoutMs ?? null;
     else if (runner && !Object.hasOwn(runner, "timeoutMs") && !own(current, "timeout")) {
-        out.timeout = DEFAULT_MODEL_WORK_TIMEOUT_MS;
+        out.timeout = DEFAULT_LLM_TIMEOUT_MS;
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
@@ -104,7 +103,8 @@ export async function callStructured(opts) {
             content: terminal.content,
             conversation: terminal.conversation,
             runner,
-            current: { ...resolveStructuredCurrent(opts.current, request, runner), tools: MODEL_WORK_TOOLS },
+            current: resolveStructuredCurrent(opts.current, request, runner),
+            modelWork: true,
         });
         const lowered = buildExecution(prepared.request, prepared.runner);
         opts.onNotices?.(lowered.notices);

package/dist/output/shapes/passthrough.js

@@ -43,6 +43,7 @@ const PASSTHROUGH_COMMANDS = [
     "extract",
     "health",
     "improve",
+    "improve-judge",
     "improve-report",
     "import",
     "index",