akm-cli 0.9.7 → 0.9.8-beta.2

package/dist/commands/health.js

@@ -7,7 +7,6 @@ import { resolveStashDir } from "../core/common.js";
 import { loadConfig } from "../core/config/config.js";
 import { ConfigError, UsageError } from "../core/errors.js";
 import { readEvents } from "../core/events.js";
-import { listTxnJournalsTolerant, TXN_SWEEP_GRACE_MS } from "../core/fs-txn.js";
 import { openLogsDatabase } from "../core/logs-db.js";
 import { classifyPathAccess, describeInaccessiblePath } from "../core/path-access.js";
 import { getConfigPath, getDataDir, getDbPath, getStateDbPathInDataDir } from "../core/paths.js";
@@ -19,6 +18,7 @@ import { queryTaskHistory } from "../storage/repositories/task-history-repositor
 import { pkgVersion } from "../version.js";
 import { collectImproveAdvisories } from "./health/advisories.js";
 import { HEALTH_CHECKS, runHealthEngineProbes } from "./health/checks.js";
+import { collectDataDirUsageAdvisory } from "./health/data-dir-usage.js";
 import { buildImproveSkipSummary, computeWallTimeStats, isAgentTaskHistoryRow, roundRate, summarizeImproveCompleted, summarizeImproveRuns, taskFailureDetail, } from "./health/improve-metrics.js";
 import { emptyLlmUsageAggregate, readLlmUsageAggregate } from "./health/llm-usage.js";
 import { computeDegradationMetrics, computeDenominatorFixedCoverage, computeEnrichmentMintingRollup, probeStateDbRoundTrip, } from "./health/metrics.js";
@@ -150,37 +150,6 @@ function gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now) {
         agentFailureRate,
     };
 }
-/**
- * Item 4: leftover durable-transaction journals under `$DATA/txn` (stranded
- * recovery state seen twice in a real 0.9 migration) had zero health
- * visibility. Uses the tolerant scan variant so one corrupt journal.json is
- * counted rather than aborting the whole gather; a journal younger than
- * {@link TXN_SWEEP_GRACE_MS} is presumed to belong to a currently-running
- * operation and is not counted as stale. Best-effort: any unexpected error
- * (e.g. a permissions issue under `$DATA/txn`) degrades to "no signal" rather
- * than aborting the health report.
- */
-function gatherStaleTxnJournalsPhase(now) {
-    const dir = path.join(getDataDir(), "txn");
-    try {
-        const { matches, unreadableMtimes } = listTxnJournalsTolerant(() => true);
-        const nowMs = now();
-        const staleAges = [
-            ...matches.map((m) => nowMs - m.mtimeMs),
-            ...unreadableMtimes.map((mtimeMs) => nowMs - mtimeMs),
-        ].filter((ageMs) => ageMs >= TXN_SWEEP_GRACE_MS);
-        const staleUnreadableCount = unreadableMtimes.filter((mtimeMs) => nowMs - mtimeMs >= TXN_SWEEP_GRACE_MS).length;
-        return {
-            dir,
-            count: staleAges.length,
-            oldestAgeMs: staleAges.length > 0 ? Math.max(...staleAges) : null,
-            unreadable: staleUnreadableCount,
-        };
-    }
-    catch {
-        return { dir, count: 0, oldestAgeMs: null, unreadable: 0 };
-    }
-}
 /**
  * Config fields the surfaces advisory needs. Best-effort: an unloadable
  * config leaves the field undefined and the caller falls back to a generic
@@ -229,9 +198,10 @@ function gatherImproveSummaryPhase(db, stateDbPath, since, now) {
     return { improveSummary, perRunSummaries };
 }
 /**
- * The four best-effort advisory groups beyond the health-check registry:
- * improve advisories, the `stash-git-exposure` probe, the 08 surfaces group
- * (binary-config-skew, egress-endpoints), and `plugin-version` (itlackey/akm#832).
+ * The best-effort advisory groups beyond the health-check registry: improve
+ * advisories, the `stash-git-exposure` probe, the 08 surfaces group
+ * (binary-config-skew, egress-endpoints), `type-directory-disagreement`
+ * (#831), `data-dir-usage` (#896), and `plugin-version` (itlackey/akm#832).
  * Order matches emission order in the returned array. A probe/filesystem
  * failure in any try/catch must not abort the health report — each group
  * degrades to "no advisory" independently.
@@ -283,6 +253,19 @@ function gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, optio
     catch {
         // Non-fatal.
     }
+    // #896: report the data dir's total size and its largest top-level
+    // subdirectory, so a disk-usage blowup (e.g. unpruned migration snapshot
+    // backups, #897) is self-diagnosing instead of requiring `du` archaeology.
+    // Best-effort — an unreadable/missing data dir must not abort the health
+    // report.
+    try {
+        const dataDirUsage = collectDataDirUsageAdvisory(getDataDir());
+        if (dataDirUsage)
+            advisories.push(dataDirUsage);
+    }
+    catch {
+        // Non-fatal.
+    }
     // itlackey/akm#832: report installed Claude Code harness plugin version(s)
     // and warn when stale or when the plugin's own akm-cli version range no
     // longer admits this CLI. Best-effort — no plugin installed, an unreadable
@@ -512,7 +495,6 @@ export function akmHealth(options = {}) {
     try {
         const taskHistory = gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now);
         const { tableNames, missingTables, probe } = taskHistory;
-        const staleTxnJournals = gatherStaleTxnJournalsPhase(now);
         const { egressConfigView } = gatherEgressConfigPhase();
         const { improveSummary } = gatherImproveSummaryPhase(db, stateDbPath, since, now);
         advisories.push(...gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, options, egressConfigView));
@@ -535,7 +517,6 @@ export function akmHealth(options = {}) {
             stuckActiveRuns: taskHistory.stuckActiveRuns,
             stuckActiveTasks: taskHistory.stuckActiveTasks,
             worstTaskFailRate: taskHistory.worstTaskFailRate,
-            staleTxnJournals,
             sessionExtraction: improveSummary.sessionExtraction,
             autoAccept: improveSummary.autoAccept,
             engineProbes,

package/dist/commands/improve/consolidate/eligibility.js

@@ -18,8 +18,8 @@ export function isConsolidationEligibleMemoryName(name) {
  *
  * Reads the file once per check; consolidate runs against ~10 memories per
  * chunk so the IO cost is trivial. Returns false on any read/parse error
- * (fail-safe: an unparseable file is treated as not-hot, but the broader
- * consolidate flow already guards against unparseable memories elsewhere).
+ * (fail-safe: an unreadable or unparseable file is treated as HOT — protected
+ * — because a deletion shield must not fail open; a missing file is not-hot).
  *
  * Defends against four observed defect classes (see
  * `memories/akm-improve-critical-review-2026-05-20`):
@@ -29,14 +29,20 @@ export function isConsolidationEligibleMemoryName(name) {
  *   - Cascade deletes (LLM uses ref:X as `contradictedBy` for ref:Y then deletes both)
  */
 export function isHotCapturedMemory(filePath) {
+    if (!fs.existsSync(filePath))
+        return false;
     try {
-        if (!fs.existsSync(filePath))
-            return false;
         const content = fs.readFileSync(filePath, "utf8");
         const parsed = parseFrontmatter(content);
         return hasHotCaptureMode(parsed.data);
     }
     catch {
-        return false;
+        // Fail CLOSED. This predicate is a deletion shield: "hot" memories are
+        // protected from consolidate's merge/delete. Returning false on a read or
+        // parse failure marked exactly the memories we could not inspect as fair
+        // game — the one direction a protection check must never fail. A missing
+        // file stays false (nothing to protect); an unreadable one is protected
+        // until someone can actually read it.
+        return true;
     }
 }

package/dist/commands/improve/extract.js

@@ -632,8 +632,40 @@ function unavailableExtractionResult(args) {
         ...args.notices,
     };
 }
+// #561 — ADDITIVE session indexing. Generate + write the session asset
+// (`sessions/<harness>/<id>.md`). FAIL-OPEN: any failure only returns a
+// warning; it NEVER changes the proposal/skip outcome of extract. Returns the
+// frontmatter fields to merge into the per-session result for state-db
+// correlation. When disabled this makes NO LLM call and writes NOTHING.
+async function maybeWriteSessionAsset(runCtx, session) {
+    const { stashDir, lease, sessionIndexing, dryRun } = runCtx;
+    const { data } = session.gate;
+    if (!sessionIndexing.enabled || dryRun)
+        return {};
+    if (!sessionMeetsDurationGate(data, sessionIndexing.minDurationMinutes))
+        return {};
+    try {
+        const result = await writeSessionAsset(data, stashDir, (summaryData) => sessionIndexing.generate(summaryData, lease));
+        if (result.written) {
+            // Write-path indexing (itself fail-open): standalone `akm extract`
+            // (session-end hook) has no post-loop reindex to pick this file up.
+            if (result.filePath)
+                await indexWrittenAssets(stashDir, [result.filePath]);
+            return {
+                ...(result.ref ? { sessionAssetRef: result.ref } : {}),
+                ...(result.logPath ? { sessionLogPath: result.logPath } : {}),
+            };
+        }
+    }
+    catch (err) {
+        if (err instanceof ConfigError)
+            throw err;
+        return { warning: `session asset write failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    return {};
+}
 async function processSession(runCtx, session) {
-    const { harness, stashDir, config, llmRunner, lease, onNotices, getNotices, chat, ctx, eventsCtx, sourceRun, dryRun, timeoutMs, sessionIndexing, signal, standardsContext, } = runCtx;
+    const { harness, stashDir, config, llmRunner, lease, onNotices, getNotices, chat, ctx, eventsCtx, sourceRun, dryRun, timeoutMs, signal, standardsContext, } = runCtx;
     const { sessionRef, gate } = session;
     const warnings = [];
     const { data, filtered, contentHash } = gate;
@@ -645,36 +677,6 @@ async function processSession(runCtx, session) {
         inlineRefs: data.inlineRefs,
         ...(standardsContext.trim() ? { standardsContext } : {}),
     });
-    // #561 — ADDITIVE session indexing. Generate + write the session asset
-    // (`sessions/<harness>/<id>.md`). FAIL-OPEN: any failure only records a
-    // warning; it NEVER changes the proposal/skip outcome of extract. Returns the
-    // frontmatter fields to merge into the per-session result for state-db
-    // correlation. When disabled this closure makes NO LLM call and writes NOTHING.
-    const maybeWriteSessionAsset = async () => {
-        if (!sessionIndexing.enabled || dryRun)
-            return {};
-        if (!sessionMeetsDurationGate(data, sessionIndexing.minDurationMinutes))
-            return {};
-        try {
-            const result = await writeSessionAsset(data, stashDir, (summaryData) => sessionIndexing.generate(summaryData, lease));
-            if (result.written) {
-                // Write-path indexing (itself fail-open): standalone `akm extract`
-                // (session-end hook) has no post-loop reindex to pick this file up.
-                if (result.filePath)
-                    await indexWrittenAssets(stashDir, [result.filePath]);
-                return {
-                    ...(result.ref ? { sessionAssetRef: result.ref } : {}),
-                    ...(result.logPath ? { sessionLogPath: result.logPath } : {}),
-                };
-            }
-        }
-        catch (err) {
-            if (err instanceof ConfigError)
-                throw err;
-            warnings.push(`session asset write failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        return {};
-    };
     const extraction = await runSessionExtractionLlmCall({
         config,
         llmRunner,
@@ -708,7 +710,9 @@ async function processSession(runCtx, session) {
     const { payload } = extraction;
     const proposalIds = [];
     // Provenance refs are added only after the cited session asset exists.
-    const sessionAsset = await maybeWriteSessionAsset();
+    const sessionAsset = await maybeWriteSessionAsset(runCtx, session);
+    if (sessionAsset.warning)
+        warnings.push(sessionAsset.warning);
     if (payload.candidates.length === 0) {
         appendEvent({
             eventType: "extract_invoked",

package/dist/commands/improve/memory/memory-belief.js

@@ -52,10 +52,17 @@ function readEdgeList(value) {
  * Write `contradictedBy` and `beliefState: contradicted` edges to a memory
  * file's frontmatter (C-3 / #382).
  *
- * This is the shared primitive used by:
- *   - `akmConsolidate` when its LLM plan includes a `contradict` op
- *   - `memory-contradiction-detect.ts` for the M-1 automated contradiction pass
- *   - `resolveFamilyContradictions` in `memory-improve.ts` for SCC resolution
+ * The shared primitive for APPENDING one contradiction edge. Used by
+ * `memory-contradiction-detect.ts`'s automated contradiction pass.
+ *
+ * NOT used by `persistBeliefStateTransition` in `memory-improve.ts`, and that
+ * is deliberate (#885): the SCC resolver is a state-TRANSITION writer, not an
+ * edge appender. It replaces `contradictedBy` wholesale from recomputed
+ * `currentBeliefRefs`, deletes the key when a memory transitions away from
+ * `contradicted`, and moves a memory to any target state including back to
+ * active. An append-only primitive that never weakens a demotion cannot
+ * express those, and routing it through this would break the resolver's
+ * ability to clear an edge.
  *
  * Idempotent: if the `contradictedByRef` is already in `contradictedBy` AND
  * the file already carries the demotion state, the file is not rewritten. The
@@ -72,9 +79,12 @@ function readEdgeList(value) {
  *
  * @param filePath          - Absolute path to the memory markdown file.
  * @param contradictedByRef - The ref that contradicts this memory.
+ * @returns `true` when the file was rewritten, `false` when the edge and the
+ *          demotion were already present (the idempotent no-op). Callers count
+ *          edges written from this.
  */
 export function writeContradictEdge(filePath, contradictedByRef) {
-    mutateFrontmatter(filePath, (parsed) => {
+    return mutateFrontmatter(filePath, (parsed) => {
         const existing = readEdgeList(parsed.data.contradictedBy);
         const currentState = parsed.data.beliefState;
         const nextState = currentState === "archived" ? currentState : "contradicted";

package/dist/commands/improve/memory/memory-contradiction-detect.js

@@ -17,8 +17,19 @@
  *   2. For each family, enumerate candidate pairs.
  *   3. For each pair, call the LLM to judge whether the two memories are in
  *      direct factual conflict.
- *   4. For confirmed contradictions, write `contradictedBy` edges directly to
- *      the losing memory's frontmatter (same mechanism as `persistBeliefStateTransition`).
+ *   4. For confirmed contradictions, append a `contradictedBy` edge to the
+ *      losing memory's frontmatter via `writeContradictEdge`
+ *      (`./memory-belief.ts`).
+ *
+ * That last step used to call a private near-copy of `writeContradictEdge`
+ * living in this file. The copy had drifted (#885): it read `contradictedBy`
+ * with `Array.isArray` only, so a SCALAR edge — live data the indexer accepts
+ * and lint never flags — read as "no edges" and was overwritten out of
+ * existence; and it set `beliefState: "contradicted"` unconditionally,
+ * promoting an `archived` memory back up (archived ranks BELOW contradicted).
+ * Both behaviors had tests, but the tests exercised the shared primitive,
+ * which nothing called — so they guarded dead code while the live path
+ * carried the bugs.
  *
  * # LLM Feature Gate
  *
@@ -36,12 +47,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import contradictionJudgeTemplate from "../../../assets/prompts/contradiction-judge.md" with { type: "text" };
-import { mutateFrontmatter, parseFrontmatter } from "../../../core/asset/frontmatter.js";
+import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
 import { parseEmbeddedJsonResponse } from "../../../core/parse.js";
 import { disposeLoweredExecutionDispatchLease } from "../../../integrations/agent/execution-lowering.js";
 import { callStructured, preflightStructuredLlmRunner } from "../../../llm/structured-call.js";
 import { resolveImproveLlmExecution } from "../execution.js";
 import { isDerivedMemory, memoryIdentityRef, resolveParentRef } from "./derived-ref.js";
+import { writeContradictEdge } from "./memory-belief.js";
 // ── Constants ────────────────────────────────────────────────────────────────
 /**
  * Minimum confidence required to write a contradiction edge. Below this
@@ -89,27 +101,6 @@ function toMemoryRef(memoriesDir, filePath) {
     return memoryIdentityRef(name);
 }
 // ── Edge writing ─────────────────────────────────────────────────────────────
-/**
- * Write a `contradictedBy` edge to the losing memory's frontmatter file.
- * Preserves all existing frontmatter keys; only adds/updates `contradictedBy`
- * and `beliefState: contradicted`.
- */
-/** Returns true if the edge was newly written, false if it already existed. */
-function writeContradictedByEdge(filePath, contradictedByRef) {
-    return mutateFrontmatter(filePath, (parsed) => {
-        const existing = Array.isArray(parsed.data.contradictedBy)
-            ? parsed.data.contradictedBy
-            : [];
-        if (existing.includes(contradictedByRef))
-            return null; // Edge already written.
-        const updatedContradictedBy = [...new Set([...existing, contradictedByRef])].sort();
-        return {
-            ...parsed.data,
-            contradictedBy: updatedContradictedBy,
-            beliefState: "contradicted",
-        };
-    });
-}
 /**
  * Deterministically pick, for a confirmed-contradiction pair, the LOSER memory
  * that receives the single directed `contradictedBy` edge (SCC-resolved to
@@ -284,7 +275,7 @@ export async function detectAndWriteContradictions(stashDir, config, chat, strat
             // a 2-cycle that the SCC resolver refreshes back to active, erasing the
             // contradiction every run (see pickContradictionLoser).
             try {
-                const wrote = writeContradictedByEdge(loser.filePath, winnerRef);
+                const wrote = writeContradictEdge(loser.filePath, winnerRef);
                 result.edgesWritten += wrote ? 1 : 0;
             }
             catch (err) {

package/dist/commands/improve/memory/memory-improve.js

@@ -9,7 +9,9 @@ import { MEMORY_ARCHIVE_REL } from "../../../core/asset/memory-archive.js";
 import { conceptIdFromTypeName } from "../../../core/asset/resolve-ref.js";
 import { asNonEmptyString, groupBy, stringArray } from "../../../core/common.js";
 import { DERIVED_SUFFIX } from "../../../core/recognition-util.js";
+import { warn } from "../../../core/warn.js";
 import { recordWrittenPath } from "../../../core/write-provenance.js";
+import { walkMarkdownFiles } from "../../../indexer/walk/walker.js";
 import { isDerivedMemory, memoryIdentityRef, parseMemoryName, resolveParentRef } from "./derived-ref.js";
 export function analyzeMemoryCleanup(stashDir, options = {}) {
     const records = collectDerivedMemories(stashDir, options.parentRef);
@@ -574,7 +576,11 @@ function collectDerivedMemories(stashDir, parentRefFilter) {
     if (!fs.existsSync(memoriesDir))
         return [];
     const records = [];
-    for (const filePath of walkMarkdownFiles(memoriesDir)) {
+    const walked = walkMarkdownFiles(memoriesDir);
+    if (!walked.complete) {
+        warn(`memory improve: directory scan under ${memoriesDir} is incomplete — some derived memories may be missing`);
+    }
+    for (const filePath of walked.files) {
         const name = toMemoryName(memoriesDir, filePath);
         if (!name)
             continue;
@@ -778,24 +784,6 @@ function firstNonEmpty(values) {
     }
     return undefined;
 }
-function* walkMarkdownFiles(root) {
-    let entries;
-    try {
-        entries = fs.readdirSync(root, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        const full = path.join(root, entry.name);
-        if (entry.isDirectory()) {
-            yield* walkMarkdownFiles(full);
-        }
-        else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
-            yield full;
-        }
-    }
-}
 function toMemoryName(memoriesDir, filePath) {
     const rel = path.relative(memoriesDir, filePath);
     if (!rel || rel.startsWith(".."))

package/dist/commands/improve/preparation.js

@@ -789,6 +789,14 @@ export async function runImprovePreparationStage(args) {
         snapshot,
         persist: !planOnly,
     });
+    const eligibilitySourceByRef = stampEligibilitySource({
+        scope,
+        processableRefs: gathered.processableRefs,
+        mergedRefs: gathered.mergedRefs,
+        signalFiltered: gathered.signalFiltered,
+        proactiveRefs: gathered.proactiveRefs,
+        highSalienceRefs: gathered.highSalienceRefs,
+    });
     // Shared admission boundary for every synthetic fallback lane. Cleanup and
     // structural validation are exclusive selectors: no later rank/replay state
     // may re-create a candidate they removed. Keep the exact surviving objects
@@ -800,7 +808,7 @@ export async function runImprovePreparationStage(args) {
         primaryStashDir,
         eventsCtx,
         mergedRefs: gathered.mergedRefs,
-        eligibilitySourceByRef: gathered.eligibilitySourceByRef,
+        eligibilitySourceByRef,
         feedbackSummary: gathered.feedbackSummary,
         retrievalCounts: gathered.retrievalCounts,
         signalFiltered: gathered.signalFiltered,
@@ -820,7 +828,7 @@ export async function runImprovePreparationStage(args) {
         eventsCtx,
         mergedRefs: scored.mergedRefs,
         salienceMap: scored.salienceMap,
-        eligibilitySourceByRef: gathered.eligibilitySourceByRef,
+        eligibilitySourceByRef,
         distillOnlyRefs: gathered.distillOnlyRefs,
         validationFailureRefs,
         summary: {
@@ -1054,7 +1062,9 @@ export function buildSnapshotManifest(args) {
 /**
  * Pass: candidate-gather — the signal-delta partition, the bulk feedback
  * summary, retrieval signals, the Layer-2 proactive and Layer-3 high-salience
- * rescue lanes, the merged candidate set, and lane attribution stamping.
+ * rescue lanes, and the merged candidate set. Lane attribution stamping is a
+ * separate pass — see `stampEligibilitySource` — run by the caller once
+ * `mergedRefs` is known.
  */
 function gatherCandidates(args) {
     const { scope, options, primaryStashDir, eventsCtx, improveProfile, resolvedPlan, postCleanupRefs, persist } = args;
@@ -1152,23 +1162,44 @@ function gatherCandidates(args) {
     // that want feedback-only runs.
     const signalAndRetrievalRefs = dedupeRefs([...signalFiltered, ...proactiveRefs, ...highSalienceRefs]);
     const mergedRefs = scope.mode === "ref" ? processableRefs : options.requireFeedbackSignal ? signalFiltered : signalAndRetrievalRefs;
-    // ── Attribution tagging: stamp each ref with the eligibility lane that
-    // selected it ──────────────────────────────────────────────────────────────
-    // Every reflect/distill proposal must record WHICH lane chose its source asset
-    // so downstream accept/reject/revert/retrieval outcomes can be sliced by lane
-    // (does the PROACTIVE lane produce value vs the reactive lanes?). We build the
-    // lane map here — the one place all three lanes are known — and stamp it onto
-    // each ImproveEligibleRef object. Because the ref objects are shared by
-    // reference across buckets, the stamp travels with the ref through the sort,
-    // disk-check, and loop stages down to the reflect/distill event emit sites and
-    // createProposal calls. See EligibilitySource for the lane vocabulary.
-    //
-    // Precedence (prefer the most specific reactive signal):
-    //   scope > signal-delta > proactive > high-salience
-    // A ref with real feedback is attributed to feedback even if it was also due
-    // for proactive maintenance or had high encoding salience. We apply lanes
-    // weakest-first so the strongest overwrites; the explicit --scope <ref> bypass
-    // wins outright (user intent).
+    return {
+        distillCooledRefs,
+        preCooldownCount,
+        distillOnlyRefs,
+        feedbackSummary,
+        signalFiltered,
+        signalBearingSet,
+        retrievalCounts,
+        proactiveRefs,
+        proactiveMaintenanceSummary,
+        proactivePlan: proactive.proactivePlan,
+        highSalienceRefs,
+        signalAndRetrievalRefs,
+        mergedRefs,
+        processableRefs,
+    };
+}
+/**
+ * Attribution tagging: stamp each ref with the eligibility lane that selected
+ * it. Every reflect/distill proposal must record WHICH lane chose its source
+ * asset so downstream accept/reject/revert/retrieval outcomes can be sliced by
+ * lane (does the PROACTIVE lane produce value vs the reactive lanes?). We
+ * build the lane map here — the one place all three lanes are known — and
+ * stamp it onto each ImproveEligibleRef object. Because the ref objects are
+ * shared by reference across buckets, the stamp travels with the ref through
+ * the sort, disk-check, and loop stages down to the reflect/distill event
+ * emit sites and createProposal calls. See EligibilitySource for the lane
+ * vocabulary.
+ *
+ * Precedence (prefer the most specific reactive signal):
+ *   scope > signal-delta > proactive > high-salience
+ * A ref with real feedback is attributed to feedback even if it was also due
+ * for proactive maintenance or had high encoding salience. We apply lanes
+ * weakest-first so the strongest overwrites; the explicit --scope <ref> bypass
+ * wins outright (user intent).
+ */
+function stampEligibilitySource(args) {
+    const { scope, processableRefs, mergedRefs, signalFiltered, proactiveRefs, highSalienceRefs } = args;
     const eligibilitySourceByRef = new Map();
     for (const r of highSalienceRefs)
         eligibilitySourceByRef.set(r.ref, "high-salience");
@@ -1188,22 +1219,7 @@ function gatherCandidates(args) {
         // mergedRefs is always a subset of the four lanes above).
         r.eligibilitySource = eligibilitySourceByRef.get(r.ref) ?? "unknown";
     }
-    return {
-        distillCooledRefs,
-        preCooldownCount,
-        distillOnlyRefs,
-        feedbackSummary,
-        signalFiltered,
-        signalBearingSet,
-        retrievalCounts,
-        proactiveRefs,
-        proactiveMaintenanceSummary,
-        proactivePlan: proactive.proactivePlan,
-        highSalienceRefs,
-        signalAndRetrievalRefs,
-        mergedRefs,
-        eligibilitySourceByRef,
-    };
+    return eligibilitySourceByRef;
 }
 /**
  * The signal-delta partition of postCleanupRefs into the four buckets (pass:

package/dist/commands/improve/reflect.js

@@ -133,27 +133,23 @@ export const REFLECT_ALLOWED_TYPES = new Set([
 const PROTECTED_FRONTMATTER_FIELDS = new Set(["name", "ref", "id", "slug", "type"]);
 /**
  * Read the last 1–3 archived rejected proposals for a given ref from the
- * proposal store. Best-effort — returns `[]` when the proposals dir is absent
- * or the ref is undefined. Used to inject Reflexion-style verbal-RL context
- * into the reflect prompt so the agent avoids re-proposing already-refused
- * content (arXiv:2303.11366).
+ * proposal store. Returns `[]` when the proposals store is absent (not yet
+ * created) or the ref is undefined — `listProposalsReadOnly` already handles
+ * that case; a genuine read failure propagates instead of being swallowed,
+ * since silently dropping this Reflexion-style context risks re-proposing
+ * content that was already rejected (arXiv:2303.11366).
  */
 function readRejectedProposals(stash, ref, proposalsCtx) {
     if (!ref)
         return [];
-    try {
-        return listProposalsReadOnly(stash, { ref, status: "rejected", includeArchive: true }, proposalsCtx)
-            .sort((a, b) => new Date(b.updatedAt ?? 0).getTime() - new Date(a.updatedAt ?? 0).getTime())
-            .slice(0, MAX_REJECTED_PROPOSALS)
-            .map((p) => ({
-            ref: p.ref,
-            reason: p.review?.reason ?? "no reason given",
-            contentPreview: proposalContent(p).slice(0, 500),
-        }));
-    }
-    catch {
-        return [];
-    }
+    return listProposalsReadOnly(stash, { ref, status: "rejected", includeArchive: true }, proposalsCtx)
+        .sort((a, b) => new Date(b.updatedAt ?? 0).getTime() - new Date(a.updatedAt ?? 0).getTime())
+        .slice(0, MAX_REJECTED_PROPOSALS)
+        .map((p) => ({
+        ref: p.ref,
+        reason: p.review?.reason ?? "no reason given",
+        contentPreview: proposalContent(p).slice(0, 500),
+    }));
 }
 /**
  * Synthesize a tmp draft-file path for the agent/sdk file-write contract.

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

@@ -36,10 +36,10 @@ import path from "node:path";
 import { isScalar, parseDocument } from "yaml";
 import { assetPathCandidatesForName, assetPathForName, stashDirFor } from "../../core/asset/asset-placement.js";
 import { BUNDLE_REF_RE } from "../../core/asset/asset-ref.js";
-import { removeFrontmatterListValues, spliceFrontmatterLine } from "../../core/asset/frontmatter.js";
+import { removeFrontmatterListValues, rewriteFrontmatterListValue, spliceFrontmatterLine, } from "../../core/asset/frontmatter.js";
 import { checkUnquotedDescriptionColon } from "../../core/asset/frontmatter-lint.js";
 import { isArchivedRelPath } from "../../core/asset/memory-archive.js";
-import { typeNameFromConceptId } from "../../core/asset/resolve-ref.js";
+import { conceptIdFromTypeName, typeNameFromConceptId } from "../../core/asset/resolve-ref.js";
 import { localDateStamp } from "../../core/common.js";
 import { findFenceRegions } from "./markdown-insertion.js";
 // ── Helpers ───────────────────────────────────────────────────────────────────
@@ -786,6 +786,46 @@ function runMissingRefChecks(ctx, raw, shouldRun, pendingFixes) {
                 const values = readRefStringOrArray(ctx.data?.[key]);
                 if (values === null)
                     continue;
+                // `lint --fix` migration for the retired `type:slug` xref grammar
+                // (see legacyTypeSlugParts): rewrite a value to its conceptId form
+                // ONLY when the rewritten spelling still resolves to a real asset —
+                // a dangling legacy ref must stay reported as `missing-ref` in its
+                // original spelling, never rewritten into a differently-spelled
+                // dangling ref. Runs before the missing-ref scan below so a value
+                // this loop rewrites is checked (and reported, if still dangling)
+                // under its ORIGINAL spelling by that scan, and never double-fixed.
+                if (ctx.fix) {
+                    const legacyRewrites = new Map();
+                    for (const raw of values) {
+                        const value = raw.trim();
+                        const parts = legacyTypeSlugParts(value);
+                        if (parts === undefined)
+                            continue;
+                        const relPath = refToRelPath(parts.type, parts.name);
+                        if (relPath === null)
+                            continue;
+                        if (!refExistsInAnyStash(relPath, parts.type, parts.name, [ctx.stashRoot, ...(ctx.extraStashRoots ?? [])]))
+                            continue; // dangling — leave reported as missing-ref, unrewritten
+                        legacyRewrites.set(value, conceptIdFromTypeName(parts.type, parts.name));
+                    }
+                    if (legacyRewrites.size > 0) {
+                        const rewritten = rewriteFrontmatterListValue(currentRaw, key, legacyRewrites);
+                        if (rewritten !== null) {
+                            currentRaw = rewritten;
+                            modified = true;
+                            for (const [oldValue, newValue] of legacyRewrites) {
+                                const issue = {
+                                    file: ctx.relPath,
+                                    issue: "missing-ref",
+                                    detail: `legacy xref grammar migrated: ${key} ${oldValue} -> ${newValue}`,
+                                    fixed: true,
+                                };
+                                issues.push(issue);
+                                pendingFixes.push(issue);
+                            }
+                        }
+                    }
+                }
                 const missingXrefs = checkMissingRefsInList(values, ctx.stashRoot, ctx.extraStashRoots);
                 // #884 opt-in repair. Scoped to the BELIEF channels only: an edge whose
                 // target has neither a file nor a prune tombstone asserts a