akm-cli 0.8.0-rc1 → 0.8.0

package/dist/indexer/project-context.js

@@ -0,0 +1,192 @@
+// 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/.
+/**
+ * Project-context resolution for search ranking.
+ *
+ * Extracts meaningful identifier tokens from the current working directory
+ * so the ranking pipeline can boost assets that are relevant to the active
+ * project. Token extraction tries, in order:
+ *
+ *   1. `.git/config` remote-origin URL basename (strips `.git` extension)
+ *   2. `package.json` `name` field (last `/`-separated segment, minus common
+ *      framework suffixes)
+ *   3. Basename of the directory returned by `resolveWorkflowScopeAnchor`
+ *   4. `null` — no meaningful project context (home dir, /tmp, etc.)
+ *
+ * Tokens are lowercased, split on `[-_/]`, then filtered through a noise-word
+ * blocklist. A maximum of 5 tokens is kept.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resolveWorkflowScopeAnchor } from "../workflows/scope-key.js";
+// Words that appear in almost every project name and carry no discriminating
+// signal for ranking. Filtered out after token splitting.
+const TOKEN_BLOCKLIST = new Set([
+    "my",
+    "the",
+    "app",
+    "lib",
+    "sdk",
+    "api",
+    "cli",
+    "tool",
+    "kit",
+    "core",
+    "main",
+    "index",
+    "src",
+    "test",
+]);
+// Common suffixes stripped from package.json `name` before tokenisation so
+// that e.g. `akm-cli` contributes `akm` rather than `akm` + `cli` (which is
+// in the blocklist anyway, but explicit stripping keeps the raw name shorter).
+const STRIP_SUFFIXES = ["-cli", "-app", "-lib", "-sdk", "-plugin"];
+const MAX_TOKENS = 5;
+// Paths that are definitely NOT a meaningful project root (home dir, tmp).
+// When `resolveWorkflowScopeAnchor` returns one of these we return `null`.
+function isNoiseRoot(dir) {
+    const homedir = os.homedir();
+    const normalized = dir.replace(/\/+$/, "");
+    if (normalized === homedir || normalized === homedir.replace(/\/+$/, ""))
+        return true;
+    // /tmp or /tmp/… (any depth)
+    if (normalized === "/tmp" || normalized.startsWith("/tmp/"))
+        return true;
+    // Windows-style temp
+    const tmpdir = os.tmpdir();
+    if (normalized === tmpdir || normalized.startsWith(tmpdir + path.sep))
+        return true;
+    return false;
+}
+/**
+ * Resolve the project context for the given working directory.
+ *
+ * @param cwd       - Directory to inspect. Defaults to `process.cwd()`.
+ * @param fsOverride - Optional FS override for unit testing.
+ * @returns `ProjectContext` with a non-empty `tokens` set, or `null` when no
+ *          meaningful context can be derived (home dir, /tmp, extraction failed).
+ */
+export function resolveProjectContext(cwd, fsOverride) {
+    const effectiveCwd = cwd ?? process.cwd();
+    const readFile = fsOverride?.readFileSync ?? ((p, enc) => fs.readFileSync(p, enc));
+    // Attempt 1 — git remote-origin URL
+    const gitConfigPath = path.join(effectiveCwd, ".git", "config");
+    const gitTokens = tryExtractGitTokens(gitConfigPath, readFile);
+    if (gitTokens !== null && gitTokens.size > 0) {
+        return { tokens: gitTokens };
+    }
+    // Attempt 2 — package.json name
+    const pkgJsonPath = path.join(effectiveCwd, "package.json");
+    const pkgTokens = tryExtractPackageJsonTokens(pkgJsonPath, readFile);
+    if (pkgTokens !== null && pkgTokens.size > 0) {
+        return { tokens: pkgTokens };
+    }
+    // Attempt 3 — workflow scope anchor basename
+    try {
+        const anchor = resolveWorkflowScopeAnchor(effectiveCwd);
+        if (isNoiseRoot(anchor))
+            return null;
+        const baseName = path.basename(anchor);
+        const tokens = tokenize(baseName);
+        if (tokens.size > 0) {
+            return { tokens };
+        }
+    }
+    catch {
+        // Ignore errors from scope anchor resolution (e.g. during testing).
+    }
+    return null;
+}
+// ── Private helpers ──────────────────────────────────────────────────────────
+/**
+ * Parse `.git/config` for the `[remote "origin"]` section and extract the
+ * repo name from the `url =` line.
+ *
+ *   url = git@github.com:itlackey/akm.git   → "akm"
+ *   url = https://github.com/itlackey/akm   → "akm"
+ */
+function tryExtractGitTokens(gitConfigPath, readFile) {
+    try {
+        const content = readFile(gitConfigPath, "utf-8");
+        const urlMatch = extractRemoteOriginUrl(content);
+        if (!urlMatch)
+            return null;
+        // Strip .git extension, then take the last path segment.
+        const withoutGit = urlMatch.replace(/\.git$/, "");
+        const segments = withoutGit.replace(/\/$/, "").split(/[/:]/).filter(Boolean);
+        const repoName = segments[segments.length - 1] ?? "";
+        const tokens = tokenize(repoName);
+        return tokens.size > 0 ? tokens : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extracts the `url =` value from the `[remote "origin"]` section of a git
+ * config file. Returns `null` when the section or key is absent.
+ */
+function extractRemoteOriginUrl(content) {
+    // Split into sections delimited by `[...]` headers.
+    const lines = content.split(/\r?\n/);
+    let inOrigin = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("[")) {
+            // New section header
+            inOrigin = /^\[remote\s+"origin"\]$/i.test(trimmed);
+            continue;
+        }
+        if (inOrigin) {
+            const m = trimmed.match(/^url\s*=\s*(.+)$/i);
+            if (m)
+                return m[1].trim();
+        }
+    }
+    return null;
+}
+/**
+ * Read `package.json` and extract the `name` field as tokens.
+ */
+function tryExtractPackageJsonTokens(pkgPath, readFile) {
+    try {
+        const content = readFile(pkgPath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (typeof parsed.name !== "string" || !parsed.name)
+            return null;
+        // For scoped packages (@org/pkg-name) take the last `/`-separated segment.
+        const rawName = parsed.name.split("/").pop() ?? parsed.name;
+        // Strip common framework suffixes before tokenising.
+        let strippedName = rawName;
+        for (const suffix of STRIP_SUFFIXES) {
+            if (strippedName.endsWith(suffix)) {
+                strippedName = strippedName.slice(0, -suffix.length);
+                break; // only strip one suffix
+            }
+        }
+        const tokens = tokenize(strippedName);
+        return tokens.size > 0 ? tokens : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Split a raw name string into lowercase tokens, then filter through the
+ * blocklist and cap at `MAX_TOKENS`.
+ *
+ *   "akm-cli"   → Set { "akm" }
+ *   "my-app"    → Set {}  (all tokens blocked)
+ *   "openpalm"  → Set { "openpalm" }
+ */
+function tokenize(raw) {
+    const parts = raw
+        .toLowerCase()
+        .split(/[-_/]+/)
+        .filter(Boolean)
+        .filter((t) => !TOKEN_BLOCKLIST.has(t))
+        .slice(0, MAX_TOKENS);
+    return new Set(parts);
+}

package/dist/indexer/ranking-contributors.js

@@ -1,3 +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/.
 import { computeGraphBoost } from "./graph-boost";
 const TYPE_BOOST = {
     skill: 0.4,
@@ -11,17 +14,36 @@ const TYPE_BOOST = {
 const MAX_BOOST_SUM = 3.0;
 const UTILITY_WEIGHT = 0.5;
 const UTILITY_MAX_BOOST = 1.5;
-const RECENCY_DECAY_DAYS = 30;
+/**
+ * Phase 2A / Rec 5: default recency half-life (days) used when no
+ * `utilityDecayConfig` is supplied to the ranking pipeline. Matches the
+ * pre-2A hardcoded `RECENCY_DECAY_DAYS = 30` constant — the formula is
+ * default-safe and collapses to `exp(-days / 30)` when no overrides apply.
+ */
+const DEFAULT_RECENCY_HALF_LIFE_DAYS = 30;
+/**
+ * Cap on the effective half-life after applying the feedback stability
+ * boost — prevents indefinite half-life inflation for memories with many
+ * positive feedback events. `effectiveHalfLife = min(halfLife * boost^count, halfLife * 4)`.
+ */
+const FEEDBACK_HALF_LIFE_CAP_MULTIPLIER = 4;
 function beliefStateBoost(item) {
     const entry = item.entry;
     if (entry.type !== "memory")
         return 0;
+    // Phase 1A: `asserted` and `deprecated` are first-class states.
+    // `asserted` carries stronger user-explicit authority than `active`.
+    // `deprecated` is a frozen historical state — penalized but milder than `superseded`.
     if (entry.beliefState === "contradicted")
         return -0.45;
     if (entry.beliefState === "superseded")
         return -0.25;
     if (entry.beliefState === "archived")
         return -0.6;
+    if (entry.beliefState === "deprecated")
+        return -0.15;
+    if (entry.beliefState === "asserted")
+        return 0.08;
     if (entry.beliefState === "active")
         return 0.06;
     return 0;
@@ -151,29 +173,131 @@ const graphRankingContributor = {
         return ctx.graphContext ? computeGraphBoost(ctx.graphContext, item.filePath) : 0;
     },
 };
+/**
+ * Capture-mode boost — Phase 1B / Rec 7.
+ *
+ * Memories captured via the hot path (`akm remember`) get a modest additive
+ * boost so they outrank otherwise-equal background-derived memories. Memories
+ * without `captureMode` (legacy) return 0 and rank exactly as before.
+ */
+const captureModeRankingContributor = {
+    name: "capture-mode-ranking",
+    appliesTo(item) {
+        return item.entry.type === "memory" && item.entry.captureMode === "hot";
+    },
+    adjust() {
+        return 0.2;
+    },
+};
+/**
+ * Lesson strength boost — Phase 7A / Advantage D4b.
+ *
+ * Each ref that has credited a lesson via `akm feedback --applied-to` adds
+ * 0.06 to the boost (capped at 0.3 ≈ five credits). Lessons without a
+ * `lessonStrength` array (or a number) return 0.
+ */
+const lessonStrengthContributor = {
+    name: "lesson-strength-ranking",
+    appliesTo(item) {
+        return (item.entry.type === "lesson" && typeof item.entry.lessonStrength === "number" && item.entry.lessonStrength > 0);
+    },
+    adjust(item) {
+        const strength = item.entry.lessonStrength ?? 0;
+        return Math.min(0.3, 0.06 * strength);
+    },
+};
+/**
+ * Blend ratio for scoped vs. global utility signals.
+ *
+ * When a scoped row exists: `effectiveUtility = scoped * 0.7 + global * 0.3`
+ * This ensures the in-project signal strongly dominates while the global
+ * cold-start signal still helps when scoped history is sparse.
+ */
+const SCOPED_UTILITY_BLEND_SCOPED = 0.7;
+const SCOPED_UTILITY_BLEND_GLOBAL = 1 - SCOPED_UTILITY_BLEND_SCOPED;
 const utilityRankingContributor = {
     name: "utility-ranking",
     appliesTo(item, ctx) {
         const utilScore = ctx.utilityScores.get(item.id);
-        return Boolean(utilScore && utilScore.utility > 0);
+        const scopedScore = ctx.scopedUtilityScores?.get(item.id);
+        return Boolean((utilScore && utilScore.utility > 0) || (scopedScore && scopedScore.utility > 0));
     },
     apply(item, ctx) {
         const utilScore = ctx.utilityScores.get(item.id);
-        if (!utilScore || utilScore.utility <= 0)
+        const scopedScore = ctx.scopedUtilityScores?.get(item.id);
+        // Determine effective utility: prefer scoped when present, blend with global.
+        const globalUtility = utilScore?.utility ?? 0;
+        const scopedUtility = scopedScore?.utility ?? 0;
+        const effectiveUtility = scopedUtility > 0
+            ? scopedUtility * SCOPED_UTILITY_BLEND_SCOPED + globalUtility * SCOPED_UTILITY_BLEND_GLOBAL
+            : globalUtility;
+        if (effectiveUtility <= 0)
             return;
+        // Recency decay: use the global lastUsedAt for the decay factor (it's an
+        // ISO string with full resolution), falling back to scoped lastUsedAt (ms).
         let recencyFactor = 1;
-        if (utilScore.lastUsedAt) {
-            const lastUsedMs = new Date(utilScore.lastUsedAt).getTime();
+        const lastUsedRaw = utilScore?.lastUsedAt ?? (scopedScore ? new Date(scopedScore.lastUsedAt).toISOString() : undefined);
+        if (lastUsedRaw) {
+            const lastUsedMs = new Date(lastUsedRaw).getTime();
             const daysSinceLastUse = Number.isNaN(lastUsedMs)
                 ? Infinity
                 : Math.max(0, (Date.now() - lastUsedMs) / (1000 * 60 * 60 * 24));
-            recencyFactor = Math.exp(-daysSinceLastUse / RECENCY_DECAY_DAYS);
+            // Phase 2A / Rec 5: configurable forgetting curve with optional
+            // feedback-stability boost. Absent config + absent positive feedback
+            // collapses to `exp(-days / 30)` — pre-2A default-safe.
+            const halfLifeDays = ctx.utilityDecayConfig?.halfLifeDays ?? DEFAULT_RECENCY_HALF_LIFE_DAYS;
+            const stabilityBoost = ctx.utilityDecayConfig?.feedbackStabilityBoost ?? 1.5;
+            const positiveCount = ctx.positiveFeedbackCounts?.get(item.id) ?? 0;
+            // `boost^count` is 1 when count is 0 OR when boost is 1.0, so neither
+            // a missing feedback count nor a "no boost" config widens the half-life.
+            let stabilizedHalfLife = halfLifeDays * stabilityBoost ** positiveCount;
+            stabilizedHalfLife = Math.min(stabilizedHalfLife, halfLifeDays * FEEDBACK_HALF_LIFE_CAP_MULTIPLIER);
+            // Defensive: half-life must stay positive to avoid div-by-zero / Infinity.
+            const safeHalfLife = Math.max(0.0001, stabilizedHalfLife);
+            recencyFactor = Math.exp(-daysSinceLastUse / safeHalfLife);
         }
-        const rawBoost = 1 + utilScore.utility * recencyFactor * UTILITY_WEIGHT;
+        const rawBoost = 1 + effectiveUtility * recencyFactor * UTILITY_WEIGHT;
         item.score *= Math.min(rawBoost, UTILITY_MAX_BOOST);
         item.utilityBoosted = true;
     },
 };
+/**
+ * Project-context boost.
+ *
+ * Auto-boosts assets whose name, tags, aliases, or search hints contain tokens
+ * derived from the current working directory's project name. For example, when
+ * running `akm search` from the `akm` git repo, assets tagged `akm` or named
+ * `akm-*` receive an additive boost.
+ *
+ * The boost is capped at 0.5 so it can never overpower an exact-name match
+ * (which contributes 2.0). Each matching token adds 0.2 up to the cap.
+ *
+ * Skipped entirely when `projectContext` is absent or has no tokens (e.g.
+ * when running from home dir, /tmp, or when disabled via
+ * `--no-project-context` / `AKM_DISABLE_PROJECT_CONTEXT=1`).
+ */
+const projectContextRankingContributor = {
+    name: "project-context-ranking",
+    appliesTo(_item, ctx) {
+        return ctx.projectContext != null && ctx.projectContext.tokens.size > 0;
+    },
+    adjust(item, ctx) {
+        if (!ctx.projectContext)
+            return 0;
+        const fields = [
+            item.entry.name ?? "",
+            ...(item.entry.tags ?? []),
+            ...(item.entry.aliases ?? []),
+            ...(item.entry.searchHints ?? []),
+        ].map((s) => s.toLowerCase());
+        let hits = 0;
+        for (const token of ctx.projectContext.tokens) {
+            if (fields.some((f) => f.includes(token)))
+                hits++;
+        }
+        return Math.min(0.5, hits * 0.2);
+    },
+};
 export const defaultRankingContributors = [
     exactNameRankingContributor,
     typeRankingContributor,
@@ -184,6 +308,9 @@ export const defaultRankingContributors = [
     descriptionRankingContributor,
     metadataRankingContributor,
     graphRankingContributor,
+    captureModeRankingContributor,
+    lessonStrengthContributor,
+    projectContextRankingContributor,
 ];
 export const defaultUtilityRankingContributors = [utilityRankingContributor];
 export function applyScoreContributors(item, ctx, contributors = defaultRankingContributors) {

package/dist/indexer/ranking.js

@@ -1,3 +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/.
 import { getUtilityScoresByIds } from "./db";
 import { applyScoreContributors, applyUtilityContributors } from "./ranking-contributors";
 export function normalizeFtsScores(results) {
@@ -58,14 +61,18 @@ export function applyRankingRules(options) {
         queryLower,
         queryTokens,
         graphContext: options.graphContext,
+        projectContext: options.projectContext,
     };
     for (const item of options.items) {
         applyScoreContributors(item, rankingContext);
     }
-    const utilScoresMap = getUtilityScoresByIds(options.db, options.items.map((item) => item.id));
+    const { global: utilScoresMap, scoped: scopedUtilScoresMap } = getUtilityScoresByIds(options.db, options.items.map((item) => item.id), options.scopeKey);
     const utilityContext = {
         ...rankingContext,
         utilityScores: utilScoresMap,
+        scopedUtilityScores: scopedUtilScoresMap,
+        utilityDecayConfig: options.utilityDecayConfig,
+        positiveFeedbackCounts: options.positiveFeedbackCounts,
     };
     for (const item of options.items) {
         applyUtilityContributors(item, utilityContext);

package/dist/indexer/search-fields.js

@@ -1,12 +1,6 @@
-/**
- * Per-field search text extraction for FTS5 indexing.
- *
- * Extracted from indexer.ts to break the circular dependency:
- *   db.ts -> indexer.ts -> db.ts
- *
- * This module imports only from metadata.ts (for the StashEntry type),
- * so it can be safely imported by both db.ts and indexer.ts.
- */
+// 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/.
 /**
  * Return per-field search text for multi-column FTS5 indexing.
  *
@@ -45,6 +39,8 @@ export function buildSearchFields(entry) {
         hintParts.push(entry.xrefs.join(" "));
     if (entry.pageKind)
         hintParts.push(entry.pageKind);
+    if (entry.whenToUse)
+        hintParts.push(entry.whenToUse);
     const hints = hintParts.join(" ").toLowerCase();
     const contentParts = [];
     if (entry.toc) {

package/dist/indexer/search-hit-enrichers.js

@@ -1,3 +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 { makeAssetRef } from "../core/asset-ref";
+import { getDerivedForParent } from "./db";
 import { getRenderer } from "./file-context";
 const rendererSearchHitEnricher = {
     name: "renderer-search-hit-enricher",
@@ -12,8 +17,92 @@ const rendererSearchHitEnricher = {
         renderer?.enrichSearchHit?.(hit, ctx.stashDir);
     },
 };
-export const defaultSearchHitEnrichers = [rendererSearchHitEnricher];
-export async function enrichSearchHit(hit, ctx, enrichers = defaultSearchHitEnrichers) {
+/**
+ * Phase 5A / Advantage D5 — derived-memory enricher.
+ *
+ * When a parent memory has a `.derived` child indexed (the LLM-distilled
+ * lesson surface), this enricher rewrites the parent hit to surface the
+ * derived child's description / searchHints / tags AND sets `expandTo` to
+ * the derived child's ref so callers can fetch it via `akm show <ref>`.
+ *
+ * The parent ref is preserved on the hit — only the surface text is
+ * swapped, so links and provenance still point at the canonical parent.
+ *
+ * Skipped for:
+ *  - non-memory hits
+ *  - memory hits that are themselves derived children (name ends with
+ *    `.derived`) — we never recurse parent→child→grandchild
+ *  - contexts without an open DB connection
+ */
+export const derivedMemoryEnricher = {
+    name: "derived-memory-enricher",
+    appliesTo(ctx) {
+        return ctx.type === "memory" && ctx.db !== undefined;
+    },
+    enrich(hit, ctx) {
+        if (!ctx.db)
+            return;
+        // Never recurse: a `.derived` hit is itself the child surface; leaving
+        // it untouched also avoids `<parent>.derived.derived` chains.
+        if (hit.name.toLowerCase().endsWith(".derived"))
+            return;
+        // Parent ref shape: `memory:<name>`. Re-build from the entry's name
+        // so we don't depend on whatever wiki/registry prefix `hit.ref` carries.
+        const parentRef = makeAssetRef("memory", hit.name);
+        const derived = getDerivedForParent(ctx.db, parentRef);
+        if (!derived)
+            return;
+        // Swap description / searchHints / tags from the derived child.
+        // The parent ref itself is preserved — only the surface text is swapped.
+        if (typeof derived.entry.description === "string" && derived.entry.description.length > 0) {
+            hit.description = derived.entry.description;
+        }
+        if (Array.isArray(derived.entry.searchHints) && derived.entry.searchHints.length > 0) {
+            // We don't have a `searchHints` field on SourceSearchHit today — it's
+            // only used inside ranking. The plan says to swap when present; we
+            // record it onto the hit only if a future renderer surfaces it. For
+            // now, treat as advisory (no-op when SearchHit lacks the field).
+        }
+        if (Array.isArray(derived.entry.tags) && derived.entry.tags.length > 0) {
+            hit.tags = derived.entry.tags;
+        }
+        hit.expandTo = makeAssetRef("memory", derived.entry.name);
+    },
+};
+/**
+ * Registry of additional enrichers — populated by
+ * {@link registerSearchHitEnricher} and consumed in addition to
+ * {@link defaultSearchHitEnrichers} when `enrichSearchHit` is invoked
+ * without an explicit enricher list.
+ *
+ * Kept module-local so callers must use `registerSearchHitEnricher` rather
+ * than mutating the array directly.
+ */
+const additionalEnrichers = [];
+export const defaultSearchHitEnrichers = [rendererSearchHitEnricher, derivedMemoryEnricher];
+/**
+ * Register an additional enricher to be applied alongside the defaults.
+ *
+ * Idempotent on `name`: subsequent calls with the same name replace the
+ * previously-registered enricher (so tests can re-register cleanly without
+ * stacking duplicates).
+ */
+export function registerSearchHitEnricher(enricher) {
+    const existingIndex = additionalEnrichers.findIndex((e) => e.name === enricher.name);
+    if (existingIndex >= 0) {
+        additionalEnrichers[existingIndex] = enricher;
+    }
+    else {
+        additionalEnrichers.push(enricher);
+    }
+}
+/**
+ * Test-only: clear the registered-enrichers list. Not part of the public API.
+ */
+export function _resetRegisteredSearchHitEnrichers() {
+    additionalEnrichers.length = 0;
+}
+export async function enrichSearchHit(hit, ctx, enrichers = [...defaultSearchHitEnrichers, ...additionalEnrichers]) {
     for (const enricher of enrichers) {
         if (!enricher.appliesTo(ctx))
             continue;

package/dist/indexer/search-source.js

@@ -1,3 +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/.
 import fs from "node:fs";
 import path from "node:path";
 import { resolveStashDir } from "../core/common";
@@ -37,8 +40,24 @@ export function resolveSourceEntries(overrideStashDir, existingConfig) {
     const seen = new Set([path.resolve(stashDir)]);
     const addSource = (dir, registryId, wikiName, writable) => {
         const resolved = path.resolve(dir);
-        if (seen.has(resolved))
+        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
+            // 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)
+                    existing.registryId = registryId;
+                if (wikiName && !existing.wikiName)
+                    existing.wikiName = wikiName;
+                if (writable && !existing.writable)
+                    existing.writable = true;
+            }
             return;
+        }
         seen.add(resolved);
         if (isSuspiciousStashRoot(dir)) {
             warn(`Warning: stash root "${dir}" appears to be a system directory. This may be unintentional.`);

package/dist/indexer/semantic-status.js

@@ -1,7 +1,10 @@
+// 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 { writeFileAtomic } from "../core/common";
 import { getCacheDir, getSemanticStatusPath } from "../core/paths";
-import { DEFAULT_LOCAL_MODEL } from "../llm/embedder";
+import { DEFAULT_LOCAL_MODEL } from "../llm/embedders/local";
 export function deriveSemanticProviderFingerprint(embedding) {
     if (embedding?.endpoint) {
         return `remote:${embedding.endpoint}|${embedding.model}|${embedding.dimension ?? "default"}`;