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

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

@@ -4,7 +4,7 @@
 import path from "node:path";
 import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { daysToMs } from "../../core/common.js";
-import { loadConfig } from "../../core/config/config.js";
+import { DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE, loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { openLogsDatabase, purgeOldTaskLogs } from "../../core/logs-db.js";
@@ -12,11 +12,11 @@ import { getDbPath } from "../../core/paths.js";
 import { withStateDb } from "../../core/state-db.js";
 import { info, warn } from "../../core/warn.js";
 import { closeDatabase, openIndexDatabase } from "../../indexer/db/db.js";
-import { runGraphExtractionPass } from "../../indexer/graph/graph-extraction.js";
+import { DEFAULT_GRAPH_EXTRACTION_INCLUDE_TYPES, runGraphExtractionPass, } from "../../indexer/graph/graph-extraction.js";
 import { withIndexWriterLease } from "../../indexer/index-writer-lock.js";
 import { collectPendingMemories, runMemoryInferencePass, } from "../../indexer/passes/memory-inference.js";
 import { getWritableStashDirs, resolveSourceEntries } from "../../indexer/search/search-source.js";
-import { resolveImproveProcessRunnerFromProfile } from "../../integrations/agent/runner.js";
+import { materializeLlmRunnerConnection } from "../../integrations/agent/runner.js";
 import { isProcessEnabled } from "../../llm/feature-gate.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
 import { purgeOldCycleMetrics } from "../../storage/repositories/canaries-repository.js";
@@ -31,7 +31,7 @@ import { deriveKnowledgeRef } from "./distill-promotion-policy.js";
 import { findAssetFilePath, isDistillCandidateRef } from "./eligibility.js";
 import { writeEvalCase } from "./eval-cases.js";
 import { makeGateConfig, runAutoAcceptGate } from "./improve-auto-accept.js";
-import { resolveProcessEnabled, shouldSkipRef } from "./improve-profiles.js";
+import { shouldSkipRef } from "./improve-strategies.js";
 // The pre-loop preparation pipeline lives in ./preparation.
 import { maybeAutoTuneThreshold } from "./preparation.js";
 import { akmProcedural } from "./procedural.js";
@@ -41,7 +41,7 @@ import { errMessage, refSlug } from "./shared.js";
 // ── improve loop / post-loop / maintenance stages ───────────────────
 // The cycle stages run by akmImprove, extracted from improve.ts.
 export async function runImproveLoopStage(args) {
-    const { scope, options, primaryStashDir, reflectFn, distillFn, loopRefs, actions, signalBearingSet, distillCooledRefs, distillOnlyRefs, recentErrors, rejectedProposalsByRef, utilityMap, startMs, budgetMs, eventsCtx, improveProfile, } = args;
+    const { scope, options, primaryStashDir, reflectFn, distillFn, loopRefs, actions, signalBearingSet, distillCooledRefs, distillOnlyRefs, recentErrors, rejectedProposalsByRef, utilityMap, startMs, budgetMs, eventsCtx, improveProfile, resolvedPlan, } = args;
     // O-1 (#364): compute remaining budget at call time so each sub-call
     // receives only its fair share of the wall-clock budget.
     const remainingBudgetMs = () => Math.max(0, budgetMs - (Date.now() - startMs));
@@ -206,26 +206,22 @@ export async function runImproveLoopStage(args) {
                     // 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 = remainingBudgetMs();
-                    // Wire profile.processes.reflect.{mode, profile, timeoutMs} into the reflect
-                    // dispatch when present. Falls back to akmReflect's own config-based resolution
-                    // (profiles.improve.<name>.processes.reflect → defaults.llm) when the profile
-                    // does not specify.
-                    const reflectProfileRunner = resolveImproveProcessRunnerFromProfile(improveProfile.processes?.reflect, options.config ?? loadConfig());
+                    // Use the runner frozen in the invocation plan; no leaf re-resolution.
+                    const reflectProfileRunner = resolvedPlan.processes.reflect.runner;
                     const reflectCallArgs = {
                         ref: planned.ref,
                         task: options.task,
-                        // Active profile so reflect's per-process reads honor `--profile`.
+                        // Active strategy supplies non-engine process tuning.
                         ...(improveProfile ? { improveProfile } : {}),
+                        config: options.config,
                         ...(options.stashDir ? { stashDir: options.stashDir } : {}),
                         ...(reflectErrors.length > 0 ? { avoidPatterns: [...reflectErrors] } : {}),
-                        agentProcess: options.agentProcess ?? "reflect",
                         eventSource: "improve",
                         // #639 — resolve the low-value filter from the ACTIVE improve profile
-                        // (default off when unset), so the running profile decides instead of
-                        // a hardcoded profiles.improve.default path.
+                        // (default off when unset), so the running strategy decides.
                         lowValueFilter: improveProfile.processes?.reflect?.lowValueFilter?.enabled === true,
                         ...(reflectBudgetMs > 0 ? { timeoutMs: reflectBudgetMs } : {}),
-                        ...(reflectProfileRunner ? { runner: reflectProfileRunner } : {}),
+                        runner: reflectProfileRunner ?? null,
                         // Attribution: carry the eligibility lane so reflect stamps it on
                         // the reflect_invoked event and the persisted proposal.
                         ...(planned.eligibilitySource ? { eligibilitySource: planned.eligibilitySource } : {}),
@@ -241,11 +237,19 @@ export async function runImproveLoopStage(args) {
                             if (remainingBudgetMs() <= 0)
                                 break;
                             // draftMode: skip DB write so each sample doesn't create a proposal.
-                            samples.push(await withLlmStage("reflect", () => reflectFn({ ...reflectCallArgs, draftMode: true })));
+                            samples.push(await withLlmStage("reflect", () => reflectFn({ ...reflectCallArgs, draftMode: true }), {
+                                engine: resolvedPlan.processes.reflect.runner?.engine,
+                                process: "reflect",
+                            }));
                         }
                         const winner = pickMajorityVote(samples.length > 0
                             ? samples
-                            : [await withLlmStage("reflect", () => reflectFn({ ...reflectCallArgs, draftMode: true }))]);
+                            : [
+                                await withLlmStage("reflect", () => reflectFn({ ...reflectCallArgs, draftMode: true }), {
+                                    engine: resolvedPlan.processes.reflect.runner?.engine,
+                                    process: "reflect",
+                                }),
+                            ]);
                         // Persist only the majority-vote winner as a single real proposal.
                         if (winner.ok && primaryStashDir) {
                             const persistResult = createProposal(primaryStashDir, {
@@ -259,11 +263,12 @@ export async function runImproveLoopStage(args) {
                             });
                             reflectResult = isProposalSkipped(persistResult)
                                 ? {
-                                    schemaVersion: 1,
+                                    schemaVersion: 2,
                                     ok: false,
                                     reason: "cooldown",
                                     error: `SC proposal skipped: ${persistResult.message}`,
                                     ref: winner.ref,
+                                    engine: winner.engine,
                                     exitCode: null,
                                 }
                                 : { ...winner, proposal: persistResult };
@@ -273,7 +278,10 @@ export async function runImproveLoopStage(args) {
                         }
                     }
                     else {
-                        reflectResult = await withLlmStage("reflect", () => reflectFn(reflectCallArgs));
+                        reflectResult = await withLlmStage("reflect", () => reflectFn(reflectCallArgs), {
+                            engine: resolvedPlan.processes.reflect.runner?.engine,
+                            process: "reflect",
+                        });
                     }
                     const isCooldown = !reflectResult.ok && reflectResult.reason === "cooldown";
                     // Content-policy guard hits (reflect size-rail rejections) are NOT
@@ -327,7 +335,7 @@ export async function runImproveLoopStage(args) {
                         metadata: {
                             ok: reflectResult.ok,
                             durationMs: reflectResult.ok ? reflectResult.durationMs : undefined,
-                            agentProfile: reflectResult.ok ? reflectResult.agentProfile : undefined,
+                            engine: reflectResult.engine,
                             reason: reflectResult.ok ? undefined : reflectResult.reason,
                         },
                     }, eventsCtx);
@@ -478,10 +486,14 @@ export async function runImproveLoopStage(args) {
                     ...(options.stashDir ? { stashDir: options.stashDir } : {}),
                     // 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,
                     // Attribution: carry the eligibility lane so distill stamps it on the
                     // distill_invoked event and the persisted proposal.
                     ...(planned.eligibilitySource ? { eligibilitySource: planned.eligibilitySource } : {}),
-                }));
+                }), { engine: resolvedPlan.processes.distill.runner?.engine, process: "distill" });
                 actions.push({ ref: planned.ref, mode: "distill", result: distillResult });
                 if (distillResult.outcome === "queued" && distillResult.proposal) {
                     const distillGr = await runAutoAcceptGate([{ proposalId: distillResult.proposal.id, confidence: distillResult.proposal.confidence }], distillGateCfg);
@@ -593,7 +605,7 @@ export async function runImproveLoopStage(args) {
     return { reflectsWithErrorContext, memoryRefsForInference, gateAutoAcceptedCount, gateAutoAcceptFailedCount };
 }
 export async function runImprovePostLoopStage(args) {
-    const { scope, options, primaryStashDir, actionableRefs, appliedCleanup, cleanupWarnings, memoryRefsForInference, reindexFn, eventsCtx, budgetSignal, improveProfile, consolidationRan, } = args;
+    const { scope, options, primaryStashDir, actionableRefs, appliedCleanup, cleanupWarnings, memoryRefsForInference, reindexFn, eventsCtx, budgetSignal, improveProfile, resolvedPlan, consolidationRan, } = args;
     const allWarnings = [...cleanupWarnings, ...(appliedCleanup?.warnings ?? [])];
     info("[improve] post-loop maintenance starting");
     const maintenanceResult = await runImproveMaintenancePasses({
@@ -608,6 +620,7 @@ export async function runImprovePostLoopStage(args) {
         budgetSignal,
         eventsCtx,
         improveProfile,
+        resolvedPlan,
     });
     let deadUrls;
     if (scope.mode === "all" && primaryStashDir && actionableRefs.length > 0) {
@@ -641,15 +654,18 @@ export async function runImprovePostLoopStage(args) {
     let recombination;
     if (primaryStashDir &&
         improveProfile &&
-        resolveProcessEnabled("recombine", improveProfile) &&
+        resolvedPlan?.processes.recombine.enabled === true &&
         scope.mode !== "ref" &&
         !options.dryRun) {
         const recombineFn = options.recombineFn ?? akmRecombine;
         try {
-            recombination = await recombineFn({
+            recombination = await withLlmStage("recombine", () => recombineFn({
                 stashDir: primaryStashDir,
                 config: options.config ?? loadConfig(),
                 improveProfile,
+                llmConfig: resolvedPlan?.processes.recombine.runner
+                    ? materializeLlmRunnerConnection(resolvedPlan.processes.recombine.runner)
+                    : null,
                 ...(options.runId ? { sourceRun: options.runId } : {}),
                 ...(budgetSignal ? { signal: budgetSignal } : {}),
                 eligibilitySource: "recombine",
@@ -662,7 +678,7 @@ export async function runImprovePostLoopStage(args) {
                 maxClusterSize: improveProfile.processes?.recombine?.maxClusterSize,
                 excludeTags: improveProfile.processes?.recombine?.excludeTags,
                 excludeEntities: improveProfile.processes?.recombine?.excludeEntities,
-            });
+            }), { engine: resolvedPlan?.processes.recombine.runner?.engine, process: "recombine" });
         }
         catch (e) {
             allWarnings.push(`recombine: ${String(e)}`);
@@ -675,22 +691,25 @@ export async function runImprovePostLoopStage(args) {
     let proceduralCompilation;
     if (primaryStashDir &&
         improveProfile &&
-        resolveProcessEnabled("procedural", improveProfile) &&
+        resolvedPlan?.processes.procedural.enabled === true &&
         scope.mode !== "ref" &&
         !options.dryRun) {
         const proceduralFn = options.proceduralFn ?? akmProcedural;
         try {
-            proceduralCompilation = await proceduralFn({
+            proceduralCompilation = await withLlmStage("procedural", () => proceduralFn({
                 stashDir: primaryStashDir,
                 config: options.config ?? loadConfig(),
                 ...(improveProfile ? { improveProfile } : {}),
+                llmConfig: resolvedPlan?.processes.procedural.runner
+                    ? materializeLlmRunnerConnection(resolvedPlan.processes.procedural.runner)
+                    : null,
                 ...(options.runId ? { sourceRun: options.runId } : {}),
                 ...(budgetSignal ? { signal: budgetSignal } : {}),
                 eligibilitySource: "procedural",
                 ...(eventsCtx ? { ctx: eventsCtx } : {}),
                 minRecurrence: improveProfile.processes?.procedural?.minRecurrence,
                 maxProposalsPerRun: improveProfile.processes?.procedural?.maxProposalsPerRun,
-            });
+            }), { engine: resolvedPlan?.processes.procedural.runner?.engine, process: "procedural" });
         }
         catch (e) {
             allWarnings.push(`procedural: ${String(e)}`);
@@ -746,7 +765,7 @@ export async function runImprovePostLoopStage(args) {
 // Exported for tests (#584/#585 DB-locking regression coverage); production
 // callers reach it only through akmImprove → runImprovePostLoopStage.
 export async function runImproveMaintenancePasses(args) {
-    const { options, primaryStashDir, memoryRefsForInference, allWarnings, reindexFn, consolidationRan, budgetSignal, eventsCtx, improveProfile, } = args;
+    const { options, primaryStashDir, memoryRefsForInference, allWarnings, reindexFn, consolidationRan, budgetSignal, eventsCtx, improveProfile, resolvedPlan, } = args;
     if (!primaryStashDir)
         return { memoryInferenceDurationMs: 0, graphExtractionDurationMs: 0 };
     const config = options.config ?? loadConfig();
@@ -825,6 +844,13 @@ export async function runImproveMaintenancePasses(args) {
                     // O-1 (#364): pass budget signal so a hung inference call is cancelled.
                     memoryInference = await withLlmStage("memory-inference", () => memoryInferenceFn({
                         config,
+                        ...(resolvedPlan
+                            ? {
+                                llmConfig: resolvedPlan.processes.memoryInference.runner
+                                    ? materializeLlmRunnerConnection(resolvedPlan.processes.memoryInference.runner)
+                                    : null,
+                            }
+                            : {}),
                         sources,
                         signal: budgetSignal,
                         db,
@@ -833,7 +859,7 @@ export async function runImproveMaintenancePasses(args) {
                             const current = event.currentRef ? ` ${event.currentRef}` : "";
                             info(`[improve] memory inference ${event.processed}/${event.total}${current} (written ${event.writtenFacts}, skipped ${event.skippedNoFacts})`);
                         },
-                    }));
+                    }), { engine: resolvedPlan?.processes.memoryInference.runner?.engine, process: "memoryInference" });
                     memoryInferenceDurationMs = Date.now() - inferenceStart;
                     actions.push({ ref: "memory:_inference", mode: "memory-inference", result: memoryInference });
                     info(`[improve] memory inference complete (${memoryInference.writtenFacts} facts written from ${memoryInference.splitParents} parents)`);
@@ -854,12 +880,16 @@ export async function runImproveMaintenancePasses(args) {
                     allWarnings.push(`reindex after memory inference failed: ${errMessage(err)}`);
                 }
             }
-            const graphEnabled = isProcessEnabled("index", "graph_extraction", config);
+            const graphEnabled = resolvedPlan ? true : isProcessEnabled("index", "graph_extraction", config);
             const graphExtractionDisabledByProfile = improveProfile?.processes?.graphExtraction?.enabled === false;
             const graphExtractionFullScan = improveProfile?.processes?.graphExtraction?.fullScan === true;
             // #624 P2: optional incremental high-signal-first cap. Unset = process all
             // eligible (byte-identical to today; no ranking/slice).
             const graphExtractionTopN = improveProfile?.processes?.graphExtraction?.topN;
+            const graphExtractionIncludeTypes = improveProfile?.processes?.graphExtraction?.includeTypes ?? [
+                ...DEFAULT_GRAPH_EXTRACTION_INCLUDE_TYPES,
+            ];
+            const graphExtractionBatchSize = improveProfile?.processes?.graphExtraction?.batchSize ?? DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE;
             // Build the set of refs actually touched this run.
             const touchedRefs = new Set();
             for (const r of args.actionableRefs)
@@ -916,13 +946,25 @@ export async function runImproveMaintenancePasses(args) {
                     // O-1 (#364): pass budget signal so a hung graph extraction call is cancelled.
                     graphExtraction = await withLlmStage("graph-extraction", () => graphExtractionFn({
                         config,
+                        ...(resolvedPlan
+                            ? {
+                                llmConfig: resolvedPlan.processes.graphExtraction.runner
+                                    ? materializeLlmRunnerConnection(resolvedPlan.processes.graphExtraction.runner)
+                                    : null,
+                            }
+                            : {}),
                         sources,
                         signal: budgetSignal,
                         db,
                         reEnrich: false,
                         onProgress: progressHandler,
-                        options: { candidatePaths, ...(graphExtractionTopN != null ? { topN: graphExtractionTopN } : {}) },
-                    }));
+                        options: {
+                            candidatePaths,
+                            includeTypes: graphExtractionIncludeTypes,
+                            batchSize: graphExtractionBatchSize,
+                            ...(graphExtractionTopN != null ? { topN: graphExtractionTopN } : {}),
+                        },
+                    }), { engine: resolvedPlan?.processes.graphExtraction.runner?.engine, process: "graphExtraction" });
                     graphExtractionDurationMs = Date.now() - extractionStart;
                     actions.push({ ref: "graph:_artifact", mode: "graph-extraction", result: graphExtraction });
                     info(`[improve] graph extraction complete (${graphExtraction.quality.extractedFiles} files, ${graphExtraction.quality.entityCount} entities, ${graphExtraction.quality.relationCount} relations)`);

package/dist/commands/improve/memory/memory-belief.js

@@ -28,6 +28,25 @@
  * - MemOS (arXiv:2507.03724) — formal archive/merge/transition with shared state model
  */
 import { mutateFrontmatter } from "../../../core/asset/frontmatter.js";
+// ── Shared edge-list reader ───────────────────────────────────────────────────
+/**
+ * Read a frontmatter edge value (`supersededBy` / `contradictedBy`) as a
+ * string list, promoting a scalar string to a one-element list.
+ *
+ * Scalar edges are LIVE data: the indexer's `normalizeNonEmptyStringList`
+ * accepts them and lint deliberately never flags them. An Array.isArray-only
+ * read treats a scalar as "no existing edges" and silently destroys the edge
+ * on the next merge — mirror `mergeXrefsIntoContent`'s scalar promotion
+ * instead.
+ */
+function readEdgeList(value) {
+    if (Array.isArray(value)) {
+        return value.filter((v) => typeof v === "string" && v.trim().length > 0);
+    }
+    if (typeof value === "string" && value.trim())
+        return [value.trim()];
+    return [];
+}
 // ── Contradiction edge writer ─────────────────────────────────────────────────
 /**
  * Write `contradictedBy` and `beliefState: contradicted` edges to a memory
@@ -38,24 +57,77 @@ import { mutateFrontmatter } from "../../../core/asset/frontmatter.js";
  *   - `memory-contradiction-detect.ts` for the M-1 automated contradiction pass
  *   - `resolveFamilyContradictions` in `memory-improve.ts` for SCC resolution
  *
- * Idempotent: if the `contradictedByRef` is already in `contradictedBy`,
- * the file is not rewritten.
+ * Idempotent: if the `contradictedByRef` is already in `contradictedBy` AND
+ * the file already carries the demotion state, the file is not rewritten. The
+ * guard is state-aware like its sibling {@link writeSupersededEdge}: an edge
+ * present WITHOUT the demotion (e.g. a hand-written `contradictedBy:` line,
+ * or a beliefState lost to a partial edit) is repaired, not skipped — an
+ * edge-only guard would make such a file a permanent no-op while
+ * consolidate's handleContradictOp reports the contradiction as applied.
+ *
+ * Never weakens a stronger demotion: `archived` ranks BELOW `contradicted`
+ * (see `BELIEF_STATE_SCORE_CEILINGS` in
+ * src/indexer/search/ranking-contributors.ts), so contradicting an archived
+ * memory keeps `archived` and only appends the edge.
  *
  * @param filePath          - Absolute path to the memory markdown file.
  * @param contradictedByRef - The ref that contradicts this memory.
  */
 export function writeContradictEdge(filePath, contradictedByRef) {
     mutateFrontmatter(filePath, (parsed) => {
-        const existing = Array.isArray(parsed.data.contradictedBy)
-            ? parsed.data.contradictedBy
-            : [];
-        if (existing.includes(contradictedByRef))
+        const existing = readEdgeList(parsed.data.contradictedBy);
+        const currentState = parsed.data.beliefState;
+        const nextState = currentState === "archived" ? currentState : "contradicted";
+        if (existing.includes(contradictedByRef) && currentState === nextState) {
             return null; // Already written — idempotent.
+        }
         const nextContradictedBy = [...new Set([...existing, contradictedByRef])].sort();
         return {
             ...parsed.data,
             contradictedBy: nextContradictedBy,
-            beliefState: "contradicted",
+            beliefState: nextState,
+        };
+    });
+}
+// ── Supersession edge writer ─────────────────────────────────────────────────
+/**
+ * Write `supersededBy` and `beliefState: superseded` edges to an asset file's
+ * frontmatter (SPEC-5, stash-conventions-code-spec.md).
+ *
+ * Sibling of {@link writeContradictEdge}: the shared primitive for the
+ * conventions' corrections pattern — when a new asset supersedes an old one,
+ * the old asset gets a METADATA-ONLY demotion edit (every other frontmatter
+ * key and the body are preserved) so the ranker's beliefStateBoost demotes the
+ * stale incumbent and `--belief current` hides it. Used by
+ * `akm remember --supersedes` / `akm import --supersedes`.
+ *
+ * Idempotent: if `supersededByRef` is already in `supersededBy` and the file
+ * is already demoted, the file is not rewritten. Multiple corrections
+ * sorted-set-append their refs.
+ *
+ * Never WEAKENS an existing demotion: `contradicted` and `archived` rank
+ * BELOW `superseded` (severity order deprecated > superseded > contradicted >
+ * archived — see `BELIEF_STATE_SCORE_CEILINGS` in
+ * src/indexer/search/ranking-contributors.ts), so superseding an already
+ * contradicted/archived asset keeps the stronger state and only appends the
+ * `supersededBy` edge.
+ *
+ * @param filePath        - Absolute path to the asset markdown file.
+ * @param supersededByRef - The ref of the correction that supersedes this asset.
+ */
+export function writeSupersededEdge(filePath, supersededByRef) {
+    mutateFrontmatter(filePath, (parsed) => {
+        const existing = readEdgeList(parsed.data.supersededBy);
+        const currentState = parsed.data.beliefState;
+        const nextState = currentState === "contradicted" || currentState === "archived" ? currentState : "superseded";
+        if (existing.includes(supersededByRef) && currentState === nextState) {
+            return null; // Already written — idempotent.
+        }
+        const nextSupersededBy = [...new Set([...existing, supersededByRef])].sort();
+        return {
+            ...parsed.data,
+            supersededBy: nextSupersededBy,
+            beliefState: nextState,
         };
     });
 }

package/dist/commands/improve/memory/memory-contradiction-detect.js

@@ -22,7 +22,7 @@
  *
  * # LLM Feature Gate
  *
- * The pass is gated behind `profiles.improve.default.processes.consolidate.contradictionDetection.enabled`.
+ * The pass is gated by the selected strategy's consolidate contradiction setting.
  * When the gate is disabled or no LLM is configured,
  * the pass is a no-op and `analyzeMemoryCleanup` proceeds with only manually
  * annotated edges.
@@ -38,6 +38,7 @@ import path from "node:path";
 import contradictionJudgeTemplate from "../../../assets/prompts/contradiction-judge.md" with { type: "text" };
 import { mutateFrontmatter, parseFrontmatter } from "../../../core/asset/frontmatter.js";
 import { getDefaultLlmConfig } from "../../../core/config/config.js";
+import { materializeLlmRunnerConnection, resolveImproveProcessRunner } from "../../../integrations/agent/runner.js";
 import { chatCompletion, parseEmbeddedJsonResponse } from "../../../llm/client.js";
 import { tryLlmFeature } from "../../../llm/feature-gate.js";
 // ── Constants ────────────────────────────────────────────────────────────────
@@ -173,14 +174,20 @@ function pickContradictionLoser(a, b) {
  * @param config   - Loaded AKM config (used to access LLM settings).
  * @param chat     - Optional chat seam for testing (defaults to chatCompletion).
  */
-export async function detectAndWriteContradictions(stashDir, config, chat = chatCompletion) {
+export async function detectAndWriteContradictions(stashDir, config, chat = chatCompletion, strategy, resolvedLlmConfig) {
     const result = {
         familiesExamined: 0,
         pairsChecked: 0,
         edgesWritten: 0,
         warnings: [],
     };
-    const contradictionLlm = getDefaultLlmConfig(config);
+    const contradictionLlm = resolvedLlmConfig === null
+        ? undefined
+        : (resolvedLlmConfig ??
+            (() => {
+                const runner = resolveImproveProcessRunner(strategy, "consolidate", config);
+                return runner ? materializeLlmRunnerConnection(runner) : getDefaultLlmConfig(config);
+            })());
     if (!contradictionLlm)
         return result;
     // Collect derived memories grouped by parent.
@@ -254,7 +261,8 @@ export async function detectAndWriteContradictions(stashDir, config, chat = chat
                         { role: "system", content: "Return only valid JSON. No prose." },
                         { role: "user", content: prompt },
                     ]);
-                }, null);
+                }, null, // Fallback: null means "skip" — gate disabled or LLM call failed.
+                { enabled: strategy?.processes?.consolidate?.contradictionDetection?.enabled ?? false });
                 totalPairsChecked++;
                 result.pairsChecked++;
                 if (!judgeResult)