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

package/dist/workflows/exec/native-executor.js

@@ -2,7 +2,7 @@
 // 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/.
 /**
- * Native executor — executes ONE step's IR v2 subgraph (`IrStepPlan.root`) on
+ * Native executor — executes one frozen step subgraph (`IrStepPlan.root`) on
  * the local machine: fan-out through the scheduler, schema-validated
  * structured output through `runStructured` (core/structured.ts), per-unit
  * persistence through the serialized writer queue, and `workflow_unit_*`
@@ -74,9 +74,7 @@
  *     never a silent re-dispatch — under a frozen plan the same identity must
  *     reproduce the same inputs, so a mismatch means the journal (or params
  *     row) was tampered with. Failed/running/missing rows dispatch live.
- *   - Pre-release R1 journals used positional ids (`node.unit[3]`). There is
- *     no back-compat shim: those rows simply never match a content-derived id
- *     and are ignored (the step re-runs cleanly on top of them).
+ *   - Rows with unrelated ids never match a content-derived id and are ignored.
  *
  * Gate loops (addendum, R2 `gate.max_loops`): when the engine re-executes a
  * step subgraph after a gate rejection, it threads the judge's feedback in as
@@ -129,22 +127,22 @@
  *   - This module NEVER writes step rows: advancing the gated spine is the
  *     engine loop's job (`run-workflow.ts`) via `completeWorkflowStep`.
  */
+import { deepMergeConfig } from "../../core/config/deep-merge.js";
 import { ConfigError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { validateJsonSchemaSubset } from "../../core/json-schema.js";
+import { collectSensitiveValues, isEnvPassthroughValueSafeToExpose, redactSensitiveValue } from "../../core/redaction.js";
 import { runStructured } from "../../core/structured.js";
 import { warn } from "../../core/warn.js";
+import { insertEventStrict } from "../../storage/repositories/events-repository.js";
 import { withWorkflowRunsRepo } from "../../storage/repositories/workflow-runs-repository.js";
 import { LIFETIME_UNIT_CAP, scheduleUnits, UnitCapExceededError } from "./scheduler.js";
 // Shared step semantics — the ONE implementation consumed by both the engine
 // (this module + run-workflow.ts) and, from R3, the brief/report driver
 // protocol. This module dispatches; step-work.ts owns the pure decisions.
-import { buildArtifactSummary, computeStepWorkList, DEFAULT_UNIT_TIMEOUT_MS, projectStepOutput, reduceEmptyStep, reduceStepOutcomes, stepOutputsFromEvidence, unitOutcomeFromRow, } from "./step-work.js";
+import { computeStepWorkList, reduceEmptyStep, reduceStepOutcomes, stepOutputsFromEvidence, unitOutcomeFromRow, } from "./step-work.js";
 import { enqueueUnitWrite } from "./unit-writer.js";
 import { assertGitWorkTree, cleanupUnitWorktree, createUnitWorktree } from "./worktree.js";
-// Re-exported for existing consumers (run-workflow.ts, tests) that import these
-// from native-executor; they now live in the shared step-work module.
-export { buildArtifactSummary, DEFAULT_UNIT_TIMEOUT_MS, projectStepOutput };
 /**
  * Mutable per-step dispatch budget: the lifetime unit cap PLUS the declared
  * run-level budget ceilings (`budget.max_units` / `budget.max_tokens`,
@@ -254,6 +252,7 @@ export async function executeStepPlan(plan, ctx) {
         runId: ctx.runId,
         params: ctx.params,
         stepOutputs: stepOutputsFromEvidence(ctx.evidence),
+        engines: ctx.engines ?? {},
         ...(ctx.gateLoop !== undefined ? { gateLoop: ctx.gateLoop } : {}),
         ...(ctx.gateFeedback ? { gateFeedback: ctx.gateFeedback } : {}),
     });
@@ -310,7 +309,8 @@ export async function executeStepPlan(plan, ctx) {
     // attempt in dispatchJournaledAttempt.
     let worktreeBase;
     if (willDispatch && template.isolation === "worktree") {
-        if (template.runner === "llm") {
+        const engine = template.invocation ? ctx.engines?.[template.invocation.engine] : undefined;
+        if (engine?.kind === "llm") {
             return failedStep(dispatched, `Step "${plan.stepId}" declares isolation: worktree on an llm unit — the llm runner has no ` +
                 `working directory to isolate. Use the agent or sdk runner for worktree-isolated units.`);
         }
@@ -357,6 +357,12 @@ export async function executeStepPlan(plan, ctx) {
         ...(onExceeded ? { onExceeded } : {}),
     });
     let outcomes;
+    const selectedEngine = template.invocation ? ctx.engines?.[template.invocation.engine] : undefined;
+    const selectedLlmEngine = selectedEngine?.kind === "llm"
+        ? selectedEngine
+        : selectedEngine?.kind === "agent" && selectedEngine.fallbackLlmEngine
+            ? ctx.engines?.[selectedEngine.fallbackLlmEngine]
+            : undefined;
     try {
         outcomes = await scheduleUnits(workUnits, (workUnit) => runUnit({
             plan,
@@ -372,6 +378,7 @@ export async function executeStepPlan(plan, ctx) {
             concurrency: workList.list.concurrency,
             signal,
             maxConcurrency: ctx.maxConcurrency,
+            ...(selectedLlmEngine?.kind === "llm" ? { llmConcurrency: selectedLlmEngine.concurrency } : {}),
         });
     }
     finally {
@@ -427,25 +434,35 @@ async function runUnit(input) {
     if (!workUnit.resolved.ok) {
         return { unitId, ok: false, failureReason: "expression_error", error: workUnit.resolved.error };
     }
+    if (!workUnit.engine || !workUnit.invocation) {
+        return {
+            unitId,
+            ok: false,
+            failureReason: "dispatch_error",
+            error: `unit "${unitId}" has no frozen engine snapshot and cannot be dispatched`,
+        };
+    }
     // The prompt (and therefore the input hash) was built once with the BASE
     // unit id by computeStepWorkList: a retry re-dispatches the SAME input, the
     // `~r<n>` suffix is journal bookkeeping only.
     const { prompt, inputHash } = workUnit.resolved;
+    const sensitiveValues = collectWorkflowDispatchSensitiveValues(workUnit, env);
     const request = {
         runId: ctx.runId,
         stepId: plan.stepId,
         unitId,
         nodeId: workUnit.nodeId,
         prompt,
-        runner: workUnit.runner,
-        ...(workUnit.profile ? { profile: workUnit.profile } : {}),
-        ...(workUnit.model ? { model: workUnit.model } : {}),
+        engine: workUnit.engine,
+        ...(workUnit.fallbackEngine ? { fallbackEngine: workUnit.fallbackEngine } : {}),
+        invocation: workUnit.invocation,
         timeoutMs: workUnit.timeoutMs,
         ...(workUnit.schema ? { schema: workUnit.schema } : {}),
         ...(env ? { env } : {}),
+        ...(sensitiveValues.length > 0 ? { sensitiveValues } : {}),
         ...(input.signal ? { signal: input.signal } : {}),
     };
-    // Bounded retry (IR v2 failure policy): attempt 0 journals under the base
+    // Bounded retry: attempt 0 journals under the base
     // journal id (`<unitId>`, or `<unitId>~l<loop>` in a gate loop — computed by
     // the shared work-list), retry attempt N under `<baseId>~r<N>`. Every attempt
     // keeps its own row. Retries only fire when the failure reason is in
@@ -560,7 +577,8 @@ async function dispatchJournaledAttempt(input) {
             parentUnitId: workUnit.isFanOut ? `${plan.stepId}.map` : null,
             phase: null,
             runner: workUnit.runner,
-            model: workUnit.model ?? null,
+            engine: request.engine.name,
+            model: request.invocation.model,
             inputHash,
             worktreePath: worktreePath ?? null,
             startedAt: new Date().toISOString(),
@@ -573,9 +591,15 @@ async function dispatchJournaledAttempt(input) {
         ref: ctx.workflowRef,
         metadata: { runId: ctx.runId, stepId: plan.stepId, unitId: attemptId },
     });
-    const outcome = await dispatchUnit(request, dispatcher);
-    await enqueueUnitWrite(async () => {
-        await withWorkflowRunsRepo((repo) => repo.finishUnit({
+    const outcome = redactUnitOutcome(await dispatchUnit(request, dispatcher), request.sensitiveValues ?? []);
+    const finishedAt = new Date().toISOString();
+    await enqueueUnitWrite(() => withWorkflowRunsRepo((repo) => repo.immediateTransaction((db) => {
+        const run = repo.getRunById(ctx.runId);
+        if (run?.status !== "active")
+            return;
+        if (ctx.leaseHolder !== undefined && run.engine_lease_holder !== ctx.leaseHolder)
+            return;
+        repo.finishUnit({
             runId: ctx.runId,
             unitId: attemptId,
             status: outcome.ok ? "completed" : "failed",
@@ -589,21 +613,22 @@ async function dispatchJournaledAttempt(input) {
             // Harness-native session id (P2): journaled so resume can replay the
             // harness's own context cache (e.g. `codex exec resume <id>`).
             sessionId: outcome.sessionId ?? null,
-            finishedAt: new Date().toISOString(),
-        }));
-    });
-    appendEvent({
-        eventType: "workflow_unit_finished",
-        ref: ctx.workflowRef,
-        metadata: {
-            runId: ctx.runId,
-            stepId: plan.stepId,
-            unitId: attemptId,
-            status: outcome.ok ? "completed" : "failed",
-            ...(outcome.failureReason ? { failureReason: outcome.failureReason } : {}),
-            ...(outcome.tokens !== undefined ? { tokens: outcome.tokens } : {}),
-        },
-    });
+            finishedAt,
+        });
+        insertEventStrict(db, {
+            eventType: "workflow_unit_finished",
+            ts: finishedAt,
+            ref: ctx.workflowRef,
+            metadata: {
+                runId: ctx.runId,
+                stepId: plan.stepId,
+                unitId: attemptId,
+                status: outcome.ok ? "completed" : "failed",
+                ...(outcome.failureReason ? { failureReason: outcome.failureReason } : {}),
+                ...(outcome.tokens !== undefined ? { tokens: outcome.tokens } : {}),
+            },
+        });
+    })));
     // Worktree lifecycle epilogue: a CLEAN worktree (`git status --porcelain`
     // empty) is removed; a DIRTY one is retained and logged — the unit left
     // uncollected work, and its journaled worktree_path says where. Cleanup is
@@ -729,8 +754,8 @@ async function resolveEnvBindings(refs) {
  *   agent → `executeRunner` → `runAgent` (per-harness AgentCommandBuilder)
  *   sdk   → `executeRunner` → `runOpencodeSdk`
  *
- * `inherit` resolves against config: the node/step profile, else
- * `defaults.agent` (sdk when the profile is opencode-sdk), else `defaults.llm`.
+ * Every v3 invocation names a frozen engine; no live profile/default fallback
+ * is consulted during dispatch.
  */
 /**
  * Build the platform-agnostic {@link import("../../integrations/agent/builder-shared.js").AgentDispatchRequest}
@@ -756,15 +781,14 @@ async function resolveEnvBindings(refs) {
 export function buildAgentDispatchRequest(request, prompt) {
     return {
         prompt,
-        ...(request.model ? { model: request.model } : {}),
+        ...(request.invocation.model ? { model: request.invocation.model } : {}),
+        ...(request.invocation.model ? { modelIsExact: true } : {}),
         ...(request.schema ? { schema: request.schema } : {}),
     };
 }
 export const defaultUnitDispatcher = async (request, feedback) => {
-    const { loadConfig } = await import("../../core/config/config.js");
-    const config = loadConfig();
     const prompt = feedback ? `${request.prompt}\n\n${feedback}` : request.prompt;
-    const resolved = await resolveUnitRunner(request, config);
+    const resolved = frozenUnitRunner(request);
     // `env` bindings can only reach a child process. The agent (CLI) runner
     // spawns one per call, and the sdk runner now injects them for real via the
     // env-keyed opencode server registry (sdk-runner.ts module doc, open seam
@@ -794,15 +818,10 @@ export const defaultUnitDispatcher = async (request, feedback) => {
     }
     if (resolved.kind === "llm") {
         const { chatCompletion, LlmCallError } = await import("../../llm/client.js");
-        const { resolveModel } = await import("../../integrations/agent/model-aliases.js");
-        const connection = request.model
-            ? { ...resolved.connection, model: resolveModel(request.model, "llm", undefined, config.modelAliases) }
-            : resolved.connection;
+        const connection = resolved.connection;
         try {
             const text = await chatCompletion(connection, [{ role: "user", content: prompt }], {
-                // null = author declared `timeout: none` — cap at the max signed
-                // 32-bit delay (setTimeout's ceiling, ~24.8 days ≈ unbounded here).
-                timeoutMs: request.timeoutMs === null ? 2 ** 31 - 1 : request.timeoutMs,
+                timeoutMs: request.timeoutMs,
                 ...(request.signal ? { signal: request.signal } : {}),
                 // Native structured output where the connection supports it; the
                 // executor's subset validator still runs downstream either way.
@@ -821,8 +840,16 @@ export const defaultUnitDispatcher = async (request, feedback) => {
         }
     }
     const { executeRunner } = await import("../../integrations/agent/runner-dispatch.js");
-    const profile = request.model ? { ...resolved.profile, model: request.model } : resolved.profile;
-    const result = await executeRunner({ kind: resolved.kind, profile }, prompt, {
+    const profile = request.invocation.model
+        ? { ...resolved.profile, model: request.invocation.model, modelIsExact: true }
+        : resolved.profile;
+    const result = await executeRunner(resolved.kind === "sdk"
+        ? {
+            kind: "sdk",
+            profile,
+            ...(resolved.fallbackConnection ? { fallbackConnection: resolved.fallbackConnection } : {}),
+        }
+        : { kind: "agent", profile }, prompt, {
         stdio: "captured",
         parseOutput: "text",
         timeoutMs: request.timeoutMs,
@@ -863,15 +890,44 @@ export const defaultUnitDispatcher = async (request, feedback) => {
         ...(result.usage ? { usage: result.usage } : {}),
     };
 };
+function collectWorkflowDispatchSensitiveValues(workUnit, env) {
+    const values = new Set(Object.values(env ?? {}));
+    const addCredential = (engine) => {
+        if (!engine)
+            return;
+        if (engine.kind === "llm") {
+            for (const name of engine.credential?.names ?? []) {
+                const value = process.env[name]?.trim();
+                if (value)
+                    values.add(value);
+            }
+            return;
+        }
+        for (const name of engine.envPassthrough) {
+            const value = process.env[name];
+            if (!isEnvPassthroughValueSafeToExpose(name, value) && value)
+                values.add(value);
+        }
+    };
+    addCredential(workUnit.engine);
+    addCredential(workUnit.fallbackEngine);
+    return collectSensitiveValues(values);
+}
+function redactUnitOutcome(outcome, sensitiveValues) {
+    const redacted = redactSensitiveValue(outcome, sensitiveValues);
+    if (outcome.failureReason !== undefined && redacted.failureReason !== outcome.failureReason) {
+        redacted.failureReason = "reported_failure";
+    }
+    return redacted;
+}
 /**
  * Map a typed {@link import("../../llm/client.js").LlmCallErrorCode} into the
  * persisted `AgentFailureReason` taxonomy (agent/spawn.ts) — the ONLY
  * vocabulary `retry.on` accepts and the journal's `failure_reason` column
  * carries. Exhaustive over the code union (typecheck fails on drift):
  *
- *   - `timeout`        → `timeout`         (wall-clock expiry; also covers
- *                                           signal aborts, which chatCompletion
- *                                           folds into its timeout code)
+ *   - `timeout`        → `timeout`         (wall-clock expiry)
+ *   - `aborted`        → `aborted`         (caller/budget cancellation)
  *   - `rate_limited`   → `llm_rate_limit`  (HTTP 429 — the canonical transient)
  *   - `parse_error` / `provider_html_error`
  *                      → `parse_error`     (a response arrived but was not the
@@ -884,6 +940,8 @@ export const defaultUnitDispatcher = async (request, feedback) => {
  */
 export function llmFailureReasonFor(code) {
     switch (code) {
+        case "aborted":
+            return "aborted";
         case "timeout":
             return "timeout";
         case "rate_limited":
@@ -897,58 +955,63 @@ export function llmFailureReasonFor(code) {
     }
 }
 /**
- * Resolve the harness `resultExtractor` for an agent profile, mirroring the
- * platform routing of `getCommandBuilder`: the profile's explicit
- * `commandBuilder` wins, else its name (with the `-headless` builtin-variant
- * suffix stripped, same derivation as BUILTIN_BUILDERS). Unknown/custom
- * platforms resolve to no extractor — raw stdout passes through unchanged.
+ * Resolve the harness `resultExtractor` from the canonical platform frozen
+ * from the named engine. Unknown platforms pass raw stdout through unchanged.
  */
 async function resolveHarnessExtractor(profile) {
     const { getHarness } = await import("../../integrations/harnesses/index.js");
-    const platform = profile.commandBuilder ?? profile.name;
-    const harness = getHarness(platform) ?? getHarness(platform.replace(/-headless$/, ""));
+    const harness = getHarness(profile.platform ?? profile.name);
     return harness?.resultExtractor;
 }
-async function resolveUnitRunner(request, config) {
-    const requested = request.runner;
-    if (requested === "llm") {
-        const connection = request.profile
-            ? config.profiles?.llm?.[request.profile]
-            : await requireDefaultLlm(config, request);
-        if (!connection) {
-            throw new ConfigError(`Workflow unit "${request.unitId}" wants llm profile "${request.profile}", which is not in profiles.llm.`, "LLM_NOT_CONFIGURED");
-        }
-        return { kind: "llm", connection };
-    }
-    const profileName = request.profile ?? config.defaults?.agent;
-    if (profileName) {
-        const { resolveProfileFromConfig } = await import("../../integrations/agent/config.js");
-        const profile = resolveProfileFromConfig(profileName, config);
-        if (!profile) {
-            throw new ConfigError(`Workflow unit "${request.unitId}" wants agent profile "${profileName}", which cannot be resolved. ` +
-                `Define profiles.agent."${profileName}" or set defaults.agent.`, "INVALID_CONFIG_FILE");
-        }
-        const inferred = profile.sdkMode ? "sdk" : "agent";
-        if (requested !== "inherit" && requested !== inferred) {
-            throw new ConfigError(`Workflow unit "${request.unitId}" declares runner "${requested}" but profile "${profileName}" is ${profile.sdkMode ? "an opencode-sdk (sdk) profile" : "a CLI (agent) profile"}.`, "INVALID_CONFIG_FILE");
-        }
-        return { kind: inferred, profile };
+/** Reconstruct the existing RunnerSpec substrate from the frozen allowlist only. */
+function frozenUnitRunner(request) {
+    const snapshot = request.engine;
+    if (snapshot.kind === "llm") {
+        return { kind: "llm", connection: materializeFrozenLlm(snapshot, request.invocation) };
     }
-    if (requested === "inherit") {
-        const connection = await requireDefaultLlm(config, request, /* soft */ true);
-        if (connection)
-            return { kind: "llm", connection };
-    }
-    throw new ConfigError(`Workflow unit "${request.unitId}" has no runnable backend: set defaults.agent or defaults.llm in config.json, ` +
-        `or declare a runner/profile on the unit.`, "INVALID_CONFIG_FILE");
+    const profile = {
+        name: snapshot.name,
+        platform: snapshot.platform,
+        bin: snapshot.bin,
+        args: snapshot.args,
+        stdio: "captured",
+        envPassthrough: snapshot.envPassthrough,
+        parseOutput: "text",
+        ...(snapshot.workspace ? { workspace: snapshot.workspace } : {}),
+        ...(request.invocation?.model ? { model: request.invocation.model } : {}),
+        ...(request.invocation?.model ? { modelIsExact: true } : {}),
+    };
+    if (snapshot.runnerKind === "agent")
+        return { kind: "agent", profile };
+    // The catalog is supplied transitively by the work-list only for hashing; the
+    // SDK runner receives a frozen fallback copied into the request by its caller.
+    const fallback = request.fallbackEngine ? materializeFrozenLlm(request.fallbackEngine, undefined) : undefined;
+    return { kind: "sdk", profile, ...(fallback ? { fallbackConnection: fallback } : {}) };
 }
-async function requireDefaultLlm(config, request, soft = false) {
-    const { getDefaultLlmConfig } = await import("../../core/config/config.js");
-    const connection = getDefaultLlmConfig(config);
-    if (!connection && !soft) {
-        throw new ConfigError(`Workflow unit "${request.unitId}" declares runner "llm" but no default LLM is configured (defaults.llm).`, "LLM_NOT_CONFIGURED");
+function materializeFrozenLlm(snapshot, invocation) {
+    let apiKey;
+    for (const name of snapshot.credential?.names ?? []) {
+        const candidate = process.env[name]?.trim();
+        if (candidate) {
+            apiKey = candidate;
+            break;
+        }
     }
-    return connection ?? undefined;
+    if (snapshot.credential?.required && !apiKey)
+        throw new ConfigError(`Required engine credential ${snapshot.credential.names[0]} is not set.`, "INVALID_CONFIG_FILE");
+    const base = {
+        provider: snapshot.provider,
+        endpoint: snapshot.endpoint,
+        model: invocation?.model ?? snapshot.model,
+        ...(snapshot.temperature !== undefined ? { temperature: snapshot.temperature } : {}),
+        ...(snapshot.maxTokens !== undefined ? { maxTokens: snapshot.maxTokens } : {}),
+        ...(snapshot.supportsJsonSchema !== undefined ? { supportsJsonSchema: snapshot.supportsJsonSchema } : {}),
+        ...(snapshot.extraParams ? { extraParams: snapshot.extraParams } : {}),
+        ...(snapshot.contextLength !== undefined ? { contextLength: snapshot.contextLength } : {}),
+        ...(snapshot.enableThinking !== undefined ? { enableThinking: snapshot.enableThinking } : {}),
+        ...(apiKey ? { apiKey } : {}),
+    };
+    return invocation?.llm ? deepMergeConfig(base, invocation.llm) : base;
 }
 // ── Small helpers ────────────────────────────────────────────────────────────
 /**