akm-cli 0.9.0-rc.1 → 0.9.0-rc.3

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

@@ -16,7 +16,7 @@
  *   1. An LLM profile must be configured (no provider = no extraction). When
  *      absent, `resolveIndexPassLLM("graph", config)` returns `undefined`
  *      and the pass short-circuits.
- *   2. `profiles.improve.default.processes.graphExtraction.enabled !== false`
+ *   2. The selected strategy's `processes.graphExtraction.enabled !== false`
  *      — the feature-gate layer (historically v1 spec §14, since superseded by
  *      the 0.8.0 profile shape). Set to `false` to block the pass at the
  *      feature-gate layer (no network call may ever issue).
@@ -260,7 +260,7 @@ function reuseGraphNode(previousNodes, candidate, bodyHash) {
  *   1. **Provider configured** — an LLM profile must be selectable. Without a
  *      configured provider, `resolveIndexPassLLM("graph", config)` returns
  *      `undefined` (the pass cannot run because there is no model to call).
- *   2. **Feature gate** — `profiles.improve.default.processes.graphExtraction.enabled`
+ *   2. **Feature gate** — the selected strategy's `processes.graphExtraction.enabled`
  *      (defaults to `true`). When `false`, no network call may issue regardless
  *      of per-pass settings.
  *   3. **Per-pass gate** — `index.graph.llm` (defaults to `true`). When
@@ -276,21 +276,25 @@ function reuseGraphNode(previousNodes, candidate, bodyHash) {
  */
 export async function runGraphExtractionPass(ctx) {
     const { config, sources, signal, db, reEnrich, onProgress, options = {} } = ctx;
+    const invocationOwnsConnection = Object.hasOwn(ctx, "llmConfig");
     // Gate 1 — feature gate via isProcessEnabled, which reads the 0.8.0 path
-    // (profiles.improve.default.processes.graphExtraction.enabled). Defaults to
+    // (selected strategy's processes.graphExtraction.enabled). Defaults to
     // enabled when the key is absent.
-    if (!isProcessEnabled("index", "graph_extraction", config))
+    if (!invocationOwnsConnection && !isProcessEnabled("index", "graph_extraction", config))
         return { ...EMPTY_RESULT };
     // Gate 2 — per-pass opt-out (#208). Returns the resolved llm config or
     // `undefined` when the pass should not run.
-    const llmConfig = resolveIndexPassLLM("graph", config);
+    const llmConfig = Object.hasOwn(ctx, "llmConfig") ? ctx.llmConfig : resolveIndexPassLLM("graph", config);
     if (!llmConfig) {
-        const reason = getIndexPassConfig(config.index, "graph")?.llm === false
-            ? "index.graph.llm is false"
-            : "no default LLM profile is configured";
+        const reason = getIndexPassConfig(config.index, "graph")?.enabled === false
+            ? "index.graph.enabled is false"
+            : "no LLM engine is configured";
         warnVerbose(`graph extraction: skipped because ${reason}.`);
         return { ...EMPTY_RESULT };
     }
+    const featureConfig = invocationOwnsConnection
+        ? { ...config, index: { ...config.index, graph: { ...config.index?.graph, enabled: true } } }
+        : config;
     // The pass only writes to the primary (working) stash. Read-only caches
     // (git, npm, website) are deliberately untouched — the graph artifact for
     // those sources would be clobbered by the next sync().
@@ -309,10 +313,14 @@ export async function runGraphExtractionPass(ctx) {
         for (const queued of drained) {
             if (signal?.aborted)
                 break;
-            await extractGraphForSingleFile(db, primary.path, queued.filePath, queued.bodyHash, { config, signal });
+            await extractGraphForSingleFile(db, primary.path, queued.filePath, queued.bodyHash, {
+                config: featureConfig,
+                signal,
+                llmConfig,
+            });
         }
     }
-    const includeTypes = getGraphExtractionIncludeTypes(config);
+    const includeTypes = options.includeTypes ?? getGraphExtractionIncludeTypes(config);
     let eligible = collectEligibleFiles(primary.path, includeTypes).filter((candidate) => !options.candidatePaths || options.candidatePaths.has(candidate.absPath));
     // P2 (#624): when topN is set and a DB is available, rank the (already
     // candidate-filtered) eligible set by utility_scores DESC and keep only the
@@ -357,7 +365,7 @@ export async function runGraphExtractionPass(ctx) {
     // Resolve the effective batch size. Falls back to
     // DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE (4) when unset, and clamps against
     // `llm.contextLength` if the model's context window is configured.
-    const batchSize = resolveBatchSize(getIndexPassConfig(config.index, "graph")?.graphExtractionBatchSize, llmConfig.contextLength);
+    const batchSize = resolveBatchSize(options.batchSize ?? getIndexPassConfig(config.index, "graph")?.graphExtractionBatchSize, llmConfig.contextLength);
     const extractionRunId = crypto.randomUUID();
     const extractorId = getGraphExtractorId({ model: llmConfig.model, batchSize, includeTypes });
     const cacheVariant = extractorId;
@@ -438,7 +446,7 @@ export async function runGraphExtractionPass(ctx) {
             }
             if (!cached) {
                 telemetry.cacheMisses += 1;
-                const extraction = await graphExtract.extractGraphFromBody(llmConfig, candidate.body, signal, config, onFallback, { batchState, telemetry: runtimeTelemetry });
+                const extraction = await graphExtract.extractGraphFromBody(llmConfig, candidate.body, signal, featureConfig, onFallback, { batchState, telemetry: runtimeTelemetry });
                 cached = {
                     entities: extraction.entities,
                     relations: extraction.relations,
@@ -562,7 +570,7 @@ export async function runGraphExtractionPass(ctx) {
             telemetry.cacheMisses += uncachedChunk.length;
             // extractGraphFromBodies always returns an array of the same length
             // as bodies (it falls back per-asset for any missing indices).
-            const batchExtractions = await graphExtract.extractGraphFromBodies(llmConfig, bodies, signal, config, onFallback, { batchState, telemetry: runtimeTelemetry });
+            const batchExtractions = await graphExtract.extractGraphFromBodies(llmConfig, bodies, signal, featureConfig, onFallback, { batchState, telemetry: runtimeTelemetry });
             // Map LLM results back to original positions and write cache entries.
             let llmIdx = 0;
             for (let j = 0; j < chunk.length; j++) {
@@ -718,12 +726,16 @@ export async function extractGraphForSingleFile(db, stashRoot, filePath, bodyHas
         }
         else {
             const config = opts?.config ?? loadConfig();
-            if (!isProcessEnabled("index", "graph_extraction", config))
+            const invocationOwnsConnection = Object.hasOwn(opts ?? {}, "llmConfig");
+            if (!invocationOwnsConnection && !isProcessEnabled("index", "graph_extraction", config))
                 return false;
-            const llmConfig = resolveIndexPassLLM("graph", config);
+            const llmConfig = Object.hasOwn(opts ?? {}, "llmConfig") ? opts?.llmConfig : resolveIndexPassLLM("graph", config);
             if (!llmConfig)
                 return false; // model-available guard
-            const result = await graphExtract.extractGraphFromBody(llmConfig, body, opts?.signal, config);
+            const featureConfig = invocationOwnsConnection
+                ? { ...config, index: { ...config.index, graph: { ...config.index?.graph, enabled: true } } }
+                : config;
+            const result = await graphExtract.extractGraphFromBody(llmConfig, body, opts?.signal, featureConfig);
             extraction = {
                 entities: result.entities,
                 relations: result.relations,

package/dist/indexer/index-writer-lock.js

@@ -1,17 +1,18 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { AsyncLocalStorage } from "node:async_hooks";
 import fs from "node:fs";
 import path from "node:path";
-import { probeLock, releaseLock, releaseLockIfOwned, tryAcquireLockSync } from "../core/file-lock.js";
+import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync, } from "../core/file-lock.js";
+import { tryAcquireMaintenanceBarrier } from "../core/maintenance-barrier.js";
 import { getDbPath, getIndexWriterLockPath } from "../core/paths.js";
 const INDEX_WRITER_LOCK_STALE_AFTER_MS = 12 * 60 * 60 * 1000;
 const INDEX_WRITER_WAIT_MS = 100;
 const DEFAULT_INDEX_WRITER_MAX_WAIT_MS = 10 * 60 * 1000;
-const heldLocks = new Map();
-function buildPayload(purpose, pid = process.pid) {
-    return JSON.stringify({
-        pid,
+const leaseContext = new AsyncLocalStorage();
+function buildPayload(purpose) {
+    return createLockPayload({
         purpose,
         dbPath: getDbPath(),
         startedAt: new Date().toISOString(),
@@ -25,27 +26,20 @@ function throwIfAborted(signal) {
         return;
     throw signal.reason instanceof Error ? signal.reason : new Error("index writer wait aborted");
 }
-function releaseHeldLock(lockPath) {
-    const held = heldLocks.get(lockPath);
-    if (!held)
-        return;
-    held.depth -= 1;
-    if (held.depth > 0)
-        return;
-    heldLocks.delete(lockPath);
-    process.off("exit", held.exitHandler);
-    releaseLockIfOwned(lockPath, process.pid);
-}
-function retainHeldLock(lockPath) {
-    const existing = heldLocks.get(lockPath);
-    if (existing) {
-        existing.depth += 1;
-        return { lockPath, release: () => releaseHeldLock(lockPath) };
-    }
-    const exitHandler = () => releaseLockIfOwned(lockPath, process.pid);
+function createLease(lockPath, ownership) {
+    const exitHandler = () => releaseLock(ownership);
     process.on("exit", exitHandler);
-    heldLocks.set(lockPath, { depth: 1, exitHandler });
-    return { lockPath, release: () => releaseHeldLock(lockPath) };
+    let released = false;
+    return {
+        lockPath,
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            process.off("exit", exitHandler);
+            releaseLock(ownership);
+        },
+    };
 }
 export async function acquireIndexWriterLease(options) {
     const mode = options.mode ?? "wait";
@@ -53,25 +47,26 @@ export async function acquireIndexWriterLease(options) {
     const startedAt = Date.now();
     const maxWaitMs = options.maxWaitMs ?? DEFAULT_INDEX_WRITER_MAX_WAIT_MS;
     fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-    if (heldLocks.has(lockPath)) {
-        options.onAcquired?.({ waitedMs: 0 });
-        return retainHeldLock(lockPath);
-    }
     let lastWaitNoticeMs = 0;
     while (true) {
         throwIfAborted(options.signal);
-        if (tryAcquireLockSync(lockPath, buildPayload(options.purpose))) {
-            options.onAcquired?.({ waitedMs: Date.now() - startedAt });
-            return retainHeldLock(lockPath);
-        }
-        const probe = probeLock(lockPath, { staleAfterMs: INDEX_WRITER_LOCK_STALE_AFTER_MS });
-        if (probe.state === "held" && probe.holderPid === process.pid) {
-            options.onAcquired?.({ waitedMs: Date.now() - startedAt });
-            return retainHeldLock(lockPath);
-        }
-        if (probe.state === "stale") {
-            releaseLock(lockPath);
-            continue;
+        const releaseBarrier = tryAcquireMaintenanceBarrier();
+        if (releaseBarrier) {
+            try {
+                const ownership = tryAcquireLockSync(lockPath, buildPayload(options.purpose));
+                if (ownership) {
+                    options.onAcquired?.({ waitedMs: Date.now() - startedAt });
+                    return createLease(lockPath, ownership);
+                }
+                const probe = probeLock(lockPath, { staleAfterMs: INDEX_WRITER_LOCK_STALE_AFTER_MS });
+                if (probe.state === "stale") {
+                    if (reclaimStaleLock(lockPath, probe))
+                        continue;
+                }
+            }
+            finally {
+                releaseBarrier();
+            }
         }
         if (mode === "try")
             return undefined;
@@ -90,16 +85,29 @@ export async function acquireIndexWriterLease(options) {
     }
 }
 export async function withIndexWriterLease(options, run) {
-    const lease = await acquireIndexWriterLease(options);
-    if (!lease) {
-        throw new Error(`index writer lease unavailable for ${options.purpose}`);
-    }
-    try {
-        return await run();
-    }
-    finally {
-        lease.release();
-    }
+    const lockPath = getIndexWriterLockPath();
+    const inherited = leaseContext.getStore();
+    if (inherited?.has(lockPath))
+        return run();
+    const context = inherited ?? new Set();
+    const execute = async () => {
+        const lease = await acquireIndexWriterLease(options);
+        if (!lease)
+            throw new Error(`index writer lease unavailable for ${options.purpose}`);
+        context.add(lockPath);
+        try {
+            return await run();
+        }
+        finally {
+            context.delete(lockPath);
+            lease.release();
+        }
+    };
+    return inherited ? execute() : leaseContext.run(context, execute);
+}
+/** Asset writes and index rebuilds share one lease so scans cannot publish stale snapshots. */
+export function withAssetMutationLease(purpose, run) {
+    return withIndexWriterLease({ purpose }, run);
 }
 export function probeIndexWriterLease() {
     return probeLock(getIndexWriterLockPath(), { staleAfterMs: INDEX_WRITER_LOCK_STALE_AFTER_MS });

package/dist/indexer/index-written-assets.js

@@ -23,7 +23,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { getDbPath } from "../core/paths.js";
 import { warnVerbose } from "../core/warn.js";
-import { closeDatabase, getEntryCount, openExistingDatabase, rebuildFts, upsertEntry } from "./db/db.js";
+import { takeWorkflowDocument } from "../workflows/runtime/document-cache.js";
+import { closeDatabase, deleteEntriesByIds, getEntryCount, openExistingDatabase, rebuildFts, upsertEntry, upsertWorkflowDocument, } from "./db/db.js";
+import { withIndexWriterLease } from "./index-writer-lock.js";
 import { generateMetadataFlat } from "./passes/metadata.js";
 import { buildSearchText } from "./search/search-fields.js";
 /**
@@ -46,60 +48,84 @@ export const WRITE_PATH_INDEX_BUSY_TIMEOUT_MS = 5_000;
  * first read (`ensureIndex`) or an explicit `akm index`, which also cover
  * embeddings and the other passes this fast path skips.
  */
-export async function indexWrittenAssets(stashDir, filePaths) {
+export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
     try {
-        const dbPath = getDbPath();
-        if (!fs.existsSync(dbPath))
-            return;
-        // The full walk never descends into dot-directories (they hold state like
-        // `.meta/`, `.stash.json`), and `shouldIndexStashFile` relies on the walker
-        // for that — mirror it here so this fast path indexes exactly what a full
-        // run would.
-        const files = filePaths.filter((f) => {
-            if (!fs.existsSync(f))
-                return false;
-            const rel = path.relative(stashDir, f);
-            return !rel.split(/[\\/]+/).some((segment) => segment.startsWith("."));
-        });
-        if (files.length === 0)
-            return;
-        // Generate metadata BEFORE opening the DB so the write window stays
-        // short. One call per file keeps the entry↔path pairing exact.
-        const pairs = [];
-        for (const file of files) {
-            const generated = await generateMetadataFlat(stashDir, [file]);
-            const entry = generated.entries[0];
-            // Workflows carry a side-table document upsert this fast path doesn't
-            // do; no current caller writes them, but guard so one never lands
-            // half-indexed.
-            if (entry && entry.type !== "workflow")
-                pairs.push({ file, entry });
-        }
-        if (pairs.length === 0)
-            return;
-        const db = openExistingDatabase(dbPath);
-        try {
-            db.exec(`PRAGMA busy_timeout = ${WRITE_PATH_INDEX_BUSY_TIMEOUT_MS}`);
-            if (getEntryCount(db) === 0)
-                return;
-            for (const { file, entry } of pairs) {
-                const entryKey = `${stashDir}:${entry.type}:${entry.name}`;
-                let entryWithSize = entry;
-                try {
-                    entryWithSize = { ...entry, fileSize: fs.statSync(file).size };
+        return await withIndexWriterLease({ purpose: "index-written-assets" }, async () => {
+            if (options.recoverMoves !== false) {
+                const { recoverInterruptedMoveTransactions } = await import("../commands/mv-cli.js");
+                await recoverInterruptedMoveTransactions(stashDir);
+            }
+            const dbPath = getDbPath();
+            if (!fs.existsSync(dbPath))
+                return true;
+            // The full walk never descends into dot-directories (they hold state like
+            // `.meta/`, `.stash.json`), and `shouldIndexStashFile` relies on the walker
+            // for that — mirror it here so this fast path indexes exactly what a full
+            // run would.
+            const files = filePaths.filter((f) => {
+                const rel = path.relative(stashDir, f);
+                return !rel.split(/[\\/]+/).some((segment) => segment.startsWith("."));
+            });
+            if (files.length === 0)
+                return true;
+            // Generate metadata BEFORE opening the DB so the write window stays
+            // short. One call per file keeps the entry↔path pairing exact.
+            const pairs = [];
+            const unindexable = new Set();
+            for (const file of files) {
+                if (!fs.existsSync(file)) {
+                    unindexable.add(file);
+                    continue;
+                }
+                const generated = await generateMetadataFlat(stashDir, [file]);
+                const entry = generated.entries[0];
+                // Workflows also carry a workflow_documents side-table upsert — handled
+                // below, mirroring the full walk — since `akm mv` rewrites citer files
+                // that can be workflows.
+                if (entry)
+                    pairs.push({ file, entry });
+                else
+                    unindexable.add(file);
+            }
+            const db = openExistingDatabase(dbPath);
+            try {
+                db.exec(`PRAGMA busy_timeout = ${WRITE_PATH_INDEX_BUSY_TIMEOUT_MS}`);
+                if (getEntryCount(db) === 0)
+                    return true;
+                for (const file of unindexable) {
+                    const rows = db.prepare("SELECT id FROM entries WHERE file_path = ?").all(file);
+                    deleteEntriesByIds(db, rows.map((row) => row.id));
                 }
-                catch {
-                    // stat raced a delete — index without the size, like the full walk does.
+                for (const { file, entry } of pairs) {
+                    const entryKey = `${stashDir}:${entry.type}:${entry.name}`;
+                    let entryWithSize = entry;
+                    try {
+                        entryWithSize = { ...entry, fileSize: fs.statSync(file).size };
+                    }
+                    catch {
+                        // stat raced a delete — index without the size, like the full walk does.
+                    }
+                    const entryId = upsertEntry(db, entryKey, path.dirname(file), file, stashDir, entryWithSize, buildSearchText(entry));
+                    if (entry.type === "workflow") {
+                        // Same contract as the full walk (indexer.ts): the renderer cached
+                        // the parsed document during metadata generation; persist it so the
+                        // workflow runtime never sees an entry without its document.
+                        const doc = takeWorkflowDocument(entry);
+                        if (doc)
+                            upsertWorkflowDocument(db, entryId, doc, fs.readFileSync(file));
+                    }
                 }
-                upsertEntry(db, entryKey, path.dirname(file), file, stashDir, entryWithSize, buildSearchText(entry));
+                if (pairs.length > 0 || unindexable.size > 0)
+                    rebuildFts(db, { incremental: true });
+            }
+            finally {
+                closeDatabase(db);
             }
-            rebuildFts(db, { incremental: true });
-        }
-        finally {
-            closeDatabase(db);
-        }
+            return true;
+        });
     }
     catch (error) {
         warnVerbose("Write-path index update skipped (asset appears after the next full index):", error instanceof Error ? error.message : String(error));
+        return false;
     }
 }

package/dist/indexer/indexer.js

@@ -155,7 +155,7 @@ async function runFinalizePhase(ctx) {
     ctx.timing.tFtsEnd = Date.now();
     // Re-link detached usage_events and recompute utility scores.
     onProgress({ phase: "finalize", message: "Relinking usage events." });
-    relinkUsageEvents(db);
+    relinkUsageEvents(db, { sources, defaultStashDir: stashDir });
     onProgress({ phase: "finalize", message: "Recomputing utility scores." });
     recomputeUtilityScores(db);
     // Purge LLM cache entries for assets that no longer exist in the index.
@@ -182,6 +182,11 @@ async function runFinalizePhase(ctx) {
     setMeta(db, "stashDir", stashDir);
     setMeta(db, "stashDirs", JSON.stringify(sourceDirs));
     setMeta(db, "hasEmbeddings", embeddingResult.success ? "1" : "0");
+    // Stash-organization conventions (SPEC-8): track which `index.indexBodyOpening`
+    // state the index was built with, and warn while the flag diverges from it.
+    const bodyOpeningWarning = reconcileBodyOpeningIndexState(db, config.index?.indexBodyOpening === true, ctx.full || !isIncremental);
+    if (bodyOpeningWarning)
+        warn(bodyOpeningWarning);
     warnIfVecMissing(db);
     const totalEntries = getEntryCount(db);
     const semanticEntryCount = getEmbeddableEntryCount(db);
@@ -209,6 +214,41 @@ async function runFinalizePhase(ctx) {
     // suppress unused warning — sources was previously used inline
     void sources;
 }
+/**
+ * Stash-organization conventions (SPEC-8): reconcile the `index.indexBodyOpening`
+ * flag with the state the index was last FULLY built with (index_meta key
+ * `indexBodyOpening`), returning a warning message while they diverge.
+ *
+ * Incremental runs re-extract only changed files (and embeddings are only
+ * generated for rows lacking one), so a flag toggle leaves the index MIXED
+ * until a full rebuild — `akm index --full` re-extracts every entry and wipes
+ * embeddings so they regenerate from the new text. The warning therefore
+ * repeats on every incremental run until a full walk records the flag state
+ * as applied.
+ *
+ * A missing meta key on an incremental run means the index predates this
+ * feature, i.e. it was necessarily built with the flag OFF — so the absent
+ * key reads (and is seeded) as "0", never as the current flag value. This
+ * keeps the most likely real toggle scenario — upgrade, enable the flag, run
+ * a plain `akm index` — warning until `--full` runs (review finding).
+ *
+ * Exported for tests; production's only caller is the finalize phase above.
+ */
+export function reconcileBodyOpeningIndexState(db, flagEnabled, isFullWalk) {
+    const bodyOpeningFlag = flagEnabled ? "1" : "0";
+    const prevBodyOpeningFlag = getMeta(db, "indexBodyOpening") ?? "0";
+    // Only a full walk (which includes the first build ever) may record the
+    // current flag as the applied state; incremental runs preserve — or, for a
+    // pre-feature index, seed — the state of the last full build.
+    setMeta(db, "indexBodyOpening", isFullWalk ? bodyOpeningFlag : prevBodyOpeningFlag);
+    if (isFullWalk || prevBodyOpeningFlag === bodyOpeningFlag)
+        return undefined;
+    return (`index.indexBodyOpening is ${flagEnabled ? "enabled" : "disabled"} but the index was built with it ` +
+        `${flagEnabled ? "disabled" : "enabled"}. Incremental runs only re-extract changed files, so ` +
+        "indexed text and embeddings are stale for unchanged entries. Run `akm index --full` to apply the new " +
+        "setting everywhere (embeddings regenerate), and re-mint collapse-detector canary baselines via " +
+        "`akm improve canary --refresh` if you use them.");
+}
 // ── Clean pass ───────────────────────────────────────────────────────────────
 /**
  * Post-index clean pass: scan the `entries` table for rows whose source file
@@ -286,6 +326,10 @@ async function akmIndexReal(options) {
         const sourceCacheEnd = Date.now();
         const allSourceEntries = resolveSourceEntries(stashDir, config);
         const allSourceDirs = allSourceEntries.map((s) => s.path);
+        const { recoverInterruptedMoveTransactions } = await import("../commands/mv-cli.js");
+        for (const sourceDir of new Set([stashDir, ...allSourceDirs])) {
+            await recoverInterruptedMoveTransactions(sourceDir);
+        }
         onProgress({
             phase: "preflight",
             message: `Resolved ${allSourceDirs.length} stash source${allSourceDirs.length === 1 ? "" : "s"}.`,
@@ -733,10 +777,11 @@ async function enhanceDirsWithLlm(db, config, dirsNeedingLlm, onProgress, signal
     // P3 — wall-clock budget for the enrichment pass. Defaults to llm.timeoutMs
     // (or 10 minutes if not set). Users can extend this via llm.timeoutMs in
     // config — no separate knob needed.
-    const budgetMs = (llmConfig.timeoutMs ?? 10 * 60 * 1000) * Math.max(totalEntries, 1);
-    const enrichDeadline = AbortSignal.timeout(budgetMs);
+    const enrichDeadline = createEnrichmentDeadline(llmConfig.timeoutMs, totalEntries);
     let deadlineHit = false;
     const enrichSignal = (() => {
+        if (!enrichDeadline)
+            return signal ?? new AbortController().signal;
         if (!signal)
             return enrichDeadline;
         // Combine: abort when either fires.
@@ -865,6 +910,10 @@ async function enhanceDirsWithLlm(db, config, dirsNeedingLlm, onProgress, signal
         warn(`LLM enhancement failed for ${failed}/${summary.attempted} entries — they were left un-enhanced.${sample}`);
     }
 }
+export function createEnrichmentDeadline(timeoutMs, totalEntries) {
+    const perEntryTimeoutMs = timeoutMs === undefined ? 10 * 60 * 1000 : timeoutMs;
+    return perEntryTimeoutMs === null ? undefined : AbortSignal.timeout(perEntryTimeoutMs * Math.max(totalEntries, 1));
+}
 async function generateEmbeddingsForDb(db, config, onProgress, signal) {
     throwIfAborted(signal);
     if (config.semanticSearchMode === "off") {

package/dist/indexer/passes/memory-inference.js

@@ -19,7 +19,7 @@
  * the parent without re-running the LLM.
  *
  * Disabling — two orthogonal gates:
- *   1. `profiles.improve.default.processes.memoryInference.enabled = false`
+ *   1. The selected strategy sets `processes.memoryInference.enabled = false`
  *      blocks the pass at the feature-flag layer (no network call may ever
  *      issue). Historically the v1 spec §14 gate, superseded by the 0.8.0
  *      profile shape.
@@ -60,7 +60,7 @@ const FM_CAPTURE_MODE = "captureMode";
  *
  * Two orthogonal gates:
  *
- *   1. **Feature gate** — `profiles.improve.default.processes.memoryInference.enabled`
+ *   1. **Feature gate** — the selected strategy's `processes.memoryInference.enabled`
  *      (defaults to `true`). When `false`, no network call may issue regardless
  *      of per-pass settings.
  *   2. **Per-pass gate** — `resolveIndexPassLLM("memory", config)` (which
@@ -72,6 +72,7 @@ const FM_CAPTURE_MODE = "captureMode";
  */
 export async function runMemoryInferencePass(ctx) {
     const { config, sources, signal, db, reEnrich, onProgress, options = {} } = ctx;
+    const invocationOwnsConnection = Object.hasOwn(ctx, "llmConfig");
     const compressMemoryToDerivedMemory = options.compressMemoryToDerivedMemory ?? memoryInfer.compressMemoryToDerivedMemory;
     const result = {
         considered: 0,
@@ -90,15 +91,18 @@ export async function runMemoryInferencePass(ctx) {
     // gate) bubbles up into the pass result.
     const inferTelemetry = {};
     // Gate 1 — feature gate via isProcessEnabled, which reads the 0.8.0 path
-    // (profiles.improve.default.processes.memoryInference.enabled). Defaults to
+    // (selected strategy's processes.memoryInference.enabled). Defaults to
     // enabled when the key is absent.
-    if (!isProcessEnabled("index", "memory_inference", config))
+    if (!invocationOwnsConnection && !isProcessEnabled("index", "memory_inference", config))
         return result;
     // Gate 2 — per-pass opt-out (#208). Returns the resolved llm config or
     // `undefined` when the pass should not run.
-    const llmConfig = resolveIndexPassLLM("memory", config);
+    const llmConfig = Object.hasOwn(ctx, "llmConfig") ? ctx.llmConfig : resolveIndexPassLLM("memory", config);
     if (!llmConfig)
         return result;
+    const featureConfig = invocationOwnsConnection
+        ? { ...config, index: { ...config.index, memory: { ...config.index?.memory, enabled: true } } }
+        : config;
     // The pass only writes to the primary (working) stash. Read-only caches
     // (git, npm, website) are deliberately untouched — writing inferred
     // children there would be clobbered by the next sync().
@@ -173,7 +177,7 @@ export async function runMemoryInferencePass(ctx) {
             retryAttempts += 1;
         };
         const derived = db
-            ? await withLlmCache(db, record.filePath, record.body, reEnrich ?? false, () => compressMemoryToDerivedMemory(llmConfig, record.body, signal, config, (evt) => {
+            ? await withLlmCache(db, record.filePath, record.body, reEnrich ?? false, () => compressMemoryToDerivedMemory(llmConfig, record.body, signal, featureConfig, (evt) => {
                 warn(`[akm] LLM fallback for ${evt.feature}: ${evt.reason}`);
             }, inferTelemetry, onRetryAttempt), validate, undefined, "", {
                 onCacheHit: () => {