akm-cli 0.10.261012-beta → 0.10.261014-beta

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

@@ -7,7 +7,7 @@
  * `finalizeImproveResult` persists on a live run (`improve-usage-report.ts`),
  * so the command and the end-of-run stderr table stay byte-identical in
  * structure. A row with no persisted `usageReport` degrades rather than
- * errors, per AGENTS.md's "reader must tolerate data older releases wrote":
+ * errors (a reader must tolerate data older releases wrote):
  * its cross-tab is recomputed from the run's own `llm_usage` events and a
  * `notes` entry explains why — either the row predates #944, or (per
  * `recordTerminatedImproveRun` in improve-result-file.ts) the run was

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

@@ -4,12 +4,12 @@
 import consolidate from "../../assets/improve-strategies/consolidate.json" with { type: "json" };
 import defaultStrategy from "../../assets/improve-strategies/default.json" with { type: "json" };
 import { conceptIdFromTypeName, parseRefInput } from "../../core/asset/resolve-ref.js";
+import { ambiguousDefaultAdvice, } from "../../core/config/config.js";
 import { ImproveProfileConfigSchema } from "../../core/config/config-schema.js";
 import { deepMergeConfig } from "../../core/config/deep-merge.js";
 import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_ENGINE_PROCESSES, IMPROVE_PROCESS_NAMES, REMOVED_IMPROVE_STRATEGY_NAMES, } from "../../core/config/engine-semantics.js";
+import { SHIPPED_ALIAS } from "../../core/config/model-aliases.js";
 import { ConfigError } from "../../core/errors.js";
-import { describeLlmCredentialAvailability, } from "../../integrations/agent/engine-resolution.js";
-import { runnerLlmConnection } from "../../integrations/agent/runner.js";
 import { applyAutonomyGate } from "./autonomy-gate.js";
 import { resolveImproveExecution } from "./execution.js";
 import { stripBundle } from "./ledger.js";
@@ -70,7 +70,7 @@ if (BUILTIN_IMPROVE_STRATEGY_NAMES.some((name) => !(name in BUILTIN_STRATEGIES))
     throw new Error("Built-in improve strategy names are out of sync with their assets");
 }
 export function resolveImproveStrategy(name, config) {
-    const selectedName = name ?? config.defaults?.improveStrategy ?? "default";
+    const selectedName = name ?? config.improve?.strategy ?? "default";
     const userStrategies = config.improve?.strategies ?? {};
     // graph-refresh named a specific, common retirement — refuse it
     // unconditionally, even when `improve.strategies["graph-refresh"]` still
@@ -111,16 +111,15 @@ export function resolveImproveStrategy(name, config) {
 }
 /**
  * The processes that make their own model calls, so the plan resolves a runner
- * for each: every engine process but triage, whose engine is its judgment's.
+ * for each: every process that makes a model call but triage, whose connection or harness is its judgment's.
  */
 export const MODEL_CALLING_PROCESSES = new Set(IMPROVE_ENGINE_PROCESSES.filter((name) => name !== "triage"));
 /**
  * Project a resolved improve plan into one routing row per
  * {@link IMPROVE_PROCESS_NAMES} name, plus a `"triage.judgment"`
- * pseudo-row when the strategy configures a judgment engine. Pure — no I/O,
+ * pseudo-row when the strategy configures a judgment connection or harness. Pure — no I/O,
  * no re-resolution. Shared by `improve --dry-run`'s `plan.processes` (#947)
- * and `akm health`'s post-run reporting (#944); health's own
- * `active-improve-strategy` check keeps its existing `engines` shape.
+ * and `akm health`'s post-run reporting (#944).
  */
 export function projectResolvedProcessRouting(plan) {
     const unavailableByProcess = new Map(plan.engineUnavailable.map((item) => [item.process, item]));
@@ -133,20 +132,11 @@ export function projectResolvedProcessRouting(plan) {
             enabled: process.enabled,
             ...(process.runner
                 ? {
-                    engine: process.runner.engine,
-                    model: runnerLlmConnection(process.runner)?.model,
+                    engine: process.runner.name,
+                    ...(process.runner.model !== undefined ? { model: process.runner.model } : {}),
                     engineKind: process.runner.kind,
                 }
-                : // #800/#957 round 3 — a credential-unavailable process never carries a
-                    // runner, but its structurally resolved engine/model is still worth
-                    // showing in the routing table (dry-run preview, health probe).
-                    unavailable?.engine
-                        ? {
-                            engine: unavailable.engine,
-                            ...(unavailable.model ? { model: unavailable.model } : {}),
-                            engineKind: "llm",
-                        }
-                        : {}),
+                : {}),
             notices: process.notices ?? [],
             ...(unavailable ? { unavailable: { configKey: unavailable.configKey, reason: unavailable.reason } } : {}),
         });
@@ -158,9 +148,9 @@ export function projectResolvedProcessRouting(plan) {
             enabled: plan.triageJudgment !== null,
             ...(plan.triageJudgment
                 ? {
-                    engine: plan.triageJudgment.engine,
+                    engine: plan.triageJudgment.name,
                     engineKind: plan.triageJudgment.kind,
-                    ...(plan.triageJudgment.kind === "llm" ? { model: plan.triageJudgment.connection.model } : {}),
+                    ...(plan.triageJudgment.model !== undefined ? { model: plan.triageJudgment.model } : {}),
                 }
                 : {}),
             notices: plan.triageJudgmentNotices ?? [],
@@ -193,39 +183,9 @@ export function resolveImprovePlan(name, config, options = {}) {
     const strategy = { name: selected.name, config: gatedStrategyConfig };
     return { ...buildImprovePlan(strategy, config, options), autonomyGated: gated };
 }
-/** Describe why a resolved-but-uncredentialed runner belongs in `engineUnavailable` (#957). */
-function credentialUnavailableReason(engineName, status) {
-    return `requires a credential that is not available in this process's environment (engine "${engineName}": ${status.reason})`;
-}
-/**
- * Whether the credential akm reads for `runner` is reachable in `env`: an LLM
- * engine's own, or an SDK engine's LLM fallback. An agent CLI reads its own.
- */
-function runnerCredentialStatus(runner, env) {
-    if (runner.kind === "llm")
-        return describeLlmCredentialAvailability(runner, env);
-    if (runner.kind === "sdk") {
-        return describeLlmCredentialAvailability({
-            credential: runner.fallbackCredential,
-            apiKeyFile: runner.fallbackApiKeyFile,
-            apiKeySecretRef: runner.fallbackApiKeySecretRef,
-        }, env);
-    }
-    return { available: true };
-}
 function buildImprovePlan(strategy, config, options) {
-    const env = options.env ?? process.env;
     const processes = {};
     const engineUnavailable = [];
-    // #957 round 2 — distinguishes "credential unavailable" (a working engine
-    // whose secret isn't in this environment) from "no engine selected at all"
-    // among the pushes below, so `allowAllDisabled` can bypass the ConfigError
-    // only for the former. The latter is the guard's original, pre-#957
-    // condition and must keep hard-aborting for every caller, including a
-    // health probe with `allowAllDisabled` set — a totally unconfigured
-    // install is not the credential-in-the-wrong-environment case this option
-    // exists for.
-    let anyEngineNotConfigured = false;
     for (const processName of IMPROVE_PROCESS_NAMES) {
         const sourceProcessConfig = strategy.config.processes?.[processName] ?? {};
         const enabled = sourceProcessConfig.enabled === true;
@@ -238,49 +198,22 @@ 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.
         const skipsRepairEngine = processName === "validation" && options.repairValidationFailures === false;
-        // #957: a resolved-but-uncredentialed runner is folded into the same
-        // "no engine" branch below — set here so the shared push/continue block
-        // can tell the two apart in its reason text.
-        let credentialUnavailableMessage;
-        // #800/#957 round 3 — the structurally resolved engine/model/contextLength
-        // for the credential-unavailable case only, so a dry-run preview can read
-        // what resolution decided (e.g. the consolidation chunk-size estimate)
-        // without the runner ever carrying a credential-less connection forward.
-        let credentialUnavailableRouting;
         if (!skipsRepairEngine) {
             const resolved = resolveImproveExecution({
                 config,
-                profile: strategy.config,
-                process: sourceProcessConfig,
                 processName,
+                alias: SHIPPED_ALIAS.improve,
+                ...(options.run ? { run: options.run } : {}),
             });
             runner = resolved?.runner ?? null;
             notices = resolved?.notices ?? [];
-            if (runner) {
-                const credentialStatus = runnerCredentialStatus(runner, env);
-                if (!credentialStatus.available) {
-                    const connection = runnerLlmConnection(runner);
-                    credentialUnavailableMessage = credentialUnavailableReason(runner.engine, credentialStatus);
-                    credentialUnavailableRouting = {
-                        engine: runner.engine,
-                        ...(connection?.model !== undefined ? { model: connection.model } : {}),
-                        ...(connection?.contextLength !== undefined ? { contextLength: connection.contextLength } : {}),
-                    };
-                    runner = null;
-                    notices = [];
-                }
-            }
         }
         if (!runner && !skipsRepairEngine) {
-            const configKey = `improve.strategies.${strategy.name}.processes.${processName}.engine`;
-            if (!credentialUnavailableMessage)
-                anyEngineNotConfigured = true;
+            const configKey = `improve.processes.${processName}.connection`;
             engineUnavailable.push({
                 process: processName,
                 configKey,
-                reason: credentialUnavailableMessage ??
-                    `requires an engine that is not configured. Set defaults.llmEngine or ${configKey}`,
-                ...credentialUnavailableRouting,
+                reason: `requires a connection or harness that is not configured. Run \`akm setup\`, or set ${configKey}`,
             });
             processes[processName] = Object.freeze({
                 enabled: false,
@@ -299,43 +232,26 @@ function buildImprovePlan(strategy, config, options) {
         });
     }
     if (engineUnavailable.length > 0 &&
-        // proactiveMaintenance uses no engine: it is a selector, so it alone does not keep a run alive.
-        !IMPROVE_ENGINE_PROCESSES.some((name) => processes[name].enabled) &&
-        (!options.allowAllDisabled || anyEngineNotConfigured)) {
+        // Triage without its judgment and proactiveMaintenance make no model call: they alone do not keep a run alive.
+        ![...MODEL_CALLING_PROCESSES].some((name) => processes[name].enabled)) {
         const names = engineUnavailable.map((item) => `"${item.process}"`).join(", ");
-        throw new ConfigError(`No improve process can run: ${names} ${engineUnavailable.length === 1 ? "requires" : "require"} an engine that is not configured. Set defaults.llmEngine, or the per-process engine key named for each.`, "LLM_NOT_CONFIGURED");
+        const ambiguous = ambiguousDefaultAdvice(config);
+        throw new ConfigError(`No improve process can run: ${names} ${engineUnavailable.length === 1 ? "requires" : "require"} a connection or harness that ${ambiguous ? "has no default to run on" : "is not configured"}. ${ambiguous ? `${ambiguous}.` : "Run `akm setup`, or set improve.connection or improve.harness."}`, "LLM_NOT_CONFIGURED");
     }
     const triage = strategy.config.processes?.triage;
     const judgmentEnabled = triage?.judgment?.enabled === true;
     const triageJudgmentResolution = processes.triage.enabled && judgmentEnabled
         ? resolveImproveExecution({
             config,
-            profile: strategy.config,
-            process: triage,
-            current: triage.judgment,
+            process: "triage",
             processName: "triage-judgment",
+            alias: SHIPPED_ALIAS.judge,
+            ...(options.run ? { run: options.run } : {}),
         })
         : null;
-    let triageJudgment = triageJudgmentResolution?.runner ?? null;
+    const triageJudgment = triageJudgmentResolution?.runner ?? null;
     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");
-    }
-    // #957: same credential-unavailable treatment as the main per-process loop
-    // above — a triage judgment engine that resolves structurally but whose
-    // credential (or, for an SDK judgment, its LLM fallback credential) is
-    // unavailable in this process's environment is folded into
-    // `engineUnavailable` under the reserved `"triage.judgment"` process name
-    // instead of silently reaching dispatch with a doomed credential.
-    if (triageJudgment) {
-        const credentialStatus = runnerCredentialStatus(triageJudgment, env);
-        if (!credentialStatus.available) {
-            engineUnavailable.push({
-                process: "triage.judgment",
-                configKey: `improve.strategies.${strategy.name}.processes.triage.judgment.engine`,
-                reason: credentialUnavailableReason(triageJudgment.engine, credentialStatus),
-            });
-            triageJudgment = null;
-        }
+        throw new ConfigError(`Enabled improve triage judgment requires a connection or harness. Run \`akm setup\`, or set improve.connection or improve.processes.triage.connection.`, "LLM_NOT_CONFIGURED");
     }
     const frozenProcesses = Object.freeze(processes);
     const frozenStrategy = Object.freeze({
@@ -350,6 +266,7 @@ function buildImprovePlan(strategy, config, options) {
         strategy: frozenStrategy,
         processes: frozenProcesses,
         triageJudgment: triageJudgment ? cloneAndFreeze(triageJudgment) : null,
+        ...(options.run ? { run: cloneAndFreeze(options.run) } : {}),
         ...(triageJudgmentResolution?.notices.length
             ? { triageJudgmentNotices: cloneAndFreeze(triageJudgmentResolution.notices) }
             : {}),

package/dist/commands/improve/improve.js

@@ -10,6 +10,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
 import { bundlesToSourceEntries, loadConfig } from "../../core/config/config.js";
+import { collectCredentialValues } from "../../core/config/credentials.js";
 import { ConfigError, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { classifyImproveAction, foldDistillSkipped } from "../../core/improve-types.js";
@@ -20,12 +21,12 @@ import { openStateDatabase } from "../../core/state-db.js";
 import { info, warn, warnVerbose } from "../../core/warn.js";
 import { beginWriteProvenance, relativeWrittenPath } from "../../core/write-provenance.js";
 import { resolveWorkingStashTarget, resolveWritable, resolveWriteTarget } from "../../core/write-source.js";
+import { noticeSet } from "../../execution/notices.js";
 import { ensureIndex } from "../../indexer/ensure-index.js";
 import { indexWrittenAssets } from "../../indexer/index-written-assets.js";
 import { akmIndex } from "../../indexer/indexer.js";
 import { countPendingMemoriesNeedingDecision } from "../../indexer/passes/memory-inference.js";
 import { resolveEntryContentDir, resolveSourceEntries } from "../../indexer/search/search-source.js";
-import { collectEngineCredentialValues } from "../../integrations/agent/engine-resolution.js";
 import { installLlmUsagePersistence } from "../../llm/usage-persist.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
 import { GitStashPushError, isGitBackedStash, listGitChangedPaths, resolveWritableOverride, saveGitStash, } from "../../sources/providers/git.js";
@@ -47,7 +48,7 @@ import { analyzeMemoryCleanup, purgeGracedArchive, RETIRE_GRACE_DAYS, } from "./
 import { buildImproveExecutionPlan } from "./planner.js";
 import { CONSOLIDATION_CONFIG_KEYS, pickDefined, recordImproveSkip, runImprovePreparationStage } from "./preparation.js";
 import { akmReflect } from "./reflect.js";
-import { errMessage, noticeSet } from "./stage.js";
+import { errMessage } from "./stage.js";
 export { runImproveMaintenancePasses } from "./loop-stages.js";
 export function renderSyncCommitMessage(template, result, nowMs) {
     const iso = new Date(nowMs).toISOString();
@@ -65,7 +66,7 @@ export function renderSyncCommitMessage(template, result, nowMs) {
     return template.replace(/\{(\w+)\}/g, (match, key) => tokens[key] ?? match);
 }
 /**
- * How long the loop waits for its first engine response before printing one
+ * How long the loop waits for its first model response before printing one
  * "still waiting" line (#957): a dead endpoint otherwise looks like a slow run.
  * Armed when the loop starts, not at run start.
  */
@@ -109,7 +110,7 @@ export async function akmImprove(options = {}) {
     const { budgetMs, budgetAbortController, scope, selectedStrategy, syncRepoDir, resolvedStateDbPath } = setup;
     let clearBudgetTimer = () => { };
     let clearFirstResponseHeartbeat = () => { };
-    // Set by the usage sink when any engine call terminates, prepass included.
+    // Set by the usage sink when any model call terminates, prepass included.
     let firstEngineResponseSeen = false;
     let initialGitPaths = new Set();
     let preRunSync;
@@ -253,7 +254,7 @@ export async function akmImprove(options = {}) {
         }
         if (!firstEngineResponseSeen) {
             const firstResponseTimer = setTimeout(() => {
-                warn("[improve] Still waiting for the first engine response...");
+                warn("[improve] Still waiting for the first model response...");
             }, FIRST_ENGINE_RESPONSE_HEARTBEAT_MS);
             firstResponseTimer.unref?.();
             clearFirstResponseHeartbeat = () => clearTimeout(firstResponseTimer);
@@ -360,12 +361,8 @@ function resolveImproveRunSetup(options) {
     const scope = resolveImproveScope(options.scope);
     const config = options.config ?? loadConfig();
     const configuredImproveProfile = resolveImproveStrategy(options.strategy, config).config;
-    // A dry run never dispatches, so an all-disabled strategy must not abort it.
     const resolvedPlan = options.resolvedPlan ??
-        resolveImprovePlan(options.strategy, config, {
-            repairValidationFailures: options.repairValidationFailures,
-            allowAllDisabled: options.dryRun,
-        });
+        resolveImprovePlan(options.strategy, config, { repairValidationFailures: options.repairValidationFailures });
     const selectedStrategy = resolvedPlan.strategy;
     const improveProfile = selectedStrategy.config;
     const configuredLimits = {
@@ -433,7 +430,7 @@ function resolveImproveRunSetup(options) {
         config,
         resolvedPlan,
         selectedStrategy,
-        improveSensitiveValues: collectEngineCredentialValues(config),
+        improveSensitiveValues: collectCredentialValues(config),
         improveProfile,
         configuredImproveProfile,
         configuredLimits,
@@ -626,7 +623,6 @@ export function buildDryRunResult(run, collected, preparation) {
         ...(preparation?.planning ? { plan: buildResultExecutionPlan(run, preparation, collected, true) } : {}),
         ...(strategyFilteredRefs.length > 0 ? { strategyFilteredRefs } : {}),
         ...(run.resolvedPlan.engineUnavailable.length > 0 ? { skippedProcesses: run.resolvedPlan.engineUnavailable } : {}),
-        ...(run.options.engineProbe !== undefined ? { engineProbe: run.options.engineProbe } : {}),
         ...(preparation?.proactiveMaintenance ? { proactiveMaintenance: preparation.proactiveMaintenance } : {}),
     };
 }
@@ -725,7 +721,8 @@ async function runTriagePrePass(run) {
             dryRun: false,
             excludeIds: new Set(),
             judgment: resolvedPlan.triageJudgment,
-        }), { engine: resolvedPlan.triageJudgment?.engine, process: "triage.judgment" });
+            signal: run.budgetAbortController.signal,
+        }), { engine: resolvedPlan.triageJudgment?.name, process: "triage.judgment" });
     }
     catch (err) {
         warn(`[improve] triage pre-pass failed (non-fatal): ${errMessage(err)}`);
@@ -1026,7 +1023,6 @@ function finalizeImproveResult(args) {
         ...(preparation.planning ? { plan: buildResultExecutionPlan(run, preparation, collected, false) } : {}),
         ...(strategyFilteredRefs.length > 0 ? { strategyFilteredRefs } : {}),
         ...(resolvedPlan.engineUnavailable.length > 0 ? { skippedProcesses: resolvedPlan.engineUnavailable } : {}),
-        ...(options.engineProbe !== undefined ? { engineProbe: options.engineProbe } : {}),
         ...(usageReport ? { usageReport } : {}),
         actions: persistedActions,
         ...(distillSkippedAggregate ? { distillSkipped: distillSkippedAggregate } : {}),

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

@@ -155,6 +155,8 @@ async function runLoopReflectPass(planned, env, tally) {
         signal: env.budgetSignal,
         eventsCtx: env.eventsCtx,
         ...(planned.eligibilitySource ? { eligibilitySource: planned.eligibilitySource } : {}),
+        llmRunner: resolvedPlan.processes.reflect.runner,
+        ...(resolvedPlan.run ? { run: resolvedPlan.run } : {}),
     };
     const result = await attributeStage(resolvedPlan, "reflect", () => env.reflectFn(reflectArgs));
     const reason = result.ok ? undefined : result.reason;
@@ -254,6 +256,7 @@ async function runLoopDistillPass(planned, refType, isDistillOnly, env, tally) {
         ...(improveProfile ? { improveProfile } : {}),
         config: options.config,
         llmRunner: resolvedPlan.processes.distill.runner,
+        ...(resolvedPlan.run ? { run: resolvedPlan.run } : {}),
         signal: env.budgetSignal,
         eventsCtx: env.eventsCtx,
         ...(planned.eligibilitySource ? { eligibilitySource: planned.eligibilitySource } : {}),

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

@@ -558,7 +558,7 @@ export function archiveCleanupCandidate(stashDir, candidate, filePath) {
             ? { successorRefs: candidate.successorRefs }
             : {}),
     }, "Archived derived memory for recoverable cleanup.\n");
-    // 4c (third review round): write the tombstone BEFORE moving the file — a
+    // Write the tombstone BEFORE moving the file — a
     // crash in between used to leave a file already at archivedPath with no
     // cleanup.md to explain it (unrecoverable: revert refuses on a missing
     // tombstone, and nothing else knows this archive dir exists). Reordered,

package/dist/commands/improve/preparation.js

@@ -24,7 +24,6 @@ import { appendEvent, readEvents } from "../../core/events.js";
 import { withStateDb } from "../../core/state-db.js";
 import { info, warn } from "../../core/warn.js";
 import { countUsageEventsByType, USAGE_EVENT_RETENTION_DAYS } from "../../indexer/usage/usage-events.js";
-import { runnerLlmConnection } from "../../integrations/agent/runner.js";
 import { getAvailableHarnesses } from "../../integrations/session-logs/index.js";
 import { getZeroResultSearches } from "../../storage/repositories/index-entries-repository.js";
 import { getRetrievalCounts } from "../../storage/repositories/index-utility-repository.js";
@@ -113,11 +112,8 @@ function planConsolidationPass(args) {
             maxChunkSize: processConfig?.maxChunkSize,
         }, primaryStashDir, [], args.existingKnowledgeBodyHashes ?? loadExistingKnowledgeBodyHashes(primaryStashDir), { readOnly: args.eventsCtx?.readOnly === true })
         : { poolSize: 0, candidatePoolSize: 0, judgedUnchanged: 0 };
-    // A credential-unavailable engine still resolved its context length.
-    const unavailable = resolvedPlan.engineUnavailable.find((item) => item.process === "consolidate");
-    const chunkSize = computeSafeChunkSize((resolvedPlan.processes.consolidate.runner &&
-        runnerLlmConnection(resolvedPlan.processes.consolidate.runner)?.contextLength) ??
-        unavailable?.contextLength ??
+    const consolidateRunner = resolvedPlan.processes.consolidate.runner;
+    const chunkSize = computeSafeChunkSize((consolidateRunner?.kind === "connection" ? consolidateRunner.contextLength : undefined) ??
         DEFAULT_CONTEXT_LENGTH_TOKENS, 500, processConfig?.maxChunkSize);
     const profilePassed = processConfig?.enabled !== false;
     const deltaPassed = pool.candidatePoolSize > 0 || pool.judgedUnchanged === 0;
@@ -194,17 +190,17 @@ async function runConsolidationPass(args) {
     return { consolidation, plan: planned.plan };
 }
 /** The extract gates, evaluated once for both the live pass and the dry-run report. */
-function inspectExtractPass(args, readOnly) {
+async function inspectExtractPass(args, readOnly) {
     const { options, improveProfile, resolvedPlan, eventsCtx } = args;
     const enabled = resolvedPlan.processes.extract.enabled;
-    const hasRunner = resolvedPlan.processes.extract.runner?.engine !== undefined;
+    const hasRunner = resolvedPlan.processes.extract.runner !== null;
     const availableHarnesses = (options.extractHarnesses ?? getAvailableHarnesses()).filter((h) => h.isAvailable());
     const configured = improveProfile.processes?.extract?.minNewSessions;
     const minNewSessions = typeof configured === "number" ? configured : 0;
     let newCandidateCount;
     if (enabled && hasRunner && availableHarnesses.length > 0 && minNewSessions > 0) {
         const defaultSince = improveProfile.processes?.extract?.defaultSince;
-        newCandidateCount = (options.extractCandidateCountFn ?? countNewExtractCandidates)(options.config ?? loadConfig(), {
+        newCandidateCount = await (options.extractCandidateCountFn ?? countNewExtractCandidates)(options.config ?? loadConfig(), {
             harnesses: availableHarnesses,
             improveProfile,
             ...(defaultSince ? { since: defaultSince } : {}),
@@ -245,17 +241,16 @@ async function runSessionExtractPass(args, plan) {
     if (!resolvedPlan.processes.extract.enabled)
         return { warnings };
     const runner = resolvedPlan.processes.extract.runner;
-    if (!runner?.engine) {
+    if (!runner) {
         throw new ConfigError("Resolved improve plan has no runner for enabled extract process.", "LLM_NOT_CONFIGURED");
     }
     const config = options.config ?? loadConfig();
     const extractPlan = Object.freeze({
         strategy: resolvedPlan.strategy.name,
-        engine: runner.engine,
+        engine: runner.name,
         enabled: true,
         process: resolvedPlan.processes.extract.config,
         runner,
-        timeoutMs: runner.timeoutMs === undefined ? 600_000 : runner.timeoutMs,
         embeddingConfig: Object.freeze(structuredClone(config.embedding)),
         ...(resolvedPlan.processes.extract.notices?.length ? { notices: resolvedPlan.processes.extract.notices } : {}),
     });
@@ -374,7 +369,7 @@ export async function runImprovePreparationStage(args) {
             plan: planConsolidationPass(args).plan,
         }
         : await runConsolidationPass(args);
-    const extractPlan = inspectExtractPass(args, planOnly);
+    const extractPlan = await inspectExtractPass(args, planOnly);
     const extractPass = planOnly ? { warnings: [] } : await runSessionExtractPass(args, extractPlan);
     cleanupWarnings.push(...extractPass.warnings);
     if (persist) {