akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

package/dist/commands/proposal/drain.js

@@ -9,13 +9,13 @@
  * the engine behind `akm proposal drain` and (later) the `triage` improve
  * pre-pass.
  *
- * Design (see docs/archive/proposal-triage-implementation-plan.md):
+ * Design:
  *   - 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.
- *     It deliberately does NOT use `runAutoAcceptGate`, which is confidence-gated.
+ *     Deterministic by design; only the configured drain policy decides.
  *   - Backlog-only: `excludeIds` removes this-run's fresh proposals so triage
- *     never re-adjudicates the per-run auto-accept gate's decisions (decision #2).
+ *     never re-adjudicates a current run's output (decision #2).
  *   - Hard guardrails enforced in code: a `maxAccepts` ceiling checked *before*
  *     the promote loop (remainder → `skippedByCap`); `maxDiffLines` defers large
  *     accepts; `applyMode: "queue"` (the safe default) never promotes (stage
@@ -31,20 +31,22 @@
  *     never silently looks like full success.
  *
  * The promote / reject functions and the runner dispatch are injectable
- * (mirrors `improve-auto-accept.ts` and reflect's dual test seams) so tests can
- * run the full engine without touching the filesystem or spawning a process.
+ * (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 { parseAssetRef } from "../../core/asset/asset-ref.js";
-import { resolveAssetPathFromName, TYPE_DIRS } from "../../core/asset/asset-spec.js";
+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, recordGateDecision } from "./repository.js";
+import { listProposals, proposalContent, recordGateDecision, } from "./repository.js";
 // ---------------------------------------------------------------------------
 // Content helpers
 // ---------------------------------------------------------------------------
@@ -63,7 +65,7 @@ export function contentLineCount(content) {
 }
 /** An empty / near-empty diff has no meaningful body content. */
 export function isEmptyDiff(proposal) {
-    const content = proposal.payload.content ?? "";
+    const content = proposalContent(proposal);
     if (content.trim().length === 0)
         return true;
     return contentBodyLineCount(content) === 0;
@@ -73,7 +75,7 @@ export function isEmptyDiff(proposal) {
  * Returns `null` when no rule applies (the proposal is left pending untouched).
  */
 export function classifyProposal(proposal, policy, maxDiffLines) {
-    const content = proposal.payload.content ?? "";
+    const content = proposalContent(proposal);
     // Empty / near-empty diffs reject first (the reject-empty floor).
     if (policy.rejectEmpty && isEmptyDiff(proposal)) {
         return { verdict: "reject", reason: "empty diff", gate: { reason: "empty-diff" } };
@@ -82,7 +84,7 @@ export function classifyProposal(proposal, policy, maxDiffLines) {
         if (r.generator !== proposal.source)
             return false;
         if (r.requireType !== undefined) {
-            const fm = parseFrontmatter(proposal.payload.content ?? "").data;
+            const fm = parseFrontmatter(proposalContent(proposal)).data;
             if (typeof fm.type !== "string" || fm.type !== r.requireType)
                 return false;
         }
@@ -126,12 +128,12 @@ function deferReasonForSource(source) {
 /** Read the live on-disk content of a proposal's target asset, if it exists. */
 function readLiveAssetContent(stashDir, ref) {
     try {
-        const parsed = parseAssetRef(ref);
-        const typeDir = TYPE_DIRS[parsed.type];
+        const parsed = parseRefInput(ref);
+        const typeDir = stashDirFor(parsed.type);
         if (!typeDir)
             return undefined;
         const typeRoot = path.join(stashDir, typeDir);
-        const assetPath = resolveAssetPathFromName(parsed.type, typeRoot, parsed.name);
+        const assetPath = assetPathForName(parsed.type, typeRoot, parsed.name);
         if (!fs.existsSync(assetPath))
             return undefined;
         return fs.readFileSync(assetPath, "utf8");
@@ -152,7 +154,7 @@ function prefetchJudgmentContext(stashDir, proposal, pending) {
 }
 /** Build the judgment prompt with the proposed content + pre-fetched context. */
 export function buildJudgmentPrompt(proposal, reason, ctx) {
-    const proposed = proposal.payload.content ?? "";
+    const proposed = proposalContent(proposal);
     const sections = [
         "You are adjudicating a pending knowledge-base proposal that the deterministic",
         "triage pass could not resolve. Decide whether to accept, reject, or defer it.",
@@ -175,7 +177,7 @@ export function buildJudgmentPrompt(proposal, reason, ctx) {
     if (ctx.siblings.length > 0) {
         sections.push("", "## Other pending proposals for the same ref (dedup context)");
         for (const sib of ctx.siblings) {
-            sections.push("", `### Sibling ${sib.id} (source: ${sib.source})`, "```", sib.payload.content ?? "", "```");
+            sections.push("", `### Sibling ${sib.id} (source: ${sib.source})`, "```", proposalContent(sib), "```");
         }
     }
     sections.push("", "## Your task", 'Return ONLY a JSON object: {"decision": "accept" | "reject" | "defer", "reason": "<short reason>"}.', "- accept: the proposed content is a correct, valuable update worth committing.", "- reject: the proposal is wrong, a duplicate, or contradicts the live asset.", "- defer: you cannot decide from the provided context (leave it pending).", "Output the JSON object and nothing else.");
@@ -183,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.
@@ -240,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.
@@ -284,7 +289,12 @@ async function runJudgmentTier(input) {
                 continue;
             }
             try {
-                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) {
@@ -300,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
@@ -314,7 +339,13 @@ async function runJudgmentTier(input) {
             continue;
         }
         try {
-            await input.promoteFn({ stashDir: input.stashDir, id: item.id });
+            await input.promoteFn({
+                stashDir: input.stashDir,
+                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;
         }
@@ -341,6 +372,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)
@@ -353,22 +385,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.
@@ -377,6 +418,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 });
@@ -392,7 +434,12 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
             continue;
         }
         try {
-            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) {
@@ -413,7 +460,17 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
         info(`[triage] auto-promote active: ${withinCap.length} accepts allowed this run`);
         for (const id of withinCap) {
             try {
-                await promoteFn({ stashDir: opts.stashDir, id });
+                await promoteFn({
+                    stashDir: opts.stashDir,
+                    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;
             }
@@ -447,7 +504,10 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
             promoteFn,
             rejectFn,
             seams: judgmentSeams,
+            ...(opts.target ? { target: opts.target } : {}),
+            ...(opts.config ? { config: opts.config } : {}),
             remainingAcceptBudget,
+            gateLabel,
         });
         result.promoted.push(...tier.promoted);
         result.rejected.push(...tier.rejected);
@@ -458,15 +518,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.