akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/commands/observability-cli.js

@@ -2,50 +2,78 @@
 // 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/.
 /**
- * Observability command cluster — `akm log` (events list/tail), `akm lessons`
- * (coverage), and `akm hints`. Extracted verbatim from src/cli.ts (WS6) so the
- * God Module shrinks; the `main.subCommands.{log,lessons,hints}` keys and every
- * subcommand's args/output shape are byte-identical.
+ * Observability command cluster — `akm log` (append-only events stream).
+ * Extracted verbatim from src/cli.ts (WS6) so the God Module shrinks; the
+ * `main.subCommands.log` key and its args/output shape are byte-identical.
  *
- * These three surfaces are cohesive read-only "tell me what happened / what to
- * do" commands: `log` reads the append-only state.db events stream, `lessons
- * coverage` reports tag-coverage gaps from the index, and `hints` prints the
- * embedded AGENTS.md guidance. They share no helpers with any command still
- * inline in cli.ts, so the `loadHints` private helper and the
- * `formatEventLine` / `EMBEDDED_HINTS*` / db-tag-set imports move with them.
+ * `log` reads the append-only state.db events stream. It shares no helpers
+ * with any command still inline in cli.ts.
  *
- * The leaf handlers whose body is a plain `runWithJsonErrors(...) + output(...)`
- * (`events list`, `lessons coverage`) are migrated onto `defineJsonCommand`,
- * which emits the same JSON envelope (stdout/stderr/exit-code) as the inline
- * form. `events tail` (manual streaming console/stderr writes) and `hints`
- * (direct `process.stdout.write`) keep a plain `defineCommand` wrapping
- * `runWithJsonErrors` so their byte-for-byte output stays untouched.
+ * 0.9.0 CLI overhaul (S3): `log` was a group with `list`/`tail` subcommands;
+ * `tail` (a foreground polling daemon) is dropped and `log` becomes a LEAF
+ * command that is today's `list` surface, unchanged (including the
+ * `--since @offset:<id>` durable cursor and --ref/--type filters). The
+ * `lessons`/`lesson` group (`coverage`, `strength`) is dropped entirely —
+ * ranking's `lessonStrength` contributor is untouched, only the CLI read
+ * surface for it goes away.
+ *
+ * The embedded agent-guide surfaces (`akm hints` and `akm help agents`) live
+ * in src/cli.ts, so their loading code is intentionally outside this module.
+ *
+ * The leaf handler's body is a plain `runWithJsonErrors(...) + output(...)`,
+ * migrated onto `defineJsonCommand`, which emits the same JSON envelope
+ * (stdout/stderr/exit-code) as the inline form.
  */
-import fs from "node:fs";
-import path from "node:path";
-import { defineCommand } from "citty";
 import { parsePositiveIntFlag } from "../cli/parse-args.js";
-import { defineJsonCommand, output, parseAllFlagValues, runWithJsonErrors } from "../cli/shared.js";
-import { EMBEDDED_HINTS, EMBEDDED_HINTS_FULL } from "../output/cli-hints.js";
-import { getOutputMode, parseDetailLevel } from "../output/context.js";
-import { formatEventLine } from "../output/text.js";
-import { getDirname } from "../runtime.js";
-import { closeDatabase, openExistingDatabase } from "../storage/repositories/index-connection.js";
-import { collectTagSetFromEntries } from "../storage/repositories/index-entries-repository.js";
-import { akmEventsList, akmEventsTail } from "./events.js";
+import { retiredCommandHint } from "../cli/retired-commands.js";
+import { defineJsonCommand, output, parseAllFlagValues } from "../cli/shared.js";
+import { UsageError } from "../core/errors.js";
+import { akmEventsList } from "./log.js";
+/**
+ * `log` flattened from a group (`log list`/`log tail`) to a leaf in 0.9 (S3).
+ * `log` declares no positional args, so citty leaves any leftover positional
+ * token in `args._` uninterpreted rather than rejecting it — meaning
+ * `akm log tail` and `akm log list` silently ran today's `log` surface
+ * instead of failing like the other removed spellings (`log tail` is the
+ * dangerous one: it used to stream/follow, so an unmigrated caller got a
+ * silent one-shot snapshot instead of an error).
+ */
+function rejectExtraLogPositionals(positionals) {
+    const extra = Array.isArray(positionals) ? positionals.map(String) : [];
+    if (extra.length === 0)
+        return;
+    // A retired subcommand spelling gets its replacement hint (same table the
+    // unknown-command path uses), so `akm log tail` teaches the durable-cursor
+    // polling pattern instead of a bare "takes no positional arguments".
+    const retired = extra[0] === undefined ? undefined : retiredCommandHint(["log"], extra[0]);
+    throw new UsageError(`akm log takes no positional arguments, but got ${extra.map((token) => `"${token}"`).join(" ")}. ` +
+        '"log list"/"log tail" were removed in 0.9.0 — `akm log` alone is today\'s `log list` surface.', "INVALID_FLAG_VALUE", retired);
+}
 // ── `akm log` ────────────────────────────────────────────────────────────────
-// Append-only events stream surface (#204). `list` reads state.db events
-// with optional --since/--type/--ref filters; `tail` follows the table via
-// a polling loop and prints each event as a single JSONL line.
-const eventsListCommand = defineJsonCommand({
-    meta: { name: "list", description: "List events from the append-only state.db events stream" },
+// Append-only events stream surface (#204). Reads state.db events with
+// optional --since/--type/--ref filters.
+//
+// R-060: the internal output()/shape-registry command name is `log-list`
+// (renamed from the pre-rename `events-list`, back when the command group was
+// still called `akm events`). This string never reaches the wire —
+// `shapeEventsOutput` (src/output/shapes/helpers.ts) builds its own envelope
+// and never stamps a `shape` field — so the rename is a coherence-only
+// change, not a schemaVersion bump. Kept as `log-list` (not renamed to `log`)
+// even though the group flattened to a leaf, to avoid unrelated churn on the
+// internal registry key.
+export const logCommand = defineJsonCommand({
+    meta: { name: "log", description: "List events from the append-only state.db events stream" },
     args: {
         since: {
             type: "string",
             description: "ISO timestamp / epoch ms, OR `@offset:<id>` for a durable row-id cursor (resume across processes)",
         },
         type: { type: "string", description: "Filter by event type (add, remove, remember, feedback, ...)" },
-        ref: { type: "string", description: "Filter by asset ref (type:name)" },
+        ref: { type: "string", description: "Filter by asset ref ([bundle//]conceptId)" },
+        run: {
+            type: "string",
+            description: "Filter to a workflow run's events (metadata.runId), e.g. the id from `akm workflow run`",
+        },
         "exclude-tags": {
             type: "string",
             description: "Exclude events matching these tags (repeatable)",
@@ -54,192 +82,25 @@ const eventsListCommand = defineJsonCommand({
             type: "string",
             description: "Only include events with ALL these tags (repeatable)",
         },
+        limit: {
+            type: "string",
+            description: "Return only the most recent N events matching every other filter (default: unlimited)",
+        },
     },
     run({ args }) {
+        rejectExtraLogPositionals(args._);
         const excludeTags = parseAllFlagValues("--exclude-tags");
         const includeTags = parseAllFlagValues("--include-tags");
+        const limit = parsePositiveIntFlag(args.limit);
         const result = akmEventsList({
             since: args.since,
             type: args.type,
             ref: args.ref,
+            run: args.run,
             ...(excludeTags.length > 0 ? { excludeTags } : {}),
             ...(includeTags.length > 0 ? { includeTags } : {}),
+            ...(limit !== undefined ? { limit } : {}),
         });
-        output("events-list", result);
+        output("log-list", result);
     },
 });
-const eventsTailCommand = defineCommand({
-    meta: { name: "tail", description: "Follow the append-only state.db events stream (polling)" },
-    args: {
-        since: {
-            type: "string",
-            description: "ISO timestamp / epoch ms, OR `@offset:<id>` for a durable row-id cursor (resume across processes)",
-        },
-        type: { type: "string", description: "Filter by event type" },
-        ref: { type: "string", description: "Filter by asset ref (type:name)" },
-        "interval-ms": { type: "string", description: "Polling interval in ms (default: 75)" },
-        "max-duration-ms": { type: "string", description: "Stop after this many ms (default: never)" },
-        "max-events": { type: "string", description: "Stop after observing this many events" },
-        "exclude-tags": {
-            type: "string",
-            description: "Exclude events matching these tags (repeatable)",
-        },
-        "include-tags": {
-            type: "string",
-            description: "Only include events with ALL these tags (repeatable)",
-        },
-    },
-    async run({ args }) {
-        await runWithJsonErrors(async () => {
-            const intervalMs = parsePositiveIntFlag(args["interval-ms"], "--interval-ms");
-            const maxDurationMs = parsePositiveIntFlag(args["max-duration-ms"], "--max-duration-ms");
-            const maxEvents = parsePositiveIntFlag(args["max-events"], "--max-events");
-            const mode = getOutputMode();
-            // In streaming text mode we want each event to print as soon as it
-            // arrives. The polling loop emits via `onEvent`; the final result is
-            // also rendered through the standard output() pipeline so JSON
-            // consumers always get the canonical envelope.
-            const stream = mode.format === "text" || mode.format === "jsonl";
-            const excludeTags = parseAllFlagValues("--exclude-tags");
-            const includeTags = parseAllFlagValues("--include-tags");
-            const result = await akmEventsTail({
-                since: args.since,
-                type: args.type,
-                ref: args.ref,
-                intervalMs,
-                maxDurationMs,
-                maxEvents,
-                ...(excludeTags.length > 0 ? { excludeTags } : {}),
-                ...(includeTags.length > 0 ? { includeTags } : {}),
-                onEvent: stream
-                    ? (event) => {
-                        if (mode.format === "jsonl") {
-                            console.log(JSON.stringify(event));
-                        }
-                        else {
-                            console.log(formatEventLine(event));
-                        }
-                    }
-                    : undefined,
-            });
-            // Emit the canonical envelope last (JSON/YAML modes rely on this;
-            // streaming modes already printed each event but we still emit a
-            // trailer so callers can persist the resumable cursor).
-            if (!stream) {
-                output("events-tail", result);
-            }
-            else if (mode.format === "jsonl") {
-                // Final discriminated trailer row so jsonl consumers can resume.
-                const trailer = {
-                    _kind: "trailer",
-                    schemaVersion: 1,
-                    nextOffset: result.nextOffset,
-                    totalCount: result.totalCount,
-                    reason: result.reason,
-                };
-                console.log(JSON.stringify(trailer));
-            }
-            else {
-                // text mode: keep stdout pristine for line-oriented parsers and
-                // emit the trailer on stderr.
-                process.stderr.write(`[events-tail] reason=${result.reason} nextOffset=${result.nextOffset} total=${result.totalCount}\n`);
-            }
-        });
-    },
-});
-export const logCommand = defineCommand({
-    meta: {
-        name: "log",
-        description: "Read or follow the append-only state.db events stream (mutations, feedback, indexing)",
-    },
-    subCommands: {
-        list: eventsListCommand,
-        tail: eventsTailCommand,
-    },
-});
-// ── lessons subcommands (Phase 7A / Advantage D4c) ──────────────────────────
-const lessonsCoverageCommand = defineJsonCommand({
-    meta: {
-        name: "coverage",
-        description: "Report tags that exist on indexed assets but are NOT yet covered by any lesson.\n\n" +
-            "Useful for spotting topics where the stash has skills/commands/scripts but no\n" +
-            "crystallized lesson — a signal that the team has tacit knowledge worth distilling.\n\n" +
-            "Default output is JSON: { uncoveredTags: string[], lessonTagCount: number, totalTagCount: number }.\n" +
-            "Pass --format text for a plain-text bulleted list.",
-    },
-    args: {},
-    run() {
-        const db = openExistingDatabase();
-        try {
-            const allTagSet = collectTagSetFromEntries(db, undefined);
-            const lessonTagSet = collectTagSetFromEntries(db, "lesson");
-            const uncovered = [];
-            for (const tag of allTagSet) {
-                if (!lessonTagSet.has(tag))
-                    uncovered.push(tag);
-            }
-            uncovered.sort((a, b) => a.localeCompare(b));
-            output("lessons-coverage", {
-                ok: true,
-                uncoveredTags: uncovered,
-                lessonTagCount: lessonTagSet.size,
-                totalTagCount: allTagSet.size,
-            });
-        }
-        finally {
-            closeDatabase(db);
-        }
-    },
-});
-export const lessonsCommand = defineCommand({
-    meta: {
-        name: "lessons",
-        alias: "lesson",
-        description: "Lesson-asset tooling: tag-coverage gaps, strength queries.",
-    },
-    subCommands: {
-        coverage: lessonsCoverageCommand,
-    },
-});
-// ── `akm hints` ──────────────────────────────────────────────────────────────
-export const hintsCommand = defineCommand({
-    meta: {
-        name: "hints",
-        description: "Print agent instructions on how to use akm, use --detail full for a complete guide",
-    },
-    args: {
-        detail: {
-            type: "string",
-            description: "Hints detail level (brief|normal|full). `brief` prints the short guide; `normal`/`full` print the complete guide.",
-            default: "normal",
-        },
-    },
-    run({ args }) {
-        return runWithJsonErrors(() => {
-            // Let the global parser validate the value so an invalid `--detail`
-            // returns the standard JSON error envelope (exit 2) rather than a raw
-            // stack trace + exit 1. `brief` → short doc; `normal`/`full` → full doc.
-            const detail = parseDetailLevel(args.detail) ?? "normal";
-            process.stdout.write(loadHints(detail === "brief" ? "brief" : "full"));
-        });
-    },
-});
-// ── Hints (embedded AGENTS.md) ──────────────────────────────────────────────
-function loadHints(detail = "normal") {
-    // `brief` → the short AGENTS.md guide; `normal`/`full` → the complete guide.
-    const wantFull = detail !== "brief";
-    const filename = wantFull ? "AGENTS.full.md" : "AGENTS.md";
-    const fallback = wantFull ? EMBEDDED_HINTS_FULL : EMBEDDED_HINTS;
-    // Try reading from the docs/ directory (works in dev and when installed via npm)
-    try {
-        const docsPath = path.resolve(getDirname(import.meta.url), `../../docs/agents/${filename}`);
-        if (fs.existsSync(docsPath)) {
-            return fs.readFileSync(docsPath, "utf8");
-        }
-    }
-    catch {
-        // fall through
-    }
-    // Fallback for compiled binary — inline content
-    return fallback;
-}

package/dist/commands/proposal/drain.js

@@ -13,8 +13,7 @@
  *   - Reuses `listProposals` (no source filter — generator filtering is
  *     in-memory) and the `akmProposalAccept` / `akmProposalReject` wrappers from
  *     `proposal.ts` so the standard `promoted` / `rejected` events are emitted.
- *     Deterministic by design — never confidence-gated (the improve confidence
- *     gate that once ran alongside this engine died in 0.9.0).
+ *     Deterministic by design; only the configured drain policy decides.
  *   - Backlog-only: `excludeIds` removes this-run's fresh proposals so triage
  *     never re-adjudicates a current run's output (decision #2).
  *   - Hard guardrails enforced in code: a `maxAccepts` ceiling checked *before*
@@ -35,17 +34,19 @@
  * (mirrors reflect's dual test seams) so tests can run the full engine without
  * touching the filesystem or spawning a process.
  */
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 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 { appendEvent } from "../../core/events.js";
+import { escapeJsonStringControls, stripCodeFences, stripThinkBlocks } from "../../core/parse.js";
 import { info, warn } from "../../core/warn.js";
 import { executeRunner } from "../../integrations/agent/runner-dispatch.js";
-import { chatCompletion, stripJsonFences } from "../../llm/client.js";
+import { chatCompletion } from "../../llm/client.js";
 import { akmProposalAccept, akmProposalReject } from "./proposal.js";
-import { listProposals, proposalContent, recordGateDecision, } from "./repository.js";
+import { listProposals, preflightProposalPromotion, proposalContent, recordGateDecision, } from "./repository.js";
 // ---------------------------------------------------------------------------
 // Content helpers
 // ---------------------------------------------------------------------------
@@ -184,7 +185,7 @@ export function buildJudgmentPrompt(proposal, reason, ctx) {
 }
 /** Parse a {@link JudgmentVerdict} from raw runner output. Lenient. */
 export function parseJudgmentVerdict(raw) {
-    const cleaned = stripJsonFences(raw).trim();
+    const cleaned = escapeJsonStringControls(stripCodeFences(stripThinkBlocks(raw))).trim();
     if (!cleaned)
         return null;
     // Find the first balanced-looking JSON object in the output.
@@ -241,6 +242,9 @@ async function dispatchJudgment(runner, prompt, seams) {
     }
     return parseJudgmentVerdict(result.stdout);
 }
+function judgedContentHash(proposal) {
+    return createHash("sha256").update(proposalContent(proposal), "utf8").digest("hex");
+}
 /**
  * Run the judgment tier over the deferred items. The runner only *judges*; the
  * engine performs the resulting accept (respecting `applyMode`) / reject write.
@@ -285,7 +289,12 @@ async function runJudgmentTier(input) {
                 continue;
             }
             try {
-                await input.rejectFn({ stashDir: input.stashDir, id: item.id, reason: verdict.reason || "judgment: reject" });
+                await input.rejectFn({
+                    stashDir: input.stashDir,
+                    id: item.id,
+                    reason: verdict.reason || "judgment: reject",
+                    gateDecision: { outcome: "auto-rejected", reason: "judgment-reject", gate: input.gateLabel },
+                });
                 rejected.push(item.id);
             }
             catch (err) {
@@ -301,6 +310,21 @@ async function runJudgmentTier(input) {
             // is RESOLVED (the runner judged it). Track separately so it is NOT
             // reported as "left unresolved" and a follow-up promote run picks it up.
             staged.push(item.id);
+            if (!input.dryRun) {
+                try {
+                    recordGateDecision(input.stashDir, item.id, {
+                        outcome: "staged",
+                        reason: "judgment-accept",
+                        contentHash: judgedContentHash(proposal),
+                        gate: input.gateLabel,
+                    });
+                }
+                catch (err) {
+                    warn(`[triage] failed to stage judgment for ${item.id}: ${err instanceof Error ? err.message : String(err)}`);
+                    staged.pop();
+                    stillDeferred.push(item);
+                }
+            }
             continue;
         }
         // Accept cap: once the shared budget is exhausted, route further accepts to
@@ -310,6 +334,19 @@ async function runJudgmentTier(input) {
             continue;
         }
         if (input.dryRun) {
+            try {
+                if (input.config) {
+                    preflightProposalPromotion(input.config, proposal, {
+                        ...(input.target ? { target: input.target } : {}),
+                        gateDecision: { outcome: "auto-accepted", reason: "judgment-accept", gate: input.gateLabel },
+                    });
+                }
+            }
+            catch (err) {
+                warn(`[triage] judgment preflight failed for ${item.id}: ${err instanceof Error ? err.message : String(err)}`);
+                stillDeferred.push(item);
+                continue;
+            }
             promoted.push(item.id);
             acceptBudget -= 1;
             continue;
@@ -320,6 +357,7 @@ async function runJudgmentTier(input) {
                 id: item.id,
                 ...(input.target ? { target: input.target } : {}),
                 ...(input.config ? { config: input.config } : {}),
+                gateDecision: { outcome: "auto-accepted", reason: "judgment-accept", gate: input.gateLabel },
             });
             promoted.push(item.id);
             acceptBudget -= 1;
@@ -347,6 +385,7 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
     const pending = listProposals(opts.stashDir, { status: "pending" }).filter((p) => !exclude.has(p.id));
     // First, classify every proposal deterministically.
     const acceptIds = [];
+    const acceptGateReasons = new Map();
     const rejectTargets = [];
     const gateLabel = `triage:${opts.policy.name}`;
     // Items deferred purely because they need a judge (no threshold-based reason)
@@ -359,22 +398,31 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
         // the audit trail and silently promote content the gate explicitly rejected.
         // Such proposals remain pending until the TTL expires them — the queue is
         // audited-autonomous; no manual-review rung exists (06-M3).
-        if (proposal.gateDecision?.outcome === "auto-rejected")
+        if (proposal.gateDecision?.outcome === "auto-rejected" && !proposal.gateDecision.gate?.startsWith("triage:")) {
             continue;
+        }
+        if (proposal.gateDecision?.outcome === "staged" &&
+            proposal.gateDecision.gate === gateLabel &&
+            proposal.gateDecision.contentHash === judgedContentHash(proposal)) {
+            acceptIds.push(proposal.id);
+            acceptGateReasons.set(proposal.id, "judgment-accept");
+            continue;
+        }
         const decision = classifyProposal(proposal, opts.policy, opts.maxDiffLines);
         if (decision === null)
             continue;
         // #577: stamp the gate's verdict onto the proposal so `akm proposal show`
         // can explain WHY it landed here. A dry-run performs zero writes, so it
         // records nothing.
-        const outcome = decision.verdict === "accept" ? "auto-accepted" : decision.verdict === "reject" ? "auto-rejected" : "deferred";
-        stampGateDecision(opts, proposal.id, {
-            outcome,
-            reason: decision.gate.reason,
-            ...(decision.gate.measured !== undefined ? { measured: decision.gate.measured } : {}),
-            ...(decision.gate.thresholds ? { thresholds: decision.gate.thresholds } : {}),
-            gate: gateLabel,
-        });
+        if (decision.verdict === "defer") {
+            stampGateDecision(opts, proposal.id, {
+                outcome: "deferred",
+                reason: decision.gate.reason,
+                ...(decision.gate.measured !== undefined ? { measured: decision.gate.measured } : {}),
+                ...(decision.gate.thresholds ? { thresholds: decision.gate.thresholds } : {}),
+                gate: gateLabel,
+            });
+        }
         // A defer with no threshold (mid-band / possible-dup from the defer list) is
         // pending only because it needs adjudication — re-stampable to
         // `no-judge-configured`. A band-based defer keeps its specific reason.
@@ -383,6 +431,7 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
         }
         if (decision.verdict === "accept") {
             acceptIds.push(proposal.id);
+            acceptGateReasons.set(proposal.id, "policy-accept");
         }
         else if (decision.verdict === "reject") {
             rejectTargets.push({ id: proposal.id, reason: decision.reason });
@@ -398,7 +447,12 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
             continue;
         }
         try {
-            await rejectFn({ stashDir: opts.stashDir, id: target.id, reason: target.reason });
+            await rejectFn({
+                stashDir: opts.stashDir,
+                id: target.id,
+                reason: target.reason,
+                gateDecision: { outcome: "auto-rejected", reason: "empty-diff", gate: gateLabel },
+            });
             result.rejected.push(target.id);
         }
         catch (err) {
@@ -424,6 +478,11 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
                     id,
                     ...(opts.target ? { target: opts.target } : {}),
                     ...(opts.config ? { config: opts.config } : {}),
+                    gateDecision: {
+                        outcome: "auto-accepted",
+                        reason: acceptGateReasons.get(id) ?? "policy-accept",
+                        gate: gateLabel,
+                    },
                 });
                 result.promoted.push(id);
                 deterministicPromoted += 1;
@@ -434,10 +493,31 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
         }
     }
     else if (opts.applyMode === "promote" && opts.dryRun) {
-        // Dry-run promote: report (and count, for the shared budget) what would be
-        // promoted without writing.
-        result.promoted.push(...withinCap);
-        deterministicPromoted = withinCap.length;
+        // Exercise the same stamped candidate and lint boundary as real promotion.
+        // Tests that omit config retain the classification-only seam.
+        const byId = new Map(pending.map((proposal) => [proposal.id, proposal]));
+        for (const id of withinCap) {
+            try {
+                if (opts.config) {
+                    const proposal = byId.get(id);
+                    if (!proposal)
+                        throw new Error(`Proposal ${id} disappeared during drain preflight.`);
+                    preflightProposalPromotion(opts.config, proposal, {
+                        ...(opts.target ? { target: opts.target } : {}),
+                        gateDecision: {
+                            outcome: "auto-accepted",
+                            reason: acceptGateReasons.get(id) ?? "policy-accept",
+                            gate: gateLabel,
+                        },
+                    });
+                }
+                result.promoted.push(id);
+                deterministicPromoted += 1;
+            }
+            catch (err) {
+                warn(`[triage] preflight failed for ${id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
     }
     // applyMode "queue": leave accept candidates pending (staged). No promotion.
     // Remaining accept budget for the judgment tier: maxAccepts minus what was
@@ -461,6 +541,7 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
             ...(opts.target ? { target: opts.target } : {}),
             ...(opts.config ? { config: opts.config } : {}),
             remainingAcceptBudget,
+            gateLabel,
         });
         result.promoted.push(...tier.promoted);
         result.rejected.push(...tier.rejected);
@@ -471,15 +552,6 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
         if (tier.skippedByCap.length > 0) {
             info(`[triage] accept ceiling reached in judgment tier: ${tier.skippedByCap.length} judged-accept items skipped by cap (maxAccepts=${opts.maxAccepts})`);
         }
-        // #577: re-stamp the gate decision for items the judgment tier resolved so
-        // `akm proposal show` reflects the judge's verdict, not the earlier
-        // deterministic defer.
-        for (const id of tier.promoted) {
-            stampGateDecision(opts, id, { outcome: "auto-accepted", reason: "judgment-accept", gate: gateLabel });
-        }
-        for (const id of tier.rejected) {
-            stampGateDecision(opts, id, { outcome: "auto-rejected", reason: "judgment-reject", gate: gateLabel });
-        }
         // Replace the deferred list with only the items the judgment tier could NOT
         // resolve (verdict "defer", parse failure, or runner error). Staged
         // queue-mode accepts are RESOLVED and tracked in result.staged instead.