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

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,
         };