akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/workflows/exec/unit-dispatch.js

@@ -1,34 +1,110 @@
 // 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 { resolveCredentialFromEnv } from "../../integrations/agent/engine-resolution.js";
+import { ConfigError } from "../../core/errors.js";
+import { assertFrozenDirectoryIdentity } from "../../execution/directory-identity.js";
+import { assertFrozenExecutableIdentity } from "../../execution/executable-identity.js";
+import { canonicalResolvedExecutionRequest, decodeResolvedExecutionRequest, } from "../../execution/resolved-request.js";
+import { dispatchLoweredExecutionRequest, lowerResolvedExecutionRequestWithRunner, } from "../../integrations/agent/execution-lowering.js";
+import { getHarness } from "../../integrations/harnesses/index.js";
+/** Lower a persisted v4 common request through its persisted runner only. */
+export function prepareWorkflowExecution(request, prompt = request.prompt) {
+    const target = request.frozenTarget;
+    if (target.cwdIdentity)
+        assertFrozenDirectoryIdentity(target.cwdIdentity);
+    if (target.executable)
+        assertFrozenExecutableIdentity(target.executable, `unit ${request.unitId} executable`);
+    const wire = JSON.parse(canonicalResolvedExecutionRequest(target.request));
+    const command = { ...wire.command, content: prompt };
+    const runtime = {
+        ...wire.runtime,
+        ...(request.cwd !== undefined
+            ? { workspace: request.cwd }
+            : target.cwdIdentity
+                ? { workspace: target.cwdIdentity.realCwd }
+                : {}),
+        ...(request.env !== undefined ? { environment: request.env } : {}),
+    };
+    wire.command = command;
+    wire.runtime = runtime;
+    if (request.systemPrompt !== undefined) {
+        wire.conversation = [{ role: "system", content: request.systemPrompt }];
+    }
+    return lowerResolvedExecutionRequestWithRunner(decodeResolvedExecutionRequest(wire), target.runner);
+}
+function message(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 /**
- * Materialize a frozen llm engine snapshot into a live connection: resolve the
- * credential out of `process.env`, then apply the invocation's model/llm
- * overrides. The ONE definition — the default dispatcher's llm runner and the
- * frozen gate judge both dispatch through it, so credential resolution and
- * connection-field mapping cannot drift between the two llm dispatch paths.
- *
- * The credential read itself is {@link resolveCredentialFromEnv}, shared with
- * the live-config dispatch boundary (`materializeLlmConnection`): a frozen
- * snapshot's `credential` and a resolved engine's `CredentialDescriptor` are the
- * same descriptor, so lookup order and the "required … is not set" failure are
- * one implementation, not two that happen to agree.
+ * Dispatch one frozen workflow engine call through the common prepared/lowered
+ * seam. Credential materialization happens inside the final dispatch only.
  */
-export function materializeFrozenLlm(snapshot, invocation) {
-    const apiKey = resolveCredentialFromEnv(snapshot.credential);
-    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 } : {}),
+export async function dispatchWorkflowExecution(request, feedback) {
+    const prompt = feedback ? `${request.prompt}\n\n${feedback}` : request.prompt;
+    if (request.frozenTarget.kind !== "command") {
+        throw new ConfigError(`unit ${JSON.stringify(request.unitId)} is not a command target.`, "INVALID_CONFIG_FILE");
+    }
+    const lowered = prepareWorkflowExecution(request, prompt);
+    const notices = lowered.notices.length > 0 ? lowered.notices : undefined;
+    if (request.env && Object.keys(request.env).length > 0 && lowered.runner.kind === "llm") {
+        return {
+            ok: false,
+            text: "",
+            failureReason: "env_unsupported",
+            error: `unit ${JSON.stringify(request.unitId)} declares env bindings, which require a child process ` +
+                `(agent or sdk runner) — the "llm" runner cannot inject a per-unit child environment.`,
+            ...(notices ? { notices } : {}),
+        };
+    }
+    if (request.cwd && lowered.runner.kind === "llm") {
+        return {
+            ok: false,
+            text: "",
+            failureReason: "isolation_unsupported",
+            error: `unit ${JSON.stringify(request.unitId)} declares isolation: worktree but resolved to the "llm" runner, ` +
+                `which has no working directory to isolate. Use the agent or sdk runner for isolated units.`,
+            ...(notices ? { notices } : {}),
+        };
+    }
+    let result;
+    try {
+        result = await dispatchLoweredExecutionRequest(lowered, {
+            runOptions: {
+                stdio: "captured",
+                parseOutput: "text",
+                ...(request.signal ? { signal: request.signal } : {}),
+            },
+        });
+    }
+    catch (err) {
+        if (err instanceof ConfigError)
+            throw err;
+        return {
+            ok: false,
+            text: "",
+            failureReason: "dispatch_error",
+            error: message(err),
+            ...(notices ? { notices } : {}),
+        };
+    }
+    let text = result.stdout;
+    let sessionId = result.sessionId;
+    if (lowered.runner.kind === "agent" && result.ok) {
+        const harness = getHarness(lowered.runner.profile.platform ?? lowered.runner.profile.name);
+        if (harness?.resultExtractor) {
+            const extraction = harness.resultExtractor(result);
+            text = extraction.text;
+            if (extraction.sessionId !== undefined)
+                sessionId = extraction.sessionId;
+        }
+    }
+    return {
+        ok: result.ok,
+        text,
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(result.reason ? { failureReason: result.reason } : {}),
+        ...(result.error ? { error: result.error } : {}),
+        ...(result.usage ? { usage: result.usage } : {}),
+        ...(notices ? { notices } : {}),
     };
-    return invocation?.llm ? deepMergeConfig(base, invocation.llm) : base;
 }

package/dist/workflows/exec/unit-writer.js

@@ -16,11 +16,11 @@
  * admission control: every unit write executes strictly in enqueue order.
  *
  * That is the ONLY invariant the chain owns. In particular it does NOT own
- * per-unit insert→finish ordering: `dispatchJournaledAttempt` awaits its insert
+ * per-unit reserve→finish ordering: `dispatchJournaledAttempt` awaits its reservation
  * before it dispatches and only finishes after the dispatch resolves, so a
  * unit's own writes are ordered by program order, not by queue position. The
- * queue could be reordered arbitrarily between units without breaking
- * `finishUnitFromDispatch`'s row-conditional logic.
+ * queue could be reordered arbitrarily between units without breaking the
+ * attempt claim/dispatch CAS.
  *
  * ## Scope of the serialization (issue B)
  *

package/dist/workflows/exec/worktree.js

@@ -225,7 +225,7 @@ async function pathExists(p) {
  * GC sweep — in this process or another one — never collects the tree while the
  * unit is still running in it.
  */
-export async function createUnitWorktree(baseDir, runId, attemptId) {
+export async function createUnitWorktree(baseDir, runId, attemptId, commitOid) {
     // Opportunistic, at most once per process, never awaited — GC must never sit
     // on the dispatch path.
     sweepStaleWorktreesOnce();
@@ -273,7 +273,7 @@ export async function createUnitWorktree(baseDir, runId, attemptId) {
                 prunedRuns.set(runId, new Set([repoKey]));
             await git(baseDir, ["worktree", "prune"]);
         }
-        const added = await git(baseDir, ["worktree", "add", "--detach", dest]);
+        const added = await git(baseDir, ["worktree", "add", "--detach", dest, ...(commitOid ? [commitOid] : [])]);
         if (!added.ok) {
             return {
                 ok: false,

package/dist/workflows/ir/compile.js

@@ -4,10 +4,9 @@
 /**
  * Frontend -> unresolved workflow plan compiler (workflow-format-unification).
  *
- * ONE frontend now: {@link compileWorkflowPlan} lowers a parsed unified
- * `WorkflowDocument` (`../parser.ts`) into the same `WorkflowPlanDraft` shape
- * IR v3 has always consumed — the pre-unification split between a linear
- * markdown compiler and a YAML-program compiler is gone. This pass owns the
+ * ONE frontend now: {@link compileWorkflowPlan} lowers adapter-neutral source
+ * IR into the current unresolved plan draft. Markdown and YAML never reach a
+ * format-specific runtime compiler. This pass owns the
  * semantic rules the parser deliberately does not check:
  *
  *   - every reference string (`map.over` / `route.input` / `inputs[]`) parses
@@ -28,18 +27,33 @@
  */
 import { formatReference, parseReference } from "../program/expressions.js";
 import { projectExecCore } from "../program/schema.js";
+import { sourceStepInstructions, sourceStepProgramUnit, sourceStepRef } from "../source-ir/program.js";
+import { decodeWorkflowSourceIrV1, } from "../source-ir/schema.js";
 /**
- * Compile a parsed unified workflow document into a frozen-plan-ready graph.
+ * Compile source IR into a frozen-plan-ready graph.
  * `title` is the run-level display title (the asset's canonical name — the
  * format carries no authored title). Assumes the document came out of
  * `parseWorkflow` ok (structure already valid).
  */
-export function compileWorkflowPlan(document, title) {
+export function compileWorkflowPlan(input, title, resolvedUnits = new Map()) {
+    const sourceIr = decodeWorkflowSourceIrV1(input);
     const errors = [];
-    const allStepIds = new Set(document.steps.map((s) => s.id));
+    if (sourceIr.jobs.length !== 1) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    line: sourceIr.jobs[1]?.source.start ?? sourceIr.source.start,
+                    message: "Current workflow execution requires exactly one source-IR job.",
+                },
+            ],
+        };
+    }
+    const sourceSteps = sourceIr.jobs[0]?.steps ?? [];
+    const allStepIds = new Set(sourceSteps.map((step) => step.id));
     const earlierStepIds = new Set();
     const steps = [];
-    document.steps.forEach((step) => {
+    sourceSteps.forEach((step, sequenceIndex) => {
         const check = { allStepIds, earlierStepIds, errors };
         if (step.map) {
             checkReferenceField(step.map.over, { ...check, line: step.source.start, label: `Step "${step.id}" map.over` });
@@ -58,24 +72,26 @@ export function compileWorkflowPlan(document, title) {
                 label: `Step "${step.id}" inputs`,
             });
         }
-        steps.push(compileStep(step, defaultsOf(document)));
+        steps.push(compileStep(step, sequenceIndex, sourceIr.defaults, resolvedUnits.get(step.id)));
         earlierStepIds.add(step.id);
     });
     if (errors.length > 0)
         return { ok: false, errors };
-    const paramNames = document.params ? Object.keys(document.params) : [];
+    const paramNames = sourceIr.params ? Object.keys(sourceIr.params) : [];
     return {
         ok: true,
-        warnings: collectWorkflowWarnings(document),
+        warnings: collectWorkflowWarnings(sourceIr),
         plan: {
             title,
             ...(paramNames.length > 0 ? { params: paramNames } : {}),
-            ...(document.params && paramNames.length > 0 ? { paramSchemas: document.params } : {}),
-            ...(document.budget
+            ...(sourceIr.params && paramNames.length > 0
+                ? { paramSchemas: sourceIr.params }
+                : {}),
+            ...(sourceIr.budget
                 ? {
                     budget: {
-                        ...(document.budget.maxTokens !== undefined ? { maxTokens: document.budget.maxTokens } : {}),
-                        ...(document.budget.maxUnits !== undefined ? { maxUnits: document.budget.maxUnits } : {}),
+                        ...(sourceIr.budget.maxTokens !== undefined ? { maxTokens: sourceIr.budget.maxTokens } : {}),
+                        ...(sourceIr.budget.maxUnits !== undefined ? { maxUnits: sourceIr.budget.maxUnits } : {}),
                     },
                 }
                 : {}),
@@ -83,10 +99,7 @@ export function compileWorkflowPlan(document, title) {
         },
     };
 }
-function defaultsOf(document) {
-    return document.defaults;
-}
-function compileStep(step, defaults) {
+function compileStep(step, sequenceIndex, defaults, resolved) {
     const gate = {
         kind: "gate",
         id: `${step.id}.gate`,
@@ -94,31 +107,32 @@ function compileStep(step, defaults) {
         // The body `### gate` rubric is carried through as the ONE criterion string
         // — the judge receives the whole section byte-exact (spec §2.4). A step
         // with no rubric needs no verification (criteria: []).
-        criteria: step.gateRubric?.text.trim() ? [step.gateRubric.text] : [],
+        criteria: step.gate?.rubric?.trim() ? [step.gate.rubric] : [],
         ...(step.gate?.maxLoops !== undefined ? { maxLoops: step.gate.maxLoops } : {}),
     };
     let root;
     if (step.route === undefined) {
-        const instructionsText = step.instructions?.text ?? "";
+        const unit = resolved?.unit ?? sourceStepProgramUnit(step);
+        const instructionsText = resolved?.instructions ?? sourceStepInstructions(step);
         if (step.map) {
             root = {
                 kind: "map",
                 id: `${step.id}.map`,
                 over: step.map.over,
-                template: compileUnit(step.map.unit, `${step.id}.unit`, instructionsText, defaults, step.inputs, step.source),
+                template: compileUnit(unit, `${step.id}.unit`, instructionsText, defaults, step.inputs, sourceStepRef(step)),
                 ...(step.map.concurrency !== undefined ? { concurrency: step.map.concurrency } : {}),
                 reducer: step.map.reducer ?? "collect",
                 source: step.source,
             };
         }
         else {
-            root = compileUnit(step.unit, step.id, instructionsText, defaults, step.inputs, step.instructions?.source);
+            root = compileUnit(unit, step.id, instructionsText, defaults, step.inputs, sourceStepRef(step));
         }
     }
     return {
         stepId: step.id,
         title: step.id,
-        sequenceIndex: step.sequenceIndex,
+        sequenceIndex,
         ...(root ? { root } : {}),
         ...(step.route
             ? {
@@ -144,18 +158,15 @@ function compileUnit(unit, id, instructions, defaults, inputs, source) {
         kind: "unit",
         id,
         instructions,
-        templating: "verbatim",
         ...(inputs && inputs.length > 0 ? { inputs: [...inputs] } : {}),
-        // Shared projection: both env-scope keys are carried CONDITIONALLY (and
-        // `inheritEnv` only when true), so an exec unit that says nothing about its
-        // environment freezes — and therefore hashes — byte-identically to one
-        // authored before these keys existed.
-        ...(unit?.exec ? { exec: projectExecCore(unit.exec) } : {}),
-        ...(unit?.output !== undefined ? { schema: unit.output } : {}),
-        ...(unit?.retry ? { retry: { max: unit.retry.max, on: [...unit.retry.on] } } : {}),
-        onError: unit?.onError ?? defaults?.onError ?? "fail",
-        ...(unit?.env ? { env: [...unit.env] } : {}),
-        ...(unit?.isolation !== undefined ? { isolation: unit.isolation } : {}),
+        // Shared projection: named pass-through scope is carried conditionally;
+        // whole-process environment inheritance is not an authoring surface.
+        ...(unit.exec ? { exec: projectExecCore(unit.exec) } : {}),
+        ...(unit.output !== undefined ? { schema: unit.output } : {}),
+        ...(unit.retry ? { retry: { max: unit.retry.max, on: [...unit.retry.on] } } : {}),
+        onError: unit.onError ?? defaults?.onError ?? "fail",
+        ...(unit.env ? { env: [...unit.env] } : {}),
+        ...(unit.isolation !== undefined ? { isolation: unit.isolation } : {}),
         ...(source ? { source } : {}),
     };
 }
@@ -223,47 +234,50 @@ function checkInputReference(text, index, check) {
  *      only re-run the identical command — and its side effects. The declared
  *      budget is not silently different from what runs; say so.
  */
-export function collectWorkflowWarnings(document) {
+export function collectWorkflowWarnings(input) {
+    const sourceIr = decodeWorkflowSourceIrV1(input);
     const warnings = [];
-    const declaredParams = document.params ? new Set(Object.keys(document.params)) : undefined;
-    for (const step of document.steps) {
-        const maxLoops = step.gate?.maxLoops ?? 1;
-        const execUnit = step.map ? step.map.unit?.exec : step.unit?.exec;
-        if (maxLoops > 1 && execUnit && step.gateRubric?.text.trim()) {
-            warnings.push({
-                line: step.source.start,
-                message: `Step "${step.id}" declares \`gate.max_loops: ${maxLoops}\` on an \`exec\` step — it runs its command ` +
-                    `ONCE. A gate loop re-executes the step so it can address the judge's feedback, and a frozen argv cannot ` +
-                    `read that feedback; looping would only repeat the command's side effects. The gate still evaluates and ` +
-                    `can still fail the step.`,
-            });
-        }
-        if ((step.map || step.route === undefined) && step.output === undefined) {
-            warnings.push({
-                line: step.source.start,
-                message: `Step "${step.id}" declares no \`output:\` schema — its unit results are carried as an untyped ` +
-                    `artifact (permitted). Add an \`output:\` JSON Schema to type and validate the step artifact.`,
-            });
-        }
-        if (declaredParams) {
-            const declaredList = [...declaredParams].join(", ");
-            const scan = (text, label) => {
-                if (!text)
-                    return;
-                const parsed = parseReference(text);
-                if (!parsed.ok || parsed.expr.kind !== "param" || declaredParams.has(parsed.expr.name))
-                    return;
+    const declaredParams = sourceIr.params ? new Set(Object.keys(sourceIr.params)) : undefined;
+    for (const job of sourceIr.jobs) {
+        for (const step of job.steps) {
+            const maxLoops = step.gate?.maxLoops ?? 1;
+            const execUnit = step.exec ?? step.run;
+            if (maxLoops > 1 && execUnit && step.gate?.rubric?.trim()) {
                 warnings.push({
                     line: step.source.start,
-                    message: `${label}: "${formatReference(parsed.expr)}" references a param not declared in \`params:\` ` +
-                        `(declared: ${declaredList || "none"}) — likely a typo. An undeclared param supplied at start still ` +
-                        `resolves at run time.`,
+                    message: `Step "${step.id}" declares \`gate.max_loops: ${maxLoops}\` on an \`exec\` step — it runs its command ` +
+                        `ONCE. A gate loop re-executes the step so it can address the judge's feedback, and a frozen argv cannot ` +
+                        `read that feedback; looping would only repeat the command's side effects. The gate still evaluates and ` +
+                        `can still fail the step.`,
                 });
-            };
-            if (step.map)
-                scan(step.map.over, `Step "${step.id}" map.over`);
-            if (step.route)
-                scan(step.route.input, `Step "${step.id}" route.input`);
+            }
+            if ((step.map || step.route === undefined) && step.output === undefined) {
+                warnings.push({
+                    line: step.source.start,
+                    message: `Step "${step.id}" declares no \`output:\` schema — its unit results are carried as an untyped ` +
+                        `artifact (permitted). Add an \`output:\` JSON Schema to type and validate the step artifact.`,
+                });
+            }
+            if (declaredParams) {
+                const declaredList = [...declaredParams].join(", ");
+                const scan = (text, label) => {
+                    if (!text)
+                        return;
+                    const parsed = parseReference(text);
+                    if (!parsed.ok || parsed.expr.kind !== "param" || declaredParams.has(parsed.expr.name))
+                        return;
+                    warnings.push({
+                        line: step.source.start,
+                        message: `${label}: "${formatReference(parsed.expr)}" references a param not declared in \`params:\` ` +
+                            `(declared: ${declaredList || "none"}) — likely a typo. An undeclared param supplied at start still ` +
+                            `resolves at run time.`,
+                    });
+                };
+                if (step.map)
+                    scan(step.map.over, `Step "${step.id}" map.over`);
+                if (step.route)
+                    scan(step.route.input, `Step "${step.id}" route.input`);
+            }
         }
     }
     return warnings;