akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/indexer/search/ranking.js

@@ -1,98 +1,8 @@
 // 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/.
-import fs from "node:fs";
-import { conceptIdFromTypeName } from "../../core/asset/resolve-ref.js";
-import { acquireMaintenanceActivitySync } from "../../core/maintenance-barrier.js";
-import { getStateDbPath } from "../../core/state-db.js";
-import { openDatabase } from "../../storage/database.js";
 import { getUtilityScoresByIds } from "../../storage/repositories/index-utility-repository.js";
 import { applyBeliefStateScoreCeiling, applyContributorAblation, applyScoreContributors, applyUtilityContributors, defaultRankingContributors, defaultUtilityRankingContributors, } from "./ranking-contributors.js";
-/**
- * R2 — best-effort load of `asset_salience.rank_score` from state.db for the
- * ranked items. Fail-open: any error (state.db locked by a concurrent improve
- * run, missing table, unreadable path) returns an empty map, which makes the
- * salience contributor a no-op — byte-identical to pre-R2 ranking.
- *
- * Deliberately NOT `openStateDatabase()`: that helper runs migrations and sets
- * a 30 s busy timeout — too heavy for a search hot path. This opens read-only,
- * never creates or migrates state.db (missing file / missing table = empty
- * map), and caps lock waits at 250 ms so a concurrent improve run can only
- * ever cost the search a quarter second, not a stall.
- */
-export function loadSalienceRankScores(items) {
-    const result = new Map();
-    if (items.length === 0)
-        return result;
-    try {
-        const dbPath = getStateDbPath();
-        if (!fs.existsSync(dbPath))
-            return result; // improve loop has never run here
-        const releaseActivity = acquireMaintenanceActivitySync("state-db");
-        // Fold both durable salience spellings into the single `IN` query, keyed
-        // back to the entry id (Chunk-8 WI-8.5c — the legacy `type:name` arm is
-        // retired):
-        //   • the fully-qualified `item_ref` (`<bundle>//<conceptId>`) — what the
-        //     improve writer keys salience by when the planner resolved provenance;
-        //   • the bare conceptId — the write-key fallback for entries with no
-        //     resolved `item_ref` (`item_ref` NULL is the bare form of the same key).
-        // Output is keyed by id, so a fully-qualified match wins over the bare-conceptId
-        // match for the same asset id.
-        const idByRef = new Map();
-        try {
-            for (const item of items) {
-                // Bare-conceptId arm (the item_ref-absent write-key fallback).
-                idByRef.set(conceptIdFromTypeName(item.entry.type, item.entry.name), { id: item.id, isNew: false });
-                // Fully-qualified `item_ref` arm (skipped for NULL-provenance rows).
-                if (item.itemRef)
-                    idByRef.set(item.itemRef, { id: item.id, isNew: true });
-            }
-            const stateDb = openDatabase(dbPath, { readonly: true });
-            try {
-                try {
-                    stateDb.exec("PRAGMA busy_timeout = 250");
-                }
-                catch {
-                    // pragma failure on a readonly handle is fine — default timeout applies
-                }
-                const refs = [...idByRef.keys()];
-                const CHUNK = 500;
-                const newHits = new Set();
-                for (let i = 0; i < refs.length; i += CHUNK) {
-                    const chunk = refs.slice(i, i + CHUNK);
-                    const placeholders = chunk.map(() => "?").join(",");
-                    const rows = stateDb
-                        .prepare(`SELECT asset_ref, rank_score FROM asset_salience WHERE asset_ref IN (${placeholders})`)
-                        .all(...chunk);
-                    for (const row of rows) {
-                        const target = idByRef.get(row.asset_ref);
-                        if (!target)
-                            continue;
-                        // New-grammar match wins over a stale legacy row for the same id;
-                        // a legacy match applies only when no new row has claimed the id.
-                        if (target.isNew) {
-                            result.set(target.id, row.rank_score);
-                            newHits.add(target.id);
-                        }
-                        else if (!newHits.has(target.id)) {
-                            result.set(target.id, row.rank_score);
-                        }
-                    }
-                }
-            }
-            finally {
-                stateDb.close();
-            }
-        }
-        finally {
-            releaseActivity();
-        }
-    }
-    catch {
-        // Fail open — search must never break because state.db is unavailable.
-    }
-    return result;
-}
 export function normalizeFtsScores(results) {
     const ftsScoreMap = new Map();
     if (results.length === 0)
@@ -124,6 +34,8 @@ export function combineSearchScores(options) {
             score: combinedScore,
             rankingMode: embedScore !== undefined ? "hybrid" : "fts",
             itemRef: result.itemRef,
+            bundleId: result.bundleId,
+            conceptId: result.conceptId,
         });
     }
     for (const [id, cosine] of options.embedScoreMap) {
@@ -144,6 +56,8 @@ export function combineSearchScores(options) {
             score: cosine * VEC_WEIGHT,
             rankingMode: "semantic",
             itemRef: found.itemRef,
+            bundleId: found.bundleId,
+            conceptId: found.conceptId,
         });
     }
     return scored;
@@ -159,21 +73,26 @@ export function applyRankingRules(options) {
         graphContext: options.graphContext,
         projectContext: options.projectContext,
     };
-    // Eval/debug only: AKM_ABLATE_CONTRIBUTORS lets the ablation harness drop
-    // named contributors to measure their effect. Resolved once per query;
-    // a no-op (full lists) when the env var is unset — see applyContributorAblation.
-    const ablateEnv = process.env.AKM_ABLATE_CONTRIBUTORS;
+    // Eval/debug only: lets the ablation harness drop named contributors to
+    // measure their effect. Resolved once per query; a no-op (full lists) when
+    // unset — see applyContributorAblation. C9: DI via
+    // `options.ablateContributors` is now the primary path (see the field's
+    // doc comment on RankEntriesOptions); AKM_ABLATE_CONTRIBUTORS is a
+    // temporary fallback for the one caller that cannot yet thread the option
+    // through (see that doc comment for why).
+    const ablateEnv = options.ablateContributors ?? process.env.AKM_ABLATE_CONTRIBUTORS;
     const activeScoreContributors = applyContributorAblation(defaultRankingContributors, ablateEnv);
     const activeUtilityContributors = applyContributorAblation(defaultUtilityRankingContributors, ablateEnv);
     for (const item of options.items) {
         applyScoreContributors(item, rankingContext, activeScoreContributors);
     }
     const { global: utilScoresMap, scoped: scopedUtilScoresMap } = getUtilityScoresByIds(options.db, options.items.map((item) => item.id), options.scopeKey);
-    // R2 — compose the improve loop's salience into user-facing ranking.
-    // undefined = load from state.db (default); null = explicitly disabled.
-    const salienceRankScores = options.salienceRankScores === null
-        ? new Map()
-        : (options.salienceRankScores ?? loadSalienceRankScores(options.items));
+    // R2 / #692 — salience-ranking is not in defaultUtilityRankingContributors
+    // (see ranking-contributors.ts), so this is never consumed by the default
+    // ranking path below; it exists only for a caller that explicitly builds a
+    // contributor list including salienceRankingContributor. undefined/null
+    // both normalize to "no data" — there is no state.db fallback load.
+    const salienceRankScores = options.salienceRankScores ?? new Map();
     const utilityContext = {
         ...rankingContext,
         utilityScores: utilScoresMap,

package/dist/indexer/search/search-fields.js

@@ -17,7 +17,8 @@
 // scored via FTS against it. Changing what buildSearchFields includes shifts
 // the detector's recall baseline for ALL existing canary sets — coordinate
 // with src/commands/improve/collapse-detector.ts (buildCanaryQuery) and expect
-// operators to re-mint via `akm improve canary --refresh` after such a change.
+// operators to re-mint via `bun scripts/refresh-canary-set.ts --refresh` after
+// such a change.
 export function buildSearchFields(entry) {
     const name = entry.name.replace(/[-_]/g, " ").toLowerCase();
     const description = (entry.description ?? "").toLowerCase();
@@ -28,6 +29,8 @@ export function buildSearchFields(entry) {
         tagParts.push(entry.aliases.join(" "));
     const tags = tagParts.join(" ").toLowerCase();
     const hintParts = [];
+    if (entry.hints)
+        hintParts.push(entry.hints.join(" "));
     if (entry.searchHints)
         hintParts.push(entry.searchHints.join(" "));
     if (entry.examples)
@@ -50,6 +53,8 @@ export function buildSearchFields(entry) {
         hintParts.push(entry.whenToUse);
     const hints = hintParts.join(" ").toLowerCase();
     const contentParts = [];
+    if (entry.content)
+        contentParts.push(entry.content);
     if (entry.toc) {
         contentParts.push(entry.toc.map((h) => h.text).join(" "));
     }
@@ -74,7 +79,7 @@ export function buildSearchFields(entry) {
 }
 /**
  * Build a single concatenated search text string for an entry.
- * Used for the `search_text` column in the entries table (backward compat)
+ * Used for the `search_text` column in the entries table.
  * and for generating embedding text.
  */
 export function buildSearchText(entry) {

package/dist/indexer/search/search-source.js

@@ -4,85 +4,101 @@
 import fs from "node:fs";
 import path from "node:path";
 import { isSourceWriteActivated } from "../../core/activation-policy.js";
-import { displayRef } from "../../core/asset/resolve-ref.js";
-import { resolveStashDir } from "../../core/common.js";
-import { bundlesToSourceEntries, getSources, loadConfig } from "../../core/config/config.js";
-import { resolveGitContentRoot } from "../../core/write-source.js";
-import { lockContentRootFor, readLockfile } from "../../integrations/lockfile.js";
+import { isWithin, resolveStashDir } from "../../core/common.js";
+import { bundleComponentConfig, bundlesToSourceEntries, getSources, loadConfig } from "../../core/config/config.js";
+import { resolveGitContentRoot, resolveWritable } from "../../core/write-source.js";
+import { lockContentRootFor } from "../../integrations/lockfile.js";
 import { resolveSourceProviderFactory } from "../../sources/provider-factory.js";
 // Eager side-effect imports so all built-in source providers self-register
 // before resolveEntryContentDir() runs.
 import "../../sources/providers/index.js";
 import { warn } from "../../core/warn.js";
-// Legacy "context-hub" / "github" type aliases are normalized to "git" at
-// config-load time (see src/config.ts), so this set only contains the canonical
-// type.
-const GIT_STASH_TYPES = new Set(["git"]);
 // ── Resolution ──────────────────────────────────────────────────────────────
 /**
  * Build the ordered list of stash sources, walking every configured stash
  * once. Iteration order:
  *
- *   1. The primary stash directory (the entry marked `primary: true`, or the
- *      legacy top-level `stashDir`). Always emitted, even when the directory
- *      does not yet exist on disk, so callers can use it as the clone target.
- *   2. Each entry in `config.sources[]` (in declared order), excluding the
- *      one already emitted as the primary.
- *   3. Each entry in `config.installed[]` (registry-managed stashes).
+ *   1. An explicit argument or `AKM_BUNDLE_DIR`, when present.
+ *   2. The configured `defaultBundle`, after component-root validation.
+ *   3. Remaining configured bundles in installation-priority order.
  *
  * Replaces the previous four-pass loop that walked `stashes[]` separately
- * for each provider kind. Disabled entries (`enabled: false`) and entries
- * whose disk path doesn't exist are filtered after deduplication.
+ * for each provider kind. Disabled entries (`enabled: false`) are filtered
+ * after deduplication. Missing configured roots remain in the result so the
+ * indexer can classify their scan as incomplete instead of mistaking them for
+ * removed sources.
  */
 export function resolveSourceEntries(overrideStashDir, existingConfig) {
-    const stashDir = overrideStashDir ?? resolveStashDir();
     const config = existingConfig ?? loadConfig();
-    // Primary stash is always writable.
-    const sources = [{ path: stashDir, writable: true }];
-    const seen = new Set([path.resolve(stashDir)]);
-    const addSource = (dir, registryId, writable) => {
+    const configuredEntries = bundlesToSourceEntries(config) ?? [];
+    const envOverride = process.env.AKM_BUNDLE_DIR?.trim();
+    const implicitStashDir = overrideStashDir !== undefined
+        ? path.resolve(overrideStashDir)
+        : envOverride
+            ? resolveStashDir()
+            : config.defaultBundle
+                ? undefined
+                : resolveStashDir();
+    // Explicit and environment overrides stay first. Without either override,
+    // the configured default enters through the validated loop below.
+    const sources = implicitStashDir ? [{ path: implicitStashDir, writable: true }] : [];
+    const seen = new Set(implicitStashDir ? [implicitStashDir] : []);
+    const addSource = (dir, registryId, writable, type, adapterId, unresolved = false) => {
         const resolved = path.resolve(dir);
         if (seen.has(resolved)) {
             // Already in the source list — typically the primary stash injected at
             // sources[0] before this loop. Enrich that entry with whatever metadata
-            // the matching config source carries so `--source <config-name>` can
+            // the matching config source carries so `--from <config-name>` can
             // find it via registryId. Without this, the primary stash entry stays
             // identity-less and a user-named primary source ("name": "my-stash")
             // would validate but match zero entries when filtering.
             const existing = sources.find((s) => s.path === resolved);
-            if (existing) {
-                if (registryId && !existing.registryId)
+            if (existing && existing.type === undefined) {
+                if (registryId)
                     existing.registryId = registryId;
-                if (writable && !existing.writable)
-                    existing.writable = true;
+                existing.type = type;
+                existing.writable = writable;
+                existing.adapterId = adapterId;
             }
+            if (existing && unresolved)
+                existing.unresolved = true;
             return;
         }
         seen.add(resolved);
         if (isSuspiciousStashRoot(dir)) {
             warn(`Warning: stash root "${dir}" appears to be a system directory. This may be unintentional.`);
         }
-        if (isValidDirectory(dir)) {
-            sources.push({
-                path: resolved,
-                ...(registryId ? { registryId } : {}),
-                ...(writable ? { writable: true } : {}),
-            });
-        }
+        sources.push({
+            path: resolved,
+            ...(registryId ? { registryId } : {}),
+            writable,
+            type,
+            ...(adapterId ? { adapterId } : {}),
+            ...(unresolved ? { unresolved: true } : {}),
+        });
     };
     // 0.9.0 shape (spec §10.1 / D-R5): resolve from `bundles` + `defaultBundle`.
-    // `bundlesToSourceEntries` returns the source list ordered defaultBundle-first
-    // (already injected as the primary via `resolveStashDir` above), then map
-    // insertion order — folding the retired sources[]/installed[] roles into one
-    // list. Each entry's `name` is its bundle key, so the addSource `registryId`
-    // == the bundle id. A config with no bundles yields just the primary stash.
-    for (const entry of bundlesToSourceEntries(config) ?? []) {
+    // `bundlesToSourceEntries` returns the configured default first, then map
+    // insertion order. Each entry is validated before insertion so a component
+    // root can never escape its provider's materialized content root.
+    for (const entry of configuredEntries) {
         if (entry.enabled === false)
             continue;
-        const dir = resolveEntryContentDir(entry);
-        if (dir == null)
+        const component = bundleComponentConfig(config.bundles?.[entry.name ?? ""]);
+        const contentRoot = resolveEntryContentDir(entry);
+        if (contentRoot == null) {
+            const unresolvedPath = path.join(implicitStashDir ?? process.cwd(), ".akm", "unresolved-sources", entry.name ?? entry.type);
+            addSource(unresolvedPath, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, true);
+            continue;
+        }
+        const dir = path.resolve(contentRoot, component?.root ?? ".");
+        if (!isWithin(dir, contentRoot)) {
+            warn(`Warning: component root "${component?.root}" escapes bundle "${entry.name}"; skipping source.`);
+            const unresolvedPath = path.join(contentRoot, ".akm", "unresolved-sources", entry.name ?? entry.type);
+            addSource(unresolvedPath, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, true);
             continue;
-        addSource(dir, entry.name, entry.writable === true);
+        }
+        addSource(dir, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter);
     }
     return sources;
 }
@@ -138,7 +154,7 @@ export function resolveEntryContentDir(entry) {
     // layout puts indexable files under `<repo>/content/`, so the walker needs
     // that subdirectory. This is a content-layout convention, not a provider
     // capability — keep it here.
-    if (GIT_STASH_TYPES.has(entry.type)) {
+    if (entry.type === "git") {
         return resolveGitContentRoot(dir);
     }
     return dir;
@@ -151,11 +167,6 @@ export function resolveAllStashDirs(overrideStashDir) {
 }
 /**
  * Return the resolved absolute paths of all writable stash sources.
- *
- * The primary stash is always writable. Filesystem/git sources that have
- * `writable: true` in config are also included. Registry-cached sources
- * (installed without `writable: true`) are excluded because they are
- * overwritten on `akm update` and must never be mutated.
  */
 export function getWritableStashDirs(overrideStashDir, existingConfig) {
     return resolveSourceEntries(overrideStashDir, existingConfig)
@@ -194,46 +205,22 @@ export function getPrimarySource(sources) {
 }
 // ── Editability ─────────────────────────────────────────────────────────────
 /**
- * Determine whether a file is safe to edit in place.
- *
- * 0.9.0 (spec §10.2 / Decision D): the files that are NOT editable are those
- * under a bundle's materialized cache root (the lock's `localRoot`) whose bundle
- * is not explicitly `writable` — `akm update` overwrites them without warning.
- * The read-only decision is re-expressed via bundle `writable` + lock `localRoot`
- * (replacing the retired `installed[].cacheDir` scan); a writable git/filesystem
- * bundle stays editable, and a source with no lock entry (a plain filesystem
- * bundle / local project dir) is the user's domain to manage.
+ * Determine whether AKM policy allows modifying this exact file in place.
+ * Ownership is resolved by longest source-root match and unknown ownership
+ * fails closed. Resolved sources already carry canonical `resolveWritable()`
+ * semantics; editability is never persisted in the index.
  */
-export function isEditable(filePath, config) {
-    const cfg = config ?? loadConfig();
-    const resolved = path.resolve(filePath);
-    const isWin = process.platform === "win32";
-    const bundles = cfg.bundles ?? {};
-    const startsWithin = (root) => {
-        const base = path.resolve(root);
-        return isWin
-            ? resolved.toLowerCase().startsWith(base.toLowerCase() + path.sep)
-            : resolved.startsWith(base + path.sep);
-    };
-    for (const lock of readLockfile()) {
-        if (!lock.localRoot)
-            continue;
-        // The lock is keyed by bundle id, so writability comes from that bundle.
-        const writable = bundles[lock.id]?.writable === true;
-        if (!writable && startsWithin(lock.localRoot))
-            return false;
-    }
-    return true;
+export function isEditable(filePath, config, sources) {
+    const resolvedSources = sources ?? resolveSourceEntries(undefined, config ?? loadConfig());
+    return findSourceForPath(filePath, resolvedSources)?.writable === true;
 }
 /**
  * Build an actionable hint for the agent when a file is not editable.
  * Callers must check `isEditable()` before calling — this function
  * unconditionally returns the hint string.
  */
-export function buildEditHint(_filePath, assetType, assetName, origin) {
-    // F4b output-spelling flip: emit the 0.9.0 conceptId grammar for the clone hint.
-    const ref = displayRef({ type: assetType, name: assetName, bundleId: origin });
-    return `This asset is managed by akm and may be overwritten on update. To edit, run: akm clone ${ref}`;
+export function buildEditHint(ref) {
+    return `This asset is read-only under current AKM source policy. To make an editable copy, run: akm clone ${ref}`;
 }
 // ── Validation ──────────────────────────────────────────────────────────────
 const SUSPICIOUS_ROOTS = new Set(["/", "/etc", "/bin", "/sbin", "/usr", "/var", "/tmp", "/dev", "/proc", "/sys"]);
@@ -250,15 +237,6 @@ function isSuspiciousStashRoot(dir) {
     }
     return false;
 }
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function isValidDirectory(dir) {
-    try {
-        return fs.statSync(dir).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
 // ── Stash cache integration ─────────────────────────────────────────────────
 /**
  * Ensure all cache-backed stash providers are refreshed so their cache
@@ -295,6 +273,17 @@ export async function ensureSourceCaches(config, options) {
     for (const entry of getSources(cfg)) {
         if (entry.enabled === false)
             continue;
+        const lockedRoot = lockContentRootFor(entry.name, entry.type);
+        if (lockedRoot) {
+            if (!isMaterializedDir(lockedRoot)) {
+                warn(`Warning: managed source "${entry.name}" is missing its locked materialization at ${lockedRoot}; ` +
+                    `run \`akm bundle update ${entry.name}\` to restore it.`);
+            }
+            // Managed installs are refreshed only by add/update. Hydrating the URL-
+            // derived provider cache here would create a second checkout while reads
+            // and writes continue using the lock root.
+            continue;
+        }
         const factory = resolveSourceProviderFactory(entry.type);
         if (!factory)
             continue;
@@ -315,7 +304,7 @@ export async function ensureSourceCaches(config, options) {
             continue;
         }
         try {
-            await provider.sync({ force });
+            await provider.sync({ force, secrets: options?.secrets });
         }
         catch (err) {
             warn(`Warning: failed to refresh ${provider.kind} source "${provider.name}": ${err instanceof Error ? err.message : String(err)}`);
@@ -355,5 +344,5 @@ function warnIfSourceUnavailableForRead(entry, providerName) {
     if (dir && isMaterializedDir(dir))
         return;
     warn(`Warning: source "${providerName}" is not materialized locally; skipping it for this read. ` +
-        "Run `akm index` (or `akm source update`) to fetch it.");
+        "Run `akm index` (or `akm bundle update`) to fetch it.");
 }

package/dist/indexer/usage/usage-events.js

@@ -1,14 +1,6 @@
 // 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/.
-/**
- * Usage event helpers for telemetry and utility-based re-ranking.
- *
- * Schema (created by ensureUsageEventsSchema):
- *   id, event_type, query, entry_id (nullable), entry_ref, signal, metadata, source, created_at
- */
-import { stashDirFor } from "../../core/asset/asset-placement.js";
-import { typeNameFromConceptId } from "../../core/asset/resolve-ref.js";
 const USAGE_EVENT_SOURCES = new Set(["user", "improve", "task", "audit", "unknown"]);
 /** Resolve subprocess provenance without treating an invalid value as user demand. */
 export function resolveUsageEventSource(env = process.env) {
@@ -51,88 +43,7 @@ export function insertUsageEvent(db, event) {
         /* fire-and-forget: silently ignore errors */
     }
 }
-/**
- * Bare-form candidates a bare `entry_ref` filter matches a stored row under.
- * The durable `usage_events.entry_ref` column straddles the F5 ref-grammar flip:
- * F4c-indexed rows carry the new-grammar conceptId (`memories/alpha`) while
- * transitional / not-yet-re-keyed rows still carry the legacy `type:name`
- * (`memory:alpha`). Both name the SAME asset, so a bare filter in EITHER grammar
- * must bridge to the other spelling — otherwise a history/telemetry query misses
- * half the asset's own events across the flip boundary. (Fully-qualified filters
- * apply this bridge under a fixed origin — see getUsageEvents.)
- */
-function usageEventBareCandidates(ref) {
-    const trimmed = ref.trim();
-    const out = new Set([trimmed]);
-    // New-grammar conceptId (`memories/alpha`) → its legacy `type:name` sibling.
-    const legacy = typeNameFromConceptId(trimmed);
-    if (legacy)
-        out.add(`${legacy.type}:${legacy.name}`);
-    // Legacy `type:name` (`memory:alpha`) → its new-grammar `stashDir/name` sibling.
-    const colon = trimmed.indexOf(":");
-    if (colon > 0) {
-        const dir = stashDirFor(trimmed.slice(0, colon));
-        if (dir)
-            out.add(`${dir}/${trimmed.slice(colon + 1)}`);
-    }
-    return [...out];
-}
 // ── Query ────────────────────────────────────────────────────────────────────
-/**
- * Retrieve usage events, optionally filtered by event_type and/or entry_ref.
- */
-export function getUsageEvents(db, filters) {
-    const conditions = [];
-    const params = [];
-    if (filters?.event_type) {
-        conditions.push("event_type = ?");
-        params.push(filters.event_type);
-    }
-    if (filters?.entry_ref) {
-        if (filters.entry_ref.includes("//")) {
-            // Fully-qualified filter (`bundle//conceptId` or legacy `origin//type:name`)
-            // — the user named a specific bundle/origin, so match that origin exactly,
-            // but bridge the bare tail across the F5 grammar flip (see
-            // usageEventBareCandidates) so a `stash//memories/alpha` filter also matches
-            // an un-re-keyed `stash//memory:alpha` row (and vice versa).
-            const boundary = filters.entry_ref.indexOf("//");
-            const origin = filters.entry_ref.slice(0, boundary);
-            const bareTail = filters.entry_ref.slice(boundary + 2);
-            const quals = usageEventBareCandidates(bareTail).map((bare) => `${origin}//${bare}`);
-            conditions.push(`entry_ref IN (${quals.map(() => "?").join(", ")})`);
-            params.push(...quals);
-        }
-        else {
-            // Bare filter — match the stored bare form (everything after the first
-            // `//`, or the whole value when un-qualified) against the conceptId the
-            // filter normalizes to.
-            const candidates = usageEventBareCandidates(filters.entry_ref);
-            const placeholders = candidates.map(() => "?").join(", ");
-            conditions.push(`(CASE WHEN instr(entry_ref, '//') > 0 THEN substr(entry_ref, instr(entry_ref, '//') + 2) ELSE entry_ref END) ` +
-                `IN (${placeholders})`);
-            params.push(...candidates);
-        }
-    }
-    if (filters?.source) {
-        if (filters.source === "unknown") {
-            conditions.push("(source = 'unknown' OR source IS NULL OR source = '')");
-        }
-        else {
-            conditions.push("source = ?");
-            params.push(filters.source);
-        }
-    }
-    if (filters?.since) {
-        conditions.push("created_at >= ?");
-        params.push(filters.since);
-    }
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const sql = `SELECT id, event_type, query, entry_id, entry_ref, signal, metadata, source, created_at
-               FROM usage_events ${where}
-               ORDER BY id ASC`;
-    const rows = db.prepare(sql).all(...params);
-    return rows.map((row) => ({ ...row, source: row.source || "unknown" }));
-}
 /**
  * Aggregate positive/negative feedback counts for a single entry.
  *

package/dist/indexer/walk/file-context.js

@@ -107,11 +107,12 @@ export async function getAllRenderers() {
  * Build a RenderContext by merging a FileContext with its winning MatchResult
  * and the list of stash search paths.
  */
-export function buildRenderContext(ctx, match, stashDirs, origin) {
+export function buildRenderContext(ctx, match, stashDirs, origin, defaultBundle) {
     return {
         ...ctx,
         matchResult: match,
         stashDirs,
         origin,
+        defaultBundle,
     };
 }