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

package/dist/core/config/schema/improve-processes.js

@@ -103,6 +103,21 @@ const fidelityCheckField = z.object({ enabled: z.boolean().optional() }).passthr
  * byte-identical behaviour). Reflect process only.
  */
 const lowValueFilterField = z.object({ enabled: z.boolean().optional() }).passthrough().optional();
+/**
+ * The wording lists of reflect's pre-judge defect filter (`findReflectDefect`).
+ * Each list is optional: one that is set replaces that rule's default list, and
+ * an empty one turns the rule off. Phrases (`placeholders`, `metaCommentary`)
+ * match as whole words in any case; `frontmatterKeys` are exact key names.
+ * Reflect process only.
+ */
+const defectFilterField = z
+    .object({
+    placeholders: z.array(nonEmptyString).optional(),
+    metaCommentary: z.array(nonEmptyString).optional(),
+    frontmatterKeys: z.array(nonEmptyString).optional(),
+})
+    .passthrough()
+    .optional();
 /**
  * #626 — extract process: pre-LLM heuristic triage gate. When enabled, a
  * deterministic scorer decides BEFORE the extraction LLM call whether a
@@ -159,6 +174,7 @@ const REFLECT_PROCESS_FIELDS = {
     limit: processLimitField,
     qualityGate: qualityGateField,
     lowValueFilter: lowValueFilterField,
+    defectFilter: defectFilterField,
 };
 const DISTILL_PROCESS_FIELDS = {
     allowedTypes: allowedTypesField,

package/dist/core/redaction.js

@@ -19,6 +19,10 @@ const ENV_PASSTHROUGH_REDACTION_POLICY = {
     OPENCODE_CONFIG: "path",
     CLAUDE_CONFIG: "path",
     CODEX_CONFIG: "path",
+    XDG_CONFIG_HOME: "path",
+    XDG_DATA_HOME: "path",
+    XDG_CACHE_HOME: "path",
+    XDG_STATE_HOME: "path",
     AWS_PROFILE: "identifier",
     AWS_REGION: "identifier",
     LLM_MODEL: "identifier",

package/dist/core/spawn-env.js

@@ -45,6 +45,31 @@ export const COMMON_SPAWN_ENV_PASSTHROUGH = [
     "TMPDIR",
     "AKM_EVENT_SOURCE",
 ];
+/**
+ * The XDG base-directory variables. opencode resolves its config, data, cache
+ * and state directories from them, so it must receive them: an akm that runs
+ * under a custom `XDG_CONFIG_HOME` otherwise spawns an opencode that reads
+ * `$HOME/.config/opencode` and misses the provider config its caller named.
+ *
+ * Deliberately NOT part of {@link COMMON_SPAWN_ENV_PASSTHROUGH}, which is every
+ * harness's baseline, the workflow exec unit's default allowlist (a documented
+ * list) and, through profile `envPassthrough`, frozen into workflow plans.
+ * codex, gemini and pi keep their own dotdirs under `$HOME`, and handing the
+ * names to a shell command would redirect the `git` and `gh` config it reads. A
+ * harness that reads them asks for them by name: the opencode profile's list,
+ * and the opencode-sdk server's allowlist (`opencodeSdkServerEnvironmentNames`).
+ *
+ * A name added to a profile's list changes the plans frozen after it (their
+ * bytes, so their `plan_hash`); a stored plan keeps the list it was frozen with
+ * and still resumes, because nothing gates on that hash. The SDK server's
+ * allowlist is not part of a plan, so it takes the names by code.
+ */
+export const XDG_BASE_DIR_ENV_PASSTHROUGH = [
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_CACHE_HOME",
+    "XDG_STATE_HOME",
+];
 /**
  * The names Windows itself requires of ANY child, whatever the caller's
  * allowlist says. Applied at build time rather than added to

package/dist/core/structured.js

@@ -34,7 +34,7 @@ import { parseEmbeddedJsonResponse } from "./parse.js";
 export function withSchemaInstruction(prompt, schema) {
     return `${prompt}\n\nRespond with ONLY a JSON value matching this JSON Schema (no prose, no code fences):\n${JSON.stringify(schema)}`;
 }
-function defaultFeedback(failure) {
+export function defaultFeedback(failure) {
     if (failure.reason === "parse_error") {
         return "Your previous response contained no parseable JSON. Respond with ONLY a JSON value that matches the requested schema — no prose, no code fences.";
     }

package/dist/execution/source.js

@@ -6,19 +6,15 @@ export const EXECUTION_SOURCE_SCHEMA_VERSION = 1;
 /** Current internal adapter identifiers are lowercase kebab-case registry keys. */
 export const EXECUTION_ADAPTER_ID_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 /**
- * The model-work tool policy: unattended model work (improve, the judges,
- * index passes, remember) may read, edit only inside the dispatch's own
- * scratch working directory, and run `akm search` and `akm show`. The stash
- * stays read-only to it. A transport grants what it can confine and refuses
- * the policy at build when it can confine nothing; an LLM has no tools.
+ * The model-work tool policy: unattended model work (improve, the judges, index
+ * passes, remember) may read, edit only inside the dispatch's own scratch
+ * working directory, and run `akm search` and `akm show`; the stash stays
+ * read-only to it. A transport grants what it can confine and refuses the policy
+ * at build when it can confine nothing; an LLM has no tools. A request carries it
+ * as `authorization.policy.id`, set only when its caller asks (`modelWork`): no
+ * `tools` value names it, so an asset's own `tools:` cannot.
  */
-export const MODEL_WORK_TOOLS = Object.freeze(["read", "edit", "akm search", "akm show"]);
-/** Whether a selection names the model-work tool policy. */
-export function isModelWorkTools(tools) {
-    return (Array.isArray(tools) &&
-        tools.length === MODEL_WORK_TOOLS.length &&
-        tools.every((tool, index) => tool === MODEL_WORK_TOOLS[index]));
-}
+export const MODEL_WORK_POLICY_ID = "model-work";
 function requireRecord(value, path) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         throw new TypeError(`${path} must be an object`);

package/dist/integrations/agent/config.js

@@ -3,7 +3,5 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /** Default agent CLI timeout; null means agents run until they finish. */
 export const DEFAULT_AGENT_TIMEOUT_MS = null;
-/** Default hard timeout for direct LLM calls when no engine/use override exists. */
+/** Default hard timeout for a direct LLM call, and the bound on model work on every runner kind, when no engine/use override exists. */
 export const DEFAULT_LLM_TIMEOUT_MS = 600_000;
-/** Default bound on model work (structured calls, judgments) on every runner kind. */
-export const DEFAULT_MODEL_WORK_TIMEOUT_MS = 600_000;

package/dist/integrations/agent/engine-resolution.js

@@ -13,7 +13,6 @@ import { collectSensitiveValues } from "../../core/redaction.js";
 import { resolveSecretFromStore } from "../../sources/snapshot-fetchers/secret-seam.js";
 import { getHarness } from "../harnesses/index.js";
 import { DEFAULT_LLM_TIMEOUT_MS } from "./config.js";
-import { engineModelAndInference } from "./model-map.js";
 import { getBuiltinAgentProfile, OPENCODE_SDK_SERVER_BIN } from "./profiles.js";
 const LLM_CONNECTION_FIELDS = [
     "provider",
@@ -274,7 +273,6 @@ function lowerAgentEngine(name, engine, config) {
     const platform = harness.id;
     const sdk = platform === "opencode-sdk";
     const builtin = getBuiltinAgentProfile(platform);
-    const { inference } = engineModelAndInference(engine);
     const profile = {
         name,
         platform,
@@ -287,7 +285,6 @@ function lowerAgentEngine(name, engine, config) {
         parseOutput: "text",
         ...(engine.workspace ? { workspace: path.resolve(engine.workspace) } : {}),
         ...(engine.model ? { model: engine.model } : {}),
-        ...(inference ? { inference } : {}),
     };
     // An engine that sets no timeoutMs leaves it unset, so a caller's own default
     // (model work's 600 s) can apply; a dispatch with none runs unbounded.

package/dist/integrations/agent/execution.js

@@ -6,7 +6,7 @@ import { ConfigError } from "../../core/errors.js";
 import { DURATION_UNITS, parseDuration } from "../../core/time.js";
 import { EXECUTION_MAX_TIMEOUT_MS } from "../../execution/limits.js";
 import { createInlineResolvedCommand, createResolvedExecutionRequest, decodeResolvedExecutionRequest, } from "../../execution/resolved-request.js";
-import { cloneToolSelection, isModelWorkTools, isPortableExecutionAgentSelector, } from "../../execution/source.js";
+import { cloneToolSelection, isPortableExecutionAgentSelector, MODEL_WORK_POLICY_ID, } from "../../execution/source.js";
 import { getHarness } from "../harnesses/index.js";
 import { DEFAULT_LLM_TIMEOUT_MS } from "./config.js";
 import { FALLBACK_ENGINE_NAME, fallbackEngineConfig, NO_ENGINE_MESSAGE_SUFFIX, NO_ENGINE_REMEDY, } from "./engine-fallback.js";
@@ -78,11 +78,8 @@ function engineDefaults(name, engine, config) {
         modelMapKey: own.model === undefined ? fallbackName : "opencode-sdk",
         values: {
             ...(inherited.model !== undefined ? { model: inherited.model } : {}),
+            ...(inherited.inference !== undefined ? { inference: inherited.inference } : {}),
             ...values,
-            // The engine's own inference is added over the fallback's, field by field.
-            ...(inherited.inference !== undefined || own.inference !== undefined
-                ? { inference: { ...inherited.inference, ...own.inference } }
-                : {}),
             timeout: Object.hasOwn(engine, "timeoutMs")
                 ? (engine.timeoutMs ?? null)
                 : Object.hasOwn(fallback, "timeoutMs")
@@ -191,12 +188,16 @@ function requestedToolNames(tools) {
  * nothing is allowed. The model-work policy is akm's own and always allowed:
  * it confines an engine more tightly than leaving tools unset does.
  */
-function authorizeTools(tools, config) {
+function authorizeTools(tools, config, modelWork) {
+    if (modelWork) {
+        return {
+            status: "allowed",
+            reason: "The model-work tool policy is akm's own.",
+            policy: { id: MODEL_WORK_POLICY_ID },
+        };
+    }
     if (!hasToolSelection(tools))
         return { status: "not-required" };
-    if (isModelWorkTools(tools)) {
-        return { status: "allowed", reason: "The model-work tool policy is akm's own.", policy: { id: "model-work" } };
-    }
     if (!config) {
         return {
             status: "denied",
@@ -392,13 +393,14 @@ export function resolveExecution(input) {
         return layer;
     };
     const schemaLayer = select("outputSchema", "outputSchema");
-    const toolsLayer = select("tools", "tools");
+    const modelWork = input.modelWork === true;
+    const toolsLayer = modelWork ? undefined : select("tools", "tools");
     const timeoutLayer = select("timeout", "runtime.timeoutMs");
     const workspaceLayer = select("workspace", "runtime.workspace");
     const environmentLayer = select("environment", "runtime.environment");
     const settingsLayer = select("runtime", "runtime.settings");
     const tools = toolsLayer ? cloneToolSelection(toolsLayer.values.tools ?? null, "tools") : undefined;
-    const authorization = authorizeTools(tools, input.runner ? undefined : input.config);
+    const authorization = authorizeTools(tools, input.runner ? undefined : input.config, modelWork);
     provenance.authorization = {
         layer: typeof authorization.policy?.id === "string" ? authorization.policy.id : "not-required",
         kind: "authorization",
@@ -438,8 +440,7 @@ function buildLlm(request, runner, options) {
     if (typeof request.agent === "string" && request.persona === null) {
         throw new ConfigError(`The direct LLM transport cannot consume native agent selector ${JSON.stringify(request.agent)}.`, "INVALID_CONFIG_FILE");
     }
-    // An LLM has no tools, which already meets the model-work policy.
-    if (hasToolSelection(request.tools) && !isModelWorkTools(request.tools)) {
+    if (hasToolSelection(request.tools)) {
         throw new ConfigError("The direct LLM transport cannot enforce the resolved tool policy.", "INVALID_CONFIG_FILE");
     }
     const notices = [...request.notices];

package/dist/integrations/agent/index.js

@@ -4,4 +4,4 @@
 export { DEFAULT_AGENT_TIMEOUT_MS } from "./config.js";
 export { _setAgentDetectForTests, defaultWhich, detectAgentCliProfiles, pickDefaultAgentProfile } from "./detect.js";
 export { BUILTIN_AGENT_PROFILE_NAMES, getBuiltinAgentProfile, listBuiltinAgentProfiles, } from "./profiles.js";
-export { buildProposePrompt, buildReflectPrompt, buildSchemaRepairPrompt, parseAgentProposalPayload, } from "./prompts.js";
+export { buildProposePrompt, buildReflectPrompt, parseAgentProposalPayload } from "./prompts.js";

package/dist/integrations/agent/model-map.js

@@ -220,33 +220,32 @@ function mergeProfiles(base, overlay) {
  * copied verbatim from the engine's own config value; it must already be
  * meaningful for the model-map column's platform (akm does not translate
  * between an engine's connection and an agent platform's own provider
- * registry). An agent-kind engine contributes only the inference fields its
- * platform translates (config validation rejects the rest); an `llm` engine
- * also contributes `supportsJsonSchema` and `extraParams`.
+ * registry). Only `kind: "llm"` engines contribute inference defaults — an
+ * agent-kind engine's schema carries no temperature/thinking fields.
  */
 export function engineModelAndInference(engine) {
     const out = {};
     if (Object.hasOwn(engine, "model") && engine.model !== undefined)
         out.model = engine.model;
-    const inference = {};
-    if (Object.hasOwn(engine, "temperature"))
-        inference.temperature = engine.temperature;
-    if (Object.hasOwn(engine, "maxTokens"))
-        inference.maxTokens = engine.maxTokens;
     if (engine.kind === "llm") {
+        const inference = {};
+        if (Object.hasOwn(engine, "temperature"))
+            inference.temperature = engine.temperature;
+        if (Object.hasOwn(engine, "maxTokens"))
+            inference.maxTokens = engine.maxTokens;
         if (Object.hasOwn(engine, "supportsJsonSchema"))
             inference.supportsJsonSchema = engine.supportsJsonSchema;
         if (Object.hasOwn(engine, "extraParams"))
             inference.extraParams = engine.extraParams;
+        if (Object.hasOwn(engine, "contextLength"))
+            inference.contextLength = engine.contextLength;
+        if (Object.hasOwn(engine, "enableThinking"))
+            inference.enableThinking = engine.enableThinking;
+        if (Object.hasOwn(engine, "reasoningEffort"))
+            inference.reasoningEffort = engine.reasoningEffort;
+        if (Object.keys(inference).length > 0)
+            out.inference = inference;
     }
-    if (Object.hasOwn(engine, "contextLength"))
-        inference.contextLength = engine.contextLength;
-    if (Object.hasOwn(engine, "enableThinking"))
-        inference.enableThinking = engine.enableThinking;
-    if (Object.hasOwn(engine, "reasoningEffort"))
-        inference.reasoningEffort = engine.reasoningEffort;
-    if (Object.keys(inference).length > 0)
-        out.inference = inference;
     return Object.freeze(out);
 }
 /** Overlay user fields over installed fields, per (alias, column), without resolving `engine` indirection. */

package/dist/integrations/agent/profiles.js

@@ -8,7 +8,7 @@
  * coding-agent CLI. Named engines lower canonical harness metadata into this
  * intentionally small internal shape. The wrapper is in `./spawn.ts`.
  */
-import { COMMON_SPAWN_ENV_PASSTHROUGH } from "../../core/spawn-env.js";
+import { COMMON_SPAWN_ENV_PASSTHROUGH, XDG_BASE_DIR_ENV_PASSTHROUGH } from "../../core/spawn-env.js";
 // AKM_EVENT_SOURCE carries usage-event provenance (improve/task) so that akm
 // invocations a spawned agent makes are recorded as machine traffic, not user
 // demand (DRIFT-6). Without it in the passthrough whitelist, buildChildEnv drops
@@ -30,7 +30,7 @@ const BUILTINS = {
         bin: "opencode",
         args: ["run"],
         stdio: "interactive",
-        envPassthrough: [...COMMON_PASSTHROUGH, "OPENCODE_API_KEY", "OPENCODE_CONFIG"],
+        envPassthrough: [...COMMON_PASSTHROUGH, "OPENCODE_API_KEY", "OPENCODE_CONFIG", ...XDG_BASE_DIR_ENV_PASSTHROUGH],
         parseOutput: "text",
     },
     claude: {

package/dist/integrations/agent/prompts.js

@@ -341,7 +341,8 @@ export function buildReflectPrompt(input) {
         // Embed concrete counts only when the gate will actually fire (source >= 200 chars).
         const showCharBounds = sourceBodyLen >= 200;
         const minChars = Math.max(Math.round(0.5 * sourceBodyLen), 150);
-        const maxChars = Math.min(Math.max(Math.round(2.5 * sourceBodyLen), 2500), 25000);
+        // A source already past the 25000 cap may not grow, and need not shrink to the cap.
+        const maxChars = Math.max(Math.min(Math.max(Math.round(2.5 * sourceBodyLen), 2500), 25000), sourceBodyLen);
         sections.push([
             "## Content preservation rules (MUST follow)",
             "1. PRESERVE ALL concrete content: code blocks, fenced snippets, CLI commands, numbered/bulleted checklists, tables, YAML/JSON examples, file paths, configuration keys, environment variable names, and CSS/HTML selectors. These are load-bearing — do NOT replace them with prose summaries.",
@@ -350,7 +351,7 @@ export function buildReflectPrompt(input) {
                 ? `3. DO NOT shrink the asset. Your body must be at least ${minChars} characters (source body is ${sourceBodyLen} chars; floor is 50%). If you genuinely need to remove a major section, explain why in a comment line at the top of the body (e.g. \`<!-- removed obsolete section X because ... -->\`).`
                 : "3. DO NOT shrink the asset dramatically. The improved body must be at least 50% of the source body length. If you genuinely need to remove a major section, explain why in a comment line at the top of the body (e.g. `<!-- removed obsolete section X because ... -->`).",
             showCharBounds
-                ? `4. DO NOT pad the asset with speculative material. Your body must be at most ${maxChars} characters (source body is ${sourceBodyLen} chars; ceiling is 250%). Do not add invented sections, hypothetical examples, or padding prose.`
+                ? `4. DO NOT pad the asset with speculative material. Your body must be at most ${maxChars} characters (source body is ${sourceBodyLen} chars; ceiling is ${maxChars === sourceBodyLen ? "100%" : "250%"}). Do not add invented sections, hypothetical examples, or padding prose.`
                 : "4. DO NOT pad the asset with speculative material. The improved body must be at most 250% of the source body length unless the feedback explicitly requests added sections.",
             "5. Improve clarity of surrounding prose, fix structural issues, add missing required frontmatter fields. Do NOT rewrite a runbook into an essay.",
         ].join("\n"));
@@ -388,43 +389,6 @@ export function buildProposePrompt(input) {
     sections.push(RESPONSE_CONTRACT_JSON);
     return sections.join("\n\n");
 }
-/**
- * Build the prompt for the schema repair pass in `akm improve`. Asks the
- * agent to add the minimal required frontmatter to an asset that failed
- * validation — without rewriting the body.
- */
-export function buildSchemaRepairPrompt(input) {
-    const sections = [];
-    sections.push(`This ${input.type} asset failed schema validation with the error: "${input.reason}". ` +
-        `Your task is to fix the schema issue by adding or correcting the missing/invalid field(s) ` +
-        `while preserving all existing content.`);
-    sections.push(`Target ref: ${input.ref}`);
-    sections.push(`Schema requirements for ${input.type} assets: ${hintForType(input.type)}`);
-    if (input.standardsContext?.trim()) {
-        sections.push("Standards to follow (the rulebook for this target):");
-        sections.push(input.standardsContext.trim());
-    }
-    {
-        const authoringRules = authoringRulesForType(input.type);
-        if (authoringRules) {
-            sections.push(authoringRules);
-        }
-    }
-    const CONTENT_CAP = 3000;
-    const body = input.assetContent.trimEnd();
-    const truncated = body.length > CONTENT_CAP;
-    sections.push("Current asset content (first 3000 chars — sufficient to generate missing frontmatter):");
-    sections.push("```");
-    sections.push(truncated ? `${body.slice(0, CONTENT_CAP)}\n... [truncated]` : body);
-    sections.push("```");
-    sections.push("Produce the minimal fix: add ONLY the missing required frontmatter field(s). " +
-        "Do not rewrite the body unless it is empty. " +
-        "If `description` is missing, generate a concise one-sentence description from the content. " +
-        "If `when_to_use` is missing, generate a one-line trigger sentence. " +
-        "Preserve all existing frontmatter keys and the full body verbatim.");
-    sections.push(RESPONSE_CONTRACT_JSON);
-    return sections.join("\n\n");
-}
 /**
  * Parse agent stdout into a proposal payload. The agent contract requires a
  * single JSON object; anything else is reported as a parse error so callers

package/dist/integrations/agent/request-lowering.js

@@ -3,7 +3,8 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { ConfigError } from "../../core/errors.js";
 import { withSchemaInstruction } from "../../core/structured.js";
-import { isModelWorkTools } from "../../execution/source.js";
+import { MODEL_WORK_POLICY_ID } from "../../execution/source.js";
+import { HARNESS_MODEL_WORK_IDS } from "../harnesses/ids.js";
 import { composeConversationFallbackPrompt } from "./conversation-fallback.js";
 import { composePersonaFallbackPrompt } from "./persona-fallback.js";
 /** A tool selection that actually names tools (not omitted, null, or empty). */
@@ -47,8 +48,9 @@ export function extensionFields(request) {
  * composing into the prompt what the harness has no channel for.
  */
 export function createAgentRequestLowerer(options) {
-    return (profile, request) => {
-        const supportedInference = new Set(typeof options.inference === "function" ? options.inference(profile, request) : (options.inference ?? []));
+    const supportedInference = new Set(options.inference ?? []);
+    return (_profile, request) => {
+        const modelWork = request.authorization.policy?.id === MODEL_WORK_POLICY_ID;
         const notices = [];
         const skip = (field) => {
             notices.push(untranslated(options.adapter, field));
@@ -92,19 +94,19 @@ export function createAgentRequestLowerer(options) {
         if (Object.hasOwn(request, "inference")) {
             dispatch.inference = request.inference ?? null;
             for (const key of Object.keys(request.inference ?? {}).sort()) {
-                if (!supportedInference.has(key))
+                if (!(modelWork && supportedInference.has(key)))
                     skip(`inference.${key}`);
             }
         }
-        if (isModelWorkTools(request.tools)) {
-            if (!options.modelWorkTools) {
+        if (modelWork) {
+            if (!HARNESS_MODEL_WORK_IDS.has(options.adapter)) {
                 throw new ConfigError(`The ${options.adapter} transport cannot enforce the model-work tool policy.`, "INVALID_CONFIG_FILE");
             }
             // The builder selects its own confined agent or flags; another agent would replace them.
             if (dispatch.agent) {
                 throw new ConfigError(`The ${options.adapter} transport cannot run native agent ${JSON.stringify(dispatch.agent)} under the model-work tool policy.`, "INVALID_CONFIG_FILE");
             }
-            dispatch.tools = request.tools;
+            dispatch.modelWork = true;
         }
         else if (request.tools !== undefined) {
             // An explicit empty selection still reaches the builder (e.g. an empty allowlist).

package/dist/integrations/agent/runner-dispatch.js

@@ -12,13 +12,14 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { assertNever } from "../../core/assert.js";
-import { ConfigError, UsageError } from "../../core/errors.js";
+import { UsageError } from "../../core/errors.js";
 import { collectSensitiveValues, isEnvPassthroughValueSafeToExpose, redactSensitiveText, redactSensitiveValue, } from "../../core/redaction.js";
-import { isModelWorkTools } from "../../execution/source.js";
+import { MODEL_WORK_POLICY_ID } from "../../execution/source.js";
 import { chatCompletion, LlmCallError } from "../../llm/client.js";
 import { emitLlmUsage } from "../../llm/usage-telemetry.js";
 import { getHarness } from "../harnesses/index.js";
 import { closeServer as disposeOpencodeSdkServers, runOpencodeSdk } from "../harnesses/opencode-sdk/sdk-runner.js";
+import { modelFromArgs } from "./builder-shared.js";
 import { lookupApiKeyFileValue, lookupApiKeySecretRefValue, lookupCredentialFromEnv, resolveEngine, } from "./engine-resolution.js";
 import { materializeLlmRunnerConnection, materializeSdkFallbackConnection } from "./runner.js";
 import { runAgent } from "./spawn.js";
@@ -86,18 +87,28 @@ const USAGE_ERROR_CODES = {
     parse_error: "parse_error",
     llm_rate_limit: "rate_limited",
 };
+/**
+ * The model an agent or SDK dispatch ran: the request's, else the one an agent
+ * CLI's own `args` select, which its command carries when the request names
+ * none. An SDK server never sees `args`, so an SDK engine with no model named
+ * has none to report: opencode picks it.
+ */
+function dispatchedModel({ request, runner }) {
+    return request.model?.resolved ?? (runner.kind === "agent" ? modelFromArgs(runner.profile.args) : undefined);
+}
 /**
  * One usage record for an agent or SDK dispatch, through the same sink and
  * ambient `withLlmStage` attribution as the LLM transport's per-HTTP-attempt
- * records: the request's model, and tokens when the runner reported them.
+ * records: the model it ran, and tokens when the runner reported them.
  */
 function recordDispatchUsage(execution, result) {
     const { inputTokens, outputTokens, reasoningTokens } = result.usage ?? {};
     const reported = [inputTokens, outputTokens, reasoningTokens].filter((count) => count !== undefined);
+    const model = dispatchedModel(execution);
     emitLlmUsage({
         outcome: result.ok ? "success" : "error",
         modelSource: "configured",
-        ...(execution.request.model?.resolved ? { model: execution.request.model.resolved } : {}),
+        ...(model ? { model } : {}),
         durationMs: result.durationMs,
         ...(inputTokens !== undefined ? { promptTokens: inputTokens } : {}),
         ...(outputTokens !== undefined ? { completionTokens: outputTokens } : {}),
@@ -135,30 +146,13 @@ async function dispatchRunner(runner, prompt, opts, seams, llm) {
     }
     return redactResult(result, collectSensitiveValues(secrets));
 }
-/** The git repository a directory is inside, if any: a `.git` file, or a `.git` directory with a HEAD. */
-function enclosingGitRepository(dir) {
-    for (let current = fs.realpathSync(dir);; current = path.dirname(current)) {
-        const marker = path.join(current, ".git");
-        if (fs.existsSync(path.join(marker, "HEAD")) || (fs.existsSync(marker) && fs.statSync(marker).isFile())) {
-            return current;
-        }
-        if (path.dirname(current) === current)
-            return undefined;
-    }
-}
 /**
  * The scratch working directory for one model-work dispatch on an agent or SDK
  * engine, so the edit the model-work tool policy grants never reaches the
- * stash. opencode counts a whole git repository as inside its working
- * directory, so a scratch directory inside one is refused.
+ * stash.
  */
 function createModelWorkDirectory() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-model-work-"));
-    const repository = enclosingGitRepository(dir);
-    if (repository === undefined)
-        return dir;
-    fs.rmSync(dir, { recursive: true, force: true });
-    throw new ConfigError(`Model work runs an agent in a scratch directory outside any git repository, but ${dir} is inside the repository at ${repository}.`, "INVALID_CONFIG_FILE", "Point TMPDIR at a directory outside any git repository.");
+    return fs.mkdtempSync(path.join(os.tmpdir(), "akm-model-work-"));
 }
 /**
  * Run a built execution. Credentials are read here, once per call, and never
@@ -168,7 +162,7 @@ function createModelWorkDirectory() {
  * limit, for one) has failed with `parse_error`.
  */
 export async function runExecution(execution, options = {}) {
-    const scratch = execution.runner.kind !== "llm" && isModelWorkTools(execution.request.tools)
+    const scratch = execution.runner.kind !== "llm" && execution.request.authorization.policy?.id === MODEL_WORK_POLICY_ID
         ? createModelWorkDirectory()
         : undefined;
     try {
@@ -179,14 +173,14 @@ export async function runExecution(execution, options = {}) {
             fs.rmSync(scratch, { recursive: true, force: true });
     }
 }
-/**
- * A model-work reply's answer: the harness's result extractor strips its
- * framing (claude's `--output-format json` result envelope, for one), as a
- * workflow unit's does, and no answer is a `parse_error`.
- */
-function modelWorkAnswer(runner, result) {
+/** A successful reply's text, unwrapped from its harness's framing (claude's `--output-format json` result envelope, for one). */
+export function unwrapHarnessReply(runner, result) {
     const extractor = runner.kind === "agent" ? getHarness(runner.profile.platform ?? runner.profile.name)?.resultExtractor : undefined;
-    const extracted = extractor ? extractor(result) : { text: result.stdout };
+    return extractor ? extractor(result) : { text: result.stdout };
+}
+/** A model-work reply's answer: its harness's framing stripped, and no answer is a `parse_error`. */
+function modelWorkAnswer(runner, result) {
+    const extracted = unwrapHarnessReply(runner, result);
     const answer = {
         ...result,
         stdout: extracted.text,

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

@@ -56,8 +56,7 @@
  *   session model (plan §"Session, MCP, and identity across harnesses" —
  *   Aider is the plan's named example).
  * - **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: `aiderBuilder` is `AiderHarness.agentBuilder` (`./index.ts`),
  * one of the ten harnesses `HARNESS_REGISTRY` constructs

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

@@ -51,8 +51,7 @@
  *   — Q then refuses untrusted tool actions in non-interactive mode, which is
  *   the conservative failure mode.
  * - **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: `amazonqBuilder` is `AmazonqHarness.agentBuilder`
  * (`./index.ts`), one of the ten harnesses `HARNESS_REGISTRY` constructs

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

@@ -28,7 +28,6 @@
  *
  * The builder's `platform` stays `'claude'` (the canonical harness id).
  */
-import { isModelWorkTools } from "../../../execution/source.js";
 import { modelFromArgs, normalizeTools, resolveDispatchModel, } from "../../agent/builder-shared.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
 /** The model-work tool policy on Claude Code: read, edit in the working directory, `akm search`, `akm show`. */
@@ -45,17 +44,11 @@ export const MODEL_WORK_CLAUDE_FLAGS = Object.freeze([
 /**
  * Claude Code builder.
  * Command shape:
- *   claude [--agent <name>] [--system-prompt "..."] [--model <m>] [--effort <level>]
- *          [--allowedTools <t>] [--output-format json] --print -- "<prompt>"
+ *   claude [--agent <name>] [--system-prompt "..."] [--model <m>] [--allowedTools <t>]
+ *          [--output-format json] --print -- "<prompt>"
  *
  * --print switches Claude Code to non-interactive captured output mode.
  *
- * `--effort` carries the request's `reasoningEffort` as the harness's own
- * level (`low`, `medium`, `high`, `xhigh` or `max` in 2.1.283), passed through
- * as given: a value Claude Code rejects fails the dispatch. It is the only
- * inference field Claude Code takes on its command line, so the others are
- * reported as untranslated.
- *
  * The model-work tool policy lowers to {@link MODEL_WORK_CLAUDE_FLAGS} in place
  * of the engine's `args` and `--allowedTools`, verified against Claude Code
  * 2.1.283 and a local stub:
@@ -78,11 +71,9 @@ export const claudeBuilder = {
         personaChannel: "native",
         nativeAgentSelector: true,
         tools: "all",
-        modelWorkTools: true,
-        inference: ["reasoningEffort"],
     }),
     build(profile, req) {
-        const modelWork = isModelWorkTools(req.tools);
+        const modelWork = req.modelWork === true;
         const args = modelWork ? [...MODEL_WORK_CLAUDE_FLAGS] : [...profile.args];
         if (req.agent) {
             args.push("--agent", req.agent);
@@ -99,10 +90,7 @@ export const claudeBuilder = {
             if (model)
                 args.push("--model", model);
         }
-        const effort = req.inference?.reasoningEffort;
-        if (typeof effort === "string" && effort.length > 0)
-            args.push("--effort", effort);
-        if (req.tools && !modelWork) {
+        if (req.tools) {
             args.push("--allowedTools", normalizeTools(req.tools));
         }
         if (req.schema) {

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

@@ -43,8 +43,7 @@
  *     field yet); {@link codexResumeArgs} exposes the argv prefix for the
  *     integration task that wires session-id reuse from `workflow_run_units`.
  *   - The request's inference is not translated: the shared lowering reports
- *     each field as untranslated (`inference` in `harnesses/ids.ts` lists none
- *     for codex). codex would take `reasoningEffort` as
+ *     each field as untranslated. codex would take `reasoningEffort` as
  *     `-c model_reasoning_effort=<v>`, which is left to the integration task.
  *
  * Registered: `codexBuilder` is `CodexHarness.agentBuilder` (`./index.ts`),