akm-cli 0.9.24 → 0.9.25-alpha.2

package/dist/commands/improve/stage.js

@@ -4,13 +4,14 @@
 import { getImproveProcessConfig } from "../../core/config/config.js";
 import { ConfigError } from "../../core/errors.js";
 import { parseEmbeddedJsonResponse } from "../../core/parse.js";
+import { defaultFeedback } 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 +28,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),
@@ -44,10 +45,38 @@ export function stageRunner(frozen, config, profile, processName, onNotices) {
     return resolved?.runner;
 }
 /**
- * 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 the
+ * stage's own `parse` rejects gets one corrective retry; the last reply comes
+ * back either way, and the caller parses it again.
  */
 export async function callStage(call) {
+    const reply = await callStageOnce(call);
+    if (!reply.ok || !call.request?.responseSchema)
+        return reply;
+    if ((call.parse ?? parseEmbeddedJsonResponse)(reply.raw) !== undefined)
+        return reply;
+    const feedback = defaultFeedback({ reason: "parse_error", errors: [] });
+    const retry = await callStageOnce({ ...call, prompt: `${call.prompt}\n\n${feedback}` });
+    // A retry that fails in transport keeps the first reply, which the caller may still accept.
+    return retry.ok ? retry : reply;
+}
+/** 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 +92,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 +115,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 +191,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 +203,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 +211,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;
@@ -232,15 +262,24 @@ function buildChangedRegion(sourceContent, candidateContent) {
     const added = candidate.slice(prefix, candidate.length - suffix).join("\n");
     return boundedDocument(`Removed or replaced:\n${removed || "(none)"}\n\nAdded or replacement:\n${added || "(none)"}`);
 }
-/** Judge prompt for an in-place revision. */
-export function buildReflectJudgePrompt(candidateContent, sourceContent, feedback) {
+/**
+ * What the judge may do with tools when it runs on an agent engine: verify a
+ * fact the revision adds or alters, and nothing else. The plain judge's prompt
+ * is unchanged (its rubric is tuned and measured without this paragraph).
+ */
+function reflectJudgeToolRules(ref) {
+    const asset = ref ? `The asset is \`${ref}\`: read it with akm_show, ` : "Read an asset with akm_show ";
+    return `Tools: ${asset}or an asset the changed region names, only to verify a fact the revision adds or alters; the text above already shows every change. Do not search, do not read anything else, and do not use a tool to judge structure or wording. One or two reads at most. Before scoring, check three lists: (1) every statement the revision adds: find each in the asset, or as a fact the feedback states about the subject, and score QUALITY 1-2 if any is in neither; a statement is found only when the asset or the feedback says it, in any words: a new step, cause, consequence or detail that merely seems to follow is not found; feedback says what to fix and is not content, so an added statement about how the asset was used, found or verified is unsupported; (2) every fact, caveat and field of the source: find each in the revision, and score PRESERVATION 1-3 if any is missing; (3) every point the feedback makes: find the text it is about changed in the revision, and score NEED 2-3 if any is not; a note that restates the feedback does not address it. A read that finds nothing wrong raises no score above what these lists support. Then reply with the JSON.`;
+}
+/** Judge prompt for an in-place revision. `tools` is set when the judge runs on an agent engine. */
+export function buildReflectJudgePrompt(candidateContent, sourceContent, feedback, tools) {
     return [
         "You are evaluating a proposed revision to an existing akm asset.",
         "",
         "Score this revision on each criterion from 1 (poor) to 5 (excellent):",
-        "1. NEED: Does the revision fix a concrete problem in the source? Concrete problems are: something the feedback reports as wrong or missing; a factual error; or broken, garbled, truncated or missing text, including frontmatter fields such as description or when_to_use. Score 4-5 when it fixes one, even a small one. Score 1-2 when the source was already correct and the revision only rewords, restates, reformats, or adds headings, an introduction or a table of contents.",
-        "2. PRESERVATION: Does it keep every concrete fact, identifier, command, path, number and example from the source, without truncation?",
-        "3. QUALITY: Is it coherent and accurate, with no claims, steps or details that the source or the feedback does not support?",
+        "1. NEED: Does the revision fix a concrete problem in the source? Concrete problems are: something the feedback reports as wrong or missing; a factual error; broken, garbled, truncated or missing text; and a missing or broken title, description or when_to_use field. Compare the source's description with the revision's: a description with a sentence split in its middle by a stray period or line-wrap artifact (as in 'calls. asset writes'), an unbalanced or escaped quote, or a truncated ending is broken, and repairing it is a concrete problem fixed even when the rest of the revision only adds stamps or reformats; adding or removing a trailing period, or rewording a readable description, repairs nothing. A missing title, description or when_to_use is a concrete problem whether or not the feedback mentions it: empty or positive feedback does not mean the source was complete, and the frontmatter is complete only when it has all three. A when_to_use is missing when the frontmatter has none, even if the body has a 'when to use' section; moving or copying that text into the field is the fix. A missing type field or a provenance stamp such as generated or verified is not a concrete problem. Score 4-5 when the revision fixes one, even a small one, whatever else it also reformats. Score 1-2 when the source was already complete and correct and the revision only rewords, restates, reformats, adds a type field or a stamp, or adds headings, an introduction or a table of contents.",
+        "2. PRESERVATION: Does it keep every concrete fact, identifier, command, path, number, example, caveat and frontmatter field from the source, without truncation? Check the changed region line by line. Score 1-3 when any of them is dropped or weakened, even when the revision also fixes something. Trimming narrative that states no fact, or removing what the feedback asks to remove or rescope, is not a drop.",
+        "3. QUALITY: Is it coherent and accurate, with no claims, steps or details that the source or the feedback does not support? Check each added or changed statement against the source and the feedback: a statement that follows from either counts as supported, and frontmatter stamps such as type, generated, verified or quality, whatever their values, and a restatement of existing content are not claims. Score 1-2 when the revision adds a claim neither supports, turns a draft or proposal into a decision, strengthens a statement beyond the source (a preference into a requirement, a possibility into a fact, a pending fix into a done one), adds a hedge such as 'may be outdated', or a placeholder such as 'TODO' or 'verify'; a fix elsewhere in the revision does not raise this score.",
         "",
         "Feedback:",
         "```",
@@ -262,6 +301,7 @@ export function buildReflectJudgePrompt(candidateContent, sourceContent, feedbac
         buildChangedRegion(sourceContent, candidateContent),
         "```",
         "",
+        ...(tools ? [reflectJudgeToolRules(tools.ref), ""] : []),
         'Return ONLY valid JSON, no prose: {"scores": {"need": <1-5 integer>, "preservation": <1-5 integer>, "quality": <1-5 integer>}, "reason": "<one sentence>"}',
     ].join("\n");
 }
@@ -349,13 +389,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,13 +403,14 @@ 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 } : {}),
             ...(options.signal ? { signal: options.signal } : {}),
             ...(chat ? { chat } : {}),
         },
+        parse: (raw) => parseJudgeResponse(raw, keys),
         ...(options.onNotices ? { onNotices: options.onNotices } : {}),
     });
     if (!outcome.ok) {
@@ -411,6 +452,8 @@ export function runLessonQualityJudge(config, lessonContent, sourceContent, chat
 }
 /** Judge an in-place reflect revision without new-lesson novelty criteria. */
 export function runReflectQualityJudge(config, candidateContent, sourceContent, feedback, chat, options = {}) {
-    const prompt = buildReflectJudgePrompt(candidateContent, sourceContent, feedback);
+    // A judge on an agent engine gets the tool rules; the runner is the frozen one or none.
+    const tools = options.llmRunner && options.llmRunner.kind !== "llm" ? { ref: options.ref } : undefined;
+    const prompt = buildReflectJudgePrompt(candidateContent, sourceContent, feedback, tools);
     return runQualityJudge("proposal_quality_gate", config, prompt, REFLECT_JUDGE_CRITERIA, chat, options);
 }

package/dist/commands/proposal/drain.js

@@ -25,6 +25,7 @@ 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 { DEFAULT_LLM_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 +171,14 @@ 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_LLM_TIMEOUT_MS },
+            modelWork: true,
+        });
         const lowered = buildExecution(prepared.request, prepared.runner);
         notices = lowered.notices;
         const chat = seams.chat;
@@ -330,10 +338,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,
+            modelWork: true,
         });
         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,13 @@ 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 { assertRunnerCredentials, collectDispatchSensitiveValues, runExecution, } from "../../integrations/agent/runner-dispatch.js";
+import { buildProposePrompt, PROPOSAL_JSON_SCHEMA, validateProposalPayload, } from "../../integrations/agent/prompts.js";
+import { assertRunnerCredentials, collectDispatchSensitiveValues, runExecution, unwrapHarnessReply, } from "../../integrations/agent/runner-dispatch.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 +43,63 @@ 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");
+/**
+ * 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 unwrapHarnessReply(execution.runner, result).text;
+            },
+            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 +150,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 +158,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 +175,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 +257,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 +266,7 @@ export async function akmPropose(options) {
         proposal,
         ref: proposal.ref,
         engine: engineName,
-        durationMs: result.durationMs,
+        durationMs: dispatch.durationMs,
         ...noticeFields(notices),
     };
 }

package/dist/commands/proposal/validators/proposal-quality-validators.js

@@ -9,7 +9,8 @@
  * growing past min(max(250% of the source, 2500 bytes), 25000 bytes) suggests
  * speculation. The absolute bounds keep small assets (a p25 source is ~780
  * bytes) from tripping on one good paragraph, and 25000 (below p99) still
- * catches runaway expansion. Sources under 200 bytes are too noisy to judge.
+ * catches runaway expansion. Sources under 200 bytes are too noisy to judge. A
+ * body that does not grow is never expansion, however long its source.
  */
 import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
 import { parseRefInput } from "../../../core/asset/resolve-ref.js";
@@ -159,7 +160,8 @@ export function checkReflectSize(sourceBody, proposedBody) {
         return { ok: false, code: "EXCESSIVE_SHRINKAGE", ratio };
     }
     const expandCeiling = Math.min(Math.max(REFLECT_EXPAND_RATIO_MAX * sourceLen, REFLECT_ABSOLUTE_CEILING_BYTES), REFLECT_ABSOLUTE_MAX_BYTES);
-    if (proposedLen > expandCeiling)
+    // A body that does not grow is never expansion, even where the cap sits below the source's own length.
+    if (proposedLen > sourceLen && proposedLen > expandCeiling)
         return { ok: false, code: "EXCESSIVE_EXPANSION", ratio };
     return { ok: true };
 }