akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/integrations/agent/persona-fallback.js

@@ -0,0 +1,30 @@
+// 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/.
+export const PERSONA_FALLBACK_NOTICE_CODE = "persona-prompt-composed";
+export const PERSONA_FALLBACK_BEGIN = "<AKM_PERSONA>";
+export const PERSONA_FALLBACK_END = "</AKM_PERSONA>";
+function withTrailingNewline(value) {
+    return value.endsWith("\n") ? value : `${value}\n`;
+}
+/** Preserve a persona when a target has no native system/persona channel. */
+export function composePersonaFallbackPrompt(persona, command, adapter) {
+    if (typeof persona !== "string" || typeof command !== "string") {
+        throw new TypeError("persona fallback content must be strings");
+    }
+    if (typeof adapter !== "string" || adapter.length === 0) {
+        throw new TypeError("persona fallback adapter must be a non-empty string");
+    }
+    const notice = Object.freeze({
+        code: PERSONA_FALLBACK_NOTICE_CODE,
+        severity: "info",
+        adapter,
+        field: "persona",
+        message: "The selected engine has no native persona channel; AKM composed the persona into the prompt.",
+    });
+    const notices = Object.freeze([notice]);
+    return Object.freeze({
+        prompt: `${PERSONA_FALLBACK_BEGIN}\n${withTrailingNewline(persona)}${PERSONA_FALLBACK_END}\n\n${command}`,
+        notices,
+    });
+}

package/dist/integrations/agent/request-lowering.js

@@ -0,0 +1,186 @@
+// 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 { ConfigError } from "../../core/errors.js";
+import { composeConversationFallbackPrompt } from "./conversation-fallback.js";
+import { composePersonaFallbackPrompt } from "./persona-fallback.js";
+function own(value, key) {
+    return Object.hasOwn(value, key);
+}
+function hasToolSelection(value) {
+    if (value === null)
+        return false;
+    if (typeof value === "string")
+        return value.length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    return Object.keys(value).length > 0;
+}
+function translatesTools(mode, value) {
+    if (!hasToolSelection(value))
+        return true;
+    if (mode === "all")
+        return true;
+    if (mode === "flat")
+        return typeof value === "string" || Array.isArray(value);
+    if (mode === "sdk") {
+        return (typeof value === "string" ||
+            Array.isArray(value) ||
+            (value !== null && Object.values(value).every((entry) => typeof entry === "boolean")));
+    }
+    return false;
+}
+function notice(adapter, field) {
+    return Object.freeze({
+        code: "untranslated-field",
+        severity: "warning",
+        adapter,
+        field,
+        message: `The ${adapter} lowerer does not translate resolved field ${field}; dispatch will continue optimistically.`,
+    });
+}
+function conversationFallbackNotice(adapter) {
+    return Object.freeze({
+        code: "conversation-prompt-composed",
+        severity: "warning",
+        adapter,
+        field: "conversation",
+        message: `The ${adapter} transport has no native multi-message channel; AKM composed the conversation prefix into one deterministic JSON prompt block.`,
+    });
+}
+function selectedExtensionPaths(request) {
+    const out = [];
+    if (own(request, "extensions"))
+        out.push("extensions");
+    if (own(request.command, "extensions"))
+        out.push("command.extensions");
+    const persona = own(request, "persona") ? request.persona : undefined;
+    if (persona && own(persona, "extensions"))
+        out.push("persona.extensions");
+    if (own(request.engine, "extensions"))
+        out.push("engine.extensions");
+    if (own(request.runtime, "extensions"))
+        out.push("runtime.extensions");
+    return out;
+}
+function sortedUnique(values) {
+    return Object.freeze([...new Set(values)].sort());
+}
+/**
+ * Build one harness-owned structural lowerer. Each harness registers the
+ * function it gets back beside its argv builder; no global model/provider
+ * capability table participates in dispatch.
+ */
+export function createAgentRequestLowerer(options) {
+    const supportedInference = new Set(options.inference ?? []);
+    return (_profile, request) => {
+        const translated = new Set(["command.content", "engine"]);
+        for (const field of ["timeoutMs", "workspace", "environment"]) {
+            if (own(request.runtime, field))
+                translated.add(`runtime.${field}`);
+        }
+        const untranslated = new Set();
+        const notices = [];
+        const reject = (field) => {
+            untranslated.add(field);
+            notices.push(notice(options.adapter, field));
+        };
+        let prompt = request.command.content;
+        if (own(request, "conversation")) {
+            translated.add("conversation");
+            if (request.conversation && request.conversation.length > 0) {
+                prompt = composeConversationFallbackPrompt(request.conversation, prompt);
+                notices.push(conversationFallbackNotice(options.adapter));
+            }
+        }
+        let systemPrompt;
+        const persona = own(request, "persona") ? request.persona : undefined;
+        const agent = own(request, "agent") ? request.agent : undefined;
+        let nativeAgent;
+        if (persona) {
+            if (options.personaChannel === "native") {
+                systemPrompt = persona.content;
+                translated.add("persona");
+            }
+            else {
+                const composed = composePersonaFallbackPrompt(persona.content, prompt, options.adapter);
+                prompt = composed.prompt;
+                notices.push(...composed.notices);
+                translated.add("persona");
+            }
+            if (typeof agent === "string")
+                translated.add("agent");
+        }
+        else if (typeof agent === "string") {
+            if (!options.nativeAgentSelector) {
+                throw new ConfigError(`The ${options.adapter} transport cannot consume native agent selector ${JSON.stringify(agent)}.`, "INVALID_CONFIG_FILE");
+            }
+            nativeAgent = agent;
+            translated.add("agent");
+        }
+        else if (own(request, "agent")) {
+            translated.add("agent");
+        }
+        const dispatch = { prompt };
+        if (nativeAgent !== undefined)
+            dispatch.agent = nativeAgent;
+        if (systemPrompt !== undefined)
+            dispatch.systemPrompt = systemPrompt;
+        if (own(request, "model")) {
+            translated.add("model");
+            if (request.model) {
+                dispatch.model = request.model.resolved;
+            }
+        }
+        if (own(request, "inference")) {
+            dispatch.inference = request.inference;
+            const inference = request.inference;
+            if (inference && Object.keys(inference).length > 0) {
+                for (const key of Object.keys(inference).sort()) {
+                    const field = `inference.${key}`;
+                    if (supportedInference.has(key))
+                        translated.add(field);
+                    else
+                        reject(field);
+                }
+                if (typeof inference.effort === "string")
+                    dispatch.effort = inference.effort;
+            }
+            else {
+                translated.add("inference");
+            }
+        }
+        if (own(request, "outputSchema")) {
+            if (request.outputSchema === null || options.outputSchema)
+                translated.add("outputSchema");
+            else
+                reject("outputSchema");
+            if (request.outputSchema)
+                dispatch.schema = request.outputSchema;
+        }
+        if (own(request, "tools")) {
+            const tools = request.tools;
+            if (translatesTools(options.tools, tools))
+                translated.add("tools");
+            else
+                reject("tools");
+            dispatch.tools = tools;
+        }
+        if (own(request.runtime, "settings")) {
+            const settings = request.runtime.settings;
+            if (settings === null || Object.keys(settings).length === 0)
+                translated.add("runtime.settings");
+            else
+                reject("runtime.settings");
+        }
+        for (const field of selectedExtensionPaths(request))
+            reject(field);
+        return Object.freeze({
+            prompt,
+            dispatch: Object.freeze(dispatch),
+            translatedFields: sortedUnique(translated),
+            untranslatedFields: sortedUnique(untranslated),
+            notices: Object.freeze(notices),
+        });
+    };
+}

package/dist/integrations/agent/runner-dispatch.js

@@ -2,37 +2,183 @@
 // 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/.
 /**
- * X3 — the ONE dispatch seam for the {@link RunnerSpec} tagged union.
+ * The low-level exhaustive dispatch seam for the {@link RunnerSpec} transport
+ * union (`llm | agent | sdk`). User/model work reaches this function only
+ * after `ResolvedExecutionRequestV1` preparation and engine-owned lowering;
+ * `dispatchLoweredExecutionRequest` supplies the direct-LLM handler. A
+ * prompt-free native launch crosses the explicit payload-free interactive
+ * lowerer in that same shared layer.
  *
- * The improve slice dispatches a `RunnerSpec` (`llm | agent | sdk`) in several
- * places (`reflect.ts`, `proposal/drain.ts`, …). Before this module each site
- * re-rolled the identical 3-arm switch and re-declared its own per-kind test
- * seams (`chat`, `runAgentFn`, `runSdkFn`). `executeRunner` collapses that into
- * one switch + one {@link RunnerSeams} object.
- *
- * Scoping (behavior-preserving):
- *   - The `agent` and `sdk` arms are byte-identical across call sites: invoke
- *     the profile runner (`runAgent` / `runOpencodeSdk`) with the per-call
- *     `RunAgentOptions` the caller passes. Those default runners live here so
- *     callers stop importing `runAgent` / `runOpencodeSdk` for dispatch. The
- *     `opts` (incl. any `timeoutMs`) is constructed by the caller and passed
- *     through unchanged, so each site keeps its exact option set.
- *   - The `llm` arm is irreducibly caller-specific (reflect wraps
- *     `runReflectViaLlm`, which returns reflect's iteration shape; drain wraps a
- *     plain `chatCompletion`). It is therefore a REQUIRED seam — there is no
- *     default `llm` handler — so neither caller's bespoke behavior is changed.
- *   - The `assertNever` exhaustiveness arm is kept so a 4th `RunnerSpec` kind is
- *     a compile error here instead of a silent runtime fall-through.
- *
- * The return type is {@link AgentRunResult} so a later `callStructured` layer
- * (X2) can wrap `executeRunner` without changing this contract.
+ * Agent and SDK arms use the shared profile runners. The LLM arm deliberately
+ * requires a handler because structured callers own their parse/fallback
+ * contract. The `assertNever` arm keeps a fourth transport kind from becoming
+ * an implicit fallthrough. Symbolic LLM and SDK-fallback credentials are
+ * materialized here, at authorized operation-lease acquisition or the final
+ * single-call boundary, then scrubbed from the result.
  */
 import { assertNever } from "../../core/assert.js";
 import { collectSensitiveValues, isEnvPassthroughValueSafeToExpose, redactSensitiveText, redactSensitiveValue, } from "../../core/redaction.js";
-import { closeServer as disposeOpencodeSdkServers, runOpencodeSdk } from "../harnesses/opencode-sdk/sdk-runner.js";
-import { materializeLlmConnection } from "./engine-resolution.js";
-import { materializeLlmRunnerConnection } from "./runner.js";
+import { spawnEnvNamesFor } from "../../core/spawn-env.js";
+import { closeServer as disposeOpencodeSdkServers, opencodeSdkServerEnvironmentNames, runOpencodeSdk, } from "../harnesses/opencode-sdk/sdk-runner.js";
+import { lookupCredentialFromEnv, materializeLlmConnection, materializeLlmConnectionWithCredential, resolveCredentialFromEnv, } from "./engine-resolution.js";
+import { materializeLlmRunnerConnection, materializeLlmRunnerConnectionWithCredential, } from "./runner.js";
 import { runAgent } from "./spawn.js";
+const liveRunnerDispatchLeases = new WeakMap();
+const issuedRunnerDispatchLeases = new WeakSet();
+const disposedRunnerDispatchLeases = new WeakSet();
+function credentialBinding(credential) {
+    return credential ? { names: [...credential.names], required: credential.required } : null;
+}
+function passthroughBinding(spec) {
+    return [...new Set(spec.profile.envPassthrough)].sort();
+}
+function dispatchEnvironmentNames(spec) {
+    switch (spec.kind) {
+        case "llm":
+            return [];
+        case "agent":
+            return spawnEnvNamesFor(spec.profile.envPassthrough);
+        case "sdk":
+            return opencodeSdkServerEnvironmentNames(spec.profile);
+        default:
+            return assertNever(spec);
+    }
+}
+function snapshotDispatchEnvironment(spec, envSource) {
+    const snapshot = new Map();
+    const read = (name) => {
+        if (!snapshot.has(name))
+            snapshot.set(name, envSource[name]);
+        return snapshot.get(name);
+    };
+    const environmentSource = new Proxy(Object.create(null), {
+        get(_target, property) {
+            return typeof property === "string" ? snapshot.get(property) : undefined;
+        },
+    });
+    for (const name of dispatchEnvironmentNames(spec))
+        read(name);
+    const passthroughSensitiveValues = new Set();
+    if (spec.kind !== "llm") {
+        for (const name of new Set(spec.profile.envPassthrough)) {
+            const value = snapshot.get(name);
+            if (!isEnvPassthroughValueSafeToExpose(name, value) && value)
+                passthroughSensitiveValues.add(value);
+        }
+    }
+    return { environmentSnapshot: snapshot, environmentSource, passthroughSensitiveValues, read };
+}
+/** Bind only transport identity; request model/inference/schema/timeout remain per-call. */
+function runnerLeaseBinding(spec) {
+    switch (spec.kind) {
+        case "llm":
+            return JSON.stringify({
+                kind: spec.kind,
+                engine: spec.engine ?? null,
+                endpoint: spec.connection.endpoint,
+                provider: spec.connection.provider ?? null,
+                credential: credentialBinding(spec.credential),
+            });
+        case "agent":
+            return JSON.stringify({
+                kind: spec.kind,
+                engine: spec.engine ?? null,
+                platform: spec.profile.platform ?? null,
+                name: spec.profile.name,
+                bin: spec.profile.bin,
+                envPassthrough: passthroughBinding(spec),
+            });
+        case "sdk":
+            return JSON.stringify({
+                kind: spec.kind,
+                engine: spec.engine ?? null,
+                platform: spec.profile.platform ?? null,
+                name: spec.profile.name,
+                bin: spec.profile.bin,
+                envPassthrough: passthroughBinding(spec),
+                fallbackEndpoint: spec.fallbackConnection?.endpoint ?? null,
+                fallbackProvider: spec.fallbackConnection?.provider ?? null,
+                fallbackCredential: credentialBinding(spec.fallbackCredential),
+            });
+        default:
+            return assertNever(spec);
+    }
+}
+function requireRunnerDispatchLease(lease, spec) {
+    if (typeof lease !== "object" || lease === null)
+        throw new TypeError("invalid dispatch lease");
+    const state = liveRunnerDispatchLeases.get(lease);
+    if (!state) {
+        if (issuedRunnerDispatchLeases.has(lease) && disposedRunnerDispatchLeases.has(lease)) {
+            throw new TypeError("dispatch lease is disposed");
+        }
+        throw new TypeError("invalid dispatch lease");
+    }
+    if (spec && state.binding !== runnerLeaseBinding(spec)) {
+        throw new TypeError("dispatch lease does not match the lowered runner transport");
+    }
+    return state;
+}
+/** @internal Verify provenance, liveness, and transport binding without exposing state. */
+export function assertRunnerDispatchLease(lease, spec) {
+    requireRunnerDispatchLease(lease, spec);
+}
+/** @internal Acquire only through execution-lowering after authorization/provenance validation. */
+export function acquireRunnerDispatchLease(spec, envSource = process.env) {
+    const environment = snapshotDispatchEnvironment(spec, envSource);
+    const credentialSource = new Proxy(Object.create(null), {
+        get(_target, property) {
+            return typeof property === "string" ? environment.read(property) : undefined;
+        },
+    });
+    const primaryCredential = spec.kind === "llm" ? resolveCredentialFromEnv(spec.credential, credentialSource) : undefined;
+    const fallbackCredential = spec.kind === "sdk" ? resolveCredentialFromEnv(spec.fallbackCredential, credentialSource) : undefined;
+    const handle = Object.create(null);
+    Object.defineProperty(handle, "toJSON", {
+        configurable: false,
+        enumerable: false,
+        writable: false,
+        value: () => {
+            throw new TypeError("dispatch lease is not serializable");
+        },
+    });
+    Object.freeze(handle);
+    const sensitiveValues = collectSensitiveValues([
+        primaryCredential,
+        fallbackCredential,
+        ...environment.passthroughSensitiveValues,
+    ]);
+    liveRunnerDispatchLeases.set(handle, {
+        binding: runnerLeaseBinding(spec),
+        primaryCredential,
+        fallbackCredential,
+        environmentSnapshot: environment.environmentSnapshot,
+        environmentSource: environment.environmentSource,
+        sensitiveValues,
+    });
+    issuedRunnerDispatchLeases.add(handle);
+    return handle;
+}
+/** @internal Scrub private material and invalidate one issued handle. */
+export function disposeRunnerDispatchLease(lease) {
+    if (typeof lease !== "object" || lease === null || !issuedRunnerDispatchLeases.has(lease)) {
+        throw new TypeError("invalid dispatch lease");
+    }
+    const state = liveRunnerDispatchLeases.get(lease);
+    if (!state)
+        return;
+    state.primaryCredential = undefined;
+    state.fallbackCredential = undefined;
+    state.environmentSnapshot.clear();
+    state.sensitiveValues.fill("");
+    state.sensitiveValues = [];
+    liveRunnerDispatchLeases.delete(lease);
+    disposedRunnerDispatchLeases.add(lease);
+}
+/** @internal Redact with private credential material without exposing its values. */
+export function redactWithRunnerDispatchLease(lease, value) {
+    return redactSensitiveText(value, requireRunnerDispatchLease(lease).sensitiveValues);
+}
 /**
  * Release every long-lived resource the dispatch runners CACHE for reuse, so a
  * one-shot process (the CLI) can exit cleanly once dispatching is done.
@@ -67,6 +213,10 @@ export function collectDispatchSensitiveValues(spec, opts, envSource = opts.envS
         addConnection(spec.connection);
     if (spec.kind === "sdk")
         addConnection(spec.fallbackConnection);
+    if (spec.kind === "llm")
+        add(lookupCredentialFromEnv(spec.credential, envSource));
+    if (spec.kind === "sdk")
+        add(lookupCredentialFromEnv(spec.fallbackCredential, envSource));
     if (spec.kind !== "llm") {
         for (const value of Object.values(spec.profile.env ?? {}))
             add(value);
@@ -82,6 +232,33 @@ export function collectDispatchSensitiveValues(spec, opts, envSource = opts.envS
     }
     return collectSensitiveValues(values);
 }
+function collectNonCredentialDispatchSensitiveValues(spec, opts, envSource = opts.envSource ?? process.env, includeProfilePassthrough = true) {
+    const values = new Set();
+    const add = (value) => {
+        if (value !== undefined && value.length > 0)
+            values.add(value);
+    };
+    if (spec.kind === "llm")
+        add(spec.connection.apiKey);
+    if (spec.kind === "sdk")
+        add(spec.fallbackConnection?.apiKey);
+    if (spec.kind !== "llm") {
+        for (const value of Object.values(spec.profile.env ?? {}))
+            add(value);
+        if (includeProfilePassthrough) {
+            for (const name of spec.profile.envPassthrough) {
+                const value = envSource[name];
+                if (!isEnvPassthroughValueSafeToExpose(name, value))
+                    add(value);
+            }
+        }
+    }
+    for (const [name, value] of Object.entries(opts.env ?? {})) {
+        if (!isEnvPassthroughValueSafeToExpose(name, value))
+            add(value);
+    }
+    return collectSensitiveValues(values);
+}
 function redactResult(result, sensitiveValues) {
     return {
         ...result,
@@ -94,23 +271,33 @@ function redactResult(result, sensitiveValues) {
 /**
  * Dispatch a {@link RunnerSpec} to its runner and return the raw
  * {@link AgentRunResult}. `opts` is the {@link RunAgentOptions} for the profile
- * (`agent` / `sdk`) arms; it is passed through unchanged so each caller keeps
- * its exact option set (incl. any `timeoutMs` the caller chose to apply).
+ * (`agent` / `sdk`) arms. Callers keep their per-call options; a bound lease
+ * replaces only `envSource` with its private immutable environment snapshot.
  */
-export async function executeRunner(spec, prompt, opts, seams = {}) {
-    const withSpecOptions = (timeoutMs, workspace) => ({
+export async function executeRunner(spec, prompt, opts, seams = {}, lease) {
+    const withSpecOptions = (timeoutMs, workspace, environmentSource) => ({
         ...opts,
         ...(Object.hasOwn(opts, "timeoutMs") ? {} : timeoutMs !== undefined ? { timeoutMs } : {}),
         ...(opts.cwd === undefined && workspace ? { cwd: workspace } : {}),
+        ...(environmentSource ? { envSource: environmentSource } : {}),
     });
     let result;
     const dispatchSensitiveValues = [];
+    const leaseState = lease ? requireRunnerDispatchLease(lease, spec) : undefined;
+    const preDispatchSensitiveValues = leaseState
+        ? collectSensitiveValues([
+            ...leaseState.sensitiveValues,
+            ...collectNonCredentialDispatchSensitiveValues(spec, opts, undefined, false),
+        ])
+        : collectDispatchSensitiveValues(spec, opts);
     switch (spec.kind) {
         case "llm": {
             if (!seams.llm) {
                 throw new Error("executeRunner: an `llm` runner requires a `seams.llm` handler (no default LLM dispatch).");
             }
-            const connection = materializeLlmRunnerConnection(spec);
+            const connection = leaseState
+                ? materializeLlmRunnerConnectionWithCredential(spec, leaseState.primaryCredential)
+                : materializeLlmRunnerConnection(spec);
             if (connection.apiKey)
                 dispatchSensitiveValues.push(connection.apiKey);
             result = await seams.llm({ ...spec, connection }, prompt, withSpecOptions(spec.timeoutMs));
@@ -118,13 +305,13 @@ export async function executeRunner(spec, prompt, opts, seams = {}) {
         }
         case "agent": {
             const run = seams.runAgent ?? runAgent;
-            result = await run(spec.profile, prompt, withSpecOptions(spec.timeoutMs, spec.profile.workspace));
+            result = await run(spec.profile, prompt, withSpecOptions(spec.timeoutMs, spec.profile.workspace, leaseState?.environmentSource));
             break;
         }
         case "sdk": {
             const run = seams.runSdk ?? runOpencodeSdk;
-            const fallbackConnection = spec.fallbackConnection
-                ? materializeLlmConnection({
+            const fallbackMaterial = spec.fallbackConnection
+                ? {
                     engine: spec.engine ?? "unnamed-sdk-fallback",
                     connection: spec.fallbackConnection,
                     ...(spec.fallbackCredential ? { credential: spec.fallbackCredential } : {}),
@@ -133,16 +320,22 @@ export async function executeRunner(spec, prompt, opts, seams = {}) {
                         : Object.hasOwn(spec.fallbackConnection, "timeoutMs")
                             ? (spec.fallbackConnection.timeoutMs ?? null)
                             : null,
-                })
+                }
+                : undefined;
+            const fallbackConnection = fallbackMaterial
+                ? leaseState
+                    ? materializeLlmConnectionWithCredential(fallbackMaterial, leaseState.fallbackCredential)
+                    : materializeLlmConnection(fallbackMaterial)
                 : undefined;
             if (fallbackConnection?.apiKey)
                 dispatchSensitiveValues.push(fallbackConnection.apiKey);
-            result = await run(spec.profile, prompt, withSpecOptions(spec.timeoutMs, spec.profile.workspace), fallbackConnection);
+            result = await run(spec.profile, prompt, withSpecOptions(spec.timeoutMs, spec.profile.workspace, leaseState?.environmentSource), fallbackConnection);
             break;
         }
         default:
             // Exhaustiveness arm: a 4th RunnerSpec kind becomes a compile error here.
             return assertNever(spec);
     }
-    return redactResult(result, [...collectDispatchSensitiveValues(spec, opts), ...dispatchSensitiveValues]);
+    const sensitiveValues = collectSensitiveValues([...preDispatchSensitiveValues, ...dispatchSensitiveValues]);
+    return redactResult(result, sensitiveValues);
 }

package/dist/integrations/agent/runner.js

@@ -1,99 +1,28 @@
 // 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 { ConfigError } from "../../core/errors.js";
-import { materializeLlmConnection, resolveEngine, resolveLlmEngineUse, } from "./engine-resolution.js";
-import { resolveModel } from "./model-aliases.js";
+import { materializeLlmConnection, materializeLlmConnectionWithCredential, } from "./engine-resolution.js";
 /** Resolve the current credential value for one frozen LLM runner at dispatch. */
 export function materializeLlmRunnerConnection(runner) {
-    const connectionWithLegacyTimeout = runner.connection;
-    const timeoutMs = runner.timeoutMs !== undefined
-        ? runner.timeoutMs
-        : Object.hasOwn(connectionWithLegacyTimeout, "timeoutMs")
-            ? (connectionWithLegacyTimeout.timeoutMs ?? null)
-            : null;
     return materializeLlmConnection({
-        engine: runner.engine ?? "unnamed",
+        engine: runner.engine,
         connection: runner.connection,
         ...(runner.credential ? { credential: runner.credential } : {}),
-        timeoutMs,
+        timeoutMs: runner.timeoutMs ?? null,
     });
 }
+/** Inject an already-snapshotted credential without consulting live process state. */
+export function materializeLlmRunnerConnectionWithCredential(runner, credentialValue) {
+    return materializeLlmConnectionWithCredential({
+        engine: runner.engine,
+        connection: runner.connection,
+        ...(runner.credential ? { credential: runner.credential } : {}),
+        timeoutMs: runner.timeoutMs ?? null,
+    }, credentialValue);
+}
 export function runnerIsLlm(runner) {
     return runner.kind === "llm";
 }
 export function runnerSupportsFileWrite(runner) {
     return runner.kind !== "llm";
 }
-/** Resolve the configured LLM default without ever consulting retired profiles. */
-export function resolveDefaultLlmRunner(config, timeoutMs) {
-    const resolved = resolveLlmEngineUse(config, [], { optional: true });
-    if (!resolved)
-        return null;
-    return {
-        kind: "llm",
-        engine: resolved.engine,
-        connection: resolved.connection,
-        ...(resolved.credential ? { credential: resolved.credential } : {}),
-        ...(timeoutMs !== undefined ? { timeoutMs } : { timeoutMs: resolved.timeoutMs }),
-    };
-}
-/** Resolve a triage judgment using judgment -> triage -> strategy -> defaults.llmEngine precedence. */
-export function resolveTriageJudgmentRunner(judgment, config, triage, strategy) {
-    const layers = [strategy ?? {}, triage ?? {}, judgment ?? {}];
-    const selectedEngine = judgment?.engine ?? triage?.engine ?? strategy?.engine ?? config.defaults?.llmEngine;
-    if (selectedEngine) {
-        const runner = resolveEngine(selectedEngine, config);
-        if (runner.kind === "llm") {
-            const resolved = resolveLlmEngineUse(config, layers);
-            return {
-                kind: "llm",
-                engine: resolved.engine,
-                connection: resolved.connection,
-                ...(resolved.credential ? { credential: resolved.credential } : {}),
-                timeoutMs: resolved.timeoutMs,
-            };
-        }
-        const effectiveLlmOverrides = [...layers].reverse().find((layer) => layer.llm !== undefined)?.llm;
-        if (effectiveLlmOverrides) {
-            throw new ConfigError(`Triage judgment engine "${selectedEngine}" is an agent engine and cannot receive llm overrides.`, "INVALID_CONFIG_FILE");
-        }
-        const model = [...layers].reverse().find((layer) => layer.model !== undefined)?.model;
-        const profile = model
-            ? {
-                ...runner.profile,
-                model: resolveModel(model, runner.profile.platform ?? runner.profile.name, runner.profile.modelAliases, runner.profile.globalModelAliases),
-                modelIsExact: true,
-            }
-            : runner.profile;
-        const timeoutLayer = [...layers].reverse().find((layer) => Object.hasOwn(layer, "timeoutMs"));
-        return {
-            ...runner,
-            profile,
-            ...(timeoutLayer ? { timeoutMs: timeoutLayer.timeoutMs ?? null } : {}),
-        };
-    }
-    return null;
-}
-export function resolveImproveProcessLlmUse(config, strategy, processName, options = {}) {
-    const process = strategy?.processes?.[processName];
-    const layers = strategy ? [strategy, process ?? {}] : [];
-    return options.optional
-        ? resolveLlmEngineUse(config, layers, { optional: true })
-        : resolveLlmEngineUse(config, layers);
-}
-/** Resolve the LLM runner selected by an improve strategy and process without reading credentials. */
-export function resolveImproveProcessRunner(strategy, processName, config) {
-    if (!strategy)
-        return null;
-    const resolved = resolveImproveProcessLlmUse(config, strategy, processName, { optional: true });
-    if (!resolved)
-        return null;
-    return {
-        kind: "llm",
-        engine: resolved.engine,
-        connection: resolved.connection,
-        ...(resolved.credential ? { credential: resolved.credential } : {}),
-        timeoutMs: resolved.timeoutMs,
-    };
-}