akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/indexer/scan/drain-dir.js

@@ -15,29 +15,24 @@
  *    via the renderer contributor's throw → metadata-pass skip-with-warning; the
  *    `akm` adapter's synchronous `foldRecognizedMetadata` SWALLOWS the parse
  *    error, so a broken workflow would otherwise silently index. We re-run
- *    `parseWorkflow` / `parseWorkflowProgram` on drained workflow docs and DROP
+ *    `parseWorkflow` on drained workflow docs and DROP
  *    the entry with the same `Skipped workflow …` warning
  *    ({@link buildMetadataSkipWarning}), so the workflow-skip summary counts it.
  *  - **Workflow-document side-table (workflow-md only).** The valid parsed
  *    `WorkflowDocument` is handed to the persist layer through the same
  *    `document-cache` side channel the live renderer contributor used, keyed by
  *    the reconstructed entry — so `takeWorkflowDocument(entry)` in the persist
- *    loop writes the `workflow_documents` row exactly as before. YAML programs
- *    are re-parsed from disk by the runtime loader, so they carry no cache row
- *    (mirrors the live path).
+ *    loop writes the `workflow_documents` row exactly as before.
  *
  * `doc.hash` (= sha256 of the file content) is surfaced per recognized file so
  * the persist layer can populate the `content_hash` column (item 2). It is keyed
- * by the file's absolute path (stable across the legacy-sidecar merge,
- * which rebuilds entry objects) rather than by the entry object.
+ * by the file's absolute path rather than by the entry object.
  *
  * Pure of DB/global state beyond the workflow-document side channel; a new leaf
  * (nothing imports it back), so it joins no import cycle.
  */
 import { akmAdapter } from "../../core/adapter/adapters/akm-adapter.js";
 import { parseWorkflow } from "../../workflows/parser.js";
-import { parseWorkflowProgram } from "../../workflows/program/parser.js";
-import { WORKFLOW_PROGRAM_RENDERER_NAME } from "../../workflows/program/project.js";
 import { cacheWorkflowDocument } from "../../workflows/runtime/document-cache.js";
 import { buildMetadataSkipWarning } from "../passes/metadata.js";
 import { buildFileContext } from "../walk/file-context.js";
@@ -62,6 +57,10 @@ export function drainDirDocuments(adapter, component, fileContexts) {
         const doc = adapter.recognize(component, file);
         if (doc === null)
             continue;
+        if (!doc.conceptId) {
+            warnings.push(`Skipped ${file.absPath}: adapter "${adapter.id}" returned no conceptId.`);
+            continue;
+        }
         const entry = indexDocumentToStashEntry(doc);
         // Workflow docs: drop-with-warning if broken; otherwise cache the parsed
         // markdown document for the persist-time `workflow_documents` write.
@@ -72,8 +71,7 @@ export function drainDirDocuments(adapter, component, fileContexts) {
         }
         if (doc.hash !== undefined)
             hashByFile.set(file.absPath, doc.hash);
-        if (doc.conceptId !== undefined)
-            conceptIdByFile.set(file.absPath, doc.conceptId);
+        conceptIdByFile.set(file.absPath, doc.conceptId);
         entries.push(entry);
     }
     return { entries, warnings, hashByFile, conceptIdByFile };
@@ -106,20 +104,12 @@ export function recognizeStashEntries(stashRoot, files) {
  * `null` immediately.
  */
 function handleWorkflowDoc(doc, entry, file) {
-    const renderer = docRenderer(doc);
-    if (renderer === WORKFLOW_MD_RENDERER) {
-        const result = parseWorkflow(file.content(), { path: file.relPath });
-        if (!result.ok)
-            return workflowDropWarning(file, result.errors);
-        cacheWorkflowDocument(entry, result.document);
+    if (docRenderer(doc) !== WORKFLOW_MD_RENDERER)
         return null;
-    }
-    if (renderer === WORKFLOW_PROGRAM_RENDERER_NAME) {
-        const result = parseWorkflowProgram(file.content(), { path: file.relPath });
-        if (!result.ok)
-            return workflowDropWarning(file, result.errors);
-        return null;
-    }
+    const result = parseWorkflow(file.content(), { path: file.relPath });
+    if (!result.ok)
+        return workflowDropWarning(file, result.errors);
+    cacheWorkflowDocument(entry, result.document);
     return null;
 }
 /** The winning renderer name the `akm` adapter carries on `documentJson.renderer`, or `undefined`. */

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

@@ -14,8 +14,9 @@
  * implementation, not a "local vs. remote" distinction.
  */
 import fs from "node:fs";
+import path from "node:path";
 import { buildActionFromContributors, defaultActionContributors } from "../../core/action-contributors.js";
-import { placementTypes } from "../../core/asset/asset-placement.js";
+import { stashDirFor } from "../../core/asset/asset-placement.js";
 import { displayRef } from "../../core/asset/resolve-ref.js";
 import { getDbPath } from "../../core/paths.js";
 import { defaultRendererRegistry } from "../../core/type-presentation.js";
@@ -30,7 +31,7 @@ import { ensureIndex } from "../ensure-index.js";
 import { collectGraphRelatedHit, loadGraphBoostContext } from "../graph/graph-boost.js";
 import { isProposedQuality } from "../passes/metadata.js";
 import { resolveProjectContext } from "../walk/project-context.js";
-import { parseRefPrefixQuery, sanitizeFtsQuery } from "./fts-query.js";
+import { parseRefPrefixQuery, parseRetiredTypePrefixQuery, sanitizeFtsQuery } from "./fts-query.js";
 import { applyRankingRules, combineSearchScores, normalizeFtsScores } from "./ranking.js";
 import { attachSearchHitAttribution, copySearchHitAttribution, getSearchHitAttribution } from "./search-attribution.js";
 import { enrichSearchHit } from "./search-hit-enrichers.js";
@@ -44,6 +45,9 @@ import { deriveSemanticProviderFingerprint, getEffectiveSemanticStatus, isSemant
  * actionable without re-introducing read-triggered reindexing.
  */
 const STALE_INDEX_HINT_MS = 7 * 24 * 60 * 60 * 1000;
+function hasIndexedProvenance(entry) {
+    return Boolean(entry.itemRef && entry.bundleId && entry.conceptId);
+}
 function buildStaleIndexHint(db) {
     try {
         const builtAt = getMeta(db, "builtAt");
@@ -59,21 +63,19 @@ function buildStaleIndexHint(db) {
         return undefined;
     }
 }
+function indexedProvenance(entry) {
+    return { itemRef: entry.itemRef, bundleId: entry.bundleId, conceptId: entry.conceptId };
+}
 export function buildLocalAction(type, ref, registry = defaultRendererRegistry) {
     return buildActionFromContributors({ type, ref }, defaultActionContributors(registry)) ?? `akm show ${ref}`;
 }
-function resolveSearchHitRef(entry, refName, source) {
-    // F4b output-spelling flip: emit the 0.9.0 conceptId grammar for the hit's
-    // user-facing ref (short conceptId in the primary bundle, `bundle//conceptId`
-    // for a slug-clean non-default source). `displayRef` prefers the row's stored
-    // conceptId and derives `stashDir/name` (== the old `stashDir/name` body) when it
-    // is absent, so this is a pure ref-spelling change over the old output.
+function resolveSearchHitRef(entry, provenance, defaultBundleId) {
     return displayRef({
         type: entry.type,
-        name: refName,
-        conceptId: entry.conceptId,
-        bundleId: source?.registryId ?? undefined,
-    });
+        name: entry.name,
+        conceptId: provenance.conceptId,
+        bundleId: provenance.bundleId,
+    }, defaultBundleId);
 }
 function resolveSearchHitOrigin(source) {
     return source?.registryId ?? null;
@@ -130,7 +132,26 @@ export async function searchLocal(input) {
         }
     }
     if (config.semanticSearchMode === "auto" && semanticStatus === "blocked") {
-        warnings.push("Semantic search is currently blocked. Using keyword search until the semantic backend is healthy again.");
+        if (!config.embedding?.endpoint || !config.embedding?.model) {
+            // F7/A2: same predicate as the `pending` branch above (#480) — a
+            // `blocked` status can outlive the provider config that produced it
+            // (e.g. the embedding config was later unset). This is not a fault;
+            // there is simply nothing configured to use.
+            warnings.push("Semantic search is enabled (semanticSearchMode='auto') but no embedding provider is configured. " +
+                'Either: (a) `akm config set embedding \'{"endpoint":"...","model":"..."}\'`, or ' +
+                "(b) `akm config set semanticSearchMode off` to use keyword-only search.");
+        }
+        else {
+            // F7/A2: surface the ACTUAL diagnostic instead of one fixed generic
+            // string. `rawStatus.reason`/`rawStatus.message` record why the
+            // semantic backend failed (auth, network, a stuck local-model
+            // download, …) — read at `readSemanticStatus()` above and, before
+            // this fix, discarded here in favor of a message that never varied.
+            const detail = rawStatus?.message ?? (rawStatus?.reason ? `reason: ${rawStatus.reason}` : undefined);
+            warnings.push(`Semantic search is blocked${detail ? ` (${detail})` : ""}. Using keyword search until the semantic ` +
+                "backend is healthy again. Run 'akm index --full' to retry, or " +
+                "`akm config set semanticSearchMode off` to silence this warning.");
+        }
     }
     // Bootstrap-only: builds the index inline when it cannot serve this stash.
     // Content freshness is the writers' job (indexWrittenAssets + full runs);
@@ -162,9 +183,7 @@ export async function searchLocal(input) {
         const { hits, embedMs, rankMs, usedSemantic } = await searchDatabase(db, query, searchType, limit, stashDir, allSourceDirs, config, sources, rendererRegistry, filters, includeProposed, beliefFilter, restrictToSources, includeExcludedTypes, disableProjectContext, disableScopedUtility);
         return {
             hits,
-            tip: hits.length === 0
-                ? "No matching stash assets were found. Try a different query or run 'akm index' to rebuild."
-                : undefined,
+            tip: hits.length === 0 ? emptyResultTip(query) : undefined,
             warnings: warnings.length > 0 ? warnings : undefined,
             embedMs,
             rankMs,
@@ -185,14 +204,15 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
     // `includeExcludedTypes`. When the config key is ABSENT a built-in default of
     // ['session'] is applied; an explicit empty list disables exclusion.
     const defaultExcludes = searchType === "any" && !includeExcludedTypes ? (config.search?.defaultExcludeTypes ?? ["session"]) : [];
-    // SPEC-4 — ref-prefix queries (`<type>:` / `<type>:<prefix>/`) translate to
-    // a typed enumeration narrowed by name prefix, instead of degenerating into
-    // the AND-token FTS query their sanitized form would produce ("memory
-    // projecta" — noise). The branch fires only on the untyped path: an explicit
-    // `--type` flag expresses stronger intent and wins. The PARSED type is
-    // itself explicit intent, so `defaultExcludeTypes` does not apply — a bare
-    // `session:` enumerates sessions exactly like `--type session` does.
-    const refPrefix = searchType === "any" ? parseRefPrefixQuery(query, placementTypes()) : null;
+    // D4 — conceptId-prefix queries (`memories/projecta/`, `bundle//`,
+    // `bundle//skills/`) translate to a deterministic enumeration narrowed by
+    // conceptId, instead of degenerating into the AND-token FTS query their
+    // sanitized form would produce ("memories projecta" — noise). The branch
+    // fires only on the untyped path: an explicit `--type` flag expresses
+    // stronger intent and wins. The PREFIX is itself explicit intent, so
+    // `defaultExcludeTypes` does not apply — `sessions/` enumerates sessions
+    // exactly like `--type session` does, and `bundle//` means the whole bundle.
+    const refPrefix = searchType === "any" ? parseRefPrefixQuery(query) : null;
     // Shared args for the two browse paths below; browse never runs semantic
     // ranking, so both return usedSemantic: false.
     const browseArgs = {
@@ -210,13 +230,13 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
         restrictToSources,
     };
     if (refPrefix) {
-        // Browse path (ref-prefix enumeration).
+        // Browse path (conceptId-prefix enumeration).
         return {
             ...(await enumerateEntries({
                 ...browseArgs,
-                typeFilter: refPrefix.type,
                 excludeTypes: [],
-                namePrefix: refPrefix.namePrefix,
+                conceptIdPrefix: refPrefix.conceptIdPrefix,
+                ...(refPrefix.bundle !== undefined ? { bundle: refPrefix.bundle } : {}),
             })),
             usedSemantic: false,
         };
@@ -272,7 +292,7 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
         // not leak into default ('any') results. defaultExcludes is already []
         // unless this is the untyped path without includeExcludedTypes.
         excludeTypes: defaultExcludes,
-    });
+    }).filter(hasIndexedProvenance);
     // ── Scoring Phase ──────────────────────────────────────────────────────
     // Apply boosts as multiplicative factors (all boosts in a single phase
     // so that sort order and displayed scores are always consistent).
@@ -298,7 +318,7 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
     })();
     // Resolve project-context tokens from the current working directory once
     // per search invocation. Returns null when running from home dir / /tmp,
-    // or when the caller has set AKM_DISABLE_PROJECT_CONTEXT=1.
+    // or when the caller passed `--no-project-context` (disableProjectContext).
     const projectContext = disableProjectContext ? null : resolveProjectContext(process.cwd());
     // Phase 2A / Rec 5: resolve forgetting-curve config and skip the feedback
     // count query when the boost cannot make a difference (default ≤ 1.0 means
@@ -316,7 +336,8 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
         ? getPositiveFeedbackCountsByIds(scored.map((item) => item.id))
         : undefined;
     // Resolve per-project scope key for scoped utility scoring.
-    // AKM_DISABLE_SCOPED_UTILITY=1 opts out (e.g. for registry searches or tests).
+    // `disableScopedUtility` (wired from `akm search --no-project-context`)
+    // opts out (e.g. for registry searches or tests).
     let scopeKey;
     try {
         scopeKey = disableScopedUtility ? undefined : getCurrentWorkflowScopeKey();
@@ -365,9 +386,6 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
     const displayScore = (s) => Math.round(Math.min(1, Math.max(0, s)) * 10000) / 10000;
     preFilter.sort((a, b) => displayScore(b.score) - displayScore(a.score) || a.entry.name.localeCompare(b.entry.name));
     // Deduplicate by file path — keep only the highest-scored entry per file.
-    // Multiple legacy-sidecar entries can map to the same file (e.g. entries without
-    // a filename field all collapse to files[0]). Showing the same path/ref
-    // multiple times clutters results.
     const deduped = deduplicateByPath(preFilter);
     // Source → scope → proposed-quality → derived-twin belief inheritance →
     // belief: the post-candidate filter chain shared with enumerateEntries (see
@@ -396,7 +414,7 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
         return buildDbHit({
             entry,
             path: filePath,
-            // Round to 4 decimal places
+            ...indexedProvenance(ranked),
             score: Math.round(finalScore * 10000) / 10000,
             query,
             rankingMode,
@@ -413,18 +431,33 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
     }));
     return { embedMs, rankMs, hits, usedSemantic };
 }
+/**
+ * The no-hits tip. A query in the retired `<type>:` / `<type>:<prefix>/` browse
+ * grammar gets the conceptId spelling that replaces it: without this it comes
+ * back empty and silent, which is the failure D4 removed the grammar to avoid.
+ */
+function emptyResultTip(query) {
+    const generic = "No matching stash assets were found. Try a different query or run 'akm index' to rebuild.";
+    const retired = parseRetiredTypePrefixQuery(query);
+    if (!retired)
+        return generic;
+    const root = stashDirFor(retired.type);
+    if (!root)
+        return generic;
+    return `No matching stash assets were found. The '<type>:' browse grammar was removed in 0.9.0 — use the conceptId spelling: 'akm search "${root}/${retired.rest}"'.`;
+}
 // ── Enumeration (browse) path ────────────────────────────────────────────────
 /**
  * Enumerate index entries without FTS scoring — the browse path shared by
- * empty/unsearchable queries and SPEC-4 ref-prefix queries (`<type>:` /
- * `<type>:<prefix>/`). Applies the same post-ranking filters as the scored
+ * empty/unsearchable queries and D4 conceptId-prefix queries (`memories/`,
+ * `bundle//`, `bundle//skills/`). Applies the same post-ranking filters as the scored
  * path (source narrowing, scope, proposed-quality, belief) before the limit
  * slice. Hits carry the fixed browse score 1 in type-then-name order — this is
  * a deterministic listing, not a relevance ranking.
  */
 async function enumerateEntries(opts) {
     const { db, query, sources, config, rendererRegistry, filters, beliefFilter } = opts;
-    const allEntries = getAllEntries(db, opts.typeFilter, opts.excludeTypes);
+    const allEntries = getAllEntries(db, opts.typeFilter, opts.excludeTypes).filter(hasIndexedProvenance);
     // Explicit listing order: type, then name, then filePath. The underlying
     // SELECT carries no ORDER BY, so its row order tracks the query plan and the
     // index-insertion (file-walk) order — both machine-dependent. A browse
@@ -432,11 +465,17 @@ async function enumerateEntries(opts) {
     allEntries.sort((a, b) => a.entry.type.localeCompare(b.entry.type) ||
         a.entry.name.localeCompare(b.entry.name) ||
         a.filePath.localeCompare(b.filePath));
-    // SPEC-4: narrow to the requested subtree. `startsWith` on the full
-    // slash-retaining prefix is exact — "projecta/" cannot match a sibling
-    // "projectalpha/…" scope.
-    const namePrefix = opts.namePrefix?.toLowerCase() ?? "";
-    const prefixFiltered = namePrefix.length > 0 ? allEntries.filter((ie) => ie.entry.name.toLowerCase().startsWith(namePrefix)) : allEntries;
+    // D4: narrow to the requested bundle and subtree. Matching is against the
+    // conceptId — the spelling every emitted `ref` carries — so a ref copied out
+    // of search output round-trips back in. `startsWith` on the full
+    // slash-retaining prefix is exact: "memories/projecta/" cannot match a
+    // sibling "memories/projectalpha/…" scope.
+    const bundle = opts.bundle?.toLowerCase();
+    const bundleFiltered = bundle === undefined ? allEntries : allEntries.filter((ie) => ie.bundleId.toLowerCase() === bundle);
+    const conceptIdPrefix = opts.conceptIdPrefix?.toLowerCase() ?? "";
+    const prefixFiltered = conceptIdPrefix.length > 0
+        ? bundleFiltered.filter((ie) => ie.conceptId.toLowerCase().startsWith(conceptIdPrefix))
+        : bundleFiltered;
     // Deduplicate by file path — multiple entries can share the same file
     const seenFilePaths = new Set();
     const uniqueEntries = prefixFiltered.filter((ie) => {
@@ -464,6 +503,9 @@ async function enumerateEntries(opts) {
     const hits = await Promise.all(selected.map((ie) => buildDbHit({
         entry: ie.entry,
         path: ie.filePath,
+        itemRef: ie.itemRef,
+        bundleId: ie.bundleId,
+        conceptId: ie.conceptId,
         score: 1,
         query,
         rankingMode: "fts",
@@ -502,10 +544,10 @@ async function enumerateEntries(opts) {
  */
 function applyEntryFilters(items, opts) {
     const { filters } = opts;
-    // Source filter: when the caller narrowed `sources` via `--source <name>`,
+    // Source filter: when the caller narrowed `sources` via `--from <name>`,
     // drop entries whose filePath does not live under any requested source. The
     // FTS/enumerate index spans every configured source, so without this filter a
-    // narrowed --source request would still leak results from other sources.
+    // narrowed --from request would still leak results from other sources.
     const sourceFiltered = opts.restrictToSources
         ? items.filter((item) => findSourceForPath(item.filePath, opts.sources) !== undefined)
         : items;
@@ -598,7 +640,8 @@ async function tryVecScores(db, query, k, config) {
 // ── Hit building ────────────────────────────────────────────────────────────
 export async function buildDbHit(input) {
     const rendererRegistry = input.rendererRegistry ?? defaultRendererRegistry;
-    const entryStashDir = findSourceForPath(input.path, input.sources)?.path ?? input.defaultStashDir;
+    const absolutePath = path.resolve(input.path);
+    const entryStashDir = findSourceForPath(absolutePath, input.sources)?.path ?? input.defaultStashDir;
     // Quality and confidence boosts are now applied in the main scoring
     // phase (searchDatabase). buildDbHit receives the already-final score and
     // passes it through without further multiplication. We still compute the
@@ -611,21 +654,23 @@ export async function buildDbHit(input) {
     const score = Math.round(input.score * 10000) / 10000;
     const graphBoost = getSearchHitAttribution(input.attributionSource ?? {})?.graphExtraction?.boost ?? 0;
     const whyMatched = buildWhyMatched(input.entry, input.query, input.rankingMode, qualityBoost, confidenceBoost, input.utilityBoosted, graphBoost);
-    const graphHit = input.graphContext ? collectGraphRelatedHit(input.graphContext, input.path) : null;
-    const source = findSourceForPath(input.path, input.sources);
-    const ref = resolveSearchHitRef(input.entry, input.entry.name, source);
-    const editable = isEditable(input.path, input.config);
+    const graphHit = input.graphContext ? collectGraphRelatedHit(input.graphContext, absolutePath) : null;
+    const source = findSourceForPath(absolutePath, input.sources);
+    const defaultBundleId = input.config?.defaultBundle ??
+        (source && path.resolve(source.path) === path.resolve(input.defaultStashDir)
+            ? (input.bundleId ?? undefined)
+            : undefined);
+    const ref = resolveSearchHitRef(input.entry, input, defaultBundleId);
+    const editable = isEditable(absolutePath, input.config, input.sources);
     const estimatedTokens = typeof input.entry.fileSize === "number" ? Math.round(input.entry.fileSize / 4) : undefined;
     const hit = {
         type: input.entry.type,
         name: input.entry.name,
-        path: input.path,
+        path: absolutePath,
         ref,
         origin: resolveSearchHitOrigin(source),
         editable,
-        ...(!editable
-            ? { editHint: buildEditHint(input.path, input.entry.type, input.entry.name, source?.registryId) }
-            : {}),
+        ...(!editable ? { editHint: buildEditHint(ref) } : {}),
         description: input.entry.description,
         tags: input.entry.tags,
         size: deriveSize(input.entry.fileSize),
@@ -744,7 +789,7 @@ function deduplicateByPath(items) {
     });
 }
 /**
- * Exact-match scope filter check. Legacy entries without a `scope` object only
+ * Exact-match scope filter check. Entries without a `scope` object only
  * match when no filter is supplied — which is what the caller guards on
  * before invoking this helper.
  */

package/dist/indexer/search/fts-query.js

@@ -52,41 +52,64 @@ export function buildPrefixQuery(ftsQuery) {
     return prefixTokens.join(" ");
 }
 /**
- * SPEC-4 — parse a ref-prefix query (`akm search "<type>:<prefix>/"`).
+ * D4 — parse a conceptId-prefix browse query.
  *
- * Decides whether a raw query is a typed subtree-enumeration request rather
- * than an ordinary keyword search. Matching is deliberately conservative: the
- * trimmed query must be EXACTLY
+ * Decides whether a raw query is a subtree-enumeration request rather than an
+ * ordinary keyword search. Matching is deliberately conservative: the trimmed
+ * query must be EXACTLY
  *
- *   - `<known-type>:`           → enumerate the whole type (namePrefix `""`), or
- *   - `<known-type>:<prefix>/`  → enumerate names under `<prefix>/`.
+ *   - `<conceptId prefix>/`           → that subtree in any bundle,
+ *   - `<bundle>//`                    → one bundle entirely,
+ *   - `<bundle>//<conceptId prefix>/` → that subtree of that bundle.
  *
- * The trailing slash is REQUIRED for a non-empty prefix — and is RETAINED in
- * the returned `namePrefix` — so that a plain `entry.name.startsWith(namePrefix)`
- * check gives exact `/`-boundary subtree semantics (`"projecta/"` cannot match
- * a sibling `projectalpha/…` scope). Bare refs like `memory:a/b` therefore
- * stay ordinary searches (resolving one ref is `akm show` territory), and any
- * interior whitespace disqualifies (prose mentioning a ref is still prose).
+ * The trailing slash is REQUIRED — and is RETAINED in `conceptIdPrefix` — so a
+ * plain `conceptId.startsWith(conceptIdPrefix)` check gives exact `/`-boundary
+ * subtree semantics (`"projecta/"` cannot match a sibling `projectalpha/…`
+ * scope). Bare refs like `memories/a/b` therefore stay ordinary searches
+ * (resolving one ref is `akm show` territory), and any interior whitespace
+ * disqualifies (prose mentioning a ref is still prose).
  *
- * `knownTypes` is passed in by the caller (e.g. `placementTypes()`) to keep
- * this module dependency-free.
+ * The prefix matches the conceptId — the same string every emitted `ref`
+ * carries — so a ref copied out of search output round-trips back in as a
+ * prefix. Nothing here consults a type list: enumeration covers every
+ * adapter's items uniformly, which the retired `<type>:` grammar could not do.
  *
- * Returns `null` when the query is not a ref-prefix request.
+ * Returns `null` when the query is not a browse request.
  */
-export function parseRefPrefixQuery(query, knownTypes) {
+export function parseRefPrefixQuery(query) {
     const trimmed = query.trim();
     if (trimmed.length === 0 || /\s/.test(trimmed))
         return null;
+    const separator = trimmed.indexOf("//");
+    if (separator < 0) {
+        return trimmed.endsWith("/") ? { conceptIdPrefix: trimmed } : null;
+    }
+    const bundle = trimmed.slice(0, separator);
+    if (bundle.length === 0)
+        return null;
+    const rest = trimmed.slice(separator + 2);
+    if (rest === "")
+        return { bundle, conceptIdPrefix: "" };
+    if (rest.endsWith("/") && !rest.includes("//"))
+        return { bundle, conceptIdPrefix: rest };
+    return null;
+}
+/**
+ * Recognize the retired `<type>:` / `<type>:<prefix>/` browse grammar so the
+ * caller can name the replacement spelling rather than letting the query
+ * degrade silently into a keyword search — the exact silent failure D4 removes.
+ * Shape recognition only; mapping the type to its conceptId root belongs to the
+ * caller, which keeps this module dependency-free.
+ */
+export function parseRetiredTypePrefixQuery(query) {
+    const trimmed = query.trim();
+    if (trimmed.length === 0 || /\s/.test(trimmed) || trimmed.includes("//"))
+        return null;
     const colon = trimmed.indexOf(":");
     if (colon <= 0)
         return null;
-    const type = trimmed.slice(0, colon);
-    if (!knownTypes.includes(type))
-        return null;
     const rest = trimmed.slice(colon + 1);
-    if (rest === "")
-        return { type, namePrefix: "" };
-    if (rest.endsWith("/"))
-        return { type, namePrefix: rest };
-    return null;
+    if (rest !== "" && !rest.endsWith("/"))
+        return null;
+    return { type: trimmed.slice(0, colon), rest };
 }

package/dist/indexer/search/ranking-contributors.js

@@ -51,13 +51,19 @@ const MAX_BOOST_SUM = 3.0;
 const UTILITY_WEIGHT = 0.5;
 const UTILITY_MAX_BOOST = 1.5;
 /**
- * R2 — weight of the improve
- * loop's `asset_salience.rank_score` in user-facing ranking. Bounded well
- * below the utility boost so the composed signal refines, never dominates,
- * lexical/semantic relevance. rank_score ∈ [0,1] → boost ∈ [1, 1.2].
+ * R2 / #692 — weight of the improve loop's `asset_salience.rank_score`.
+ * rank_score ∈ [0,1] → boost ∈ [1, 1.2]. Bounded well below the utility boost
+ * so the composed signal would refine, never dominate, lexical/semantic
+ * relevance.
+ *
+ * As of #692 this is NOT wired into default user-facing ranking — see
+ * {@link salienceRankingContributor}'s doc comment. Kept exported (with the
+ * contributor) for a future gated experiment; do not reintroduce it into
+ * {@link defaultUtilityRankingContributors} without a measured
+ * curate-golden-bench delta and an explicit config gate.
  */
-const SALIENCE_WEIGHT = 0.2;
-const SALIENCE_MAX_BOOST = 1.2;
+export const SALIENCE_WEIGHT = 0.2;
+export const SALIENCE_MAX_BOOST = 1.2;
 /**
  * Phase 2A / Rec 5: default recency half-life (days) used when no
  * `utilityDecayConfig` is supplied to the ranking pipeline. Matches the
@@ -113,7 +119,7 @@ function beliefStateBoost(item) {
  * a ceilinged one; demoted entries still list (belief FILTERING stays a
  * separate opt-in axis, `--belief`), and scores already below a ceiling keep
  * their relative ordering. Ceiling order mirrors the additive-penalty
- * severity order pinned in tests/belief-state-phase1a.test.ts:
+ * severity order pinned in tests/integration/belief-state-phase1a.test.ts:
  * deprecated (mildest) > superseded > contradicted > archived.
  */
 const BELIEF_STATE_SCORE_CEILINGS = {
@@ -290,7 +296,7 @@ const graphRankingContributor = {
  *
  * 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.
+ * without `captureMode` return 0.
  */
 const captureModeRankingContributor = {
     name: "capture-mode-ranking",
@@ -404,7 +410,7 @@ const utilityRankingContributor = {
  *
  * 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`).
+ * `--no-project-context`).
  */
 const projectContextRankingContributor = {
     name: "project-context-ranking",
@@ -444,15 +450,31 @@ export const defaultRankingContributors = [
     projectContextRankingContributor,
 ];
 /**
- * R2 — compose the improve loop's salience core into user-facing ranking.
+ * R2 — the improve loop's salience core, as a bounded multiplicative ranking
+ * boost. `asset_salience.rank_score` (encoding + outcome + retrieval
+ * projection, maintained every improve run) otherwise drives only improve's
+ * INTERNAL maintenance selection.
+ *
+ * **#692 — NOT in {@link defaultUtilityRankingContributors}.** Removed from
+ * default user-facing ranking (search/curate): the boost was
+ * retrieval-dominated (`w_r = 0.60` in salience.ts, with no source filter, so
+ * it double-counted the same `usage_events` the utility EMA contributor
+ * already reinforces), warm-started non-zero with no outcome evidence, had
+ * zero pack coverage (favoring only self-generated personal assets), and
+ * measured as noise on live data (max observed multiplier ×1.071). Removing
+ * its default state.db load also deleted a confirmed hot-path defect — see
+ * the now-deleted `loadSalienceRankScores` in `ranking.ts` git history.
  *
- * `asset_salience.rank_score` (encoding + outcome + retrieval projection,
- * maintained every improve run) previously drove only improve's INTERNAL
- * maintenance selection — the "better assets surface more" loop ran solely
- * through the utility EMA. This bounded multiplicative boost closes the outer
- * loop: usage/outcome-reinforced assets rank higher in `search`/`curate`.
+ * `rank_score` itself is UNCHANGED as improve's internal selection signal.
+ * This contributor, and its weight/cap constants, stay exported so a FUTURE
+ * gated experiment (config-gated, outcome-gated) can wire it back in
+ * explicitly — see `RankEntriesOptions.salienceRankScores`'s doc comment in
+ * `ranking.ts`. Reachable today only via explicit contributor-list injection
+ * (tests / eval harnesses calling `applyUtilityContributors` directly with a
+ * list that includes it) — never through `applyRankingRules` / `akm search` /
+ * `akm curate`.
  */
-const salienceRankingContributor = {
+export const salienceRankingContributor = {
     name: "salience-ranking",
     appliesTo(item, ctx) {
         const rank = ctx.salienceRankScores?.get(item.id);
@@ -464,10 +486,10 @@ const salienceRankingContributor = {
         item.score *= Math.min(rawBoost, SALIENCE_MAX_BOOST);
     },
 };
-export const defaultUtilityRankingContributors = [
-    utilityRankingContributor,
-    salienceRankingContributor,
-];
+// #692 — salienceRankingContributor deliberately excluded; see its doc
+// comment. Do not add it back here without a config gate + a measured
+// curate-golden-bench delta justifying it.
+export const defaultUtilityRankingContributors = [utilityRankingContributor];
 /**
  * EVAL/DEBUG ONLY — remove named ranking contributors from a list.
  *