akm-cli 0.9.0-rc.0 → 0.9.0-rc.2

package/dist/commands/improve/preparation.js

@@ -6,13 +6,14 @@ import path from "node:path";
 import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { daysToMs } from "../../core/common.js";
-import { getDefaultLlmConfig, loadConfig } from "../../core/config/config.js";
-import { rethrowIfTestIsolationError } from "../../core/errors.js";
+import { loadConfig } from "../../core/config/config.js";
+import { ConfigError, rethrowIfTestIsolationError } from "../../core/errors.js";
 import { appendEvent, readEvents } from "../../core/events.js";
 import { openStateDatabase, withStateDb } from "../../core/state-db.js";
 import { info, warn } from "../../core/warn.js";
 import { closeDatabase, getRetrievalCounts, getZeroResultSearches, openExistingDatabase } from "../../indexer/db/db.js";
 import { countUsageEventsByType } from "../../indexer/usage/usage-events.js";
+import { materializeLlmRunnerConnection } from "../../integrations/agent/runner.js";
 import { getAvailableHarnesses } from "../../integrations/session-logs/index.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
 import { persistPhaseThreshold } from "../../storage/repositories/improve-runs-repository.js";
@@ -27,7 +28,6 @@ import { buildLatestFeedbackTsMap, buildLatestProposalTsMap, buildUtilityMap, de
 import { akmExtract, countNewExtractCandidates } from "./extract.js";
 import { computeValenceScore, FEEDBACK_WEIGHT, UTILITY_WEIGHT } from "./feedback-valence.js";
 import { makeGateConfig, resolveExtractConfidence, runAutoAcceptGate } from "./improve-auto-accept.js";
-import { resolveProcessEnabled } from "./improve-profiles.js";
 import { applyMemoryCleanup } from "./memory/memory-improve.js";
 import { computeProxyAdequacy, getAllAssetOutcomes, getOutcomeScoresByRef, OUTCOME_SCORE_MAX, outcomeScoreToSalience, updateAssetOutcome, } from "./outcome-loop.js";
 import { DEFAULT_DUE_DAYS, DEFAULT_MAX_PER_RUN, selectProactiveMaintenanceRefs } from "./proactive-maintenance.js";
@@ -151,36 +151,12 @@ export function maybeAutoTuneThreshold(currentThreshold, config, stateDbPath, ct
  *      need, so the fix is non-invasive and provably correct.
  */
 export async function runConsolidationPass(args) {
-    const { options, primaryStashDir, memorySummary, improveProfile, eventsCtx, budgetSignal, runBudgetMs } = args;
+    const { options, primaryStashDir, memorySummary, improveProfile, resolvedPlan, eventsCtx, budgetSignal, runBudgetMs, } = args;
     const baseConfig = options.config ?? loadConfig();
     const MEMORY_VOLUME_THRESHOLD = options.memoryVolumeConsolidationThreshold ?? 100;
-    const hasLlm = !!(baseConfig.defaults?.llm || baseConfig.defaults?.agent);
+    const hasLlm = resolvedPlan.processes.consolidate.runner !== null;
     const volumeTriggered = typeof memorySummary.eligible === "number" && memorySummary.eligible > MEMORY_VOLUME_THRESHOLD && hasLlm;
-    // When volume triggers a consolidation pass, force-enable the consolidate
-    // process on the default improve profile so the gate accepts the run even
-    // if the user's config disabled it. We synthesise a new profile override
-    // rather than mutating connection settings.
-    const consolidationConfig = volumeTriggered
-        ? {
-            ...baseConfig,
-            profiles: {
-                ...(baseConfig.profiles ?? {}),
-                improve: {
-                    ...(baseConfig.profiles?.improve ?? {}),
-                    default: {
-                        ...(baseConfig.profiles?.improve?.default ?? {}),
-                        processes: {
-                            ...(baseConfig.profiles?.improve?.default?.processes ?? {}),
-                            consolidate: {
-                                ...(baseConfig.profiles?.improve?.default?.processes?.consolidate ?? {}),
-                                enabled: true,
-                            },
-                        },
-                    },
-                },
-            },
-        }
-        : baseConfig;
+    const consolidationConfig = baseConfig;
     // 0.8.0 pool-delta gate for consolidate: re-eligible iff at least one
     // memory file has been updated since the most recent successful
     // consolidate_completed event. Time-based cooldowns produced the same
@@ -323,6 +299,9 @@ export async function runConsolidationPass(args) {
             // Active profile for this improve run — lets consolidate's secondary
             // process-config reads honor `--profile <name>` instead of `default`.
             improveProfile,
+            llmConfig: resolvedPlan.processes.consolidate.runner
+                ? materializeLlmRunnerConnection(resolvedPlan.processes.consolidate.runner)
+                : null,
             autoTriggered: volumeTriggered,
             // Tie consolidate proposals back to this improve invocation so
             // accept-rate-per-run aggregation works. Mirrors reflect/propose/extract.
@@ -357,7 +336,7 @@ export async function runConsolidationPass(args) {
             // WS-5: pass total run budget so perfTelemetry.estimatedBudgetFractionUsed
             // can flag when consolidation alone exceeded the budget.
             runBudgetMs,
-        }));
+        }), { engine: resolvedPlan.processes.consolidate.runner?.engine, process: "consolidate" });
         {
             const consolidateGr = await runAutoAcceptGate(consolidation.promoted.map((proposalId) => {
                 try {
@@ -422,7 +401,7 @@ export async function runConsolidationPass(args) {
  * consolidation pass and accumulated here.
  */
 async function runSessionExtractPass(args) {
-    const { options, primaryStashDir, improveProfile, eventsCtx, seedGateAccepted, seedGateFailed } = args;
+    const { options, primaryStashDir, improveProfile, resolvedPlan, eventsCtx, seedGateAccepted, seedGateFailed } = args;
     const warnings = [];
     // Phase 0.4 — session-extract pass.
     //
@@ -476,11 +455,22 @@ async function runSessionExtractPass(args) {
     // #593/#594: the ACTIVE resolved improve profile is the single source of
     // truth for whether extract runs. (Previously this also ANDed in the legacy
     // `session_extraction` feature flag, which only reads
-    // `profiles.improve.default.processes.extract.enabled`; that made the default
-    // profile a global kill switch, so a non-default profile enabling extract was
-    // silently overridden. The default profile is now just another profile.)
+    // a retired global feature path; the selected strategy is authoritative.)
     // `akmExtract` re-checks the same active profile internally via `improveProfile`.
-    if (resolveProcessEnabled("extract", improveProfile)) {
+    if (resolvedPlan.processes.extract.enabled) {
+        const extractRunner = resolvedPlan.processes.extract.runner;
+        if (!extractRunner?.engine) {
+            throw new ConfigError("Resolved improve plan has no runner for enabled extract process.", "LLM_NOT_CONFIGURED");
+        }
+        const extractPlan = Object.freeze({
+            strategy: resolvedPlan.strategy.name,
+            engine: extractRunner.engine,
+            enabled: true,
+            process: resolvedPlan.processes.extract.config,
+            runner: extractRunner,
+            timeoutMs: extractRunner.timeoutMs === undefined ? 600_000 : extractRunner.timeoutMs,
+            embeddingConfig: Object.freeze(structuredClone(extractConfig.embedding)),
+        });
         const availableHarnesses = options.extractHarnesses ?? getAvailableHarnesses();
         // The guard engages only when minNewSessions > 0; 0 disables it entirely.
         let belowMinNewSessions = false;
@@ -521,14 +511,12 @@ async function runSessionExtractPass(args) {
                         type: h.name,
                         ...(primaryStashDir !== undefined ? { stashDir: primaryStashDir } : {}),
                         config: extractConfig,
-                        // Thread the ACTIVE profile so extract's internal gate + per-process
-                        // config read the running profile, not always `default`.
-                        improveProfile,
+                        resolvedPlan: extractPlan,
                         dryRun: options.dryRun ?? false,
                         ...(options.extractHarnesses ? { harnesses: options.extractHarnesses } : {}),
                         // C2: pin extract's skip-tracking state.db open to the boundary path.
                         ...(eventsCtx?.dbPath ? { stateDbPath: eventsCtx.dbPath } : {}),
-                    }));
+                    }), { engine: resolvedPlan.processes.extract.runner?.engine, process: "extract" });
                     extractResults.push(result);
                     {
                         const gr = await runAutoAcceptGate(primaryStashDir
@@ -577,49 +565,47 @@ async function runSessionExtractPass(args) {
  * with structural problems (missing file, missing lesson description), attempts
  * LLM schema repair, and returns the still-failing ref set + the repair records.
  */
-async function runValidationAndRepairPass(args) {
-    const { postCleanupRefs, options, startMs, budgetMs, primaryStashDir } = args;
-    const validationFailures = [];
-    for (const candidate of postCleanupRefs) {
+export async function runValidationAndRepairPass(args) {
+    const { postCleanupRefs, options, startMs, budgetMs, primaryStashDir, resolvedPlan, repairValidationFailures, schemaRepairFn = runSchemaRepairPass, } = args;
+    const validateCandidate = async (candidate) => {
         try {
-            // #591: use the path pre-resolved at planning time when it is still on
-            // disk — a serial async DB lookup per ref cost ~500 s on a 9 000-ref
-            // stash. Fall back to findAssetFilePath only for refs that bypassed
-            // collectEligibleRefs' index scan or whose file moved since planning.
             const filePath = candidate.filePath && fs.existsSync(candidate.filePath)
                 ? candidate.filePath
                 : await findAssetFilePath(candidate.ref, options.stashDir);
-            if (!filePath) {
-                validationFailures.push({ ref: candidate.ref, reason: "file not found on disk" });
-                continue;
-            }
-            if (path.extname(filePath).toLowerCase() !== ".md") {
-                continue;
-            }
+            if (!filePath)
+                return "file not found on disk";
+            if (path.extname(filePath).toLowerCase() !== ".md")
+                return undefined;
             if (isLessonCandidate(candidate.ref)) {
-                const raw = fs.readFileSync(filePath, "utf8");
-                const fm = parseFrontmatter(raw).data;
+                const fm = parseFrontmatter(fs.readFileSync(filePath, "utf8")).data;
                 if (!fm.description)
-                    validationFailures.push({ ref: candidate.ref, reason: "missing description" });
+                    return "missing description";
             }
+            return undefined;
         }
-        catch (e) {
-            validationFailures.push({ ref: candidate.ref, reason: String(e) });
+        catch (error) {
+            return String(error);
         }
+    };
+    const validationFailures = [];
+    for (const candidate of postCleanupRefs) {
+        const reason = await validateCandidate(candidate);
+        if (reason)
+            validationFailures.push({ ref: candidate.ref, reason });
     }
     if (validationFailures.length > 0) {
-        info(`[improve] ${validationFailures.length} assets have validation issues (will attempt schema repair):`);
+        info(`[improve] ${validationFailures.length} assets have validation issues${repairValidationFailures ? " (will attempt schema repair)" : ""}:`);
         for (const f of validationFailures)
             info(`  ${f.ref}: ${f.reason}`);
     }
     let schemaRepairs = [];
-    let repairedRefs = new Set();
+    const repairedRefs = new Set();
     // Schema repair pass: attempt to fix validation failures via LLM before skipping.
-    if (validationFailures.length > 0 && options.repairValidationFailures !== false) {
-        const baseConfigForRepair = options.config ?? loadConfig();
-        const llmCfg = getDefaultLlmConfig(baseConfigForRepair);
+    if (validationFailures.length > 0) {
+        const validationRunner = resolvedPlan.processes.validation.runner;
+        const llmCfg = validationRunner ? materializeLlmRunnerConnection(validationRunner) : undefined;
         if (llmCfg) {
-            const result = await runSchemaRepairPass(validationFailures, {
+            const result = await withLlmStage("validation", () => schemaRepairFn(validationFailures, {
                 startMs,
                 budgetMs,
                 llmConfig: llmCfg,
@@ -633,9 +619,17 @@ async function runValidationAndRepairPass(args) {
                 stashDir: primaryStashDir,
                 findFilePath: findAssetFilePath,
                 isLessonCandidateFn: isLessonCandidate,
-            });
+            }), { engine: resolvedPlan.processes.validation.runner?.engine, process: "validation" });
             schemaRepairs = result.repairs;
-            repairedRefs = result.repairedRefs;
+            // A repair result is advisory. Only a fresh structural read of the live
+            // asset can remove it from the failure set; queued content is not live.
+            const failedRefs = new Set(validationFailures.map((failure) => failure.ref));
+            const candidatesByRef = new Map(postCleanupRefs.map((candidate) => [candidate.ref, candidate]));
+            for (const ref of failedRefs) {
+                const candidate = candidatesByRef.get(ref);
+                if (candidate && !(await validateCandidate(candidate)))
+                    repairedRefs.add(ref);
+            }
         }
     }
     const validationFailureRefs = new Set(validationFailures.filter((f) => !repairedRefs.has(f.ref)).map((f) => f.ref));
@@ -645,7 +639,7 @@ async function runValidationAndRepairPass(args) {
     return { validationFailures, validationFailureRefs, schemaRepairs };
 }
 export async function runImprovePreparationStage(args) {
-    const { scope, options, plannedRefs, memoryCleanupPlan, primaryStashDir, memorySummary, reindexFn, startMs, budgetMs, eventsCtx, initialCleanupWarnings, improveProfile, budgetSignal, } = args;
+    const { scope, options, plannedRefs, memoryCleanupPlan, primaryStashDir, memorySummary, reindexFn, startMs, budgetMs, eventsCtx, initialCleanupWarnings, improveProfile, resolvedPlan, strategyName, budgetSignal, } = args;
     const actions = [];
     const cleanupWarnings = initialCleanupWarnings ? [...initialCleanupWarnings] : [];
     // Phase 0 — MEMORY.md budget check (200-line cap; warn at 180)
@@ -681,6 +675,7 @@ export async function runImprovePreparationStage(args) {
         primaryStashDir,
         memorySummary,
         improveProfile,
+        resolvedPlan,
         eventsCtx,
         budgetSignal,
         runBudgetMs: budgetMs,
@@ -690,6 +685,7 @@ export async function runImprovePreparationStage(args) {
         options,
         primaryStashDir,
         improveProfile,
+        resolvedPlan,
         eventsCtx,
         seedGateAccepted: consolidationPass.gateAutoAcceptedCount,
         seedGateFailed: consolidationPass.gateAutoAcceptFailedCount,
@@ -704,7 +700,7 @@ export async function runImprovePreparationStage(args) {
     appendEvent({
         eventType: "improve_invoked",
         ref: scope.mode === "ref" ? scope.value : `improve:${scope.mode}:${scope.value ?? "all"}`,
-        metadata: { scope, dryRun: options.dryRun ?? false, eligibleCount: plannedRefs.length },
+        metadata: { strategy: strategyName, scope, dryRun: options.dryRun ?? false, eligibleCount: plannedRefs.length },
     }, eventsCtx);
     // ensureIndex now runs in akmImprove() BEFORE collectEligibleRefs so the
     // eligible-ref query sees a populated `entries` table on the very first
@@ -751,6 +747,8 @@ export async function runImprovePreparationStage(args) {
         startMs,
         budgetMs,
         primaryStashDir,
+        resolvedPlan,
+        repairValidationFailures: resolvedPlan.processes.validation.enabled && options.repairValidationFailures !== false,
     });
     // Phase 0.5 — structural hygiene pass
     let lintSummary;
@@ -892,7 +890,7 @@ export async function runImprovePreparationStage(args) {
             // Has feedback on record but no signal delta since the last proposal —
             // genuinely fully skipped. Counted here; a single aggregated
             // improve_skipped event is emitted after the loop (mirrors
-            // profile_filtered_all_passes) instead of one event per ref.
+            // strategy_filtered_all_passes) instead of one event per ref.
             fullySkippedCount++;
             actions.push({
                 ref: r.ref,
@@ -903,7 +901,7 @@ export async function runImprovePreparationStage(args) {
     }
     // Emit ONE aggregated skip event for the fully-skipped bucket rather than one
     // improve_skipped event per ref (#592 pattern, mirrors
-    // profile_filtered_all_passes above). The per-ref loop previously produced
+    // strategy_filtered_all_passes above). The per-ref loop previously produced
     // ~11K state.db writes per run on a large stash, the dominant contributor to
     // 900 s timeouts. The in-memory `actions` log keeps the per-ref detail for the
     // run summary; no downstream consumer needs a per-ref DB audit trail (health's
@@ -1063,7 +1061,7 @@ export async function runImprovePreparationStage(args) {
     // runs rotate through the due pool rather than re-selecting the same heads.
     let proactiveRefs = [];
     let proactiveMaintenanceSummary;
-    const proactiveEnabled = scope.mode !== "ref" && resolveProcessEnabled("proactiveMaintenance", improveProfile);
+    const proactiveEnabled = scope.mode !== "ref" && resolvedPlan.processes.proactiveMaintenance.enabled;
     if (proactiveEnabled) {
         const pmCfg = improveProfile.processes?.proactiveMaintenance;
         const dueDays = pmCfg?.dueDays ?? DEFAULT_DUE_DAYS;

package/dist/commands/improve/procedural.js

@@ -4,8 +4,8 @@
 /**
  * #615 — procedural-compilation pass.
  *
- * An OPT-IN post-loop improve stage (default disabled via
- * `IMPROVE_PROCESS_DEFAULTS.procedural`). It reads assets that carry an
+ * An OPT-IN post-loop improve stage (the built-in default strategy sets
+ * `processes.procedural.enabled: false`). It reads assets that carry an
  * `orderedActions` frontmatter list (captured by #619), detects RECURRING
  * successful action sequences across sessions (the SAME normalized ordered step
  * list appearing >= `minRecurrence` times with a non-failure `outcomeData`), and
@@ -293,6 +293,7 @@ export async function akmProcedural(opts) {
             tag: "[procedural]",
             signal: opts.signal,
             activeProfile: opts.improveProfile,
+            llmConfig: opts.llmConfig,
         });
     if (!llmFn) {
         warnings.push("procedural: no LLM configured — skipping");

package/dist/commands/improve/recombine.js

@@ -5,7 +5,7 @@
  * #609 — recombine / synthesize pass.
  *
  * A whole-corpus synthesis stage that runs AFTER consolidation and is OPT-IN
- * (default disabled via `IMPROVE_PROCESS_DEFAULTS.recombine`). It clusters
+ * (the built-in default strategy sets `processes.recombine.enabled: false`). It clusters
  * memories by RELATEDNESS (shared tags / graph entities — NEVER embedding
  * similarity), issues ONE bounded LLM call per cluster to induce a single
  * cross-episodic generalization, and emits the result as a NORMAL pending
@@ -554,6 +554,7 @@ export async function akmRecombine(opts) {
             tag: "[recombine]",
             signal: opts.signal,
             activeProfile: opts.improveProfile,
+            llmConfig: opts.llmConfig,
         });
     if (!llmFn) {
         warnings.push("recombine: no LLM configured — skipping");