akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/commands/proposal/drain.js

@@ -30,15 +30,14 @@ import path from "node:path";
 import { assetPathForName, stashDirFor } from "../../core/asset/asset-placement.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
-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 { noticeSet } from "../../execution/notices.js";
 import { buildExecution, resolveExecution } from "../../integrations/agent/execution.js";
-import { assertRunnerCredentials, runExecution, } from "../../integrations/agent/runner-dispatch.js";
+import { callStructured } from "../../llm/structured-call.js";
 import { NEIGHBOUR_EXCERPT_CHARS, NEIGHBOUR_NOTE_COUNT, nearestKnowledgeNotes, shingleContainment, wordShingles, } from "../improve/consolidate/coverage.js";
-import { errMessage, noticeSet } from "../improve/stage.js";
+import { errMessage } from "../improve/stage.js";
 import { akmProposalAccept, akmProposalReject } from "./proposal.js";
 import { isRetireProposal, PAIR_PASS_GATE, STALE_TARGET_GATE_REASON } from "./proposal-types.js";
 import { commitCollectedAccepts, listProposals, listProposalsReadOnly, preflightProposalPromotion, proposalContent, proposalContentHash, readFreshProposalTarget, recordGateDecision, } from "./repository.js";
@@ -218,38 +217,20 @@ export function parseJudgmentVerdict(raw) {
         return null;
     return { decision, reason: typeof reason === "string" ? reason : "" };
 }
-/** Lower the judgment prompt through the frozen runner and dispatch it. */
-async function dispatchJudgment(runner, prompt, seams) {
+/** Dispatch the judgment prompt on the frozen runner: one model call, under the model-work tool policy. */
+async function dispatchJudgment(runner, prompt, seams, signal) {
     let notices = [];
-    try {
-        // 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;
-        const llmRunner = lowered.runner.kind === "llm" ? lowered.runner : undefined;
-        const result = await runExecution(lowered, {
-            ...(seams.runAgentFn ? { runAgent: seams.runAgentFn } : {}),
-            ...(seams.runSdkFn ? { runSdk: seams.runSdkFn } : {}),
-            ...(chat && llmRunner
-                ? { chat: async (connection, messages) => chat({ ...llmRunner, connection }, messages) }
-                : {}),
-        });
-        if (!result.ok)
-            return { verdict: null, notices, error: result.error ?? result.reason ?? "unknown error" };
-        return { verdict: parseJudgmentVerdict(result.stdout), notices };
-    }
-    catch (error) {
-        if (error instanceof ConfigError)
-            throw error;
-        return { verdict: null, notices, error: errMessage(error) };
-    }
+    const outcome = await callStructured({
+        runner,
+        messages: [{ role: "user", content: prompt }],
+        request: { ...(seams.chat ? { chat: seams.chat } : {}), ...(signal ? { signal } : {}) },
+        onNotices: (value) => {
+            notices = value;
+        },
+    });
+    if (!outcome.ok)
+        return { verdict: null, notices, error: outcome.error };
+    return { verdict: parseJudgmentVerdict(outcome.raw), notices };
 }
 /**
  * The judgment tier: the runner only judges; the drain performs the accept
@@ -268,6 +249,12 @@ async function runJudgmentTier(opts, result, pending, acceptBudget, promoteFn, r
             stillDeferred.push(item);
             continue;
         }
+        // Past the deadline nothing is dispatched: the item stays undecided, as an error would leave it.
+        if (opts.signal?.aborted) {
+            deferNotes.set(item.id, { reason: "judgment-error" });
+            stillDeferred.push(item);
+            continue;
+        }
         const liveAsset = readLiveAssetContent(opts.stashDir, proposal.ref);
         const prompt = buildJudgmentPrompt(proposal, item.reason, {
             liveAsset,
@@ -277,7 +264,7 @@ async function runJudgmentTier(opts, result, pending, acceptBudget, promoteFn, r
                 ? { neighbours: promotionNeighbours(opts.stashDir, proposal, acceptedPromotions) }
                 : {}),
         });
-        const dispatch = await dispatchJudgment(opts.judgment, prompt, seams);
+        const dispatch = await dispatchJudgment(opts.judgment, prompt, seams, opts.signal);
         notices.add(dispatch.notices);
         if (dispatch.error)
             warn(`[triage] judgment dispatch failed for ${item.id}: ${dispatch.error}`);
@@ -439,7 +426,7 @@ async function drainPending(opts, promoteFn, rejectFn, judgmentSeams) {
         // A consolidate pair-pass `retire` proposal is auto-accepted only when the
         // pair pass staged it: nothing unique on either side, confirmed by a
         // second look, no continuity risk; every other one waits for a direct
-        // `akm proposal accept` (spec §25.6). Checked before isEmptyDiff, which
+        // `akm proposal accept`. Checked before isEmptyDiff, which
         // has nothing meaningful to read on a delete-primary change.
         if (isRetireProposal(proposal)) {
             const staged = proposal.gateDecision;
@@ -479,13 +466,13 @@ async function drainPending(opts, promoteFn, rejectFn, judgmentSeams) {
         }
     }
     if (opts.judgment && result.deferred.some((d) => d.reason === "needs-judgment")) {
-        // Symbolic credentials, and the runner's model-work tool policy, are checked before any gate, reject or promote.
+        // Build the judgment runner's request before any gate, reject or promote: a transport that cannot run at all fails here, not after a mutation.
         const prepared = resolveExecution({
             content: "Validate the selected proposal judgment runner before mutation.",
             runner: opts.judgment,
             modelWork: true,
         });
-        assertRunnerCredentials(buildExecution(prepared.request, prepared.runner).runner);
+        buildExecution(prepared.request, prepared.runner);
     }
     for (const id of empties) {
         const failure = await rejectProposal(opts, id, "empty diff", "empty-diff", rejectFn);

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

@@ -17,7 +17,9 @@ import { parsePositiveIntFlag } from "../../cli/parse-args.js";
 import { defineGroupCommand, defineJsonCommand, EXIT_CODES, output } from "../../cli/shared.js";
 import { resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
-import { UsageError } from "../../core/errors.js";
+import { SHIPPED_ALIAS } from "../../core/config/model-aliases.js";
+import { ConfigError, UsageError } from "../../core/errors.js";
+import { mergeNotices } from "../../execution/notices.js";
 import { installLlmUsagePersistenceIfAbsent } from "../../llm/usage-persist.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
 import { resolveImproveExecution } from "../improve/execution.js";
@@ -27,14 +29,6 @@ import { drainProposals } from "./drain.js";
 import { akmProposalAccept, akmProposalAcceptMany, akmProposalDiff, akmProposalList, akmProposalReject, akmProposalReopen, akmProposalRevert, akmProposalShow, bulkAdjudicateProposals, } from "./proposal.js";
 import { proposalWaitingSince } from "./proposal-types.js";
 import { proposeCommand } from "./propose-cli.js";
-export function mergeProposalDrainNotices(resolutionNotices, dispatchNotices) {
-    const byKey = new Map();
-    for (const notice of resolutionNotices ?? [])
-        byKey.set(JSON.stringify(notice), notice);
-    for (const notice of dispatchNotices ?? [])
-        byKey.set(JSON.stringify(notice), notice);
-    return byKey.size > 0 ? Object.freeze([...byKey.values()]) : undefined;
-}
 /**
  * Parse + validate the shared bulk-adjudication filter flags
  * (`--max-diff-lines`, `--older-than`). Extracted from the two verbatim
@@ -433,10 +427,9 @@ const proposalDrainCommand = defineJsonCommand({
             }
         }
         // `--older-than` is applied here as a pre-filter on excludeIds: ids that
-        // are too fresh are excluded so the engine never touches them. This reads
+        // are too fresh are excluded so the drain never touches them. This reads
         // the pending set once here; drainProposals reads the pending set again
-        // internally, so a future engine-level olderThan option could remove this
-        // second read (engine API owned by another agent — not changed here).
+        // internally.
         let excludeIds;
         if (olderThanMs !== undefined) {
             const { listProposals } = await import("./repository.js");
@@ -456,15 +449,18 @@ const proposalDrainCommand = defineJsonCommand({
         // disabled block. An explicitly selected strategy may opt in through its
         // judgment block; the implicit default strategy keeps standalone drain's
         // historical no-judge behavior.
-        const judgmentResolution = args.judgment === true || (args.strategy !== undefined && triageConfig?.judgment?.enabled === true)
+        const judgmentWanted = args.judgment === true || (args.strategy !== undefined && triageConfig?.judgment?.enabled === true);
+        const judgmentResolution = judgmentWanted
             ? resolveImproveExecution({
                 config: cfg,
-                profile: selectedStrategy.config,
-                process: triageConfig,
-                current: triageConfig?.judgment,
+                process: "triage",
                 processName: "proposal-triage-judgment",
+                alias: SHIPPED_ALIAS.judge,
             })
             : null;
+        if (judgmentWanted && !judgmentResolution) {
+            throw new ConfigError("Proposal judgment was requested, but no connection or harness is configured to judge with.", "LLM_NOT_CONFIGURED", "Run `akm setup`, or set improve.connection or improve.processes.triage.connection.");
+        }
         const judgment = judgmentResolution?.runner ?? null;
         // #576: persist + attribute per-call LLM usage for the standalone drain
         // path. `IfAbsent` keeps an enclosing `akm improve` sink in charge when
@@ -486,14 +482,14 @@ const proposalDrainCommand = defineJsonCommand({
             disposeDrainUsageSink();
         }
         const dispatchNotices = result.notices;
-        const notices = mergeProposalDrainNotices(judgmentResolution?.notices, dispatchNotices);
+        const notices = mergeNotices(judgmentResolution?.notices, dispatchNotices);
         output("proposal-drain", {
             schemaVersion: 1,
             ok: true,
             applyMode,
             dryRun,
             strategy: selectedStrategy.name,
-            judgmentEngine: judgment?.engine ?? null,
+            judgmentEngine: judgment?.name ?? null,
             judgmentKind: judgment?.kind ?? null,
             ...(notices ? { notices } : {}),
             promoted: result.promoted,

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

@@ -18,6 +18,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { defineCommand } from "citty";
 import { getStringArg, parsePositiveIntFlag } from "../../cli/parse-args.js";
+import { RETIRED_ENGINE_ARG, SELECTION_ARGS, selectionFromArgs } from "../../cli/selection.js";
 import { EXIT_CODES, GLOBAL_OUTPUT_ARGS, output, runWithJsonErrors } from "../../cli/shared.js";
 import { assertFlatAssetName, combineCreatePath, normalizeCreateSubPath } from "../../core/asset/asset-create.js";
 import { UsageError } from "../../core/errors.js";
@@ -51,7 +52,8 @@ export const proposeCommand = defineCommand({
             type: "string",
             description: "Configured writable bundle to queue the proposal for and draw convention facts from (default: the working bundle)",
         },
-        engine: { type: "string", description: "Engine to use (defaults to defaults.engine)" },
+        ...SELECTION_ARGS,
+        ...RETIRED_ENGINE_ARG,
         "timeout-ms": { type: "string", description: "Override the engine timeout in milliseconds" },
     },
     async run({ args }) {
@@ -76,7 +78,7 @@ export const proposeCommand = defineCommand({
                 type: String(args.type),
                 name: proposedName,
                 task: taskText,
-                engine: getStringArg(args, "engine"),
+                selection: selectionFromArgs(args),
                 bundle: getStringArg(args, "bundle"),
                 ...(timeoutMs !== undefined ? { timeoutMs } : {}),
             });

package/dist/commands/proposal/propose.js

@@ -1,34 +1,21 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * `akm proposal new <type> <name> --task ...` — proposal-producing command
- * (#226).
- *
- * 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 { placementTypes, stashDirFor } from "../../core/asset/asset-placement.js";
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
 import { resolveStashDir } from "../../core/common.js";
+import { SHIPPED_ALIAS } from "../../core/config/model-aliases.js";
 import { generatedContentRejection } from "../../core/content-safety.js";
 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 { resolveWriteTarget } from "../../core/write-source.js";
 import { deriveEntryProvenance } from "../../indexer/installations.js";
-import { fallbackAnnouncement } from "../../integrations/agent/engine-fallback.js";
-import { buildExecution, resolveExecution } from "../../integrations/agent/execution.js";
+import { buildExecution, currentLayer, resolveExecution, shippedAlias } from "../../integrations/agent/execution.js";
 import { buildProposePrompt, PROPOSAL_JSON_SCHEMA, validateProposalPayload, } from "../../integrations/agent/prompts.js";
-import { assertRunnerCredentials, collectDispatchSensitiveValues, runExecution, unwrapHarnessReply, } from "../../integrations/agent/runner-dispatch.js";
+import { runExecution } from "../../integrations/agent/runner-dispatch.js";
+import { isRefused, jsonParser, structuredLoop } from "../../llm/structured.js";
+import { outcomeOf } from "../../llm/structured-call.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") {
@@ -44,7 +31,6 @@ function failureEnvelope(result, type, name, engine, notices, fallbackReason = "
 function noticeFields(notices) {
     return notices.length > 0 ? { notices } : {};
 }
-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
@@ -52,55 +38,41 @@ const DISPATCH_FAILED = Symbol("proposal-dispatch-failed");
  */
 async function dispatchProposalPrompt(prompt, config, options, onDispatchReady) {
     const current = {
-        ...(options.engine !== undefined ? { engine: options.engine } : {}),
+        ...options.selection,
         ...(options.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
         outputSchema: PROPOSAL_JSON_SCHEMA,
     };
-    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);
-    // 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. The dispatch reads
-    // the same caller environment.
-    const envSource = options.runAgentOptions?.envSource;
-    assertRunnerCredentials(lowered.runner, envSource);
+    // The target is resolved once; a corrective attempt rebuilds only the request, for the same runner.
+    const prepared = resolveExecution({
+        content: prompt,
+        config,
+        layers: [shippedAlias(SHIPPED_ALIAS.agent), currentLayer(current)],
+    });
+    const lowered = buildExecution(prepared.request, prepared.runner);
+    const corrected = (content) => buildExecution(resolveExecution({ content, runner: prepared.runner, layers: [currentLayer(current)] }).request, prepared.runner);
+    // Resolution and lowering come before the entry event opens durable state; provider and
+    // runtime failures occur after it, preserving the command-attempt observability contract.
+    const engineName = prepared.request.target.name;
     onDispatchReady();
     options.onDispatchReady?.();
-    // runStructured dispatches at least once, so a returned or DISPATCH_FAILED exchange has a result.
+    // The loop dispatches at least once, so there is 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;
-    }
+    const reply = await structuredLoop({
+        dispatch: async (correction) => {
+            const execution = correction ? corrected(`${prompt}\n\n${correction.text}`) : lowered;
+            const result = await runExecution(execution);
+            results.push(result);
+            return outcomeOf(result);
+        },
+        parse: jsonParser(validateProposalPayload),
+    });
     return {
         result: results.at(-1),
-        ...(reply ? { reply } : {}),
+        reply,
         durationMs: results.reduce((total, result) => total + result.durationMs, 0),
         engineName,
-        ...(lowered.runner.kind === "llm" ? {} : { engineBin: lowered.runner.profile.bin }),
+        ...(lowered.runner.kind === "harness" ? { engineBin: lowered.runner.bin } : {}),
         notices: lowered.notices,
-        sensitiveValues: collectDispatchSensitiveValues(lowered.runner, {}, envSource),
     };
 }
 /**
@@ -121,6 +93,7 @@ function proposeItemRef(bundleId, type, name) {
  * (`proposeItemRef`), so the entry event and the stored proposal agree.
  */
 function emitProposeInvoked(bundleId, options) {
+    const named = options.selection?.connection ?? options.selection?.harness ?? options.selection?.engine;
     appendEvent({
         eventType: "propose_invoked",
         ref: proposeItemRef(bundleId, options.type, options.name),
@@ -128,7 +101,7 @@ function emitProposeInvoked(bundleId, options) {
             type: options.type,
             name: options.name,
             task: options.task,
-            ...(options.engine ? { engine: options.engine } : {}),
+            ...(named ? { engine: named } : {}),
         },
     });
 }
@@ -145,7 +118,7 @@ export async function akmPropose(options) {
     if (!stashDirFor(options.type)) {
         throw new UsageError(`propose: unknown asset type "${options.type}". Known types: ${[...placementTypes()].sort().join(", ")}.`, "INVALID_FLAG_VALUE");
     }
-    // 1. Resolve the write target. Engine/model/inference resolution happens
+    // 1. Resolve the write target. Connection, harness, model and inference resolution happens
     // exactly once below through the shared execution cascade. `--bundle` names a
     // configured, writable bundle (same resolver and errors as `akm remember
     // --bundle`); its root becomes the stash the proposal is queued for and the
@@ -168,9 +141,9 @@ export async function akmPropose(options) {
     // 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, reply, engineName, notices, sensitiveValues } = dispatch;
-    if (!reply) {
-        // B3: ENOENT / not-found gives an actionable hint.
+    const { result, reply, engineName, notices } = dispatch;
+    if (!reply.ok && !isRefused(reply)) {
+        // The dispatch failed. B3: ENOENT / not-found gives an actionable hint.
         if (isEnoentFailure(result)) {
             return {
                 ...failureEnvelope(result, options.type, options.name, engineName, notices),
@@ -179,7 +152,7 @@ export async function akmPropose(options) {
         }
         return failureEnvelope(result, options.type, options.name, engineName, notices);
     }
-    // 5. The proposal the engine returned on stdout, validated.
+    // 5. The proposal the model returned on stdout, validated.
     if (!reply.ok) {
         return {
             schemaVersion: 2,
@@ -196,7 +169,7 @@ export async function akmPropose(options) {
         };
     }
     const payload = reply.value;
-    const unsafeContent = generatedContentRejection(payload.content, redactSensitiveText(payload.content, sensitiveValues));
+    const unsafeContent = generatedContentRejection(payload.content);
     if (unsafeContent) {
         return {
             schemaVersion: 2,

package/dist/commands/proposal/repository.js

@@ -446,7 +446,7 @@ export function resolveProposalIdIn(db, stashDir, idOrRef) {
         return exact;
     if (idOrRef.includes(":") || idOrRef.includes("/")) {
         const wantRef = filterRefIdentity(idOrRef);
-        // Should-fix 7: by-ref resolution never picks a retire proposal — the
+        // By-ref resolution never picks a retire proposal — the
         // newest pending proposal for a ref could be a `consolidate-pair`
         // retirement rather than the reflect/distill edit a person typed the
         // ref to accept, and accepting it archives the asset instead. A retire
@@ -1226,7 +1226,7 @@ async function promoteProposalWithLease(stashDir, config, id, options, ctx) {
  * Every archive dir a tombstone under `.akm/memory-cleanup/archive/` claims
  * for `proposalId` — the primary asset's, and its `.derived` twin's if one
  * was archived alongside it. Used to detect what a resumed retire accept
- * (should-fix 5) has already moved.
+ * has already moved.
  */
 function findRetireArchiveDirsByProposalId(stashRoot, proposalId) {
     const archiveRoot = path.join(stashRoot, ".akm", "memory-cleanup", "archive");
@@ -1267,7 +1267,7 @@ function alreadyArchivedOriginalPaths(stashRoot, dirs) {
     return paths;
 }
 /**
- * Should-fix 5: record a retire accept's intent — `backupContent` and which
+ * Record a retire accept's intent — `backupContent` and which
  * files (asset, `.derived` twin) are about to move — on the still-pending
  * proposal BEFORE any file is moved. A crash after this point resumes from
  * exactly this record instead of re-deriving `backupContent` from whatever
@@ -1287,7 +1287,7 @@ function recordRetireAcceptIntent(stashDir, proposalId, intent, ctx) {
 /**
  * Persist a retire's "accepted" decision — the row, its ledger decision and
  * its event — the one finalize step a fresh accept and one resumed after a
- * crash (should-fix 5) share: by the time either calls it, every file move
+ * crash share: by the time either calls it, every file move
  * is already confirmed done. Mirrors the accept branch of
  * {@link persistProposalDecision}, kept separate since a retire's
  * accepted-shape fields (`retiredArchive`, no published `content`) do not
@@ -1347,10 +1347,10 @@ function persistRetireAcceptance(stashDir, proposal, info, ctx) {
     }));
 }
 /**
- * B2: throws a stale-retire `UsageError` unless the successor still exists
+ * Throws a stale-retire `UsageError` unless the successor still exists
  * and both sides' recorded body hashes and judged scopes still match — the
- * durable half of the chain guard. Used for a fresh accept, and (4b, third
- * review round) to re-check a resumed accept whose intent was recorded but
+ * durable half of the chain guard. Used for a fresh accept, and to
+ * re-check a resumed accept whose intent was recorded but
  * nothing has moved yet: a separate proposal accepted in between (e.g. this
  * one's successor itself retired by a B->C accept) can make the decision
  * stale even though nothing about the retired side's own file changed.
@@ -1377,15 +1377,15 @@ function assertRetirementStillFresh(proposalId, proposalRef, retirement, targetS
 }
 /**
  * Accept a `retire` proposal (0.9.17-alpha.9, the consolidate pair pass): no
- * new content is written. Should-fix 5 (second review round) makes this a
+ * new content is written. It is a
  * three-phase, resume-safe sequence: (1) record intent — `backupContent`
  * and the exact files about to move — on the still-pending proposal; (2)
  * move each file into the recoverable cleanup archive
  * (`archiveCleanupCandidate`), skipping any the tombstone scan shows a prior,
  * crashed attempt already moved; (3) finalize via
  * {@link persistRetireAcceptance}. A `supersedes` judgement writes the
- * supersede edge on the retired (older) side AFTER intent is recorded (4a,
- * third review round — recording it first means a crash before the edge
+ * supersede edge on the retired (older) side AFTER intent is recorded —
+ * recording it first means a crash before the edge
  * write can never cause a resume to re-read the file and capture its own
  * edge into `backupContent`), so the archived copy still preserves it. A
  * target already gone with no recorded intent (raced with something else)
@@ -1429,8 +1429,8 @@ async function retireProposalWithLease(stashDir, config, proposal, options, ctx)
         // `retiredThisRun` in pair-pass.ts):
         assertRetirementStillFresh(proposal.id, proposal.ref, retirement, target.source, currentBytes);
         assertAkmAssetWrite(target.source);
-        // Phase 1: record intent BEFORE any move, and BEFORE the supersede edge
-        // (4a, third review round) — `backupContent` is `currentBytes`, read
+        // Phase 1: record intent BEFORE any move, and BEFORE the supersede edge:
+        // `backupContent` is `currentBytes`, read
         // above, before any mutation of this file. Recording first means a crash
         // between here and the edge write below can never cause a resume to
         // re-read the file and capture the edge INTO backupContent as if it were
@@ -1472,7 +1472,7 @@ async function retireProposalWithLease(stashDir, config, proposal, options, ctx)
         archiveDirs.push(path.dirname(record.auditPath));
         paths.push(intent.assetPath, path.join(mutationTarget.source.path, record.archivedPath), path.join(mutationTarget.source.path, record.auditPath));
     }
-    // 4d (third review round): the twin path is re-derived, not carried on the
+    // The twin path is re-derived, not carried on the
     // intent — it is a pure function of assetPath and the ref's type, and the
     // tombstone scan above (`alreadyDone`) already finds one archived earlier,
     // so storing it was redundant persisted state.
@@ -1528,7 +1528,7 @@ export async function revertProposal(stashDir, config, id, options = {}, ctx) {
  * tombstone names the exact paths to restore — no re-scan of every
  * tombstone in the archive.
  *
- * Should-fix 5 (second review round): every archive dir is resolved and
+ * Every archive dir is resolved and
  * validated before any of them are moved, AND that validation tells "not
  * yet moved" apart from "already moved by an earlier, crashed attempt of
  * our own" (original present, archived copy gone) rather than treating the
@@ -1591,7 +1591,7 @@ async function unretireProposalWithLease(stashDir, config, proposal, options, ct
         if (!originalExists && !archivedExists && !fromBackup) {
             throw new UsageError(`Cannot revert proposal ${proposal.id}: archived copy ${archivedRel} is missing.`, "INVALID_FLAG_VALUE");
         }
-        // Must-fix 2 (third review round): "original present, archived copy
+        // "original present, archived copy
         // missing" is not necessarily our own earlier, crashed revert — once a
         // purge can delete an archived copy on its own, a LATER, unrelated file
         // can occupy this same path (a new memory reusing a retired one's name),
@@ -1714,8 +1714,8 @@ async function revertProposalWithLease(stashDir, config, id, options, ctx) {
     }
     const target = prepareWriteTargetForMutation(boundTarget);
     if (!fs.existsSync(assetPath) || contentHash(fs.readFileSync(assetPath)) !== recorded.contentHash) {
-        // Nit (third review round): by-ref resolution skips retire proposals
-        // (should-fix 7), so reverting by ref when a SEPARATE retire proposal
+        // By-ref resolution skips retire proposals, so reverting by ref when a
+        // SEPARATE retire proposal
         // for the same ref exists (pending or already accepted) lands here with
         // no clue that proposal is the real story — name it when one does.
         const siblingRetire = listProposalsReadOnly(stashDir, { ref: proposal.ref, includeArchive: true }, ctx).find((p) => isRetireProposal(p) && (p.status === "pending" || p.status === "accepted"));

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

@@ -52,8 +52,8 @@ const canonicalProposalValidators = {
         const name = ctx.parsedRef?.name;
         if (!name)
             return [];
-        // Version-routing seam (spec docs/plans/specs/p2a-task-source-v4.md
-        // §3.6): a proposal body is validated by parsing alone — neither arm's
+        // Version-routing seam: a proposal body is validated by parsing alone —
+        // neither arm's
         // parsed document is inspected further, so routing through the union is
         // a pure swap; any parse failure (either version) is turned into an
         // `invalid-task-structure` finding by the try/catch this call sits in.
@@ -80,10 +80,7 @@ const canonicalProposalValidators = {
             ];
         }
         const sourcePath = proposal.changes[0]?.path || proposal.ref;
-        const result = compileWorkflowSource(content, {
-            path: sourcePath,
-            workspaceRoot: proposal.proposedTarget.root,
-        });
+        const result = compileWorkflowSource(content, { path: sourcePath });
         if (result.ok)
             return [];
         return result.errors.map((error) => ({

package/dist/commands/read/curate.js

@@ -28,7 +28,6 @@ import { matchBeliefFilter, searchHitContent } from "../../indexer/search/db-sea
 import { copySearchHitAttribution, getSearchHitAttribution, usageEventAttributionMetadata, } from "../../indexer/search/search-attribution.js";
 import { insertUsageEvent } from "../../indexer/usage/usage-events.js";
 import { estimateTokenCount } from "../../llm/embedders/remote.js";
-import { isLlmFeatureEnabled, tryLlmFeature } from "../../llm/feature-gate.js";
 import { rerankDocuments } from "../../llm/rerank-client.js";
 import { truncateDescription } from "../../output/shapes/helpers.js";
 import { TELEMETRY_BUSY_TIMEOUT_MS, withIndexDb } from "../../storage/repositories/index-db.js";
@@ -188,7 +187,7 @@ export async function curateSearchResults(query, result, limit, selectedType, ev
  * `budgetTokens`.
  *
  * Registry hits are never packed — only `CuratedStashItem`s (locked
- * contract, AGENTS.md: registry results stay separate/opt-in).
+ * contract: registry results stay separate/opt-in).
  *
  * Truncation policy: drop whole hits from the tail of the ranked list first.
  * The only exception is a single high-rank hit that alone exceeds the
@@ -337,7 +336,7 @@ function buildCurateSummary(query, items) {
 }
 /** How many fused candidates curate fetches for the reranker; 0 when reranking is off. */
 function rerankTopN(config) {
-    if (!isLlmFeatureEnabled(config, "curate_rerank"))
+    if (!config.search?.curateRerank?.enabled)
         return 0;
     return config.search?.curateRerank?.topN ?? DEFAULT_CURATE_RERANK_TOP_N;
 }
@@ -355,15 +354,20 @@ async function maybeRerankCuratedStashHits(query, hits) {
         return hits;
     const config = loadConfig();
     const rerankConfig = config.search?.curateRerank;
-    return tryLlmFeature("curate_rerank", config, async () => {
+    if (!rerankConfig?.enabled)
+        return hits;
+    try {
         const head = hits.slice(0, rerankTopN(config));
         const tail = hits.slice(head.length);
-        const ranked = await rerankDocuments(rerankConfig ?? {}, query, rerankDocumentTexts(head));
+        const ranked = await rerankDocuments(rerankConfig, query, rerankDocumentTexts(head));
         const rerankedHead = ranked
             .map(({ index }) => head[index])
             .filter((hit) => hit !== undefined);
         return [...rerankedHead, ...tail];
-    }, hits, { timeoutMs: rerankConfig?.timeoutMs ?? null });
+    }
+    catch {
+        return hits;
+    }
 }
 /**
  * Name, description and the start of each hit's indexed content, capped for