akm-cli 0.9.17-alpha.3 → 0.9.17-alpha.4

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

@@ -25,7 +25,6 @@ import { resolveImproveExecution } from "../improve/execution.js";
 import { extractCommand } from "../improve/extract-cli.js";
 import { resolveImproveStrategy } from "../improve/improve-strategies.js";
 import { drainProposals } from "./drain.js";
-import { resolveDrainPolicy } from "./drain-policies.js";
 import { akmProposalAccept, akmProposalDiff, akmProposalList, akmProposalReject, akmProposalRevert, akmProposalShow, bulkAdjudicateProposals, } from "./proposal.js";
 import { proposeCommand } from "./propose-cli.js";
 export function mergeProposalDrainNotices(resolutionNotices, dispatchNotices) {
@@ -323,13 +322,9 @@ const proposalShowCommand = defineJsonCommand({
 const proposalDrainCommand = defineJsonCommand({
     meta: {
         name: "drain",
-        description: "Drain the standing pending proposal backlog using a deterministic triage policy",
+        description: "Drain the pending proposal backlog: accept what a quality judge passed, reject empty diffs, leave the rest for judgment or review",
     },
     args: {
-        policy: {
-            type: "string",
-            description: "Built-in preset (personal-stash|conservative|manual) or path to a policy file",
-        },
         "dry-run": {
             type: "boolean",
             description: "List what would be accepted/rejected/deferred without writing.",
@@ -345,10 +340,6 @@ const proposalDrainCommand = defineJsonCommand({
             type: "string",
             description: "Hard per-run accept ceiling. Accepts beyond this are reported as skippedByCap.",
         },
-        "max-diff-lines": {
-            type: "string",
-            description: "Defer (never promote) accepts whose proposed content exceeds this many lines.",
-        },
         "older-than": {
             type: "string",
             description: "Only consider proposals created more than this many days ago.",
@@ -365,7 +356,7 @@ const proposalDrainCommand = defineJsonCommand({
         },
         strategy: {
             type: "string",
-            description: "Read the triage block (policy, applyMode, ceilings, judgment) from this improve strategy.",
+            description: "Read the triage block (applyMode, ceilings, judgment) from this improve strategy.",
         },
     },
     async run({ args, rawArgs }) {
@@ -378,20 +369,17 @@ const proposalDrainCommand = defineJsonCommand({
         // always override config; config supplies defaults for any flag omitted.
         const selectedStrategy = resolveImproveStrategy(args.strategy, cfg);
         const triageConfig = selectedStrategy.config.processes?.triage;
-        const policy = resolveDrainPolicy(args.policy ?? triageConfig?.policy);
         const dryRun = args["dry-run"] === true;
         const applyMode = args.promote === true ? "promote" : (triageConfig?.applyMode ?? "queue");
         const maxAccepts = parsePositiveIntFlag(args["max-accepts"], "--max-accepts") ??
             triageConfig?.maxAcceptsPerRun ??
             25;
-        const maxDiffLines = parsePositiveIntFlag(args["max-diff-lines"], "--max-diff-lines") ??
-            triageConfig?.maxDiffLines;
         const rawOlderThan = parsePositiveIntFlag(args["older-than"], "--older-than");
         const olderThanMs = rawOlderThan !== undefined ? rawOlderThan * 86_400_000 : undefined;
         // Promotion in promote mode is destructive (commits to git, no batch revert).
         if (applyMode === "promote" && !dryRun) {
             const { confirmDestructive } = await import("../../cli/confirm.js");
-            const confirmed = await confirmDestructive(`Drain and promote matching pending proposals under policy "${policy.name}"? Promotions commit to git and cannot be batch-reverted.`, { yes: args.yes === true });
+            const confirmed = await confirmDestructive("Drain and promote judge-passed pending proposals? Promotions commit to git and cannot be batch-reverted.", { yes: args.yes === true });
             if (!confirmed) {
                 process.stderr.write("Aborted.\n");
                 return;
@@ -444,11 +432,9 @@ const proposalDrainCommand = defineJsonCommand({
             result = await withLlmStage("drain", () => drainProposals({
                 stashDir,
                 config: cfg,
-                policy,
                 applyMode,
                 maxAccepts,
                 dryRun,
-                ...(maxDiffLines !== undefined ? { maxDiffLines } : {}),
                 ...(excludeIds ? { excludeIds } : {}),
                 judgment,
             }));
@@ -461,7 +447,6 @@ const proposalDrainCommand = defineJsonCommand({
         output("proposal-drain", {
             schemaVersion: 1,
             ok: true,
-            policy: policy.name,
             applyMode,
             dryRun,
             strategy: selectedStrategy.name,

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

@@ -1,37 +1,24 @@
 // 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/.
-// ── Source allow-list (F-4 / #385) ──────────────────────────────────────────
 /**
- * Curated allow-list of valid `source` values for proposals (F-4 / #385).
- *
- * Rationale (W3C PROV-DM 2013): Provenance records require typed, validated
- * sources for meaningful aggregation. Accept-rate-per-source is the core
- * self-measurement metric for recursive self-improvement: if reflect proposals
- * are accepted at 20% and distill proposals at 60%, that guides resource
- * allocation. Free-text typos (`"reflct"`) produce unaggregatable events.
- *
- * Automated sources (those in {@link AUTOMATED_PROPOSAL_SOURCES}) require a
- * `sourceRun` field for full PROV-DM traceability.
+ * Valid proposal `source` values (#385): typed sources keep accept-rate per
+ * source aggregatable (PROV-DM). An unknown value is accepted with a warning.
  */
 export const PROPOSAL_SOURCES = [
-    // Automated sources — require sourceRun for traceability.
     "reflect",
     "distill",
     "consolidate",
     "extract",
     "improve",
-    // Semi-automated / tool-driven.
     "feedback",
-    // Human-initiated / CLI-driven.
     "propose",
     "remember",
     "import",
-    // Internal / system.
     "distill_quality_rejected",
     "schema-repair",
 ];
-/** Automated sources that SHOULD include a `sourceRun` for PROV-DM traceability. */
+/** Automated sources, which should carry a `sourceRun`. */
 export const AUTOMATED_PROPOSAL_SOURCES = [
     "reflect",
     "distill",
@@ -40,38 +27,30 @@ export const AUTOMATED_PROPOSAL_SOURCES = [
     "improve",
     "schema-repair",
 ];
-/**
- * Check whether a string is a valid {@link ProposalSource}.
- * Unknown source values are accepted with a runtime warning rather than a hard
- * error, to allow extensions without breaking existing callers.
- */
 export function isValidProposalSource(source) {
     return PROPOSAL_SOURCES.includes(source);
 }
-/**
- * Check whether a source value is an automated source requiring `sourceRun`.
- */
 export function isAutomatedProposalSource(source) {
     return AUTOMATED_PROPOSAL_SOURCES.includes(source);
 }
-/**
- * Gate-decision reason token for a promote refusal caused by the TARGET
- * changing after mint — often akm's own bookkeeping, not a merit judgement on
- * the proposed content (STALE, R20). The drain stamps this on the auto-reject
- * it issues instead of retrying a promote that will fail identically forever;
- * {@link isStaleTargetRejection} and the rejection-backoff guard
- * (`repository.ts`'s `checkFingerprintAndBackoff`) both key off the exact
- * string so they can't drift apart.
- */
+/** A promote refused because the target changed after mint (STALE, R20) — not a merit judgement. */
 export const STALE_TARGET_GATE_REASON = "stale-target";
+export const EXPIRED_GATE_REASON = "expired";
+export const ASSET_MISSING_GATE_REASON = "asset-missing";
+const PROCEDURAL_GATE_REASONS = new Set([
+    STALE_TARGET_GATE_REASON,
+    EXPIRED_GATE_REASON,
+    ASSET_MISSING_GATE_REASON,
+]);
 /**
- * True for a rejected proposal whose rejection was the drain's stale-target
- * auto-reject (STALE, R20), not a judgement on the proposed content. Readers
- * that treat a rejection as "this content was refused" — the Reflexion
- * "previously rejected" context (`improve/reflect.ts`, `improve/distill.ts`)
- * and the accept-rate health metric (`health/accept-rate.ts`) — exclude these
- * rows so a procedural refusal doesn't misrepresent content quality.
+ * A rejection nobody judged on its content (stale target, expiry, orphan
+ * purge). The "previously rejected" prompt context and the accept-rate metric
+ * leave these out. Expiries archived before the gate reason existed are known
+ * by their review reason.
  */
-export function isStaleTargetRejection(proposal) {
-    return (proposal.gateDecision?.outcome === "auto-rejected" && proposal.gateDecision.reason === STALE_TARGET_GATE_REASON);
+export function isProceduralRejection(proposal) {
+    if (proposal.gateDecision?.outcome === "auto-rejected" && PROCEDURAL_GATE_REASONS.has(proposal.gateDecision.reason)) {
+        return true;
+    }
+    return proposal.review?.reason?.startsWith("expired:") === true;
 }

package/dist/commands/proposal/proposal.js

@@ -15,7 +15,7 @@ import { resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
 import { resolveWriteTarget } from "../../core/write-source.js";
 import { withAssetMutationLease } from "../../indexer/index-writer-lock.js";
-import { diffProposal, listProposals, preflightProposalPromotion, promoteProposal, proposalContent, recoverProposalTransactionsForStash, rejectProposalDurably, resolveProposalId, revertProposal, } from "./repository.js";
+import { diffProposal, listProposals, preflightProposalPromotion, promoteProposal, proposalContent, rejectProposalDurably, resolveProposalId, revertProposal, } from "./repository.js";
 import { validateProposal } from "./validators/proposals.js";
 // ── Shared helpers ──────────────────────────────────────────────────────────
 function resolveStash(stashDir) {
@@ -104,7 +104,6 @@ export async function akmProposalReject(options) {
         const config = options.config ?? loadConfig();
         const { stashDir: stash } = resolveProposalQueue(options.stashDir, options.queue, config);
         const proposalId = resolveProposalId(stash, options.id, options.ctx).id;
-        await recoverProposalTransactionsForStash(stash, config, options.ctx, proposalId);
         const updated = rejectProposalDurably(stash, proposalId, options.reason, options.ctx, options.gateDecision);
         return {
             schemaVersion: 1,

package/dist/commands/proposal/propose.js

@@ -19,15 +19,16 @@ import { resolveStashDir } from "../../core/common.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 { warn } from "../../core/warn.js";
 import { deriveEntryProvenance } from "../../indexer/installations.js";
 import { fallbackAnnouncement } from "../../integrations/agent/engine-fallback.js";
-import { acquireLoweredExecutionDispatchLease, dispatchLoweredExecutionRequest, disposeLoweredExecutionDispatchLease, lowerResolvedExecutionRequest, redactWithLoweredExecutionDispatchLease, } from "../../integrations/agent/execution-lowering.js";
-import { prepareInlineExecution } from "../../integrations/agent/inline-execution.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 { baseFailureFields, enoentHintMessage, isEnoentFailure } from "../agent/agent-support.js";
-import { createProposal, isProposalSkipped, resolveProposalQueueTarget, } from "./repository.js";
+import { createProposal, resolveProposalQueueTarget, } from "./repository.js";
 function failureEnvelope(result, type, name, engine, notices, fallbackReason = "non_zero_exit") {
     return {
         ...baseFailureFields(result, fallbackReason),
@@ -41,56 +42,43 @@ function failureEnvelope(result, type, name, engine, notices, fallbackReason = "
 function noticeFields(notices) {
     return notices.length > 0 ? { notices } : {};
 }
-/** Materialize required credentials through the real runner boundary, without provider I/O. */
-async function preflightProposalDispatch(lowered, runOptions) {
-    return acquireLoweredExecutionDispatchLease(lowered, {
-        ...(runOptions.envSource ? { envSource: runOptions.envSource } : {}),
-    });
-}
 /** Resolve, lower, and dispatch the already-rendered proposal prompt. */
 async function dispatchProposalPrompt(prompt, config, options, onDispatchReady) {
     const current = {
         ...(options.engine !== undefined ? { engine: options.engine } : {}),
         ...(options.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
     };
-    const prepared = prepareInlineExecution({
+    const prepared = resolveExecution({
         content: prompt,
         config,
-        invocationKind: "direct",
         ...(Object.keys(current).length > 0 ? { current } : {}),
     });
     const engineName = prepared.request.engine.name;
     const announcement = fallbackAnnouncement(prepared.fallbackEngineName, engineName);
     if (announcement)
         warn(announcement);
-    const lowered = lowerResolvedExecutionRequest(prepared.request, prepared.config);
+    const lowered = buildExecution(prepared.request, prepared.runner);
     const interactive = !options.runAgentOptions?.spawn;
     const runOptions = {
         stdio: interactive ? "interactive" : "captured",
         parseOutput: "text",
         ...(options.runAgentOptions ?? {}),
     };
-    const lease = await preflightProposalDispatch(lowered, runOptions);
-    // Materialize/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.
-    try {
-        onDispatchReady();
-        options.onDispatchReady?.();
-        const result = await dispatchLoweredExecutionRequest(lowered, { runOptions, lease });
-        return {
-            result,
-            engineName,
-            ...(lowered.runner.kind === "llm" ? {} : { engineBin: lowered.runner.profile.bin }),
-            notices: lowered.notices,
-            lease,
-            interactive,
-        };
-    }
-    catch (error) {
-        disposeLoweredExecutionDispatchLease(lease);
-        throw error;
-    }
+    // 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);
+    onDispatchReady();
+    options.onDispatchReady?.();
+    const result = await runExecution(lowered, { runOptions });
+    return {
+        result,
+        engineName,
+        ...(lowered.runner.kind === "llm" ? {} : { engineBin: lowered.runner.profile.bin }),
+        notices: lowered.notices,
+        sensitiveValues: collectDispatchSensitiveValues(lowered.runner, {}, runOptions.envSource),
+        interactive,
+    };
 }
 /**
  * WI-8.5a — the fully-qualified `bundle//conceptId` item_ref for a proposal
@@ -158,153 +146,139 @@ export async function akmPropose(options) {
     // no synthetic persona, conversation turn, schema, or tool selection is
     // introduced while it crosses the shared resolved/lowered boundary.
     const dispatch = await dispatchProposalPrompt(prompt, config, options, () => emitProposeInvoked(target.source, options));
-    const { result, engineName, notices, lease } = dispatch;
-    try {
-        if (!result.ok) {
-            // B3: ENOENT / not-found gives an actionable hint.
-            if (isEnoentFailure(result)) {
-                return {
-                    ...failureEnvelope(result, options.type, options.name, engineName, notices),
-                    error: enoentHintMessage(dispatch.engineBin ?? engineName),
-                };
-            }
-            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,
+    const { result, engineName, notices, sensitiveValues } = dispatch;
+    if (!result.ok) {
+        // B3: ENOENT / not-found gives an actionable hint.
+        if (isEnoentFailure(result)) {
+            return {
+                ...failureEnvelope(result, options.type, options.name, engineName, notices),
+                error: enoentHintMessage(dispatch.engineBin ?? engineName),
             };
         }
-        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 unsafeContent = generatedContentRejection(payload.content, redactWithLoweredExecutionDispatchLease(lease, payload.content));
-        if (unsafeContent) {
+        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,
+        };
+    }
+    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: unsafeContent,
+                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),
             };
         }
-        // 6. Insert the proposal. Note: we allow the agent's `ref` to normalise the
-        // asset name (e.g. path-cleanup), but only after validating that the ref is
-        // well-formed and the type still matches the requested type.
-        const expectedRef = proposeItemRef(target.source, options.type, options.name);
-        let ref = expectedRef;
-        if (payload.ref) {
-            let parsedRef;
-            try {
-                parsedRef = parseRefInput(payload.ref);
-            }
-            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),
-                };
-            }
-            if (parsedRef.type !== options.type) {
-                return {
-                    schemaVersion: 2,
-                    ok: false,
-                    reason: "parse_error",
-                    error: `Agent returned ref type ${parsedRef.type} but expected ${options.type}`,
-                    type: options.type,
-                    name: options.name,
-                    engine: engineName,
-                    exitCode: result.exitCode,
-                    stdout: result.stdout,
-                    ...(result.stderr ? { stderr: result.stderr } : {}),
-                    ...noticeFields(notices),
-                };
-            }
-            ref = proposeItemRef(target.source, parsedRef.type, parsedRef.name);
+        try {
+            payload = parseAgentProposalPayload(result.stdout ?? "");
         }
-        const createInput = {
-            ref,
-            source: "propose",
-            sourceRun: `propose-${Date.now()}`,
-            target,
-            // User-initiated proposals always bypass dedup/cooldown guards — the
-            // operator is explicitly asking for a new proposal.
-            force: true,
-            payload: {
-                content: payload.content,
-                ...(payload.frontmatter ? { frontmatter: payload.frontmatter } : {}),
-            },
-        };
-        const proposalResult = createProposal(stash, createInput, options.ctx);
-        // With force:true, the result is always a Proposal (never skipped).
-        if (isProposalSkipped(proposalResult)) {
-            // Should never happen when force:true, but be defensive.
-            throw new Error(`Unexpected skip in propose command: ${proposalResult.message}`);
+        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 proposal = proposalResult;
+    }
+    const unsafeContent = generatedContentRejection(payload.content, redactSensitiveText(payload.content, sensitiveValues));
+    if (unsafeContent) {
         return {
             schemaVersion: 2,
-            ok: true,
-            proposal,
-            ref: proposal.ref,
+            ok: false,
+            reason: "parse_error",
+            error: unsafeContent,
+            type: options.type,
+            name: options.name,
             engine: engineName,
-            durationMs: result.durationMs,
+            exitCode: result.exitCode,
             ...noticeFields(notices),
         };
     }
-    finally {
-        disposeLoweredExecutionDispatchLease(lease);
+    // 6. Insert the proposal. Note: we allow the agent's `ref` to normalise the
+    // asset name (e.g. path-cleanup), but only after validating that the ref is
+    // well-formed and the type still matches the requested type.
+    const expectedRef = proposeItemRef(target.source, options.type, options.name);
+    let ref = expectedRef;
+    if (payload.ref) {
+        let parsedRef;
+        try {
+            parsedRef = parseRefInput(payload.ref);
+        }
+        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),
+            };
+        }
+        if (parsedRef.type !== options.type) {
+            return {
+                schemaVersion: 2,
+                ok: false,
+                reason: "parse_error",
+                error: `Agent returned ref type ${parsedRef.type} but expected ${options.type}`,
+                type: options.type,
+                name: options.name,
+                engine: engineName,
+                exitCode: result.exitCode,
+                stdout: result.stdout,
+                ...(result.stderr ? { stderr: result.stderr } : {}),
+                ...noticeFields(notices),
+            };
+        }
+        ref = proposeItemRef(target.source, parsedRef.type, parsedRef.name);
     }
+    const createInput = {
+        ref,
+        source: "propose",
+        sourceRun: `propose-${Date.now()}`,
+        target,
+        payload: {
+            content: payload.content,
+            ...(payload.frontmatter ? { frontmatter: payload.frontmatter } : {}),
+        },
+    };
+    const proposal = createProposal(stash, createInput, options.ctx);
+    return {
+        schemaVersion: 2,
+        ok: true,
+        proposal,
+        ref: proposal.ref,
+        engine: engineName,
+        durationMs: result.durationMs,
+        ...noticeFields(notices),
+    };
 }