akm-cli 0.9.16 → 0.9.17-alpha.10

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) {
@@ -90,6 +89,10 @@ const proposalListCommand = defineJsonCommand({
         },
         ref: { type: "string", description: "Filter by asset ref ([bundle//]conceptId, e.g. knowledge/guide.md)" },
         type: { type: "string", description: "Filter by asset type" },
+        generator: {
+            type: "string",
+            description: "Filter by generator/source (e.g. reflect, distill, consolidate-pair) — same value accept/reject --generator take.",
+        },
     },
     run({ args }) {
         const status = parseProposalStatus(args.status);
@@ -98,6 +101,7 @@ const proposalListCommand = defineJsonCommand({
             status,
             ref: args.ref,
             type: args.type,
+            generator: args.generator,
             includeArchive: status === "accepted" || status === "rejected" || status === "reverted",
         });
         output("proposal-list", result);
@@ -150,7 +154,7 @@ const proposalAcceptCommand = defineJsonCommand({
                 return;
             }
             const { maxDiffLines, olderThanMs } = parseBulkFilterFlags(args);
-            const { count, results } = await bulkAdjudicateProposals({
+            const { count, results, skippedForContinuityRisk } = await bulkAdjudicateProposals({
                 action: "accept",
                 generator,
                 maxDiffLines,
@@ -159,7 +163,16 @@ const proposalAcceptCommand = defineJsonCommand({
                 queue: args.queue,
                 target: args.target,
             });
-            output("proposal-accept-batch", { accepted: count, results, dryRun: args["dry-run"] });
+            output("proposal-accept-batch", {
+                accepted: count,
+                results,
+                // S4: how many otherwise-matching proposals were skipped specifically
+                // because they carry retirement.continuityRisk — visible under
+                // --dry-run and on a real run alike, distinct from an ordinary
+                // --max-diff-lines/--older-than miss.
+                skippedForContinuityRisk,
+                dryRun: args["dry-run"],
+            });
             return;
         }
         if (!args.id) {
@@ -323,13 +336,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 +354,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 +370,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 +383,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 +446,9 @@ const proposalDrainCommand = defineJsonCommand({
             result = await withLlmStage("drain", () => drainProposals({
                 stashDir,
                 config: cfg,
-                policy,
                 applyMode,
                 maxAccepts,
                 dryRun,
-                ...(maxDiffLines !== undefined ? { maxDiffLines } : {}),
                 ...(excludeIds ? { excludeIds } : {}),
                 judgment,
             }));
@@ -461,7 +461,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,56 +1,63 @@
 // 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",
+    /** The consolidate pair pass's own retire proposals (alpha.9, S6) — kept apart from `consolidate`'s promotions so a bulk `accept --generator consolidate` never sweeps a retirement, and the reverse. */
+    "consolidate-pair",
     "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",
     "consolidate",
+    "consolidate-pair",
     "extract",
     "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);
 }
+/** A pending or accepted proposal whose primary change deletes its target (a consolidate retire proposal, alpha.9). */
+export function isRetireProposal(proposal) {
+    return proposal.changes[0]?.op === "delete";
+}
+/** 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,
+]);
+/**
+ * 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 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,8 @@ 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 { isRetireProposal } from "./proposal-types.js";
+import { diffProposal, listProposals, preflightProposalPromotion, promoteProposal, proposalContent, rejectProposalDurably, resolveProposalId, revertProposal, } from "./repository.js";
 import { validateProposal } from "./validators/proposals.js";
 // ── Shared helpers ──────────────────────────────────────────────────────────
 function resolveStash(stashDir) {
@@ -55,7 +56,7 @@ export function akmProposalList(options = {}) {
         status: options.status,
         ref: options.ref,
         type: options.type,
-    });
+    }).filter((p) => options.generator === undefined || p.source === options.generator);
     return { schemaVersion: 1, totalCount: proposals.length, proposals };
 }
 export function akmProposalShow(options) {
@@ -64,9 +65,13 @@ export function akmProposalShow(options) {
     const proposal = resolveProposalId(stash, options.id);
     let validation = validateProposal(proposal);
     // An explicit stashDir without config is an in-process storage test seam; it
-    // has no authenticated write-target context to preflight against.
+    // has no authenticated write-target context to preflight against. A retire
+    // proposal writes no content — preflightProposalPromotion's stamp/lint
+    // machinery is create/update-shaped and has nothing meaningful to check
+    // here; `diff` already shows the body being retired.
     if (validation.ok &&
         proposal.status === "pending" &&
+        !isRetireProposal(proposal) &&
         (options.config !== undefined || options.stashDir === undefined)) {
         try {
             preflightProposalPromotion(options.config ?? loadConfig(), proposal, { queueTarget: queue.target });
@@ -104,7 +109,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,
@@ -162,6 +166,16 @@ export async function akmProposalRevert(options) {
         proposal: result.proposal,
     };
 }
+/** The retired file's current line count for `--max-diff-lines` (S6); unresolvable is never size-filtered here — the real accept/reject attempt fails cleanly on a genuinely stale target. */
+function retiredTargetLineCount(stashDir, config, proposal, queueTarget) {
+    try {
+        const existing = diffProposal(stashDir, config, proposal.id, { queueTarget }).existing;
+        return existing === null ? 0 : existing.split("\n").length;
+    }
+    catch {
+        return 0;
+    }
+}
 /**
  * Bulk accept/reject every pending proposal from one generator, applying the
  * shared `--max-diff-lines` / `--older-than` filters. Consolidates the two
@@ -171,12 +185,21 @@ export async function akmProposalRevert(options) {
  */
 export async function bulkAdjudicateProposals(options) {
     const config = options.config ?? loadConfig();
-    const { stashDir } = resolveProposalQueue(options.stashDir, options.queue, config);
-    const pending = listProposals(stashDir, { status: "pending" }).filter((p) => {
+    const { stashDir, target: queueTarget } = resolveProposalQueue(options.stashDir, options.queue, config);
+    // Every filter EXCEPT the continuityRisk exclusion below — matched against
+    // separately so its own count (S4) can be reported apart from an ordinary
+    // --max-diff-lines/--older-than miss.
+    const matched = listProposals(stashDir, { status: "pending" }).filter((p) => {
         if (p.source !== options.generator)
             return false;
         if (options.maxDiffLines !== undefined) {
-            const lines = proposalContent(p).split("\n").length;
+            // S6: a retire proposal's own payload is empty (it deletes its
+            // target) — proposalContent() would always read as 1 line, so
+            // --max-diff-lines could never filter one out. Count the retired
+            // file's own current line count instead.
+            const lines = isRetireProposal(p)
+                ? retiredTargetLineCount(stashDir, config, p, queueTarget)
+                : proposalContent(p).split("\n").length;
             if (lines > options.maxDiffLines)
                 return false;
         }
@@ -187,6 +210,13 @@ export async function bulkAdjudicateProposals(options) {
         }
         return true;
     });
+    // Item 1 (continuity check, alpha.9 plan §5.4, rule R3): a retire proposal
+    // the check flagged is never bulk-accepted, by generator or any other
+    // sweep — only a person accepting it by id can. Bulk reject is unaffected:
+    // declining a risky proposal is never the unsafe direction.
+    const isContinuityExcluded = (p) => options.action === "accept" && Boolean(p.retirement?.continuityRisk);
+    const skippedForContinuityRisk = matched.filter(isContinuityExcluded).length;
+    const pending = matched.filter((p) => !isContinuityExcluded(p));
     const results = [];
     for (const proposal of pending) {
         if (options.dryRun) {
@@ -199,5 +229,5 @@ export async function bulkAdjudicateProposals(options) {
             results.push(await akmProposalReject({ stashDir, id: proposal.id, queue: options.queue, reason: options.reason, config }));
         }
     }
-    return { count: results.length, results };
+    return { count: results.length, results, skippedForContinuityRisk };
 }