akm-cli 0.10.261013-beta → 0.10.261014-beta

package/dist/commands/improve/consolidate/pair-pass.js

@@ -38,8 +38,6 @@ import { parseEmbeddedJsonResponse } from "../../../core/parse.js";
 import { DERIVED_SUFFIX } from "../../../core/recognition-util.js";
 import { warnOnce } from "../../../core/warn.js";
 import { sameScope, scopeFromFrontmatter } from "../../../indexer/passes/metadata.js";
-import { runnerLlmConnection } from "../../../integrations/agent/runner.js";
-import { assertRunnerCredentials } from "../../../integrations/agent/runner-dispatch.js";
 import { runGit } from "../../../sources/providers/git-install.js";
 import { closeDatabase, openExistingDatabase, openReadonlyExistingDatabase, } from "../../../storage/repositories/index-connection.js";
 import { getAllEntries, getEntryById } from "../../../storage/repositories/index-entries-repository.js";
@@ -542,15 +540,12 @@ function checkSection(label, side) {
  */
 async function confirmNothingLost(ctx, retired, successor) {
     const outcome = await callStage({
-        feature: "memory_consolidation",
         runner: ctx.llmRunner,
         system: consolidatePairCheckPrompt,
         prompt: `${checkSection("X (to delete)", retired)}\n${checkSection("Y (kept)", successor)}\n${termHints([`Tokens only in X: ${exclusiveTerms(retired, successor)}`])}${Date.parse(retired.createdIso) === Date.parse(successor.createdIso) ? `\n${consolidatePairSameAge}` : ""}`,
-        gate: { config: ctx.config, enabled: true },
         request: {
             responseSchema: PAIR_CHECK_JSON_SCHEMA,
             enableThinking: false,
-            ...(Object.hasOwn(ctx.llmRunner, "timeoutMs") ? { timeoutMs: ctx.llmRunner.timeoutMs } : {}),
             signal: ctx.opts.signal,
             ...(ctx.chat ? { chat: ctx.chat } : {}),
         },
@@ -592,15 +587,12 @@ async function judgeOne(ctx, candidate) {
     }
     const { older, newer } = orderByAge(initiatorSide, otherSide);
     const outcome = await callStage({
-        feature: "memory_consolidation",
         runner: ctx.llmRunner,
         system: consolidatePairPrompt,
         prompt: buildPairUserPrompt(older, newer),
-        gate: { config: ctx.config, enabled: true },
         request: {
             responseSchema: PAIR_JUDGE_JSON_SCHEMA,
             enableThinking: false,
-            ...(Object.hasOwn(ctx.llmRunner, "timeoutMs") ? { timeoutMs: ctx.llmRunner.timeoutMs } : {}),
             signal: ctx.opts.signal,
             ...(ctx.chat ? { chat: ctx.chat } : {}),
         },
@@ -647,7 +639,7 @@ async function judgeOne(ctx, candidate) {
     // durable half).
     const retiredKey = stripBundle(retired.asset.ref);
     const successorKey = stripBundle(successor.asset.ref);
-    // Must-fix 1 (third review round): a retire-worthy verdict the same-run
+    // A retire-worthy verdict the same-run
     // chain guard drops is not a settled "no action" — a LATER run, once the
     // conflicting retirement has been reviewed, may well mint it. Counted as
     // failed so its initiator gets no row (real data: night 1 alone judged 177
@@ -731,7 +723,7 @@ async function judgeOne(ctx, candidate) {
     }
     catch (error) {
         ctx.warnings.push(`Pair pass: could not mint a retire proposal for ${retired.asset.ref}: ${error instanceof Error ? error.message : String(error)}`);
-        // Must-fix 1: a mint failure is transient (a lock, a disk error, a
+        // A mint failure is transient (a lock, a disk error, a
         // validation hiccup) — treated the same as a same-run drop, so no row is
         // written and the pair is retried next run instead of abandoned.
         return { failed: true };
@@ -748,8 +740,8 @@ const emptyLabelCounts = () => ({
 /**
  * The pair pass (alpha.9): initiators -> candidates -> one judge call per
  * pair -> retire proposals for the calibrated classes. Runs alongside the
- * promote pass, sharing its gate, its frozen LLM runner and its engine
- * concurrency. `bundleId` is the target bundle's id (`undefined` skips the
+ * promote pass, sharing its gate, its frozen LLM runner and its
+ * connection's concurrency. `bundleId` is the target bundle's id (`undefined` skips the
  * pass — nothing to scope candidates to).
  */
 export async function runConsolidatePairPass(opts, config, stashDir, bundleId, warnings, 
@@ -811,7 +803,7 @@ seams = {}) {
     }
     const isPendingBlocked = (c) => pendingRetireRefs.has(stripBundle(c.initiator.ref)) || pendingRetireRefs.has(stripBundle(c.other.ref));
     const rejectedPairKeys = loadRejectedPairKeys(stashDir, opts.proposalsCtx);
-    // Blocker 2: admit WHOLE initiators under MAX_PAIRS_PER_RUN, never
+    // Admit WHOLE initiators under MAX_PAIRS_PER_RUN, never
     // individual pairs — the old flat "top 300 candidates by cosine" cap let a
     // pending-blocked pair spend a budget slot doing nothing, and left
     // whichever initiators landed past slot 300 partially judged forever (no
@@ -869,21 +861,14 @@ seams = {}) {
         continuitySearch: seams.continuitySearch ?? createContinuitySearch(stashDir, config),
     };
     let failedJudgments = 0;
-    // Should-fix 3: an initiator with any failed (or never-sent) judge call
+    // An initiator with any failed (or never-sent) judge call
     // gets no ledger row — a failure attempted nothing conclusive, so writing
     // one would mean the pair is never retried.
     const failedInitiators = new Set();
     if (judgeable.length > 0) {
-        // The promote pass validates opts.llmRunner's credentials once, but only
-        // when it has memories to dispatch — the pair pass can still have work
-        // when that pool is empty, so it validates independently before its
-        // first real dispatch. A test-injected chat seam bypasses the transport
-        // entirely and needs no credential.
-        if (!seams.chat)
-            assertRunnerCredentials(llmRunner);
-        const results = await concurrentMap(judgeable, (candidate) => judgeOne(ctx, candidate), runnerLlmConnection(llmRunner)?.concurrency ?? 1, { signal: opts.signal });
+        const results = await concurrentMap(judgeable, (candidate) => judgeOne(ctx, candidate), (llmRunner.kind === "connection" ? llmRunner.concurrency : undefined) ?? 1, { signal: opts.signal });
         results.forEach((r, idx) => {
-            // Must-fix 3: `concurrentMap` leaves an entry `undefined` for a call an
+            // `concurrentMap` leaves an entry `undefined` for a call an
             // aborted run never sent at all — `r?.failed === true` reads that as
             // `undefined === true` (false), so an unsent call counted as a clean
             // "no action" verdict. Explicit `undefined` check closes that gap.
@@ -897,7 +882,7 @@ seams = {}) {
     // candidates were admitted (whole-initiator admission above makes this a
     // simple membership check: judgeable either has every one of an
     // initiator's candidates, or none of them) and none of them failed
-    // (should-fix 3) — including an initiator with zero candidates, which
+    // — including an initiator with zero candidates, which
     // trivially satisfies both. One left out by the cap or a pending-proposal
     // collision gets no row at all, so the next run reconsiders it rather
     // than treating it as settled.
@@ -928,7 +913,7 @@ seams = {}) {
         initiators: initiators.length,
         initiatorsBacklog,
         pairsConsidered: candidates.length,
-        // Must-fix 3: parsed verdicts only — judgeable.length counted pairs that
+        // Parsed verdicts only — judgeable.length counted pairs that
         // were admitted, not pairs a verdict actually came back for.
         pairsJudged: judgeable.length - failedJudgments,
         labelCounts: ctx.labelCounts,

package/dist/commands/improve/consolidate.js

@@ -33,12 +33,12 @@ import { parseEmbeddedJsonResponse } from "../../core/parse.js";
 import { openStateDatabase } from "../../core/state-db.js";
 import { warn, warnVerbose } from "../../core/warn.js";
 import { resolveWriteTarget } from "../../core/write-source.js";
+import { noticeSet } from "../../execution/notices.js";
 import { deriveInstallations } from "../../indexer/installations.js";
 import { resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { USAGE_EVENT_RETENTION_DAYS } from "../../indexer/usage/usage-events.js";
-import { runnerLlmConnection } from "../../integrations/agent/runner.js";
-import { assertRunnerCredentials } from "../../integrations/agent/runner-dispatch.js";
 import { cosineSimilarity, embedBatch, resolveEmbeddingModelId } from "../../llm/embedder.js";
+import { effectiveEmbedding } from "../../llm/embedders/connection.js";
 import { getBodyEmbeddings, upsertBodyEmbeddings } from "../../storage/repositories/embeddings-repository.js";
 import { closeDatabase, openExistingDatabase, openReadonlyExistingDatabase, } from "../../storage/repositories/index-connection.js";
 import { getAllEntries } from "../../storage/repositories/index-entries-repository.js";
@@ -52,7 +52,7 @@ import { contentHash } from "./content-hash.js";
 import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
 import { isContentDrivenRow, isLedgerBlocked, ledgerKey, loadLedgerSnapshot, recordLedgerAttempt } from "./ledger.js";
 import { isInRetrievalScope, loadRetrievalScope } from "./retrieval-scope.js";
-import { callStage, mintProposal, noticeSet, stageRunner } from "./stage.js";
+import { callStage, mintProposal, stageRunner } from "./stage.js";
 function parsePlan(raw) {
     const plan = parseEmbeddedJsonResponse(raw);
     return plan && Array.isArray(plan.operations) ? { ...plan, operations: plan.operations } : undefined;
@@ -122,9 +122,10 @@ export const CONSOLIDATE_PLAN_JSON_SCHEMA = {
  */
 async function clusterMemoriesBySimilarity(memories, config, stateDb, signal) {
     const telemetry = { embedMs: 0, cacheHits: 0, cacheMisses: 0 };
-    if (memories.length < 3 || !config.embedding)
+    const embedding = effectiveEmbedding(config);
+    if (memories.length < 3 || !embedding)
         return { ordered: memories, embedTelemetry: telemetry };
-    const modelId = resolveEmbeddingModelId(config.embedding);
+    const modelId = resolveEmbeddingModelId(embedding);
     const texts = memories.map((m) => [m.description, m.tags.join(" ")].filter(Boolean).join(". ") || m.name);
     const hashes = texts.map((t) => contentHash(t));
     let cached = new Map();
@@ -144,7 +145,7 @@ async function clusterMemoriesBySimilarity(memories, config, stateDb, signal) {
         const embedStart = Date.now();
         let missVecs;
         try {
-            missVecs = await embedBatch(missIndices.map((i) => texts[i]), config.embedding, signal);
+            missVecs = await embedBatch(missIndices.map((i) => texts[i]), embedding, signal);
         }
         catch {
             return { ordered: memories, embedTelemetry: telemetry };
@@ -335,7 +336,7 @@ export async function akmConsolidate(opts = {}) {
     const stashDir = writeTarget.source.path;
     const notices = noticeSet(opts.onNotices);
     const enabled = resolveProcessEnabled("consolidate", profile);
-    const runner = enabled ? stageRunner(opts, config, profile, "consolidate", notices.add) : undefined;
+    const runner = enabled ? stageRunner(opts, config, "consolidate", notices.add) : undefined;
     opts = {
         ...opts,
         target: writeTarget.source.name,
@@ -520,7 +521,7 @@ const ABORT_FAILURE_RATE = 0.5;
  * into exactly one accounting bucket.
  */
 async function judgeConsolidationChunks(args) {
-    const { chunks, opts, config, warnings, acc } = args;
+    const { chunks, opts, warnings, acc } = args;
     const llmRunner = opts.llmRunner ?? undefined;
     const memRef = (m) => conceptIdFromTypeName("memory", m.name);
     const failChunk = (message, chunk) => {
@@ -563,15 +564,12 @@ async function judgeConsolidationChunks(args) {
         }
         // The transport already retries once; a failed chunk is not retried here.
         const outcome = await callStage({
-            feature: "memory_consolidation",
             runner: llmRunner,
             system: consolidateSystemPrompt,
             prompt: buildChunkPrompt(args.sourceName, chunk, chunkIdx, chunks.length, args.bodyTruncation, args.pendingProposalBodyHashes),
-            gate: { config, enabled: true },
             request: {
                 responseSchema: CONSOLIDATE_PLAN_JSON_SCHEMA,
                 enableThinking: false,
-                ...(Object.hasOwn(llmRunner, "timeoutMs") ? { timeoutMs: llmRunner.timeoutMs } : {}),
                 signal: opts.signal,
             },
             parse: parsePlan,
@@ -626,7 +624,7 @@ async function planConsolidation(opts, config, stashDir, memories, warnings, sta
     const llmRunner = opts.llmRunner ?? undefined;
     // 500 body chars per memory keep the judgement useful; chunk size varies instead.
     const bodyTruncation = 500;
-    const chunkSize = computeSafeChunkSize((llmRunner && runnerLlmConnection(llmRunner)?.contextLength) ?? DEFAULT_CONTEXT_LENGTH_TOKENS, bodyTruncation, opts.maxChunkSize);
+    const chunkSize = computeSafeChunkSize((llmRunner?.kind === "connection" ? llmRunner.contextLength : undefined) ?? DEFAULT_CONTEXT_LENGTH_TOKENS, bodyTruncation, opts.maxChunkSize);
     const sourceName = opts.target ?? stashDir;
     let budgeted = memories;
     const budgetMs = opts.signal?.remainingBudgetMs;
@@ -642,8 +640,6 @@ async function planConsolidation(opts, config, stashDir, memories, warnings, sta
         }
     }
     const slice = (list) => Array.from({ length: Math.ceil(list.length / chunkSize) }, (_, i) => list.slice(i * chunkSize, (i + 1) * chunkSize));
-    if (llmRunner && budgeted.length > 0)
-        assertRunnerCredentials(llmRunner);
     const { ordered, embedTelemetry } = await clusterMemoriesBySimilarity(budgeted, config, stateDb, opts.signal);
     const chunks = slice(ordered);
     const pendingProposalBodyHashes = loadPendingConsolidateProposalHashes(stashDir, opts.proposalsCtx);
@@ -652,7 +648,6 @@ async function planConsolidation(opts, config, stashDir, memories, warnings, sta
     const planned = await judgeConsolidationChunks({
         chunks,
         opts,
-        config,
         sourceName,
         bodyTruncation,
         pendingProposalBodyHashes,

package/dist/commands/improve/distill.js

@@ -33,8 +33,8 @@ import { resolveStandardsContext } from "../../core/standards/resolve-standards-
 import { withStateDb } from "../../core/state-db.js";
 import { warn, warnVerbose } from "../../core/warn.js";
 import { recordWrittenPath } from "../../core/write-provenance.js";
+import { noticeSet } from "../../execution/notices.js";
 import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
-import { assertRunnerCredentials } from "../../integrations/agent/runner-dispatch.js";
 import { closeDatabase, openReadonlyExistingDatabase } from "../../storage/repositories/index-connection.js";
 import { getAllEntries } from "../../storage/repositories/index-entries-repository.js";
 import { listProposals } from "../proposal/repository.js";
@@ -48,7 +48,7 @@ import { buildRefVocabulary, scoreEncodingSalience } from "./encoding-salience.j
 import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
 import { recordLedgerAttempt } from "./ledger.js";
 import { computeSalience, upsertAssetSalience } from "./salience.js";
-import { callStage, LESSON_REJECT_MAX_SCORE, mintProposal, noticeSet, rejectedProposalContext, resolveQualityGateJudge, runLessonQualityJudge, stageRunner, } from "./stage.js";
+import { callStage, LESSON_REJECT_MAX_SCORE, mintProposal, rejectedProposalContext, resolveQualityGateJudge, runLessonQualityJudge, stageRunner, } from "./stage.js";
 /**
  * Input types distill structurally refuses: a lesson is the distilled form
  * (distilling one would mint `lessons/lesson-…-lesson`), and env/secret bytes
@@ -355,8 +355,8 @@ export async function akmDistill(options) {
         stash,
         config,
         profile,
-        runner: stageRunner(options, config, profile, "distill", notices.add),
-        judgeRunner: resolveQualityGateJudge(config, profile, "distill", notices.add),
+        runner: stageRunner(options, config, "distill", notices.add),
+        judgeRunner: resolveQualityGateJudge(config, profile, "distill", notices.add, options.run),
         notices,
         eligMeta,
         asset,
@@ -372,11 +372,6 @@ async function distill(run, targetKind, kind, outputRef, feedbackEvents) {
     // A reinforced memory graduates to knowledge without a generation call.
     const promotion = targetKind === "lesson" ? null : await planPromotion(run, feedbackEvents);
     if (promotion) {
-        if (run.runner && promotion.existing)
-            assertRunnerCredentials(run.runner);
-        const judge = run.judgeRunner ?? run.runner;
-        if (judge && qualityGateEnabled(run))
-            assertRunnerCredentials(judge);
         const promoted = await promoteToKnowledge(run, promotion);
         stampInputSalience(run);
         return promoted;
@@ -394,11 +389,9 @@ async function distill(run, targetKind, kind, outputRef, feedbackEvents) {
     const { system, prompt } = await buildDistillMessages(run, feedback, kind, outputRef);
     const call = run.runner
         ? await callStage({
-            feature: "distill",
             runner: run.runner,
             system,
             prompt,
-            gate: { config: run.config, enabled: true },
             // NONE is an answer: a parser that rejected it would ask for a lesson again.
             parse: (raw) => (answeredNone(raw) ? raw : parseEmbeddedJsonResponse(raw)),
             // The injected test transport never sees the schema.
@@ -504,7 +497,7 @@ function assembleDistilledContent(run, raw, kind, outputRef) {
         });
         throw new UsageError(`Distilled ${kind} failed validation:\n${structural.map((f) => f.message).join("\n")}`, "MISSING_REQUIRED_ARGUMENT", kind === "knowledge"
             ? "Knowledge proposals require a non-empty markdown body."
-            : "Lessons require non-empty `description` and `when_to_use` frontmatter fields. See v1 spec §13.");
+            : "Lessons require non-empty `description` and `when_to_use` frontmatter fields.");
     }
     // Heuristic quality findings go to a human, not the bin.
     const quality = kind === "lesson" ? collectLessonQualityFindings(content, run.inputRef) : [];
@@ -655,11 +648,9 @@ async function proposeLessonUpdate(run, feedback, finding, related) {
     if (candidates.length === 0)
         return undefined;
     const call = await callStage({
-        feature: "distill",
         runner: run.runner,
         system: "Return only valid JSON. No prose.",
         prompt: buildLessonUpdatePrompt(memory, feedback, candidates),
-        gate: { config: run.config, enabled: true },
         request: {
             ...(run.options.chat === undefined
                 ? { responseSchema: DISTILL_LESSON_UPDATE_JSON_SCHEMA }
@@ -862,7 +853,6 @@ async function promoteToKnowledge(run, plan) {
     let content = plan.content;
     if (plan.existing && run.runner) {
         const merged = await callStage({
-            feature: "distill",
             runner: run.runner,
             system: "Return only valid JSON. No prose.",
             prompt: [

package/dist/commands/improve/eligibility.js

@@ -4,10 +4,10 @@
 /** The refs an improve run may consider, read from the index, and the small predicates over them. */
 import fs from "node:fs";
 import path from "node:path";
-import { closestMatch } from "../../cli/unknown-flags.js";
 import { parseBundleRef } from "../../core/asset/asset-ref.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { conceptIdFromTypeName, parseRefInput, resolveRef, typeNameFromConceptId } from "../../core/asset/resolve-ref.js";
+import { closestMatch } from "../../core/closest-match.js";
 import { loadConfig } from "../../core/config/config.js";
 import { ConfigError, NotFoundError, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { isPathAbsent } from "../../core/path-access.js";

package/dist/commands/improve/execution.js

@@ -1,47 +1,44 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { deepMergeConfig } from "../../core/config/deep-merge.js";
-import { buildExecution, resolveExecution } from "../../integrations/agent/execution.js";
-function own(value, key) {
-    return value !== undefined && Object.hasOwn(value, key);
-}
-function cascadeDefaults(layer) {
-    if (!layer)
-        return {};
-    return {
-        ...(own(layer, "engine") ? { engine: layer.engine } : {}),
-        ...(own(layer, "model") ? { model: layer.model } : {}),
-        ...(own(layer, "llm") ? { inference: layer.llm } : {}),
-        ...(own(layer, "timeoutMs") ? { timeout: layer.timeoutMs ?? null } : {}),
-    };
-}
-function mergeDefaults(farther, nearer) {
-    return deepMergeConfig(farther, nearer);
-}
+import { IMPROVE_ENGINE_PROCESSES } from "../../core/config/engine-semantics.js";
+import { ConfigError } from "../../core/errors.js";
+import { executionDefaultsOf } from "../../execution/source.js";
+import { buildExecution, currentLayer, resolveExecution, shippedAlias } from "../../integrations/agent/execution.js";
 /**
- * Resolve improve-owned model work through the canonical execution cascade:
- * defaults.llmEngine -> strategy -> index.<pass> -> process -> current invocation.
- * The engine may be of any kind that confines the model-work tool policy: one
- * that cannot, chosen with `--engine` say, is refused here, before any work.
+ * Resolve improve-owned model work: `improve.connection` / `improve.harness`
+ * -> index.<pass> -> `improve.processes.<name>` -> the call's own settings ->
+ * the run's selection, nearest wins, over the default by name. A strategy adds no layer: it says which
+ * processes run, never where. `null` when no connection or harness is
+ * configured for it.
  */
 export function resolveImproveExecution(options) {
-    const defaultEngine = options.config.defaults?.llmEngine;
-    const profileDefaults = cascadeDefaults(options.profile);
-    const indexDefaults = cascadeDefaults(options.index);
-    const processDefaults = cascadeDefaults(options.process);
-    const currentDefaults = cascadeDefaults(options.current);
-    const selectedEngine = currentDefaults.engine ?? processDefaults.engine ?? indexDefaults.engine ?? profileDefaults.engine ?? defaultEngine;
-    if (selectedEngine === undefined || selectedEngine === null)
-        return null;
-    const invocationDefaults = mergeDefaults(mergeDefaults(defaultEngine ? { engine: defaultEngine } : {}, profileDefaults), indexDefaults);
-    const prepared = resolveExecution({
-        content: `improve ${options.processName} execution selection`,
-        config: options.config,
-        invocationDefaults,
-        current: mergeDefaults(processDefaults, currentDefaults),
-        modelWork: true,
-    });
-    const lowered = buildExecution(prepared.request, prepared.runner);
-    return Object.freeze({ runner: lowered.runner, notices: lowered.notices });
+    const processKey = options.process ?? options.processName;
+    const processes = options.config.improve?.processes;
+    try {
+        const prepared = resolveExecution({
+            content: `improve ${options.processName} execution selection`,
+            config: options.config,
+            layers: [
+                shippedAlias(options.alias),
+                { id: "improve", kind: "invocation-defaults", values: executionDefaultsOf(options.config.improve) },
+                { id: "index", kind: "invocation-defaults", values: executionDefaultsOf(options.index) },
+                {
+                    id: `improve.processes.${processKey}`,
+                    kind: "invocation-defaults",
+                    values: executionDefaultsOf(IMPROVE_ENGINE_PROCESSES.includes(processKey) ? processes?.[processKey] : undefined),
+                },
+                currentLayer(executionDefaultsOf(options.current)),
+                { id: "run", kind: "current", values: executionDefaultsOf(options.run) },
+            ],
+            modelWork: true,
+        });
+        const lowered = buildExecution(prepared.request, prepared.runner);
+        return Object.freeze({ runner: lowered.runner, notices: lowered.notices });
+    }
+    catch (error) {
+        if (error instanceof ConfigError && error.code === "LLM_NOT_CONFIGURED")
+            return null;
+        throw error;
+    }
 }

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

@@ -18,6 +18,7 @@
  * `--auto` runs multiple harnesses).
  */
 import { getStringArg } from "../../cli/parse-args.js";
+import { RETIRED_ENGINE_ARG, SELECTION_ARGS, selectionFromArgs } from "../../cli/selection.js";
 import { defineJsonCommand, EXIT_CODES, output } from "../../cli/shared.js";
 import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
@@ -62,15 +63,13 @@ export const extractCommand = defineJsonCommand({
         },
         "timeout-ms": {
             type: "string",
-            description: "Per-session LLM timeout in ms (default 600000).",
-        },
-        engine: {
-            type: "string",
-            description: "Named LLM engine for this invocation. Mutually exclusive with --strategy.",
+            description: "Per-session LLM timeout in ms. Default: the engine's own timeout.",
         },
+        ...SELECTION_ARGS,
+        ...RETIRED_ENGINE_ARG,
         strategy: {
             type: "string",
-            description: "Improve strategy supplying extract behavior and engine. Mutually exclusive with --engine.",
+            description: "Improve strategy supplying extract behavior.",
         },
     },
     async run({ args }) {
@@ -81,7 +80,6 @@ export const extractCommand = defineJsonCommand({
         const auto = args.auto === true;
         const dryRun = args["dry-run"] === true;
         const force = args.force === true;
-        const engine = getStringArg(args, "engine");
         const strategy = getStringArg(args, "strategy");
         const timeoutMs = typeof args["timeout-ms"] === "string" && args["timeout-ms"] !== ""
             ? Number.parseInt(args["timeout-ms"], 10)
@@ -89,9 +87,6 @@ export const extractCommand = defineJsonCommand({
         if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
             throw new UsageError(`--timeout-ms must be a positive integer (got "${args["timeout-ms"]}").`, "INVALID_FLAG_VALUE");
         }
-        if (engine && strategy) {
-            throw new UsageError("--engine and --strategy are mutually exclusive. Pick one.", "INVALID_FLAG_VALUE");
-        }
         if (auto && type) {
             throw new UsageError("--auto and --type are mutually exclusive. Pick one.", "INVALID_FLAG_VALUE");
         }
@@ -100,7 +95,7 @@ export const extractCommand = defineJsonCommand({
         }
         const config = loadConfig();
         const resolvedPlan = resolveStandaloneExtractPlan(config, {
-            ...(engine ? { engine } : {}),
+            ...selectionFromArgs(args),
             ...(strategy ? { strategy } : {}),
             ...(timeoutMs !== undefined ? { timeoutMs } : {}),
         });

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

@@ -19,8 +19,8 @@ import { escapeJsonStringControls, stripCodeFences, stripThinkBlocks } from "../
 const EXTRACT_CANDIDATE_NAME_PATTERN = "^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:/[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)?$";
 const EXTRACT_CANDIDATE_NAME_RE = new RegExp(EXTRACT_CANDIDATE_NAME_PATTERN);
 /**
- * JSON Schema for the structured extract output. Passed to `chatCompletion`
- * unless the configured LLM connection sets `supportsJsonSchema: false`.
+ * JSON Schema for the structured extract output. Passed to `chatCompletion`,
+ * which drops it once for a provider that rejects it.
  *
  * Shape:
  *   {