akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/commands/improve/preparation.js

@@ -3,6 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
+import { makeBundleRef } from "../../core/asset/asset-ref.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { typeNameFromConceptId } from "../../core/asset/resolve-ref.js";
 import { daysToMs } from "../../core/common.js";
@@ -21,6 +22,7 @@ import { getRetrievalCounts } from "../../storage/repositories/index-utility-rep
 import { listStateProposals } from "../../storage/repositories/proposals-repository.js";
 import { akmLint } from "../lint/index.js";
 import { runSchemaRepairPass } from "../sources/schema-repair.js";
+import { isAutonomyLaneAllowed } from "./autonomy-gate.js";
 import { akmConsolidate } from "./consolidate.js";
 // Eligibility / candidate-selection predicates live in ./eligibility.
 import { buildLatestFeedbackTsMap, buildLatestProposalTsMap, buildUtilityMap, dedupeRefs, findAssetFilePath, isDistillCandidateRef, isLessonCandidate, isSignalDeltaEligible, } from "./eligibility.js";
@@ -31,34 +33,26 @@ import { computeProxyAdequacy, getAllAssetOutcomes, getOutcomeScoresByRef, OUTCO
 import { DEFAULT_DUE_DAYS, DEFAULT_MAX_PER_RUN, selectProactiveMaintenanceRefs } from "./proactive-maintenance.js";
 import { buildRankChangeReport, computeSalience, getAllRankScores, getAssetSalience, getLastUseMsByRef, isContentEncodingRow, SALIENCE_NO_OP_DAMPEN_FACTOR, SALIENCE_NO_OP_DAMPEN_THRESHOLD, upsertAssetSalience, } from "./salience.js";
 import { bareImproveRef, improveStateReadRefs } from "./source-identity.js";
-function readAssetSalienceForImproveRef(db, ref, sourceName, includeLegacyBare = false, itemRef) {
-    // Chunk-5 flip F5e — probe [itemRef, durable, bare] so a row written under
-    // EITHER grammar is found during the transition window (source-identity.ts).
-    for (const key of improveStateReadRefs(ref, sourceName, includeLegacyBare, itemRef)) {
+function readAssetSalienceForImproveRef(db, ref, itemRef) {
+    for (const key of improveStateReadRefs(ref, itemRef)) {
         const row = getAssetSalience(db, key);
         if (row)
             return row;
     }
     return undefined;
 }
-function readConsecutiveNoOpsForImproveRef(db, ref, sourceName, includeLegacyBare = false, itemRef) {
-    return readAssetSalienceForImproveRef(db, ref, sourceName, includeLegacyBare, itemRef)?.consecutive_no_ops ?? 0;
+function readConsecutiveNoOpsForImproveRef(db, ref, itemRef) {
+    return readAssetSalienceForImproveRef(db, ref, itemRef)?.consecutive_no_ops ?? 0;
 }
-// ── Durable-state write keys (Chunk-8 WI-8.5c: collapsed onto the item_ref) ────
+// ── Durable-state write keys ──────────────────────────────────────────────────
 //
 // The durable improve-state writers (salience + outcome) key by the resolved
-// index entry's `item_ref` (`<bundle>//<conceptId>`, D-R3) WHEN the planner
-// resolved one (`ImproveEligibleRef.itemRef`). The pre-flip source-qualified /
-// bare fallbacks were retired here: both writers now share ONE key expression,
+// index entry's `item_ref` (`<bundle>//<conceptId>`) when the planner resolved
+// one (`ImproveEligibleRef.itemRef`). Both writers share one key expression,
 // `itemRefByRef.get(ref) ?? ref`.
 //
-// THE ONE SURVIVING FALLBACK (`?? ref`): a `--scope <ref>` candidate is targeted
-// directly by the user and never flows through `collectEligibleRefsFromIndex`,
-// so the planner never resolves an `item_ref` for it. Its `ref` (the caller's
-// scope string) IS the write key. Every planner-resolved candidate carries its
-// item_ref (or, for a provenance-NULL / write-back index row, the SHORT
-// conceptId `ref` the WI-8.5c flip now assigns) — both are final new-grammar
-// spellings the one-time state.db re-key leaves untouched.
+// A direct `--scope <ref>` candidate does not flow through
+// `collectEligibleRefsFromIndex`, so its conceptId `ref` is the write key.
 //
 // itemRefByRef is `ref → item_ref | undefined`, built once per pass from the
 // candidate set.
@@ -77,17 +71,9 @@ function salienceWriteKey(ref, itemRefByRef) {
 function outcomeWriteKey(ref, itemRefByRef) {
     return itemRefByRef.get(ref) ?? ref;
 }
-/**
- * Recover the legacy asset type from a ref in EITHER grammar (Chunk-5 flip F5e):
- * the `type:` prefix of a bare/source-qualified `type:name`, or the D-R2
- * stash-subdir of a `[bundle//]conceptId`. "" when neither applies (a foreign
- * bare-name conceptId). Byte-identical to the prior `ref.slice(0, indexOf(":"))`
- * guard for the bare `type:name` refs the salience vector actually iterates.
- */
-function legacyTypeOf(ref) {
+/** Resolve an AKM asset type from a short or bundle-qualified conceptId. */
+function assetTypeOf(ref) {
     const tail = ref.includes("//") ? ref.slice(ref.indexOf("//") + 2) : ref;
-    if (tail.includes(":"))
-        return tail.slice(0, tail.indexOf(":"));
     return typeNameFromConceptId(tail)?.type ?? "";
 }
 /**
@@ -105,11 +91,14 @@ function evaluateConsolidationEligibility(args) {
     // consolidate_completed event. Time-based cooldowns produced the same
     // synchronised-wave failure mode the reflect/distill cooldowns did; the
     // pool-delta gate ties consolidation to actual work-to-do.
+    const sourceName = options.sourceName ?? options.writeTarget?.source.name ?? options.config?.defaultBundle ?? "stash";
     const recentConsolidations = readEvents({ type: "consolidate_completed" });
     const lastConsolidation = recentConsolidations.events
-        .filter((e) => e.metadata?.processed && Number(e.metadata.processed) > 0)
+        .filter((e) => e.metadata?.source === sourceName && Number(e.metadata?.processed) > 0)
         .sort((a, b) => new Date(b.ts ?? 0).getTime() - new Date(a.ts ?? 0).getTime())[0];
-    const lastConsolidateTs = lastConsolidation?.ts;
+    const lastConsolidateTs = typeof lastConsolidation?.metadata?.completedThrough === "string"
+        ? lastConsolidation.metadata.completedThrough
+        : lastConsolidation?.ts;
     // #551 smarter gate: build the set of memory asset paths whose only delta
     // since the last consolidate is their OWN promotion. Those files
     // have not had a full improve cycle to settle, so they offer no merge /
@@ -154,21 +143,29 @@ function evaluateConsolidationEligibility(args) {
         if (!fs.existsSync(memoriesDir))
             return false;
         try {
-            return fs.readdirSync(memoriesDir).some((f) => {
-                if (!f.endsWith(".md"))
-                    return false;
-                const filePath = path.join(memoriesDir, f);
-                // #551: skip files that were only touched by their own promotion this
-                // cohort — they have no settled merge/contradiction candidates yet.
-                if (promotedSinceConsolidate.has(path.resolve(filePath)))
-                    return false;
-                try {
-                    return fs.statSync(filePath).mtime.toISOString() > lastConsolidateTs;
-                }
-                catch {
-                    return false;
+            const pending = [memoriesDir];
+            while (pending.length > 0) {
+                const current = pending.pop();
+                for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+                    const filePath = path.join(current, entry.name);
+                    if (entry.isDirectory()) {
+                        pending.push(filePath);
+                        continue;
+                    }
+                    if (!entry.isFile() || !entry.name.endsWith(".md"))
+                        continue;
+                    if (promotedSinceConsolidate.has(path.resolve(filePath)))
+                        continue;
+                    try {
+                        if (fs.statSync(filePath).mtime.toISOString() > lastConsolidateTs)
+                            return true;
+                    }
+                    catch {
+                        // Ignore files that disappear during the scan.
+                    }
                 }
-            });
+            }
+            return false;
         }
         catch {
             return false;
@@ -240,9 +237,11 @@ export async function runConsolidationPass(args) {
         info(`[improve] consolidation skipped (pool ${eligiblePoolSize} < minPoolSize ${minPoolSize})`);
     }
     else if (!consolidationOnCooldown) {
+        const consolidationStartedAt = new Date().toISOString();
         consolidation = await withLlmStage("consolidate", () => akmConsolidate({
             ...options.consolidateOptions,
             config: consolidationConfig,
+            dryRun: options.dryRun ?? false,
             stashDir: options.stashDir,
             // Active profile for this improve run — lets consolidate's secondary
             // process-config reads honor `--profile <name>` instead of `default`.
@@ -258,17 +257,9 @@ export async function runConsolidationPass(args) {
             // recently-changed memories + graph neighbours — use this for frequent
             // passes (quick-shredder). Leave absent in the nightly default profile for
             // a full-pool sweep that catches stale-but-unmerged duplicates.
-            incrementalSince: improveProfile?.processes?.consolidate?.incrementalSince,
             limit: improveProfile?.processes?.consolidate?.limit,
             neighborsPerChanged: improveProfile?.processes?.consolidate?.neighborsPerChanged,
             maxChunkSize: improveProfile?.processes?.consolidate?.maxChunkSize,
-            // The improve pipeline is an automated batch flow: it must never
-            // block on consolidate's interactive HTTP-path confirm prompt, and
-            // scheduled runs must keep APPLYING the consolidation plan (the
-            // shipped tasks previously got this via `--auto-accept safe`'s
-            // prompt-bypass role; the confidence gate itself died in 0.9.0).
-            // An explicit caller-provided consolidateOptions.assumeYes wins.
-            assumeYes: options.consolidateOptions?.assumeYes ?? true,
             // WS-3a: forward budget signal for graceful abort on timeout, and pass
             // the profile's p90 estimate for cold-start budget reduction.
             signal: budgetSignal,
@@ -277,12 +268,24 @@ export async function runConsolidationPass(args) {
             // can flag when consolidation alone exceeded the budget.
             runBudgetMs,
         }), { engine: resolvedPlan.processes.consolidate.runner?.engine, process: "consolidate" });
-        if (consolidation.processed > 0) {
+        const sourceName = options.sourceName ?? options.writeTarget?.source.name ?? baseConfig.defaultBundle ?? "stash";
+        const complete = (consolidation.failedChunks ?? 0) === 0 &&
+            (consolidation.failedChunkMemories ?? 0) === 0 &&
+            (consolidation.failedPromotions ?? 0) === 0 &&
+            (consolidation.deferredMemories ?? 0) === 0;
+        const hasUnappliedAdvisoryOperations = consolidation.planned?.some((op) => op.op !== "promote") ?? false;
+        if (consolidation.ok &&
+            !consolidation.dryRun &&
+            complete &&
+            !hasUnappliedAdvisoryOperations &&
+            consolidation.processed > 0) {
             appendEvent({
                 eventType: "consolidate_completed",
-                ref: "memories/_consolidation",
+                ref: makeBundleRef(sourceName, "memories/_consolidation"),
                 metadata: {
                     processed: consolidation.processed,
+                    source: sourceName,
+                    completedThrough: consolidationStartedAt,
                     merged: consolidation.merged,
                     deleted: consolidation.deleted,
                     contradicted: consolidation.contradicted,
@@ -304,7 +307,11 @@ export async function runConsolidationPass(args) {
         info("[improve] consolidation skipped (no memory updates since last run)");
     }
     // D9: track whether consolidation wrote any data so graph extraction can reindex if needed
-    const consolidationRan = !consolidateDisabledByProfile && !poolBelowMinSize && !consolidationOnCooldown && consolidation.processed > 0;
+    const consolidationRan = !consolidateDisabledByProfile &&
+        !poolBelowMinSize &&
+        !consolidationOnCooldown &&
+        !consolidation.previewOnly &&
+        consolidation.processed > 0;
     return { consolidation, consolidationRan };
 }
 /**
@@ -570,7 +577,14 @@ export async function runImprovePreparationStage(args) {
     // eligible-ref query sees a populated `entries` table on the very first
     // pass after a DB version upgrade (#339). Any failure messages from that
     // earlier call were threaded in via args.initialCleanupWarnings.
-    const cleanup = await applyCleanupPass({ primaryStashDir, memoryCleanupPlan, plannedRefs, reindexFn, budgetSignal });
+    const cleanup = await applyCleanupPass({
+        primaryStashDir,
+        memoryCleanupPlan,
+        plannedRefs,
+        reindexFn,
+        budgetSignal,
+        allowApply: isAutonomyLaneAllowed("memoryCleanup", options.config ?? loadConfig()),
+    });
     const appliedCleanup = cleanup.appliedCleanup;
     const postCleanupRefs = cleanup.postCleanupRefs;
     actions.push(...cleanup.pruneActions);
@@ -588,7 +602,7 @@ export async function runImprovePreparationStage(args) {
     let lintSummary;
     if (primaryStashDir) {
         try {
-            const lintResult = akmLint({ fix: true, dir: primaryStashDir });
+            const lintResult = await akmLint({ fix: false, dir: primaryStashDir });
             lintSummary = { fixed: lintResult.summary.fixed, flagged: lintResult.summary.flagged };
         }
         catch {
@@ -596,7 +610,7 @@ export async function runImprovePreparationStage(args) {
         }
     }
     const recentErrors = seedRecentErrorWindows(schemaRepairs);
-    const snapshot = buildSnapshotManifest({ postCleanupRefs, validationFailureRefs, options });
+    const snapshot = buildSnapshotManifest({ postCleanupRefs, validationFailureRefs });
     const gathered = gatherCandidates({
         scope,
         options,
@@ -614,7 +628,6 @@ export async function runImprovePreparationStage(args) {
         options,
         primaryStashDir,
         eventsCtx,
-        improveProfile,
         mergedRefs: gathered.mergedRefs,
         eligibilitySourceByRef: gathered.eligibilitySourceByRef,
         feedbackSummary: gathered.feedbackSummary,
@@ -707,13 +720,15 @@ function assessMemoryIndexBudget(primaryStashDir) {
  * orchestrator to fold (same order as the old inline pushes).
  */
 async function applyCleanupPass(args) {
-    const { primaryStashDir, memoryCleanupPlan, plannedRefs, reindexFn, budgetSignal } = args;
+    const { primaryStashDir, memoryCleanupPlan, plannedRefs, reindexFn, budgetSignal, allowApply } = args;
     const pruneActions = [];
     const warnings = [];
     let appliedCleanup;
     try {
         appliedCleanup =
-            primaryStashDir && memoryCleanupPlan ? applyMemoryCleanup(primaryStashDir, memoryCleanupPlan) : undefined;
+            primaryStashDir && memoryCleanupPlan && allowApply
+                ? applyMemoryCleanup(primaryStashDir, memoryCleanupPlan)
+                : undefined;
     }
     catch (err) {
         warnings.push(`applyMemoryCleanup failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -775,7 +790,7 @@ function seedRecentErrorWindows(schemaRepairs) {
 }
 /** Pass: snapshot-manifest — the three timestamp maps + the 30-day signal window. */
 export function buildSnapshotManifest(args) {
-    const { postCleanupRefs, validationFailureRefs, options } = args;
+    const { postCleanupRefs, validationFailureRefs } = args;
     // ── Phase 2: signal-delta eligibility sets built EARLY ────────────────────
     // 0.8.0 replaces the flat time-based cooldowns (which produced synchronised
     // waves whenever many refs cooled at the same instant — see the 2026-05-26
@@ -798,12 +813,11 @@ export function buildSnapshotManifest(args) {
     // Per-ref queries would be N+1 and the planner is already the hottest path
     // in `akm improve`.
     const candidateRefs = postCleanupRefs.filter((r) => !validationFailureRefs.has(r.ref)).map((r) => r.ref);
-    // Chunk-5 flip F5e — carry each candidate's item_ref so the feedback/proposal
-    // ts readers dual-arm their reverse maps on [item_ref, durable, bare].
+    // Carry each candidate's item_ref into the feedback/proposal timestamp reads.
     const itemRefByRef = buildItemRefByRef(postCleanupRefs);
-    const latestFeedbackTs = buildLatestFeedbackTsMap(candidateRefs, feedbackSinceCutoff, options.sourceName, options.legacyBareState, itemRefByRef);
-    const lastReflectProposalTs = buildLatestProposalTsMap(candidateRefs, "reflect", options.sourceName, options.legacyBareState, itemRefByRef);
-    const lastDistillProposalTs = buildLatestProposalTsMap(candidateRefs, "distill", options.sourceName, options.legacyBareState, itemRefByRef);
+    const latestFeedbackTs = buildLatestFeedbackTsMap(candidateRefs, feedbackSinceCutoff, itemRefByRef);
+    const lastReflectProposalTs = buildLatestProposalTsMap(candidateRefs, "reflect", itemRefByRef);
+    const lastDistillProposalTs = buildLatestProposalTsMap(candidateRefs, "distill", itemRefByRef);
     return { feedbackSinceCutoff, latestFeedbackTs, lastReflectProposalTs, lastDistillProposalTs };
 }
 /**
@@ -835,7 +849,6 @@ function gatherCandidates(args) {
     const feedbackSummary = buildFeedbackSummaryMap({
         processableRefs,
         noFeedbackPool,
-        options,
         eventsCtx,
         feedbackSinceCutoff,
     });
@@ -1089,7 +1102,7 @@ export function partitionBySignalDelta(args) {
 }
 /** Bulk per-ref feedback summary in a SINGLE readEvents pass (candidate-gather). */
 function buildFeedbackSummaryMap(args) {
-    const { processableRefs, noFeedbackPool, options, eventsCtx, feedbackSinceCutoff } = args;
+    const { processableRefs, noFeedbackPool, eventsCtx, feedbackSinceCutoff } = args;
     // Gap 6: only surface feedback signals from the last 30 days so that
     // ancient one-off feedback events don't permanently lock an asset into
     // every improve run. Assets with only stale signals fall through to the
@@ -1111,10 +1124,8 @@ function buildFeedbackSummaryMap(args) {
     {
         const feedbackCandidates = [...processableRefs, ...noFeedbackPool];
         const feedbackCandidateSet = new Set(feedbackCandidates.map((r) => r.ref));
-        // Chunk-5 flip F5e — dual-arm the reverse map on [item_ref, durable, bare]
-        // so an item_ref-keyed feedback event resolves back to its candidate ref
-        // once the writers emit item_ref. // Chunk-8: collapse to [item_ref].
-        const feedbackRefByDurableKey = new Map(feedbackCandidates.flatMap((r) => improveStateReadRefs(r.ref, options.sourceName, options.legacyBareState, r.itemRef).map((key) => [key, r.ref])));
+        // Map each candidate's single durable event key back to its display ref.
+        const feedbackRefByDurableKey = new Map(feedbackCandidates.flatMap((r) => improveStateReadRefs(r.ref, r.itemRef).map((key) => [key, r.ref])));
         if (feedbackCandidateSet.size > 0) {
             // Fetch ALL feedback events in one query (no ref filter, no since filter =
             // single full table scan). Filtering per-ref in memory avoids N sequential
@@ -1180,7 +1191,6 @@ function fetchRetrievalSignals(args) {
             retrievalCounts = getRetrievalCounts(dbForRetrievalIndex, stateDb, allCandidateRefs, {
                 sourceName: options.sourceName,
                 stashDir: primaryStashDir,
-                includeLegacyBare: options.legacyBareState,
             });
         });
         lastUseMsForProactive = getLastUseMsByRef(dbForRetrieval, noFeedbackCandidates.map((r) => r.ref), primaryStashDir);
@@ -1315,9 +1325,9 @@ function selectHighSalienceLane(args) {
             // found later in the scan lost its slot to an earlier lower-scoring one.
             const qualifying = [];
             for (const r of candidates) {
-                const row = readAssetSalienceForImproveRef(dbForHighSalience, r.ref, options.sourceName, options.legacyBareState, r.itemRef);
+                const row = readAssetSalienceForImproveRef(dbForHighSalience, r.ref, r.itemRef);
                 if (row &&
-                    isContentEncodingRow(row, legacyTypeOf(r.ref)) &&
+                    isContentEncodingRow(row) &&
                     row.encoding_salience >= salienceThreshold &&
                     !lastReflectProposalTs.has(r.ref)) {
                     qualifying.push({ ref: r, score: row.encoding_salience });
@@ -1348,31 +1358,23 @@ function selectHighSalienceLane(args) {
  * attribution identity is load-bearing (see the candidate-gather comments).
  */
 function scoreSalience(args) {
-    const { scope, options, primaryStashDir, eventsCtx, improveProfile, eligibilitySourceByRef, feedbackSummary, retrievalCounts, signalFiltered, proactiveRefs, highSalienceRefs, } = args;
+    const { scope, options, primaryStashDir, eventsCtx, eligibilitySourceByRef, feedbackSummary, retrievalCounts, signalFiltered, proactiveRefs, highSalienceRefs, } = args;
     const mergedRefs = args.mergedRefs;
     // Chunk-5 flip F5e — resolve each candidate's durable item_ref ONCE for this
     // pass (the write/read key source for the outcome + salience state writers).
     const itemRefByRef = buildItemRefByRef(mergedRefs);
     // WS-1 — Unified salience vector (S1 seam).
     //
-    // The legacy sort combined three independent formulas (utility EMA, negative-only
-    // ratio / symmetric-valence magnitude, and the proactive-maintenance priority
-    // formula). WS-1 converges them into one `computeSalience()` call per ref, with
+    // WS-1 converges utility, valence, and proactive-maintenance signals into one
+    // `computeSalience()` call per ref, with
     // three independently-stored sub-scores and one documented rankScore projection.
     //
-    // Migration note: if a profile still has `symmetricValence` set, emit a one-time
-    // warning — its behaviour (symmetric |valence| attention) is now always-on as
-    // part of the salience vector, so the knob is a no-op and will be removed in 0.10.
-    if (improveProfile.symmetricValence === true) {
-        warn("[improve] Profile option 'symmetricValence' is deprecated (WS-1 salience vector). " +
-            "Symmetric valence is now always active; remove the option from your improve profile.");
-    }
     // Fetch last-use timestamps from the index DB for the full merged set so the
     // recency term in retrievalSalience is genuinely decayable (plan §WS-1 step 2).
     // This reuses the index DB opened earlier for retrieval counts; a separate
     // lightweight open is used here to avoid holding the connection longer than needed.
     let lastUseMsByRef = new Map();
-    // utilityMap is kept for backward-compatible observability (health report reads it).
+    // Health and outcome reporting consume the utility projection.
     const utilityMap = buildUtilityMap(mergedRefs);
     let dbForSalience;
     try {
@@ -1471,9 +1473,8 @@ function updateOutcomeScores(args) {
                 const valenceResult = computeValenceScore(fb);
                 try {
                     const result = updateAssetOutcome(outcomeDb, {
-                        // Chunk-5 flip F5e — key by item_ref when resolved, else the bare
-                        // pre-flip outcome spelling. rawOutcomeScores stays keyed by the
-                        // bare `r.ref` (its in-memory identity for the salience vector).
+                        // Key by item_ref when resolved, else by the conceptId. Keep
+                        // rawOutcomeScores keyed by r.ref, its in-memory identity.
                         ref: outcomeWriteKey(r.ref, itemRefByRef),
                         currentRetrievalCount: retrievalCounts.get(r.ref) ?? 0,
                         lastRetrievedAt: lastUseMsByRef.get(r.ref) ?? 0,
@@ -1499,10 +1500,7 @@ function updateOutcomeScores(args) {
                     if (row.outcome_score > maxOutcomeScore)
                         maxOutcomeScore = row.outcome_score;
                 }
-                // Read-clip: legacy rows written before the OUTCOME_SCORE_MAX write-clip
-                // existed can sit above the ceiling (live max was 3.13). Without this
-                // clip they inflate the normalisation denominator and floor everyone
-                // else's outcomeSalience (#691 follow-up).
+                // Keep the normalization denominator within the writer's score bounds.
                 maxOutcomeScore = Math.min(maxOutcomeScore, OUTCOME_SCORE_MAX);
                 // Proxy-adequacy tripwire (two-tailed): inverted (corr < −0.3) and
                 // dead (|corr| < 0.1 at n ≥ 500) both emit health events.
@@ -1590,9 +1588,8 @@ function computeSalienceVectors(args) {
     try {
         withStateDb((dbForStoredEncoding) => {
             for (const r of mergedRefs) {
-                const type = legacyTypeOf(r.ref);
-                const row = readAssetSalienceForImproveRef(dbForStoredEncoding, r.ref, options.sourceName, options.legacyBareState, itemRefByRef.get(r.ref));
-                if (row && isContentEncodingRow(row, type)) {
+                const row = readAssetSalienceForImproveRef(dbForStoredEncoding, r.ref, itemRefByRef.get(r.ref));
+                if (row && isContentEncodingRow(row)) {
                     storedEncodingByRef.set(r.ref, row.encoding_salience);
                 }
             }
@@ -1603,7 +1600,7 @@ function computeSalienceVectors(args) {
         // best-effort: if DB unavailable, fall back to type-weight stub (prior behaviour)
     }
     for (const r of mergedRefs) {
-        const type = legacyTypeOf(r.ref);
+        const type = assetTypeOf(r.ref);
         const sizeBytes = (() => {
             const fp = r.filePath;
             if (!fp)
@@ -1641,19 +1638,19 @@ function toRankPositions(scores) {
 }
 /**
  * Chunk-5 flip F5e — the durable salience write-key maps for one improve pass.
- * `wk(ref)` is a pool asset's write key (item_ref, else source-qualified);
- * `normalizeStoredKey` folds every stored spelling ([item_ref, durable, bare])
- * of an in-pool asset onto its write key (no stashSize double-count); and
+ * `wk(ref)` is a pool asset's write key (item_ref, else conceptId);
+ * `normalizeStoredKey` maps each in-pool asset's durable spelling to its write
+ * key (no stashSize double-count); and
  * `refByWriteKey` reverses a write key back to its filesystem-facing bare ref.
  */
-function buildSalienceWriteKeyMaps(itemRefByRef, sourceName) {
+function buildSalienceWriteKeyMaps(itemRefByRef) {
     const wk = (ref) => salienceWriteKey(ref, itemRefByRef);
     const normalizeStoredKey = new Map();
     const refByWriteKey = new Map();
     for (const [ref, itemRef] of itemRefByRef) {
         const writeKey = wk(ref);
         refByWriteKey.set(writeKey, ref);
-        for (const spelling of improveStateReadRefs(ref, sourceName, true, itemRef)) {
+        for (const spelling of improveStateReadRefs(ref, itemRef)) {
             normalizeStoredKey.set(spelling, writeKey);
         }
     }
@@ -1663,11 +1660,9 @@ function buildSalienceWriteKeyMaps(itemRefByRef, sourceName) {
 function persistSalienceAndReportRanks(args) {
     const { salienceMap, itemRefByRef, utilityMap, feedbackSummary, options, eventsCtx, nowForSalience } = args;
     // Chunk-5 flip F5e — the WRITE-key space. salienceMap stays keyed by each
-    // candidate's own bare `r.ref`; the state.db boundary keys by the durable
-    // salience write key (item_ref, else source-qualified `type:name`), and every
-    // stored spelling of one asset folds onto that key so a seeded-legacy row and
-    // a fresh item_ref write can never double-count in the rank report.
-    const { wk, normalizeStoredKey, refByWriteKey } = buildSalienceWriteKeyMaps(itemRefByRef, options.sourceName);
+    // candidate's own short `r.ref`; the state.db boundary keys by item_ref when
+    // available and otherwise by conceptId.
+    const { wk, normalizeStoredKey, refByWriteKey } = buildSalienceWriteKeyMaps(itemRefByRef);
     // Persist salience vectors to state.db (best-effort, non-blocking).
     // The canonical store enables WS-3 homeostatic demotion and WS-2 outcome reads.
     //
@@ -1720,9 +1715,8 @@ function persistSalienceAndReportRanks(args) {
             // Step 7: stash-wide rank-change report BEFORE overwriting the table.
             //
             // Load ALL existing rows so rank positions are stash-relative, not pool-relative.
-            // Chunk-5 flip F5e — source-scope by PREFIX (`<bundle|source>//…`, works
-            // for BOTH grammars — no legacy-parser throw on an item_ref row) and
-            // fold each in-pool asset's stored spelling onto its single write key so
+            // Source-scope by the `<bundle>//` prefix and fold each in-pool asset's
+            // stored spelling onto its single write key so
             // the merge below never double-counts one asset across two spellings.
             const allStoredScores = getAllRankScores(stateDb);
             const existingAllScores = new Map();
@@ -1730,7 +1724,7 @@ function persistSalienceAndReportRanks(args) {
                 if (options.sourceName) {
                     const boundary = ref.indexOf("//");
                     const prefix = boundary >= 0 ? ref.slice(0, boundary) : undefined;
-                    const belongs = prefix === options.sourceName || (options.legacyBareState && prefix === undefined);
+                    const belongs = prefix === options.sourceName;
                     if (!belongs)
                         continue;
                 }
@@ -1830,8 +1824,7 @@ function persistSalienceAndReportRanks(args) {
                 }, eventsCtx);
             }
             for (const [ref, vector] of salienceMap) {
-                // Chunk-5 flip F5e — persist salience under the durable WRITE key
-                // (item_ref when resolved, else source-qualified `type:name`).
+                // Persist salience under item_ref when resolved, else the conceptId.
                 upsertAssetSalience(stateDb, wk(ref), vector, nowForSalience);
             }
         }, { path: eventsCtx?.dbPath });
@@ -1939,7 +1932,7 @@ async function filterEligibility(args) {
             const ownsNoOpDb = !eventsCtx?.db;
             try {
                 for (const r of mergedRefs) {
-                    noOpMap.set(r.ref, readConsecutiveNoOpsForImproveRef(noOpDb, r.ref, options.sourceName, options.legacyBareState, r.itemRef));
+                    noOpMap.set(r.ref, readConsecutiveNoOpsForImproveRef(noOpDb, r.ref, r.itemRef));
                 }
             }
             finally {
@@ -1967,9 +1960,8 @@ async function filterEligibility(args) {
     // suppresses repeated LLM attempts on those same assets without touching their
     // persisted rank_score (so they remain fully retrievable).
     //
-    // This is the ONLY ranking path — negativeOnlyRatio and the legacy
-    // symmetricValence branch are replaced. The eligibilitySource lanes
-    // (signal-delta / proactive / high-salience) survive as labels (set above).
+    // This is the only ranking path. The eligibilitySource lanes (signal-delta /
+    // proactive / high-salience) survive as labels set above.
     const effectiveScore = (ref) => {
         const rankScore = salienceMap.get(ref)?.rankScore ?? 0;
         const noOps = noOpMap.get(ref) ?? 0;
@@ -2090,14 +2082,13 @@ function applyReplaySelection(args) {
                         bareRefByItemRef.set(itemRef, bareRef);
                 const allRankScores = options.sourceName
                     ? (() => {
-                        // Source-scope by PREFIX (both grammars — no legacy-parser throw
-                        // on an item_ref row), then re-key onto the bare ref: item_ref rows
-                        // via the planned reverse map, legacy rows inline via bareImproveRef.
+                        // Source-scope by the bundle prefix, then re-key item_ref rows
+                        // onto the short conceptId used by the planned-ref pool.
                         const m = new Map();
                         for (const [ref, score] of storedRankScores) {
                             const boundary = ref.indexOf("//");
                             const prefix = boundary >= 0 ? ref.slice(0, boundary) : undefined;
-                            const belongs = prefix === options.sourceName || (options.legacyBareState && prefix === undefined);
+                            const belongs = prefix === options.sourceName;
                             if (!belongs)
                                 continue;
                             m.set(bareRefByItemRef.get(ref) ?? bareImproveRef(ref), score);
@@ -2114,7 +2105,7 @@ function applyReplaySelection(args) {
                 for (const [ref, rankScore] of allRankScores) {
                     if (alreadyInPool.has(ref))
                         continue;
-                    const noOps = readConsecutiveNoOpsForImproveRef(replayDb, ref, options.sourceName, options.legacyBareState, itemRefByPlanned.get(ref));
+                    const noOps = readConsecutiveNoOpsForImproveRef(replayDb, ref, itemRefByPlanned.get(ref));
                     if (noOps >= SALIENCE_NO_OP_DAMPEN_THRESHOLD) {
                         convergedSkipped++;
                         continue;

package/dist/commands/improve/proactive-maintenance.js

@@ -35,11 +35,8 @@ export const DEFAULT_MAX_PER_RUN = 25;
 const SIZE_FLOOR_BYTES = 200;
 /**
  * Derive the asset type from a candidate's canonical conceptId ref
- * (`[bundle//]<stash-subdir>/<name>`, ref-grammar decision D-R2/D-R3) via the
- * permanent reverse table. Returns "" when the leading segment is not a known
- * stash subdir. The candidate refs are the SHORT conceptId derived fresh from
- * the index each run (`eligibility.ts`), never a durable `type:name` row, so no
- * legacy colon arm is needed here.
+ * (`[bundle//]<stash-subdir>/<name>`) via the permanent reverse table. Returns
+ * "" when the leading segment is not a known stash subdir.
  */
 function refType(ref) {
     const body = ref.includes("//") ? ref.slice(ref.indexOf("//") + 2) : ref;