akm-cli 0.9.0-beta.6 → 0.9.0-beta.9

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

@@ -0,0 +1,113 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/** One day in milliseconds. */
+const DAY_MS = 86_400_000;
+/**
+ * Importance multipliers by asset type. Higher = more worth maintaining. These
+ * are the design defaults; callers may override any subset via config.
+ */
+export const DEFAULT_IMPORTANCE_WEIGHTS = Object.freeze({
+    skill: 1.5,
+    agent: 1.5,
+    command: 1.3,
+    workflow: 1.3,
+    lesson: 1.2,
+    knowledge: 1.0,
+    script: 0.9,
+    memory: 0.7,
+});
+/** Default staleness gate: an asset is due when last reflected > this many days ago (or never). */
+export const DEFAULT_DUE_DAYS = 30;
+/** Default bound on how many assets the selector surfaces per run. */
+export const DEFAULT_MAX_PER_RUN = 25;
+/**
+ * Half-life (days) for the recency-of-use decay term. An asset used today
+ * contributes a full recency multiplier; one unused for one half-life
+ * contributes half. Mirrors the validated prototype (21 days).
+ */
+const RECENCY_HALFLIFE_DAYS = 21;
+/** Lower bound on size used in the cost denominator so tiny files don't divide by ~0. */
+const SIZE_FLOOR_BYTES = 200;
+/** Parse the bare asset type out of a `type:name` ref. Returns "" when unparseable. */
+function refType(ref) {
+    const i = ref.indexOf(":");
+    return i > 0 ? ref.slice(0, i) : "";
+}
+/**
+ * Score and select due assets for proactive maintenance.
+ *
+ * Priority formula (mirrors the validated prototype):
+ *
+ *   priority = (importance × log(1 + retrievalFreq) × (0.1 + 0.5^(useAgeDays/21)))
+ *              / log10(max(size, 200))
+ *
+ * DUE gate: an asset is eligible only if it was never reflected OR last
+ * reflected/distilled more than `dueDays` ago. The same gate doubles as the
+ * ROTATION cooldown — a freshly-reflected asset is excluded until it ages back
+ * past `dueDays`, so successive runs rotate through the due pool rather than
+ * re-selecting the same heads. Non-due assets never enter the selection.
+ */
+export function selectProactiveMaintenanceRefs(params) {
+    const now = params.now ?? Date.now();
+    const dueDays = params.dueDays ?? DEFAULT_DUE_DAYS;
+    const maxPerRun = params.maxPerRun ?? DEFAULT_MAX_PER_RUN;
+    const weights = { ...DEFAULT_IMPORTANCE_WEIGHTS, ...(params.importanceWeights ?? {}) };
+    const scored = [];
+    for (const candidate of params.candidates) {
+        const ref = candidate.ref;
+        const type = refType(ref);
+        // Staleness from the most recent of reflect/distill — either one touching
+        // the asset resets its maintenance clock.
+        const reflectIso = params.lastReflectTs.get(ref);
+        const distillIso = params.lastDistillTs.get(ref);
+        let lastTouchMs = 0;
+        if (reflectIso)
+            lastTouchMs = Math.max(lastTouchMs, Date.parse(reflectIso) || 0);
+        if (distillIso)
+            lastTouchMs = Math.max(lastTouchMs, Date.parse(distillIso) || 0);
+        const neverReflected = lastTouchMs === 0;
+        const staleDays = neverReflected ? Number.POSITIVE_INFINITY : (now - lastTouchMs) / DAY_MS;
+        // DUE / rotation gate.
+        const due = neverReflected || staleDays > dueDays;
+        // Retrieval frequency + recency decay.
+        const retrievalFreq = params.retrievalCounts.get(ref) ?? 0;
+        const lastUse = params.lastUseMs?.get(ref) ?? 0;
+        const useAgeDays = lastUse > 0 ? (now - lastUse) / DAY_MS : 9999;
+        const recencyDecay = 0.1 + 0.5 ** (useAgeDays / RECENCY_HALFLIFE_DAYS);
+        // Size proxy (cost): larger assets are slightly deprioritized, but only by
+        // log10 so a big-but-hot asset is never starved.
+        let sizeBytes = params.sizeBytesOf?.(candidate) ?? 0;
+        if (!sizeBytes || sizeBytes < 0)
+            sizeBytes = SIZE_FLOOR_BYTES;
+        const sizeProxy = Math.max(SIZE_FLOOR_BYTES, sizeBytes);
+        const importance = weights[type] ?? 1.0;
+        const priority = (importance * Math.log(1 + retrievalFreq) * recencyDecay) / Math.log10(sizeProxy);
+        scored.push({
+            ref: candidate,
+            type,
+            staleDays,
+            neverReflected,
+            retrievalFreq,
+            recencyDecay,
+            sizeBytes,
+            importance,
+            priority,
+            due,
+        });
+    }
+    const dueScored = scored.filter((s) => s.due);
+    const dueTotal = dueScored.length;
+    const neverReflected = dueScored.filter((s) => s.neverReflected).length;
+    // Rank due assets by composite priority (desc). Ties broken by staleness
+    // (older first) then ref string for deterministic ordering.
+    const ranked = dueScored.slice().sort((a, b) => {
+        if (b.priority !== a.priority)
+            return b.priority - a.priority;
+        if (b.staleDays !== a.staleDays)
+            return b.staleDays - a.staleDays;
+        return a.ref.ref < b.ref.ref ? -1 : a.ref.ref > b.ref.ref ? 1 : 0;
+    });
+    const selected = ranked.slice(0, Math.max(0, maxPerRun)).map((s) => s.ref);
+    return { selected, dueTotal, neverReflected, scored };
+}

package/dist/commands/improve/reflect.js

@@ -585,6 +585,9 @@ export async function akmReflect(options = {}) {
         metadata: {
             ...(options.task ? { task: options.task } : {}),
             ...(options.profile ? { profile: options.profile } : {}),
+            // Attribution tagging: stamp the eligibility lane so reflect_invoked can be
+            // sliced by lane downstream. See EligibilitySource.
+            ...(options.eligibilitySource ? { eligibilitySource: options.eligibilitySource } : {}),
         },
     });
     // Fix #3 (observability 0.8.0): every failure path below MUST emit
@@ -1228,6 +1231,9 @@ export async function akmReflect(options = {}) {
         // `parseAgentProposalPayload` already clamps to [0, 1] and drops non-
         // finite values; `createProposal` runs its own sanitizer as a safety net.
         ...(typeof payload.confidence === "number" ? { confidence: payload.confidence } : {}),
+        // Attribution tagging: persist the eligibility lane on the proposal so it
+        // survives to accept/reject/revert time even across runs. See EligibilitySource.
+        ...(options.eligibilitySource ? { eligibilitySource: options.eligibilitySource } : {}),
     };
     const proposalResult = createProposal(stash, createInput, options.ctx);
     if (isProposalSkipped(proposalResult)) {

package/dist/commands/proposal/proposal.js

@@ -75,6 +75,11 @@ export async function akmProposalAccept(options) {
             source: result.proposal.source,
             ...(result.proposal.sourceRun !== undefined ? { sourceRun: result.proposal.sourceRun } : {}),
             assetPath: result.assetPath,
+            // Attribution tagging: carry the eligibility lane from the proposal record
+            // onto the promoted event so accept outcomes can be sliced by lane.
+            ...(result.proposal.eligibilitySource !== undefined
+                ? { eligibilitySource: result.proposal.eligibilitySource }
+                : {}),
         },
     });
     return {

package/dist/commands/proposal/validators/proposals.js

@@ -50,7 +50,7 @@ import { makeAssetRef, parseAssetRef } from "../../../core/asset/asset-ref.js";
 import { resolveAssetPathFromName, TYPE_DIRS } from "../../../core/asset/asset-spec.js";
 import { NotFoundError, UsageError } from "../../../core/errors.js";
 import { appendEvent } from "../../../core/events.js";
-import { getStateDbPath, getStateProposal, hasImportedFsProposals, insertProposalIfAbsent, listStateProposalIdsByPrefix, listStateProposals, openStateDatabase, recordFsProposalsImport, upsertProposal, } from "../../../core/state-db.js";
+import { getStateDbPath, getStateProposal, hasImportedFsProposals, insertProposalIfAbsent, listStateProposalIdsByPrefix, listStateProposals, openStateDatabase, recordFsProposalsImport, upsertProposal, withImmediateTransaction, } from "../../../core/state-db.js";
 import { warn } from "../../../core/warn.js";
 import { commitWriteTargetBoundary, formatRefForMessage, resolveWriteTarget, writeAssetToSource, } from "../../../core/write-source.js";
 import { runProposalValidators } from "./proposal-validators.js";
@@ -334,37 +334,42 @@ export function createProposal(stashDir, input, ctx) {
     }
     const normalizedRef = makeAssetRef(parsedRef.type, parsedRef.name, parsedRef.origin);
     return withProposalsDb(stashDir, ctx, (db) => {
-        if (!input.force) {
-            const skip = checkDedupAndCooldown(db, stashDir, normalizedRef, input, ctx);
-            if (skip)
-                return skip;
-        }
-        const created = nowIso(ctx);
-        // Phase 6A: validate confidence is a finite number in [0, 1]. Anything else
-        // is dropped silently — we never store NaN, Infinity, or out-of-range values.
-        // Callers that mis-report confidence should not poison the auto-accept gate.
-        const sanitizedConfidence = typeof input.confidence === "number" &&
-            Number.isFinite(input.confidence) &&
-            input.confidence >= 0 &&
-            input.confidence <= 1
-            ? input.confidence
-            : undefined;
-        const proposal = {
-            id: newId(ctx),
-            ref: normalizedRef,
-            status: "pending",
-            source: input.source,
-            ...(input.sourceRun !== undefined ? { sourceRun: input.sourceRun } : {}),
-            createdAt: created,
-            updatedAt: created,
-            payload: {
-                content: input.payload.content,
-                ...(input.payload.frontmatter !== undefined ? { frontmatter: input.payload.frontmatter } : {}),
-            },
-            ...(sanitizedConfidence !== undefined ? { confidence: sanitizedConfidence } : {}),
-        };
-        upsertProposal(db, proposal, stashDir);
-        return proposal;
+        return withImmediateTransaction(db, () => {
+            if (!input.force) {
+                const skip = checkDedupAndCooldown(db, stashDir, normalizedRef, input, ctx);
+                if (skip)
+                    return skip;
+            }
+            const created = nowIso(ctx);
+            // Phase 6A: validate confidence is a finite number in [0, 1]. Anything else
+            // is dropped silently — we never store NaN, Infinity, or out-of-range values.
+            // Callers that mis-report confidence should not poison the auto-accept gate.
+            const sanitizedConfidence = typeof input.confidence === "number" &&
+                Number.isFinite(input.confidence) &&
+                input.confidence >= 0 &&
+                input.confidence <= 1
+                ? input.confidence
+                : undefined;
+            const proposal = {
+                id: newId(ctx),
+                ref: normalizedRef,
+                status: "pending",
+                source: input.source,
+                ...(input.sourceRun !== undefined ? { sourceRun: input.sourceRun } : {}),
+                createdAt: created,
+                updatedAt: created,
+                payload: {
+                    content: input.payload.content,
+                    ...(input.payload.frontmatter !== undefined ? { frontmatter: input.payload.frontmatter } : {}),
+                },
+                ...(sanitizedConfidence !== undefined ? { confidence: sanitizedConfidence } : {}),
+                // Attribution tagging: persist the eligibility lane so it survives to
+                // accept/reject/revert time. See EligibilitySource.
+                ...(input.eligibilitySource !== undefined ? { eligibilitySource: input.eligibilitySource } : {}),
+            };
+            upsertProposal(db, proposal, stashDir);
+            return proposal;
+        });
     });
 }
 /**
@@ -517,19 +522,25 @@ export function resolveProposalId(stashDir, idOrRef, ctx) {
  */
 export function archiveProposal(stashDir, id, status, reason, ctx) {
     return withProposalsDb(stashDir, ctx, (db) => {
-        const existing = requireProposal(db, stashDir, id);
-        const updated = {
-            ...existing,
-            status,
-            updatedAt: nowIso(ctx),
-            review: {
-                outcome: status,
-                ...(reason !== undefined ? { reason } : {}),
-                decidedAt: nowIso(ctx),
-            },
-        };
-        upsertProposal(db, updated, stashDir);
-        return updated;
+        return withImmediateTransaction(db, () => {
+            const existing = requireProposal(db, stashDir, id);
+            if (existing.status !== "pending") {
+                throw new UsageError(`Proposal ${id} is not pending (current status: ${existing.status}). Only pending proposals can be ${status}.`, "INVALID_FLAG_VALUE");
+            }
+            const decidedAt = nowIso(ctx);
+            const updated = {
+                ...existing,
+                status,
+                updatedAt: decidedAt,
+                review: {
+                    outcome: status,
+                    ...(reason !== undefined ? { reason } : {}),
+                    decidedAt,
+                },
+            };
+            upsertProposal(db, updated, stashDir);
+            return updated;
+        });
     });
 }
 /**
@@ -548,15 +559,17 @@ export function archiveProposal(stashDir, id, status, reason, ctx) {
  */
 export function recordGateDecision(stashDir, id, decision, ctx) {
     return withProposalsDb(stashDir, ctx, (db) => {
-        const existing = getStateProposal(db, id, stashDir);
-        if (!existing)
-            return undefined;
-        const updated = {
-            ...existing,
-            gateDecision: { ...decision, decidedAt: decision.decidedAt ?? nowIso(ctx) },
-        };
-        upsertProposal(db, updated, stashDir);
-        return updated;
+        return withImmediateTransaction(db, () => {
+            const existing = getStateProposal(db, id, stashDir);
+            if (!existing || existing.status !== "pending")
+                return undefined;
+            const updated = {
+                ...existing,
+                gateDecision: { ...decision, decidedAt: decision.decidedAt ?? nowIso(ctx) },
+            };
+            upsertProposal(db, updated, stashDir);
+            return updated;
+        });
     });
 }
 /**

package/dist/commands/read/curate.js

@@ -54,6 +54,9 @@ function logCurateEvent(query, result) {
     try {
         const db = openExistingDatabase();
         try {
+            // Summary row (entry_ref = NULL): preserves the query → itemRefs audit
+            // trail. Retrieval counting ignores NULL-ref rows, so this row is purely
+            // informational.
             insertUsageEvent(db, {
                 event_type: "curate",
                 query,
@@ -63,6 +66,20 @@ function logCurateEvent(query, result) {
                 }),
                 source: "user",
             });
+            // Per-item rows with entry_ref populated so curation registers as a real
+            // retrieval signal in getRetrievalCounts (which counts 'curate' events).
+            // Only stash items expose a canonical asset ref; registry hits
+            // (`registry:<id>`) have no asset ref and are skipped here.
+            for (const item of result.items) {
+                if (!("ref" in item) || typeof item.ref !== "string")
+                    continue;
+                insertUsageEvent(db, {
+                    event_type: "curate",
+                    query,
+                    entry_ref: item.ref,
+                    source: "user",
+                });
+            }
         }
         finally {
             closeDatabase(db);

package/dist/commands/sources/stash-cli.js

@@ -71,6 +71,11 @@ export const indexCommand = defineCommand({
             description: "When combined with --clean, report stale entries without deleting them.",
             default: false,
         },
+        background: {
+            type: "boolean",
+            description: "Run as a background process (suppresses interactive output, manages PID file).",
+            default: false,
+        },
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
@@ -80,6 +85,7 @@ export const indexCommand = defineCommand({
             if (getHyphenatedBoolean(args, "re-enrich") || parseFlagValue(process.argv, "--re-enrich") !== undefined) {
                 throw new UsageError("`akm index --re-enrich` has been removed. Re-enrichment of index-time LLM passes is not exposed in this slice.");
             }
+            const isBackground = args.background === true;
             const outputMode = getOutputMode();
             const controller = new AbortController();
             const abort = () => controller.abort(new Error("index interrupted"));
@@ -88,7 +94,7 @@ export const indexCommand = defineCommand({
             const indexLogFile = path.join(getCacheDir(), "logs", "index", `${new Date().toISOString().replace(/[:.]/g, "-")}.log`);
             setLogFile(indexLogFile);
             const verbose = isVerbose();
-            const spin = !verbose && outputMode.format === "text" ? p.spinner() : null;
+            const spin = !verbose && !isBackground && outputMode.format === "text" ? p.spinner() : null;
             if (spin) {
                 spin.start(`Building search index${args.full ? " (full rebuild)" : ""}...`);
             }
@@ -114,7 +120,9 @@ export const indexCommand = defineCommand({
                 if (spin) {
                     spin.stop(`Indexed ${result.totalEntries} assets.`);
                 }
-                output("index", result);
+                if (!isBackground) {
+                    output("index", result);
+                }
             }
             catch (error) {
                 if (spin) {

package/dist/core/config/config-schema.js

@@ -156,6 +156,15 @@ export const ImproveProcessConfigSchema = z
     neighborsPerChanged: z.number().int().min(1).optional(),
     // Distill process: skip distill entirely when reflect produced zero planned refs.
     requirePlannedRefs: z.boolean().optional(),
+    // proactiveMaintenance process (Layer 2): staleness gate + rotation cooldown
+    // in days (default 30). Only meaningful on `proactiveMaintenance`.
+    dueDays: z.number().int().min(0).optional(),
+    // proactiveMaintenance process: top-N bound per run (default 25). Alias for
+    // `limit`; `maxPerRun` wins when both are set.
+    maxPerRun: positiveInt.optional(),
+    // proactiveMaintenance process: optional per-type importance overrides,
+    // merged over the built-in defaults. Only meaningful on `proactiveMaintenance`.
+    importanceWeights: z.record(z.string().min(1), z.number()).optional(),
     // MemoryInference process: minimum pending memory count to run the pass.
     minPendingCount: z.number().int().min(0).optional(),
     // Extract process: minimum number of new (unseen, in-window) candidate
@@ -195,6 +204,7 @@ const ImproveProfileProcessesSchema = z
     graphExtraction: ImproveProcessConfigSchema.optional(),
     validation: ImproveProcessConfigSchema.optional(),
     triage: ImproveProcessConfigSchema.optional(),
+    proactiveMaintenance: ImproveProcessConfigSchema.optional(),
 })
     .passthrough()
     .superRefine((val, ctx) => {
@@ -218,6 +228,7 @@ const ImproveProfileProcessesSchema = z
         "validation",
         "extract",
         "triage",
+        "proactiveMaintenance",
     ]);
     for (const k of Object.keys(raw)) {
         if (!allowed.has(k)) {

package/dist/core/paths.js

@@ -215,6 +215,9 @@ export function getDataDir(env = process.env, platform = process.platform) {
 export function getDbPath() {
     return path.join(getDataDir(), "index.db");
 }
+export function getIndexWriterLockPath() {
+    return path.join(getDataDir(), "index.db.write.lock");
+}
 export function getWorkflowDbPath() {
     return path.join(getDataDir(), "workflow.db");
 }

package/dist/core/state-db.js

@@ -193,7 +193,7 @@ const MIGRATIONS = [
       --   metadata_json TEXT      — JSON object for future proposal fields.
       --                             Current fields stored here: sourceRun,
       --                             review, confidence, gateDecision (#577),
-      --                             backupContent.
+      --                             backupContent, eligibilitySource.
       --
       -- ADD COLUMN extension points (future migrations):
       --   ALTER TABLE proposals ADD COLUMN source_run TEXT DEFAULT NULL;
@@ -488,6 +488,20 @@ const MIGRATIONS = [
       );
     `,
     },
+    // ── Migration 006 — pending proposal lookup index ──────────────────────────
+    //
+    // Supports the transaction-scoped dedup / queue-mutation hardening added in
+    // 0.9.x. The queue now acquires an IMMEDIATE write transaction before it
+    // reads pending proposals, so the hot path is a stash-scoped `status='pending'
+    // AND ref=?` probe followed by an update/insert. This composite index keeps
+    // that lookup index-covered under contention.
+    {
+        id: "006-proposals-pending-ref-source",
+        up: `
+      CREATE INDEX IF NOT EXISTS idx_proposals_stash_status_ref_source
+        ON proposals(stash_dir, status, ref, source);
+    `,
+    },
 ];
 /**
  * Apply every pending migration in a single transaction per migration.
@@ -562,6 +576,9 @@ export function proposalRowToProposal(row) {
         ...(typeof meta.confidence === "number" ? { confidence: meta.confidence } : {}),
         ...(meta.gateDecision !== undefined ? { gateDecision: meta.gateDecision } : {}),
         ...(typeof meta.backupContent === "string" ? { backupContent: meta.backupContent } : {}),
+        ...(typeof meta.eligibilitySource === "string"
+            ? { eligibilitySource: meta.eligibilitySource }
+            : {}),
     };
 }
 /**
@@ -581,6 +598,8 @@ export function proposalToRowValues(proposal, stashDir) {
         metaObj.gateDecision = proposal.gateDecision;
     if (proposal.backupContent !== undefined)
         metaObj.backupContent = proposal.backupContent;
+    if (proposal.eligibilitySource !== undefined)
+        metaObj.eligibilitySource = proposal.eligibilitySource;
     return {
         id: proposal.id,
         stash_dir: stashDir,
@@ -785,6 +804,32 @@ export function insertProposalIfAbsent(db, proposal, stashDir) {
     const changes = result.changes ?? 0;
     return Number(changes) > 0;
 }
+/**
+ * Run `fn` inside a `BEGIN IMMEDIATE` transaction.
+ *
+ * `db.transaction()` is DEFERRED by default on both Bun and better-sqlite3,
+ * which means two writers can both perform stale preflight reads and only race
+ * when they finally attempt the write. Proposal creation and queue mutation
+ * need the write lock BEFORE those reads so concurrent processes serialize on
+ * the live queue state rather than clobbering each other.
+ */
+export function withImmediateTransaction(db, fn) {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        const result = fn();
+        db.exec("COMMIT");
+        return result;
+    }
+    catch (err) {
+        try {
+            db.exec("ROLLBACK");
+        }
+        catch {
+            // Ignore rollback failures so the original error is preserved.
+        }
+        throw err;
+    }
+}
 // ── task_history table helpers ───────────────────────────────────────────────
 /**
  * Upsert a task history row.

package/dist/indexer/db/db.js

@@ -1262,6 +1262,19 @@ export function getEntryIdByFilePath(db, filePath) {
     const row = db.prepare("SELECT id FROM entries WHERE file_path = ? LIMIT 1").get(filePath);
     return row?.id;
 }
+/**
+ * Set of every non-empty `entries.file_path` currently indexed (across all
+ * stashes/sources). Used by staleness detection to spot files that exist on
+ * disk but were never indexed — a clock-independent signal for newly-added
+ * assets that an mtime-vs-builtAt comparison can miss when the two clocks
+ * (filesystem vs wall-clock) are skewed within the same millisecond.
+ */
+export function getIndexedFilePaths(db) {
+    const rows = db
+        .prepare("SELECT DISTINCT file_path FROM entries WHERE file_path IS NOT NULL AND file_path <> ''")
+        .all();
+    return new Set(rows.map((r) => r.file_path));
+}
 /**
  * Resolve a single `entries.file_path` by primary key, or `undefined` if no
  * row matches.
@@ -1477,25 +1490,98 @@ export function computeBodyHash(body) {
     return sha256Hex(body);
 }
 /**
- * Count search and show events for the given entry refs.
- * Returns a Map<ref, count> with only refs that have at least one event.
- * Used by the improve loop to find high-retrieval assets without feedback.
+ * Reduce a ref to its bare `type:name` form, dropping any `origin//` prefix.
+ *
+ * usage_events store entry_ref inconsistently: search/show writers persist
+ * whatever ref the result carried, which is sometimes stash-prefixed
+ * (`origin//type:name`) and sometimes bare (`type:name`). Retrieval counting
+ * keys on the bare form so both spellings of the same asset collapse together.
+ *
+ * Returns the bare form, or the original string when it cannot be parsed (best
+ * effort — never throws so a malformed stored ref can't break counting).
+ */
+function bareRef(ref) {
+    try {
+        const parsed = parseAssetRef(ref);
+        return `${parsed.type}:${parsed.name}`;
+    }
+    catch {
+        return ref;
+    }
+}
+/**
+ * Count retrieval events for the given entry refs.
+ *
+ * Counts `search`, `show`, and `curate` usage events. Returns a
+ * Map<inputRef, count> keyed by the *input* ref strings (only those with at
+ * least one matching event appear). Used by the improve loop to find
+ * high-retrieval assets without feedback.
+ *
+ * Matching is normalization-aware: each stored `entry_ref` is reduced to its
+ * bare `type:name` form before comparison, so a stash-prefixed stored ref
+ * (`origin//type:name`) still matches a bare input ref (`type:name`) and vice
+ * versa. Previously the raw `entry_ref IN (...)` comparison silently dropped
+ * roughly half the signal whenever the two spellings disagreed.
+ *
+ * `curate` events are included: their per-item rows are written with
+ * entry_ref populated (see logCurateEvent), so curation is a real retrieval
+ * signal here. Legacy summary-only curate rows with a NULL entry_ref simply
+ * contribute nothing.
  */
 export function getRetrievalCounts(db, refs) {
     if (refs.length === 0)
         return new Map();
-    const result = new Map();
+    // Map each distinct bare form back to the input ref(s) that produced it so we
+    // can re-key DB results (grouped by bare form) onto the caller's ref strings.
+    const bareToInputs = new Map();
+    for (const ref of refs) {
+        const bare = bareRef(ref);
+        const existing = bareToInputs.get(bare);
+        if (existing)
+            existing.push(ref);
+        else
+            bareToInputs.set(bare, [ref]);
+    }
+    const bareForms = [...bareToInputs.keys()];
+    // Accumulate counts per bare form across chunks before re-keying.
+    const countsByBare = new Map();
     // Chunk to stay within SQLITE_MAX_VARIABLE_NUMBER (same pattern as getUtilityScoresByIds).
-    for (let i = 0; i < refs.length; i += SQLITE_CHUNK_SIZE) {
-        const chunk = refs.slice(i, i + SQLITE_CHUNK_SIZE);
+    for (let i = 0; i < bareForms.length; i += SQLITE_CHUNK_SIZE) {
+        const chunk = bareForms.slice(i, i + SQLITE_CHUNK_SIZE);
         const placeholders = chunk.map(() => "?").join(", ");
+        // Normalize the stored entry_ref to its bare form inside SQL by stripping
+        // everything up to and including the last `//` separator. SQLite has no
+        // rfind, but stored origins never themselves contain `//`, so a stash ref
+        // has exactly one `//` and `substr(... instr ...)` is exact; bare refs have
+        // no `//` and pass through unchanged.
         const rows = db
-            .prepare(`SELECT entry_ref, COUNT(*) AS cnt FROM usage_events
-         WHERE event_type IN ('search','show') AND entry_ref IN (${placeholders})
-         GROUP BY entry_ref`)
+            .prepare(`SELECT
+           CASE
+             WHEN instr(entry_ref, '//') > 0
+               THEN substr(entry_ref, instr(entry_ref, '//') + 2)
+             ELSE entry_ref
+           END AS bare_ref,
+           COUNT(*) AS cnt
+         FROM usage_events
+         WHERE event_type IN ('search','show','curate')
+           AND entry_ref IS NOT NULL
+           AND CASE
+                 WHEN instr(entry_ref, '//') > 0
+                   THEN substr(entry_ref, instr(entry_ref, '//') + 2)
+                 ELSE entry_ref
+               END IN (${placeholders})
+         GROUP BY bare_ref`)
             .all(...chunk);
-        for (const r of rows)
-            result.set(r.entry_ref, r.cnt);
+        for (const r of rows) {
+            countsByBare.set(r.bare_ref, (countsByBare.get(r.bare_ref) ?? 0) + r.cnt);
+        }
+    }
+    // Re-key bare-form counts onto every input ref that maps to that bare form.
+    const result = new Map();
+    for (const [bare, count] of countsByBare) {
+        for (const input of bareToInputs.get(bare) ?? []) {
+            result.set(input, count);
+        }
     }
     return result;
 }