akm-cli 0.9.6 → 0.9.8-beta.1

package/dist/commands/health/improve-metrics.js

@@ -33,42 +33,16 @@ export function taskFailureDetail(row) {
     }
 }
 /**
- * D8 read-boundary predicate (spec docs/plans/specs/p1b-model-extraction.md
- * §5.3) for `akm health`'s `agentFailureRate`: true for a `task_history` row
- * that represents a prepared command (agent/LLM) result, across both
- * vocabularies. Mirrors src/tasks/run/task-history.ts's
- * `taskHistoryRowToResult` read mapping:
- *   - NEW rows mark themselves with metadata `targetVocab: 2` and store
- *     `target_kind: "command"` for the agent/LLM arm.
- *   - LEGACY rows (no marker, written before P1b's F-2 re-code) stored
- *     `target_kind: "prompt"` for the same arm — and `"command"` for the
- *     UNRELATED native shell/script arm, which must NOT be counted here.
- * So an unmarked `"command"` row is a legacy shell/script run, not an
- * agent/LLM one; a marked `"command"` row (or an unmarked `"prompt"` row) is.
+ * `akm health`'s `agentFailureRate` predicate: true for a `task_history` row
+ * that represents a prepared command (agent/LLM) result. `target_kind` is
+ * read in the current (post-D8) vocabulary — the
+ * `025-task-history-vocabulary-backfill` state migration rewrites every
+ * legacy-vocabulary row (which stored the agent/LLM arm as `"prompt"` and
+ * the native shell/script arm as `"command"`) before this ever runs against
+ * it, so a `"command"` row here is unambiguously the agent/LLM arm.
  */
 export function isAgentTaskHistoryRow(row) {
-    // Check target_kind BEFORE decoding metadata: some rows in the wild
-    // (e.g. improve-pipeline task_history rows, target_kind "improve") carry
-    // metadata_json that predates the metadataVersion:2 shape entirely, and
-    // decodeTaskHistoryMetadata throws on that — exactly like the pre-fix
-    // `target_kind === "prompt"` filter, which never called it for a row this
-    // function isn't going to count anyway. Only decode for the two target
-    // kinds this predicate can return true for.
-    if (row.target_kind !== "command" && row.target_kind !== "prompt")
-        return false;
-    // An undecodable metadata_json is by definition unmarked: pre-P1b rows can
-    // carry shapes decodeTaskHistoryMetadata rejects, and `akm health` must
-    // classify them as legacy rather than throw (round-3 review advisory).
-    let marked = false;
-    try {
-        marked = decodeTaskHistoryMetadata(row.metadata_json).targetVocab === 2;
-    }
-    catch {
-        marked = false;
-    }
-    if (row.target_kind === "command")
-        return marked;
-    return !marked;
+    return row.target_kind === "command";
 }
 function createUnknownImproveMetrics() {
     return {

package/dist/commands/health/windows.js

@@ -148,10 +148,6 @@ export function buildWindowMetrics(db, stateDbPath, since, until, now = () => Da
     const failedTaskRows = taskRows.filter((row) => row.status === "failed");
     const activeRows = taskRows.filter((row) => row.status === "active" && row.completed_at === null);
     const stuckActiveRuns = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS).length;
-    // D8 (spec §5.3): a marked "command" row or a legacy (unmarked) "prompt"
-    // row is the agent/LLM arm; an unmarked "command" row is the legacy
-    // native shell/script arm and must not be counted here (see
-    // isAgentTaskHistoryRow's header comment for the full mapping).
     const agentRows = taskRows.filter((row) => isAgentTaskHistoryRow(row));
     const agentFailures = agentRows.filter((row) => {
         const detail = taskFailureDetail(row);

package/dist/commands/health.js

@@ -7,10 +7,9 @@ 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";
+import { getConfigPath, getDbPath, getStateDbPathInDataDir } from "../core/paths.js";
 import { listExistingTableNames, openStateDatabase } from "../core/state-db.js";
 import { DURATION_UNITS, parseDuration, parseSinceToIso } from "../core/time.js";
 import { closeDatabase, openReadonlyExistingDatabase } from "../storage/repositories/index-connection.js";
@@ -150,37 +149,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
@@ -512,7 +480,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 +502,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/improve-cli.js

@@ -114,7 +114,7 @@ export const improveCommand = defineCommand({
         },
         strategy: {
             type: "string",
-            description: "Named improve strategy from improve.strategies or built-in strategies (catchup, consolidate, default, frequent, graph-refresh, memory-focus, proactive-maintenance, quick, reflect-distill, thorough). Controls which sub-processes run and which asset types are processed.",
+            description: "Named improve strategy from improve.strategies or built-in strategies (catchup, consolidate, default, graph-refresh, proactive-maintenance, quick, reflect-distill, thorough). Controls which sub-processes run and which asset types are processed.",
         },
         sync: {
             type: "boolean",

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

@@ -4,9 +4,7 @@
 import catchup from "../../assets/improve-strategies/catchup.json" with { type: "json" };
 import consolidate from "../../assets/improve-strategies/consolidate.json" with { type: "json" };
 import defaultStrategy from "../../assets/improve-strategies/default.json" with { type: "json" };
-import frequent from "../../assets/improve-strategies/frequent.json" with { type: "json" };
 import graphRefresh from "../../assets/improve-strategies/graph-refresh.json" with { type: "json" };
-import memoryFocus from "../../assets/improve-strategies/memory-focus.json" with { type: "json" };
 import proactiveMaintenance from "../../assets/improve-strategies/proactive-maintenance.json" with { type: "json" };
 import quick from "../../assets/improve-strategies/quick.json" with { type: "json" };
 import reflectDistill from "../../assets/improve-strategies/reflect-distill.json" with { type: "json" };
@@ -45,9 +43,7 @@ const BUILTIN_STRATEGIES = {
     default: defaultStrategy,
     quick,
     thorough,
-    "memory-focus": memoryFocus,
     "graph-refresh": graphRefresh,
-    frequent,
     consolidate,
     catchup,
     "reflect-distill": reflectDistill,

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

@@ -5,10 +5,13 @@ import fs from "node:fs";
 import path from "node:path";
 import { assembleAsset } from "../../../core/asset/asset-serialize.js";
 import { mutateFrontmatter, parseFrontmatter } from "../../../core/asset/frontmatter.js";
+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);
@@ -553,7 +556,7 @@ function priorBeliefStateForArchive(candidate) {
 }
 function createArchiveDir(stashDir, ref, archivedAt) {
     const baseName = `${archivedAt.replace(/[:.]/g, "-")}-${sanitizeRef(ref)}`;
-    const root = path.join(stashDir, ".akm", "memory-cleanup", "archive");
+    const root = path.join(stashDir, MEMORY_ARCHIVE_REL);
     fs.mkdirSync(root, { recursive: true });
     let attempt = 0;
     while (true) {
@@ -573,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;
@@ -777,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

@@ -760,7 +760,7 @@ async function runPreparationPrelude(args) {
     };
 }
 export async function runImprovePreparationStage(args) {
-    const { scope, options, plannedRefs, primaryStashDir, eventsCtx, initialCleanupWarnings, improveProfile, resolvedPlan, planOnly = options.dryRun === true, } = args;
+    const { scope, options, primaryStashDir, eventsCtx, initialCleanupWarnings, improveProfile, resolvedPlan, planOnly = options.dryRun === true, } = args;
     const actions = [];
     const cleanupWarnings = initialCleanupWarnings ? [...initialCleanupWarnings] : [];
     const { memoryIndexHealth, consolidationPass, extractPlan, extractResults, appliedCleanup, postCleanupRefs, cleanupGate, validationFailures, validationFailureRefs, schemaRepairs, } = await runPreparationPrelude({ ...args, planOnly, actions, cleanupWarnings });
@@ -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.
@@ -790,7 +786,7 @@ function parseDirectReflectOutput(raw, mode, targetRef) {
 export async function runReflectViaLlm(opts) {
     const start = Date.now();
     let repairAttempts = 0;
-    const connection = opts.runner.connection;
+    const _connection = opts.runner.connection;
     const messages = [{ role: "user", content: opts.prompt ?? "" }];
     const configuredTimeout = Object.hasOwn(opts, "timeoutMs")
         ? (opts.timeoutMs ?? null)