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

package/dist/commands/health/improve-metrics.js

@@ -1,18 +1,23 @@
 // 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 { decodeImproveResult } from "../../core/improve-result.js";
 import { queryImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
+import { decodeTaskHistoryMetadata } from "../../storage/repositories/task-history-repository.js";
 import { summarizeCalibration } from "../improve/calibration.js";
 export function roundRate(value) {
     return Number(value.toFixed(4));
 }
 export function parseTaskMetadata(row) {
-    try {
-        return JSON.parse(row.metadata_json);
-    }
-    catch {
-        return {};
-    }
+    const metadata = decodeTaskHistoryMetadata(row.metadata_json);
+    return {
+        ...(metadata.durationMs !== undefined ? { durationMs: metadata.durationMs } : {}),
+        ...(metadata.detail ? { detail: metadata.detail } : {}),
+        ...(metadata.metadataVersion === 2 && metadata.engine !== undefined ? { engine: metadata.engine } : {}),
+        ...(metadata.metadataVersion === 1 && metadata.legacyProfile !== undefined
+            ? { legacyProfile: metadata.legacyProfile }
+            : {}),
+    };
 }
 function createUnknownImproveMetrics() {
     return {
@@ -21,7 +26,7 @@ function createUnknownImproveMetrics() {
         skipped: 0,
         skipReasons: {},
         plannedRefs: 0,
-        profileFilteredRefs: 0,
+        strategyFilteredRefs: 0,
         actions: {
             reflect: { ok: 0, failed: 0, cooldown: 0, skipped: 0, guardRejected: 0, skippedByReason: {} },
             distill: {
@@ -181,12 +186,14 @@ function projectRunMetrics(result) {
     const plannedRefs = result.plannedRefs;
     if (Array.isArray(plannedRefs))
         metrics.plannedRefs += plannedRefs.length;
-    // profileFilteredRefs (array of {ref, reason}) — 2026-05-27: pre-filter
+    // strategyFilteredRefs (array of {ref, reason}) — 2026-05-27: pre-filter
     // bucket from `collectEligibleRefs` so the metric reflects work the
     // planner dropped before signal-delta / per-pass dispatch.
-    const profileFilteredRefs = result.profileFilteredRefs;
-    if (Array.isArray(profileFilteredRefs))
-        metrics.profileFilteredRefs += profileFilteredRefs.length;
+    // Health v3 reports strategy metrics only. Historical v1 profile filtering
+    // remains legacy data and must not be silently relabelled as a strategy metric.
+    const strategyFilteredRefs = result.schemaVersion === 2 ? result.strategyFilteredRefs : undefined;
+    if (Array.isArray(strategyFilteredRefs))
+        metrics.strategyFilteredRefs += strategyFilteredRefs.length;
     // actions: split reflect / distill by outcome, count others.
     const actions = result.actions;
     if (Array.isArray(actions)) {
@@ -496,8 +503,8 @@ function finalizeImproveMetrics(metrics) {
  */
 function mergeImproveMetrics(dst, src) {
     dst.plannedRefs += src.plannedRefs;
-    // profileFilteredRefs is the count of refs the planner drops up-front for the
-    // active profile — recomputed against the (stable) stash every run, so it is a
+    // strategyFilteredRefs is the count of refs the planner drops up-front for the
+    // active strategy — recomputed against the (stable) stash every run, so it is a
     // snapshot, NOT a per-run increment. Summing it re-counts the same refs each
     // run (the ~2.4M bug). Set from the most recent run in summarizeImproveRuns.
     dst.actions.reflect.ok += src.actions.reflect.ok;
@@ -613,22 +620,16 @@ export function summarizeImproveRuns(db, since, until) {
     // MOST RECENT run's snapshot (current state) — not a sum across runs.
     let latestStartMs = Number.NEGATIVE_INFINITY;
     let latestMemorySummary;
-    let latestProfileFilteredRefs = 0;
+    let latestStrategyFilteredRefs = 0;
     for (const row of rows) {
-        let result;
-        try {
-            result = JSON.parse(row.result_json);
-        }
-        catch {
-            continue;
-        }
+        const result = decodeImproveResult(row.result_json).envelope;
         const perRow = projectRunMetrics(result);
         mergeImproveMetrics(accum, perRow);
         const startMs = new Date(row.started_at).getTime();
         if (Number.isFinite(startMs) && startMs >= latestStartMs) {
             latestStartMs = startMs;
             latestMemorySummary = perRow.memorySummary;
-            latestProfileFilteredRefs = perRow.profileFilteredRefs;
+            latestStrategyFilteredRefs = perRow.strategyFilteredRefs;
         }
         // Collect per-phase durations directly off the envelope. consolidation's
         // duration lives inside the sub-object; memoryInference and graphExtraction
@@ -648,7 +649,7 @@ export function summarizeImproveRuns(db, since, until) {
     finalizeImproveMetrics(accum);
     if (latestMemorySummary)
         accum.memorySummary = latestMemorySummary;
-    accum.profileFilteredRefs = latestProfileFilteredRefs;
+    accum.strategyFilteredRefs = latestStrategyFilteredRefs;
     accum.wallTime.byPhase = {
         consolidation: summarizePhaseDurations(phaseDurations.consolidation),
         memoryInference: summarizePhaseDurations(phaseDurations.memoryInference),
@@ -680,13 +681,8 @@ export function summarizePhaseDurations(samples) {
  * Used by `akm health --detail per-run`.
  */
 export function projectImproveRunSummary(row, wallTimeMs, taskId) {
-    let result = {};
-    try {
-        result = JSON.parse(row.result_json);
-    }
-    catch {
-        // fall through with empty result so per-stage rollups are zeros
-    }
+    const decoded = decodeImproveResult(row.result_json);
+    const result = decoded.envelope;
     const perRow = projectRunMetrics(result);
     finalizeImproveMetrics(perRow);
     const orphansPurged = toFiniteNumber(result.orphansPurged);
@@ -699,6 +695,8 @@ export function projectImproveRunSummary(row, wallTimeMs, taskId) {
         completedAt: row.completed_at,
         wallTimeMs,
         ok: row.ok === 1,
+        strategy: row.strategy,
+        legacyProfile: row.legacyProfile,
         scope: {
             mode: row.scope_mode,
             ...(row.scope_value ? { value: row.scope_value } : {}),
@@ -744,10 +742,10 @@ export function buildImproveSkipSummary(events) {
     //  - Per-occurrence (no `count`): one event per skipped ref → SUM is correct.
     //  - Aggregated snapshot (carries `count`): a single per-run event whose count
     //    is the number of refs that hit a STABLE, whole-stash condition that run
-    //    (`no_new_signal`, `profile_filtered_all_passes`). Each run re-counts the
+    //    (`no_new_signal`, `strategy_filtered_all_passes`). Each run re-counts the
     //    same stable set, so summing across the window re-counts it N times (the
     //    2.7M / 3M inflation). For these we keep the MOST RECENT run's count — the
-    //    current snapshot — matching how memorySummary/profileFilteredRefs are
+    //    current snapshot — matching how memorySummary/strategyFilteredRefs are
     //    handled. Events arrive in chronological (offset) order, so the last
     //    count-bearing event per reason is the latest run's value.
     const summed = {};

package/dist/commands/health/llm-usage.js

@@ -7,7 +7,7 @@
  */
 import { readEvents } from "../../core/events.js";
 import { LLM_USAGE_EVENT } from "../../llm/usage-persist.js";
-import { toFiniteNumber } from "./improve-metrics.js";
+import { decodeLlmUsageRecord } from "../../llm/usage-telemetry.js";
 /** Stage key used for `llm_usage` events recorded outside any stage scope. */
 const UNATTRIBUTED_STAGE = "unattributed";
 function emptyLlmUsageStageAggregate() {
@@ -21,7 +21,7 @@ function emptyLlmUsageStageAggregate() {
     };
 }
 function emptyLlmUsageAggregate() {
-    return { ...emptyLlmUsageStageAggregate(), byStage: {} };
+    return { ...emptyLlmUsageStageAggregate(), byStage: {}, byProcess: {}, byEngine: {} };
 }
 /**
  * Aggregate `llm_usage` events (#576) into a window total plus a per-stage
@@ -32,25 +32,25 @@ function emptyLlmUsageAggregate() {
 export function summarizeLlmUsage(events) {
     const aggregate = emptyLlmUsageAggregate();
     for (const event of events) {
-        const meta = event.metadata ?? {};
-        const stageKey = typeof meta.stage === "string" && meta.stage ? meta.stage : UNATTRIBUTED_STAGE;
-        let stage = aggregate.byStage[stageKey];
-        if (!stage) {
-            stage = emptyLlmUsageStageAggregate();
-            aggregate.byStage[stageKey] = stage;
+        const record = decodeLlmUsageRecord(event.metadata);
+        if (!record)
+            continue;
+        const dimensions = [];
+        for (const [groups, key] of [
+            [aggregate.byStage, record.stage ?? UNATTRIBUTED_STAGE],
+            [aggregate.byProcess, record.process ?? UNATTRIBUTED_STAGE],
+            [aggregate.byEngine, record.engine ?? UNATTRIBUTED_STAGE],
+        ]) {
+            groups[key] ??= emptyLlmUsageStageAggregate();
+            dimensions.push(groups[key]);
         }
-        const durationMs = toFiniteNumber(meta.durationMs);
-        const promptTokens = toFiniteNumber(meta.promptTokens);
-        const completionTokens = toFiniteNumber(meta.completionTokens);
-        const totalTokens = toFiniteNumber(meta.totalTokens);
-        const reasoningTokens = toFiniteNumber(meta.reasoningTokens);
-        for (const target of [aggregate, stage]) {
+        for (const target of [aggregate, ...dimensions]) {
             target.calls += 1;
-            target.totalDurationMs += durationMs;
-            target.promptTokens += promptTokens;
-            target.completionTokens += completionTokens;
-            target.totalTokens += totalTokens;
-            target.reasoningTokens += reasoningTokens;
+            target.totalDurationMs += record.durationMs;
+            target.promptTokens += record.promptTokens ?? 0;
+            target.completionTokens += record.completionTokens ?? 0;
+            target.totalTokens += record.totalTokens ?? 0;
+            target.reasoningTokens += record.reasoningTokens ?? 0;
         }
     }
     return aggregate;

package/dist/commands/health/md-report.js

@@ -28,6 +28,8 @@ export function renderRunsDetailMd(runs) {
     const headers = [
         "ts",
         "ok",
+        "strategy",
+        "legacy_profile",
         "actions",
         "refl_ok/fail/cd/skip",
         "distill_q/llm-fail/qrej/cfg/skip",
@@ -54,6 +56,8 @@ export function renderRunsDetailMd(runs) {
         return [
             r.startedAt,
             String(r.ok),
+            r.strategy ?? "",
+            r.legacyProfile ?? "",
             String(totalActions),
             `${r.actions.reflect.ok}/${r.actions.reflect.failed}/${r.actions.reflect.cooldown}/${r.actions.reflect.skipped}`,
             `${r.actions.distill.queued}/${r.actions.distill.llmFailed}/${r.actions.distill.qualityRejected}/${r.actions.distill.configDisabled}/${r.actions.distill.skipped}`,

package/dist/commands/health/metrics.js

@@ -7,6 +7,7 @@
  * minting rollup, and the WS-5 per-run degradation metrics.
  */
 import { appendEvent, readEvents } from "../../core/events.js";
+import { decodeImproveResult } from "../../core/improve-result.js";
 import { queryImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
 import { listProposalGateDecisions, listStateProposals } from "../../storage/repositories/proposals-repository.js";
 import { gateDecisionsToSamples, summarizeCalibration } from "../improve/calibration.js";
@@ -221,7 +222,7 @@ export function computeDegradationMetrics(db, since, until) {
         let totalProcessed = 0;
         for (const row of runs) {
             try {
-                const result = JSON.parse(row.result_json);
+                const result = decodeImproveResult(row.result_json).envelope;
                 const cons = result.consolidation;
                 if (cons) {
                     totalContradicted += toFiniteNumber(cons.contradicted);

package/dist/commands/health/surfaces.js

@@ -18,7 +18,8 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { CURRENT_CONFIG_VERSION, compareConfigVersion } from "../../core/config/config-migration.js";
+import { CURRENT_CONFIG_VERSION } from "../../core/config/config-schema.js";
+import { compareConfigVersion } from "../../core/config/config-version.js";
 const GROUP_OTHER_BITS = 0o077;
 const OFFENDER_EVIDENCE_CAP = 50;
 function modeOctal(mode) {
@@ -182,10 +183,10 @@ export function collectEgressAdvisory(config) {
             continue;
         endpoints.push(`source ${source.name ?? "(unnamed)"} (${source.type ?? "?"}): ${source.url}`);
     }
-    for (const [name, profile] of Object.entries(config.profiles?.llm ?? {})) {
-        if (!profile?.endpoint)
+    for (const [name, engine] of Object.entries(config.engines ?? {})) {
+        if (engine?.kind !== "llm" || !engine.endpoint)
             continue;
-        endpoints.push(`llm ${name}: ${profile.endpoint}`);
+        endpoints.push(`llm ${name}: ${engine.endpoint}`);
     }
     if (config.embedding?.endpoint)
         endpoints.push(`embedding: ${config.embedding.endpoint}`);

package/dist/commands/health.js

@@ -284,7 +284,7 @@ export function akmHealth(options = {}) {
             runs = buildPerRunSummaries(db, since);
         }
         return {
-            schemaVersion: 2,
+            schemaVersion: 3,
             ok: !hardFailure,
             status,
             since: topLevelSince,

package/dist/commands/improve/consolidate/chunking.js

@@ -33,9 +33,9 @@ const PROMPT_OVERHEAD_TOKENS = 2_000;
  *     chunk content.
  *   - When the HTTP path is used (an LLM profile is selected), only the akm
  *     system prompt and user prompt are sent, so the budget can be set to the
- *     model's actual context length via profiles.llm[defaults.llm].contextLength.
+ *     model's actual context length via the selected LLM engine's contextLength.
  *
- * Set profiles.llm[defaults.llm].contextLength in your config file to the
+ * Set the selected LLM engine's contextLength in your config file to the
  * model's actual context window to allow larger chunks on the HTTP path.
  */
 export const DEFAULT_CONTEXT_LENGTH_TOKENS = 4_096;

package/dist/commands/improve/consolidate.js

@@ -29,12 +29,13 @@ import { openStateDatabase, withStateDb } from "../../core/state-db.js";
 import { warn } from "../../core/warn.js";
 import { commitWriteTargetBoundary, deleteAssetFromSource, resolveWriteTarget, writeAssetToSource, } from "../../core/write-source.js";
 import { closeDatabase, findEntryIdByRef, getAllEntries, getEntryById, getNeighborsByEntryId, openExistingDatabase, } from "../../indexer/db/db.js";
-import { resolveImproveProcessRunnerFromProfile, runnerIsLlm } from "../../integrations/agent/runner.js";
+import { materializeLlmRunnerConnection, resolveImproveProcessRunner } from "../../integrations/agent/runner.js";
 import { chatCompletion } from "../../llm/client.js";
 import { cosineSimilarity, embedBatch, resolveEmbeddingModelId } from "../../llm/embedder.js";
-import { isLlmFeatureEnabled, tryLlmFeature } from "../../llm/feature-gate.js";
+import { tryLlmFeature } from "../../llm/feature-gate.js";
 import { getConsolidationJudgedMap, upsertConsolidationJudged, } from "../../storage/repositories/consolidation-repository.js";
 import { getBodyEmbeddings, upsertBodyEmbeddings } from "../../storage/repositories/embeddings-repository.js";
+import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
 // Chunk sizing + per-chunk prompt assembly live in ./consolidate/chunking.
 // Imported for internal use by the orchestrator and re-exported for importers.
 import { buildChunkPrompt, computeSafeChunkSize, DEFAULT_CONTEXT_LENGTH_TOKENS } from "./consolidate/chunking.js";
@@ -493,13 +494,13 @@ function archiveMemory(filePath, stashDir, ref, reason, opIndex, supersededBy, w
  *
  * Priority order (mirrors extract / reflect / distill — see
  * `src/commands/extract.ts:421-438` and the canonical
- * `resolveImproveProcessRunnerFromProfile` pattern):
+ * `resolveImproveProcessRunner` pattern):
  *
- *   1. `profiles.improve.default.processes.consolidate.profile` (or `mode`)
- *      via {@link resolveImproveProcessRunnerFromProfile}. Lets the user pin
+ *   1. `improve.strategies.<name>.processes.consolidate.engine`
+ *      via {@link resolveImproveProcessRunner}. Lets the user pin
  *      a dedicated model (e.g. `ministral-3b`) for consolidation instead of
- *      whatever `defaults.llm` happens to be.
- *   2. `getDefaultLlmConfig(config)` — the baseline default LLM profile.
+ *      whatever `defaults.llmEngine` happens to be.
+ *   2. `getDefaultLlmConfig(config)` — the baseline default LLM engine.
  *
  * Regression guard (2026-05-26): before this resolver, `akmConsolidate`
  * called `getDefaultLlmConfig` directly and silently ignored a configured
@@ -509,13 +510,9 @@ function archiveMemory(filePath, stashDir, ref, reason, opIndex, supersededBy, w
  * `/tmp/akm-health-investigations/consolidation-no-op.md`.
  */
 function resolveConsolidateLlmConfig(config, activeProfile) {
-    const consolidateProcess = getImproveProcessConfig(config, "consolidate", activeProfile);
-    const runnerSpec = resolveImproveProcessRunnerFromProfile(consolidateProcess, config);
-    if (runnerSpec && runnerIsLlm(runnerSpec)) {
-        return runnerSpec.connection;
-    }
-    // Non-LLM runner modes (agent/sdk) don't apply to consolidate's HTTP path;
-    // fall back to the default LLM profile rather than disabling the pass.
+    const runnerSpec = resolveImproveProcessRunner(activeProfile, "consolidate", config);
+    if (runnerSpec)
+        return materializeLlmRunnerConnection(runnerSpec);
     return getDefaultLlmConfig(config);
 }
 // ── Judged-state cache (#581) ────────────────────────────────────────────────
@@ -578,8 +575,9 @@ export async function akmConsolidate(opts = {}) {
     // standalone `akm consolidate` gets a self-contained token.
     const sourceRun = opts.sourceRun ?? `consolidate-${startMs}`;
     const config = opts.config ?? loadConfig();
+    opts = { ...opts, improveProfile: opts.improveProfile ?? resolveImproveStrategy(undefined, config).config };
     const stashDir = opts.stashDir ?? resolveStashDir();
-    if (!isLlmFeatureEnabled(config, "memory_consolidation")) {
+    if (!resolveProcessEnabled("consolidate", opts.improveProfile ?? resolveImproveStrategy(undefined, config).config)) {
         return makeConsolidateResult({
             dryRun: opts.dryRun ?? false,
             target: opts.target ?? stashDir,
@@ -868,9 +866,11 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
     // CLI. The agent CLI is for interactive agent sessions (reflect, propose);
     // structured JSON generation works better and faster via HTTP.
     //
-    // Honor `profiles.improve.default.processes.consolidate.profile` first; fall
-    // back to the default LLM. See {@link resolveConsolidateLlmConfig}.
-    const llmConfig = resolveConsolidateLlmConfig(config, opts.improveProfile);
+    // Improve supplies a frozen connection; standalone consolidate resolves its
+    // selected strategy/default engine here.
+    const llmConfig = Object.hasOwn(opts, "llmConfig")
+        ? (opts.llmConfig ?? undefined)
+        : resolveConsolidateLlmConfig(config, opts.improveProfile);
     const isHttpPath = !!llmConfig;
     // Chunk sizing: derive a safe chunk size from the configured model context
     // window so that the full prompt (system prompt + chunk user prompt) never
@@ -1087,7 +1087,7 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
             catch (e) {
                 return { ok: false, error: String(e) };
             }
-        }, { ok: false, error: fallbackError });
+        }, { ok: false, error: fallbackError }, { enabled: true });
         let raw = await callChunkLlm(`chunk ${chunkIdx + 1} failed`);
         if (!raw.ok) {
             // Single retry with 2s backoff before recording chunk as lost.
@@ -1230,7 +1230,7 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
  * the op-handlers' `pushSkipReason`. Behavior-identical to the former inlined
  * write block. Never invoked on the dry-run or aborted-confirm paths.
  */
-async function applyConsolidationPlan(config, stashDir, sourceRun, memories, warnings, allOps, accounting, dedupCollapsed, activeProfile) {
+async function applyConsolidationPlan(config, stashDir, sourceRun, memories, warnings, allOps, accounting, dedupCollapsed, activeProfile, llmConfig) {
     // -- Phase B + writes -------------------------------------------------------
     const target = resolveWriteTarget(config);
     const timestamp = timestampForFilename();
@@ -1258,6 +1258,7 @@ async function applyConsolidationPlan(config, stashDir, sourceRun, memories, war
     const opCtx = {
         config,
         improveProfile: activeProfile,
+        llmConfig: llmConfig ?? null,
         stashDir,
         sourceRun,
         target,
@@ -1380,7 +1381,9 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
         }
     }
     // -- Pass 3: execute the plan against the filesystem ------------------------
-    const { merged, deleted, contradicted, mergeFloorViolations, mergedSecondaries, promoted } = await applyConsolidationPlan(config, stashDir, sourceRun, memories, warnings, allOps, accounting, dedupCollapsed, opts.improveProfile);
+    const { merged, deleted, contradicted, mergeFloorViolations, mergedSecondaries, promoted } = await applyConsolidationPlan(config, stashDir, sourceRun, memories, warnings, allOps, accounting, dedupCollapsed, opts.improveProfile, Object.hasOwn(opts, "llmConfig")
+        ? (opts.llmConfig ?? null)
+        : (resolveConsolidateLlmConfig(config, opts.improveProfile) ?? null));
     const runDurationMs = Date.now() - startMs;
     const budgetFraction = opts.runBudgetMs !== undefined && opts.runBudgetMs > 0 ? runDurationMs / opts.runBudgetMs : undefined;
     return {
@@ -1502,7 +1505,7 @@ export async function handleMergeOp(op, opIndex, ctx) {
         emitMergeFailureSkips("merge_read_failed");
         return;
     }
-    const mergeResult = await generateMergedContent(config, op.primary, primaryBody, op.secondaries, memoryByRef, ctx.improveProfile);
+    const mergeResult = await generateMergedContent(config, op.primary, primaryBody, op.secondaries, memoryByRef, ctx.improveProfile, ctx.llmConfig);
     if ("error" in mergeResult) {
         warnings.push(`Merge: ${mergeResult.error} for ${mergeResult.detail}.`);
         emitMergeFailureSkips(mergeResult.error);
@@ -2147,7 +2150,7 @@ function loadMemoriesForSource(source, stashDir, warnings) {
     }
     return memories;
 }
-async function generateMergedContent(config, primaryRef, primaryBody, secondaryRefs, memoryByRef, activeProfile) {
+async function generateMergedContent(config, primaryRef, primaryBody, secondaryRefs, memoryByRef, activeProfile, resolvedLlmConfig) {
     // Only handle single-secondary merges per design (one call per merge op)
     const secRef = secondaryRefs[0];
     const secEntry = memoryByRef.get(secRef);
@@ -2191,7 +2194,7 @@ async function generateMergedContent(config, primaryRef, primaryBody, secondaryR
         .join("\n");
     // Use the same per-process profile resolution as the chunk-plan call above
     // so the merge generation step doesn't silently revert to the default LLM.
-    const llmConfig = resolveConsolidateLlmConfig(config, activeProfile);
+    const llmConfig = resolvedLlmConfig === null ? undefined : (resolvedLlmConfig ?? resolveConsolidateLlmConfig(config, activeProfile));
     const result = await tryLlmFeature("memory_consolidation", config, async () => {
         if (!llmConfig)
             return { ok: false, error: "No LLM configured for consolidation" };
@@ -2204,7 +2207,7 @@ async function generateMergedContent(config, primaryRef, primaryBody, secondaryR
         catch (e) {
             return { ok: false, error: String(e) };
         }
-    }, { ok: false, error: `merge content generation failed for ${primaryRef}` });
+    }, { ok: false, error: `merge content generation failed for ${primaryRef}` }, { enabled: true });
     if (!result.ok) {
         return {
             error: "merge_transport_failed",

package/dist/commands/improve/distill/promote-memory.js

@@ -18,11 +18,8 @@
  */
 import fs from "node:fs";
 import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
-import { getDefaultLlmConfig } from "../../../core/config/config.js";
-import { ConfigError } from "../../../core/errors.js";
 import { appendEvent } from "../../../core/events.js";
 import { parseEmbeddedJsonResponse } from "../../../llm/client.js";
-import { isLlmFeatureEnabled } from "../../../llm/feature-gate.js";
 import { createProposal, isProposalSkipped } from "../../proposal/repository.js";
 import { assessMemoryKnowledgePromotionCandidate } from "../distill-promotion-policy.js";
 import { persistOutputEncodingSalience, runLessonQualityJudge, writeQualityRejection } from "./quality-gate.js";
@@ -62,7 +59,7 @@ export async function promoteMemoryToKnowledge(ctx) {
             }
         })()
         : null;
-    if (existingKnowledgeContent && config && getDefaultLlmConfig(config)) {
+    if (existingKnowledgeContent && ctx.llmConfig) {
         // Existing content found: call LLM for contradiction-resolution merge.
         const mergePrompt = [
             "You are merging two versions of a knowledge document.",
@@ -81,11 +78,7 @@ export async function promoteMemoryToKnowledge(ctx) {
             "```",
         ].join("\n");
         try {
-            const mergeLlm = getDefaultLlmConfig(config);
-            if (!mergeLlm) {
-                throw new ConfigError("LLM is not configured for distillation merge.", "LLM_NOT_CONFIGURED");
-            }
-            const mergeResponse = await chat(mergeLlm, [
+            const mergeResponse = await chat(ctx.llmConfig, [
                 { role: "system", content: "Return only valid JSON. No prose." },
                 { role: "user", content: mergePrompt },
             ]);
@@ -122,7 +115,7 @@ export async function promoteMemoryToKnowledge(ctx) {
             // The reviewer will see both versions in the proposal diff.
         }
     }
-    else if (existingKnowledgeContent && config && !getDefaultLlmConfig(config)) {
+    else if (existingKnowledgeContent) {
         // No LLM configured: include existing content as context in the proposal
         // so the reviewer can do the contradiction resolution manually.
         resolvedPromotionContent = [
@@ -141,10 +134,10 @@ export async function promoteMemoryToKnowledge(ctx) {
     // D-5 / #388: Three-band system — review_needed band queues to proposal
     // queue with review_needed outcome rather than auto-rejecting.
     let knowledgeJudgeConfidence;
-    if (isLlmFeatureEnabled(config, "lesson_quality_gate")) {
+    if (ctx.strategy?.processes?.distill?.qualityGate?.enabled ?? true) {
         // D-4 / #390: retrieve top-3 similar lessons for dedup check in judge.
         const similarLessons = await fetchSimilarLessonsFn(resolvedPromotionContent.slice(0, 500), 3);
-        const judgeResult = await runLessonQualityJudge(config, resolvedPromotionContent, assetContent ?? "", chat, similarLessons.length > 0 ? similarLessons : undefined);
+        const judgeResult = await runLessonQualityJudge(config, resolvedPromotionContent, assetContent ?? "", chat, similarLessons.length > 0 ? similarLessons : undefined, ctx.llmConfig);
         if (!judgeResult.pass) {
             if (judgeResult.reviewNeeded) {
                 // Uncertainty band (2.5–3.5): queue as review_needed instead of rejecting.

package/dist/commands/improve/distill/quality-gate.js

@@ -102,10 +102,8 @@ export function buildJudgePrompt(lessonContent, sourceContent, similarLessons) {
  * Run the LLM-as-judge quality gate on a proposal's content.
  *
  * Exported so reflect.ts can apply the same gate to reflect proposals (R-5 / #374).
- * Gated by the flag name `lesson_quality_gate` (or its alias
- * `proposal_quality_gate`) via {@link isLlmFeatureEnabled} — which reads
- * `profiles.improve.default.processes.distill.qualityGate.enabled` (and the
- * corresponding `.reflect.qualityGate.enabled` for proposals).
+ * The selected strategy's distill/reflect quality-gate setting is resolved by
+ * the caller before this function runs.
  *
  * Fail-CLOSED (07 P0-2): returns `pass: false` (score -1) on timeout, parse
  * failure, or missing LLM. Minted content that cannot be judged is rejected,
@@ -114,12 +112,12 @@ export function buildJudgePrompt(lessonContent, sourceContent, similarLessons) {
  */
 export async function runLessonQualityJudge(config, lessonContent, sourceContent, chat, 
 /** D-4 / #390: top-3 similar existing lessons for dedup check. */
-similarLessons) {
-    const llmConfig = getDefaultLlmConfig(config);
+similarLessons, llmConfigOverride) {
+    const llmConfig = llmConfigOverride ?? getDefaultLlmConfig(config);
     if (!llmConfig) {
         return { pass: false, score: -1, reason: "no LLM configured — cannot judge, failing closed" };
     }
-    const judgeLlmConfig = llmConfig.judgeModel ? { ...llmConfig, model: llmConfig.judgeModel } : llmConfig;
+    const judgeLlmConfig = llmConfig;
     const JUDGE_TIMEOUT_MS = 8_000;
     try {
         const raw = await Promise.race([

package/dist/commands/improve/distill.js

@@ -69,8 +69,9 @@ import { withStateDb } from "../../core/state-db.js";
 import { warnVerbose } from "../../core/warn.js";
 import { closeDatabase, getAllEntries, openIndexDatabase } from "../../indexer/db/db.js";
 import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
+import { materializeLlmRunnerConnection, resolveImproveProcessRunner } from "../../integrations/agent/runner.js";
 import { chatCompletion, parseEmbeddedJsonResponse } from "../../llm/client.js";
-import { isLlmFeatureEnabled, tryLlmFeature } from "../../llm/feature-gate.js";
+import { tryLlmFeature } from "../../llm/feature-gate.js";
 import { createProposal, isProposalSkipped, listProposals, } from "../proposal/repository.js";
 import { stripFrontmatterBody as stripBodyForFidelity } from "./dedup.js";
 import { autoRepairLessonFrontmatter, autoSwapDescriptionWhenToUse, collectLessonQualityFindings, repairLessonDescriptionTruncation, } from "./distill/content-repair.js";
@@ -79,6 +80,7 @@ import { fetchTopSimilarLessons, persistOutputEncodingSalience, runLessonQuality
 import { buildClsContext, checkDistillFidelity } from "./distill-guards.js";
 import { deriveKnowledgeRef } from "./distill-promotion-policy.js";
 import { buildRefVocabulary, scoreEncodingSalience } from "./encoding-salience.js";
+import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
 import { computeSalience, upsertAssetSalience } from "./salience.js";
 // Re-exported for `reflect.ts`, which applies the same LLM-as-judge gate to
 // reflect proposals (R-5 / #374).
@@ -474,8 +476,15 @@ export async function akmDistill(options) {
         };
     }
     const config = options.config ?? loadConfig();
+    options = { ...options, improveProfile: options.improveProfile ?? resolveImproveStrategy(undefined, config).config };
     const stash = options.stashDir ?? resolveStashDir();
     const chat = options.chat ?? chatCompletion;
+    const distillLlm = Object.hasOwn(options, "llmConfig")
+        ? (options.llmConfig ?? undefined)
+        : (() => {
+            const runner = resolveImproveProcessRunner(options.improveProfile, "distill", config);
+            return runner ? materializeLlmRunnerConnection(runner) : getDefaultLlmConfig(config);
+        })();
     const lookup = options.lookupFn ?? defaultLookup;
     const readEventsImpl = options.readEventsFn ?? readEvents;
     // R1 opt-out must flow into every computeSalience call this command makes so
@@ -602,6 +611,8 @@ export async function akmDistill(options) {
         assetContent,
         filteredEvents,
         config,
+        strategy: options.improveProfile,
+        llmConfig: distillLlm,
         chat,
         stash,
         lookup,
@@ -684,12 +695,11 @@ export async function akmDistill(options) {
     const distillSchema = effectiveProposalKind === "knowledge" ? DISTILL_KNOWLEDGE_JSON_SCHEMA : DISTILL_LESSON_JSON_SCHEMA;
     let fallbackReason;
     const raw = await tryLlmFeature("distill", config, async () => {
-        const distillLlm = getDefaultLlmConfig(config);
         if (!distillLlm) {
             // No LLM connection configured — treat as gate-disabled. Throwing
             // here lets `tryLlmFeature` route us through the "error" fallback,
             // which is the same graceful skipped path.
-            throw new ConfigError("No LLM connection configured. Set `defaults.llm` and a profile under `profiles.llm`.", "LLM_NOT_CONFIGURED");
+            throw new ConfigError("No LLM engine configured. Set defaults.llmEngine or improve.strategies.<name>.processes.distill.engine.", "LLM_NOT_CONFIGURED");
         }
         // Production path: pass the JSON schema so providers that honour
         // `response_format: json_schema` enforce shape upstream. Providers that
@@ -701,6 +711,7 @@ export async function akmDistill(options) {
         // functions (which return markdown strings) continue to work.
         return chat(distillLlm, messages);
     }, null, {
+        enabled: resolveProcessEnabled("distill", options.improveProfile ?? resolveImproveStrategy(undefined, config).config),
         onFallback: (evt) => {
             fallbackReason = evt.reason;
             // Log the fallback reason; the caller (raw === null path) handles
@@ -822,10 +833,10 @@ export async function akmDistill(options) {
     // D-5 / #388: Three-band system — review_needed band queues a proposal
     // with review_needed outcome rather than auto-rejecting.
     let lessonJudgeConfidence;
-    if (isLlmFeatureEnabled(config, "lesson_quality_gate")) {
+    if (options.improveProfile?.processes?.distill?.qualityGate?.enabled ?? true) {
         // D-4 / #390: retrieve top-3 similar lessons for dedup check in judge.
         const similarLessons = await fetchSimilarLessonsFn(content.slice(0, 500), 3);
-        const judgeResult = await runLessonQualityJudge(config, content, assetContent ?? "", chat, similarLessons.length > 0 ? similarLessons : undefined);
+        const judgeResult = await runLessonQualityJudge(config, content, assetContent ?? "", chat, similarLessons.length > 0 ? similarLessons : undefined, distillLlm);
         if (!judgeResult.pass) {
             if (judgeResult.reviewNeeded) {
                 return writeQualityRejection(stash, inputRef, effectiveLessonRef, content, judgeResult.score, judgeResult.reason, {