akm-cli 0.9.17-alpha.8 → 0.9.17

package/dist/commands/improve/stage.js

@@ -90,7 +90,6 @@ const STAGE_LABELS = {
     consolidate: "consolidate",
     extract: "session-extraction",
     memoryInference: "memory-inference",
-    graphExtraction: "graph-extraction",
     validation: "validation",
 };
 export function attributeStage(plan, process, fn) {

package/dist/commands/lint/base-linter.js

@@ -204,12 +204,14 @@ export function refExistsInAnyStash(relPath, refType, refName, stashRoots) {
         if (resolveRefPathInStash(relPath, refType, refName, root) !== null)
             return true;
     }
-    // #884: a memory pruned by `analyzeMemoryCleanup` was ARCHIVED, not deleted —
-    // its bytes and identity live on under `.akm/memory-cleanup/archive`. Inbound
-    // belief edges to it are satisfied, not dangling, so resolve the tombstone
-    // rather than reporting `missing-ref`. Checked only after every live location
-    // misses: a tombstone must never shadow a real file, and the scan then costs
-    // one directory read per root instead of one per ref.
+    // #884: an asset `analyzeMemoryCleanup` pruned, or (alpha.9) a consolidate
+    // pair-pass `retire` proposal or a promotion's source memory retired, was
+    // ARCHIVED, not deleted — its bytes and identity live on under
+    // `.akm/memory-cleanup/archive`. Inbound refs to it are satisfied, not
+    // dangling, so resolve the tombstone rather than reporting `missing-ref`.
+    // Checked only after every live location misses: a tombstone must never
+    // shadow a real file, and the scan then costs one directory read per root
+    // instead of one per ref.
     //
     // Existence ONLY. `resolveRefPathInStash` deliberately does NOT consult the
     // archive: it hands back a path callers MUTATE (SPEC-5 `--supersedes`
@@ -231,13 +233,19 @@ function refPathCandidates(refType, typeDir, refName) {
     return [...candidates, assetPathForName(refType, typeDir, `${refName}${DERIVED_SUFFIX}`)];
 }
 /**
- * True when `(refType, refName)` names a memory that prune archived in any
- * root. Mirrors `resolveRefPathInStash`'s candidate set so a ref that resolved
- * through the `.derived.md` child (#882) still resolves once archived.
+ * True when `(refType, refName)` names an asset the cleanup archive holds a
+ * tombstone for, in any root. Mirrors `resolveRefPathInStash`'s candidate set
+ * so a memory ref that resolved through the `.derived.md` child (#882) still
+ * resolves once archived.
+ *
+ * Originally memory-only (#884: only `.derived` memories were ever pruned).
+ * 0.9.17-alpha.9 generalized `archiveCleanupCandidate` to any memory,
+ * knowledge or lesson file (a consolidate pair-pass `retire` proposal, or an
+ * accepted promotion's source memory), so this must check every type, not
+ * just `memory` — otherwise an xref to a retired knowledge or lesson asset
+ * reports `missing-ref` even though it resolves fine through the tombstone.
  */
 function memoryArchiveHasRef(refType, refName, stashRoots) {
-    if (refType !== "memory")
-        return false; // only memories are ever archived
     const typeDir = stashDirFor(refType);
     if (typeDir === undefined)
         return false;

package/dist/commands/proposal/drain.js

@@ -29,7 +29,7 @@ import { buildExecution, resolveExecution } from "../../integrations/agent/execu
 import { assertRunnerCredentials, runExecution, } from "../../integrations/agent/runner-dispatch.js";
 import { errMessage, noticeSet } from "../improve/stage.js";
 import { akmProposalAccept, akmProposalReject } from "./proposal.js";
-import { STALE_TARGET_GATE_REASON } from "./proposal-types.js";
+import { isRetireProposal, STALE_TARGET_GATE_REASON } from "./proposal-types.js";
 import { listProposals, listProposalsReadOnly, preflightProposalPromotion, proposalContent, proposalContentHash, readFreshProposalTarget, recordGateDecision, } from "./repository.js";
 /** The gate label on every decision the drain records. */
 const DRAIN_GATE = "triage";
@@ -305,6 +305,13 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
     const accepts = [];
     const empties = [];
     for (const proposal of pending) {
+        // A consolidate pair-pass `retire` proposal is never auto-decided here,
+        // whatever `applyMode` says (alpha.9 brief §A "Review"; spec §25.6):
+        // untouched, still pending, waiting for a direct `akm proposal accept`.
+        // Checked before isEmptyDiff, which reads proposalContent() and has
+        // nothing meaningful to read on a delete-primary change anyway.
+        if (isRetireProposal(proposal))
+            continue;
         const decision = proposal.gateDecision;
         // Another gate's rejection stands; a human-review deferral from the distill
         // quality gate is left for that human.

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

@@ -89,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);
@@ -97,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);
@@ -149,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,
@@ -158,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) {

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

@@ -9,6 +9,8 @@ export const PROPOSAL_SOURCES = [
     "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",
     "feedback",
@@ -23,6 +25,7 @@ export const AUTOMATED_PROPOSAL_SOURCES = [
     "reflect",
     "distill",
     "consolidate",
+    "consolidate-pair",
     "extract",
     "improve",
     "schema-repair",
@@ -33,6 +36,10 @@ export function isValidProposalSource(source) {
 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";

package/dist/commands/proposal/proposal.js

@@ -15,6 +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 { 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 ──────────────────────────────────────────────────────────
@@ -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 });
@@ -161,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
@@ -170,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;
         }
@@ -186,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) {
@@ -198,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 };
 }