akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/commands/improve/improve-strategies.js

@@ -12,11 +12,12 @@ import quick from "../../assets/improve-strategies/quick.json" with { type: "jso
 import reflectDistill from "../../assets/improve-strategies/reflect-distill.json" with { type: "json" };
 import thorough from "../../assets/improve-strategies/thorough.json" with { type: "json" };
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
+import { ImproveProfileConfigSchema } from "../../core/config/config-schema.js";
 import { deepMergeConfig } from "../../core/config/deep-merge.js";
 import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_PROCESS_ENGINE_CAPABILITIES, } from "../../core/config/engine-semantics.js";
 import { ConfigError } from "../../core/errors.js";
-import { resolveImproveProcessRunner, resolveTriageJudgmentRunner, } from "../../integrations/agent/runner.js";
 import { applyAutonomyGate } from "./autonomy-gate.js";
+import { resolveImproveExecution, resolveImproveLlmExecution } from "./execution.js";
 export const DEFAULT_ALLOWED_TYPES = {
     reflect: ["agent", "command", "knowledge", "lesson", "memory", "skill", "workflow"],
     distill: ["memory"],
@@ -42,13 +43,13 @@ export function isStrategyFilteredForAllPasses(ref, strategy) {
 }
 const BUILTIN_STRATEGIES = {
     default: defaultStrategy,
-    quick: quick,
-    thorough: thorough,
+    quick,
+    thorough,
     "memory-focus": memoryFocus,
     "graph-refresh": graphRefresh,
-    frequent: frequent,
-    consolidate: consolidate,
-    catchup: catchup,
+    frequent,
+    consolidate,
+    catchup,
     "reflect-distill": reflectDistill,
     "proactive-maintenance": proactiveMaintenance,
 };
@@ -63,9 +64,9 @@ export function resolveImproveStrategy(name, config) {
         throw new ConfigError(`Improve strategy "${selectedName}" not found. Valid strategies: ${valid.join(", ")}.`, "UNKNOWN_IMPROVE_STRATEGY");
     }
     const selectedStrategy = BUILTIN_STRATEGIES[selectedName] ?? {};
-    const baseStrategy = deepMergeConfig(BUILTIN_STRATEGIES.default, selectedStrategy);
+    const baseStrategy = deepMergeConfig(BUILTIN_STRATEGIES.default ?? {}, selectedStrategy);
     const resolved = deepMergeConfig(baseStrategy, (userStrategies[selectedName] ?? {}));
-    return { name: selectedName, config: resolved };
+    return { name: selectedName, config: ImproveProfileConfigSchema.parse(resolved) };
 }
 function cloneAndFreeze(value) {
     const clone = structuredClone(value);
@@ -95,6 +96,7 @@ function buildImprovePlan(strategy, config, options) {
         const processConfig = cloneAndFreeze(strategy.config.processes?.[processName] ?? {});
         const enabled = processConfig.enabled === true;
         let runner = null;
+        let notices = [];
         if (IMPROVE_PROCESS_ENGINE_CAPABILITIES[processName] !== "llm" || !enabled) {
             processes[processName] = Object.freeze({ enabled, config: processConfig, runner });
             continue;
@@ -102,21 +104,44 @@ function buildImprovePlan(strategy, config, options) {
         // Validation itself is structural and always runs. Only its optional repair
         // step needs a model, so disabling repair must not create an LLM preflight.
         if (processName !== "validation" || options.repairValidationFailures !== false) {
-            runner = resolveImproveProcessRunner(strategy.config, processName, config);
+            const resolved = resolveImproveLlmExecution({
+                config,
+                profile: strategy.config,
+                process: processConfig,
+                processName,
+            });
+            runner = resolved?.runner ?? null;
+            notices = resolved?.notices ?? [];
         }
         if (!runner && !(processName === "validation" && options.repairValidationFailures === false)) {
             throw new ConfigError(`Enabled improve process "${processName}" requires an LLM engine. Set defaults.llmEngine or improve.strategies.${strategy.name}.processes.${processName}.engine.`, "LLM_NOT_CONFIGURED");
         }
         if (runner)
             runner = cloneAndFreeze(runner);
-        processes[processName] = Object.freeze({ enabled, config: processConfig, runner });
+        processes[processName] = Object.freeze({
+            enabled,
+            config: processConfig,
+            runner,
+            ...(notices.length > 0 ? { notices: cloneAndFreeze(notices) } : {}),
+        });
     }
     const triage = strategy.config.processes?.triage;
-    const judgmentOptedIn = triage !== undefined && Object.hasOwn(triage, "judgment");
-    const triageJudgment = processes.triage.enabled && judgmentOptedIn
-        ? resolveTriageJudgmentRunner(triage.judgment, config, triage, strategy.config)
+    const judgmentEnabled = triage?.judgment?.enabled === true;
+    const triageJudgmentResolution = processes.triage.enabled && judgmentEnabled
+        ? resolveImproveExecution({
+            config,
+            profile: strategy.config,
+            process: triage,
+            current: triage.judgment,
+            processName: "triage-judgment",
+        })
         : null;
-    if (processes.triage.enabled && judgmentOptedIn && !triageJudgment) {
+    const triageJudgment = triageJudgmentResolution?.runner ?? null;
+    const effectiveJudgmentLlm = triage?.judgment?.llm ?? triage?.llm ?? strategy.config.llm;
+    if (triageJudgment && triageJudgment.kind !== "llm" && effectiveJudgmentLlm) {
+        throw new ConfigError(`Triage judgment engine "${triageJudgment.engine ?? "unknown"}" is an agent engine and cannot receive llm overrides.`, "INVALID_CONFIG_FILE");
+    }
+    if (processes.triage.enabled && judgmentEnabled && !triageJudgment) {
         throw new ConfigError(`Enabled improve triage judgment requires an engine. Set defaults.llmEngine or improve.strategies.${strategy.name}.processes.triage.judgment.engine.`, "LLM_NOT_CONFIGURED");
     }
     const frozenProcesses = Object.freeze(processes);
@@ -128,8 +153,12 @@ function buildImprovePlan(strategy, config, options) {
         }),
     });
     return Object.freeze({
+        config: cloneAndFreeze(config),
         strategy: frozenStrategy,
         processes: frozenProcesses,
         triageJudgment: triageJudgment ? cloneAndFreeze(triageJudgment) : null,
+        ...(triageJudgmentResolution?.notices.length
+            ? { triageJudgmentNotices: cloneAndFreeze(triageJudgmentResolution.notices) }
+            : {}),
     });
 }

package/dist/commands/improve/improve.js

@@ -19,13 +19,14 @@ import { beginWriteProvenance, relativeWrittenPath } from "../../core/write-prov
 import { resolveWritable, resolveWriteTarget } from "../../core/write-source.js";
 import { ensureIndex } from "../../indexer/ensure-index.js";
 import { akmIndex } from "../../indexer/indexer.js";
+import { collectPendingMemories } from "../../indexer/passes/memory-inference.js";
 import { resolveEntryContentDir, resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { collectEngineCredentialValues } from "../../integrations/agent/engine-resolution.js";
-import { materializeLlmRunnerConnection } from "../../integrations/agent/runner.js";
 import { installLlmUsagePersistence } from "../../llm/usage-persist.js";
 import { isGitBackedStash, listGitChangedPaths, resolveWritableOverride, saveGitStash, } from "../../sources/providers/git.js";
 import { closeDatabase, openExistingDatabase } from "../../storage/repositories/index-connection.js";
 import { getEntryCount } from "../../storage/repositories/index-entries-repository.js";
+import { openSqliteReadSnapshot, SqliteReadSnapshotUnavailableError } from "../../storage/sqlite-read-snapshot.js";
 import { drainProposals } from "../proposal/drain.js";
 import { resolveDrainPolicy } from "../proposal/drain-policies.js";
 import { describeGatedLanes, isAutonomyLaneAllowed } from "./autonomy-gate.js";
@@ -33,11 +34,12 @@ import { akmDistill } from "./distill.js";
 // Eligibility / candidate-selection predicates live in ./eligibility.
 import { buildLatestProposalTsMap, collectEligibleRefs, collectEligibleRefsReadOnly, memoryCleanupParentRef, resolveImproveScope, shouldAnalyzeMemoryCleanup, } from "./eligibility.js";
 import { countEvalCases } from "./eval-cases.js";
-import { resolveImprovePlan } from "./improve-strategies.js";
+import { resolveImprovePlan, resolveImproveStrategy } from "./improve-strategies.js";
 import { improveLockPath, MIN_IMPROVE_LOCK_STALE_MS, releaseImproveLock, tryAcquireImproveLock } from "./locks.js";
 // The cycle loop / post-loop / maintenance stages live in ./loop-stages.
 import { runImproveLoopStage, runImprovePostLoopStage } from "./loop-stages.js";
 import { analyzeMemoryCleanup } from "./memory/memory-improve.js";
+import { buildImproveExecutionPlan } from "./planner.js";
 // The pre-loop preparation pipeline lives in ./preparation.
 import { runImprovePreparationStage } from "./preparation.js";
 import { DEFAULT_DUE_DAYS, filterProactiveDue } from "./proactive-maintenance.js";
@@ -118,12 +120,10 @@ export async function akmImprove(options = {}) {
     let initialGitPaths = new Set();
     const runJournal = createRunWriteJournal();
     const preEnsureCleanupWarnings = [];
-    // Assigned by runIndexAndCollect() (closure) so TS cannot prove definite
-    // assignment — seed with empty values; the runIndexAndCollect() call below
-    // always overwrites them before any read.
     let plannedRefs = [];
     let memorySummary = { eligible: 0, derived: 0 };
     let strategyFilteredRefs = [];
+    let indexSnapshot;
     let memoryCleanupPlan;
     let autonomyGatedDirectLanes = [];
     let guidance;
@@ -191,12 +191,20 @@ export async function akmImprove(options = {}) {
         plannedRefs = collected.plannedRefs;
         memorySummary = collected.memorySummary;
         strategyFilteredRefs = collected.strategyFilteredRefs;
+        indexSnapshot = collected.indexSnapshot;
         memoryCleanupPlan = collected.memoryCleanupPlan;
         autonomyGatedDirectLanes = collected.autonomyGatedDirectLanes;
         guidance = collected.guidance;
         preEnsureCleanupWarnings.push(...collected.warnings);
         if (options.dryRun) {
-            const result = buildDryRunResult(setup, collected);
+            const result = await runDryPlanningStage({
+                run: setup,
+                collected,
+                resolvedStateDbPath,
+                budgetMs,
+                initialCleanupWarnings: preEnsureCleanupWarnings,
+                signal: budgetAbortController.signal,
+            });
             clearBudgetTimer();
             return result;
         }
@@ -215,16 +223,9 @@ export async function akmImprove(options = {}) {
         throw err;
     }
     try {
-        try {
-            eventsDb = openStateDatabase(resolvedStateDbPath);
-            eventsCtx = { db: eventsDb };
-        }
-        catch (err) {
-            rethrowIfTestIsolationError(err);
-            // If we cannot open state.db up-front, fall back to per-call opens — but
-            // still pinned to the boundary-resolved path, never a live env re-read.
-            eventsCtx = { dbPath: resolvedStateDbPath };
-        }
+        const openedEvents = openImproveEventsContext(resolvedStateDbPath);
+        eventsDb = openedEvents.db;
+        eventsCtx = openedEvents.ctx;
         // WI-9.10: construct the run's RunContext here — the first point after
         // run-setup where config/stashDir/eventsCtx/proposalsCtx/sourceRun/dryRun
         // are all in hand. See buildImproveRunContext for exactly which
@@ -248,6 +249,8 @@ export async function akmImprove(options = {}) {
             memorySummary,
             memoryCleanupPlan,
             strategyFilteredRefs,
+            rawPlannedRefs: plannedRefs,
+            indexSnapshot,
             triageDrain,
             eventsCtx,
         });
@@ -313,6 +316,17 @@ export async function akmImprove(options = {}) {
         }
     }
 }
+/** Open the run-owned state handle while preserving the boundary-pinned fallback. */
+function openImproveEventsContext(dbPath) {
+    try {
+        const db = openStateDatabase(dbPath);
+        return { db, ctx: { db } };
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        return { ctx: { dbPath } };
+    }
+}
 /**
  * Shape the run's journaled absolute paths for `result.writtenPaths` (#652):
  * POSIX-relative to the run's primary stash dir (the repo root for a git-backed
@@ -386,6 +400,7 @@ function resolveImproveRunSetup(options) {
     // Resolve the improve profile for this run. Profile drives type filtering,
     // process gating, and the default limit value.
     const _earlyConfig = options.config ?? loadConfig();
+    const configuredImproveProfile = resolveImproveStrategy(options.strategy, _earlyConfig).config;
     const resolvedPlan = options.resolvedPlan ??
         resolveImprovePlan(options.strategy, _earlyConfig, {
             repairValidationFailures: options.repairValidationFailures,
@@ -393,6 +408,14 @@ function resolveImproveRunSetup(options) {
     const selectedStrategy = resolvedPlan.strategy;
     const improveSensitiveValues = collectEngineCredentialValues(_earlyConfig);
     const improveProfile = selectedStrategy.config;
+    const configuredLimits = {
+        ...(options.limit !== undefined ? { cli: options.limit } : {}),
+        ...(configuredImproveProfile.limit !== undefined ? { profile: configuredImproveProfile.limit } : {}),
+        ...(configuredImproveProfile.processes?.reflect?.limit !== undefined
+            ? { reflect: configuredImproveProfile.processes.reflect.limit }
+            : {}),
+    };
+    const effectiveLimit = options.limit ?? improveProfile?.processes?.reflect?.limit ?? improveProfile.limit;
     const scopedRef = scope.mode === "ref" && scope.value ? parseRefInput(scope.value) : undefined;
     const readSource = options.dryRun
         ? options.writeTarget
@@ -438,7 +461,7 @@ function resolveImproveRunSetup(options) {
         },
         // Profile-level limit, then process-level reflect.limit as fallback.
         // CLI --limit takes precedence over both.
-        limit: options.limit ?? improveProfile?.processes?.reflect?.limit ?? improveProfile.limit,
+        limit: effectiveLimit,
     };
     let primaryStashDir;
     try {
@@ -482,6 +505,9 @@ function resolveImproveRunSetup(options) {
         selectedStrategy,
         improveSensitiveValues,
         improveProfile,
+        configuredImproveProfile,
+        configuredLimits,
+        effectiveLimit,
         writeTarget,
         options,
         primaryStashDir,
@@ -515,14 +541,9 @@ function buildImproveRunContext(run, eventsCtx) {
         // Not yet wired into any proposal call site this stage — verb-level
         // RunContext adoption (reflect/distill/extract/consolidate) is later.
         proposalsCtx: { dbPath: run.resolvedStateDbPath },
-        // Representative connection for this run: reflect is the loop's primary
-        // LLM-driving process. Mirrors the existing
-        // `runner ? materializeLlmRunnerConnection(runner) : null` pattern
-        // already used for the consolidate process elsewhere (contradiction pass).
-        getLlmConfig: () => {
-            const runner = run.resolvedPlan.processes.reflect.runner;
-            return runner ? materializeLlmRunnerConnection(runner) : null;
-        },
+        // Representative symbolic runner for this run: reflect is the loop's
+        // primary model-driving process. Credentials remain unresolved here.
+        getLlmRunner: () => run.resolvedPlan.processes.reflect.runner,
         sourceRun: run.options.runId ?? `improve-${run.startMs}`,
         // Always false here: callers only reach this point past the dry-run
         // early return in akmImprove.
@@ -559,6 +580,7 @@ async function indexAndCollect(args) {
     let plannedRefs = [];
     let memorySummary = { eligible: 0, derived: 0 };
     let strategyFilteredRefs = [];
+    let indexSnapshot;
     // #339 fix: ensureIndex MUST run BEFORE collectEligibleRefs. The eligible-ref
     // query reads the `entries` table; if a DB version upgrade just dropped that
     // table (or the index is otherwise empty), the prior run order silently
@@ -622,6 +644,7 @@ async function indexAndCollect(args) {
         plannedRefs,
         memorySummary,
         strategyFilteredRefs = [],
+        indexSnapshot,
     } = await collectEligibleRefsImpl(scope, options.stashDir, improveProfile, _earlyConfig));
     const cleanupParentRef = memoryCleanupParentRef(scope, options.stashDir);
     // D8 — the two direct lanes share one eligibility predicate, which reads scope
@@ -646,6 +669,7 @@ async function indexAndCollect(args) {
         plannedRefs,
         memorySummary,
         strategyFilteredRefs: strategyFilteredRefs ?? [],
+        indexSnapshot,
         memoryCleanupPlan,
         autonomyGatedDirectLanes,
         guidance,
@@ -667,23 +691,172 @@ export function buildLockSkippedResult(strategyName, scope, runId) {
         ...(runId !== undefined ? { runId } : {}),
     };
 }
+/** Evaluate the real selectors on read-only state, stopping before every writer boundary. */
+async function runDryPlanningStage(args) {
+    const { run, collected, resolvedStateDbPath, budgetMs, initialCleanupWarnings, signal } = args;
+    let stateDb;
+    let stateSnapshotUnavailable = false;
+    try {
+        try {
+            stateDb = openSqliteReadSnapshot(resolvedStateDbPath);
+            stateSnapshotUnavailable = !stateDb;
+        }
+        catch (error) {
+            if (!(error instanceof SqliteReadSnapshotUnavailableError))
+                throw error;
+            stateSnapshotUnavailable = true;
+        }
+        const eventsCtx = {
+            ...(stateDb ? { db: stateDb } : { dbPath: resolvedStateDbPath }),
+            readOnly: true,
+            ...(stateSnapshotUnavailable ? { readOnlySnapshotUnavailable: true } : {}),
+        };
+        const preparation = await run.runImprovePreparationStageImpl({
+            scope: run.scope,
+            options: run.options,
+            plannedRefs: collected.plannedRefs,
+            memoryCleanupPlan: collected.memoryCleanupPlan,
+            primaryStashDir: run.primaryStashDir,
+            memorySummary: collected.memorySummary,
+            reindexFn: run.reindexFn,
+            startMs: run.startMs,
+            budgetMs,
+            eventsCtx,
+            initialCleanupWarnings,
+            improveProfile: run.improveProfile,
+            resolvedPlan: run.resolvedPlan,
+            strategyName: run.selectedStrategy.name,
+            budgetSignal: signal,
+            planOnly: true,
+        });
+        return buildDryRunResult(run, collected, preparation);
+    }
+    finally {
+        stateDb?.close();
+    }
+}
 /** The P3 dry-run envelope (plan-only early return). Exported for unit tests. */
-export function buildDryRunResult(run, collected) {
+export function buildDryRunResult(run, collected, preparation) {
     const { selectedStrategy, scope } = run;
     const { guidance, memorySummary, memoryCleanupPlan, plannedRefs, strategyFilteredRefs } = collected;
+    const effectiveRefs = preparation?.loopRefs ?? plannedRefs;
+    const notices = collectImproveNotices({ resolvedPlan: run.resolvedPlan });
     return {
         schemaVersion: 2,
         ok: true,
         strategy: selectedStrategy.name,
         scope,
         dryRun: true,
+        ...(notices.length > 0 ? { notices } : {}),
         ...(guidance ? { guidance } : {}),
         memorySummary,
         ...(memoryCleanupPlan ? { memoryCleanup: shapeMemoryCleanup(memoryCleanupPlan) } : {}),
-        plannedRefs,
+        plannedRefs: effectiveRefs,
+        ...(preparation?.planning
+            ? {
+                plan: buildResultExecutionPlan(run, preparation, plannedRefs, strategyFilteredRefs, collected.indexSnapshot, true),
+            }
+            : {}),
         ...(strategyFilteredRefs.length > 0 ? { strategyFilteredRefs } : {}),
+        ...(preparation?.proactiveMaintenance ? { proactiveMaintenance: preparation.proactiveMaintenance } : {}),
     };
 }
+/** One public plan projection for the dry and live result assemblers. */
+function buildResultExecutionPlan(run, preparation, rawProfileEligibleRefs, strategyFilteredRefs, indexSnapshot, dryRun) {
+    const { improveProfile, configuredImproveProfile, resolvedPlan, configuredLimits, effectiveLimit, scope } = run;
+    const triageConfig = improveProfile.processes?.triage;
+    const configuredTriage = configuredImproveProfile.processes?.triage;
+    const configuredProactive = configuredImproveProfile.processes?.proactiveMaintenance;
+    const configuredConsolidation = configuredImproveProfile.processes?.consolidate;
+    const triageEnabled = scope.mode !== "ref" && resolvedPlan.processes.triage.enabled;
+    const distillOnlySet = new Set(preparation.distillOnlyRefs.map((entry) => entry.ref));
+    const inferenceMinPending = improveProfile.processes?.memoryInference?.minPendingCount;
+    const pendingMemories = run.primaryStashDir && inferenceMinPending !== undefined && inferenceMinPending > 0
+        ? collectPendingMemories(run.primaryStashDir).length
+        : undefined;
+    const memoryInferenceEnabled = resolvedPlan.processes.memoryInference.enabled &&
+        !(pendingMemories !== undefined && inferenceMinPending !== undefined && pendingMemories < inferenceMinPending);
+    const graphExtractionEnabled = resolvedPlan.processes.graphExtraction.enabled && run.primaryStashDir !== undefined;
+    const profileGate = {
+        name: "profile",
+        removed: strategyFilteredRefs.length,
+        reason: "all enabled per-ref processes refuse the asset type",
+    };
+    const proactive = preparation.planning.proactive
+        ? {
+            ...preparation.planning.proactive,
+            configured: {
+                ...(configuredProactive?.dueDays !== undefined ? { dueDays: configuredProactive.dueDays } : {}),
+                ...(configuredProactive?.maxPerRun !== undefined ? { maxPerRun: configuredProactive.maxPerRun } : {}),
+                ...(configuredProactive?.limit !== undefined ? { limit: configuredProactive.limit } : {}),
+            },
+        }
+        : undefined;
+    const consolidation = {
+        ...preparation.planning.consolidation,
+        configured: {
+            ...(configuredConsolidation?.enabled !== undefined ? { enabled: configuredConsolidation.enabled } : {}),
+            ...(configuredConsolidation?.minPoolSize !== undefined
+                ? { minPoolSize: configuredConsolidation.minPoolSize }
+                : {}),
+            ...(configuredConsolidation?.limit !== undefined ? { limit: configuredConsolidation.limit } : {}),
+            ...(configuredConsolidation?.maxChunkSize !== undefined
+                ? { maxChunkSize: configuredConsolidation.maxChunkSize }
+                : {}),
+            ...(configuredConsolidation?.incrementalSince !== undefined
+                ? { incrementalSince: configuredConsolidation.incrementalSince }
+                : {}),
+        },
+    };
+    return buildImproveExecutionPlan({
+        dryRun,
+        snapshot: indexSnapshot ?? {
+            status: "unknown",
+            reason: "the injected selector did not report an index snapshot status",
+        },
+        rawInScope: rawProfileEligibleRefs.length + strategyFilteredRefs.length,
+        selectedRefs: preparation.actionableRefs,
+        effectiveRefs: preparation.loopRefs,
+        distillOnlyRefs: distillOnlySet,
+        configuredLimits,
+        effectiveLimit,
+        replayBudget: preparation.planning.replayBudget,
+        gates: [profileGate, ...preparation.planning.gates],
+        ...(proactive ? { proactive } : {}),
+        consolidation,
+        stageConfig: {
+            extract: {
+                enabled: preparation.planning.extract.wouldRun,
+                reason: preparation.planning.extract.reason,
+            },
+            graphExtraction: {
+                enabled: graphExtractionEnabled,
+                reason: !resolvedPlan.processes.graphExtraction.enabled
+                    ? "disabled"
+                    : graphExtractionEnabled
+                        ? improveProfile.processes?.graphExtraction?.fullScan === true
+                            ? "enabled for a full-corpus scan"
+                            : "enabled for refs touched by this run"
+                        : "enabled but no primary source is available",
+            },
+            memoryInference: {
+                enabled: memoryInferenceEnabled,
+                reason: !resolvedPlan.processes.memoryInference.enabled
+                    ? "disabled"
+                    : !memoryInferenceEnabled
+                        ? `${pendingMemories ?? 0} pending memories is below minPendingCount ${inferenceMinPending}`
+                        : "enabled; the pass discovers pending memories independently of selected refs",
+            },
+        },
+        triage: {
+            enabled: triageEnabled,
+            configuredMode: configuredTriage?.applyMode ?? "queue",
+            mode: triageConfig?.applyMode ?? "queue",
+            maxAcceptsPerRun: configuredTriage?.maxAcceptsPerRun ?? 25,
+            ...(configuredTriage?.maxDiffLines !== undefined ? { maxDiffLines: configuredTriage.maxDiffLines } : {}),
+        },
+    });
+}
 /** The triage drain pre-pass (non-fatal; single-ref scope never drains). */
 async function runTriagePrePass(run) {
     const { primaryStashDir, resolvedPlan, scope, options, improveProfile, drainProposalsFn } = run;
@@ -1088,7 +1261,7 @@ async function runImproveStageSequence(args) {
  * side effects run between assembly and emit).
  */
 function finalizeImproveResult(args) {
-    const { guidance, memorySummary, memoryCleanupPlan, strategyFilteredRefs, triageDrain, eventsCtx } = args;
+    const { guidance, memorySummary, memoryCleanupPlan, strategyFilteredRefs, rawPlannedRefs, indexSnapshot, triageDrain, eventsCtx, } = args;
     const { selectedStrategy, scope, options, primaryStashDir, startMs } = args.run;
     const { preparation, consolidation, memoryInference, graphExtraction, cycleMetrics, reflectsWithErrorContext, memoryInferenceDurationMs, graphExtractionDurationMs, orphansPurged, proposalsExpired, allWarnings, deadUrls, finalActions, } = args.seq;
     // C1 (13-bus-factor): fold the per-ref `distill-skipped` rows (~13k/run,
@@ -1097,12 +1270,23 @@ function finalizeImproveResult(args) {
     // the unbounded row list never reaches result_json. Reflect skip counters
     // below still read `finalActions` (reflect skips are not folded).
     const { actions: persistedActions, aggregate: distillSkippedAggregate } = foldDistillSkipped(finalActions);
+    const notices = collectImproveNotices({
+        resolvedPlan: args.run.resolvedPlan,
+        actions: finalActions,
+        schemaRepairs: preparation.schemaRepairs,
+        consolidation,
+        extract: preparation.extract,
+        memoryInference,
+        graphExtraction,
+        triageDrain,
+    });
     const result = {
         schemaVersion: 2,
         ok: true,
         strategy: selectedStrategy.name,
         scope,
         dryRun: false,
+        ...(notices.length > 0 ? { notices } : {}),
         ...(guidance ? { guidance } : {}),
         memorySummary,
         ...(memoryCleanupPlan
@@ -1126,7 +1310,12 @@ function finalizeImproveResult(args) {
                 },
             }
             : {}),
-        plannedRefs: preparation.actionableRefs,
+        plannedRefs: preparation.loopRefs,
+        ...(preparation.planning
+            ? {
+                plan: buildResultExecutionPlan(args.run, preparation, rawPlannedRefs, strategyFilteredRefs, indexSnapshot, false),
+            }
+            : {}),
         ...(strategyFilteredRefs.length > 0 ? { strategyFilteredRefs } : {}),
         actions: persistedActions,
         ...(distillSkippedAggregate ? { distillSkipped: distillSkippedAggregate } : {}),
@@ -1185,6 +1374,37 @@ function finalizeImproveResult(args) {
         }, eventsCtx);
     return result;
 }
+function collectImproveNotices(args) {
+    const byKey = new Map();
+    const collect = (carrier) => {
+        if (typeof carrier !== "object" || carrier === null)
+            return;
+        const notices = carrier.notices;
+        if (!Array.isArray(notices))
+            return;
+        for (const notice of notices)
+            byKey.set(JSON.stringify(notice), notice);
+    };
+    for (const process of Object.values(args.resolvedPlan.processes))
+        collect(process);
+    for (const notice of args.resolvedPlan.triageJudgmentNotices ?? []) {
+        byKey.set(JSON.stringify(notice), notice);
+    }
+    for (const action of args.actions ?? [])
+        collect(action.result);
+    for (const repair of args.schemaRepairs ?? [])
+        collect(repair);
+    collect(args.consolidation);
+    for (const extract of args.extract ?? []) {
+        collect(extract);
+        for (const session of extract.sessions ?? [])
+            collect(session);
+    }
+    collect(args.memoryInference);
+    collect(args.graphExtraction);
+    collect(args.triageDrain);
+    return Object.freeze([...byKey.values()]);
+}
 function emitImproveCompletedEvent(result, durations, eventsCtx) {
     const actionCounts = {
         reflect: 0,

package/dist/commands/improve/loop-stages.js

@@ -14,9 +14,9 @@ import { withStateDb } from "../../core/state-db.js";
 import { info } from "../../core/warn.js";
 import { DEFAULT_GRAPH_EXTRACTION_INCLUDE_TYPES, runGraphExtractionPass, } from "../../indexer/graph/graph-extraction.js";
 import { withIndexWriterLease } from "../../indexer/index-writer-lock.js";
+import { deriveWritableBundleIds } from "../../indexer/installations.js";
 import { collectPendingMemories, runMemoryInferencePass, } from "../../indexer/passes/memory-inference.js";
-import { getWritableStashDirs, resolveSourceEntries } from "../../indexer/search/search-source.js";
-import { materializeLlmRunnerConnection } from "../../integrations/agent/runner.js";
+import { resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { isProcessEnabled } from "../../llm/feature-gate.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
 import { purgeOldCycleMetrics } from "../../storage/repositories/canaries-repository.js";
@@ -179,8 +179,9 @@ async function runLoopReflectPass(planned, isDistillOnly, env, tally) {
             // O-1 (#364): pass remaining budget as timeoutMs so the agent spawn is
             // bounded by the wall-clock deadline rather than the default per-profile timeout.
             const reflectBudgetMs = env.remainingBudgetMs();
-            // Use the runner frozen in the invocation plan; no leaf re-resolution.
-            const reflectProfileRunner = resolvedPlan.processes.reflect.runner;
+            // Re-enter canonical named-engine lowering with the config snapshot and
+            // process profile frozen into the invocation plan. The loop never injects
+            // a RunnerSpec seam or observes later caller-config mutations.
             const reflectCallArgs = {
                 ref: planned.ref,
                 // Carry the resolved item_ref so reflect uses the same durable key for
@@ -189,7 +190,7 @@ async function runLoopReflectPass(planned, isDistillOnly, env, tally) {
                 task: options.task,
                 // Active strategy supplies non-engine process tuning.
                 ...(improveProfile ? { improveProfile } : {}),
-                config: options.config,
+                config: resolvedPlan.config,
                 ...(primaryStashDir ? { stashDir: primaryStashDir } : {}),
                 ...(options.sourceName && primaryStashDir
                     ? { target: { source: options.sourceName, root: primaryStashDir } }
@@ -201,7 +202,6 @@ async function runLoopReflectPass(planned, isDistillOnly, env, tally) {
                 lowValueFilter: improveProfile.processes?.reflect?.lowValueFilter?.enabled === true,
                 ...(reflectBudgetMs > 0 ? { timeoutMs: reflectBudgetMs } : {}),
                 signal: budgetSignal,
-                runner: reflectProfileRunner ?? null,
                 // R25: reflect's event emits reuse the run's long-lived state.db handle.
                 eventsCtx: env.eventsCtx,
                 // Attribution: carry the eligibility lane so reflect stamps it on
@@ -437,9 +437,7 @@ async function invokeDistillAndRecord(planned, parsedPlannedRef, env, tally) {
         // Active profile so distill's per-process reads honor `--profile`.
         ...(improveProfile ? { improveProfile } : {}),
         config: options.config,
-        llmConfig: resolvedPlan.processes.distill.runner
-            ? materializeLlmRunnerConnection(resolvedPlan.processes.distill.runner)
-            : null,
+        llmRunner: resolvedPlan.processes.distill.runner,
         signal: budgetSignal,
         // R25: distill's event emits reuse the run's long-lived state.db handle.
         eventsCtx,
@@ -814,9 +812,7 @@ export async function runMemoryInferenceMaintenancePass(ctx, dbCell, memoryRefsF
                 config,
                 ...(resolvedPlan
                     ? {
-                        llmConfig: resolvedPlan.processes.memoryInference.runner
-                            ? materializeLlmRunnerConnection(resolvedPlan.processes.memoryInference.runner)
-                            : null,
+                        llmRunner: resolvedPlan.processes.memoryInference.runner,
                     }
                     : {}),
                 sources,
@@ -907,8 +903,8 @@ export async function runGraphExtractionMaintenancePass(ctx, dbCell, args) {
             if (!graphExtractionFullScan) {
                 candidatePaths = new Set();
                 if (primaryStashDir && touchedRefs.size > 0) {
-                    const writableDirSet = new Set(getWritableStashDirs(primaryStashDir).map((d) => path.resolve(d)));
-                    const resolved = await Promise.all([...touchedRefs].map((ref) => findAssetFilePath(ref, primaryStashDir, writableDirSet).catch(() => null)));
+                    const writableBundleIds = deriveWritableBundleIds(resolveSourceEntries(primaryStashDir));
+                    const resolved = await Promise.all([...touchedRefs].map((ref) => findAssetFilePath(ref, primaryStashDir, writableBundleIds).catch(() => null)));
                     for (const p of resolved) {
                         if (typeof p === "string" && p.length > 0)
                             candidatePaths.add(p);
@@ -924,9 +920,7 @@ export async function runGraphExtractionMaintenancePass(ctx, dbCell, args) {
                 config,
                 ...(resolvedPlan
                     ? {
-                        llmConfig: resolvedPlan.processes.graphExtraction.runner
-                            ? materializeLlmRunnerConnection(resolvedPlan.processes.graphExtraction.runner)
-                            : null,
+                        llmRunner: resolvedPlan.processes.graphExtraction.runner,
                     }
                     : {}),
                 sources,