akm-cli 0.9.0-beta.57 → 0.9.0-beta.59

package/dist/indexer/db/db.js

@@ -257,6 +257,49 @@ export function getDerivedForParent(db, parentRef) {
         return null;
     }
 }
+/**
+ * 03-R3: for the given derived-twin row ids, fetch each twin's BASE memory
+ * `beliefState`, keyed by twin id.
+ *
+ * Used by the derived-twin belief inheritance in search ranking: a `.derived`
+ * twin has no belief state of its own, so it inherits its base memory's
+ * demoting state (contradicted/superseded/…) at search time. A twin's
+ * `entry_key` is exactly its base's `entry_key` plus the `.derived` suffix
+ * (same stash + type prefix, `<name>` vs `<name>.derived`), so the base is
+ * found by stripping that suffix — no ref/prefix reconstruction. Returns a map
+ * of twin id → base beliefState for bases that carry a non-empty state.
+ * Best-effort: any query error (e.g. legacy DB) yields no inheritance rather
+ * than failing the search.
+ */
+export function getBaseBeliefStatesForDerivedTwins(db, twinIds) {
+    const out = new Map();
+    if (twinIds.length === 0)
+        return out;
+    // Chunk at SQLITE_CHUNK_SIZE like the sibling bulk-by-id helpers, so a large
+    // `--limit` candidate set never trips SQLITE_MAX_VARIABLE_NUMBER (which would
+    // otherwise fall into the best-effort catch and silently disable the feature).
+    for (let i = 0; i < twinIds.length; i += SQLITE_CHUNK_SIZE) {
+        const chunk = twinIds.slice(i, i + SQLITE_CHUNK_SIZE);
+        const placeholders = chunk.map(() => "?").join(",");
+        bestEffort(() => {
+            const rows = db
+                .prepare(`SELECT twin.id AS twin_id, json_extract(base.entry_json, '$.beliefState') AS belief
+           FROM entries twin
+           JOIN entries base
+             ON base.entry_type = 'memory'
+            AND base.entry_key = substr(twin.entry_key, 1, length(twin.entry_key) - length('.derived'))
+           WHERE twin.id IN (${placeholders})
+             AND twin.entry_key LIKE '%.derived'
+             AND json_extract(base.entry_json, '$.beliefState') IS NOT NULL`)
+                .all(...chunk);
+            for (const r of rows) {
+                if (typeof r.belief === "string" && r.belief.trim().length > 0)
+                    out.set(r.twin_id, r.belief.trim());
+            }
+        }, "legacy DB / entry_json without beliefState — treat as no twin inheritance");
+    }
+    return out;
+}
 /**
  * Phase 2A / Rec 5: bulk-load positive feedback event counts for the given
  * entry ids. Used by the utility-decay forgetting curve to stabilize
@@ -648,7 +691,8 @@ function runFtsQuery(db, ftsQuery, limit, entryType, excludeTypes) {
         }
         return results;
     }
-    catch {
+    catch (err) {
+        warn("[db] runFtsQuery failed:", err instanceof Error ? err.message : String(err));
         return [];
     }
 }
@@ -747,8 +791,7 @@ export function getEntryCount(db) {
     return row.cnt;
 }
 export function getEmbeddableEntryCount(db) {
-    const row = db.prepare("SELECT COUNT(*) AS cnt FROM entries").get();
-    return row.cnt;
+    return getEntryCount(db);
 }
 export function getEmbeddingCount(db) {
     const row = db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();
@@ -1327,49 +1370,11 @@ export function relinkUsageEvents(db) {
     }, "usage_events table may not exist yet during entry_id re-resolution");
 }
 // ── registry_index_cache helpers ─────────────────────────────────────────────
-/**
- * Upsert a registry index cache entry in index.db.
- *
- * @param db          - Open index.db connection (from openDatabase / openExistingDatabase).
- * @param registryUrl - Canonical URL of the registry (used as primary key).
- * @param indexJson   - Serialised registry index document (JSON string).
- * @param opts.etag        - HTTP ETag from the response (optional).
- * @param opts.lastModified - HTTP Last-Modified from the response (optional).
- */
-export function upsertRegistryIndexCache(db, registryUrl, indexJson, opts) {
-    db.prepare(`
-    INSERT INTO registry_index_cache (registry_url, fetched_at, etag, last_modified, index_json)
-    VALUES (?, ?, ?, ?, ?)
-    ON CONFLICT(registry_url) DO UPDATE SET
-      fetched_at    = excluded.fetched_at,
-      etag          = excluded.etag,
-      last_modified = excluded.last_modified,
-      index_json    = excluded.index_json
-  `).run(registryUrl, new Date().toISOString(), opts?.etag ?? null, opts?.lastModified ?? null, indexJson);
-}
-/**
- * Look up a cached registry index entry from index.db.
- * Returns undefined when not found or when the entry is older than `maxAgeMs`.
- *
- * TTL check: if `Date.now() - new Date(fetched_at).getTime() > maxAgeMs` the
- * entry is considered a cache miss and undefined is returned.
- *
- * @param db          - Open index.db connection.
- * @param registryUrl - Canonical URL of the registry (primary key).
- * @param maxAgeMs    - Maximum age in milliseconds before the entry is stale (default: 1 hour).
- */
-export function getRegistryIndexCache(db, registryUrl, maxAgeMs = 3_600_000 /* 1 hour */) {
-    const row = db
-        .prepare(`SELECT fetched_at, etag, last_modified, index_json
-       FROM registry_index_cache WHERE registry_url = ?`)
-        .get(registryUrl);
-    if (!row)
-        return undefined;
-    const fetchedAt = Date.parse(row.fetched_at);
-    if (Number.isNaN(fetchedAt) || Date.now() - fetchedAt > maxAgeMs)
-        return undefined;
-    return { indexJson: row.index_json, etag: row.etag, lastModified: row.last_modified };
-}
+// The raw SQL for the `registry_index_cache` table now lives in the storage
+// layer (`src/storage/repositories/registry-index-cache-repository.ts`) so the
+// dependency arrow points indexer → storage. These thin re-exports preserve the
+// previously-public symbols for any importer of this module.
+export { getRegistryIndexCache, upsertRegistryIndexCache, } from "../../storage/repositories/registry-index-cache-repository.js";
 /**
  * Walk indexed entries and collect a deduplicated set of tags. When
  * `entryType` is provided, only entries of that type contribute tags.

package/dist/indexer/graph/graph-extraction.js

@@ -838,14 +838,10 @@ export function rankCandidatesByUtility(db, candidates, _stashRoot) {
  *
  * Inferred-child memories (frontmatter `inferred: true`) are skipped — they
  * are already derived summaries, with no additional internal graph structure worth
- * extracting. Session-capture telemetry checkpoints are skipped too (see below).
+ * extracting.
  *
  * Exported for direct unit testing.
  */
-// #632 — canonical session-capture name shape, mirrored from
-// isSessionCaptureMemoryName (src/commands/improve/consolidate/eligibility.ts).
-// Inlined to avoid an improve-layer import from the indexer layer.
-const SESSION_CAPTURE_NAME_RE = /-(session|checkpoint)-\d{8}/;
 export function collectEligibleFiles(stashRoot, includeTypes = [...DEFAULT_GRAPH_EXTRACTION_INCLUDE_TYPES]) {
     const out = [];
     for (const rawType of includeTypes) {
@@ -871,14 +867,6 @@ export function collectEligibleFiles(stashRoot, includeTypes = [...DEFAULT_GRAPH
             // graph to extract from a single-fact body.
             if (type === "memory" && parsed.data.inferred === true)
                 continue;
-            // #632 — skip session-capture telemetry checkpoints (named
-            // `<harness>-(session|checkpoint)-<YYYYMMDD>-<id>`). Their bodies are
-            // pipeline bookkeeping; graph-extracting them lifts metadata fields as
-            // entities that then dominate clustering as bland stash-wide buckets.
-            // Mirrors isSessionCaptureMemoryName (consolidate/eligibility.ts); inlined
-            // here to keep the indexer layer free of an improve-layer import.
-            if (type === "memory" && SESSION_CAPTURE_NAME_RE.test(path.basename(filePath, ".md")))
-                continue;
             const body = parsed.content.trim();
             if (!body)
                 continue;

package/dist/indexer/indexer.js

@@ -331,7 +331,6 @@ async function akmIndexReal(options) {
                 walkWarnings: [],
                 dirsNeedingLlm: [],
                 embeddingResult: null,
-                graphExtractionResult: null,
             };
             onProgress({
                 phase: "summary",
@@ -399,14 +398,21 @@ async function akmIndexReal(options) {
         }
     });
 }
-// ── Extracted helpers for indexing ────────────────────────────────────────────
-async function indexEntries(db, allSourceEntries, isIncremental, builtAtMs, hadRemovedSources, doFullDelete = false, onProgress) {
+/**
+ * Phase 1 (async): walk every source directory and pre-generate all metadata
+ * outside any transaction, producing the per-directory scan records that
+ * {@link persistDirRecords} later writes.
+ *
+ * generateMetadataFlat is async (uses dynamic import for the matcher/renderer
+ * registry), so it cannot run inside a db.transaction() callback — hence the
+ * split into a pure-ish scan pass and a synchronous persist pass.
+ */
+async function scanSourceDirs(db, allSourceEntries, isIncremental, builtAtMs, hadRemovedSources, onProgress) {
     let scannedDirs = 0;
     let skippedDirs = 0;
     let generatedCount = 0;
     const warnings = [];
     const seenPaths = new Set();
-    const dirsNeedingLlm = [];
     const dirRecords = [];
     let processedDirs = 0;
     let priorDirsChanged = hadRemovedSources;
@@ -426,6 +432,53 @@ async function indexEntries(db, allSourceEntries, isIncremental, builtAtMs, hadR
         reportScanProgress(`${kind === "scan" ? "Rescanning" : "Skipping"} ${path.relative(currentStashDir, dirPath) || "."} ` +
             `from ${currentStashDir}: ${reason.kind}${detail}${rowInfo}`);
     };
+    // Duplicate-directory guard shared by the wiki-root and normal branches. A
+    // dir may surface via multiple stash roots; only the first occurrence is
+    // indexed, and the later ones are recorded as skips. Returns true when the
+    // dir was already seen (caller should skip further processing).
+    const markSeenOrSkipDuplicate = (dirPath, currentStashDir, files) => {
+        const resolved = path.resolve(dirPath);
+        if (seenPaths.has(resolved)) {
+            const reason = { kind: "duplicate-dir" };
+            dirRecords.push({ dirPath, currentStashDir, files, stash: null, skip: true, reason });
+            reportDirDecision("skip", dirPath, currentStashDir, reason);
+            return true;
+        }
+        seenPaths.add(resolved);
+        return false;
+    };
+    // Incremental freshness gate shared by both branches: consult the persisted
+    // dir state and record either a skip (unchanged + eligible for incremental
+    // skip) or a scan record carrying the candidate stash.
+    const recordFreshnessDecision = (dirPath, currentStashDir, stateFiles, stash) => {
+        const previousState = getDirIndexState(db, dirPath, stateFiles, builtAtMs);
+        if (isIncremental && !previousState.stale && canUseIncrementalSkip(previousState, priorDirsChanged)) {
+            skippedDirs++;
+            dirRecords.push({
+                dirPath,
+                currentStashDir,
+                files: stateFiles,
+                stash: null,
+                skip: true,
+                reason: previousState.reason,
+            });
+            reportDirDecision("skip", dirPath, currentStashDir, previousState.reason, previousState.persistedRowCount);
+            return;
+        }
+        scannedDirs++;
+        priorDirsChanged = true;
+        const reason = isIncremental ? previousState.reason : { kind: "full-rebuild" };
+        dirRecords.push({
+            dirPath,
+            currentStashDir,
+            files: stateFiles,
+            stash,
+            skip: false,
+            reason,
+            persistedRowCount: previousState.persistedRowCount,
+        });
+        reportDirDecision("scan", dirPath, currentStashDir, reason, previousState.persistedRowCount);
+    };
     for (const sourceAdded of allSourceEntries) {
         const currentStashDir = sourceAdded.path;
         const fileContexts = walkStashFlat(currentStashDir);
@@ -463,33 +516,9 @@ async function indexEntries(db, allSourceEntries, isIncremental, builtAtMs, hadR
                 }
             }
             for (const [dirPath, { files, entries }] of wikiDirGroups) {
-                if (seenPaths.has(path.resolve(dirPath))) {
-                    const reason = { kind: "duplicate-dir" };
-                    dirRecords.push({ dirPath, currentStashDir, files, stash: null, skip: true, reason });
-                    reportDirDecision("skip", dirPath, currentStashDir, reason);
-                    continue;
-                }
-                seenPaths.add(path.resolve(dirPath));
-                const previousState = getDirIndexState(db, dirPath, files, builtAtMs);
-                if (isIncremental && !previousState.stale && canUseIncrementalSkip(previousState, priorDirsChanged)) {
-                    skippedDirs++;
-                    dirRecords.push({ dirPath, currentStashDir, files, stash: null, skip: true, reason: previousState.reason });
-                    reportDirDecision("skip", dirPath, currentStashDir, previousState.reason, previousState.persistedRowCount);
+                if (markSeenOrSkipDuplicate(dirPath, currentStashDir, files))
                     continue;
-                }
-                scannedDirs++;
-                priorDirsChanged = true;
-                const reason = isIncremental ? previousState.reason : { kind: "full-rebuild" };
-                dirRecords.push({
-                    dirPath,
-                    currentStashDir,
-                    files,
-                    stash: { entries },
-                    skip: false,
-                    reason,
-                    persistedRowCount: previousState.persistedRowCount,
-                });
-                reportDirDecision("scan", dirPath, currentStashDir, reason, previousState.persistedRowCount);
+                recordFreshnessDecision(dirPath, currentStashDir, files, { entries });
             }
             continue;
         }
@@ -504,13 +533,8 @@ async function indexEntries(db, allSourceEntries, isIncremental, builtAtMs, hadR
         }
         for (const [dirPath, files] of dirGroups) {
             const indexableFiles = files.filter((file) => shouldIndexStashFile(currentStashDir, file));
-            if (seenPaths.has(path.resolve(dirPath))) {
-                const reason = { kind: "duplicate-dir" };
-                dirRecords.push({ dirPath, currentStashDir, files: indexableFiles, stash: null, skip: true, reason });
-                reportDirDecision("skip", dirPath, currentStashDir, reason);
+            if (markSeenOrSkipDuplicate(dirPath, currentStashDir, indexableFiles))
                 continue;
-            }
-            seenPaths.add(path.resolve(dirPath));
             if (indexableFiles.length === 0) {
                 skippedDirs++;
                 const reason = { kind: "no-indexable-files" };
@@ -540,37 +564,17 @@ async function indexEntries(db, allSourceEntries, isIncremental, builtAtMs, hadR
             if (generated.entries.length > 0) {
                 generatedCount += generated.entries.length;
             }
-            const previousState = getDirIndexState(db, dirPath, staleFiles, builtAtMs);
-            if (isIncremental && !previousState.stale && canUseIncrementalSkip(previousState, priorDirsChanged)) {
-                skippedDirs++;
-                dirRecords.push({
-                    dirPath,
-                    currentStashDir,
-                    files: staleFiles,
-                    stash: null,
-                    skip: true,
-                    reason: previousState.reason,
-                });
-                reportDirDecision("skip", dirPath, currentStashDir, previousState.reason, previousState.persistedRowCount);
-                continue;
-            }
-            scannedDirs++;
-            priorDirsChanged = true;
-            const reason = isIncremental ? previousState.reason : { kind: "full-rebuild" };
-            dirRecords.push({
-                dirPath,
-                currentStashDir,
-                files: staleFiles,
-                stash,
-                skip: false,
-                reason,
-                persistedRowCount: previousState.persistedRowCount,
-            });
-            reportDirDecision("scan", dirPath, currentStashDir, reason, previousState.persistedRowCount);
+            recordFreshnessDecision(dirPath, currentStashDir, staleFiles, stash);
         }
     }
-    // Phase 2 (sync): write all pre-generated metadata inside a single transaction.
-    //
+    return { dirRecords, scannedDirs, skippedDirs, generatedCount, warnings };
+}
+/**
+ * Phase 2 (sync): write all pre-generated scan records inside a single
+ * transaction, returning the directories that still need LLM enrichment.
+ */
+function persistDirRecords(db, dirRecords, doFullDelete, warnings) {
+    const dirsNeedingLlm = [];
     // Cross-stash dedup: track indexed assets by content identity
     // (type + filename + description) so the same asset from a lower-priority
     // stash root is skipped when a higher-priority root already covers it.
@@ -692,6 +696,14 @@ async function indexEntries(db, allSourceEntries, isIncremental, builtAtMs, hadR
         }
     });
     insertTransaction();
+    return { dirsNeedingLlm };
+}
+async function indexEntries(db, allSourceEntries, isIncremental, builtAtMs, hadRemovedSources, doFullDelete = false, onProgress) {
+    // Phase 1 (async): walk directories and pre-generate all metadata outside the
+    // transaction.
+    const { dirRecords, scannedDirs, skippedDirs, generatedCount, warnings } = await scanSourceDirs(db, allSourceEntries, isIncremental, builtAtMs, hadRemovedSources, onProgress);
+    // Phase 2 (sync): write all pre-generated metadata inside a single transaction.
+    const { dirsNeedingLlm } = persistDirRecords(db, dirRecords, doFullDelete, warnings);
     return { scannedDirs, skippedDirs, generatedCount, warnings, dirsNeedingLlm };
 }
 async function enhanceDirsWithLlm(db, config, dirsNeedingLlm, onProgress, signal, reEnrich = false) {

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

@@ -20,7 +20,7 @@ import { defaultRendererRegistry } from "../../core/asset/asset-registry.js";
 import { getDbPath } from "../../core/paths.js";
 import { warn } from "../../core/warn.js";
 import { getCurrentWorkflowScopeKey } from "../../workflows/authoring/scope-key.js";
-import { closeDatabase, getAllEntries, getEntryById, getEntryCount, getMeta, getPositiveFeedbackCountsByIds, openExistingDatabase, sanitizeFtsQuery, searchFts, searchVec, } from "../db/db.js";
+import { closeDatabase, getAllEntries, getBaseBeliefStatesForDerivedTwins, getEntryById, getEntryCount, getMeta, getPositiveFeedbackCountsByIds, openExistingDatabase, sanitizeFtsQuery, searchFts, searchVec, } from "../db/db.js";
 import { ensureIndex } from "../ensure-index.js";
 import { collectGraphRelatedHit, computeGraphBoost, loadGraphBoostContext, } from "../graph/graph-boost.js";
 import { isProposedQuality } from "../passes/metadata.js";
@@ -201,7 +201,11 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
         const qualityFiltered = includeProposed
             ? scopeFiltered
             : scopeFiltered.filter((ie) => !isProposedQuality(ie.entry.quality));
-        const beliefFiltered = qualityFiltered.filter((ie) => matchBeliefFilter(ie.entry.type, ie.entry.beliefState, beliefFilter));
+        // 03-R3: derived twins inherit their base's demoting belief state here too,
+        // so the belief FILTER (and the reported hit state) stays consistent on the
+        // enumerate/browse path — not only on the FTS-scored path below.
+        inheritDerivedTwinBeliefStates(db, qualityFiltered);
+        const beliefFiltered = qualityFiltered.filter((ie) => matchBeliefFilter(ie.entry.beliefState, beliefFilter));
         const selected = beliefFiltered.slice(0, limit);
         const hits = await Promise.all(selected.map((ie) => buildDbHit({
             entry: ie.entry,
@@ -302,6 +306,9 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
     catch {
         // Non-fatal — ranking proceeds without scoped utility on any error.
     }
+    // 03-R3: derived twins inherit their base's demoting belief state before
+    // ranking, so the (03) belief-state ranker demotes a stale flag-free twin.
+    inheritDerivedTwinBeliefStates(db, scored);
     applyRankingRules({
         db,
         query,
@@ -358,7 +365,7 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
     const qualityFiltered = includeProposed
         ? scopeFiltered
         : scopeFiltered.filter((item) => !isProposedQuality(item.entry.quality));
-    const beliefFiltered = qualityFiltered.filter((item) => matchBeliefFilter(item.entry.type, item.entry.beliefState, beliefFilter));
+    const beliefFiltered = qualityFiltered.filter((item) => matchBeliefFilter(item.entry.beliefState, beliefFilter));
     const rankMs = Date.now() - tRank0;
     const selected = beliefFiltered.slice(0, limit);
     const hits = await Promise.all(selected.map(({ entry, filePath, score, rankingMode, utilityBoosted }) => {
@@ -386,11 +393,39 @@ async function searchDatabase(db, query, searchType, limit, stashDir, allSourceD
     }));
     return { embedMs, rankMs, hits };
 }
-function matchBeliefFilter(type, beliefState, filter) {
+/**
+ * 03-R3: let each `.derived` twin inherit its base memory's demoting belief
+ * state for this ranking pass, so a stale flag-free twin is demoted like its
+ * corrected base. The base carries the flag (a contradicted base takes a real
+ * ranking penalty); its near-duplicate `.derived` twin carries none and would
+ * otherwise outrank the corrected copy. Done in-memory at search time — NOT by
+ * writing the twin's frontmatter — because the SCC belief resolver refreshes any
+ * non-frozen state written to a derived memory back to `active` on the next
+ * improve run, erasing it. Only twins with no state of their own inherit; an
+ * explicit twin state always wins. Reuses the (03) belief-state ranker + filter.
+ */
+function inheritDerivedTwinBeliefStates(db, items) {
+    const DEMOTING = new Set(["contradicted", "superseded", "deprecated", "archived"]);
+    const twins = items.filter((it) => it.entry.type === "memory" &&
+        it.entry.beliefState === undefined &&
+        it.entry.name.toLowerCase().endsWith(".derived"));
+    if (twins.length === 0)
+        return;
+    const baseBeliefByTwinId = getBaseBeliefStatesForDerivedTwins(db, twins.map((t) => t.id));
+    for (const t of twins) {
+        const baseBelief = baseBeliefByTwinId.get(t.id);
+        // Only inherit DEMOTIONS — never let a base's active/asserted state lift a twin.
+        if (baseBelief && DEMOTING.has(baseBelief)) {
+            t.entry.beliefState = baseBelief;
+        }
+    }
+}
+function matchBeliefFilter(beliefState, filter) {
     if (filter === "all")
         return true;
-    if (type !== "memory")
-        return true;
+    // 03: the belief filter applies to ANY flagged entry, not just memories, so
+    // `current`/`historical` filters catch contradicted/superseded KNOWLEDGE too.
+    // Unflagged entries (beliefState === undefined) still pass the `current` filter.
     if (filter === "current") {
         // Phase 1A: `asserted` is a "current" state (stronger authority than `active`);
         // `deprecated` is excluded from current results.

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

@@ -40,8 +40,10 @@ const DEFAULT_RECENCY_HALF_LIFE_DAYS = 30;
 const FEEDBACK_HALF_LIFE_CAP_MULTIPLIER = 4;
 function beliefStateBoost(item) {
     const entry = item.entry;
-    if (entry.type !== "memory")
-        return 0;
+    // 03: belief-state penalties/boosts apply to ANY flagged entry (memory OR
+    // knowledge), so contradicted/superseded KNOWLEDGE is demoted from results
+    // just like flagged memories. Entries without a belief state fall through to
+    // the `return 0` below (default-safe — no effect on unflagged assets).
     // 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`.
@@ -87,14 +89,18 @@ const typeRankingContributor = {
         return TYPE_BOOST[item.entry.type] ?? 0;
     },
 };
-const memoryRankingContributor = {
-    name: "memory-ranking",
+const beliefStateRankingContributor = {
+    name: "belief-state-ranking",
     appliesTo(item) {
-        return item.entry.type === "memory";
+        // Fire for any entry that carries a belief state, regardless of type — so
+        // contradicted/superseded knowledge is demoted, not just memories. The
+        // `.derived`-twin `derivedBoost` (±0.12/−0.08) is deleted (03-R3): it made
+        // stale flag-free twins outrank their corrected base memory; belief-state
+        // demotion is the principled signal, not the twin-name heuristic.
+        return item.entry.beliefState !== undefined;
     },
     adjust(item) {
-        const derivedBoost = item.entry.name.toLowerCase().endsWith(".derived") ? 0.12 : -0.08;
-        return derivedBoost + beliefStateBoost(item);
+        return beliefStateBoost(item);
     },
 };
 const tagRankingContributor = {
@@ -330,7 +336,7 @@ const projectContextRankingContributor = {
 export const defaultRankingContributors = [
     exactNameRankingContributor,
     typeRankingContributor,
-    memoryRankingContributor,
+    beliefStateRankingContributor,
     tagRankingContributor,
     searchHintRankingContributor,
     aliasRankingContributor,

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

@@ -167,14 +167,26 @@ export function getWritableStashDirs(overrideStashDir, existingConfig) {
 }
 /**
  * Find which source a file path belongs to.
+ *
+ * Longest-matching-prefix wins: a source nested inside another (e.g. `akm add
+ * ./sub` where `./sub` lives under the primary stash — which is always
+ * `sources[0]`) is the more specific owner and must win over the enclosing
+ * source regardless of array order. A first-match-in-order scan would
+ * misattribute every asset under the nested source to the primary stash,
+ * corrupting origin / editability / provenance decisions for the affected files.
  */
 export function findSourceForPath(filePath, sources) {
     const resolved = path.resolve(filePath);
+    let best;
+    let bestLen = -1;
     for (const source of sources) {
-        if (resolved.startsWith(path.resolve(source.path) + path.sep))
-            return source;
+        const base = path.resolve(source.path);
+        if (resolved.startsWith(base + path.sep) && base.length > bestLen) {
+            best = source;
+            bestLen = base.length;
+        }
     }
-    return undefined;
+    return best;
 }
 /**
  * Return the primary stash source (first entry in the list).

package/dist/llm/feature-gate.js

@@ -22,12 +22,11 @@ const FEATURE_LOCATION = {
     graph_extraction: (cfg) => cfg.profiles?.improve?.default?.processes?.graphExtraction?.enabled ?? true,
     // Legacy default: false
     metadata_enhance: (cfg) => cfg.index?.metadataEnhance?.enabled ?? false,
-    // Legacy default: false
-    curate_rerank: (cfg) => cfg.search?.curateRerank?.enabled ?? false,
     // Default ON since R3 (docs/design/improve-self-learning-analysis.md G5):
-    // distill is a primary acquisition path and the judge fails open (no LLM /
-    // timeout / parse failure all pass through), so the gate only ever filters
-    // when a judge verdict actually exists. Opt out via
+    // distill is a primary acquisition path, so the gate guards minted content by
+    // default. The judge fails CLOSED (07 P0-2): no LLM / timeout / parse failure
+    // reject the proposal rather than passing it through — an unjudgeable proposal
+    // must not slip into the stash. Opt out via
     // profiles.improve.default.processes.distill.qualityGate.enabled: false.
     lesson_quality_gate: (cfg) => cfg.profiles?.improve?.default?.processes?.distill?.qualityGate?.enabled ?? true,
     // Legacy default: false
@@ -112,9 +111,6 @@ export function isProcessEnabled(section, processName, config) {
             return isLlmFeatureEnabled(config, "graph_extraction");
         }
     }
-    if (section === "search" && (processName === "curate_rerank" || processName === "curateRerank")) {
-        return config.search?.curateRerank?.enabled ?? false;
-    }
     if (section === "improve") {
         const processes = config.profiles?.improve?.default?.processes;
         const entry = processes?.[processName];

package/dist/output/renderers.js

@@ -210,6 +210,10 @@ const agentMdRenderer = {
             action: "Dispatch using the prompt below verbatim. Use modelHint and toolPolicy if present.",
             description: asNonEmptyString(parsedMd.data.description),
             prompt: parsedMd.content,
+            // `tools` is self-declared frontmatter. The provenance CEILING that decides
+            // whether this self-declared policy is honoured is applied at the show
+            // layer (`akmShowUnified`), which knows whether the source is the operator's
+            // own writable stash vs a read-only third-party source (07 P1-D).
             toolPolicy: parsedMd.data.tools,
             modelHint: typeof parsedMd.data.model === "string" ? parsedMd.data.model : undefined,
         };