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

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

@@ -70,10 +70,8 @@ function knownTypeList() {
 export const REFLECT_CONTENT_CAP = 12_000;
 /**
  * Marker appended to truncated asset content when it exceeds the active
- * content budget (#952). Exported so `sanitizeReflectPayload` can detect a
- * model that echoed this notice back into its rewrite instead of proposing
- * real content, and so the output contracts can reference the exact string
- * to forbid.
+ * content budget (#952). Exported so the proposal validators can refuse a body
+ * that still carries it.
  */
 export const REFLECT_TRUNCATION_MARKER = "... [truncated — focus on the visible portion]";
 /**
@@ -119,16 +117,12 @@ export function reflectResponseContract(mode, targetScoped) {
     if (mode === "json_schema") {
         return reflectLlmSchemaContract
             .replace("{{FIELD_RULE}}", targetScoped
-            ? "The response has exactly the required fields `content`, `confidence`, and `frontmatterPatch`; do not echo `ref` or arbitrary `frontmatter`."
-            : "The response has exactly the required fields `ref`, `content`, `confidence`, and `frontmatterPatch`; `ref` must identify the selected asset.")
-            .replaceAll("{{TRUNCATION_MARKER}}", REFLECT_TRUNCATION_MARKER)
+            ? "The response has exactly the required fields `confidence` and `frontmatterPatch`; do not echo `ref` or arbitrary `frontmatter`."
+            : "The response has exactly the required fields `ref`, `confidence`, and `frontmatterPatch`; `ref` must identify the selected asset.")
             .trim();
     }
     const refLine = targetScoped ? "" : "AKM_REFLECT_REF: <selected asset ref>\n";
-    return reflectLlmFramedContract
-        .replace("{{REF_LINE}}", refLine)
-        .replaceAll("{{TRUNCATION_MARKER}}", REFLECT_TRUNCATION_MARKER)
-        .trim();
+    return reflectLlmFramedContract.replace("{{REF_LINE}}", refLine).trim();
 }
 export function buildReflectOutputRepairPrompt(mode, targetScoped) {
     return reflectOutputRepair.replace("{{OUTPUT_CONTRACT}}", reflectResponseContract(mode, targetScoped)).trim();
@@ -158,23 +152,47 @@ function sourceHasNonEmptyDescription(assetContent) {
     return value.length > 0;
 }
 /**
- * Build the prompt for `akm reflect [ref]`. Asks the agent to review an
- * existing asset (plus any negative feedback / lint findings) and propose
- * an improved version. Returns a {@link ReflectPromptResult} containing the
- * prompt string and an optional character ceiling for max-tokens enforcement.
+ * The frontmatter problems akm can see for itself, named in the prompt so the
+ * model fixes them instead of having to spot them: a description split by a
+ * stray period or carrying an escaped quote, no `when_to_use`, no title. A
+ * missing description has its own instruction (#636).
+ */
+function frontmatterProblems(assetContent) {
+    const fm = assetContent?.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+    if (!assetContent || !fm)
+        return [];
+    const block = fm[1] ?? "";
+    const problems = [];
+    const raw = block
+        .match(/^description\s*:(.*(?:\r?\n[ \t]+.*)*)/m)?.[1]
+        ?.replace(/\s+/g, " ")
+        .trim() ?? "";
+    const split = [...raw.matchAll(/[\w`)\]]\. [a-z]/g)].find((m) => !/\b(?:e\.g|i\.e|vs|etc|cf)$/i.test(raw.slice(0, (m.index ?? 0) + 1)));
+    if (split) {
+        problems.push(`the \`description\` is broken: a stray period splits a sentence ("${raw}"); repair only the break, keeping its wording and every name, number, path and status word in it`);
+    }
+    else if (raw.includes('\\"')) {
+        problems.push("the `description` is broken by an escaped quote; repair only the quoting, keeping the rest of its wording");
+    }
+    if (!/^when_to_use\s*:\s*(?:\S|\r?\n[ \t]+\S)/m.test(block)) {
+        problems.push("there is no `when_to_use`: write one, a single sentence the body supports, saying when to reach for this asset");
+    }
+    if (!/^title\s*:\s*\S/m.test(block) && !/^#[ \t]+\S/m.test(assetContent.slice(fm[0].length))) {
+        problems.push("the body has no level-1 title: give one in `title`");
+    }
+    return problems;
+}
+/**
+ * Build the prompt for `akm reflect [ref]`. Asks the agent to check an
+ * existing asset's `description`, `when_to_use` and title against its body
+ * (plus any negative feedback / lint findings) and return the fields that
+ * need a fix. Returns a {@link ReflectPromptResult} containing the prompt
+ * string.
  */
 export function buildReflectPrompt(input) {
     const sections = [];
     if (input.ref && input.type && input.name) {
-        // Change 2 — type-conditioned goal framing
-        const isLesson = input.type === "lesson";
-        const isSkill = input.type === "skill";
-        const goalSentence = isLesson
-            ? `Your task is to distill what usage signals reveal about this ${input.type} asset — when to reach for it, what goes wrong without it, and what real use has revealed that the asset itself does not say. Do not reproduce the source content; your proposal must add information the source does not contain.`
-            : isSkill
-                ? "Your task is to review this skill asset, identify what the feedback and related distilled lessons show is broken, missing, unclear, or durable enough to promote into long-term documentation, and produce a single improved proposal. If the strongest evidence points to companion reference material rather than the main SKILL.md, you may instead propose a skill-adjacent knowledge doc such as `knowledge/skills/<skill>/references/<topic>`."
-                : `Your task is to review this ${input.type} asset, identify what the feedback signals as broken, missing, or unclear, and produce an improved version. Do not reproduce the source content unchanged; your proposal must correct or add something the source lacks.`;
-        sections.push(goalSentence);
+        sections.push(`Your task is to check this ${input.type} asset's \`description\`, \`when_to_use\` and title against its body and the feedback below, and fix any that is missing, broken, or claims something the body does not cover. AKM keeps the body exactly as it is: you change only these fields, and when none needs a change you return null for each.`);
         sections.push(`Target ref: ${input.ref}`);
         sections.push(`Asset-type guidance: ${hintForType(input.type)}`);
     }
@@ -200,12 +218,9 @@ export function buildReflectPrompt(input) {
         sections.push("Recent feedback / signals:");
         sections.push("- (no feedback events recorded)");
     }
-    else if (input.type === "skill" && input.relatedLessons && input.relatedLessons.length > 0) {
-        sections.push("No direct feedback events were recorded. Limit substantive changes to what is justified by the related distilled lessons below; do not speculate beyond that evidence.");
-    }
     else {
-        // ref is set but no feedback — explicitly constrain scope to schema compliance
-        sections.push("No usage feedback recorded. Limit your proposal to schema and structural improvements only: missing required frontmatter fields, unclear `when_to_use`, ambiguous description, or broken formatting. Do not speculate about runtime weaknesses you have not observed.");
+        // ref is set but no feedback — explicitly constrain scope to broken or missing fields
+        sections.push("No usage feedback recorded. Fix only a missing or broken `description`, `when_to_use` or title; otherwise return null for each.");
     }
     if (input.standardsContext?.trim()) {
         sections.push("Standards to follow (the rulebook for this target):");
@@ -253,7 +268,7 @@ export function buildReflectPrompt(input) {
         sections.push("```");
     }
     else if (input.ref) {
-        sections.push("(No existing content — propose a fresh asset that fits the ref.)");
+        sections.push("(No existing content.)");
     }
     else {
         sections.push("(No existing asset content was supplied.)");
@@ -263,23 +278,10 @@ export function buildReflectPrompt(input) {
         for (const line of input.schemaHints)
             sections.push(`- ${line}`);
     }
-    if (input.relatedLessons && input.relatedLessons.length > 0) {
-        sections.push("Related distilled lessons to evaluate for consolidation:");
-        for (const lesson of input.relatedLessons) {
-            sections.push(`Lesson ref: ${lesson.ref}`);
-            sections.push("```");
-            sections.push(lesson.content.trimEnd());
-            sections.push("```");
-        }
-        sections.push("Evaluate whether these lessons contain strong evidence of factual, repeatable guidance that should be promoted into long-term skill documentation.");
-        sections.push("Promote only guidance that is durable, generally applicable, and supported by repeated evidence. Do not copy anecdotal details, one-off incidents, or duplicate wording verbatim.");
-        sections.push("If the guidance belongs in the main skill instructions, update the skill proposal. If it belongs in a companion reference document, return a `knowledge/skills/<skill>/references/<topic>` proposal instead.");
-    }
     if (input.rejectedProposals && input.rejectedProposals.length > 0) {
         const lines = ["## Previously Rejected Proposals"];
         lines.push("The following proposals for this ref were already reviewed and rejected. " +
-            "Do NOT reproduce the same content or the same structural shape. " +
-            "Your new proposal must meaningfully differ from each of these in its approach, framing, or evidence used.");
+            "Do not propose the same change again; if no other change is justified, return null for each field.");
         for (const rp of input.rejectedProposals) {
             lines.push(`\nRef: ${rp.ref}`);
             lines.push(`Rejection reason: ${rp.reason}`);
@@ -303,57 +305,16 @@ export function buildReflectPrompt(input) {
             "The following is your previous draft proposal. " +
             "Identify specific weaknesses: missing evidence, vague wording, incomplete frontmatter, " +
             "or claims that duplicate existing content without adding new signal. " +
-            "Then produce an improved version that addresses those weaknesses. " +
-            "The revised proposal must be meaningfully better than the draft below — " +
-            "do not return the same content unchanged.\n\n" +
+            "Then produce an improved version that addresses those weaknesses.\n\n" +
             "Previous draft:\n```\n" +
             input.priorDraft.trimEnd() +
             "\n```");
     }
-    sections.push("Produce a single proposal that addresses the feedback and respects the asset-type contract. If the proposal's frontmatter is missing `when_to_use`, you MUST generate one — a one-line trigger sentence describing exactly when a user should reach for this asset.");
-    // Content-preservation safety rails (#reflect-pipeline-fixes).
-    // These rules counter the observed failure modes where reflect rewrites
-    // asset content into shorter prose, drops concrete structure, or strips
-    // load-bearing frontmatter. Loud and explicit so small models follow.
-    //
-    // Guard-audit finding 15: this used to also hand back a maxOutputChars
-    // value so an LLM-path caller could convert it into a hard `max_tokens`
-    // cap on the API request. llm/client.ts's own doc comment (and
-    // commands/improve/reflect.ts's recorded history of responses actually
-    // getting cut off) is explicit that a character-derived max_tokens causes
-    // silent truncation — a real model's output is measured in tokens, not
-    // characters, and the ratio between the two varies enough that any fixed
-    // conversion either truncates legitimate output or provides no real cap at
-    // all. The size policy below is already enforced twice more (the prompt
-    // rules the model reads, and the post-processor's own size check), so nothing
-    // is lost by not adding a THIRD, byte-derived enforcement point that can
-    // only ever cut a response off early, never usefully re-check it.
     if (input.ref && input.assetContent?.trim()) {
-        // Strip frontmatter to get source body length — mirrors checkReflectSize which
-        // compares body-only lengths. Inline regex avoids importing parseFrontmatter.
-        const rawContent = input.assetContent.trimEnd();
-        const fmBodyMatch = rawContent.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?([\s\S]*)$/);
-        const sourceBodyLen = (fmBodyMatch ? fmBodyMatch[1] : rawContent).trim().length;
-        // Compute concrete char bounds matching checkReflectSize constants:
-        //   REFLECT_SIZE_GUARD_MIN_BYTES=200, REFLECT_SHRINK_RATIO_MIN=0.5,
-        //   REFLECT_ABSOLUTE_FLOOR_BYTES=150, REFLECT_EXPAND_RATIO_MAX=2.5,
-        //   REFLECT_ABSOLUTE_CEILING_BYTES=2500, REFLECT_ABSOLUTE_MAX_BYTES=25000.
-        // 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);
-        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.",
-            "2. PRESERVE the source asset's frontmatter. The post-processor reassembles the final asset from the original frontmatter plus your body. Do NOT emit `---` frontmatter delimiters at the top of `content` — start `content` with the markdown body (e.g. `# Heading` or the first paragraph). If you include frontmatter anyway, identity fields (`name`, `ref`, `id`, `slug`, `type`) will be reset to the original values.",
-            showCharBounds
-                ? `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. 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"));
+        const problems = frontmatterProblems(input.assetContent);
+        sections.push(problems.length > 0
+            ? `akm found these problems in the asset; fix each one:\n${problems.map((p) => `- ${p}`).join("\n")}`
+            : "akm found no missing or broken field.");
     }
     sections.push(reflectResponseContract(input.outputMode ?? "json_schema", input.ref !== undefined));
     return { prompt: sections.join("\n\n") };
@@ -388,43 +349,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