akm-cli 0.9.16 → 0.9.17-alpha.10

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

@@ -46,13 +46,12 @@ import { todayIso } from "../../core/common.js";
 import { concurrentMap } from "../../core/concurrent.js";
 import { ConfigError } from "../../core/errors.js";
 import { warn } from "../../core/warn.js";
-import { recordWrittenPath } from "../../core/write-provenance.js";
+import { beginWriteProvenance, recordWrittenPath } from "../../core/write-provenance.js";
 import { writeAssetToSource } from "../../core/write-source.js";
-import { disposeLoweredExecutionDispatchLease, } from "../../integrations/agent/execution-lowering.js";
+import { assertRunnerCredentials } from "../../integrations/agent/runner-dispatch.js";
 import { isProcessEnabled } from "../../llm/feature-gate.js";
 import { resolveIndexPassExecution } from "../../llm/index-passes.js";
 import * as memoryInfer from "../../llm/memory-infer.js";
-import { preflightStructuredLlmRunner } from "../../llm/structured-call.js";
 import { computeBodyHash, getLlmCacheEntry } from "../../storage/repositories/index-llm-cache-repository.js";
 import { withLlmCache } from "../db/llm-cache.js";
 import { walkMarkdownFiles } from "../walk/walker.js";
@@ -102,7 +101,7 @@ function memoryExecutionForContext(ctx, config) {
 }
 async function inferPendingMemoryRecord(plan, ctx) {
     const { record } = plan;
-    const { config, featureConfig, signal, db, reEnrich, llmRunner, lease, inferTelemetry, compressMemoryToDerivedMemory, onNotices, onConfigFailure, } = ctx;
+    const { config, featureConfig, signal, db, reEnrich, llmRunner, inferTelemetry, compressMemoryToDerivedMemory, onNotices, onConfigFailure, } = ctx;
     if (signal?.aborted || plan.kind === "aborted")
         return { aborted: true };
     // Existing children are complete, but the parent may be unmarked after a
@@ -131,7 +130,7 @@ async function inferPendingMemoryRecord(plan, ctx) {
     const onRetryAttempt = () => {
         retryAttempts += 1;
     };
-    const infer = () => compressMemoryToDerivedMemory(llmRunner, record.body, signal, featureConfig, (event) => warn(`[akm] LLM fallback for ${event.feature}: ${event.reason}`), inferTelemetry, onRetryAttempt, onNotices, lease);
+    const infer = () => compressMemoryToDerivedMemory(llmRunner, record.body, signal, featureConfig, (event) => warn(`[akm] LLM fallback for ${event.feature}: ${event.reason}`), inferTelemetry, onRetryAttempt, onNotices);
     let derived = plan.kind === "cache-hit" ? plan.derived : undefined;
     try {
         if (plan.kind === "model") {
@@ -141,7 +140,7 @@ async function inferPendingMemoryRecord(plan, ctx) {
                         fromCache = true;
                     },
                 })
-                : await compressMemoryToDerivedMemory(llmRunner, record.body, signal, config, (event) => warn(`[akm] LLM fallback for ${event.feature}: ${event.reason}`), inferTelemetry, onRetryAttempt, onNotices, lease);
+                : await compressMemoryToDerivedMemory(llmRunner, record.body, signal, config, (event) => warn(`[akm] LLM fallback for ${event.feature}: ${event.reason}`), inferTelemetry, onRetryAttempt, onNotices);
         }
     }
     catch (error) {
@@ -188,6 +187,18 @@ async function inferPendingMemoryRecord(plan, ctx) {
  * short-circuits to a no-op result.
  */
 export async function runMemoryInferencePass(ctx) {
+    // R78: owns the write-provenance journal end-to-end so it closes on every
+    // exit path, including a throw out of the body below — an unclosed journal
+    // would keep reporting every later write in this process as this call's own.
+    const provenance = beginWriteProvenance();
+    try {
+        return await runMemoryInferencePassBody(ctx, provenance);
+    }
+    finally {
+        provenance.end();
+    }
+}
+async function runMemoryInferencePassBody(ctx, provenance) {
     const { config, sources, signal, db, reEnrich, onProgress, options = {} } = ctx;
     const invocationOwnsRunner = Object.hasOwn(ctx, "llmRunner");
     const compressMemoryToDerivedMemory = options.compressMemoryToDerivedMemory ?? memoryInfer.compressMemoryToDerivedMemory;
@@ -202,6 +213,7 @@ export async function runMemoryInferencePass(ctx) {
         skippedAborted: 0,
         unaccounted: 0,
         htmlErrorCount: 0,
+        writtenPaths: [],
     };
     // Mutable sink threaded into compressMemoryToDerivedMemory so the per-call
     // HTML-error categorization (which is otherwise swallowed inside the feature
@@ -215,6 +227,8 @@ export async function runMemoryInferencePass(ctx) {
     const completeResult = () => {
         if (noticesByKey.size > 0)
             result.notices = Object.freeze([...noticesByKey.values()]);
+        // Non-destructive read — the wrapper's `finally` owns closing the journal.
+        result.writtenPaths = provenance.writtenPaths();
         return result;
     };
     // Gate 1 — feature gate via isProcessEnabled, which reads the 0.8.0 path
@@ -247,84 +261,37 @@ export async function runMemoryInferencePass(ctx) {
     // keeps aborted, existing-child, and validated-cache-only batches available
     // offline while preserving all-or-nothing preflight for mixed batches.
     const plans = pending.map((record) => planPendingMemoryRecord(record, { signal, db, reEnrich }));
-    const dispatchLease = plans.some((plan) => plan.kind === "model")
-        ? await preflightStructuredLlmRunner(llmRunner)
-        : undefined;
-    try {
-        let processed = 0;
-        const total = pending.length;
-        onProgress?.({ processed, total, writtenFacts: 0, skippedNoFacts: 0 });
-        let configFailure;
-        const perRecordResults = await concurrentMap(plans, (plan) => inferPendingMemoryRecord(plan, {
-            config,
-            featureConfig,
-            signal,
-            db,
-            reEnrich,
-            llmRunner,
-            lease: dispatchLease,
-            inferTelemetry,
-            compressMemoryToDerivedMemory,
-            onNotices,
-            onConfigFailure: (error) => {
-                configFailure ??= error;
-            },
-        }), 
-        // Caller-set connection concurrency or 1: `resolveLlmEngineUse` does
-        // not forward `engines.<name>.concurrency`, so config cannot raise this.
-        llmRunner.connection.concurrency ?? 1);
-        if (configFailure)
-            throw configFailure;
-        for (let i = 0; i < perRecordResults.length; i++) {
-            const res = perRecordResults[i];
-            if (!res)
-                continue;
-            if ("aborted" in res && res.aborted) {
-                result.skippedAborted += 1;
-                processed++;
-                onProgress?.({
-                    processed,
-                    total,
-                    writtenFacts: result.writtenFacts,
-                    skippedNoFacts: result.skippedNoFacts,
-                    currentRef: pending[i]?.ref,
-                });
-                continue;
-            }
-            if (res.fromCache) {
-                result.cacheHits += 1;
-            }
-            if ("retryAttempts" in res) {
-                result.retryAttempts += res.retryAttempts;
-            }
-            if (res.skipped) {
-                result.skippedNoFacts += 1;
-                // Intentionally NOT marked processed — a transient LLM failure should
-                // be retried on the next index run.
-            }
-            else if (res.splitParent) {
-                result.splitParents += 1;
-                result.writtenFacts += res.written;
-            }
-            else if ("childExists" in res && res.childExists) {
-                // Derived child already on disk. Track separately so this category is
-                // observable in health output and stops bleeding into the
-                // freshAttempts denominator. Pre-check skips (#588) are the routine
-                // self-healing path — no LLM attempt was consumed and the parent has
-                // been marked processed — so only the rare post-LLM case (mid-flight
-                // race or write failure) warrants a per-ref warning.
-                result.skippedChildExists += 1;
-                if (!res.precheck) {
-                    warn(`memory inference: derived child for ${pending[i]?.ref ?? "<unknown>"} already existed or write failed; counted as skippedChildExists`);
-                }
-            }
-            else {
-                // The per-record state machine should cover every outcome. A hit here
-                // means a new code path slipped past the categorisation — surface it
-                // loudly so health metrics stay honest and we get a signal to fix.
-                result.unaccounted += 1;
-                warn(`memory inference: unaccounted per-record outcome for ${pending[i]?.ref ?? "<unknown>"}`);
-            }
+    if (plans.some((plan) => plan.kind === "model"))
+        assertRunnerCredentials(llmRunner);
+    let processed = 0;
+    const total = pending.length;
+    onProgress?.({ processed, total, writtenFacts: 0, skippedNoFacts: 0 });
+    let configFailure;
+    const perRecordResults = await concurrentMap(plans, (plan) => inferPendingMemoryRecord(plan, {
+        config,
+        featureConfig,
+        signal,
+        db,
+        reEnrich,
+        llmRunner,
+        inferTelemetry,
+        compressMemoryToDerivedMemory,
+        onNotices,
+        onConfigFailure: (error) => {
+            configFailure ??= error;
+        },
+    }), 
+    // Caller-set connection concurrency or 1: `resolveLlmEngineUse` does
+    // not forward `engines.<name>.concurrency`, so config cannot raise this.
+    llmRunner.connection.concurrency ?? 1);
+    if (configFailure)
+        throw configFailure;
+    for (let i = 0; i < perRecordResults.length; i++) {
+        const res = perRecordResults[i];
+        if (!res)
+            continue;
+        if ("aborted" in res && res.aborted) {
+            result.skippedAborted += 1;
             processed++;
             onProgress?.({
                 processed,
@@ -333,14 +300,53 @@ export async function runMemoryInferencePass(ctx) {
                 skippedNoFacts: result.skippedNoFacts,
                 currentRef: pending[i]?.ref,
             });
+            continue;
         }
-        result.htmlErrorCount = inferTelemetry.htmlErrorCount ?? 0;
-        return completeResult();
-    }
-    finally {
-        if (dispatchLease)
-            disposeLoweredExecutionDispatchLease(dispatchLease);
+        if (res.fromCache) {
+            result.cacheHits += 1;
+        }
+        if ("retryAttempts" in res) {
+            result.retryAttempts += res.retryAttempts;
+        }
+        if (res.skipped) {
+            result.skippedNoFacts += 1;
+            // Intentionally NOT marked processed — a transient LLM failure should
+            // be retried on the next index run.
+        }
+        else if (res.splitParent) {
+            result.splitParents += 1;
+            result.writtenFacts += res.written;
+        }
+        else if ("childExists" in res && res.childExists) {
+            // Derived child already on disk. Track separately so this category is
+            // observable in health output and stops bleeding into the
+            // freshAttempts denominator. Pre-check skips (#588) are the routine
+            // self-healing path — no LLM attempt was consumed and the parent has
+            // been marked processed — so only the rare post-LLM case (mid-flight
+            // race or write failure) warrants a per-ref warning.
+            result.skippedChildExists += 1;
+            if (!res.precheck) {
+                warn(`memory inference: derived child for ${pending[i]?.ref ?? "<unknown>"} already existed or write failed; counted as skippedChildExists`);
+            }
+        }
+        else {
+            // The per-record state machine should cover every outcome. A hit here
+            // means a new code path slipped past the categorisation — surface it
+            // loudly so health metrics stay honest and we get a signal to fix.
+            result.unaccounted += 1;
+            warn(`memory inference: unaccounted per-record outcome for ${pending[i]?.ref ?? "<unknown>"}`);
+        }
+        processed++;
+        onProgress?.({
+            processed,
+            total,
+            writtenFacts: result.writtenFacts,
+            skippedNoFacts: result.skippedNoFacts,
+            currentRef: pending[i]?.ref,
+        });
     }
+    result.htmlErrorCount = inferTelemetry.htmlErrorCount ?? 0;
+    return completeResult();
 }
 // ── Pending detection ───────────────────────────────────────────────────────
 /**