akm-cli 0.9.0-beta.2 → 0.9.0-beta.4

package/dist/commands/proposal/drain.js

@@ -46,7 +46,7 @@ import { runAgent } from "../../integrations/agent/index.js";
 import { runOpencodeSdk } from "../../integrations/harnesses/opencode-sdk/index.js";
 import { chatCompletion, stripJsonFences } from "../../llm/client.js";
 import { akmProposalAccept, akmProposalReject } from "./proposal.js";
-import { listProposals } from "./validators/proposals.js";
+import { listProposals, recordGateDecision } from "./validators/proposals.js";
 // ---------------------------------------------------------------------------
 // Content helpers
 // ---------------------------------------------------------------------------
@@ -78,7 +78,7 @@ export function classifyProposal(proposal, policy, maxDiffLines) {
     const content = proposal.payload.content ?? "";
     // Empty / near-empty diffs reject first (the reject-empty floor).
     if (policy.rejectEmpty && isEmptyDiff(proposal)) {
-        return { verdict: "reject", reason: "empty diff" };
+        return { verdict: "reject", reason: "empty diff", gate: { reason: "empty-diff" } };
     }
     const rule = policy.accept.find((r) => r.generator === proposal.source);
     if (rule) {
@@ -87,16 +87,25 @@ export function classifyProposal(proposal, policy, maxDiffLines) {
         // Per-rule and global diff bounds defer large accepts (no silent rewrites).
         const effectiveMax = Math.min(rule.maxDiffLines ?? Number.POSITIVE_INFINITY, maxDiffLines ?? Number.POSITIVE_INFINITY);
         if (lines > effectiveMax) {
-            return { verdict: "defer", reason: "mid-band" };
+            return {
+                verdict: "defer",
+                reason: "mid-band",
+                gate: { reason: "max-diff-lines", measured: lines, thresholds: { maxDiffLines: effectiveMax } },
+            };
         }
         if (rule.minContentLines !== undefined && body < rule.minContentLines) {
             // Too little content to confidently auto-accept — leave for judgment.
-            return { verdict: "defer", reason: "mid-band" };
+            return {
+                verdict: "defer",
+                reason: "mid-band",
+                gate: { reason: "min-content-lines", measured: body, thresholds: { minContentLines: rule.minContentLines } },
+            };
         }
-        return { verdict: "accept" };
+        return { verdict: "accept", gate: { reason: "policy-accept" } };
     }
     if (policy.defer.includes(proposal.source)) {
-        return { verdict: "defer", reason: deferReasonForSource(proposal.source) };
+        const reason = deferReasonForSource(proposal.source);
+        return { verdict: "defer", reason, gate: { reason } };
     }
     // No matching rule — leave pending, untouched.
     return null;
@@ -347,10 +356,31 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
     // First, classify every proposal deterministically.
     const acceptIds = [];
     const rejectTargets = [];
+    const gateLabel = `triage:${opts.policy.name}`;
+    // Items deferred purely because they need a judge (no threshold-based reason)
+    // — these are re-stamped `no-judge-configured` when no runner resolves them.
+    const needsJudge = new Set();
     for (const proposal of pending) {
         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,
+        });
+        // 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.
+        if (decision.verdict === "defer" && !decision.gate.thresholds) {
+            needsJudge.add(proposal.id);
+        }
         if (decision.verdict === "accept") {
             acceptIds.push(proposal.id);
         }
@@ -434,14 +464,51 @@ 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.
         result.deferred = tier.stillDeferred;
     }
+    else if (result.deferred.length > 0) {
+        // #577: no judgment runner configured — items deferred *because they need a
+        // judge* (mid-band / possible-dup, no threshold reason) stay pending solely
+        // for lack of one. Re-stamp those as `no-judge-configured` so the operator
+        // sees a per-proposal reason instead of inferring it from the run-level
+        // triage_deferred aggregate. Band-deferred items keep their specific reason
+        // (e.g. `max-diff-lines`), which is more actionable than "no judge".
+        for (const item of result.deferred) {
+            if (needsJudge.has(item.id)) {
+                stampGateDecision(opts, item.id, { outcome: "deferred", reason: "no-judge-configured", gate: gateLabel });
+            }
+        }
+    }
     emitDrainEvents(opts, result);
     return result;
 }
+/**
+ * Persist a gate decision onto a proposal, honouring the dry-run contract
+ * (a dry run performs zero writes, so it records nothing) and never letting a
+ * persistence failure abort the drain (#577). Best-effort by design.
+ */
+function stampGateDecision(opts, id, decision) {
+    if (opts.dryRun)
+        return;
+    try {
+        recordGateDecision(opts.stashDir, id, decision);
+    }
+    catch (err) {
+        warn(`[triage] failed to record gate decision for ${id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 // ---------------------------------------------------------------------------
 // Events
 // ---------------------------------------------------------------------------

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

@@ -16,6 +16,8 @@ import { resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
 import { resolveTriageJudgmentRunner } from "../../integrations/agent/runner.js";
+import { installLlmUsagePersistenceIfAbsent } from "../../llm/usage-persist.js";
+import { withLlmStage } from "../../llm/usage-telemetry.js";
 import { resolveImproveProfile } from "../improve/improve-profiles.js";
 import { drainProposals } from "./drain.js";
 import { resolveDrainPolicy } from "./drain-policies.js";
@@ -407,16 +409,26 @@ const proposalDrainCommand = defineJsonCommand({
         // nothing is configured → the engine leaves deferred items unresolved and
         // emits triage_deferred.
         const judgment = args.judgment === true ? resolveTriageJudgmentRunner(triageConfig?.judgment, cfg) : null;
-        const result = await drainProposals({
-            stashDir,
-            policy,
-            applyMode,
-            maxAccepts,
-            dryRun,
-            ...(maxDiffLines !== undefined ? { maxDiffLines } : {}),
-            ...(excludeIds ? { excludeIds } : {}),
-            judgment,
-        });
+        // #576: persist + attribute per-call LLM usage for the standalone drain
+        // path. `IfAbsent` keeps an enclosing `akm improve` sink in charge when
+        // drain runs as a sub-step; the disposer clears only a sink we installed.
+        const disposeDrainUsageSink = installLlmUsagePersistenceIfAbsent();
+        let result;
+        try {
+            result = await withLlmStage("drain", () => drainProposals({
+                stashDir,
+                policy,
+                applyMode,
+                maxAccepts,
+                dryRun,
+                ...(maxDiffLines !== undefined ? { maxDiffLines } : {}),
+                ...(excludeIds ? { excludeIds } : {}),
+                judgment,
+            }));
+        }
+        finally {
+            disposeDrainUsageSink();
+        }
         output("proposal-drain", {
             schemaVersion: 1,
             ok: true,

package/dist/commands/proposal/proposal.js

@@ -22,6 +22,17 @@ function resolveStash(stashDir) {
         return stashDir;
     return resolveStashDir();
 }
+/**
+ * Thin in-process read of the pending proposal queue, used by the health HTML
+ * report builder (#582) so it never shells out to `akm proposal list`.
+ *
+ * Deliberately narrow (one optional arg, returns the storage-layer rows) so
+ * the parallel proposal-storage-to-SQLite consolidation only has to swap this
+ * one function's body.
+ */
+export function listPendingProposals(stashDir) {
+    return listProposals(resolveStash(stashDir), { status: "pending" });
+}
 export function akmProposalList(options = {}) {
     const stash = resolveStash(options.stashDir);
     // `--status accepted|rejected|reverted` implies archive-inclusion since the
@@ -141,7 +152,7 @@ export function akmProposalCreate(options) {
  *     (raised by `resolveProposalId` / `getProposal`).
  *   - Proposal is not `status === "accepted"` → `UsageError("INVALID_FLAG_VALUE")`
  *     with message `"only accepted proposals can be reverted ..."`.
- *   - No `backup` field, or the backup file is missing on disk →
+ *   - No backup content on the record (new-asset proposals capture none) →
  *     `UsageError` with message `"no backup available for this proposal ..."`.
  *
  * On success, emits a `proposal_reverted` event for observability, mirroring