knodin 0.8.5 → 0.8.6

package/dist/bin/cli.js

@@ -422,10 +422,16 @@ function formatStatusHuman(result) {
         `${result.freshness.workingTree.pendingPaths ?? "unknown"} pending path(s).\n` +
         `Last successful refresh: ${result.freshness.lastSuccessfulRefresh ?? "never"}.\n` +
         `Freshness mechanism: ${result.freshnessMechanism.strategy}; watcher ${result.freshnessMechanism.watcher}${result.freshnessMechanism.diagnostic ? ` (${result.freshnessMechanism.diagnostic})` : ""}.\n`;
-    if (result.status === "healthy")
-        return `Graph content is healthy: ${coverage} (knodin ${result.version}; ${result.verification.mode}).\n${freshnessLine}${lifecycleLine}${integrationLine}`;
+    if (result.status === "healthy") {
+        const auditNote = result.verification.mode === "persisted-audit"
+            ? ` Cached deep-audit evidence from ${result.verification.auditVerifiedAt ?? "an earlier run"}; freshness probed ${result.verification.verifiedAt ?? "now"}. Run \`knodin status --deep\` for an exact current audit.`
+            : "";
+        return `Graph content is healthy: ${coverage} (knodin ${result.version}; ${result.verification.mode}).${auditNote}\n${freshnessLine}${lifecycleLine}${integrationLine}`;
+    }
     if (result.status === "stale")
-        return `Graph content is intact but evidence is stale (${coverage}).\n${freshnessLine}${lifecycleLine}${integrationLine}Run \`knodin wait --fresh\` or issue a graph query to reconcile bounded drift.\n`;
+        return `Graph content is intact but evidence is stale (${coverage}).${result.verification.mode === "persisted-audit"
+            ? ` Cached deep-audit evidence is from ${result.verification.auditVerifiedAt ?? "an earlier run"}; freshness was probed ${result.verification.verifiedAt ?? "now"}. Run \`knodin status --deep\` for an exact current audit.`
+            : ""}\n${freshnessLine}${lifecycleLine}${integrationLine}Run \`knodin wait --fresh\` or issue a graph query to reconcile bounded drift.\n`;
     const outstanding = result.missing.files.length + result.missing.records.length;
     const firstIssue = result.missing.files[0] ?? result.missing.records[0];
     const detail = firstIssue ? ` First issue: ${firstIssue}.` : "";
@@ -1864,7 +1870,7 @@ async function main() {
         case "status": {
             const snapshot = async () => ({
                 ...attachLifecycleHealth(repo, await engine.status(repo, {
-                    audit: rest.includes("--deep") ? "deep" : "cached",
+                    audit: rest.includes("--deep") ? "deep" : "adaptive",
                 })),
                 integration: inspectRepositoryIntegrationStatus(repo),
                 update: trustedUpdateStatus({

package/dist/src/engine/index.js

@@ -547,6 +547,20 @@ function persistSymbolIdentities(db, repoPath, filePaths) {
         throw error;
     }
 }
+/** Repair-only cancellable identity pass, bounded to one source file per transaction. */
+async function persistSymbolIdentitiesCancellable(db, repoPath, filePaths, signal) {
+    const scope = filePaths === undefined
+        ? db
+            .query("SELECT DISTINCT filePath FROM symbols ORDER BY filePath")
+            .all()
+            .map((row) => row.filePath)
+        : (scopedFilePaths(filePaths) ?? []);
+    for (const file of scope) {
+        throwIfAborted(signal);
+        persistSymbolIdentities(db, repoPath, [file]);
+        await yieldToIndexEventLoop();
+    }
+}
 /** Bind name/file reference rows to exact definitions after identities exist. */
 function persistReferenceEndpoints(db, filePaths) {
     const refs = referencesForFiles(db, filePaths);
@@ -891,18 +905,127 @@ function getGraphAnalyticsSnapshot(allRepos, resolvedRepoPath, topN = 15, relati
 const statusCache = new Map();
 const repairOperations = new Map();
 const STATUS_CACHE_LIMIT = 16;
-function databaseFileFingerprint(databasePath) {
-    return [databasePath, `${databasePath}-wal`]
+export const ADAPTIVE_STATUS_FILE_THRESHOLD = 50_000;
+const PERSISTED_AUDIT_VERSION = 1;
+export function adaptiveStatusStrategy(indexedFiles) {
+    const testThreshold = process.env.KNODIN_TEST_ADAPTIVE_STATUS_THRESHOLD !== undefined
+        ? Number(process.env.KNODIN_TEST_ADAPTIVE_STATUS_THRESHOLD)
+        : ADAPTIVE_STATUS_FILE_THRESHOLD;
+    return indexedFiles <= testThreshold ? "deep" : "persisted";
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw signal.reason instanceof Error
+        ? signal.reason
+        : new DOMException("The operation was aborted", "AbortError");
+}
+function wasAborted(error, signal) {
+    return (signal.aborted &&
+        (error === signal.reason || (error instanceof Error && error.name === "AbortError")));
+}
+function canonicalRepository(repoPath) {
+    try {
+        return fs.realpathSync.native(repoPath);
+    }
+    catch {
+        return path.resolve(repoPath);
+    }
+}
+function persistedStatusAuditPath(databasePath) {
+    return path.join(path.dirname(databasePath), "status-audit-v1.json");
+}
+function readPersistedStatusAudit(repoPath, databasePath, databaseFingerprint, schemaVersion) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(persistedStatusAuditPath(databasePath), "utf8"));
+        if (parsed.format !== PERSISTED_AUDIT_VERSION ||
+            parsed.repository !== canonicalRepository(repoPath) ||
+            parsed.schemaVersion !== schemaVersion ||
+            parsed.knodinVersion !== KNODIN_VERSION ||
+            parsed.databaseFingerprint !== databaseFingerprint ||
+            parsed.result?.status !== "healthy" ||
+            parsed.result?.verification?.mode !== "deep-audit" ||
+            parsed.auditVerifiedAt !== parsed.result.verification.verifiedAt)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function writePersistedStatusAudit(repoPath, databasePath, databaseFingerprint, result) {
+    if (result.status !== "healthy" || result.verification.mode !== "deep-audit")
+        return;
+    const target = persistedStatusAuditPath(databasePath);
+    const temporary = `${target}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    const snapshot = {
+        format: PERSISTED_AUDIT_VERSION,
+        repository: canonicalRepository(repoPath),
+        schemaVersion: result.schemaVersion,
+        knodinVersion: KNODIN_VERSION,
+        databaseFingerprint,
+        auditVerifiedAt: result.verification.verifiedAt,
+        result: structuredClone(result),
+    };
+    try {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(temporary, `${JSON.stringify(snapshot)}\n`, { mode: 0o600, flag: "wx" });
+        fs.renameSync(temporary, target);
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}
+function databaseFileFingerprint(databasePath, db) {
+    const files = [databasePath, `${databasePath}-wal`]
         .map((file) => {
         try {
             const stat = fs.statSync(file);
-            return `${stat.size}:${stat.mtimeMs}`;
+            if (file.endsWith("-wal") && stat.size === 0)
+                return "missing";
+            const descriptor = fs.openSync(file, "r");
+            try {
+                const header = Buffer.alloc(Math.min(100, stat.size));
+                fs.readSync(descriptor, header, 0, header.length, 0);
+                // SQLite rewrites volatile header counters during a clean close even
+                // when graph contents are unchanged. Logical DB evidence below binds
+                // mutations without making process shutdown invalidate the snapshot.
+                if (!file.endsWith("-wal") && header.length >= 40)
+                    header.fill(0, 24, 40);
+                return `${stat.size}:${crypto.createHash("sha256").update(header).digest("hex")}`;
+            }
+            finally {
+                fs.closeSync(descriptor);
+            }
         }
         catch {
             return "missing";
         }
     })
         .join("|");
+    if (!db)
+        return files;
+    try {
+        const counts = ["symbols", "references", "dependencies", "symbol_embeddings", "index_state"]
+            .map((table) => db.query(`SELECT COUNT(*) count FROM "${table}"`).get()?.count ??
+            0)
+            .join(":");
+        const state = db
+            .query("SELECT COUNT(*) count, COALESCE(SUM(mtimeMs),0) mtimes, COALESCE(SUM(size),0) sizes FROM index_state")
+            .get();
+        const meta = db
+            .query("SELECT key, value FROM meta ORDER BY key")
+            .all()
+            .map((row) => `${row.key}=${row.value}`)
+            .join("\0");
+        return `${files}|${crypto
+            .createHash("sha256")
+            .update(`${counts}|${state?.count}:${state?.mtimes}:${state?.sizes}|${meta}`)
+            .digest("hex")}`;
+    }
+    catch {
+        return files;
+    }
 }
 const traversalSnapshotCache = new Map();
 const TRAVERSAL_SNAPSHOT_CACHE_LIMIT = 8;
@@ -6564,9 +6687,10 @@ async function embedPreparedBatch(items, onModelProgress) {
     }
 }
 /** Incrementally generates and saves embeddings for symbols that lack them. */
-async function indexEmbeddings(db, repoPath, progress) {
+async function indexEmbeddings(db, repoPath, progress, signal) {
     return measurePerfPhase("embedding_inference_write", async () => {
         try {
+            throwIfAborted(signal);
             const missingStmt = db.query(`
 			SELECT id, name, kind, filePath, startLine, endLine, summary
 			FROM symbols
@@ -6608,6 +6732,7 @@ async function indexEmbeddings(db, repoPath, progress) {
             const sourceForEmbedding = createEmbeddingSourceReader(repoPath);
             let lastYieldAt = Date.now();
             for (let offset = 0; offset < missing.length; offset += batchSize) {
+                throwIfAborted(signal);
                 const prepared = missing.slice(offset, offset + batchSize).map((sym) => {
                     const source = sourceForEmbedding(sym.filePath, sym.startLine, sym.endLine);
                     return {
@@ -6616,6 +6741,7 @@ async function indexEmbeddings(db, repoPath, progress) {
                     };
                 });
                 const generated = await embedPreparedBatch(prepared, onModelProgress);
+                throwIfAborted(signal);
                 db.run("BEGIN TRANSACTION;");
                 try {
                     for (const { symbol, embedding: embeddingVec } of generated) {
@@ -6638,6 +6764,7 @@ async function indexEmbeddings(db, repoPath, progress) {
             insertEmbedding.finalize();
         }
         catch (error) {
+            throwIfAborted(signal);
             console.error("Error during indexEmbeddings:", error);
         }
     });
@@ -6814,6 +6941,63 @@ function gitTrackedCandidates(repoPath) {
         return null;
     }
 }
+async function execGitAbortable(repoPath, args, signal) {
+    throwIfAborted(signal);
+    return await new Promise((resolve, reject) => {
+        child_process.execFile("git", args, {
+            cwd: repoPath,
+            encoding: "utf8",
+            maxBuffer: 64 * 1024 * 1024,
+            signal,
+        }, (error, stdout) => error
+            ? reject(error instanceof Error
+                ? error
+                : new Error(typeof error === "string" ? error : "Git subprocess failed"))
+            : resolve(stdout));
+    });
+}
+async function collectRepoFilesWithCoverageAbortable(repoPath, signal) {
+    let candidates = null;
+    try {
+        const gitRoot = (await execGitAbortable(repoPath, ["rev-parse", "--show-toplevel"], signal)).trim();
+        if (gitRoot && isSameDir(gitRoot, repoPath)) {
+            candidates = splitNulPaths(await execGitAbortable(repoPath, ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], signal));
+        }
+    }
+    catch {
+        throwIfAborted(signal);
+    }
+    const files = [];
+    const skippedByExtension = new Map();
+    const source = candidates ?? walkRepoFiles(repoPath);
+    for (let index = 0; index < source.length; index++) {
+        if (index % 256 === 0) {
+            throwIfAborted(signal);
+            await yieldToIndexEventLoop();
+        }
+        const file = source[index];
+        if (candidates) {
+            try {
+                if (!fs.statSync(path.join(repoPath, file)).isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+        }
+        if (!isIndexablePath(file))
+            continue;
+        if (!isIndexableSourcePath(file)) {
+            tallyOne(skippedByExtension, extensionBucket(file));
+            continue;
+        }
+        if (!file.endsWith(".json") || isIndexableJsonCandidate(file, repoPath))
+            files.push(file);
+        else
+            tallyOne(skippedByExtension, ".json");
+    }
+    return { files: files.sort(compareBytes), skippedByExtension };
+}
 /**
  * Enumerate the repo-relative files knodin indexes: source files plus dbt
  * `manifest.json` files and Dockerfiles. Shared by the full index and the
@@ -6919,8 +7103,8 @@ function freshnessFingerprint(value) {
         return null;
     return crypto.createHash("sha256").update(value).digest("hex");
 }
-function buildFreshnessEnvelope(repoPath, db, verifiedAt, stateOverride) {
-    const git = gitWorkTreeProbe(repoPath);
+function buildFreshnessEnvelope(repoPath, db, verifiedAt, stateOverride, gitProbe) {
+    const git = gitProbe === undefined ? gitWorkTreeProbe(repoPath) : gitProbe;
     const currentHead = git && isSameDir(git.root, repoPath) ? git.head || null : gitHead(repoPath);
     const indexedHead = db ? getMeta(db, "lastIndexedHead") || null : null;
     const relation = commitRelation(repoPath, indexedHead, currentHead);
@@ -7336,7 +7520,7 @@ function gitWorkTreeProbe(repoPath) {
         // Porcelain: `XY <path>` (or `XY <orig> -> <new>` for renames).
         for (const part of line.slice(3).split(" -> ")) {
             const p = part.trim().replace(/^"|"$/g, "");
-            if (p)
+            if (p && isIndexablePath(p))
                 dirty.push(p);
         }
     }
@@ -7403,8 +7587,8 @@ function recordFreshnessBaseline(repoPath, db) {
  * pretending. A brand-new file in a non-git repo is consequently picked up by
  * the watcher or a cold start, not by this probe.
  */
-function probeDrift(repoPath, db) {
-    const git = gitWorkTreeProbe(repoPath);
+function probeDrift(repoPath, db, gitProbe) {
+    const git = gitProbe === undefined ? gitWorkTreeProbe(repoPath) : gitProbe;
     if (git && isSameDir(git.root, repoPath)) {
         if ((getMeta(db, "lastIndexedHead") ?? "") !== git.head) {
             return { drifted: true, verifiable: true };
@@ -9025,7 +9209,7 @@ function reviewChangedFiles(base, repoPath, options, modified) {
             args.push(safeReviewRevision(base || "HEAD"));
         args.push("--");
         for (const file of runGit(repoPath, args).split("\0")) {
-            if (file)
+            if (file && isIndexablePath(file))
                 files.add(file);
         }
     }
@@ -9042,7 +9226,7 @@ function reviewChangedFiles(base, repoPath, options, modified) {
                 "--exclude-standard",
                 "-z",
             ]).split("\0")) {
-                if (file)
+                if (file && isIndexablePath(file))
                     files.add(file);
             }
         }
@@ -10572,23 +10756,30 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
         const operation = Promise.resolve()
             .then(async () => {
             outerLease = acquireRepairLease(resolved);
-            before = await engine.status(resolved, { audit: "deep" });
+            before = await engine.status(resolved, {
+                audit: "deep",
+                signal: activeOperation.controller.signal,
+            });
             await suspendFileWatcher(resolved);
             const activePath = resolveDbPath(resolved);
             if (fs.existsSync(activePath)) {
-                const active = dbInstances.get(resolved) ?? new Database(activePath);
+                candidate = await engine.createCandidate(resolved, { empty: true });
+                const existing = dbInstances.get(resolved);
+                const active = existing ?? new Database(activePath, { readonly: true });
                 try {
-                    active.run("PRAGMA wal_checkpoint(TRUNCATE);");
+                    // VACUUM INTO reads a transactionally consistent image, including WAL
+                    // pages, without checkpointing or rewriting the active graph.
+                    const destination = candidate.databasePath.replaceAll("'", "''");
+                    active.run(`VACUUM INTO '${destination}'`);
                 }
                 finally {
-                    active.close();
+                    if (!existing)
+                        active.close();
                 }
-                dbInstances.delete(resolved);
-                initPromises.delete(resolved);
-                for (const suffix of ["-wal", "-shm"])
-                    fs.rmSync(`${activePath}${suffix}`, { force: true });
             }
-            candidate = await engine.createCandidate(resolved, fs.existsSync(activePath) ? { sourceDatabasePath: activePath } : undefined);
+            else {
+                candidate = await engine.createCandidate(resolved);
+            }
             candidateEngine = createEngine({
                 watcher: "disabled",
                 databasePath: candidate.databasePath,
@@ -10604,7 +10795,9 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
             if (staged.cancelled || !staged.verified) {
                 await engine.discardCandidate(candidate);
                 candidate = undefined;
-                const after = await engine.status(resolved, { audit: "deep" });
+                const after = staged.cancelled
+                    ? before
+                    : await engine.status(resolved, { audit: "deep" });
                 if (pendingCompleted)
                     deliver(pendingCompleted);
                 return {
@@ -11700,6 +11893,7 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
         },
         async status(repoPath, options = {}) {
             const resolved = path.resolve(repoPath);
+            throwIfAborted(options.signal);
             // Audit must not run the cold-start reconciler: otherwise status would
             // repair and timestamp drift before reporting it. Reuse an active DB in
             // long-lived processes, or open the existing local DB read-only.
@@ -11805,9 +11999,49 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                     ],
                 };
             }
-            const databaseFingerprint = databaseFileFingerprint(diskDbPath);
+            const databaseFingerprint = databaseFileFingerprint(diskDbPath, db);
+            let effectiveAudit = options.audit ?? "cached";
+            if (effectiveAudit === "adaptive") {
+                let indexedFileCount = 0;
+                try {
+                    indexedFileCount =
+                        db.query("SELECT COUNT(*) count FROM index_state").get()
+                            ?.count ?? 0;
+                }
+                catch {
+                    // A malformed schema needs the existing deep diagnostic path.
+                }
+                if (adaptiveStatusStrategy(indexedFileCount) === "deep") {
+                    effectiveAudit = "deep";
+                }
+                else {
+                    const schemaVersion = db.query("PRAGMA user_version").get()?.user_version ?? 0;
+                    const persisted = readPersistedStatusAudit(resolved, diskDbPath, databaseFingerprint, schemaVersion);
+                    if (persisted) {
+                        throwIfAborted(options.signal);
+                        const gitProbe = measurePerfPhaseSync("freshness_probe", () => gitWorkTreeProbe(resolved));
+                        const drift = probeDrift(resolved, db, gitProbe);
+                        const probeVerifiedAt = new Date().toISOString();
+                        const freshness = buildFreshnessEnvelope(resolved, db, probeVerifiedAt, drift.verifiable ? (drift.drifted ? "stale-working-tree" : undefined) : "unknown", gitProbe);
+                        if (!activeDb)
+                            db.close();
+                        const cachedResult = structuredClone(persisted.result);
+                        return {
+                            ...cachedResult,
+                            status: drift.verifiable && !drift.drifted ? "healthy" : "stale",
+                            freshness,
+                            verification: {
+                                mode: "persisted-audit",
+                                auditVerifiedAt: persisted.auditVerifiedAt,
+                                verifiedAt: probeVerifiedAt,
+                            },
+                        };
+                    }
+                    effectiveAudit = "deep";
+                }
+            }
             const cached = statusCache.get(statusCacheKey);
-            if (options.audit !== "deep" &&
+            if (effectiveAudit !== "deep" &&
                 cached?.generation === indexGeneration &&
                 cached.databaseFingerprint === databaseFingerprint) {
                 const auditVerifiedAt = Date.parse(cached.result.verification.verifiedAt);
@@ -11833,6 +12067,8 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                             ...cachedResult,
                             verification: {
                                 mode: "cached-after-freshness-probe",
+                                auditVerifiedAt: cached.result.verification.auditVerifiedAt ??
+                                    cached.result.verification.verifiedAt,
                                 verifiedAt: new Date(lease.at).toISOString(),
                             },
                         };
@@ -11847,6 +12083,8 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                             ...cachedResult,
                             verification: {
                                 mode: "cached-after-freshness-probe",
+                                auditVerifiedAt: cached.result.verification.auditVerifiedAt ??
+                                    cached.result.verification.verifiedAt,
                                 verifiedAt,
                             },
                         };
@@ -11857,7 +12095,11 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                     // reports repair steps instead of hiding the database problem.
                 }
             }
-            const collected = measurePerfPhaseSync("status_audit", () => collectRepoFilesWithCoverage(resolved));
+            throwIfAborted(options.signal);
+            const collected = options.signal
+                ? await measurePerfPhase("status_audit", () => collectRepoFilesWithCoverageAbortable(resolved, options.signal))
+                : measurePerfPhaseSync("status_audit", () => collectRepoFilesWithCoverage(resolved));
+            throwIfAborted(options.signal);
             const sourceFiles = collected.files;
             const coverageSkips = buildCoverageSkips(collected.skippedByExtension, db);
             const schemaVersion = db.query("PRAGMA user_version").get()?.user_version ?? 0;
@@ -11941,25 +12183,29 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                 .all()
                 .map((r) => r.filePath));
             const missingFiles = sourceFiles.filter((file) => !indexed.has(file));
-            const staleFiles = indexedRows
-                .map((row) => row.filePath)
-                .filter((file) => !sourceFileSet.has(file) && !fs.existsSync(path.join(resolved, file)));
-            const ineligibleFiles = indexedRows
-                .map((row) => row.filePath)
-                .filter((file) => !sourceFileSet.has(file) && fs.existsSync(path.join(resolved, file)));
-            const damagedFiles = indexedRows
-                .filter((row) => {
-                if (!sourceFileSet.has(row.filePath))
-                    return false;
+            const staleFiles = [];
+            const ineligibleFiles = [];
+            const damagedFiles = [];
+            for (let index = 0; index < indexedRows.length; index++) {
+                if (options.signal && index % 256 === 0) {
+                    throwIfAborted(options.signal);
+                    await yieldToIndexEventLoop();
+                }
+                const row = indexedRows[index];
+                const exists = fs.existsSync(path.join(resolved, row.filePath));
+                if (!sourceFileSet.has(row.filePath)) {
+                    (exists ? ineligibleFiles : staleFiles).push(row.filePath);
+                    continue;
+                }
                 try {
                     const stat = fs.statSync(path.join(resolved, row.filePath));
-                    return stat.size !== row.size || stat.mtimeMs !== row.mtimeMs;
+                    if (stat.size !== row.size || stat.mtimeMs !== row.mtimeMs)
+                        damagedFiles.push(row.filePath);
                 }
                 catch {
-                    return false;
+                    // A concurrently removed file is represented by the next audit/probe.
                 }
-            })
-                .map((row) => row.filePath);
+            }
             const count = (sql) => db.query(sql).get()?.count ?? 0;
             const orphaned = {
                 embeddings: count(`SELECT COUNT(*) count FROM symbol_embeddings WHERE ${ORPHANED_EMBEDDING_PREDICATE}`),
@@ -12009,7 +12255,7 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                 lastIndexedHead: getMeta(db, "lastIndexedHead") ?? "",
                 freshness,
                 indexGeneration,
-                verification: { mode: "deep-audit", verifiedAt },
+                verification: { mode: "deep-audit", auditVerifiedAt: verifiedAt, verifiedAt },
                 freshnessMechanism: freshnessMechanismFor(resolved, openPolicy),
                 repairSteps: needsRepair
                     ? [
@@ -12018,15 +12264,25 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                     ]
                     : [],
             };
-            if (!activeDb)
-                db.close();
             if (!needsRepair && !stale)
                 noteFreshness(resolved, "fresh");
+            if (activeDb) {
+                try {
+                    db.run("PRAGMA wal_checkpoint(PASSIVE);");
+                }
+                catch {
+                    // A concurrent reader can defer checkpointing; the WAL fingerprint remains binding.
+                }
+            }
+            const finalDatabaseFingerprint = databaseFileFingerprint(diskDbPath, db);
             setBoundedCache(statusCache, statusCacheKey, {
                 generation: indexGeneration,
-                databaseFingerprint,
+                databaseFingerprint: finalDatabaseFingerprint,
                 result: structuredClone(result),
             }, STATUS_CACHE_LIMIT);
+            writePersistedStatusAudit(resolved, diskDbPath, finalDatabaseFingerprint, result);
+            if (!activeDb)
+                db.close();
             return result;
         },
         async repair(repoPath, options) {
@@ -12116,10 +12372,7 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                     await suspendFileWatcher(resolved);
                 if (openPolicy.repairLease !== "disabled")
                     repairLease = acquireRepairLease(resolved);
-                const cancelBoundary = () => {
-                    if (activeOperation.controller.signal.aborted)
-                        throw activeOperation.controller.signal;
-                };
+                const cancelBoundary = () => throwIfAborted(activeOperation.controller.signal);
                 const invalidateCommittedWork = () => {
                     if (!openPolicy.databasePath &&
                         committedWork &&
@@ -12127,7 +12380,10 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                         indexGeneration++;
                 };
                 emitProgress("audit", 0, "Auditing repository health");
-                before = await engine.status(resolved);
+                before = await engine.status(resolved, {
+                    audit: "deep",
+                    signal: activeOperation.controller.signal,
+                });
                 emitProgress("audit", 1, "Repository health audit completed", {
                     phaseTotal: 1,
                 });
@@ -12273,7 +12529,11 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                         phaseTotal: 1,
                     });
                     cancelBoundary();
-                    persistSymbolIdentities(db, resolved, inheritedPostprocessing ? undefined : repairPaths);
+                    const identityScope = inheritedPostprocessing ? undefined : repairPaths;
+                    if (options?.signal)
+                        await persistSymbolIdentitiesCancellable(db, resolved, identityScope, activeOperation.controller.signal);
+                    else
+                        persistSymbolIdentities(db, resolved, identityScope);
                     if (repairAffectsTypeScriptDi)
                         reconcileTypeScriptDi(db, resolved);
                     committedWork = true;
@@ -12296,7 +12556,7 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                             const model = details.modelFile ? ` (${details.modelFile})` : "";
                             emitProgress("embeddings", 0, `${message}${model}`);
                         }
-                    });
+                    }, activeOperation.controller.signal);
                     committedWork = true;
                     setMeta(db, "repairPostprocessingPending", "0");
                     overallCompleted++;
@@ -12352,7 +12612,10 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                     phaseTotal: 1,
                 });
                 cancelBoundary();
-                let after = await engine.status(resolved, { audit: "deep" });
+                let after = await engine.status(resolved, {
+                    audit: "deep",
+                    signal: activeOperation.controller.signal,
+                });
                 cancelBoundary();
                 overallCompleted++;
                 emitProgress("verification", 1, "Repair verification completed", {
@@ -12376,7 +12639,10 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                             setMeta(db, "lastSuccessfulReconciliation", new Date().toISOString());
                             recordFreshnessBaseline(resolved, db);
                             statusCache.delete(databaseCacheKey(resolved, openPolicy.databasePath));
-                            const candidate = await engine.status(resolved, { audit: "deep" });
+                            const candidate = await engine.status(resolved, {
+                                audit: "deep",
+                                signal: activeOperation.controller.signal,
+                            });
                             if (candidate.status === "healthy") {
                                 db.run("COMMIT;");
                                 after = candidate;
@@ -12384,7 +12650,10 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                             else {
                                 db.run("ROLLBACK;");
                                 statusCache.delete(databaseCacheKey(resolved, openPolicy.databasePath));
-                                after = await engine.status(resolved, { audit: "deep" });
+                                after = await engine.status(resolved, {
+                                    audit: "deep",
+                                    signal: activeOperation.controller.signal,
+                                });
                             }
                         }
                         catch (error) {
@@ -12414,12 +12683,14 @@ export function createEngine(openPolicy = DEFAULT_ENGINE_OPEN_POLICY) {
                 return result;
             })
                 .catch(async (error) => {
-                if (error === activeOperation.controller.signal) {
+                if (wasAborted(error, activeOperation.controller.signal)) {
                     if (!openPolicy.databasePath &&
                         committedWork &&
                         indexGeneration === generationBeforeRepair)
                         indexGeneration++;
-                    const after = await engine.status(resolved, { audit: "deep" });
+                    const after = openPolicy.databasePath
+                        ? before
+                        : await engine.status(resolved, { audit: "deep" });
                     const remaining = Math.max(0, repairPaths.length - completedFiles);
                     emitProgress("cancelled", completedFiles, `Repair cancelled with ${remaining} file(s) remaining`, { phaseTotal: repairPaths.length });
                     return {

package/docs/releases/0.8.6.md

@@ -0,0 +1,10 @@
+# knodin 0.8.6
+
+This patch release makes bare `knodin status` adaptive and improves graceful repair cancellation.
+
+- Repositories with at most 50,000 indexed files receive the existing exact deep audit.
+- Larger repositories may reuse healthy persisted deep-audit evidence after a current Git freshness probe. The evidence is bound to the canonical repository, graph schema, knodin version, and SQLite/WAL fingerprint; `knodin status --deep` always bypasses it.
+- Human and JSON status output distinguish when the full audit ran from when freshness was most recently probed.
+- Deep status accepts an abort signal, embedding repair checks cancellation between batches, and cancelled candidate repair returns without starting another deep audit.
+
+Persisted evidence does not claim that every source file was inspected during the latest status invocation. Use `knodin status --deep` whenever an exact current filesystem/schema/orphan audit is required.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "knodin",
-	"version": "0.8.5",
+	"version": "0.8.6",
 	"description": "knodin — source-evidenced local code intelligence with known bounds. Stable identity, fresh evidence, truthful budgets, and recoverable bounded views.",
 	"license": "MIT",
 	"repository": {
@@ -62,6 +62,7 @@
 		"docs/releases/0.8.3.md",
 		"docs/releases/0.8.4.md",
 		"docs/releases/0.8.5.md",
+		"docs/releases/0.8.6.md",
 		"docs/assets/knodin-favicon.svg",
 		"docs/SYSTEMS-AND-RELATIONSHIPS.md",
 		"docs/TELEMETRY.md",