akm-cli 0.9.17-alpha.2 → 0.9.17-alpha.4

package/dist/commands/improve/extract.js

@@ -2,37 +2,24 @@
 // 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/.
 /**
- * `akm extract` — session-insight extractor.
+ * `akm extract` — read native session logs (claude, opencode) through the
+ * session-log harnesses, pre-filter the noise, and ask the model for
+ * memory/lesson/knowledge candidates the agent did not already save. Each
+ * candidate is queued as a proposal (`source: "extract"`), never written.
  *
- * Replaces the akm-plugin session-checkpoint hook with an on-demand extractor
- * that reads native session files (claude JSONL, opencode storage tree)
- * through the {@link SessionLogHarness} registry, pre-filters noise, and asks
- * a bounded in-tree LLM to produce candidate memory/lesson/knowledge proposals
- * for content the agent did NOT preserve via inline `akm remember`/`akm feedback`.
- *
- * Architectural notes:
- *   - Stateless. All file/LLM access goes through injectable seams so tests
- *     never touch a real platform.
- *   - Bounded LLM call routed through `callStructured`. Improve-stage
- *     enablement comes from the active strategy; explicit `akm extract` always
- *     runs regardless of that stage toggle.
- *   - 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)
- *     into the body's YAML frontmatter so the accept-time
- *     descriptionQualityValidator passes — same pattern as the
- *     consolidate-writer fix.
+ * A session is skipped with zero LLM calls when its content hash is unchanged
+ * since the last extraction, when it is nearly empty, or when the optional
+ * heuristic triage scores it below threshold.
  */
 import fs from "node:fs";
 import path from "node:path";
 import { assembleAsset } from "../../core/asset/asset-serialize.js";
-import { timestampForFilename } from "../../core/common.js";
+import { resolveStashDir, timestampForFilename } from "../../core/common.js";
 import { getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
 import { ConfigError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync, } from "../../core/file-lock.js";
 import { EXTRACT_INFRASTRUCTURE_SKIP_REASONS } from "../../core/improve-types.js";
-import { tryAcquireMaintenanceBarrier } from "../../core/maintenance-barrier.js";
 import { redactErrorBody } from "../../core/redaction.js";
 import { resolveStashStandards } from "../../core/standards/resolve-stash-standards.js";
 import { resolveTypeConventions, typeConventionRef } from "../../core/standards/resolve-type-conventions.js";
@@ -42,63 +29,33 @@ import { repairTruncatedDescription } from "../../core/text-truncation.js";
 import { DURATION_UNITS, parseDuration } from "../../core/time.js";
 import { warn, warnVerbose } from "../../core/warn.js";
 import { indexWrittenAssets } from "../../indexer/index-written-assets.js";
-import { disposeLoweredExecutionDispatchLease, } from "../../integrations/agent/execution-lowering.js";
+import { assertRunnerCredentials } from "../../integrations/agent/runner-dispatch.js";
 import { getAvailableHarnesses } from "../../integrations/session-logs/index.js";
 import { preFilterSession } from "../../integrations/session-logs/pre-filter.js";
 import { isJsonSchemaKnownUnsupported } from "../../llm/client.js";
-import { callStructured, preflightStructuredLlmRunner } from "../../llm/structured-call.js";
-import { sha256Hex } from "../../runtime.js";
 import { getExtractedSessionsMap, getLastExtractRunAt, shouldSkipAlreadyExtractedSession, upsertExtractedSession, } from "../../storage/repositories/extract-sessions-repository.js";
 import { openSqliteReadSnapshot } from "../../storage/sqlite-read-snapshot.js";
-import { isProposalSkipped } from "../proposal/repository.js";
+import { contentHash } from "./content-hash.js";
 import { resolveImproveLlmExecution } from "./execution.js";
 import { buildExtractPrompt, EXTRACT_JSON_SCHEMA, parseExtractPayload, } from "./extract-prompt.js";
-import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
-import { emitProposal } from "./proposal-envelope.js";
-import { createRunContext, resolveRunStashDir } from "./run-context.js";
+import { cloneAndFreeze, resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
+import { isLedgerBlocked, ledgerKey, loadLedgerSnapshot } from "./ledger.js";
 import { buildSessionSummaryPrompt, parseSessionSummary, SESSION_SUMMARY_JSON_SCHEMA, sessionMeetsDurationGate, writeSessionAsset, } from "./session-asset.js";
-import { resolveTriageConfig, scoreSessionTriage } from "./triage.js";
-/** Default minimum session duration (minutes) for session indexing (#561). */
+import { callStage, mintProposal, noticeSet } from "./stage.js";
+/** Minimum session duration (minutes) for writing a session asset. */
 const DEFAULT_MIN_SESSION_DURATION_MINUTES = 5;
-/**
- * Default minimum raw session size (chars) below which the extract LLM call is
- * skipped (#595/#596). Deliberately tiny: analysis of 218 candidate-producing
- * sessions showed sessions of 22–368 raw chars regularly yield 1–5 candidates,
- * so size is not a reliable proxy for value — only truly empty sessions
- * (0 chars, journal files) are safe to skip.
- */
+/** Raw session size (chars) below which the LLM call is skipped; only truly empty sessions are safe to skip. */
 const DEFAULT_MIN_CONTENT_CHARS = 10;
-/**
- * Default cap on NEW sessions the extract pass will LLM-process in a single run
- * (`processes.extract.maxSessionsPerRun` overrides; `0` disables). Bounds per-run
- * wall time + token spend so a backlog of accumulated sessions can't run a single
- * pass past its scheduled-task timeout. Overflow sessions stay unseen and are
- * processed by subsequent runs, so coverage is preserved — just spread out.
- */
+/** New sessions LLM-processed per run (`processes.extract.maxSessionsPerRun`, 0 disables); the rest wait for later runs. */
 const DEFAULT_MAX_SESSIONS_PER_RUN = 25;
 /**
- * Floor for the default discovery window (48h). When no explicit `--since` /
- * `defaultSince` is configured, discovery looks back to the LAST recorded
- * extract run for the harness (so an intermittently-online host that was off for
- * days still rediscovers sessions that ended during the gap), but never LESS
- * than this — looking back less than the prior window could drop a session that
- * a previous run deferred via `maxSessionsPerRun`. Widening is free of redundant
- * LLM cost: the content-hash ledger skips unchanged sessions with zero LLM calls.
+ * Without an explicit window, discovery looks back to the last extract run for
+ * the harness (a host that was off still finds sessions that ended meanwhile),
+ * but never less than 48h. The content-hash ledger makes the overlap free.
  */
 const DEFAULT_SINCE_FLOOR_MS = 48 * 60 * 60 * 1000;
-/**
- * Staleness window for the per-session extract lock. A single session's
- * processing is bounded by the per-session LLM timeout (default 60s) plus the
- * session-summary call, so a lock older than this must belong to a crashed
- * holder and is safe to reclaim.
- */
+/** A per-session lock older than this belongs to a crashed holder. */
 const EXTRACT_SESSION_LOCK_STALE_MS = 5 * 60 * 1000;
-/**
- * Resolve the discovery `sinceMs` cutoff when no explicit `since`/`defaultSince`
- * is set: the later of (last recorded extract run for this harness) and
- * (now − 48h). See {@link DEFAULT_SINCE_FLOOR_MS}. Best-effort — any state.db
- * error falls back to the 48h floor.
- */
 function resolveDefaultSinceMs(harnessName, now, opts) {
     const floor = now - DEFAULT_SINCE_FLOOR_MS;
     if (opts.skipTracking)
@@ -122,30 +79,22 @@ function resolveDefaultSinceMs(harnessName, now, opts) {
         snapshot?.close();
     }
 }
-/** Filesystem-safe per-session lock path, co-located with the state.db. */
-function getExtractSessionLockPath(harness, sessionId, stateDbPath) {
+function extractSessionLockPath(harness, sessionId, stateDbPath) {
     const safe = `${harness}-${sessionId}`.replace(/[^A-Za-z0-9._-]/g, "_");
     return path.join(path.dirname(stateDbPath), "extract-locks", `extract-${safe}.lock`);
 }
 function extractSessionLockIsUnavailable(harness, sessionId, stateDbPath) {
-    const lockPath = getExtractSessionLockPath(harness, sessionId, stateDbPath);
-    const probe = probeLock(lockPath, { staleAfterMs: EXTRACT_SESSION_LOCK_STALE_MS });
+    const probe = probeLock(extractSessionLockPath(harness, sessionId, stateDbPath), {
+        staleAfterMs: EXTRACT_SESSION_LOCK_STALE_MS,
+    });
     return probe.state === "held" || probe.state === "inaccessible";
 }
 /**
- * Try to claim the per-session extract lock so a concurrent extract (e.g. a
- * session-end hook firing `--session-id` while the hourly improve pass runs
- * discovery) cannot double-process the SAME session — duplicate LLM spend and
- * near-duplicate proposals. Reclaims a stale lock (dead holder PID or age past
- * {@link EXTRACT_SESSION_LOCK_STALE_MS}). Returns false when another LIVE run
- * holds it — the caller then skips the session without any LLM call. Best-effort:
- * any filesystem error resolves to `true` (proceed) so locking never blocks
- * extraction outright.
+ * Claim a session so a concurrent extract (a session-end hook racing the
+ * hourly improve run) cannot process it twice. A stale lock is reclaimed; a
+ * filesystem error proceeds, so locking never blocks extraction outright.
  */
 function acquireExtractSessionLock(lockPath) {
-    const releaseBarrier = tryAcquireMaintenanceBarrier();
-    if (!releaseBarrier)
-        return { proceed: false };
     try {
         fs.mkdirSync(path.dirname(lockPath), { recursive: true });
         let ownership = tryAcquireLockSync(lockPath, createLockPayload());
@@ -154,7 +103,6 @@ function acquireExtractSessionLock(lockPath) {
         const probe = probeLock(lockPath, { staleAfterMs: EXTRACT_SESSION_LOCK_STALE_MS });
         if (probe.state === "held")
             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());
@@ -163,38 +111,22 @@ function acquireExtractSessionLock(lockPath) {
     catch {
         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. */
+/** 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("extract", selected.config) ?? {});
-    const invocation = {
-        ...(selection.engine ? { engine: selection.engine } : {}),
-        ...(Object.hasOwn(selection, "timeoutMs") ? { timeoutMs: selection.timeoutMs ?? null } : {}),
-    };
     const resolved = resolveImproveLlmExecution({
         config,
         profile: selected.config,
         process,
-        current: invocation,
+        current: {
+            ...(selection.engine ? { engine: selection.engine } : {}),
+            ...(Object.hasOwn(selection, "timeoutMs") ? { timeoutMs: selection.timeoutMs ?? null } : {}),
+        },
         processName: "extract",
     });
     if (!resolved) {
@@ -204,8 +136,7 @@ export function resolveStandaloneExtractPlan(config, selection) {
     return Object.freeze({
         strategy: selected.name,
         engine: runner.engine,
-        // `akm extract` is an explicit operation. The strategy supplies behavior,
-        // but its improve-stage enablement gate does not disable this command.
+        // An explicit `akm extract` runs regardless of the strategy's improve-stage toggle.
         enabled: true,
         process,
         runner: cloneAndFreeze(runner),
@@ -214,8 +145,15 @@ export function resolveStandaloneExtractPlan(config, selection) {
         ...(resolved.notices.length > 0 ? { notices: cloneAndFreeze(resolved.notices) } : {}),
     });
 }
-// ── Helpers ──────────────────────────────────────────────────────────────────
-/** An extract envelope for a run that processed no sessions; `engine`/`engineKind` only once a runner is resolved. */
+const NO_PREFILTER = { inputCount: 0, outputCount: 0, truncatedCount: 0 };
+function sessionOutcome(sessionId, harness, fields) {
+    return { sessionId, harness, candidateCount: 0, proposalIds: [], preFilter: NO_PREFILTER, warnings: [], ...fields };
+}
+function preFilterStats(filtered) {
+    const { inputCount, outputCount, truncatedCount } = filtered.stats;
+    return { inputCount, outputCount, truncatedCount };
+}
+/** An extract envelope for a run that processed no sessions. */
 function emptyExtractResult(args) {
     return {
         schemaVersion: 1,
@@ -234,23 +172,13 @@ function emptyExtractResult(args) {
     };
 }
 /**
- * Parse a since-string into an absolute ms-epoch cutoff. Accepts:
- *   - ISO timestamps (parsed via Date.parse)
- *   - Relative durations: `<n>m`, `<n>h`, `<n>d` (minutes / hours / days)
- *
- * Throws UsageError on unparseable input so the CLI surfaces a clear error
- * rather than silently defaulting.
- *
- * The recognizer is deliberately CASE-INSENSITIVE and whitespace-tolerant —
- * `5M` means 5 MINUTES here, diverging from the core grammar's case-sensitive
- * `M`=months (pinned by tests/commands/goldens-duration-flags.test.ts); only
- * the unit arithmetic is delegated to the canonical {@link DURATION_UNITS}
- * table via {@link parseDuration}.
+ * A since-string as an epoch-ms cutoff: an ISO timestamp or `<n>m|h|d`
+ * (case-insensitive here — `5M` is five minutes). Default 24h; anything else
+ * is a usage error.
  */
 export function parseSinceArg(value, now = Date.now()) {
-    if (!value || value.trim() === "") {
-        return now - 24 * 60 * 60 * 1000; // default: 24h
-    }
+    if (!value || value.trim() === "")
+        return now - 24 * 60 * 60 * 1000;
     const trimmed = value.trim();
     const relMatch = trimmed.match(/^(\d+)\s*([mhd])$/i);
     if (relMatch) {
@@ -264,35 +192,17 @@ export function parseSinceArg(value, now = Date.now()) {
     throw new UsageError(`--since value "${value}" could not be parsed (expected ISO timestamp or duration like 24h / 7d / 30m)`, "INVALID_FLAG_VALUE");
 }
 /**
- * Resolve a harness instance for the given type, either from the explicit
- * `harnesses` seam or the {@link getAvailableHarnesses} registry. Returns
- * `undefined` when no harness matches (the caller surfaces that as a warning).
- */
-function resolveHarness(type, harnesses) {
-    const pool = harnesses ?? getAvailableHarnesses();
-    return pool.find((h) => h.name === type);
-}
-/**
- * Build the ref + content for a candidate. The body must contain a
- * frontmatter block carrying `description` (and `when_to_use` for lessons)
- * so the accept-time descriptionQualityValidator passes — same pattern as
- * the consolidate-writer fix at consolidate.ts.
+ * A candidate's ref and content. `description` (and a lesson's `when_to_use`)
+ * go into the body's frontmatter so accept-time validation sees them.
  */
 function buildCandidateProposal(candidate, sourceRef, sessionAssetRef) {
     const ref = deriveExtractCandidateRef(candidate, sourceRef);
-    // Post-generation repair pass (#556): deterministically complete a
-    // description the LLM sliced mid-sentence before it reaches the
-    // auto-accept validators. No-op (byte-identical) for valid descriptions.
+    // Complete a description the model cut mid-sentence (no-op for valid ones).
     const description = repairTruncatedDescription(candidate.description, candidate.body);
-    const fm = {
-        description,
-        ...(sessionAssetRef ? { xrefs: [sessionAssetRef] } : {}),
-    };
-    if (candidate.type === "lesson" && candidate.when_to_use) {
+    const fm = { description, ...(sessionAssetRef ? { xrefs: [sessionAssetRef] } : {}) };
+    if (candidate.type === "lesson" && candidate.when_to_use)
         fm.when_to_use = candidate.when_to_use;
-    }
-    const content = assembleAsset(fm, candidate.body);
-    return { ref, content, description };
+    return { ref, content: assembleAsset(fm, candidate.body), description };
 }
 function canonicalSegment(value) {
     return value
@@ -303,13 +213,11 @@ function canonicalSegment(value) {
         .replace(/^-|-$/g, "");
 }
 export function deriveExtractCandidateRef(candidate, sourceRef) {
-    const candidateParts = candidate.name.split("/").map(canonicalSegment).filter(Boolean);
-    const leaf = candidateParts.at(-1) ?? "extracted-insight";
+    const leaf = candidate.name.split("/").map(canonicalSegment).filter(Boolean).at(-1) ?? "extracted-insight";
     if (candidate.type === "memory" || candidate.type === "lesson") {
         const projectName = sourceRef.projectHint?.split(/[\\/]/).filter(Boolean).at(-1);
         const scope = projectName ? canonicalSegment(projectName) : "";
-        const subdir = candidate.type === "memory" ? "memories" : "lessons";
-        return `${subdir}/${scope ? `${scope}/` : ""}${leaf}`;
+        return `${candidate.type === "memory" ? "memories" : "lessons"}/${scope ? `${scope}/` : ""}${leaf}`;
     }
     return `knowledge/${leaf}`;
 }
@@ -326,222 +234,120 @@ function resolveExtractStandards(stashDir) {
     return sections.join("\n\n");
 }
 /**
- * Canonicalize a session's content into a single deterministic string for
- * hashing (#602). Each event is rendered `<role>\n<text>` and events are joined
- * with a NUL-delimited separator (`\n\0\n`) so event boundaries cannot be forged
- * by text that itself contains newlines.
- *
- * The input is the RAW `data.events` stream — NOT the pre-filtered / truncated
- * set — so the hash is stable across `maxTotalChars` (and any other pre-filter)
- * config changes: changing config must NEVER change the hash (idempotency AC).
- * `inlineRefs` and ref metadata (title, startedAt/endedAt timestamps) are
- * deliberately EXCLUDED so clock/title churn (and an agent adding an inline
- * `akm remember` mid-session) does not change the hash.
- */
-function canonicalizeSessionContent(data) {
-    return data.events.map((e) => `${e.role ?? "unknown"}\n${e.text}`).join("\n\0\n");
-}
-/**
- * sha256 (hex) of the normalized session content (#602). This is the byte-exact,
- * clock-independent skip authority that replaced the old `session_ended_at`
- * timestamp comparison. See {@link canonicalizeSessionContent} for exactly what
- * is (and is not) hashed.
+ * The skip authority for "already extracted": a hash of the raw event stream
+ * (`role\ntext` per event, NUL-separated so boundaries cannot be forged). It
+ * excludes titles, timestamps and inline refs, and ignores pre-filter config.
  */
 export function hashSessionContent(data) {
-    return sha256Hex(canonicalizeSessionContent(data));
+    return contentHash(data.events.map((e) => `${e.role ?? "unknown"}\n${e.text}`).join("\n\0\n"));
 }
+// ── Session triage (heuristic, zero LLM cost, default off) ───────────────────
+const DEFAULT_TRIAGE_MIN_SCORE = 2;
+const TRIAGE_MARKER_RE = /\b(error|failed|fix(?:ed)?|root cause|turns out|because|decided|instead|gotcha|workaround|regress(?:ed)?|broke|TIL)\b/i;
+const TRIAGE_EDIT_COMMIT_RE = /\b(Edit|Write|MultiEdit|git commit|diff)\b/i;
 /**
- * Process one session through the full pipeline: read → pre-filter → LLM →
- * parse → createProposal-per-candidate. Returns the per-session result.
- *
- * On any non-fatal failure (LLM error, unparseable response, individual
- * proposal validation failure) the session result records a warning and
- * keeps going — one session's bad luck never aborts a multi-session run.
+ * Score a session for extraction worth: learning markers (capped 2), tool
+ * density, edits/commits, and the substantive assistant/tool share.
  */
+function sessionTriagePasses(data, minScore) {
+    const events = data.events;
+    const count = (predicate) => events.filter(predicate).length;
+    const markers = Math.min(count((e) => TRIAGE_MARKER_RE.test(e.text)), 2);
+    const toolDensity = Math.min(count((e) => e.role === "tool") * 0.25, 1.5);
+    const editCommit = Math.min(count((e) => Boolean(e.filePath) || TRIAGE_EDIT_COMMIT_RE.test(e.text)) * 0.25, 1.5);
+    const substantive = count((e) => (e.role === "assistant" || e.role === "tool") && e.text.length >= 40);
+    const substantiveRatio = Math.min(events.length > 0 ? substantive / events.length : 0, 1);
+    return markers + toolDensity + editCommit + substantiveRatio >= minScore;
+}
 /**
- * The zero-LLM pre-flight gates for one session: read, the #602 content-hash
- * already-extracted skip, the #595/#596 minContentChars floor, and the #626
- * heuristic triage gate. Returns a terminal skip result, or the read `data` +
- * pre-filtered events + content hash to carry into the extraction prompt.
- * Extracted verbatim from `processSession` — every skip shape/reason is
- * byte-identical.
+ * The zero-LLM gates for one session: read, the content-hash skip (only
+ * `--force` overrides it, even for `--session-id`), the raw-size floor and the
+ * triage score. Returns a skip, or what the prompt needs.
  */
-function runPreLlmSessionGates(args) {
-    const { harness, sessionRef, prior, force, maxTotalChars, minContentChars, triage } = args;
+function runPreLlmSessionGates(harness, sessionRef, prior, force, gates) {
+    const { sessionId } = sessionRef;
     let data;
     try {
         data = harness.readSession(sessionRef);
     }
     catch (err) {
         return {
-            skip: {
-                sessionId: sessionRef.sessionId,
-                harness: harness.name,
-                candidateCount: 0,
-                proposalIds: [],
-                preFilter: { inputCount: 0, outputCount: 0, truncatedCount: 0 },
+            skip: sessionOutcome(sessionId, harness.name, {
                 warnings: [`readSession failed: ${err instanceof Error ? err.message : String(err)}`],
                 skipped: true,
                 skipReason: "read_failed",
-            },
+            }),
         };
     }
-    // #602 — content-hash skip. Computed on the RAW event stream immediately after
-    // a successful read, BEFORE the pre-filter / minContentChars / triage gates, so
-    // an unchanged session never reaches the LLM. Hash-based ⇒ clock-independent
-    // (immune to the Jun 11-12 timestamp double-extract/over-throttle bug). The skip
-    // applies UNIFORMLY — including explicit `--session-id` targeting (so a
-    // session-end hook firing `extract --session-id <id>` is idempotent). ONLY
-    // `--force` overrides it to re-extract a previously-extracted session.
-    const contentHash = hashSessionContent(data);
-    if (!force && shouldSkipAlreadyExtractedSession(prior, contentHash)) {
-        return { skip: alreadyExtractedResult(harness.name, sessionRef.sessionId, prior, contentHash) };
-    }
-    // #840 — harvest-without-prompting hybrid: the LLM prompt is built only from
-    // parent-origin events (folding stays as infrastructure for hashing above
-    // and inline-ref harvesting on `data.inlineRefs`, both of which still see
-    // the FULL folded stream). Subagent-origin events never reach
-    // `preFilterSession`, so #839's `dedupeTaskNotifications` naturally becomes
-    // a no-op on this path — a subagent's own event can no longer be in the
-    // kept set for a notification to be deduped against, leaving the parent's
-    // `<task-notification>` (the only surviving trace of that delegated work)
-    // untouched. See docs/plans/subagent-extraction-design.md §6.
-    const parentOriginData = {
-        ...data,
-        events: data.events.filter((e) => e.filePath === data.ref.filePath),
-    };
-    const filtered = preFilterSession(parentOriginData, {
-        ...(typeof maxTotalChars === "number" ? { maxTotalChars } : {}),
-    });
-    // #595/#596 — minContentChars gate: skip the LLM call for sessions whose RAW
-    // size is below threshold. Measured on the raw event text BEFORE the noise
-    // pre-filter, NOT on post-filter output — the pre-filter strips boilerplate
-    // so aggressively that even signal-bearing sessions can have tiny output
-    // (#596: gating post-filter filtered out 100% of sessions). Note: the 0.8.x
-    // fix gated on `filtered.stats.inputCount`, which is an EVENT count, not a
-    // char count — this port measures actual raw chars so the threshold matches
-    // the config key's documented unit.
-    // #840 — deliberately measured on the FULL folded `data.events` (parent +
-    // subagents), not the parent-origin view above: narrowing this to
-    // parent-origin chars would newly skip delegation-heavy sessions with a
-    // thin parent transcript before extraction runs at all, even though their
-    // subagent work is still fully harvested via `data.inlineRefs` above. The
-    // full-stream measurement is today's unchanged behavior, so the worst case
-    // this preserves is an LLM call over a small parent-only prompt, not a
-    // missed extraction.
-    const rawContentChars = data.events.reduce((sum, event) => sum + event.text.length, 0);
-    if (minContentChars > 0 && rawContentChars < minContentChars) {
+    const hash = hashSessionContent(data);
+    if (!force && shouldSkipAlreadyExtractedSession(prior, hash)) {
         return {
-            skip: {
-                sessionId: sessionRef.sessionId,
-                harness: harness.name,
-                candidateCount: 0,
-                proposalIds: [],
-                preFilter: {
-                    inputCount: filtered.stats.inputCount,
-                    outputCount: filtered.stats.outputCount,
-                    truncatedCount: filtered.stats.truncatedCount,
-                },
-                warnings: [],
+            skip: sessionOutcome(sessionId, harness.name, {
+                warnings: [`already extracted (content unchanged) at ${prior?.processed_at}; pass --force to re-process`],
                 skipped: true,
-                skipReason: "too_short",
-                contentHash,
-            },
+                skipReason: "already_extracted",
+                contentHash: hash,
+            }),
         };
     }
-    // #626 — pre-LLM heuristic triage gate. Runs AFTER minContentChars + the
-    // already-extracted skip check (both in the caller / above), BEFORE the
-    // extraction prompt and the session-asset write. When the session scores below
-    // the configured threshold we triage it out: no chat() call, no session asset,
-    // no proposals. Pure-heuristic — zero added LLM cost. Default-off → skipped.
-    if (triage.enabled) {
-        const t = scoreSessionTriage(data, triage.minScore);
-        if (!t.pass) {
-            return {
-                skip: {
-                    sessionId: sessionRef.sessionId,
-                    harness: harness.name,
-                    candidateCount: 0,
-                    proposalIds: [],
-                    preFilter: {
-                        inputCount: filtered.stats.inputCount,
-                        outputCount: filtered.stats.outputCount,
-                        truncatedCount: filtered.stats.truncatedCount,
-                    },
-                    warnings: [],
-                    skipped: true,
-                    skipReason: "triaged_out",
-                    contentHash,
-                },
-            };
-        }
+    // The prompt sees only parent-origin events; subagent work still reaches
+    // the hash above and the inline-ref harvest.
+    const filtered = preFilterSession({ ...data, events: data.events.filter((e) => e.filePath === data.ref.filePath) }, typeof gates.maxTotalChars === "number" ? { maxTotalChars: gates.maxTotalChars } : {});
+    // Measured on the full raw stream: pre-filtered size says little about value.
+    const rawChars = data.events.reduce((sum, event) => sum + event.text.length, 0);
+    const skipReason = gates.minContentChars > 0 && rawChars < gates.minContentChars
+        ? "too_short"
+        : gates.triage.enabled && !sessionTriagePasses(data, gates.triage.minScore)
+            ? "triaged_out"
+            : undefined;
+    if (skipReason) {
+        return {
+            skip: sessionOutcome(sessionId, harness.name, {
+                preFilter: preFilterStats(filtered),
+                skipped: true,
+                skipReason,
+                contentHash: hash,
+            }),
+        };
     }
-    return { data, filtered, contentHash };
-}
-function alreadyExtractedResult(harness, sessionId, prior, contentHash) {
-    return {
-        sessionId,
-        harness,
-        candidateCount: 0,
-        proposalIds: [],
-        preFilter: { inputCount: 0, outputCount: 0, truncatedCount: 0 },
-        warnings: [`already extracted (content unchanged) at ${prior?.processed_at}; pass --force to re-process`],
-        skipped: true,
-        skipReason: "already_extracted",
-        contentHash,
-    };
+    return { data, filtered, contentHash: hash };
 }
 function lockedConcurrentResult(harness, summary) {
-    return {
-        sessionId: summary.sessionId,
-        harness,
-        candidateCount: 0,
-        proposalIds: [],
-        preFilter: { inputCount: 0, outputCount: 0, truncatedCount: 0 },
+    return sessionOutcome(summary.sessionId, harness, {
         warnings: ["concurrent extract holds this session's lock — skipped (handled by the other run)"],
         skipped: true,
         skipReason: "locked_concurrent",
-    };
+    });
 }
+/**
+ * Classify candidates read-only, up to `maxSessionsPerRun` model sessions
+ * (explicit `--session-id` and `--force` are uncapped); the rest are deferred.
+ */
 function planExtractSessions(args) {
-    const { candidates, options, harness, seenMap, maxSessionsPerRun, trackingEnabled, dryRun } = args;
+    const { candidates, options, harness, maxSessionsPerRun, locking } = args;
+    const lockUnavailable = (summary) => locking &&
+        extractSessionLockIsUnavailable(harness.name, summary.sessionId, options.stateDbPath ?? getStateDbPath());
     const plans = [];
     let modelCount = 0;
     for (let index = 0; index < candidates.length; index++) {
-        if (options.signal?.aborted)
-            return { plans, deferredCandidates: candidates.slice(index) };
-        if (!options.sessionId && !options.force && maxSessionsPerRun > 0 && modelCount >= maxSessionsPerRun) {
+        const capped = !options.sessionId && !options.force && maxSessionsPerRun > 0 && modelCount >= maxSessionsPerRun;
+        if (options.signal?.aborted || capped)
             return { plans, deferredCandidates: candidates.slice(index) };
-        }
         const summary = candidates[index];
         if (!summary)
             continue;
-        if (trackingEnabled && !dryRun && !options.stateDb) {
-            if (extractSessionLockIsUnavailable(harness.name, summary.sessionId, options.stateDbPath ?? getStateDbPath())) {
-                plans.push({ kind: "skip", summary, result: lockedConcurrentResult(harness.name, summary) });
-                continue;
-            }
+        if (lockUnavailable(summary)) {
+            plans.push({ kind: "skip", summary, result: lockedConcurrentResult(harness.name, summary) });
+            continue;
         }
-        const gate = runPreLlmSessionGates({
-            harness,
-            sessionRef: summary,
-            prior: seenMap.get(summary.sessionId),
-            force: options.force === true,
-            maxTotalChars: args.maxTotalChars,
-            minContentChars: args.minContentChars,
-            triage: args.triage,
-        });
+        const prior = args.seenMap.get(summary.sessionId);
+        const gate = runPreLlmSessionGates(harness, summary, prior, options.force === true, args.gates);
         if ("skip" in gate) {
             plans.push({ kind: "skip", summary, result: gate.skip });
             continue;
         }
-        // Reading and classifying a session can take long enough for a concurrent
-        // session-end hook to claim its lock. Re-probe the fully classified model
-        // plan before it consumes a cap slot or forces credential materialization.
-        if (trackingEnabled &&
-            !dryRun &&
-            !options.stateDb &&
-            extractSessionLockIsUnavailable(harness.name, summary.sessionId, options.stateDbPath ?? getStateDbPath())) {
+        // Classifying can take long enough for a session-end hook to claim the lock.
+        if (lockUnavailable(summary)) {
             plans.push({ kind: "skip", summary, result: lockedConcurrentResult(harness.name, summary) });
             continue;
         }
@@ -551,42 +357,37 @@ function planExtractSessions(args) {
     return { plans, deferredCandidates: [] };
 }
 const EXTRACT_LLM_UNAVAILABLE = Symbol("extract-llm-unavailable");
-async function runSessionExtractionLlmCall(args) {
-    const { config, llmRunner, lease, chat, prompt, timeoutMs, signal, onNotices } = args;
+/**
+ * One session's extraction call. A connection without structured output gets
+ * one corrective retry; configuration errors escape before any state is written.
+ */
+async function extractFromSession(run, prompt) {
+    const { llmRunner } = run;
     try {
         const result = await runStructured({
             dispatch: async (feedback) => {
-                const content = feedback ? `${prompt}\n\n## Corrective output instruction\n\n${feedback}` : prompt;
-                const dispatched = await callStructured({
+                const outcome = await callStage({
                     feature: "session_extraction",
-                    akmConfig: config,
                     runner: llmRunner,
-                    lease,
-                    messages: [{ role: "user", content }],
+                    prompt: feedback ? `${prompt}\n\n## Corrective output instruction\n\n${feedback}` : prompt,
+                    gate: { config: run.config },
                     request: {
-                        timeoutMs,
+                        timeoutMs: run.timeoutMs,
                         responseSchema: EXTRACT_JSON_SCHEMA,
-                        ...(signal ? { signal } : {}),
-                        ...(chat ? { chat } : {}),
+                        ...(run.options.signal ? { signal: run.options.signal } : {}),
+                        ...(run.options.chat ? { chat: run.options.chat } : {}),
                     },
-                    onNotices,
-                    parse: (raw) => ({ kind: "response", raw: raw ?? "" }),
-                    onError: () => ({ kind: "unavailable" }),
-                    fallback: { kind: "unavailable" },
+                    onNotices: run.notices.add,
                 });
-                if (dispatched.kind === "unavailable")
+                if (!outcome.ok)
                     throw EXTRACT_LLM_UNAVAILABLE;
-                return dispatched.raw;
+                return outcome.raw;
             },
             parse: (raw) => {
                 const payload = parseExtractPayload(raw);
                 return payload.parseFailure ? undefined : payload;
             },
             validate: (payload) => ({ ok: true, value: payload }),
-            // One attempt when structured output is expected to work (not explicitly
-            // disabled, and this connection hasn't already proven otherwise this
-            // process — see `isJsonSchemaKnownUnsupported`); two when it's known
-            // unsupported and extraction is relying on looser prompt-contract JSON.
             maxAttempts: llmRunner.connection.supportsJsonSchema !== false && !isJsonSchemaKnownUnsupported(llmRunner.connection)
                 ? 1
                 : 2,
@@ -594,13 +395,14 @@ async function runSessionExtractionLlmCall(args) {
         });
         if (result.ok)
             return { kind: "success", payload: result.value, attempts: result.attempts };
-        const payload = parseExtractPayload(result.raw);
         return {
             kind: "malformed",
             raw: result.raw,
             attempts: result.attempts,
-            failure: payload.parseFailure ??
-                { code: "invalid_payload", message: result.errors.join("; ") },
+            failure: parseExtractPayload(result.raw).parseFailure ?? {
+                code: "invalid_payload",
+                message: result.errors.join("; "),
+            },
         };
     }
     catch (err) {
@@ -609,333 +411,148 @@ async function runSessionExtractionLlmCall(args) {
         throw err;
     }
 }
-function extractNoticeFields(getNotices) {
-    const notices = getNotices();
-    return notices.length > 0 ? { notices } : {};
-}
-function extractPreFilterStats(filtered) {
-    return {
-        inputCount: filtered.stats.inputCount,
-        outputCount: filtered.stats.outputCount,
-        truncatedCount: filtered.stats.truncatedCount,
-    };
-}
-function malformedExtractionResult(args) {
-    const { extraction, sessionRef, harness, preFilter, contentHash, notices } = args;
-    const diagnostic = `malformed_model_output: ${extraction.failure.message}; attempts=${extraction.attempts}; responseLength=${extraction.raw.length}; responseSha256=${sha256Hex(extraction.raw)}`;
-    warnVerbose(`[extract] malformed model output for session ${sessionRef.sessionId}: ${redactErrorBody(extraction.raw)}`);
-    return {
-        sessionId: sessionRef.sessionId,
-        harness,
-        candidateCount: 0,
-        proposalIds: [],
-        preFilter,
-        warnings: [diagnostic],
-        skipped: true,
-        skipReason: "malformed_model_output",
-        contentHash,
-        ...notices,
-    };
-}
-function unavailableExtractionResult(args) {
-    return {
-        sessionId: args.sessionRef.sessionId,
-        harness: args.harness,
-        candidateCount: 0,
-        proposalIds: [],
-        preFilter: args.preFilter,
-        warnings: ["session_extraction feature returned empty (disabled / timeout / error)"],
-        skipped: true,
-        skipReason: "llm_unavailable",
-        contentHash: args.contentHash,
-        ...args.notices,
-    };
-}
-// #561 — ADDITIVE session indexing. Generate + write the session asset
-// (`sessions/<harness>/<id>.md`). FAIL-OPEN: any failure only returns a
-// warning; it NEVER changes the proposal/skip outcome of extract. Returns the
-// frontmatter fields to merge into the per-session result for state-db
-// correlation. When disabled this makes NO LLM call and writes NOTHING.
-async function maybeWriteSessionAsset(runCtx, session) {
-    const { stashDir, lease, sessionIndexing, dryRun } = runCtx;
-    const { data } = session.gate;
-    if (!sessionIndexing.enabled || dryRun)
+/**
+ * Write the session's searchable asset (`sessions/<harness>/<id>.md`). Fails
+ * open: a failure is only a warning and never changes the extract outcome.
+ */
+async function maybeWriteSessionAsset(run, data) {
+    const { sessionIndexing } = run;
+    if (!sessionIndexing.enabled || run.dryRun)
         return {};
     if (!sessionMeetsDurationGate(data, sessionIndexing.minDurationMinutes))
         return {};
     try {
-        const result = await writeSessionAsset(data, stashDir, (summaryData) => sessionIndexing.generate(summaryData, lease));
-        if (result.written) {
-            // Write-path indexing (itself fail-open): standalone `akm extract`
-            // (session-end hook) has no post-loop reindex to pick this file up.
-            if (result.filePath)
-                await indexWrittenAssets(stashDir, [result.filePath]);
-            return {
-                ...(result.ref ? { sessionAssetRef: result.ref } : {}),
-                ...(result.logPath ? { sessionLogPath: result.logPath } : {}),
-            };
-        }
+        const result = await writeSessionAsset(data, run.stashDir, (summaryData) => sessionIndexing.generate(summaryData));
+        if (!result.written)
+            return {};
+        // A standalone extract has no post-loop reindex to pick the file up.
+        if (result.filePath)
+            await indexWrittenAssets(run.stashDir, [result.filePath]);
+        return {
+            ...(result.ref ? { sessionAssetRef: result.ref } : {}),
+            ...(result.logPath ? { sessionLogPath: result.logPath } : {}),
+        };
     }
     catch (err) {
         if (err instanceof ConfigError)
             throw err;
         return { warning: `session asset write failed: ${err instanceof Error ? err.message : String(err)}` };
     }
-    return {};
 }
-async function processSession(runCtx, session) {
-    const { harness, stashDir, config, llmRunner, lease, onNotices, getNotices, chat, ctx, eventsCtx, sourceRun, dryRun, timeoutMs, signal, standardsContext, } = runCtx;
-    const { sessionRef, gate } = session;
-    const warnings = [];
-    const { data, filtered, contentHash } = gate;
-    if (!lease)
-        throw new TypeError("extract model work requires an operation dispatch lease");
-    const prompt = buildExtractPrompt({
+async function processSession(run, sessionRef, gate) {
+    const { harness, stashDir, sourceRun, dryRun, options } = run;
+    const { data, filtered, contentHash: hash } = gate;
+    const base = { preFilter: preFilterStats(filtered), contentHash: hash };
+    const extraction = await extractFromSession(run, buildExtractPrompt({
         data,
         events: filtered.events,
         inlineRefs: data.inlineRefs,
-        ...(standardsContext.trim() ? { standardsContext } : {}),
-    });
-    const extraction = await runSessionExtractionLlmCall({
-        config,
-        llmRunner,
-        lease,
-        chat,
-        prompt,
-        timeoutMs,
-        signal,
-        onNotices,
-    });
+        ...(run.standardsContext.trim() ? { standardsContext: run.standardsContext } : {}),
+    }));
     if (extraction.kind === "unavailable") {
-        // The seam took the fallback path (disabled / timeout / error). Return skipped.
-        return unavailableExtractionResult({
-            sessionRef,
-            harness: harness.name,
-            preFilter: extractPreFilterStats(filtered),
-            contentHash,
-            notices: extractNoticeFields(getNotices),
+        return sessionOutcome(sessionRef.sessionId, harness.name, {
+            ...base,
+            warnings: ["session_extraction feature returned empty (disabled / timeout / error)"],
+            skipped: true,
+            skipReason: "llm_unavailable",
+            ...run.notices.fields(),
         });
     }
     if (extraction.kind === "malformed") {
-        return malformedExtractionResult({
-            extraction,
-            sessionRef,
-            harness: harness.name,
-            preFilter: extractPreFilterStats(filtered),
-            contentHash,
-            notices: extractNoticeFields(getNotices),
+        warnVerbose(`[extract] malformed model output for session ${sessionRef.sessionId}: ${redactErrorBody(extraction.raw)}`);
+        return sessionOutcome(sessionRef.sessionId, harness.name, {
+            ...base,
+            warnings: [
+                `malformed_model_output: ${extraction.failure.message}; attempts=${extraction.attempts}; responseLength=${extraction.raw.length}; responseSha256=${contentHash(extraction.raw)}`,
+            ],
+            skipped: true,
+            skipReason: "malformed_model_output",
+            ...run.notices.fields(),
         });
     }
     const { payload } = extraction;
+    const warnings = [];
+    // Provenance xrefs are added only after the cited session asset exists.
+    const { warning, ...sessionAsset } = await maybeWriteSessionAsset(run, data);
+    if (warning)
+        warnings.push(warning);
     const proposalIds = [];
-    // Provenance refs are added only after the cited session asset exists.
-    const sessionAsset = await maybeWriteSessionAsset(runCtx, session);
-    if (sessionAsset.warning)
-        warnings.push(sessionAsset.warning);
-    if (payload.candidates.length === 0) {
-        appendEvent({
-            eventType: "extract_invoked",
-            ...(sessionAsset.sessionAssetRef ? { ref: sessionAsset.sessionAssetRef } : {}),
-            metadata: {
-                outcome: "no_candidates",
-                sessionId: sessionRef.sessionId,
-                harness: harness.name,
-                sourceRun,
-                rationale: payload.rationale_if_empty,
-                repairAttempts: extraction.attempts - 1,
-                preFilterInput: filtered.stats.inputCount,
-                preFilterOutput: filtered.stats.outputCount,
-            },
-        }, eventsCtx);
-        return {
-            sessionId: sessionRef.sessionId,
-            harness: harness.name,
-            candidateCount: 0,
-            proposalIds: [],
-            ...(payload.rationale_if_empty ? { rationaleIfEmpty: payload.rationale_if_empty } : {}),
-            preFilter: {
-                inputCount: filtered.stats.inputCount,
-                outputCount: filtered.stats.outputCount,
-                truncatedCount: filtered.stats.truncatedCount,
-            },
-            warnings,
-            contentHash,
-            ...sessionAsset,
-            ...extractNoticeFields(getNotices),
-        };
-    }
-    // §23.6 fingerprint model-id term: the profile resolved for this session's
-    // LLM call (best-effort — an unconfigured profile leaves the term empty).
-    const extractModelId = llmRunner.connection.model;
-    for (const candidate of payload.candidates) {
-        const built = buildCandidateProposal(candidate, data.ref, sessionAsset.sessionAssetRef);
-        if (dryRun) {
-            proposalIds.push(`dry-run:${built.ref}`);
-            continue;
-        }
-        try {
-            const { ref, content, description } = built;
-            const result = emitProposal({ stashDir, proposalsCtx: ctx }, {
-                ref,
-                source: "extract",
-                sourceRun,
-                // §23.6 fingerprint model-id term (WI-6.4). The LLM already ran for
-                // this session, so the profile is resolvable; guard anyway.
-                ...(extractModelId ? { modelId: extractModelId } : {}),
-                payload: {
-                    content,
-                    frontmatter: {
-                        description,
-                        ...(candidate.when_to_use ? { when_to_use: candidate.when_to_use } : {}),
-                        confidence: candidate.confidence,
-                        ...(sessionAsset.sessionAssetRef ? { xrefs: [sessionAsset.sessionAssetRef] } : {}),
-                        evidence: candidate.evidence,
+    if (payload.candidates.length > 0) {
+        // A candidate the ledger holds a live window for (pending, or recently rejected) is not queued again.
+        const ledger = loadLedgerSnapshot({ proposalsCtx: options.ctx, eventsCtx: options.eventsCtx, ...(dryRun ? { readOnly: true } : {}) }, stashDir, ["extract"]);
+        const nowIso = new Date().toISOString();
+        for (const candidate of payload.candidates) {
+            const built = buildCandidateProposal(candidate, data.ref, sessionAsset.sessionAssetRef);
+            const ledgerRow = ledger.get(ledgerKey("extract", built.ref));
+            if (isLedgerBlocked(ledgerRow, nowIso)) {
+                warnings.push(`candidate ${candidate.type}:${candidate.name} skipped: ${ledgerRow?.outcome} until ${ledgerRow?.nextEligibleAt}`);
+                continue;
+            }
+            if (dryRun) {
+                proposalIds.push(`dry-run:${built.ref}`);
+                continue;
+            }
+            try {
+                const proposal = mintProposal(stashDir, options.ctx, {
+                    ref: built.ref,
+                    source: "extract",
+                    sourceRun,
+                    attemptedRefs: [built.ref],
+                    payload: {
+                        content: built.content,
+                        frontmatter: {
+                            description: built.description,
+                            ...(candidate.when_to_use ? { when_to_use: candidate.when_to_use } : {}),
+                            confidence: candidate.confidence,
+                            ...(sessionAsset.sessionAssetRef ? { xrefs: [sessionAsset.sessionAssetRef] } : {}),
+                            evidence: candidate.evidence,
+                        },
                     },
-                },
-            });
-            if (isProposalSkipped(result)) {
-                warnings.push(`candidate ${candidate.type}:${candidate.name} skipped: ${result.reason}: ${result.message}`);
+                });
+                proposalIds.push(proposal.id);
             }
-            else {
-                proposalIds.push(result.id);
+            catch (err) {
+                warnings.push(`candidate ${candidate.type}:${candidate.name} failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        catch (err) {
-            warnings.push(`candidate ${candidate.type}:${candidate.name} failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
     }
+    const empty = payload.candidates.length === 0;
     appendEvent({
         eventType: "extract_invoked",
         ...(sessionAsset.sessionAssetRef ? { ref: sessionAsset.sessionAssetRef } : {}),
         metadata: {
-            outcome: "candidates_queued",
+            outcome: empty ? "no_candidates" : "candidates_queued",
             sessionId: sessionRef.sessionId,
             harness: harness.name,
             sourceRun,
-            candidateCount: payload.candidates.length,
-            proposalCount: proposalIds.length,
+            ...(empty
+                ? { rationale: payload.rationale_if_empty }
+                : { candidateCount: payload.candidates.length, proposalCount: proposalIds.length }),
             preFilterInput: filtered.stats.inputCount,
             preFilterOutput: filtered.stats.outputCount,
             repairAttempts: extraction.attempts - 1,
         },
-    }, eventsCtx);
-    return {
-        sessionId: sessionRef.sessionId,
-        harness: harness.name,
+    }, options.eventsCtx);
+    return sessionOutcome(sessionRef.sessionId, harness.name, {
+        ...base,
         candidateCount: payload.candidates.length,
         proposalIds,
-        preFilter: {
-            inputCount: filtered.stats.inputCount,
-            outputCount: filtered.stats.outputCount,
-            truncatedCount: filtered.stats.truncatedCount,
-        },
+        ...(empty && payload.rationale_if_empty ? { rationaleIfEmpty: payload.rationale_if_empty } : {}),
         warnings,
-        contentHash,
         ...sessionAsset,
-        ...extractNoticeFields(getNotices),
-    };
-}
-function recordExtractSessionOutcome(args) {
-    const { stateDb, trackingEnabled, dryRun, harness, summary, result, sourceRun } = args;
-    if (!trackingEnabled ||
-        !stateDb ||
-        dryRun ||
-        result.skipReason === "already_extracted" ||
-        result.skipReason === "locked_concurrent")
-        return;
-    try {
-        const outcome = result.skipped
-            ? result.skipReason === "read_failed" ||
-                result.skipReason === "exception" ||
-                result.skipReason === "malformed_model_output"
-                ? "failed"
-                : "skipped"
-            : result.candidateCount === 0
-                ? "no_candidates"
-                : "candidates_queued";
-        upsertExtractedSession(stateDb, {
-            harness,
-            sessionId: summary.sessionId,
-            processedAt: new Date().toISOString(),
-            sessionEndedAt: summary.endedAt ?? null,
-            outcome,
-            candidateCount: result.candidateCount,
-            proposalCount: result.proposalIds.length,
-            rationale: result.rationaleIfEmpty ?? null,
-            sourceRun,
-            contentHash: result.skipReason === "llm_unavailable" ||
-                result.skipReason === "triaged_out" ||
-                result.skipReason === "malformed_model_output"
-                ? null
-                : (result.contentHash ?? null),
-            metadata: {
-                preFilterInputCount: result.preFilter.inputCount,
-                preFilterOutputCount: result.preFilter.outputCount,
-                preFilterTruncatedCount: result.preFilter.truncatedCount,
-                engine: result.engine,
-                ...(result.skipReason ? { skipReason: result.skipReason } : {}),
-                ...(result.sessionLogPath ? { logPath: result.sessionLogPath } : {}),
-                ...(result.sessionAssetRef ? { sessionAssetRef: result.sessionAssetRef } : {}),
-            },
-        });
-    }
-    catch (err) {
-        warn(`[extract] failed to record session ${summary.sessionId} in state.db: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-function accountExtractSessionResult(result, triageEnabled, output) {
-    const stamped = { ...result, engine: output.engine };
-    output.sessions.push(stamped);
-    if (triageEnabled) {
-        const preempted = result.skipReason === "read_failed" ||
-            result.skipReason === "too_short" ||
-            result.skipReason === "already_extracted" ||
-            result.skipReason === "locked_concurrent";
-        if (!preempted) {
-            output.triageEvaluated += 1;
-            if (result.skipReason === "triaged_out")
-                output.triagedOut += 1;
-            else
-                output.triagePassed += 1;
-        }
-    }
-    if (result.skipped)
-        output.skippedCount += 1;
-    else
-        output.processedCount += 1;
-    output.allProposalIds.push(...result.proposalIds);
-    return stamped;
+        ...run.notices.fields(),
+    });
 }
 /**
- * Iterate the discovered candidate sessions: enforce the per-run cap, take the
- * per-session cross-process lock, dispatch to {@link processSession}, aggregate
- * the #626 triage counters, and persist each seen-row outcome. Extracted verbatim
- * from `akmExtract` — the maxSessionsPerRun break, lock/skip accounting, triage
- * aggregation, and seen-row upsert are byte-identical.
+ * Work the plans: claim each model session's lock, re-read and re-gate it
+ * under the lock (the log may have changed since planning), extract, and
+ * record the outcome in the seen-session table. A skipped or locked session
+ * refills its model slot from the deferred candidates.
  */
-async function runExtractSessionLoop(args) {
-    const { plans, deferredCandidates, seenMap, options, harness, stateDb, trackingEnabled, dryRun, stashDir, config, llmRunner, lease, onNotices, getNotices, chat, sourceRun, timeoutMs, triage, sessionIndexing, extractStandardsContext, topLevelWarnings, } = args;
-    // WI-7.7 §2: run-scoped processSession inputs, resolved once per run.
-    const sessionRunCtx = {
-        harness,
-        stashDir,
-        config,
-        llmRunner,
-        lease,
-        onNotices,
-        getNotices,
-        chat,
-        ctx: options.ctx,
-        eventsCtx: options.eventsCtx,
-        sourceRun,
-        dryRun,
-        timeoutMs,
-        sessionIndexing,
-        signal: options.signal,
-        standardsContext: extractStandardsContext,
-    };
-    const output = {
-        engine: llmRunner.engine,
+async function runExtractSessionLoop(run, planned, seenMap, stateDb, tracking, topLevelWarnings) {
+    const { options, harness, gates, dryRun } = run;
+    const locking = tracking && !dryRun && !options.stateDb;
+    const tally = {
         sessions: [],
         processedCount: 0,
         skippedCount: 0,
@@ -945,103 +562,78 @@ async function runExtractSessionLoop(args) {
         allProposalIds: [],
         deferred: 0,
     };
-    const workPlans = [...plans];
-    let remainingCandidates = deferredCandidates;
+    const account = (result) => {
+        const stamped = { ...result, engine: run.llmRunner.engine };
+        tally.sessions.push(stamped);
+        const preempted = ["read_failed", "too_short", "already_extracted", "locked_concurrent"].includes(result.skipReason ?? "");
+        if (gates.triage.enabled && !preempted) {
+            tally.triageEvaluated += 1;
+            if (result.skipReason === "triaged_out")
+                tally.triagedOut += 1;
+            else
+                tally.triagePassed += 1;
+        }
+        if (result.skipped)
+            tally.skippedCount += 1;
+        else
+            tally.processedCount += 1;
+        tally.allProposalIds.push(...result.proposalIds);
+        return stamped;
+    };
+    const accountAndRecord = (summary, result) => {
+        recordSessionOutcome(stateDb, tracking && !dryRun, harness.name, summary, account(result), run.sourceRun);
+    };
+    const workPlans = [...planned.plans];
+    let remaining = planned.deferredCandidates;
     const refillModelSlot = () => {
-        if (remainingCandidates.length === 0 || options.signal?.aborted)
+        if (remaining.length === 0 || options.signal?.aborted)
             return;
         const refill = planExtractSessions({
-            candidates: remainingCandidates,
+            candidates: remaining,
             options,
             harness,
             seenMap,
-            maxTotalChars: args.maxTotalChars,
-            minContentChars: args.minContentChars,
+            gates,
             maxSessionsPerRun: 1,
-            triage,
-            trackingEnabled,
-            dryRun,
+            locking,
         });
         workPlans.push(...refill.plans);
-        remainingCandidates = refill.deferredCandidates;
+        remaining = refill.deferredCandidates;
     };
     for (const plan of workPlans) {
         if (options.signal?.aborted)
             break;
         const { summary } = plan;
         if (plan.kind === "skip") {
-            const accounted = accountExtractSessionResult(plan.result, triage.enabled, output);
-            recordExtractSessionOutcome({
-                stateDb,
-                trackingEnabled,
-                dryRun,
-                harness: harness.name,
-                summary,
-                result: accounted,
-                sourceRun,
-            });
+            accountAndRecord(summary, plan.result);
             continue;
         }
-        let sessionLockOwnership;
-        if (trackingEnabled && !dryRun && !options.stateDb) {
-            const sessionLockPath = getExtractSessionLockPath(harness.name, summary.sessionId, options.stateDbPath ?? getStateDbPath());
-            const sessionLock = acquireExtractSessionLock(sessionLockPath);
-            if (!sessionLock.proceed) {
-                accountExtractSessionResult(lockedConcurrentResult(harness.name, summary), triage.enabled, output);
+        let lockOwnership;
+        if (locking) {
+            const lock = acquireExtractSessionLock(extractSessionLockPath(harness.name, summary.sessionId, options.stateDbPath ?? getStateDbPath()));
+            if (!lock.proceed) {
+                account(lockedConcurrentResult(harness.name, summary));
                 refillModelSlot();
                 continue;
             }
-            sessionLockOwnership = sessionLock.ownership;
+            lockOwnership = lock.ownership;
         }
         try {
-            // Planning stays read-only so a credential failure creates no state. Once
-            // this run owns the session lock, read and gate the session again: the log
-            // may have grown, become too short after replacement, or been completed by
-            // another extractor between the planning snapshot and acquisition.
-            const currentPrior = stateDb
+            const prior = stateDb
                 ? getExtractedSessionsMap(stateDb, harness.name, [summary.sessionId]).get(summary.sessionId)
                 : seenMap.get(summary.sessionId);
-            const executionGate = runPreLlmSessionGates({
-                harness,
-                sessionRef: summary,
-                prior: currentPrior,
-                force: options.force === true,
-                maxTotalChars: args.maxTotalChars,
-                minContentChars: args.minContentChars,
-                triage,
-            });
-            if ("skip" in executionGate) {
-                const accounted = accountExtractSessionResult(executionGate.skip, triage.enabled, output);
-                recordExtractSessionOutcome({
-                    stateDb,
-                    trackingEnabled,
-                    dryRun,
-                    harness: harness.name,
-                    summary,
-                    result: accounted,
-                    sourceRun,
-                });
+            const gate = runPreLlmSessionGates(harness, summary, prior, options.force === true, gates);
+            if ("skip" in gate) {
+                accountAndRecord(summary, gate.skip);
                 refillModelSlot();
                 continue;
             }
-            const result = await processSession(sessionRunCtx, {
-                sessionRef: summary,
-                gate: executionGate,
-            });
+            const result = await processSession(run, summary, gate);
             if (result.skipReason === "malformed_model_output") {
                 for (const warning of result.warnings)
                     topLevelWarnings.push(`session ${summary.sessionId}: ${warning}`);
             }
-            const accounted = accountExtractSessionResult(result, triage.enabled, output);
-            recordExtractSessionOutcome({
-                stateDb,
-                trackingEnabled,
-                dryRun,
-                harness: harness.name,
-                summary,
-                result: accounted,
-                sourceRun,
-            });
+            accountAndRecord(summary, result);
         }
         catch (err) {
             if (err instanceof ConfigError)
@@ -1049,171 +641,158 @@ async function runExtractSessionLoop(args) {
             const msg = err instanceof Error ? err.message : String(err);
             warn(`[extract] session ${summary.sessionId} threw: ${msg}`);
             topLevelWarnings.push(`session ${summary.sessionId} threw: ${msg}`);
-            accountExtractSessionResult({
-                sessionId: summary.sessionId,
-                harness: harness.name,
-                candidateCount: 0,
-                proposalIds: [],
-                preFilter: { inputCount: 0, outputCount: 0, truncatedCount: 0 },
+            account(sessionOutcome(summary.sessionId, harness.name, {
                 warnings: [msg],
                 skipped: true,
                 skipReason: "exception",
-                ...extractNoticeFields(getNotices),
-            }, triage.enabled, output);
+                ...run.notices.fields(),
+            }));
         }
         finally {
-            if (sessionLockOwnership)
-                releaseLock(sessionLockOwnership);
+            if (lockOwnership)
+                releaseLock(lockOwnership);
         }
     }
-    output.deferred = remainingCandidates.length;
-    return output;
+    tally.deferred = remaining.length;
+    return tally;
 }
 /**
- * Resolve the run-scoped LLM/engine, budget, triage, and session-indexing
- * settings for one extract invocation (throwing when no engine is configured).
- * Extracted verbatim from `akmExtract` — the timeout precedence chain, the
- * session-summary generator seam, and the default resolutions are byte-identical.
+ * Persist a session's outcome in the seen-session table. A session skipped as
+ * already extracted or locked is not rewritten; one that failed for a
+ * transient reason keeps a null hash so it is retried.
  */
-function resolveExtractRunConfig(options, config, extractProcess, activeProfile) {
-    const executionNotices = new Map();
-    const onNotices = (notices) => {
-        for (const notice of notices)
-            executionNotices.set(JSON.stringify(notice), notice);
-    };
-    const getNotices = () => Object.freeze([...executionNotices.values()]);
-    // Improve supplies its invocation-owned symbolic runner. Standalone extract
-    // resolves the selected process engine through the shared execution planner.
+function recordSessionOutcome(stateDb, enabled, harness, summary, result, sourceRun) {
+    if (!enabled || !stateDb)
+        return;
+    if (result.skipReason === "already_extracted" || result.skipReason === "locked_concurrent")
+        return;
+    const reason = result.skipReason ?? "";
+    try {
+        upsertExtractedSession(stateDb, {
+            harness,
+            sessionId: summary.sessionId,
+            processedAt: new Date().toISOString(),
+            sessionEndedAt: summary.endedAt ?? null,
+            outcome: result.skipped
+                ? ["read_failed", "exception", "malformed_model_output"].includes(reason)
+                    ? "failed"
+                    : "skipped"
+                : result.candidateCount === 0
+                    ? "no_candidates"
+                    : "candidates_queued",
+            candidateCount: result.candidateCount,
+            proposalCount: result.proposalIds.length,
+            rationale: result.rationaleIfEmpty ?? null,
+            sourceRun,
+            contentHash: ["llm_unavailable", "triaged_out", "malformed_model_output"].includes(reason)
+                ? null
+                : (result.contentHash ?? null),
+            metadata: {
+                preFilterInputCount: result.preFilter.inputCount,
+                preFilterOutputCount: result.preFilter.outputCount,
+                preFilterTruncatedCount: result.preFilter.truncatedCount,
+                engine: result.engine,
+                ...(result.skipReason ? { skipReason: result.skipReason } : {}),
+                ...(result.sessionLogPath ? { logPath: result.sessionLogPath } : {}),
+                ...(result.sessionAssetRef ? { sessionAssetRef: result.sessionAssetRef } : {}),
+            },
+        });
+    }
+    catch (err) {
+        warn(`[extract] failed to record session ${summary.sessionId} in state.db: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/** The run's runner, budgets, gates and session-indexing settings (throws without an engine). */
+function resolveExtractRun(options, config, process, activeProfile) {
+    const notices = noticeSet();
     let llmRunner;
     if (options.resolvedPlan) {
         llmRunner = options.resolvedPlan.runner;
-        onNotices(options.resolvedPlan.notices ?? []);
+        notices.add(options.resolvedPlan.notices ?? []);
     }
     else if (options.llmRunner) {
         llmRunner = options.llmRunner;
     }
     else {
-        const resolved = resolveImproveLlmExecution({
-            config,
-            profile: activeProfile,
-            process: extractProcess,
-            processName: "extract",
-        });
+        const resolved = resolveImproveLlmExecution({ config, profile: activeProfile, process, processName: "extract" });
         llmRunner = resolved?.runner;
         if (resolved)
-            onNotices(resolved.notices);
+            notices.add(resolved.notices);
     }
     if (!llmRunner) {
         throw new ConfigError("No LLM engine configured for extract. Set defaults.llmEngine or improve.strategies.<name>.processes.extract.engine.", "LLM_NOT_CONFIGURED");
     }
+    const runner = llmRunner;
     const timeoutMs = options.resolvedPlan
         ? options.resolvedPlan.timeoutMs
         : Object.hasOwn(options, "timeoutMs")
             ? (options.timeoutMs ?? null)
-            : Object.hasOwn(llmRunner, "timeoutMs")
-                ? (llmRunner.timeoutMs ?? null)
+            : Object.hasOwn(runner, "timeoutMs")
+                ? (runner.timeoutMs ?? null)
                 : 600_000;
-    // 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
-    // entirely. Set `processes.extract.minContentChars: 0` to disable the gate.
-    const minContentChars = typeof extractProcess?.minContentChars === "number" ? extractProcess.minContentChars : DEFAULT_MIN_CONTENT_CHARS;
-    // Cap on NEW sessions LLM-processed per run; 0 disables. Absent = default.
-    // Bounds per-run wall time / LLM cost so a backlog can't push a run past its
-    // task timeout — the overflow stays unseen and is picked up by later runs.
-    const maxSessionsPerRun = options.since
-        ? 0
-        : typeof extractProcess?.maxSessionsPerRun === "number"
-            ? extractProcess.maxSessionsPerRun
-            : DEFAULT_MAX_SESSIONS_PER_RUN;
-    // Default discovery window — process config can override the built-in 24h.
-    const effectiveSince = options.since ?? extractProcess?.defaultSince;
-    // #626 — resolve the triage gate config once per run. Default-off → the
-    // per-session path never calls the scorer and emits no telemetry.
-    const triage = resolveTriageConfig(extractProcess);
-    // #561 — resolve session-indexing config. Default ON: we only reach this code
-    // when `session_extraction` is enabled AND an LLM is configured (both checked
-    // above), so defaulting on costs nothing offline (the summary call fails open)
-    // while making sessions searchable in the common LLM-configured case. Set
-    // `processes.extract.indexSessions: false` for byte-identical legacy behaviour.
-    const sessionIndexingEnabled = extractProcess?.indexSessions ?? true;
-    const minSessionDuration = typeof extractProcess?.minSessionDuration === "number"
-        ? extractProcess.minSessionDuration
-        : DEFAULT_MIN_SESSION_DURATION_MINUTES;
-    // Production summary generator: a bounded in-tree LLM call wrapped in the
-    // same fail-open `callStructured` seam as the rest of extract. Returns
-    // `undefined` on disablement / timeout / error so no asset is written.
-    // Tests inject a fake.
-    const defaultSessionSummaryGenerator = async (data, lease) => {
-        let raw = "";
-        await callStructured({
+    const triage = process?.triage;
+    // The default summary generator fails open: no summary, no session asset.
+    const generate = async (data) => {
+        const outcome = await callStage({
             feature: "session_extraction",
-            akmConfig: config,
-            runner: llmRunner,
-            ...(lease ? { lease } : {}),
-            messages: [{ role: "user", content: buildSessionSummaryPrompt(data) }],
+            runner,
+            prompt: buildSessionSummaryPrompt(data),
+            gate: { config },
             request: {
                 timeoutMs,
                 responseSchema: SESSION_SUMMARY_JSON_SCHEMA,
                 ...(options.signal ? { signal: options.signal } : {}),
                 ...(options.chat ? { chat: options.chat } : {}),
             },
-            onNotices,
-            parse: (r) => {
-                raw = r ?? "";
-                return raw;
-            },
-            onError: () => "",
-            fallback: "",
+            onNotices: notices.add,
         });
-        return parseSessionSummary(raw);
-    };
-    const sessionIndexing = {
-        enabled: sessionIndexingEnabled,
-        minDurationMinutes: minSessionDuration,
-        generate: options.generateSessionSummary ?? defaultSessionSummaryGenerator,
+        return parseSessionSummary(outcome.ok ? outcome.raw : "");
     };
     return {
+        llmRunner: runner,
+        notices,
         timeoutMs,
-        llmRunner,
-        onNotices,
-        getNotices,
-        maxTotalChars,
-        minContentChars,
-        maxSessionsPerRun,
-        effectiveSince,
-        triage,
-        sessionIndexing,
+        gates: {
+            maxTotalChars: typeof process?.maxTotalChars === "number" ? process.maxTotalChars : undefined,
+            minContentChars: typeof process?.minContentChars === "number" ? process.minContentChars : DEFAULT_MIN_CONTENT_CHARS,
+            triage: {
+                enabled: triage?.enabled === true,
+                minScore: typeof triage?.minScore === "number" ? triage.minScore : DEFAULT_TRIAGE_MIN_SCORE,
+            },
+        },
+        maxSessionsPerRun: options.since
+            ? 0
+            : typeof process?.maxSessionsPerRun === "number"
+                ? process.maxSessionsPerRun
+                : DEFAULT_MAX_SESSIONS_PER_RUN,
+        effectiveSince: options.since ?? process?.defaultSince,
+        sessionIndexing: {
+            enabled: process?.indexSessions ?? true,
+            minDurationMinutes: typeof process?.minSessionDuration === "number"
+                ? process.minSessionDuration
+                : DEFAULT_MIN_SESSION_DURATION_MINUTES,
+            generate: options.generateSessionSummary ?? generate,
+        },
     };
 }
-/**
- * Resolve the session set to process: the single `--session-id` target (or a
- * not-found envelope) or the discovery-window listing. Extracted verbatim from
- * `akmExtract`; the 48h default-since floor and location filter are unchanged.
- */
+/** The sessions to process: the `--session-id` target (or a not-found envelope) or the discovery window. */
 function discoverExtractCandidates(options, harness, effectiveSince, startMs, dryRun, llmRunner) {
+    const location = options.location ? { location: options.location } : {};
     if (options.sessionId) {
-        const all = harness.listSessions({
-            ...(options.location ? { location: options.location } : {}),
-        });
-        const target = all.find((s) => s.sessionId === options.sessionId);
-        if (!target) {
-            return {
-                notFound: emptyExtractResult({
-                    ok: false,
-                    dryRun,
-                    type: options.type,
-                    warning: `session ${options.sessionId} not found for harness ${options.type}`,
-                    startMs,
-                    llmRunner,
-                }),
-            };
-        }
-        return { candidates: [target] };
+        const target = harness.listSessions(location).find((s) => s.sessionId === options.sessionId);
+        if (target)
+            return { candidates: [target] };
+        return {
+            notFound: emptyExtractResult({
+                ok: false,
+                dryRun,
+                type: options.type,
+                warning: `session ${options.sessionId} not found for harness ${options.type}`,
+                startMs,
+                llmRunner,
+            }),
+        };
     }
-    // No explicit `--since`/`defaultSince` → default to "since the last run"
-    // (floored at 48h) so an intermittently-online host doesn't lose sessions
-    // that ended while it was off. See {@link resolveDefaultSinceMs}.
     const sinceMs = effectiveSince
         ? parseSinceArg(effectiveSince)
         : resolveDefaultSinceMs(harness.name, startMs, {
@@ -1221,38 +800,10 @@ function discoverExtractCandidates(options, harness, effectiveSince, startMs, dr
             ...(options.stateDbPath ? { stateDbPath: options.stateDbPath } : {}),
             ...(options.skipTracking ? { skipTracking: options.skipTracking } : {}),
         });
-    return {
-        candidates: harness.listSessions({
-            sinceMs,
-            ...(options.location ? { location: options.location } : {}),
-        }),
-    };
+    return { candidates: harness.listSessions({ sinceMs, ...location }) };
 }
-// ── Public entrypoint ────────────────────────────────────────────────────────
-/**
- * WI-9.10: build one `akm extract` run's {@link RunContext} from values
- * `akmExtract` has already resolved by the time it calls this (config,
- * stashDir, dryRun, sourceRun, and `resolveExtractRunConfig`'s symbolic runner)
- * — no second config load, credential materialization, or new db handle.
- */
-function buildExtractRunContext(args) {
-    const { options, config, stashDir, dryRun, sourceRun, llmRunner } = args;
-    return createRunContext({
-        stashDir,
-        config,
-        eventsCtx: options.eventsCtx ?? {},
-        // Not yet wired into any proposal call site this stage (mirrors
-        // buildImproveRunContext's proposalsCtx comment in improve.ts).
-        proposalsCtx: options.ctx ?? {},
-        getLlmRunner: () => llmRunner,
-        sourceRun,
-        dryRun,
-        signal: options.signal,
-    });
-}
-function loadExtractSeenMapReadOnly(args) {
-    const { options, harness, candidates, trackingEnabled, warnings } = args;
-    if (!trackingEnabled || candidates.length === 0)
+function loadSeenMapReadOnly(options, harness, candidates, warnings) {
+    if (options.skipTracking === true || candidates.length === 0)
         return new Map();
     let snapshot;
     try {
@@ -1273,84 +824,22 @@ function loadExtractSeenMapReadOnly(args) {
         snapshot?.close();
     }
 }
-function openExtractLiveStateDb(args) {
-    const { options, trackingEnabled, hasModelWork, dryRun, warnings } = args;
-    if (!trackingEnabled)
-        return undefined;
-    if (options.stateDb)
-        return options.stateDb;
-    if (!hasModelWork || dryRun)
-        return undefined;
-    try {
-        return openStateDatabase(options.stateDbPath);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        warn(`[extract] state.db unavailable, processing without skip-tracking: ${msg}`);
-        warnings.push(`state.db unavailable: ${msg}`);
-        return undefined;
-    }
-}
-function emitExtractTriageEvent(args) {
-    const { modelPlanCount, triageEnabled, result, sourceRun, eventsCtx } = args;
-    if (modelPlanCount === 0 || !triageEnabled || result.triageEvaluated === 0)
-        return;
-    appendEvent({
-        eventType: "extract_triaged",
-        metadata: {
-            evaluated: result.triageEvaluated,
-            passed: result.triagePassed,
-            triagedOut: result.triagedOut,
-            sourceRun,
-        },
-    }, eventsCtx);
-}
-/**
- * Count every session's `skipReason` (#912) and push one warning line per
- * infrastructure reason in {@link EXTRACT_INFRASTRUCTURE_SKIP_REASONS}.
- * `undefined` when nothing was skipped, so the envelope carries no key.
- */
-function buildExtractSkipAggregate(sessions, engine, warnings) {
-    const counts = {};
-    for (const session of sessions) {
-        if (!session.skipReason)
-            continue;
-        counts[session.skipReason] = (counts[session.skipReason] ?? 0) + 1;
-    }
-    if (Object.keys(counts).length === 0)
-        return undefined;
-    const total = sessions.length;
-    for (const reason of EXTRACT_INFRASTRUCTURE_SKIP_REASONS) {
-        const n = counts[reason];
-        if (n)
-            warnings.push(`${n} of ${total} sessions skipped: ${reason} (engine "${engine}")`);
-    }
-    return counts;
-}
 export async function akmExtract(options) {
     const startMs = Date.now();
     if (!options.type || options.type.trim() === "") {
         throw new UsageError("--type is required. Pass a harness name (e.g. --type claude).", "MISSING_REQUIRED_ARGUMENT");
     }
     const config = options.config ?? loadConfig();
-    const stashDir = resolveRunStashDir(options.stashDir);
+    const stashDir = options.stashDir ?? resolveStashDir();
     const dryRun = options.dryRun ?? false;
     const sourceRun = options.sourceRun ?? `extract-${timestampForFilename()}`;
-    // 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.
+    // Behavior comes from the frozen standalone plan or the active improve strategy.
     const activeProfile = options.improveProfile ?? (options.resolvedPlan ? undefined : resolveImproveStrategy(undefined, config).config);
-    const extractProcess = options.resolvedPlan?.process ?? getImproveProcessConfig("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 = options.resolvedPlan?.enabled ??
+    const process = options.resolvedPlan?.process ?? getImproveProcessConfig("extract", activeProfile);
+    // The extract toggle gates extract as an improve STAGE; an explicit `akm extract` always runs.
+    const enabled = options.resolvedPlan?.enabled ??
         (options.improveProfile ? resolveProcessEnabled("extract", options.improveProfile) : true);
-    // Feature-gate early so we get a clean "skipped because disabled" envelope.
-    if (!extractEnabled) {
+    if (!enabled) {
         return emptyExtractResult({
             ok: true,
             dryRun,
@@ -1359,101 +848,72 @@ export async function akmExtract(options) {
             startMs,
         });
     }
-    const { timeoutMs, llmRunner, onNotices, getNotices, maxTotalChars, minContentChars, maxSessionsPerRun, effectiveSince, triage, sessionIndexing, } = resolveExtractRunConfig(options, config, extractProcess, activeProfile);
-    // WI-9.10: construct this run's RunContext (extracted to
-    // buildExtractRunContext to keep akmExtract under the fn-size bar — R31).
-    const ctx = buildExtractRunContext({ options, config, stashDir, dryRun, sourceRun, llmRunner });
-    const harness = resolveHarness(options.type, options.harnesses);
-    if (!harness) {
+    const resolved = resolveExtractRun(options, config, process, activeProfile);
+    const { llmRunner, notices } = resolved;
+    const harness = (options.harnesses ?? getAvailableHarnesses()).find((h) => h.name === options.type);
+    const unavailable = !harness
+        ? `no available harness matches type "${options.type}" (check that the platform is installed)`
+        : !harness.isAvailable()
+            ? `harness ${options.type} is registered but reports not-available (no session data on this machine)`
+            : undefined;
+    if (!harness || unavailable) {
         return emptyExtractResult({
             ok: false,
             dryRun,
             type: options.type,
-            warning: `no available harness matches type "${options.type}" (check that the platform is installed)`,
+            warning: unavailable ?? "",
             startMs,
             llmRunner,
         });
     }
-    if (!harness.isAvailable()) {
-        return emptyExtractResult({
-            ok: false,
-            dryRun,
-            type: options.type,
-            warning: `harness ${options.type} is registered but reports not-available (no session data on this machine)`,
-            startMs,
-            llmRunner,
-        });
-    }
-    // Decide which sessions to process: explicit sessionId OR discovery via since.
-    const discovery = discoverExtractCandidates(options, harness, effectiveSince, startMs, dryRun, llmRunner);
+    const discovery = discoverExtractCandidates(options, harness, resolved.effectiveSince, startMs, dryRun, llmRunner);
     if ("notFound" in discovery)
         return discovery.notFound;
-    const candidates = discovery.candidates;
     const topLevelWarnings = [];
-    const trackingEnabled = options.skipTracking !== true;
-    const seenMap = loadExtractSeenMapReadOnly({
-        options,
-        harness: harness.name,
-        candidates,
-        trackingEnabled,
-        warnings: topLevelWarnings,
-    });
+    const tracking = options.skipTracking !== true;
+    const seenMap = loadSeenMapReadOnly(options, harness.name, discovery.candidates, topLevelWarnings);
     const planned = planExtractSessions({
-        candidates,
+        candidates: discovery.candidates,
         options,
         harness,
         seenMap,
-        maxTotalChars,
-        minContentChars,
-        maxSessionsPerRun,
-        triage,
-        trackingEnabled,
-        dryRun,
+        gates: resolved.gates,
+        maxSessionsPerRun: resolved.maxSessionsPerRun,
+        locking: tracking && !dryRun && !options.stateDb,
     });
     const modelPlanCount = planned.plans.filter((plan) => plan.kind === "model").length;
-    // Eligible dry-runs still dispatch to produce their candidate preview. Only
-    // deterministic no-work plans are credential-free. Materialize once after
-    // every read-only gate and before opening live state or acquiring a lock.
-    const dispatchLease = modelPlanCount > 0 ? await preflightStructuredLlmRunner(llmRunner) : undefined;
+    // Credentials are materialized once, after every read-only gate and before live state or a lock.
+    if (modelPlanCount > 0)
+        assertRunnerCredentials(llmRunner);
     let stateDb;
-    let loopResult;
+    let tally;
     try {
-        stateDb = openExtractLiveStateDb({
-            options,
-            trackingEnabled,
-            hasModelWork: modelPlanCount > 0,
-            dryRun,
-            warnings: topLevelWarnings,
-        });
-        // Stash authoring standards (convention/meta fact bodies) for non-wiki
-        // extract output. Resolved ONCE per run and threaded into each session's
-        // prompt so facts are not re-read per session.
-        const extractStandardsContext = modelPlanCount > 0 ? resolveExtractStandards(stashDir) : "";
-        loopResult = await runExtractSessionLoop({
-            plans: planned.plans,
-            deferredCandidates: planned.deferredCandidates,
-            seenMap,
+        if (tracking) {
+            if (options.stateDb) {
+                stateDb = options.stateDb;
+            }
+            else if (modelPlanCount > 0 && !dryRun) {
+                try {
+                    stateDb = openStateDatabase(options.stateDbPath);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    warn(`[extract] state.db unavailable, processing without skip-tracking: ${msg}`);
+                    topLevelWarnings.push(`state.db unavailable: ${msg}`);
+                }
+            }
+        }
+        const run = {
+            ...resolved,
             options,
             harness,
-            stateDb,
-            trackingEnabled,
-            dryRun,
             stashDir,
             config,
-            llmRunner,
-            lease: dispatchLease,
-            onNotices,
-            getNotices,
-            chat: options.chat,
             sourceRun,
-            timeoutMs,
-            maxTotalChars,
-            minContentChars,
-            triage,
-            sessionIndexing,
-            extractStandardsContext,
-            topLevelWarnings,
-        });
+            dryRun,
+            standardsContext: modelPlanCount > 0 ? resolveExtractStandards(stashDir) : "",
+        };
+        tally = await runExtractSessionLoop(run, planned, seenMap, stateDb, tracking, topLevelWarnings);
     }
     finally {
         if (stateDb && !options.stateDb) {
@@ -1461,70 +921,62 @@ export async function akmExtract(options) {
                 stateDb.close();
             }
             catch {
-                // best-effort close
+                // best-effort
             }
         }
-        if (dispatchLease)
-            disposeLoweredExecutionDispatchLease(dispatchLease);
     }
-    const { sessions, processedCount, skippedCount, allProposalIds } = loopResult;
-    if (loopResult.deferred > 0) {
-        topLevelWarnings.push(`Reached maxSessionsPerRun=${maxSessionsPerRun}; ${loopResult.deferred} session(s) deferred to a later run.`);
+    if (tally.deferred > 0) {
+        topLevelWarnings.push(`Reached maxSessionsPerRun=${resolved.maxSessionsPerRun}; ${tally.deferred} session(s) deferred to a later run.`);
+    }
+    // Every skip reason is counted; infrastructure failures also get a warning line.
+    const counts = {};
+    for (const session of tally.sessions) {
+        if (session.skipReason)
+            counts[session.skipReason] = (counts[session.skipReason] ?? 0) + 1;
+    }
+    for (const reason of EXTRACT_INFRASTRUCTURE_SKIP_REASONS) {
+        const n = counts[reason];
+        if (n)
+            topLevelWarnings.push(`${n} of ${tally.sessions.length} sessions skipped: ${reason} (engine "${llmRunner.engine}")`);
+    }
+    if (modelPlanCount > 0 && resolved.gates.triage.enabled && tally.triageEvaluated > 0) {
+        appendEvent({
+            eventType: "extract_triaged",
+            metadata: {
+                evaluated: tally.triageEvaluated,
+                passed: tally.triagePassed,
+                triagedOut: tally.triagedOut,
+                sourceRun,
+            },
+        }, options.eventsCtx);
     }
-    const skipReasons = buildExtractSkipAggregate(sessions, llmRunner.engine, topLevelWarnings);
-    emitExtractTriageEvent({
-        modelPlanCount,
-        triageEnabled: triage.enabled,
-        result: loopResult,
-        sourceRun,
-        eventsCtx: options.eventsCtx,
-    });
     return {
         schemaVersion: 1,
         ok: true,
         shape: "extract-result",
-        // Sourced from ctx (identical value to the local `dryRun` — see the
-        // RunContext construction above) so the constructed RunContext has a
-        // genuine downstream reference in this verb, which currently has no
-        // content-read site to route through ctx.readAsset (see the WI-9.10c
-        // report).
-        dryRun: ctx.dryRun,
+        dryRun,
         type: options.type,
-        sessionsProcessed: processedCount,
-        sessionsSkipped: skippedCount,
-        candidatesCreated: allProposalIds.length,
-        proposals: allProposalIds,
-        sessions,
+        sessionsProcessed: tally.processedCount,
+        sessionsSkipped: tally.skippedCount,
+        candidatesCreated: tally.allProposalIds.length,
+        proposals: tally.allProposalIds,
+        sessions: tally.sessions,
         warnings: topLevelWarnings,
         durationMs: Date.now() - startMs,
-        ...(getNotices().length > 0 ? { notices: getNotices() } : {}),
-        ...(skipReasons ? { skipReasons } : {}),
+        ...notices.fields(),
+        ...(Object.keys(counts).length > 0 ? { skipReasons: counts } : {}),
         engine: llmRunner.engine,
         engineKind: llmRunner.kind,
     };
 }
 /**
- * Count NEW (unseen, in-window) extract candidate sessions across all available
- * harnesses WITHOUT making any LLM calls. Mirrors the discovery + seen-filter
- * logic in {@link akmExtract} so the `#554 minNewSessions` gate in `improve`
- * can decide whether the extract pass is worth running before any work begins.
- *
- * #602 — this gate is intentionally CHEAP: it does NOT read session bodies, so
- * it cannot compute the content hash that {@link shouldSkipAlreadyExtractedSession}
- * now uses. It therefore uses a CONSERVATIVE row-presence approximation: a
- * session counts as "new" when there is NO prior row OR the prior row's
- * `content_hash` is null (never-seen or backfill-eligible). A prior row WITH a
- * non-null content_hash counts as NOT new — it MIGHT have changed, but the
- * precise per-session hash check happens downstream in processSession, so an
- * over-/under-count here only affects whether the pass RUNS, never whether a
- * changed session is actually re-processed.
+ * Count new in-window sessions across the available harnesses, with no LLM
+ * call, for improve's `minNewSessions` gate. It does not read session bodies,
+ * so a session counts as new when it has no seen row or a row without a
+ * content hash; the exact hash check happens at extraction.
  */
 export function countNewExtractCandidates(_config, options = {}) {
-    const extractProcess = getImproveProcessConfig("extract", options.improveProfile);
-    const effectiveSince = options.since ?? extractProcess?.defaultSince;
-    // Mirror akmExtract: when no explicit window is set, default per-harness to
-    // "since the last run" (floored at 48h) instead of a fixed 24h. Keeps this
-    // gate's discovery window identical to what akmExtract will actually scan.
+    const effectiveSince = options.since ?? getImproveProcessConfig("extract", options.improveProfile)?.defaultSince;
     const explicitSinceMs = effectiveSince ? parseSinceArg(effectiveSince) : undefined;
     const harnesses = (options.harnesses ?? getAvailableHarnesses()).filter((h) => h.isAvailable());
     let stateDb = options.stateDb;
@@ -1538,20 +990,15 @@ export function countNewExtractCandidates(_config, options = {}) {
                     ...(options.stateDbPath ? { stateDbPath: options.stateDbPath } : {}),
                     ...(options.readOnly && !options.stateDb ? { skipTracking: true } : {}),
                 });
-            const candidates = harness.listSessions({
-                sinceMs,
-                ...(options.readOnly ? { isolatedSnapshot: true } : {}),
-            });
+            const candidates = harness.listSessions({ sinceMs, ...(options.readOnly ? { isolatedSnapshot: true } : {}) });
             if (candidates.length === 0)
                 continue;
-            // A dry planner with no pre-existing state database has no seen-session
-            // ledger by definition. Count the discovered sessions directly instead
-            // of creating state.db merely to prove that it is empty.
+            // A dry planner without state.db has no seen-session ledger by definition.
             if (options.readOnly && !stateDb) {
                 total += candidates.length;
                 continue;
             }
-            let seenMap = new Map();
+            let seenMap;
             try {
                 if (!stateDb) {
                     stateDb = openStateDatabase(options.stateDbPath);
@@ -1560,9 +1007,7 @@ export function countNewExtractCandidates(_config, options = {}) {
                 seenMap = getExtractedSessionsMap(stateDb, harness.name, candidates.map((c) => c.sessionId));
             }
             catch (err) {
-                // state.db unavailable — treat every in-window session as a new
-                // candidate (fail-open: never let a transient sqlite error wrongly
-                // trip the gate and skip a pass that should have run).
+                // Fail open: a transient sqlite error must not skip a pass that should run.
                 const msg = err instanceof Error ? err.message : String(err);
                 warn(`[extract] state.db unavailable while counting candidates, treating all as new: ${msg}`);
                 total += candidates.length;
@@ -1570,12 +1015,8 @@ export function countNewExtractCandidates(_config, options = {}) {
             }
             for (const summary of candidates) {
                 const prior = seenMap.get(summary.sessionId);
-                // #602 row-presence approximation (see fn doc): a prior row WITH a
-                // non-null content_hash is treated as not-new here; everything else
-                // (never-seen, or null-hash backfill-eligible) counts as new.
-                if (prior && prior.content_hash != null)
-                    continue;
-                total += 1;
+                if (!(prior && prior.content_hash != null))
+                    total += 1;
             }
         }
     }
@@ -1585,7 +1026,7 @@ export function countNewExtractCandidates(_config, options = {}) {
                 stateDb.close();
             }
             catch {
-                // best-effort close
+                // best-effort
             }
         }
     }