akm-cli 0.9.24 → 0.9.25-alpha.2

package/dist/commands/read/search-cli.js

@@ -81,20 +81,6 @@ export const searchCommand = defineJsonCommand({
             description: "Include session assets (excluded from default search results via config.search.defaultExcludeTypes).",
             default: false,
         },
-        // Declared as the POSITIVE name with `default: true` so citty's native
-        // `--no-<name>` negation (it strips a leading `--no-` from ANY token and
-        // negates the remainder BEFORE consulting the declared-args table — see
-        // node_modules/citty/dist/index.mjs) does the work, the same pattern
-        // `sync --push/--no-push` uses. A flag DECLARED as `no-track-usage` could
-        // never be negated: `--no-track-usage` parses as "negate `track-usage`",
-        // a name nothing declared, leaving the real key at its default forever
-        // (F1/A1).
-        "track-usage": {
-            type: "boolean",
-            default: true,
-            description: "A successful search records usage-events telemetry. Default: on. Use --no-track-usage to run a " +
-                "search that records nothing.",
-        },
     },
     async run({ args }) {
         rejectRetiredSourceFlag();
@@ -108,7 +94,6 @@ export const searchCommand = defineJsonCommand({
         const filters = parseScopeFilterFlags(filterTokens, "--filter");
         const includeProposed = args["include-proposed"] === true;
         const belief = parseBeliefFilterMode(typeof args.belief === "string" ? args.belief : undefined);
-        const skipLogging = args["track-usage"] === false;
         const includeSessions = args["include-sessions"];
         const assets = args.assets === true;
         const outputMode = getOutputMode();
@@ -121,7 +106,6 @@ export const searchCommand = defineJsonCommand({
             includeProposed,
             belief,
             includeSessions,
-            skipLogging,
             assets,
             eventSource: resolveUsageEventSource(),
             attributionProjection: outputMode.shape === "agent" ? "agent" : outputMode.detail,
@@ -154,15 +138,6 @@ export const curateCommand = defineJsonCommand({
                 "with a workflow asset's own `budget` field (a run-cost cap) — this is a context-size target for this " +
                 "one curate call.",
         },
-        // Declared as the POSITIVE name with `default: true` — see the
-        // `track-usage` comment on `searchCommand` above for why a flag NAME
-        // must never start with `no-`.
-        "track-usage": {
-            type: "boolean",
-            default: true,
-            description: "A successful curate records usage-events telemetry for the curated items. Default: on. Use " +
-                "--no-track-usage to run a curate that records nothing.",
-        },
     },
     async run({ args }) {
         rejectRetiredSourceFlag();
@@ -173,7 +148,6 @@ export const curateCommand = defineJsonCommand({
         const limitParsed = parsePositiveIntFlag(args.limit ?? undefined);
         const limit = limitParsed && limitParsed > 0 ? limitParsed : 4;
         const source = parseSearchSource(args.from ?? "local");
-        const skipLogging = args["track-usage"] === false;
         const outputMode = getOutputMode();
         const packBudget = parsePositiveIntFlag(args.pack ?? undefined, "--pack");
         const curated = await akmCurate({
@@ -181,7 +155,6 @@ export const curateCommand = defineJsonCommand({
             type,
             limit,
             source,
-            skipLogging,
             eventSource: resolveUsageEventSource(),
             attributionProjection: outputMode.shape === "agent" ? "agent" : outputMode.detail,
         });
@@ -285,15 +258,6 @@ export const showCommand = defineJsonCommand({
             type: "string",
             description: "Exact context budget in characters. Requires --context lead; mutually exclusive with --max-tokens.",
         },
-        // Declared as the POSITIVE name with `default: true` — see the
-        // `track-usage` comment on `searchCommand` above for why a flag NAME
-        // must never start with `no-`.
-        "track-usage": {
-            type: "boolean",
-            default: true,
-            description: "A successful show records usage-events telemetry, including the search-selection linkage when this " +
-                "show follows a recent search. Default: on. Use --no-track-usage to run a show that records nothing.",
-        },
     },
     async run({ args }) {
         // `[origin//]meta[:name]` targets the stash `.meta/` convention, which is
@@ -342,14 +306,12 @@ export const showCommand = defineJsonCommand({
         if (maxContextChars !== undefined && !Number.isSafeInteger(maxContextChars)) {
             throw new UsageError("Fragment context budget is too large.", "INVALID_FLAG_VALUE");
         }
-        const skipLogging = args["track-usage"] === false;
         const result = await akmShowUnified({
             ref: args.ref,
             detail: showDetail,
             contextMode,
             maxContextChars,
             scope,
-            skipLogging,
             eventSource: resolveUsageEventSource(),
         });
         output("show", result);

package/dist/commands/remember.js

@@ -19,7 +19,7 @@ import { warn } from "../core/warn.js";
 import { SCOPE_KEYS } from "../indexer/passes/metadata.js";
 import { callStructured } from "../llm/structured-call.js";
 import { withLlmStage } from "../llm/usage-telemetry.js";
-import { resolveImproveLlmExecution } from "./improve/execution.js";
+import { resolveImproveExecution } from "./improve/execution.js";
 /**
  * Parse a shorthand duration string to a number of milliseconds.
  * Supports the CLI-wide canonical grammar: `30d` (days), `12h` (hours),
@@ -224,9 +224,9 @@ const LLM_ENRICH_TIMEOUT_MS = 10_000;
  */
 export async function runLlmEnrich(body) {
     const config = loadConfig();
-    const resolved = resolveImproveLlmExecution({ config, processName: "remember-enrich" });
+    const resolved = resolveImproveExecution({ config, processName: "remember-enrich" });
     if (!resolved) {
-        warn("Warning: --enrich requires an LLM to be configured. Run `akm setup` to configure one.");
+        warn("Warning: --enrich requires an engine to be configured. Run `akm setup` to configure one.");
         return { tags: [] };
     }
     const runner = resolved.runner;

package/dist/commands/sources/schema-repair.js

@@ -105,7 +105,7 @@ export async function runSchemaRepairPass(failures, options) {
     const { startMs, budgetMs, stashDir, findFilePath = defaultFindFilePath, isLessonCandidateFn = defaultIsLessonCandidate, chatFn, } = options;
     const llmRunner = options.llmRunner ?? null;
     if (!llmRunner)
-        throw new Error("runSchemaRepairPass requires a resolved LLM runner");
+        throw new Error("runSchemaRepairPass requires a resolved runner");
     if (!stashDir) {
         throw new Error("runSchemaRepairPass requires stashDir so repairs route through the proposal queue");
     }

package/dist/core/config/config-schema.js

@@ -39,7 +39,8 @@
  *   enforced at save time via `superRefine` on the top-level schema.
  */
 import { z } from "zod";
-import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_PROCESS_ENGINE_CAPABILITIES } from "./engine-semantics.js";
+import { HARNESS_MODEL_WORK_IDS } from "../../integrations/harnesses/ids.js";
+import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_ENGINE_PROCESSES } from "./engine-semantics.js";
 import { EmbeddingConnectionConfigSchema } from "./schema/embedding.js";
 import { EnginesSchema } from "./schema/engines.js";
 import { ExecutionPolicyConfigSchema } from "./schema/execution.js";
@@ -222,13 +223,32 @@ export const AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) =>
             message: "engine does not name a configured engine",
         });
     }
-    const defaultLlm = config.defaults?.llmEngine;
-    if (defaultLlm && config.engines?.[defaultLlm]?.kind !== "llm") {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["defaults", "llmEngine"],
-            message: "llmEngine must name an LLM engine",
-        });
+    // One rule for every key unattended model work reads its engine from: the
+    // engine must confine the model-work tool policy (an LLM, or an agent whose
+    // harness does), because that work runs over generated content with no one
+    // watching.
+    const confining = [...HARNESS_MODEL_WORK_IDS];
+    const confiningPlatforms = `${confining.slice(0, -1).join(", ")} or ${confining.at(-1)}`;
+    const modelWorkEngine = (name, path) => {
+        if (!name)
+            return;
+        const engine = config.engines?.[name];
+        if (!engine) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path, message: "engine does not name a configured engine" });
+        }
+        else if (engine.kind !== "llm" && !HARNESS_MODEL_WORK_IDS.has(engine.platform)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path,
+                message: `engine "${name}" (platform ${engine.platform}) cannot confine the model-work tool policy, which unattended model work requires. Use an LLM engine, or an agent engine on ${confiningPlatforms}.`,
+            });
+        }
+    };
+    modelWorkEngine(config.defaults?.llmEngine, ["defaults", "llmEngine"]);
+    for (const [passName, pass] of Object.entries(config.index ?? {})) {
+        const engine = pass?.engine;
+        if (typeof engine === "string")
+            modelWorkEngine(engine, ["index", passName, "engine"]);
     }
     const workflowJudge = config.workflow?.judgeEngine;
     if (workflowJudge && !config.engines?.[workflowJudge]) {
@@ -256,68 +276,25 @@ export const AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) =>
         });
     }
     for (const [strategyName, strategy] of Object.entries(config.improve?.strategies ?? {})) {
-        const strategyEngine = strategy.engine;
-        if (strategyEngine) {
-            const engine = config.engines?.[strategyEngine];
-            if (!engine || engine.kind !== "llm") {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: ["improve", "strategies", strategyName, "engine"],
-                    message: engine ? "strategy engine must be an LLM engine" : "engine does not name a configured engine",
-                });
-            }
-        }
+        const strategyPath = ["improve", "strategies", strategyName];
+        modelWorkEngine(strategy.engine, [...strategyPath, "engine"]);
         for (const [processName, process] of Object.entries(strategy.processes ?? {})) {
             const processConfig = process;
-            const capability = IMPROVE_PROCESS_ENGINE_CAPABILITIES[processName];
-            if (processConfig.engine && capability === null) {
+            const processPath = [...strategyPath, "processes", processName];
+            if (processConfig.engine && !IMPROVE_ENGINE_PROCESSES.includes(processName)) {
                 ctx.addIssue({
                     code: z.ZodIssueCode.custom,
-                    path: ["improve", "strategies", strategyName, "processes", processName, "engine"],
+                    path: [...processPath, "engine"],
                     message: `${processName} does not dispatch an engine`,
                 });
             }
             else {
-                const processEngine = processConfig.engine ?? strategyEngine;
-                if (processEngine && capability === "llm") {
-                    const engine = config.engines?.[processEngine];
-                    if (!engine || engine.kind !== "llm") {
-                        ctx.addIssue({
-                            code: z.ZodIssueCode.custom,
-                            path: ["improve", "strategies", strategyName, "processes", processName, "engine"],
-                            message: engine ? `${processName} requires an LLM engine` : "engine does not name a configured engine",
-                        });
-                    }
-                }
-                else if (processConfig.engine && capability === "runner" && !config.engines?.[processConfig.engine]) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        path: ["improve", "strategies", strategyName, "processes", processName, "engine"],
-                        message: "engine does not name a configured engine",
-                    });
-                }
+                modelWorkEngine(processConfig.engine, [...processPath, "engine"]);
             }
-            const judgmentEngine = processConfig.judgment?.engine;
-            if (processConfig.judgment?.enabled === true && judgmentEngine) {
-                const engine = config.engines?.[judgmentEngine];
-                if (!engine) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        path: ["improve", "strategies", strategyName, "processes", processName, "judgment", "engine"],
-                        message: "engine does not name a configured engine",
-                    });
-                }
-            }
-            const gateEngine = processConfig.qualityGate?.engine;
-            if (gateEngine && config.engines?.[gateEngine]?.kind !== "llm") {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: ["improve", "strategies", strategyName, "processes", processName, "qualityGate", "engine"],
-                    message: config.engines?.[gateEngine]
-                        ? "a quality-gate judge must be an LLM engine"
-                        : "engine does not name a configured engine",
-                });
+            if (processConfig.judgment?.enabled === true) {
+                modelWorkEngine(processConfig.judgment.engine, [...processPath, "judgment", "engine"]);
             }
+            modelWorkEngine(processConfig.qualityGate?.engine, [...processPath, "qualityGate", "engine"]);
         }
     }
     // #464.a: defaultWriteTarget must name a configured source. 0.9.0 (spec

package/dist/core/config/engine-semantics.js

@@ -11,14 +11,18 @@ export const BUILTIN_IMPROVE_STRATEGY_NAMES = [
     "reflect-distill",
     "proactive-maintenance",
 ];
-/** Engine capability required by each configured improve process. `null` means engine-free. */
-export const IMPROVE_PROCESS_ENGINE_CAPABILITIES = {
-    reflect: "llm",
-    distill: "llm",
-    consolidate: "llm",
-    memoryInference: "llm",
-    extract: "llm",
-    validation: "llm",
-    triage: "runner",
-    proactiveMaintenance: null,
-};
+/**
+ * The improve processes that use an engine. Triage's engine is its judgment's;
+ * each of the others makes the process's own model calls.
+ */
+export const IMPROVE_ENGINE_PROCESSES = [
+    "reflect",
+    "distill",
+    "consolidate",
+    "memoryInference",
+    "extract",
+    "validation",
+    "triage",
+];
+/** Every improve process, in plan order: the engine processes and `proactiveMaintenance`, which uses none. */
+export const IMPROVE_PROCESS_NAMES = [...IMPROVE_ENGINE_PROCESSES, "proactiveMaintenance"];

package/dist/core/config/schema/improve-processes.js

@@ -6,7 +6,7 @@
  * verbatim from the former `config-schema.ts` monolith — no behavior change.
  */
 import { z } from "zod";
-import { IMPROVE_PROCESS_ENGINE_CAPABILITIES } from "../engine-semantics.js";
+import { IMPROVE_PROCESS_NAMES } from "../engine-semantics.js";
 import { engineName, LlmInvocationOverridesSchema, nonEmptyString, positiveInt } from "./primitives.js";
 // ── Improve profile / process ──────────────────────────────────────────────
 //
@@ -103,6 +103,21 @@ const fidelityCheckField = z.object({ enabled: z.boolean().optional() }).passthr
  * byte-identical behaviour). Reflect process only.
  */
 const lowValueFilterField = z.object({ enabled: z.boolean().optional() }).passthrough().optional();
+/**
+ * The wording lists of reflect's pre-judge defect filter (`findReflectDefect`).
+ * Each list is optional: one that is set replaces that rule's default list, and
+ * an empty one turns the rule off. Phrases (`placeholders`, `metaCommentary`)
+ * match as whole words in any case; `frontmatterKeys` are exact key names.
+ * Reflect process only.
+ */
+const defectFilterField = z
+    .object({
+    placeholders: z.array(nonEmptyString).optional(),
+    metaCommentary: z.array(nonEmptyString).optional(),
+    frontmatterKeys: z.array(nonEmptyString).optional(),
+})
+    .passthrough()
+    .optional();
 /**
  * #626 — extract process: pre-LLM heuristic triage gate. When enabled, a
  * deterministic scorer decides BEFORE the extraction LLM call whether a
@@ -159,6 +174,7 @@ const REFLECT_PROCESS_FIELDS = {
     limit: processLimitField,
     qualityGate: qualityGateField,
     lowValueFilter: lowValueFilterField,
+    defectFilter: defectFilterField,
 };
 const DISTILL_PROCESS_FIELDS = {
     allowedTypes: allowedTypesField,
@@ -319,7 +335,7 @@ const ImproveProfileProcessesSchema = z
         });
     }
     for (const [name, process] of Object.entries(val)) {
-        if (!(name in IMPROVE_PROCESS_ENGINE_CAPABILITIES) &&
+        if (!IMPROVE_PROCESS_NAMES.includes(name) &&
             !RETIRED_PROCESS_NAMES.has(name) &&
             process !== null &&
             typeof process === "object" &&

package/dist/core/improve-result.js

@@ -3,7 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { cloneExecutionJsonObject } from "../execution/json.js";
 import { isRecord } from "./common.js";
-import { IMPROVE_PROCESS_ENGINE_CAPABILITIES } from "./config/engine-semantics.js";
+import { IMPROVE_PROCESS_NAMES } from "./config/engine-semantics.js";
 const COMMON_FIELDS = [
     "schemaVersion",
     "ok",
@@ -192,11 +192,11 @@ function validateProactivePlan(value) {
         fail("plan.proactive.selected must equal plan.proactive.selectedRefs.length");
     }
 }
-/** #947 — plan.processes: one row per IMPROVE_PROCESS_ENGINE_CAPABILITIES name, plus an optional "triage.judgment" row. */
+/** #947 — plan.processes: one row per IMPROVE_PROCESS_NAMES name, plus an optional "triage.judgment" row. */
 function validateProcessRoutingRows(value) {
     if (!Array.isArray(value))
         fail("plan.processes must be an array");
-    const canonicalNames = Object.keys(IMPROVE_PROCESS_ENGINE_CAPABILITIES);
+    const canonicalNames = IMPROVE_PROCESS_NAMES;
     const engineKinds = new Set(["llm", "agent", "sdk"]);
     const seen = new Set();
     for (const row of value) {

package/dist/core/redaction.js

@@ -19,6 +19,10 @@ const ENV_PASSTHROUGH_REDACTION_POLICY = {
     OPENCODE_CONFIG: "path",
     CLAUDE_CONFIG: "path",
     CODEX_CONFIG: "path",
+    XDG_CONFIG_HOME: "path",
+    XDG_DATA_HOME: "path",
+    XDG_CACHE_HOME: "path",
+    XDG_STATE_HOME: "path",
     AWS_PROFILE: "identifier",
     AWS_REGION: "identifier",
     LLM_MODEL: "identifier",

package/dist/core/spawn-env.js

@@ -45,6 +45,31 @@ export const COMMON_SPAWN_ENV_PASSTHROUGH = [
     "TMPDIR",
     "AKM_EVENT_SOURCE",
 ];
+/**
+ * The XDG base-directory variables. opencode resolves its config, data, cache
+ * and state directories from them, so it must receive them: an akm that runs
+ * under a custom `XDG_CONFIG_HOME` otherwise spawns an opencode that reads
+ * `$HOME/.config/opencode` and misses the provider config its caller named.
+ *
+ * Deliberately NOT part of {@link COMMON_SPAWN_ENV_PASSTHROUGH}, which is every
+ * harness's baseline, the workflow exec unit's default allowlist (a documented
+ * list) and, through profile `envPassthrough`, frozen into workflow plans.
+ * codex, gemini and pi keep their own dotdirs under `$HOME`, and handing the
+ * names to a shell command would redirect the `git` and `gh` config it reads. A
+ * harness that reads them asks for them by name: the opencode profile's list,
+ * and the opencode-sdk server's allowlist (`opencodeSdkServerEnvironmentNames`).
+ *
+ * A name added to a profile's list changes the plans frozen after it (their
+ * bytes, so their `plan_hash`); a stored plan keeps the list it was frozen with
+ * and still resumes, because nothing gates on that hash. The SDK server's
+ * allowlist is not part of a plan, so it takes the names by code.
+ */
+export const XDG_BASE_DIR_ENV_PASSTHROUGH = [
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_CACHE_HOME",
+    "XDG_STATE_HOME",
+];
 /**
  * The names Windows itself requires of ANY child, whatever the caller's
  * allowlist says. Applied at build time rather than added to

package/dist/core/structured.js

@@ -24,7 +24,17 @@
  * jittered retry; `runAgent` has timeout/abort semantics).
  */
 import { parseEmbeddedJsonResponse } from "./parse.js";
-function defaultFeedback(failure) {
+/**
+ * Append the one structured-output instruction to a prompt. Agent lowering
+ * appends it to every schema-bearing request, alongside a harness's native
+ * channel where one exists (codex `--output-schema`); the workflow engine
+ * appends it for a direct-LLM unit. Resumed workflow runs depend on these
+ * exact bytes, so do not reword it.
+ */
+export function withSchemaInstruction(prompt, schema) {
+    return `${prompt}\n\nRespond with ONLY a JSON value matching this JSON Schema (no prose, no code fences):\n${JSON.stringify(schema)}`;
+}
+export function defaultFeedback(failure) {
     if (failure.reason === "parse_error") {
         return "Your previous response contained no parseable JSON. Respond with ONLY a JSON value that matches the requested schema — no prose, no code fences.";
     }

package/dist/execution/source.js

@@ -5,6 +5,16 @@ import { cloneExecutionJson, cloneExecutionJsonObject } from "./json.js";
 export const EXECUTION_SOURCE_SCHEMA_VERSION = 1;
 /** Current internal adapter identifiers are lowercase kebab-case registry keys. */
 export const EXECUTION_ADAPTER_ID_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+/**
+ * The model-work tool policy: unattended model work (improve, the judges, index
+ * passes, remember) may read, edit only inside the dispatch's own scratch
+ * working directory, and run `akm search` and `akm show`; the stash stays
+ * read-only to it. A transport grants what it can confine and refuses the policy
+ * at build when it can confine nothing; an LLM has no tools. A request carries it
+ * as `authorization.policy.id`, set only when its caller asks (`modelWork`): no
+ * `tools` value names it, so an asset's own `tools:` cannot.
+ */
+export const MODEL_WORK_POLICY_ID = "model-work";
 function requireRecord(value, path) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         throw new TypeError(`${path} must be an object`);

package/dist/indexer/passes/memory-inference.js

@@ -48,6 +48,7 @@ import { ConfigError } from "../../core/errors.js";
 import { warn } from "../../core/warn.js";
 import { beginWriteProvenance, recordWrittenPath } from "../../core/write-provenance.js";
 import { writeAssetToSource } from "../../core/write-source.js";
+import { runnerLlmConnection } from "../../integrations/agent/runner.js";
 import { assertRunnerCredentials } from "../../integrations/agent/runner-dispatch.js";
 import { isProcessEnabled } from "../../llm/feature-gate.js";
 import { resolveIndexPassExecution } from "../../llm/index-passes.js";
@@ -283,7 +284,7 @@ async function runMemoryInferencePassBody(ctx, provenance) {
     }), 
     // Caller-set connection concurrency or 1: `resolveLlmEngineUse` does
     // not forward `engines.<name>.concurrency`, so config cannot raise this.
-    llmRunner.connection.concurrency ?? 1);
+    runnerLlmConnection(llmRunner)?.concurrency ?? 1);
     if (configFailure)
         throw configFailure;
     for (let i = 0; i < perRecordResults.length; i++) {

package/dist/integrations/agent/builder-shared.js

@@ -5,6 +5,21 @@
 export function resolveDispatchModel(request, _profile, _platform) {
     return request.model;
 }
+/**
+ * The model an engine's own `args` select, as `--model X` or `--model=X` (the
+ * last one wins), for a builder that writes its own argv in place of those args.
+ */
+export function modelFromArgs(args) {
+    let model;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--model")
+            model = args[index + 1];
+        else if (arg?.startsWith("--model="))
+            model = arg.slice("--model=".length);
+    }
+    return model;
+}
 /**
  * Normalize a toolPolicy value to a comma-separated string suitable for a
  * CLI flag. Structured policy objects are JSON-serialized.

package/dist/integrations/agent/config.js

@@ -3,5 +3,5 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /** Default agent CLI timeout; null means agents run until they finish. */
 export const DEFAULT_AGENT_TIMEOUT_MS = null;
-/** Default hard timeout for direct LLM calls when no engine/use override exists. */
+/** Default hard timeout for a direct LLM call, and the bound on model work on every runner kind, when no engine/use override exists. */
 export const DEFAULT_LLM_TIMEOUT_MS = 600_000;

package/dist/integrations/agent/engine-resolution.js

@@ -10,10 +10,9 @@ import { SECRET_STORE_REFERENCE_PATTERN } from "../../core/config/schema/primiti
 import { ConfigError } from "../../core/errors.js";
 import { formatExtraParamsIssue, validateExtraParams } from "../../core/extra-params.js";
 import { collectSensitiveValues } from "../../core/redaction.js";
-import { warn } from "../../core/warn.js";
 import { resolveSecretFromStore } from "../../sources/snapshot-fetchers/secret-seam.js";
 import { getHarness } from "../harnesses/index.js";
-import { DEFAULT_AGENT_TIMEOUT_MS, DEFAULT_LLM_TIMEOUT_MS } from "./config.js";
+import { DEFAULT_LLM_TIMEOUT_MS } from "./config.js";
 import { getBuiltinAgentProfile, OPENCODE_SDK_SERVER_BIN } from "./profiles.js";
 const LLM_CONNECTION_FIELDS = [
     "provider",
@@ -217,29 +216,15 @@ function rawLlmConnection(engine) {
     }
     return connection;
 }
-export function resolveLlmEngineUse(config, layers, options = {}) {
+/** Resolve one selected LLM engine and overlays without materializing credentials. */
+export function resolveLlmEngineUse(config, layers) {
     const name = selectedEngineName(config, layers, true);
     if (!name) {
-        if (options.optional)
-            return undefined;
         throw new ConfigError("No LLM engine is selected. Set defaults.llmEngine or specify engine.", "LLM_NOT_CONFIGURED");
     }
     const engine = configuredEngine(name, config);
-    if (engine.kind !== "llm") {
-        const fallbackName = engine.llmEngine ?? config.defaults?.llmEngine;
-        const fallbackEngine = fallbackName ? configuredEngine(fallbackName, config) : undefined;
-        if (!fallbackEngine || fallbackEngine.kind !== "llm") {
-            if (options.optional)
-                return undefined;
-            throw new ConfigError(fallbackName
-                ? `Engine "${name}" is not an LLM engine, and its llmEngine fallback "${fallbackName}" is not one either.`
-                : `Engine "${name}" is not an LLM engine, and has no llmEngine fallback configured.`, "INVALID_CONFIG_FILE");
-        }
-        warn(`[akm] Engine "${name}" is an agent engine, not an LLM engine; using its llmEngine "${fallbackName}" instead.`);
-        return options.optional
-            ? resolveLlmEngineUse(config, [{ engine: fallbackName }], { optional: true })
-            : resolveLlmEngineUse(config, [{ engine: fallbackName }]);
-    }
+    if (engine.kind !== "llm")
+        throw new ConfigError(`Engine "${name}" is not an LLM engine.`, "INVALID_CONFIG_FILE");
     let connection = rawLlmConnection(engine);
     for (const layer of layers) {
         if (layer.llm)
@@ -301,19 +286,16 @@ function lowerAgentEngine(name, engine, config) {
         ...(engine.workspace ? { workspace: path.resolve(engine.workspace) } : {}),
         ...(engine.model ? { model: engine.model } : {}),
     };
+    // An engine that sets no timeoutMs leaves it unset, so a caller's own default
+    // (model work's 600 s) can apply; a dispatch with none runs unbounded.
     const ownTimeout = Object.hasOwn(engine, "timeoutMs") ? (engine.timeoutMs ?? null) : undefined;
     if (!sdk) {
-        return {
-            kind: "agent",
-            engine: name,
-            profile,
-            timeoutMs: ownTimeout !== undefined ? ownTimeout : DEFAULT_AGENT_TIMEOUT_MS,
-        };
+        return { kind: "agent", engine: name, profile, ...(ownTimeout !== undefined ? { timeoutMs: ownTimeout } : {}) };
     }
-    const fallbackName = engine.llmEngine ?? config.defaults?.llmEngine;
-    const fallback = fallbackName
-        ? resolveLlmEngineUse(config, [{ engine: fallbackName }], { optional: true })
-        : undefined;
+    // The fallback connection is the engine's own `llmEngine` and nothing else. `defaults.llmEngine`
+    // is the default engine for model work, not a connection every SDK engine borrows: with no
+    // `llmEngine`, opencode resolves provider, model and auth from its own configuration.
+    const fallback = engine.llmEngine ? resolveLlmEngineUse(config, [{ engine: engine.llmEngine }]) : undefined;
     return {
         kind: "sdk",
         engine: name,
@@ -327,7 +309,7 @@ function lowerAgentEngine(name, engine, config) {
                 fallbackTimeoutMs: fallback.timeoutMs,
             }
             : {}),
-        timeoutMs: ownTimeout !== undefined ? ownTimeout : (fallback?.timeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS),
+        ...(ownTimeout !== undefined ? { timeoutMs: ownTimeout } : fallback ? { timeoutMs: fallback.timeoutMs } : {}),
     };
 }
 /** Resolve a configured engine name to its runner: an LLM connection, a spawned agent, or the SDK. */