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

package/dist/commands/improve/eligibility.js

@@ -8,11 +8,11 @@ import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { isAssetType } from "../../core/common.js";
 import { NotFoundError, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { readEvents } from "../../core/events.js";
-import { closeDatabase, getAllEntries, getUtilityScoresByIds, openExistingDatabase } from "../../indexer/db/db.js";
+import { closeDatabase, getAllEntries, getUtilityScoresByIds, openExistingDatabase, openReadonlyExistingDatabase, } from "../../indexer/db/db.js";
 import { getWritableStashDirs, resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
 import { isDistillRefusedInputType } from "./distill.js";
-import { isProfileFilteredForAllPasses } from "./improve-profiles.js";
+import { isStrategyFilteredForAllPasses } from "./improve-strategies.js";
 // Eligibility / candidate-selection predicates for improve. Free functions
 // (no akmImprove closure state) extracted from improve.ts to shrink the
 // orchestrator and make candidate selection independently testable.
@@ -49,6 +49,13 @@ export function dedupeRefs(refs) {
     return out;
 }
 export async function collectEligibleRefs(scope, stashDir, improveProfile) {
+    return collectEligibleRefsFromIndex(scope, stashDir, improveProfile, false);
+}
+/** Dry-run planner path: query an existing index without creating or mutating it. */
+export async function collectEligibleRefsReadOnly(scope, stashDir, improveProfile) {
+    return collectEligibleRefsFromIndex(scope, stashDir, improveProfile, true);
+}
+async function collectEligibleRefsFromIndex(scope, stashDir, improveProfile, readOnly) {
     if (scope.mode === "ref" && scope.value) {
         const parsed = parseAssetRef(scope.value);
         const writableDirs = new Set(getWritableStashDirs(stashDir).map((dir) => path.resolve(dir)));
@@ -57,7 +64,7 @@ export async function collectEligibleRefs(scope, stashDir, improveProfile) {
             return {
                 plannedRefs: [],
                 memorySummary: { eligible: 0, derived: 0 },
-                profileFilteredRefs: [],
+                strategyFilteredRefs: [],
             };
         }
         return {
@@ -66,7 +73,7 @@ export async function collectEligibleRefs(scope, stashDir, improveProfile) {
                 eligible: parsed.type === "memory" ? 1 : 0,
                 derived: parsed.type === "memory" && parsed.name.endsWith(".derived") ? 1 : 0,
             },
-            profileFilteredRefs: [],
+            strategyFilteredRefs: [],
         };
     }
     let sources;
@@ -74,10 +81,10 @@ export async function collectEligibleRefs(scope, stashDir, improveProfile) {
         sources = resolveSourceEntries(stashDir);
     }
     catch {
-        return { plannedRefs: [], memorySummary: { eligible: 0, derived: 0 }, profileFilteredRefs: [] };
+        return { plannedRefs: [], memorySummary: { eligible: 0, derived: 0 }, strategyFilteredRefs: [] };
     }
     if (sources.length === 0) {
-        return { plannedRefs: [], memorySummary: { eligible: 0, derived: 0 }, profileFilteredRefs: [] };
+        return { plannedRefs: [], memorySummary: { eligible: 0, derived: 0 }, strategyFilteredRefs: [] };
     }
     // Only operate on writable sources — never mutate read-only registry caches
     // or remote stashes that the user did not mark writable.
@@ -91,7 +98,10 @@ export async function collectEligibleRefs(scope, stashDir, improveProfile) {
     const writableDirSet = new Set(writableDirs.map((d) => path.resolve(d)));
     let db;
     try {
-        db = openExistingDatabase();
+        db = readOnly ? openReadonlyExistingDatabase() : openExistingDatabase();
+        if (!db) {
+            return { plannedRefs: [], memorySummary: { eligible: 0, derived: 0 }, strategyFilteredRefs: [] };
+        }
         const entries = getAllEntries(db, scope.mode === "type" ? scope.value : undefined).filter((indexed) => {
             // First apply the existing stashDir-scope filter (no-op when stashDir is unset).
             if (!isEntryInScope(indexed.stashDir, indexed.filePath, stashDir))
@@ -117,14 +127,14 @@ export async function collectEligibleRefs(scope, stashDir, improveProfile) {
                 // 2026-05-27: extend the .derived precedent to profile-incompatible
                 // refs. If every per-ref pass (reflect + distill) on the active
                 // profile would refuse this ref, drop it from `plannedRefs`. The
-                // caller emits `improve_skipped { reason: profile_filtered_all_passes }`
+                // caller emits `improve_skipped { reason: strategy_filtered_all_passes }`
                 // once `eventsCtx` is available so the audit trail is preserved in a
                 // single event per ref instead of 2× synthetic actions per run.
                 // Background: see /tmp/akm-health-investigations/planner-profile-metrics-deep-analysis.md
-                if (improveProfile && isProfileFilteredForAllPasses(ref, improveProfile)) {
+                if (improveProfile && isStrategyFilteredForAllPasses(ref, improveProfile)) {
                     profileFiltered.set(ref, {
                         ref,
-                        reason: "profile_filtered_all_passes",
+                        reason: "strategy_filtered_all_passes",
                         filePath: indexed.filePath,
                     });
                 }
@@ -145,14 +155,14 @@ export async function collectEligibleRefs(scope, stashDir, improveProfile) {
         return {
             plannedRefs: [...planned.values()],
             memorySummary: { eligible: memoryEligible, derived: memoryDerived },
-            profileFilteredRefs: [...profileFiltered.values()],
+            strategyFilteredRefs: [...profileFiltered.values()],
         };
     }
     catch (error) {
         // The bun-test isolation guard must never be downgraded to "empty plan".
         rethrowIfTestIsolationError(error);
         if (error instanceof NotFoundError || error instanceof Error) {
-            return { plannedRefs: [], memorySummary: { eligible: 0, derived: 0 }, profileFilteredRefs: [] };
+            return { plannedRefs: [], memorySummary: { eligible: 0, derived: 0 }, strategyFilteredRefs: [] };
         }
         throw error;
     }

package/dist/commands/improve/extract-cli.js

@@ -18,9 +18,10 @@ import fs from "node:fs";
 import path from "node:path";
 import { getStringArg } from "../../cli/parse-args.js";
 import { defineJsonCommand, EXIT_CODES, output } from "../../cli/shared.js";
+import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
 import { getAvailableHarnesses, getWatchTargets } from "../../integrations/session-logs/index.js";
-import { akmExtract } from "./extract.js";
+import { akmExtract, resolveStandaloneExtractPlan, } from "./extract.js";
 import { akmExtractWatch } from "./extract-watch.js";
 export const extractCommand = defineJsonCommand({
     meta: {
@@ -61,7 +62,15 @@ export const extractCommand = defineJsonCommand({
         },
         "timeout-ms": {
             type: "string",
-            description: "Per-session LLM timeout in ms (default 60000).",
+            description: "Per-session LLM timeout in ms (default 600000).",
+        },
+        engine: {
+            type: "string",
+            description: "Named LLM engine for this invocation. Mutually exclusive with --strategy.",
+        },
+        strategy: {
+            type: "string",
+            description: "Improve strategy supplying extract behavior and engine. Mutually exclusive with --engine.",
         },
         watch: {
             type: "boolean",
@@ -81,12 +90,17 @@ export const extractCommand = defineJsonCommand({
         const auto = args.auto === true;
         const dryRun = args["dry-run"] === true;
         const force = args.force === true;
+        const engine = getStringArg(args, "engine");
+        const strategy = getStringArg(args, "strategy");
         const timeoutMs = typeof args["timeout-ms"] === "string" && args["timeout-ms"] !== ""
             ? Number.parseInt(args["timeout-ms"], 10)
             : undefined;
         if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
             throw new UsageError(`--timeout-ms must be a positive integer (got "${args["timeout-ms"]}").`, "INVALID_FLAG_VALUE");
         }
+        if (engine && strategy) {
+            throw new UsageError("--engine and --strategy are mutually exclusive. Pick one.", "INVALID_FLAG_VALUE");
+        }
         const watch = args.watch === true;
         const debounceMs = typeof args["debounce-ms"] === "string" && args["debounce-ms"] !== ""
             ? Number.parseInt(args["debounce-ms"], 10)
@@ -94,24 +108,31 @@ export const extractCommand = defineJsonCommand({
         if (watch && (!Number.isFinite(debounceMs) || debounceMs <= 0)) {
             throw new UsageError(`--debounce-ms must be a positive integer (got "${args["debounce-ms"]}").`, "INVALID_FLAG_VALUE");
         }
-        if (watch) {
-            await runWatchMode({ debounceMs, dryRun, force, ...(since ? { since } : {}) });
-            return;
-        }
-        if (auto && type) {
+        if (!watch && auto && type) {
             throw new UsageError("--auto and --type are mutually exclusive. Pick one.", "INVALID_FLAG_VALUE");
         }
-        if (!auto && !type) {
+        if (!watch && !auto && !type) {
             throw new UsageError("--type is required (or pass --auto to try every available harness).", "MISSING_REQUIRED_ARGUMENT");
         }
-        const commonOptions = {
+        const config = loadConfig();
+        const resolvedPlan = resolveStandaloneExtractPlan(config, {
+            ...(engine ? { engine } : {}),
+            ...(strategy ? { strategy } : {}),
+            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        });
+        if (watch) {
+            await runWatchMode({ debounceMs, dryRun, force, config, resolvedPlan, ...(since ? { since } : {}) });
+            return;
+        }
+        const commonOptions = Object.freeze({
             ...(sessionId ? { sessionId } : {}),
             ...(location ? { location } : {}),
             ...(since ? { since } : {}),
             dryRun,
             force,
-            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-        };
+            config,
+            resolvedPlan,
+        });
         if (auto) {
             const harnesses = getAvailableHarnesses();
             if (harnesses.length === 0) {
@@ -196,6 +217,13 @@ function createFsWatchEventSource(roots) {
         },
     };
 }
+/** Snapshot the CLI-resolved watch options once and reuse them for every debounced trigger. */
+export function createExtractWatchTrigger(options, extractFn = akmExtract) {
+    const snapshot = Object.freeze({ ...options });
+    return async (harnessName) => {
+        await extractFn({ type: harnessName, ...snapshot });
+    };
+}
 /**
  * Run `akm extract --watch`: watch every available harness's session-log
  * roots and run extract (debounced, per-harness) on change. Stays alive until
@@ -216,18 +244,18 @@ async function runWatchMode(opts) {
     }
     const allRoots = targets.flatMap((t) => t.roots);
     const eventSource = createFsWatchEventSource(allRoots);
+    const onTrigger = createExtractWatchTrigger({
+        dryRun: opts.dryRun,
+        force: opts.force,
+        config: opts.config,
+        resolvedPlan: opts.resolvedPlan,
+        ...(opts.since ? { since: opts.since } : {}),
+    });
     const handle = akmExtractWatch({
         roots: targets,
         eventSource,
         debounceMs: opts.debounceMs,
-        onTrigger: async (harnessName) => {
-            await akmExtract({
-                type: harnessName,
-                dryRun: opts.dryRun,
-                force: opts.force,
-                ...(opts.since ? { since: opts.since } : {}),
-            });
-        },
+        onTrigger,
     });
     output("extract", {
         schemaVersion: 1,

package/dist/commands/improve/extract.js

@@ -15,7 +15,7 @@
  *     never touch a real platform.
  *   - Bounded LLM call wrapped by {@link tryLlmFeature} under the
  *     `session_extraction` gate (default-on; opt out via
- *     `profiles.improve.default.processes.extract.enabled: false`).
+ *     `improve.strategies.<name>.processes.extract.enabled: false`).
  *   - Proposals routed via `createProposal({ source: "extract", ... })` — the
  *     same review queue as reflect / distill / consolidate. Never direct-write.
  *   - Per-candidate body assembly merges description (+ when_to_use for lessons)
@@ -27,16 +27,18 @@ import fs from "node:fs";
 import path from "node:path";
 import { assembleAsset } from "../../core/asset/asset-serialize.js";
 import { resolveStashDir, timestampForFilename } from "../../core/common.js";
-import { getDefaultLlmConfig, getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
+import { getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
 import { ConfigError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
-import { probeLock, releaseLock, tryAcquireLockSync } from "../../core/file-lock.js";
+import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync, } from "../../core/file-lock.js";
+import { tryAcquireMaintenanceBarrier } from "../../core/maintenance-barrier.js";
 import { resolveStashStandards } from "../../core/standards/resolve-stash-standards.js";
 import { getStateDbPath, openStateDatabase, withStateDb } from "../../core/state-db.js";
 import { repairTruncatedDescription } from "../../core/text-truncation.js";
 import { warn } from "../../core/warn.js";
 import { indexWrittenAssets } from "../../indexer/index-written-assets.js";
-import { resolveImproveProcessRunnerFromProfile, runnerIsLlm } from "../../integrations/agent/runner.js";
+import { resolveLlmEngineUse } from "../../integrations/agent/engine-resolution.js";
+import { materializeLlmRunnerConnection, resolveImproveProcessRunner, } from "../../integrations/agent/runner.js";
 import { normalizeHarnessId } from "../../integrations/harnesses/index.js";
 import { getAvailableHarnesses } from "../../integrations/session-logs/index.js";
 import { preFilterSession } from "../../integrations/session-logs/pre-filter.js";
@@ -48,7 +50,7 @@ import { getExtractedSessionsMap, getLastExtractRunAt, shouldSkipAlreadyExtracte
 import { createProposal, isProposalSkipped } from "../proposal/repository.js";
 import { buildExtractPrompt, EXTRACT_JSON_SCHEMA, parseExtractPayload } from "./extract-prompt.js";
 import { buildHotProbationFrontmatter } from "./hot-probation.js";
-import { resolveProcessEnabled } from "./improve-profiles.js";
+import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
 import { applySchemaSimilarityPenalty, loadDerivedLayerEmbeddings, } from "./schema-similarity-gate.js";
 import { buildSessionSummaryPrompt, parseSessionSummary, SESSION_SUMMARY_JSON_SCHEMA, sessionMeetsDurationGate, writeSessionAsset, } from "./session-asset.js";
 import { resolveTriageConfig, scoreSessionTriage } from "./triage.js";
@@ -123,20 +125,75 @@ function getExtractSessionLockPath(harness, sessionId, stateDbPath) {
  * extraction outright.
  */
 function acquireExtractSessionLock(lockPath) {
+    const releaseBarrier = tryAcquireMaintenanceBarrier();
+    if (!releaseBarrier)
+        return { proceed: false };
     try {
         fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-        if (tryAcquireLockSync(lockPath, String(process.pid)))
-            return true;
+        let ownership = tryAcquireLockSync(lockPath, createLockPayload());
+        if (ownership)
+            return { proceed: true, ownership };
         const probe = probeLock(lockPath, { staleAfterMs: EXTRACT_SESSION_LOCK_STALE_MS });
         if (probe.state === "held")
-            return false;
-        // absent (released between attempt + probe) or stale → reclaim and retry once.
-        releaseLock(lockPath);
-        return tryAcquireLockSync(lockPath, String(process.pid));
+            return { proceed: false };
+        // Absent (released between attempt + probe) or successfully reclaimed stale lock → retry once.
+        if (probe.state === "stale" && !reclaimStaleLock(lockPath, probe))
+            return { proceed: false };
+        ownership = tryAcquireLockSync(lockPath, createLockPayload());
+        return ownership ? { proceed: true, ownership } : { proceed: false };
     }
     catch {
-        return true;
+        return { proceed: true };
     }
+    finally {
+        releaseBarrier();
+    }
+}
+function cloneAndFreeze(value) {
+    const clone = structuredClone(value);
+    const freeze = (item) => {
+        if (typeof item !== "object" || item === null || Object.isFrozen(item))
+            return;
+        for (const child of Object.values(item))
+            freeze(child);
+        Object.freeze(item);
+    };
+    freeze(clone);
+    return clone;
+}
+/** Resolve standalone extract selection once before discovery, auto iteration, or watch startup. */
+export function resolveStandaloneExtractPlan(config, selection) {
+    if (selection.engine && selection.strategy) {
+        throw new UsageError("--engine and --strategy are mutually exclusive. Pick one.", "INVALID_FLAG_VALUE");
+    }
+    const selected = resolveImproveStrategy(selection.strategy, config);
+    const process = cloneAndFreeze(getImproveProcessConfig(config, "extract", selected.config) ?? {});
+    const invocation = {
+        ...(selection.engine ? { engine: selection.engine } : {}),
+        ...(Object.hasOwn(selection, "timeoutMs") ? { timeoutMs: selection.timeoutMs ?? null } : {}),
+    };
+    const resolved = resolveLlmEngineUse(config, [selected.config, process, invocation], { optional: true });
+    if (!resolved) {
+        throw new ConfigError("No LLM engine configured for extract. Set defaults.llmEngine, pass --engine, or select an improve strategy with processes.extract.engine.", "LLM_NOT_CONFIGURED");
+    }
+    const runner = {
+        kind: "llm",
+        engine: resolved.engine,
+        connection: resolved.connection,
+        ...(resolved.credential ? { credential: resolved.credential } : {}),
+        timeoutMs: resolved.timeoutMs,
+    };
+    return Object.freeze({
+        strategy: selected.name,
+        engine: resolved.engine,
+        // `akm extract` is an explicit operation. The strategy supplies behavior,
+        // but its improve-stage enablement gate does not disable this command.
+        enabled: true,
+        process,
+        runner: cloneAndFreeze(runner),
+        timeoutMs: resolved.timeoutMs,
+        embeddingConfig: cloneAndFreeze(config.embedding),
+    });
 }
 // ── Helpers ──────────────────────────────────────────────────────────────────
 /**
@@ -245,11 +302,11 @@ export function hashSessionContent(data) {
  * proposal validation failure) the session result records a warning and
  * keeps going — one session's bad luck never aborts a multi-session run.
  */
-async function processSession(harness, sessionRef, stashDir, config, llmConfig, chat, ctx, sourceRun, dryRun, timeoutMs, maxTotalChars, minContentChars, 
+async function processSession(harness, sessionRef, stashDir, config, getLlmConfig, chat, ctx, sourceRun, dryRun, timeoutMs, maxTotalChars, minContentChars, 
 // #626 — pre-LLM heuristic triage gate. Default-off (enabled:false) takes the
 // exact pre-change path (no scorer call, no new skipReason).
 // #641 — proceduralAwareFloor is opt-in, DEFAULT OFF.
-triage, sessionIndexing, schemaSimilarityCtx, 
+triage, sessionIndexing, schemaSimilarityCtx, hotProbationEnabled, 
 // #602 — already-extracted skip moved INSIDE processSession: the content hash
 // can only be computed after readSession, so the skip decision lives here. The
 // prior row + bypass flags are threaded in from the caller. Skipping here still
@@ -390,7 +447,7 @@ standardsContext) {
     };
     let llmRaw = "";
     const llmResult = await tryLlmFeature("session_extraction", config, async () => {
-        llmRaw = await chat(llmConfig, [{ role: "user", content: prompt }], {
+        llmRaw = await chat(getLlmConfig(), [{ role: "user", content: prompt }], {
             timeoutMs,
             responseSchema: EXTRACT_JSON_SCHEMA,
         });
@@ -451,12 +508,7 @@ standardsContext) {
     // When enabled, system-generated extractions enter captureMode: hot-probation
     // so they spend ONE consolidation cycle in probation before the deterministic
     // dedup+quality pass promotes them. Default OFF.
-    // Reads the `default` profile deliberately: this per-session hot-probation
-    // flag lives inside the 18-arg `processSession`, which has no handle to the
-    // active profile, and threading a 19th positional arg for a DEFAULT-OFF flag
-    // isn't worth the param bloat. The extract STAGE toggle (in `akmExtract`,
-    // below) already honors `--profile`.
-    const hotProbationEnabled = getImproveProcessConfig(config, "extract")?.hotProbation?.enabled === true;
+    // The invocation boundary resolves this from the frozen extract process.
     for (const candidate of payload.candidates) {
         if (dryRun) {
             proposalIds.push(`dry-run:${candidate.type}:${candidate.name}`);
@@ -555,20 +607,19 @@ export async function akmExtract(options) {
     const stashDir = options.stashDir ?? resolveStashDir();
     const dryRun = options.dryRun ?? false;
     const sourceRun = options.sourceRun ?? `extract-${timestampForFilename()}`;
-    // Read the per-process extract config + enabled-state from the ACTIVE improve
-    // profile when `akmImprove` threaded it; otherwise fall back to the `default`
-    // profile (the explicit `akm extract` path, which has no active profile). This
-    // is what stops a non-default profile's `extract.enabled` from being silently
-    // overridden by the default profile and vice-versa.
-    const activeProfile = options.improveProfile;
-    const extractProcess = activeProfile ? activeProfile.processes?.extract : getImproveProcessConfig(config, "extract");
+    // Read process behavior from the frozen standalone plan or the active improve
+    // strategy. This prevents config changes during watch mode from changing later
+    // triggers and prevents one improve strategy from overriding another.
+    const activeProfile = options.improveProfile ?? (options.resolvedPlan ? undefined : resolveImproveStrategy(undefined, config).config);
+    const extractProcess = options.resolvedPlan?.process ?? getImproveProcessConfig(config, "extract", activeProfile);
     // The `extract.enabled` process toggle gates extract as a STAGE of `akm improve`
     // (the activeProfile path) — consistent with #593/#594 where the active profile,
     // not `default`, is the source of truth. An EXPLICIT `akm extract` invocation
     // (no activeProfile) is a direct user/cron action and always runs; gating it on
     // the default improve profile's stage toggle was a footgun — dropping extract
     // from the daily improve profile would silently disable the standalone command.
-    const extractEnabled = activeProfile ? resolveProcessEnabled("extract", activeProfile) : true;
+    const extractEnabled = options.resolvedPlan?.enabled ??
+        (options.improveProfile ? resolveProcessEnabled("extract", options.improveProfile) : true);
     // Feature-gate early so we get a clean "skipped because disabled" envelope.
     if (!extractEnabled) {
         return {
@@ -582,35 +633,29 @@ export async function akmExtract(options) {
             candidatesCreated: 0,
             proposals: [],
             sessions: [],
-            warnings: [
-                "session_extraction feature disabled — set profiles.improve.default.processes.extract.enabled: true to use",
-            ],
+            warnings: ["extract is disabled by the selected improve strategy"],
             durationMs: Date.now() - startMs,
         };
     }
-    // Resolve the LLM connection. Priority order:
-    //   1. Options.config.profiles.improve.default.processes.extract.profile
-    //      (per-process override, matches reflect/distill/consolidate)
-    //   2. config.defaults.llm (the default LLM profile)
-    //   3. throw — extract requires an LLM.
-    let llmConfig;
-    const runnerSpec = resolveImproveProcessRunnerFromProfile(extractProcess, config);
-    if (runnerSpec) {
-        if (!runnerIsLlm(runnerSpec)) {
-            throw new ConfigError(`Extract only supports mode: "llm" (in-tree LLM call). Got mode: "${runnerSpec.kind}" from profiles.improve.default.processes.extract — change it to "llm" or remove the override.`, "INVALID_CONFIG_FILE");
-        }
-        llmConfig = runnerSpec.connection;
-    }
-    else {
-        llmConfig = getDefaultLlmConfig(config) ?? undefined;
-    }
-    if (!llmConfig) {
-        throw new ConfigError("No LLM connection configured for extract. Set profiles.llm + defaults.llm, or set profiles.improve.default.processes.extract.profile to a configured LLM profile.");
+    // Improve supplies its invocation-owned connection. Standalone extract
+    // resolves the selected process engine, then defaults.llmEngine.
+    const runnerSpec = options.resolvedPlan
+        ? options.resolvedPlan.runner
+        : resolveImproveProcessRunner(activeProfile, "extract", config);
+    const fixedLlmConfig = options.resolvedPlan ? undefined : options.llmConfig;
+    if (!runnerSpec && !fixedLlmConfig) {
+        throw new ConfigError("No LLM engine configured for extract. Set defaults.llmEngine or improve.strategies.<name>.processes.extract.engine.", "LLM_NOT_CONFIGURED");
     }
-    // Honor per-process timeoutMs override; fall back to options.timeoutMs; then 60s.
-    const timeoutMs = options.timeoutMs ??
-        (typeof extractProcess?.timeoutMs === "number" ? extractProcess.timeoutMs : undefined) ??
-        60_000;
+    const timeoutMs = options.resolvedPlan
+        ? options.resolvedPlan.timeoutMs
+        : Object.hasOwn(options, "timeoutMs")
+            ? (options.timeoutMs ?? null)
+            : runnerSpec?.timeoutMs !== undefined
+                ? runnerSpec.timeoutMs
+                : fixedLlmConfig && Object.hasOwn(fixedLlmConfig, "timeoutMs")
+                    ? (fixedLlmConfig.timeoutMs ?? null)
+                    : 600_000;
+    const getLlmConfig = () => runnerSpec ? materializeLlmRunnerConnection(runnerSpec) : fixedLlmConfig;
     // Pre-filter budget — process config can raise it for large-context models.
     const maxTotalChars = typeof extractProcess?.maxTotalChars === "number" ? extractProcess.maxTotalChars : undefined;
     // #595/#596 — minimum raw session size; sessions below it skip the LLM call
@@ -643,7 +688,7 @@ export async function akmExtract(options) {
     const defaultSessionSummaryGenerator = async (data) => {
         let raw = "";
         await tryLlmFeature("session_extraction", config, async () => {
-            raw = await chatForSummary(llmConfig, [{ role: "user", content: buildSessionSummaryPrompt(data) }], {
+            raw = await chatForSummary(getLlmConfig(), [{ role: "user", content: buildSessionSummaryPrompt(data) }], {
                 timeoutMs,
                 responseSchema: SESSION_SUMMARY_JSON_SCHEMA,
             });
@@ -768,13 +813,14 @@ export async function akmExtract(options) {
     // processes.extract.schemaSimilarity.enabled: false. The gate is inert in
     // practice when no derived-layer embeddings exist (empty ctx → no penalty).
     const schemaSimilarityCfg = extractProcess?.schemaSimilarity;
+    const hotProbationEnabled = extractProcess?.hotProbation?.enabled === true;
     let schemaSimilarityCtx = null;
     if (schemaSimilarityCfg?.enabled !== false) {
         const derivedEmbeddings = options.schemaSimilarityEmbeddings ?? loadDerivedLayerEmbeddings();
         schemaSimilarityCtx = {
             config: { ...schemaSimilarityCfg, enabled: true },
             derivedEmbeddings,
-            embeddingConfig: config.embedding,
+            embeddingConfig: options.resolvedPlan?.embeddingConfig ?? config.embedding,
             embedFn: options.schemaSimilarityEmbedFn,
         };
     }
@@ -802,10 +848,11 @@ export async function akmExtract(options) {
         // runs (those that open their own state.db): dry-run is read-only, an
         // injected `stateDb` handle is an in-process/test scenario with no cross-
         // process race, and skip-tracking-off opts out entirely.
-        let sessionLockPath;
+        let sessionLockOwnership;
         if (trackingEnabled && !dryRun && !options.stateDb) {
-            sessionLockPath = getExtractSessionLockPath(harness.name, summary.sessionId, options.stateDbPath ?? getStateDbPath());
-            if (!acquireExtractSessionLock(sessionLockPath)) {
+            const sessionLockPath = getExtractSessionLockPath(harness.name, summary.sessionId, options.stateDbPath ?? getStateDbPath());
+            const sessionLock = acquireExtractSessionLock(sessionLockPath);
+            if (!sessionLock.proceed) {
                 sessions.push({
                     sessionId: summary.sessionId,
                     harness: harness.name,
@@ -819,9 +866,10 @@ export async function akmExtract(options) {
                 skippedCount += 1;
                 continue;
             }
+            sessionLockOwnership = sessionLock.ownership;
         }
         try {
-            const result = await processSession(harness, summary, stashDir, config, llmConfig, chat, options.ctx, sourceRun, dryRun, timeoutMs, maxTotalChars, minContentChars, triage, sessionIndexing, schemaSimilarityCtx, prior, options.force === true, extractStandardsContext);
+            const result = await processSession(harness, summary, stashDir, config, getLlmConfig, chat, options.ctx, sourceRun, dryRun, timeoutMs, maxTotalChars, minContentChars, triage, sessionIndexing, schemaSimilarityCtx, hotProbationEnabled, prior, options.force === true, extractStandardsContext);
             sessions.push(result);
             // #626 — triage aggregation. A session reached the triage gate only when it
             // was NOT already preempted by an earlier skip (read_failed / too_short /
@@ -916,8 +964,8 @@ export async function akmExtract(options) {
             skippedCount += 1;
         }
         finally {
-            if (sessionLockPath)
-                releaseLock(sessionLockPath);
+            if (sessionLockOwnership)
+                releaseLock(sessionLockOwnership);
         }
     }
     // Close the state.db connection we opened. Callers that injected stateDb