akm-cli 0.9.7 → 0.9.8-beta.2

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

@@ -259,25 +259,20 @@ export function acknowledgeExtractionQueueEntry(db, stashRoot, filePath, bodyHas
 export function loadGraphFilesOnly(stashPath, db) {
     try {
         return withReadableGraphDb(db, (readDb) => {
-            try {
-                const rows = readDb
-                    .prepare(`SELECT file_path, file_type, body_hash, confidence, status, reason
-                FROM graph_files
-                WHERE stash_root = ?
-                ORDER BY file_order`)
-                    .all(stashPath);
-                return rows.map((row) => ({
-                    path: row.file_path,
-                    type: row.file_type,
-                    bodyHash: row.body_hash,
-                    ...(typeof row.confidence === "number" ? { confidence: row.confidence } : {}),
-                    ...(row.status ? { status: row.status } : {}),
-                    ...(row.reason ? { reason: row.reason } : {}),
-                }));
-            }
-            catch {
-                return [];
-            }
+            const rows = readDb
+                .prepare(`SELECT file_path, file_type, body_hash, confidence, status, reason
+              FROM graph_files
+              WHERE stash_root = ?
+              ORDER BY file_order`)
+                .all(stashPath);
+            return rows.map((row) => ({
+                path: row.file_path,
+                type: row.file_type,
+                bodyHash: row.body_hash,
+                ...(typeof row.confidence === "number" ? { confidence: row.confidence } : {}),
+                ...(row.status ? { status: row.status } : {}),
+                ...(row.reason ? { reason: row.reason } : {}),
+            }));
         });
     }
     catch (err) {
@@ -292,66 +287,61 @@ export function loadGraphFilesOnly(stashPath, db) {
 export function loadStoredGraphMeta(stashPath, db) {
     try {
         return withReadableGraphDb(db, (readDb) => {
-            try {
-                const row = readDb
-                    .prepare(`SELECT
-               stash_root,
-               schema_version,
-               generated_at,
-               considered_files,
-               extracted_files,
-               entity_count,
-               relation_count,
-               extraction_coverage,
-               density,
-               extractor_id,
-               extraction_run_id,
-               model,
-               prompt_version,
-               batch_size,
-               cache_hits,
-               cache_misses,
-               truncation_count,
-               failure_count
-              FROM graph_meta
-              WHERE stash_root = ?`)
-                    .get(stashPath);
-                if (!row)
-                    return null;
-                return {
-                    stashPath: row.stash_root,
-                    graphPath: getDbPath(),
-                    schemaVersion: row.schema_version,
-                    generatedAt: row.generated_at,
-                    quality: {
-                        consideredFiles: row.considered_files,
-                        extractedFiles: row.extracted_files,
-                        entityCount: row.entity_count,
-                        relationCount: row.relation_count,
-                        extractionCoverage: row.extraction_coverage,
-                        density: row.density,
-                    },
-                    telemetry: {
-                        ...(row.extractor_id ? { extractorId: row.extractor_id } : {}),
-                        ...(row.extraction_run_id ? { extractionRunId: row.extraction_run_id } : {}),
-                        ...(row.model ? { model: row.model } : {}),
-                        ...(row.prompt_version ? { promptVersion: row.prompt_version } : {}),
-                        ...(typeof row.batch_size === "number" ? { batchSize: row.batch_size } : {}),
-                        cacheHits: row.cache_hits,
-                        cacheMisses: row.cache_misses,
-                        truncationCount: row.truncation_count,
-                        failureCount: row.failure_count,
-                        // `retry_attempts` is not persisted to the graph-meta table (it is
-                        // surfaced from the run's emitted telemetry into `akm health`, not
-                        // from the reuse cache). Default to 0 so the loaded shape satisfies
-                        // GraphExtractionTelemetry.
-                        retryAttempts: 0,
-                    },
-                };
-            }
-            catch {
+            const row = readDb
+                .prepare(`SELECT
+             stash_root,
+             schema_version,
+             generated_at,
+             considered_files,
+             extracted_files,
+             entity_count,
+             relation_count,
+             extraction_coverage,
+             density,
+             extractor_id,
+             extraction_run_id,
+             model,
+             prompt_version,
+             batch_size,
+             cache_hits,
+             cache_misses,
+             truncation_count,
+             failure_count
+            FROM graph_meta
+            WHERE stash_root = ?`)
+                .get(stashPath);
+            if (!row)
                 return null;
-            }
+            return {
+                stashPath: row.stash_root,
+                graphPath: getDbPath(),
+                schemaVersion: row.schema_version,
+                generatedAt: row.generated_at,
+                quality: {
+                    consideredFiles: row.considered_files,
+                    extractedFiles: row.extracted_files,
+                    entityCount: row.entity_count,
+                    relationCount: row.relation_count,
+                    extractionCoverage: row.extraction_coverage,
+                    density: row.density,
+                },
+                telemetry: {
+                    ...(row.extractor_id ? { extractorId: row.extractor_id } : {}),
+                    ...(row.extraction_run_id ? { extractionRunId: row.extraction_run_id } : {}),
+                    ...(row.model ? { model: row.model } : {}),
+                    ...(row.prompt_version ? { promptVersion: row.prompt_version } : {}),
+                    ...(typeof row.batch_size === "number" ? { batchSize: row.batch_size } : {}),
+                    cacheHits: row.cache_hits,
+                    cacheMisses: row.cache_misses,
+                    truncationCount: row.truncation_count,
+                    failureCount: row.failure_count,
+                    // `retry_attempts` is not persisted to the graph-meta table (it is
+                    // surfaced from the run's emitted telemetry into `akm health`, not
+                    // from the reuse cache). Default to 0 so the loaded shape satisfies
+                    // GraphExtractionTelemetry.
+                    retryAttempts: 0,
+                },
+            };
         });
     }
     catch (err) {
@@ -368,85 +358,80 @@ export function loadStoredGraphSnapshot(stashPath, db) {
             const meta = loadStoredGraphMeta(stashPath, readDb);
             if (!meta)
                 return null;
-            try {
-                const fileRows = readDb
-                    .prepare(`SELECT file_path, file_type, body_hash, confidence, status, reason, extraction_run_id
-              FROM graph_files
-              WHERE stash_root = ?
-              ORDER BY file_order`)
-                    .all(stashPath);
-                const entityRows = readDb
-                    .prepare(`SELECT gf.file_path AS file_path, gfe.entity AS entity
-             FROM graph_file_entities gfe
-             JOIN graph_files gf
-               ON gf.stash_root = gfe.stash_root
-              AND gf.file_path = gfe.file_path
-              AND gf.body_hash = gfe.body_hash
-             WHERE gf.stash_root = ?
-             ORDER BY gf.file_order, gfe.entity_order`)
-                    .all(stashPath);
-                const relationRows = readDb
-                    .prepare(`SELECT gf.file_path AS file_path,
-                    gfr.from_entity AS from_entity,
-                    gfr.to_entity AS to_entity,
-                    gfr.relation_type AS relation_type,
-                    gfr.confidence AS confidence
-             FROM graph_file_relations gfr
-             JOIN graph_files gf
-               ON gf.stash_root = gfr.stash_root
-              AND gf.file_path = gfr.file_path
-              AND gf.body_hash = gfr.body_hash
-             WHERE gf.stash_root = ?
-             ORDER BY gf.file_order, gfr.relation_order`)
-                    .all(stashPath);
-                const entitiesByPath = new Map();
-                for (const row of entityRows) {
-                    const bucket = entitiesByPath.get(row.file_path);
-                    if (bucket)
-                        bucket.push(row.entity);
-                    else
-                        entitiesByPath.set(row.file_path, [row.entity]);
-                }
-                const relationsByPath = new Map();
-                for (const row of relationRows) {
-                    const relation = {
-                        from: row.from_entity,
-                        to: row.to_entity,
-                        ...(row.relation_type ? { type: row.relation_type } : {}),
-                        ...(typeof row.confidence === "number" ? { confidence: row.confidence } : {}),
-                    };
-                    const bucket = relationsByPath.get(row.file_path);
-                    if (bucket)
-                        bucket.push(relation);
-                    else
-                        relationsByPath.set(row.file_path, [relation]);
-                }
-                const files = fileRows.map((row) => ({
-                    path: row.file_path,
-                    type: row.file_type,
-                    ...(row.body_hash ? { bodyHash: row.body_hash } : {}),
-                    entities: entitiesByPath.get(row.file_path) ?? [],
-                    relations: relationsByPath.get(row.file_path) ?? [],
+            const fileRows = readDb
+                .prepare(`SELECT file_path, file_type, body_hash, confidence, status, reason, extraction_run_id
+            FROM graph_files
+            WHERE stash_root = ?
+            ORDER BY file_order`)
+                .all(stashPath);
+            const entityRows = readDb
+                .prepare(`SELECT gf.file_path AS file_path, gfe.entity AS entity
+           FROM graph_file_entities gfe
+           JOIN graph_files gf
+             ON gf.stash_root = gfe.stash_root
+            AND gf.file_path = gfe.file_path
+            AND gf.body_hash = gfe.body_hash
+           WHERE gf.stash_root = ?
+           ORDER BY gf.file_order, gfe.entity_order`)
+                .all(stashPath);
+            const relationRows = readDb
+                .prepare(`SELECT gf.file_path AS file_path,
+                  gfr.from_entity AS from_entity,
+                  gfr.to_entity AS to_entity,
+                  gfr.relation_type AS relation_type,
+                  gfr.confidence AS confidence
+           FROM graph_file_relations gfr
+           JOIN graph_files gf
+             ON gf.stash_root = gfr.stash_root
+            AND gf.file_path = gfr.file_path
+            AND gf.body_hash = gfr.body_hash
+           WHERE gf.stash_root = ?
+           ORDER BY gf.file_order, gfr.relation_order`)
+                .all(stashPath);
+            const entitiesByPath = new Map();
+            for (const row of entityRows) {
+                const bucket = entitiesByPath.get(row.file_path);
+                if (bucket)
+                    bucket.push(row.entity);
+                else
+                    entitiesByPath.set(row.file_path, [row.entity]);
+            }
+            const relationsByPath = new Map();
+            for (const row of relationRows) {
+                const relation = {
+                    from: row.from_entity,
+                    to: row.to_entity,
+                    ...(row.relation_type ? { type: row.relation_type } : {}),
                     ...(typeof row.confidence === "number" ? { confidence: row.confidence } : {}),
-                    ...(row.status ? { status: row.status } : {}),
-                    ...(row.reason ? { reason: row.reason } : {}),
-                    ...(row.extraction_run_id ? { extractionRunId: row.extraction_run_id } : {}),
-                }));
-                return {
-                    stashPath: meta.stashPath,
-                    graphPath: meta.graphPath,
-                    schemaVersion: meta.schemaVersion,
-                    generatedAt: meta.generatedAt,
-                    ...(meta.quality ? { quality: meta.quality } : {}),
-                    ...(meta.telemetry ? { telemetry: meta.telemetry } : {}),
-                    files,
-                    entities: uniqueSorted(files.flatMap((file) => file.entities)),
-                    relations: files.flatMap((file) => file.relations),
                 };
+                const bucket = relationsByPath.get(row.file_path);
+                if (bucket)
+                    bucket.push(relation);
+                else
+                    relationsByPath.set(row.file_path, [relation]);
             }
-            catch {
-                return null;
-            }
+            const files = fileRows.map((row) => ({
+                path: row.file_path,
+                type: row.file_type,
+                ...(row.body_hash ? { bodyHash: row.body_hash } : {}),
+                entities: entitiesByPath.get(row.file_path) ?? [],
+                relations: relationsByPath.get(row.file_path) ?? [],
+                ...(typeof row.confidence === "number" ? { confidence: row.confidence } : {}),
+                ...(row.status ? { status: row.status } : {}),
+                ...(row.reason ? { reason: row.reason } : {}),
+                ...(row.extraction_run_id ? { extractionRunId: row.extraction_run_id } : {}),
+            }));
+            return {
+                stashPath: meta.stashPath,
+                graphPath: meta.graphPath,
+                schemaVersion: meta.schemaVersion,
+                generatedAt: meta.generatedAt,
+                ...(meta.quality ? { quality: meta.quality } : {}),
+                ...(meta.telemetry ? { telemetry: meta.telemetry } : {}),
+                files,
+                entities: uniqueSorted(files.flatMap((file) => file.entities)),
+                relations: files.flatMap((file) => file.relations),
+            };
         });
     }
     catch (err) {

package/dist/indexer/ensure-index.js

@@ -24,7 +24,6 @@ import path from "node:path";
 import { placementSpecList } from "../core/asset/asset-placement.js";
 import { classifyPathAccess } from "../core/path-access.js";
 import { getDbPath } from "../core/paths.js";
-import { warn } from "../core/warn.js";
 import { assertIndexPathReadable, closeDatabase, openExistingDatabase } from "../storage/repositories/index-connection.js";
 import { getEntryCount, getIndexedFilePaths } from "../storage/repositories/index-entries-repository.js";
 import { getMeta } from "../storage/repositories/index-meta-repository.js";
@@ -188,22 +187,14 @@ function indexCanServeStash(stashDir) {
     }
 }
 async function runInlineReindex(stashDir, options = {}) {
-    try {
-        const { akmIndex } = await import("./indexer.js");
-        await akmIndex({
-            stashDir,
-            implicit: true,
-            ...(options.signal ? { signal: options.signal } : {}),
-            ...(options.hydrateSources === false ? { hydrateSources: false } : {}),
-        });
-        return true;
-    }
-    catch (error) {
-        if (options.signal?.aborted)
-            throw error;
-        warn("Auto-index failed, proceeding with existing index:", error instanceof Error ? error.message : String(error));
-        return false;
-    }
+    const { akmIndex } = await import("./indexer.js");
+    await akmIndex({
+        stashDir,
+        implicit: true,
+        ...(options.signal ? { signal: options.signal } : {}),
+        ...(options.hydrateSources === false ? { hydrateSources: false } : {}),
+    });
+    return true;
 }
 /**
  * Ensure the local index exists and can serve the caller.
@@ -217,8 +208,9 @@ async function runInlineReindex(stashDir, options = {}) {
  * trigger and waits for it. Use this for callers like `improve` whose
  * planning logic depends on a current `entries` table in the same process.
  *
- * Returns `true` only when an inline index run succeeds.
- * A rebuild attempt that fails (throws) resolves to `false`.
+ * Returns `true` only when an inline index run succeeds; `false` when no
+ * rebuild was needed. A rebuild attempt that fails propagates its error to
+ * the caller rather than silently proceeding with a stale/missing index.
  */
 export async function ensureIndex(stashDir, options = {}) {
     // §11.5: warn (once) if the configured bundle ids drifted from the persisted

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

@@ -257,45 +257,34 @@ export function listRelatedPathsForFile(stashRoot, filePath, limit = 5, db) {
     }
     // Confirm the target file has a graph row; without it there is nothing to
     // relate. (Identity is file_path within the stash — one row per path.)
-    try {
-        const row = db
-            .prepare("SELECT 1 AS present FROM graph_files WHERE stash_root = ? AND file_path = ? LIMIT 1")
-            .get(stashRoot, filePath);
-        if (row === undefined)
-            return [];
-    }
-    catch {
+    const row = db
+        .prepare("SELECT 1 AS present FROM graph_files WHERE stash_root = ? AND file_path = ? LIMIT 1")
+        .get(stashRoot, filePath);
+    if (row === undefined)
         return [];
-    }
     const effectiveLimit = Math.max(1, limit);
     // Shared-entity count per candidate file_path. The target's entities are the
     // rows for `filePath`; candidates are any OTHER file_path in the stash that
     // shares a normalized entity.
-    let candidateRows;
-    try {
-        candidateRows = db
-            .prepare(`SELECT gf.file_path   AS file_path,
-                gf.file_type   AS file_type,
-                COUNT(*)       AS shared
-            FROM graph_file_entities target
-            JOIN graph_file_entities e
-              ON e.stash_root = target.stash_root
-             AND e.entity_norm = target.entity_norm
-             AND e.file_path  != target.file_path
-            JOIN graph_files gf
-              ON gf.stash_root = e.stash_root
-             AND gf.file_path = e.file_path
-             AND gf.body_hash = e.body_hash
-          WHERE target.file_path  = ?
-            AND target.stash_root = ?
-          GROUP BY gf.file_path
-          ORDER BY shared DESC, gf.file_path ASC
-          LIMIT ?`)
-            .all(filePath, stashRoot, effectiveLimit);
-    }
-    catch {
-        return [];
-    }
+    const candidateRows = db
+        .prepare(`SELECT gf.file_path   AS file_path,
+              gf.file_type   AS file_type,
+              COUNT(*)       AS shared
+          FROM graph_file_entities target
+          JOIN graph_file_entities e
+            ON e.stash_root = target.stash_root
+           AND e.entity_norm = target.entity_norm
+           AND e.file_path  != target.file_path
+          JOIN graph_files gf
+            ON gf.stash_root = e.stash_root
+           AND gf.file_path = e.file_path
+           AND gf.body_hash = e.body_hash
+        WHERE target.file_path  = ?
+          AND target.stash_root = ?
+        GROUP BY gf.file_path
+        ORDER BY shared DESC, gf.file_path ASC
+        LIMIT ?`)
+        .all(filePath, stashRoot, effectiveLimit);
     if (candidateRows.length === 0)
         return [];
     const candidatePaths = candidateRows.map((r) => r.file_path);

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

@@ -971,6 +971,11 @@ async function extractGraphForSingleFileRevision(db, stashRoot, filePath, opts)
         if (err instanceof ConfigError)
             throw err;
         rethrowIfTestIsolationError(err);
+        // A genuine extraction/write failure, distinct from the deliberate
+        // "nothing to do" skips above (missing file, empty body, no model). Warn
+        // so it is visible instead of looking identical to a no-op skip; the
+        // entry stays queued and is retried on the next pass.
+        warn(`graph extraction: failed to extract graph for ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
         return { written: false };
     }
     finally {
@@ -1057,12 +1062,17 @@ export function collectEligibleFiles(stashRoot, includeTypes = [...DEFAULT_GRAPH
         const dir = path.join(stashRoot, stashDir);
         if (!fs.existsSync(dir))
             continue;
-        for (const filePath of walkMarkdownFiles(dir)) {
+        const walked = walkMarkdownFiles(dir);
+        if (!walked.complete) {
+            warn(`graph extraction: directory scan under ${dir} is incomplete — some files may be missing`);
+        }
+        for (const filePath of walked.files) {
             let raw;
             try {
                 raw = fs.readFileSync(filePath, "utf8");
             }
-            catch {
+            catch (err) {
+                warn(`graph extraction: failed to read candidate file ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
                 continue;
             }
             const parsed = parseFrontmatter(raw);

package/dist/indexer/indexer.js

@@ -30,7 +30,7 @@ import { deleteStoredGraph } from "./db/graph-db.js";
 import { deriveEntryProvenance, deriveInstallations } from "./installations.js";
 import { indexedPathMatchesOwner, resolveAdapterConceptOwner, } from "./lookup/adapter-concept-owner.js";
 import { generateEmbeddingsForDb } from "./materialize-embeddings.js";
-import { canUseIncrementalSkip, computeDirFingerprint, getCachedZeroRowDirState, getDirIndexState, inferZeroRowReason, } from "./passes/dir-staleness.js";
+import { canUseIncrementalSkip, computeDirFingerprint, getCachedDirState, getDirIndexState, inferZeroRowReason, } from "./passes/dir-staleness.js";
 import { isEnrichmentComplete, isWorkflowSkipWarning } from "./passes/metadata.js";
 import { drainDirDocuments } from "./scan/drain-dir.js";
 import { buildSearchText } from "./search/search-fields.js";
@@ -208,7 +208,7 @@ async function runEmbeddingPhase(ctx) {
  * verify event.
  */
 async function runFinalizePhase(ctx, deferredUpdateTransaction) {
-    const { db, config, sources, sourceDirs, isIncremental, stashDir, signal, onProgress } = ctx;
+    const { db, config, sources, sourceDirs, stashDir, signal, onProgress } = ctx;
     ctx.timing.tFinalizeStart = Date.now();
     // `upsertEntry` and every canonical delete own their FTS projection. This is
     // an observation point, not a second materialization pass.
@@ -360,6 +360,19 @@ export function _setIndexTransactionHookForTests(hook) {
 function indexTransactionHook(point) {
     indexTransactionHookForTests?.(point);
 }
+let drainObserverForTests;
+/**
+ * TEST-ONLY. Observe every directory that actually reaches
+ * `drainDirDocuments` — the per-file read/sha256-hash/frontmatter-parse step
+ * (#900) — with the directory path and its walked file count. `undefined`
+ * restores. A directory the pre-drain gate (`getCachedDirState`) skips never
+ * fires this observer, so it is the
+ * seam #900's own tests use to assert an unchanged directory's files are
+ * never read on a no-op incremental run.
+ */
+export function _setDrainObserverForTests(observer) {
+    drainObserverForTests = observer;
+}
 /**
  * Detect an adapter for every resolvable source that does not declare one, and
  * persist each detection into `config.json`.
@@ -883,17 +896,19 @@ async function scanSourceDirs(db, allSourceEntries, isIncremental, builtAtMs, ha
     // 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, hashByFile, conceptIdByFile, indexVariant, forceScan, pruneMissing) => {
-        const previousState = getDirIndexState(db, dirPath, stateFiles, builtAtMs, indexVariant);
+    const recordFreshnessDecision = (dirPath, currentStashDir, stateFiles, fingerprint, stash, hashByFile, conceptIdByFile, indexVariant, forceScan, pruneMissing) => {
+        const previousState = getDirIndexState(db, dirPath, stateFiles, builtAtMs, indexVariant, fingerprint);
         if (isIncremental && !forceScan && !previousState.stale && canUseIncrementalSkip(previousState, priorDirsChanged)) {
             skippedDirs++;
             dirRecords.push({
                 dirPath,
                 currentStashDir,
                 files: stateFiles,
+                fingerprint,
                 stash: null,
                 skip: true,
                 reason: previousState.reason,
+                persistedRowCount: previousState.persistedRowCount,
                 indexVariant,
             });
             reportDirDecision("skip", dirPath, currentStashDir, previousState.reason, previousState.persistedRowCount);
@@ -906,6 +921,7 @@ async function scanSourceDirs(db, allSourceEntries, isIncremental, builtAtMs, ha
             dirPath,
             currentStashDir,
             files: stateFiles,
+            fingerprint,
             stash,
             skip: false,
             reason,
@@ -959,10 +975,13 @@ async function scanSourceDirs(db, allSourceEntries, isIncremental, builtAtMs, ha
                 reportDirDecision("skip", dirPath, currentStashDir, reason);
                 continue;
             }
-            const cachedZeroRowState = isIncremental &&
+            // #900: decide from stat data alone whether the directory can be skipped,
+            // before drainDirDocuments reads, hashes, and parses every file.
+            const fingerprint = computeDirFingerprint(dirPath, indexableFiles, indexVariant);
+            const cachedState = isIncremental &&
                 !forceScan &&
-                getCachedZeroRowDirState(db, dirPath, indexableFiles, builtAtMs, priorDirsChanged, indexVariant);
-            if (cachedZeroRowState) {
+                getCachedDirState(db, dirPath, indexableFiles, builtAtMs, priorDirsChanged, indexVariant, fingerprint);
+            if (cachedState) {
                 skippedDirs++;
                 dirRecords.push({
                     dirPath,
@@ -970,15 +989,16 @@ async function scanSourceDirs(db, allSourceEntries, isIncremental, builtAtMs, ha
                     files: indexableFiles,
                     stash: null,
                     skip: true,
-                    reason: cachedZeroRowState.reason,
+                    reason: cachedState.reason,
                     indexVariant,
                 });
-                reportDirDecision("skip", dirPath, currentStashDir, cachedZeroRowState.reason, cachedZeroRowState.persistedRowCount);
+                reportDirDecision("skip", dirPath, currentStashDir, cachedState.reason, cachedState.persistedRowCount);
                 continue;
             }
             // F4a M-core-2 (the flip): drain the dir's `IndexDocument` stream via the
             // component's dispatched `adapter.recognize` (broken workflows dropped-with-
             // warning at the drain layer) and reconstruct the durable `IndexDocument`s.
+            drainObserverForTests?.(dirPath, ctxs.length);
             const drained = drainDirDocuments(adapter, component, ctxs);
             if (drained.warnings.length)
                 warnings.push(...drained.warnings);
@@ -992,7 +1012,7 @@ async function scanSourceDirs(db, allSourceEntries, isIncremental, builtAtMs, ha
             if (generated.entries.length > 0) {
                 generatedCount += generated.entries.length;
             }
-            recordFreshnessDecision(dirPath, currentStashDir, staleFiles, stash, drained.hashByFile, drained.conceptIdByFile, indexVariant, forceScan, walkComplete);
+            recordFreshnessDecision(dirPath, currentStashDir, staleFiles, fingerprint, stash, drained.hashByFile, drained.conceptIdByFile, indexVariant, forceScan, walkComplete);
         }
     }
     return {
@@ -1089,7 +1109,7 @@ function persistDirRecords(db, dirRecords, doFullDelete, warnings, sourceRoots,
             // tests/integration/indexer/reindex-generation-atomicity.test.ts.
             indexTransactionHook("full-delete-applied");
         }
-        for (const { dirPath, currentStashDir, files, stash, skip, reason, hashByFile, conceptIdByFile, indexVariant, remove, pruneMissing, } of dirRecords) {
+        for (const { dirPath, currentStashDir, files, fingerprint, stash, skip, reason, persistedRowCount, hashByFile, conceptIdByFile, indexVariant, remove, pruneMissing, } of dirRecords) {
             const bundle = bundleByRoot.get(path.resolve(currentStashDir));
             if (!bundle)
                 throw new Error(`Missing bundle provenance for indexed source ${currentStashDir}`);
@@ -1102,14 +1122,11 @@ function persistDirRecords(db, dirRecords, doFullDelete, warnings, sourceRoots,
                 continue;
             }
             if (skip) {
-                if (reason?.kind === "unchanged") {
-                    const fingerprint = computeDirFingerprint(dirPath, files, indexVariant);
-                    upsertIndexDirState(db, {
-                        dirPath,
-                        fileSetHash: fingerprint.fileSetHash,
-                        fileMtimeMaxMs: fingerprint.fileMtimeMaxMs,
-                        reason: reason.kind,
-                    });
+                // "unchanged" is the post-drain verdict: re-persist so the row carries
+                // row_count and the gate skips this directory before draining next
+                // time. "unchanged-precheck" already matched the stored row.
+                if (reason?.kind === "unchanged" && fingerprint) {
+                    upsertIndexDirState(db, { dirPath, ...fingerprint, reason: reason.kind, rowCount: persistedRowCount });
                 }
                 continue;
             }
@@ -1165,7 +1182,7 @@ function persistDirRecords(db, dirRecords, doFullDelete, warnings, sourceRoots,
             if (pruneMissing !== false) {
                 addEntryIds(deletedUsageEntryIds, deleteEntriesByDirExceptRefs(db, dirPath, bundle.bundleId, keptItemRefs, { cleanupUsageEvents: false }));
             }
-            const fingerprint = computeDirFingerprint(dirPath, files, indexVariant);
+            const persistedFingerprint = fingerprint ?? computeDirFingerprint(dirPath, files, indexVariant);
             const persistedReason = persistedRows === 0
                 ? inferZeroRowReason(stash, reason, warnings, dirPath, dedupedRows)
                 : reason?.kind === "full-rebuild"
@@ -1173,9 +1190,13 @@ function persistDirRecords(db, dirRecords, doFullDelete, warnings, sourceRoots,
                     : (reason?.kind ?? "updated");
             upsertIndexDirState(db, {
                 dirPath,
-                fileSetHash: fingerprint.fileSetHash,
-                fileMtimeMaxMs: fingerprint.fileMtimeMaxMs,
+                ...persistedFingerprint,
                 reason: persistedReason,
+                // A directory that lost rows to per-source dedup depends on the
+                // directories persisted before it, not only on its own files, so it
+                // must keep draining every run (as it did before the gate) until a
+                // drain persists it without dedup. NULL keeps the gate closed.
+                rowCount: dedupedRows === 0 ? persistedRows : undefined,
             });
             if (persistedRows === 0) {
                 // Warn only when the dir had files that *could* produce entries (.md or