akm-cli 0.9.24 → 0.9.25-alpha.1

package/dist/commands/improve/stage.js

@@ -3,14 +3,16 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { getImproveProcessConfig } from "../../core/config/config.js";
 import { ConfigError } from "../../core/errors.js";
+import { validateJsonSchemaSubset } from "../../core/json-schema.js";
 import { parseEmbeddedJsonResponse } from "../../core/parse.js";
+import { runStructured } from "../../core/structured.js";
 import { warn } from "../../core/warn.js";
-import { LlmCallError } from "../../llm/client.js";
-import { callStructured } from "../../llm/structured-call.js";
+import { runnerLlmConnection } from "../../integrations/agent/runner.js";
+import { callStructured, dispatchFailureReason, dispatchFailureResult, } from "../../llm/structured-call.js";
 import { currentLlmStage, withLlmStage } from "../../llm/usage-telemetry.js";
 import { isProceduralRejection } from "../proposal/proposal-types.js";
 import { createProposal, listProposalsReadOnly, proposalContentHash, recordGateDecision, } from "../proposal/repository.js";
-import { resolveImproveLlmExecution } from "./execution.js";
+import { resolveImproveExecution } from "./execution.js";
 /** Normalize an unknown thrown value to a message. */
 export function errMessage(e) {
     return e instanceof Error ? e.message : String(e);
@@ -27,13 +29,13 @@ export function noticeSet(forward) {
     return { add, list, fields: () => (byKey.size > 0 ? { notices: list() } : {}) };
 }
 /**
- * A stage's LLM runner: the one the improve plan froze for it (an own
+ * A stage's runner: the one the improve plan froze for it (an own
  * `llmRunner` key, `null` meaning "none"), else the process engine cascade.
  */
 export function stageRunner(frozen, config, profile, processName, onNotices) {
     if (Object.hasOwn(frozen, "llmRunner"))
         return frozen.llmRunner ?? undefined;
-    const resolved = resolveImproveLlmExecution({
+    const resolved = resolveImproveExecution({
         config,
         profile,
         process: getImproveProcessConfig(processName, profile),
@@ -43,11 +45,59 @@ export function stageRunner(frozen, config, profile, processName, onNotices) {
         onNotices?.(resolved.notices);
     return resolved?.runner;
 }
+const TRANSPORT_FAILED = Symbol("stage-transport-failed");
 /**
- * One model call. Provider trouble (transport error, timeout, a disabled
- * feature) comes back as `{ ok: false }`; only a configuration failure throws.
+ * One model call. Provider trouble (transport error, timeout, abort, a
+ * disabled feature) comes back as `{ ok: false }`; only a configuration
+ * failure throws. A reply to a call with `request.responseSchema` that fails
+ * the schema gets one corrective retry. The caller's own parse still decides
+ * what it accepts, so the last reply comes back even when it fails the schema.
  */
 export async function callStage(call) {
+    const schema = call.request?.responseSchema;
+    if (!schema)
+        return callStageOnce(call);
+    let reply = undefined;
+    let failure = undefined;
+    try {
+        await runStructured({
+            dispatch: async (feedback) => {
+                const outcome = await callStageOnce(feedback ? { ...call, prompt: `${call.prompt}\n\n${feedback}` } : call);
+                if (!outcome.ok) {
+                    failure = outcome;
+                    throw TRANSPORT_FAILED;
+                }
+                reply = outcome;
+                return outcome.raw;
+            },
+            validate: (candidate) => {
+                const errors = validateJsonSchemaSubset(candidate, schema);
+                return errors.length === 0 ? { ok: true, value: candidate } : { ok: false, errors };
+            },
+        });
+    }
+    catch (err) {
+        if (err !== TRANSPORT_FAILED)
+            throw err;
+    }
+    // A retry that fails in transport keeps the first reply, which the caller may still accept.
+    return reply ?? failure ?? { ok: false, reason: "error" };
+}
+/** Timeout and abort come from the dispatch's own reason, whatever the runner's kind. */
+function failureReason(err) {
+    const reason = dispatchFailureReason(err);
+    return reason === "timeout" || reason === "aborted" ? reason : "error";
+}
+/** A failed call: its reason and message, and the dispatch's own result when it reached a transport. */
+function failedCall(err) {
+    const result = dispatchFailureResult(err);
+    return { ok: false, reason: failureReason(err), error: errMessage(err), ...(result ? { result } : {}) };
+}
+/**
+ * One dispatch with no validation, for a caller that parses and repairs the
+ * reply itself (reflect's repair turn, extract's own structured loop).
+ */
+export async function callStageOnce(call) {
     const messages = [
         ...(call.system ? [{ role: "system", content: call.system }] : []),
         ...(call.history ?? []),
@@ -63,10 +113,11 @@ export async function callStage(call) {
             runner: call.runner,
             messages,
             ...(call.request ? { request: call.request } : {}),
+            ...(call.current ? { current: call.current } : {}),
             ...(call.onNotices ? { onNotices: call.onNotices } : {}),
             parse: (r) => r ?? "",
             onError: (_cls, err) => {
-                failure = { ok: false, reason: "error", error: errMessage(err) };
+                failure = failedCall(err);
                 return undefined;
             },
             fallback: undefined,
@@ -85,8 +136,7 @@ export async function callStage(call) {
     catch (err) {
         if (err instanceof ConfigError)
             throw err;
-        const timedOut = err instanceof LlmCallError && err.code === "timeout";
-        return { ok: false, reason: timedOut ? "timeout" : "error", error: errMessage(err) };
+        return failedCall(err);
     }
 }
 /** Attribute a stage's LLM calls to its process and planned engine (the usage report). */
@@ -162,9 +212,10 @@ export function stageJudgedProposal(stash, proposal, judged, proposalsCtx) {
  * The judge a quality gate names for itself (#1011): the gate's `engine`,
  * `model`, `timeoutMs` and `llm` over the process's own settings, as
  * `processes.triage.judgment` resolves over triage. `undefined` when the gate
- * is off or sets none of them, so the caller keeps its own judge. Throws when
- * they resolve to no LLM engine, before anything is generated: a judge must be
- * one, and the gate never falls back to another.
+ * is off or sets none of them, so the caller keeps its own judge. The engine
+ * may be of any kind; config validation has required one that confines the
+ * model-work tool policy. Throws when they resolve to no engine at all,
+ * before anything is generated: the gate never falls back to another judge.
  */
 export function resolveQualityGateJudge(config, profile, processName, onNotices) {
     const process = profile?.processes?.[processName];
@@ -173,7 +224,7 @@ export function resolveQualityGateJudge(config, profile, processName, onNotices)
         return undefined;
     if (!["engine", "model", "timeoutMs", "llm"].some((key) => Object.hasOwn(gate, key)))
         return undefined;
-    const resolved = resolveImproveLlmExecution({
+    const resolved = resolveImproveExecution({
         config,
         processName: `${processName}-quality-judge`,
         ...(profile ? { profile } : {}),
@@ -181,7 +232,7 @@ export function resolveQualityGateJudge(config, profile, processName, onNotices)
         current: gate,
     });
     if (!resolved) {
-        throw new ConfigError(`The ${processName} quality gate's judge must be an LLM engine. Set processes.${processName}.qualityGate.engine to one.`, "INVALID_CONFIG_FILE");
+        throw new ConfigError(`The ${processName} quality gate's judge has no engine. Set processes.${processName}.qualityGate.engine.`, "INVALID_CONFIG_FILE");
     }
     onNotices?.(resolved.notices);
     return resolved.runner;
@@ -349,13 +400,13 @@ function judgeResponseSchema(keys) {
  */
 async function runQualityJudge(feature, config, prompt, keys, chat, options) {
     const resolved = !options.runnerSelectionFrozen && !options.llmRunner
-        ? resolveImproveLlmExecution({ config, processName: `${feature}-judge` })
+        ? resolveImproveExecution({ config, processName: `${feature}-judge` })
         : null;
     if (resolved)
         options.onNotices?.(resolved.notices);
     const runner = options.llmRunner ?? resolved?.runner;
     if (!runner)
-        return { pass: false, score: -1, reason: "no LLM configured — cannot judge, failing closed" };
+        return { pass: false, score: -1, reason: "no engine configured — cannot judge, failing closed" };
     const outcome = await callStage({
         feature,
         runner,
@@ -363,7 +414,7 @@ async function runQualityJudge(feature, config, prompt, keys, chat, options) {
         prompt,
         request: {
             // Off unless the judge's own engine enables thinking (a slower, separate judge engine, #1011).
-            enableThinking: runner.connection.enableThinking === true,
+            enableThinking: runnerLlmConnection(runner)?.enableThinking === true,
             temperature: 0,
             responseSchema: judgeResponseSchema(keys),
             ...(Object.hasOwn(options, "timeoutMs") ? { timeoutMs: options.timeoutMs } : {}),

package/dist/commands/proposal/drain.js

@@ -25,6 +25,8 @@ import { ConfigError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { escapeJsonStringControls, stripCodeFences, stripThinkBlocks } from "../../core/parse.js";
 import { info, warn } from "../../core/warn.js";
+import { MODEL_WORK_TOOLS } from "../../execution/source.js";
+import { DEFAULT_MODEL_WORK_TIMEOUT_MS } from "../../integrations/agent/config.js";
 import { buildExecution, resolveExecution } from "../../integrations/agent/execution.js";
 import { assertRunnerCredentials, runExecution, } from "../../integrations/agent/runner-dispatch.js";
 import { errMessage, noticeSet } from "../improve/stage.js";
@@ -170,7 +172,16 @@ export function parseJudgmentVerdict(raw) {
 async function dispatchJudgment(runner, prompt, seams) {
     let notices = [];
     try {
-        const prepared = resolveExecution({ content: prompt, runner });
+        // Model work is bounded on every runner kind: one with no timeout of its own gets the default.
+        // The judgment runs under the model-work tool policy.
+        const prepared = resolveExecution({
+            content: prompt,
+            runner,
+            current: {
+                ...(Object.hasOwn(runner, "timeoutMs") ? {} : { timeout: DEFAULT_MODEL_WORK_TIMEOUT_MS }),
+                tools: MODEL_WORK_TOOLS,
+            },
+        });
         const lowered = buildExecution(prepared.request, prepared.runner);
         notices = lowered.notices;
         const chat = seams.chat;
@@ -330,10 +341,11 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
         }
     }
     if (opts.judgment && result.deferred.length > 0) {
-        // Symbolic credentials are checked before any gate, reject or promote.
+        // Symbolic credentials, and the runner's model-work tool policy, are checked before any gate, reject or promote.
         const prepared = resolveExecution({
             content: "Validate the selected proposal judgment runner before mutation.",
             runner: opts.judgment,
+            current: { tools: MODEL_WORK_TOOLS },
         });
         assertRunnerCredentials(buildExecution(prepared.request, prepared.runner).runner);
     }

package/dist/commands/proposal/proposal-cli.js

@@ -18,7 +18,7 @@ import { parsePositiveIntFlag } from "../../cli/parse-args.js";
 import { defineGroupCommand, defineJsonCommand, output } from "../../cli/shared.js";
 import { resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
-import { ConfigError, UsageError } from "../../core/errors.js";
+import { UsageError } from "../../core/errors.js";
 import { installLlmUsagePersistenceIfAbsent } from "../../llm/usage-persist.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
 import { resolveImproveExecution } from "../improve/execution.js";
@@ -470,10 +470,6 @@ const proposalDrainCommand = defineJsonCommand({
             })
             : null;
         const judgment = judgmentResolution?.runner ?? null;
-        const effectiveJudgmentLlm = triageConfig?.judgment?.llm ?? triageConfig?.llm ?? selectedStrategy.config.llm;
-        if (judgment && judgment.kind !== "llm" && effectiveJudgmentLlm) {
-            throw new ConfigError(`Triage judgment engine "${judgment.engine ?? "unknown"}" is an agent engine and cannot receive llm overrides.`, "INVALID_CONFIG_FILE");
-        }
         // #576: persist + attribute per-call LLM usage for the standalone drain
         // path. `IfAbsent` keeps an enclosing `akm improve` sink in charge when
         // drain runs as a sub-step; the disposer clears only a sink we installed.

package/dist/commands/proposal/propose-cli.js

@@ -26,7 +26,7 @@ const EXIT_GENERAL = EXIT_CODES.GENERAL;
 export const proposeCommand = defineCommand({
     meta: {
         name: "new",
-        description: "Ask the configured agent CLI to author a brand-new asset and queue it as a proposal",
+        description: "Ask the configured engine to author a brand-new asset as JSON and queue it as a proposal",
     },
     // Raw defineCommand: declare the global output flags so their space-separated
     // values are consumed rather than shifting the `type` / `name` positionals.
@@ -48,7 +48,7 @@ export const proposeCommand = defineCommand({
         task: { type: "string", description: "Task description for the agent (what should the asset do?)" },
         file: { type: "string", description: "Read the task or prompt text from a UTF-8 file" },
         engine: { type: "string", description: "Engine to use (defaults to defaults.engine)" },
-        "timeout-ms": { type: "string", description: "Override the agent CLI timeout in milliseconds" },
+        "timeout-ms": { type: "string", description: "Override the engine timeout in milliseconds" },
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {

package/dist/commands/proposal/propose.js

@@ -2,17 +2,17 @@
 // 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/.
 /**
- * `akm propose <type> <name> --task ...` — proposal-producing agent
- * command (#226).
+ * `akm proposal new <type> <name> --task ...` — proposal-producing command
+ * (#226).
  *
- * Mirrors {@link akmReflect} but for fresh authoring. The agent receives a
- * task description plus per-asset-type schema hints and is asked to author
- * a brand-new asset payload. The output lands ONLY in the proposal queue.
+ * Mirrors {@link akmReflect} but for fresh authoring. The engine, of any kind,
+ * receives a task description plus per-asset-type schema hints and returns a
+ * brand-new asset payload as JSON on stdout. The output lands ONLY in the
+ * proposal queue.
  *
  * Failures use the same {@link AgentFailureReason} discriminants as
  * `akm reflect`. `propose_invoked` is emitted at command entry.
  */
-import fs from "node:fs";
 import { placementTypes, stashDirFor } from "../../core/asset/asset-placement.js";
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
 import { resolveStashDir } from "../../core/common.js";
@@ -21,12 +21,14 @@ import { UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { redactSensitiveText } from "../../core/redaction.js";
 import { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
+import { runStructured } from "../../core/structured.js";
 import { warn } from "../../core/warn.js";
 import { deriveEntryProvenance } from "../../indexer/installations.js";
 import { fallbackAnnouncement } from "../../integrations/agent/engine-fallback.js";
 import { buildExecution, resolveExecution } from "../../integrations/agent/execution.js";
-import { buildProposePrompt, parseAgentProposalPayload } from "../../integrations/agent/prompts.js";
+import { buildProposePrompt, PROPOSAL_JSON_SCHEMA, validateProposalPayload, } from "../../integrations/agent/prompts.js";
 import { assertRunnerCredentials, collectDispatchSensitiveValues, runExecution, } from "../../integrations/agent/runner-dispatch.js";
+import { getHarness } from "../../integrations/harnesses/index.js";
 import { baseFailureFields, enoentHintMessage, isEnoentFailure } from "../agent/agent-support.js";
 import { createProposal, resolveProposalQueueTarget, } from "./repository.js";
 function failureEnvelope(result, type, name, engine, notices, fallbackReason = "non_zero_exit") {
@@ -42,42 +44,71 @@ function failureEnvelope(result, type, name, engine, notices, fallbackReason = "
 function noticeFields(notices) {
     return notices.length > 0 ? { notices } : {};
 }
-/** Resolve, lower, and dispatch the already-rendered proposal prompt. */
+const DISPATCH_FAILED = Symbol("proposal-dispatch-failed");
+/** A reply's text, unwrapped from its harness's framing (claude's `--output-format json` envelope). */
+function replyText(execution, result) {
+    const runner = execution.runner;
+    if (runner.kind !== "agent")
+        return result.stdout;
+    const extractor = getHarness(runner.profile.platform ?? runner.profile.name)?.resultExtractor;
+    return extractor ? extractor(result).text : result.stdout;
+}
+/**
+ * Resolve, lower, and dispatch the already-rendered proposal prompt with the
+ * proposal's JSON Schema as its output schema, and capture the reply. A reply
+ * that is not a proposal gets one corrective retry.
+ */
 async function dispatchProposalPrompt(prompt, config, options, onDispatchReady) {
     const current = {
         ...(options.engine !== undefined ? { engine: options.engine } : {}),
         ...(options.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+        outputSchema: PROPOSAL_JSON_SCHEMA,
     };
-    const prepared = resolveExecution({
-        content: prompt,
-        config,
-        ...(Object.keys(current).length > 0 ? { current } : {}),
-    });
+    const lower = (content) => {
+        const prepared = resolveExecution({ content, config, current });
+        return { prepared, lowered: buildExecution(prepared.request, prepared.runner) };
+    };
+    const { prepared, lowered } = lower(prompt);
     const engineName = prepared.request.engine.name;
     const announcement = fallbackAnnouncement(prepared.fallbackEngineName, engineName);
     if (announcement)
         warn(announcement);
-    const lowered = buildExecution(prepared.request, prepared.runner);
-    const interactive = !options.runAgentOptions?.spawn;
-    const runOptions = {
-        stdio: interactive ? "interactive" : "captured",
-        parseOutput: "text",
-        ...(options.runAgentOptions ?? {}),
-    };
     // Validate every required symbolic credential before the entry event opens
     // durable state. Provider/runtime failures still occur after the event,
-    // preserving the command-attempt observability contract.
-    assertRunnerCredentials(lowered.runner, runOptions.envSource);
+    // preserving the command-attempt observability contract. The dispatch reads
+    // the same caller environment.
+    const envSource = options.runAgentOptions?.envSource;
+    assertRunnerCredentials(lowered.runner, envSource);
     onDispatchReady();
     options.onDispatchReady?.();
-    const result = await runExecution(lowered, { runOptions });
+    // runStructured dispatches at least once, so a returned or DISPATCH_FAILED exchange has a result.
+    const results = [];
+    let reply;
+    try {
+        reply = await runStructured({
+            dispatch: async (feedback) => {
+                const execution = feedback ? lower(`${prompt}\n\n${feedback}`).lowered : lowered;
+                const result = await runExecution(execution, { runOptions: options.runAgentOptions ?? {} });
+                results.push(result);
+                if (!result.ok)
+                    throw DISPATCH_FAILED;
+                return replyText(execution, result);
+            },
+            validate: validateProposalPayload,
+        });
+    }
+    catch (err) {
+        if (err !== DISPATCH_FAILED)
+            throw err;
+    }
     return {
-        result,
+        result: results.at(-1),
+        ...(reply ? { reply } : {}),
+        durationMs: results.reduce((total, result) => total + result.durationMs, 0),
         engineName,
         ...(lowered.runner.kind === "llm" ? {} : { engineBin: lowered.runner.profile.bin }),
         notices: lowered.notices,
-        sensitiveValues: collectDispatchSensitiveValues(lowered.runner, {}, runOptions.envSource),
-        interactive,
+        sensitiveValues: collectDispatchSensitiveValues(lowered.runner, {}, envSource),
     };
 }
 /**
@@ -128,10 +159,6 @@ export async function akmPropose(options) {
     const config = options.agentConfig ?? (await import("../../core/config/config.js")).loadConfig();
     const target = resolveProposalQueueTarget(stash, config);
     // 2. Build terminal user content.
-    // Synthesize a temp draft path so opencode can write the asset content
-    // directly using its file tools rather than returning JSON via stdout.
-    const draftFilePath = import("node:os").then((os) => import("node:path").then((path) => path.join(os.tmpdir(), `akm-propose-${options.type}-${options.name.replace(/[^a-z0-9_-]/gi, "_")}-${Date.now()}.md`)));
-    const resolvedDraftPath = await draftFilePath;
     // Standards "rulebook" for this target — wiki schema (wiki page) or stash
     // convention/meta facts (non-wiki asset); empty when neither fires.
     const standardsContext = resolveStandardsContext(`${options.type}:${options.name}`, stash);
@@ -140,14 +167,14 @@ export async function akmPropose(options) {
         name: options.name,
         task: options.task,
         ...(standardsContext.trim() ? { standardsContext } : {}),
-        draftFilePath: resolvedDraftPath,
     });
-    // 3. Preserve the fully-authored prompt as the terminal user content;
-    // no synthetic persona, conversation turn, schema, or tool selection is
-    // introduced while it crosses the shared resolved/lowered boundary.
+    // 3. Preserve the fully-authored prompt as the terminal user content; the
+    // proposal's JSON Schema crosses the shared resolved/lowered boundary as the
+    // request's output schema, with no synthetic persona, conversation turn, or
+    // tool selection.
     const dispatch = await dispatchProposalPrompt(prompt, config, options, () => emitProposeInvoked(target.source, options));
-    const { result, engineName, notices, sensitiveValues } = dispatch;
-    if (!result.ok) {
+    const { result, reply, engineName, notices, sensitiveValues } = dispatch;
+    if (!reply) {
         // B3: ENOENT / not-found gives an actionable hint.
         if (isEnoentFailure(result)) {
             return {
@@ -157,54 +184,23 @@ export async function akmPropose(options) {
         }
         return failureEnvelope(result, options.type, options.name, engineName, notices);
     }
-    // 5. Resolve the proposal content.
-    // Path A: opencode wrote the draft file — read it directly (no stdout parse).
-    // Path B: fallback to stdout JSON parse for non-file-writing agents.
-    let payload;
-    if (fs.existsSync(resolvedDraftPath)) {
-        const draftContent = fs.readFileSync(resolvedDraftPath, "utf8");
-        fs.unlinkSync(resolvedDraftPath);
-        payload = {
-            ref: proposeItemRef(target.source, options.type, options.name),
-            content: draftContent,
+    // 5. The proposal the engine returned on stdout, validated.
+    if (!reply.ok) {
+        return {
+            schemaVersion: 2,
+            ok: false,
+            reason: "parse_error",
+            error: `Engine "${engineName}" reply was not valid proposal JSON after ${reply.attempts} attempts: ${reply.errors.join("; ")}`,
+            type: options.type,
+            name: options.name,
+            engine: engineName,
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            ...(result.stderr ? { stderr: result.stderr } : {}),
+            ...noticeFields(notices),
         };
     }
-    else {
-        // B1: When interactive mode was used and stdout is empty, the agent did not
-        // write the draft file and stdout was not captured — surface an actionable error.
-        if (dispatch.interactive && (result.stdout ?? "") === "") {
-            return {
-                schemaVersion: 2,
-                ok: false,
-                reason: "parse_error",
-                error: "Agent did not write draft file and stdout was not captured (interactive mode). Check that the agent CLI understood the file-write instruction, or configure a headless profile with stdio: 'captured'.",
-                type: options.type,
-                name: options.name,
-                engine: engineName,
-                exitCode: result.exitCode,
-                ...(result.stderr ? { stderr: result.stderr } : {}),
-                ...noticeFields(notices),
-            };
-        }
-        try {
-            payload = parseAgentProposalPayload(result.stdout ?? "");
-        }
-        catch (err) {
-            return {
-                schemaVersion: 2,
-                ok: false,
-                reason: "parse_error",
-                error: err instanceof Error ? err.message : String(err),
-                type: options.type,
-                name: options.name,
-                engine: engineName,
-                exitCode: result.exitCode,
-                stdout: result.stdout,
-                ...(result.stderr ? { stderr: result.stderr } : {}),
-                ...noticeFields(notices),
-            };
-        }
-    }
+    const payload = reply.value;
     const unsafeContent = generatedContentRejection(payload.content, redactSensitiveText(payload.content, sensitiveValues));
     if (unsafeContent) {
         return {
@@ -270,6 +266,7 @@ export async function akmPropose(options) {
             content: payload.content,
             ...(payload.frontmatter ? { frontmatter: payload.frontmatter } : {}),
         },
+        ...(payload.confidence !== undefined ? { confidence: payload.confidence } : {}),
     };
     const proposal = createProposal(stash, createInput, options.ctx);
     return {
@@ -278,7 +275,7 @@ export async function akmPropose(options) {
         proposal,
         ref: proposal.ref,
         engine: engineName,
-        durationMs: result.durationMs,
+        durationMs: dispatch.durationMs,
         ...noticeFields(notices),
     };
 }

package/dist/commands/remember.js

@@ -19,7 +19,7 @@ import { warn } from "../core/warn.js";
 import { SCOPE_KEYS } from "../indexer/passes/metadata.js";
 import { callStructured } from "../llm/structured-call.js";
 import { withLlmStage } from "../llm/usage-telemetry.js";
-import { resolveImproveLlmExecution } from "./improve/execution.js";
+import { resolveImproveExecution } from "./improve/execution.js";
 /**
  * Parse a shorthand duration string to a number of milliseconds.
  * Supports the CLI-wide canonical grammar: `30d` (days), `12h` (hours),
@@ -224,9 +224,9 @@ const LLM_ENRICH_TIMEOUT_MS = 10_000;
  */
 export async function runLlmEnrich(body) {
     const config = loadConfig();
-    const resolved = resolveImproveLlmExecution({ config, processName: "remember-enrich" });
+    const resolved = resolveImproveExecution({ config, processName: "remember-enrich" });
     if (!resolved) {
-        warn("Warning: --enrich requires an LLM to be configured. Run `akm setup` to configure one.");
+        warn("Warning: --enrich requires an engine to be configured. Run `akm setup` to configure one.");
         return { tags: [] };
     }
     const runner = resolved.runner;

package/dist/commands/sources/schema-repair.js

@@ -105,7 +105,7 @@ export async function runSchemaRepairPass(failures, options) {
     const { startMs, budgetMs, stashDir, findFilePath = defaultFindFilePath, isLessonCandidateFn = defaultIsLessonCandidate, chatFn, } = options;
     const llmRunner = options.llmRunner ?? null;
     if (!llmRunner)
-        throw new Error("runSchemaRepairPass requires a resolved LLM runner");
+        throw new Error("runSchemaRepairPass requires a resolved runner");
     if (!stashDir) {
         throw new Error("runSchemaRepairPass requires stashDir so repairs route through the proposal queue");
     }