akm-cli 0.9.31 → 0.10.26101002-alpha

package/dist/workflows/compile.js

@@ -3,43 +3,26 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * The workflow compiler's front door. `.md` goes through the Markdown grammar
- * (`parser.ts`), `.yml` through the GitHub-shaped YAML grammar
- * (`github-yaml.ts`); both produce a {@link WorkflowPlan} directly.
+ * (`parser.ts`), which produces a {@link WorkflowPlan} directly.
  *
  * {@link checkWorkflowPlan} is the one cross-step pass the grammars do not
- * run: every `steps.<id>` reference must name an earlier step (outputs may
- * name any step), `inputs:` never name a param, and two non-fatal advisories.
+ * run: every `steps.<id>` reference must name an earlier step, `inputs:` never name a param, and two non-fatal advisories.
  */
 import path from "node:path";
-import { parseBuiltinCommandAction } from "../commands/command/builtin-action.js";
-import { PORTABLE_ARGUMENTS_PLACEHOLDER } from "../commands/command/portable-template.js";
-import { parseGithubWorkflowSource, WorkflowSourceFailure } from "./github-yaml.js";
 import { parseWorkflow } from "./parser.js";
 import { formatReference, parseReference } from "./program/expressions.js";
 import { canonicalizeWorkflowWorkingDirectory, WorkflowSourceSemanticError } from "./source-semantics.js";
-export { looksLikeGithubWorkflowSource } from "./github-yaml.js";
 /** Compile by authoritative source extension. */
 export function compileWorkflowSource(source, options) {
     const extension = path.extname(options.path).toLowerCase();
     const title = options.title ?? path.basename(options.path, path.extname(options.path));
-    if (extension === ".yml") {
-        try {
-            return { ok: true, plan: parseGithubWorkflowSource(source, { ...options, title }) };
-        }
-        catch (cause) {
-            if (cause instanceof WorkflowSourceFailure)
-                return { ok: false, errors: [cause.error] };
-            const message = cause instanceof Error ? cause.message : String(cause);
-            return { ok: false, errors: [{ code: "invalid-workflow-source", message, path: options.path, line: 1 }] };
-        }
-    }
     if (extension !== ".md") {
         return {
             ok: false,
             errors: [
                 {
                     code: "unsupported-workflow-extension",
-                    message: `Workflow source ${options.path} must use .md or .yml.`,
+                    message: `Workflow source ${options.path} must use .md.`,
                     path: options.path,
                     line: 1,
                 },
@@ -74,8 +57,7 @@ export function compileWorkflowSource(source, options) {
 }
 /**
  * The display text a step contributes to `show`, search hints, and the run
- * spine: its authored prose, else what its target does. Empty for a route
- * step with no section.
+ * spine: its authored prose, else what its target does.
  */
 export function workflowStepInstructions(step) {
     const spec = step.spec;
@@ -83,25 +65,9 @@ export function workflowStepInstructions(step) {
         return "";
     if (spec.instructions !== undefined)
         return spec.instructions;
-    if (spec.uses === "akm/command") {
-        const action = parseBuiltinCommandAction(spec.with);
-        if (action.kind === "stored") {
-            return `Invoke stored command ${action.ref}${action.arguments === undefined ? "" : " with arguments"}.`;
-        }
-        if (spec.commandMode === "literal")
-            return action.content;
-        return action.content.split(PORTABLE_ARGUMENTS_PLACEHOLDER).join(action.arguments ?? "");
-    }
-    if (spec.uses !== undefined)
-        return `Invoke local target ${spec.uses}.`;
-    return "";
-}
-/** A route step's deterministic one-line description of its branch table. */
-export function routeDescription(route) {
-    const branches = Object.entries(route.when).map(([match, stepId]) => `"${match}" -> ${stepId}`);
-    if (route.defaultStepId !== undefined)
-        branches.push(`default -> ${route.defaultStepId}`);
-    return `Route on ${route.input}: ${branches.join(", ")}.`;
+    // A prose step is `akm/command` with its body as literal content.
+    const content = spec.with?.content;
+    return spec.uses === "akm/command" && typeof content === "string" ? content : "";
 }
 /** Cross-step reference validation plus the non-fatal advisories. Pure. */
 export function checkWorkflowPlan(plan) {
@@ -136,40 +102,18 @@ export function checkWorkflowPlan(plan) {
         const line = step.spec?.source.start ?? 1;
         if (step.spec?.map)
             check(step.spec.map.over, line, `Step "${step.stepId}" map.over`, true);
-        if (step.route)
-            check(step.route.input, line, `Step "${step.stepId}" route.input`, true);
         for (const [index, reference] of (step.spec?.inputs ?? []).entries()) {
             check(reference, line, `Step "${step.stepId}" inputs[${index}]`, false);
         }
         earlierStepIds.add(step.stepId);
     }
-    // Outputs resolve at run completion, so they may name any declared step.
-    for (const [name, declaration] of Object.entries(plan.outputs ?? {})) {
-        const parsed = parseReference(declaration.from);
-        const label = `Output "${name}" from`;
-        if (!parsed.ok)
-            errors.push({ line: 1, message: `${label}: ${parsed.message}` });
-        else if (parsed.expr.kind === "param") {
-            errors.push({
-                line: 1,
-                message: `${label}: "${formatReference(parsed.expr)}" names a param, not a step output — an output projects a ` +
-                    `STEP artifact, never a param. "outputs:" only names step outputs (steps.<id>.output...).`,
-            });
-        }
-        else if (!allStepIds.has(parsed.expr.stepId)) {
-            errors.push({
-                line: 1,
-                message: `${label}: "${formatReference(parsed.expr)}" cannot be resolved — "${parsed.expr.stepId}" is not a step in this workflow.`,
-            });
-        }
-    }
     if (errors.length > 0)
         return { ok: false, errors };
     return { ok: true, warnings: workflowWarnings(plan) };
 }
 /**
  * Advisories that never fail compilation or change the plan:
- *   A. a `params.<name>` reference (in `map.over`/`route.input`) to a param the
+ *   A. a `params.<name>` reference (in `map.over`) to a param the
  *      document's `params:` block does not declare — a likely typo;
  *   B. `gate.max_loops` above 1 on an exec step, which is judged but never
  *      looped (a frozen argv cannot read the judge's feedback).
@@ -205,7 +149,6 @@ function workflowWarnings(plan) {
             });
         };
         scan(step.spec?.map?.over, `Step "${step.stepId}" map.over`);
-        scan(step.route?.input, `Step "${step.stepId}" route.input`);
     }
     return warnings;
 }

package/dist/workflows/exec/child-workflow.js

@@ -8,7 +8,8 @@
  * `with:` bindings against the child's `params:`; (2) derive the deterministic
  * invocation key; (3) publish the child run idempotently; (4) drive it with
  * the same engine as a top-level run unless it is already `blocked`/`failed`;
- * (5) map the child's final status onto this unit's outcome.
+ * (5) map the child's final status onto this unit's outcome; a completed
+ * child returns the output of its last step.
  *
  * `runWorkflowSteps` is reached through a lazy dynamic import: a static one
  * would close the cycle native-executor -> child-workflow -> run-workflow ->
@@ -19,7 +20,6 @@ import { TransientError } from "../../core/errors.js";
 import { withWorkflowRunsRepo } from "../../storage/repositories/workflow-runs-repository.js";
 import { validateWorkflowParams } from "../ir/params.js";
 import { canonicalPlanJson } from "../ir/plan-hash.js";
-import { workflowRunExportedResult } from "../runtime/run-outputs.js";
 import { frozenStepRows } from "../runtime/run-plan.js";
 import { computeChildInvocationKey } from "./child-invocation.js";
 /** The real engine, via a dynamic import (see the module doc). The caller re-reads the child row afterward. */
@@ -27,6 +27,25 @@ async function driveWithRealEngine(options) {
     const { runWorkflowSteps } = await import("./run-workflow.js");
     await runWorkflowSteps(options);
 }
+/**
+ * A completed child's result: the artifact of its last step (a step with no
+ * recorded evidence yields `null`). Read from the persisted step rows, so a
+ * resumed parent sees the same value as the live one.
+ */
+async function childFinalOutput(childRunId) {
+    const steps = await withWorkflowRunsRepo((repo) => repo.getStepsForRun(childRunId));
+    const evidenceJson = steps[steps.length - 1]?.evidence_json;
+    if (!evidenceJson)
+        return null;
+    try {
+        const evidence = JSON.parse(evidenceJson);
+        // Same projection as `steps.<id>.output` (step-work.ts `projectStepOutput`).
+        return Object.hasOwn(evidence, "output") ? evidence.output : evidence;
+    }
+    catch {
+        return null;
+    }
+}
 function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }
@@ -218,7 +237,7 @@ export async function driveChildWorkflowUnit(input) {
             return {
                 unitId: request.unitId,
                 ok: true,
-                result: workflowRunExportedResult(finalRow),
+                result: await childFinalOutput(finalRow.id),
                 childRun: childRunSummary,
             };
         case "failed": {

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

@@ -20,8 +20,6 @@
  *    gate loops journal under `~r<n>` / `~l<n>`.
  *  - `onError: "fail"` fails on any unit failure, `"continue"` lets the gate
  *    decide; `retry: { max, on }` re-dispatches listed failure reasons.
- *  - `isolation: worktree` runs each attempt of an agent/sdk unit in a fresh
- *    detached worktree (removed when clean, kept when dirty); llm units reject it.
  *  - Run `budget` ceilings are consumed per actual dispatch and abort the step
  *    when crossed, regardless of `on_error`.
  */
@@ -52,9 +50,7 @@ import { scheduleUnits } from "./scheduler.js";
 // path. This module dispatches; step-work.ts owns the pure decisions.
 import { clip, computeStepWorkList, reduceEmptyStep, reduceStepOutcomes, stepOutputsFromEvidence, unitOutcomeFromRow, } from "./step-work.js";
 import { dispatchWorkflowExecution, } from "./unit-dispatch.js";
-import { cleanupFrozenScript, frozenScriptCommand, materializeFrozenScript } from "../../tasks/frozen-script.js";
 import { enqueueUnitWrite } from "./unit-writer.js";
-import { assertGitWorkTree, cleanupUnitWorktree, createUnitWorktree } from "./worktree.js";
 /**
  * Per-step dispatch budget against the run's `budget` ceilings, seeded from
  * the journal and consumed per actual dispatch (never by a reused row).
@@ -171,7 +167,7 @@ function openDispatchBudget(ctx, dispatched) {
 }
 /** Resolve the live-at-dispatch prerequisites once, after durable-row reuse is known. */
 async function prepareStepDispatchPrerequisites(input) {
-    const { plan, template, workUnits, ctx, willDispatch, dispatched } = input;
+    const { plan, workUnits, willDispatch, dispatched } = input;
     let env;
     let sensitiveValues;
     const frozenEnvironment = workUnits[0]?.environment;
@@ -195,35 +191,10 @@ async function prepareStepDispatchPrerequisites(input) {
             };
         }
     }
-    let worktreeBase;
-    if (willDispatch && template.isolation === "worktree") {
-        if (template.frozenTarget.kind === "command" && template.frozenTarget.runner.kind === "llm") {
-            return {
-                ok: false,
-                result: 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.`),
-            };
-        }
-        const target = workUnits[0]?.frozenTarget;
-        const frozenCwd = target && "cwdIdentity" in target ? target.cwdIdentity : undefined;
-        if (frozenCwd)
-            assertFrozenDirectoryContained(frozenCwd);
-        const base = frozenCwd?.realRoot ?? ctx.workDir ?? process.cwd();
-        const preflightWorktree = ctx.preflightWorktree ?? assertGitWorkTree;
-        const gitError = preflightWorktree(base);
-        if (gitError !== undefined) {
-            return {
-                ok: false,
-                result: failedStep(dispatched, `Step "${plan.stepId}" cannot use isolation: worktree: ${gitError}`),
-            };
-        }
-        worktreeBase = base;
-    }
     return {
         ok: true,
         ...(env ? { env } : {}),
         ...(sensitiveValues ? { sensitiveValues } : {}),
-        ...(worktreeBase !== undefined ? { worktreeBase } : {}),
     };
 }
 async function executeStepPlanInConnection(plan, ctx) {
@@ -251,32 +222,25 @@ async function executeStepPlanInConnection(plan, ctx) {
     const dispatcher = ctx.dispatcher ?? defaultUnitDispatcher;
     // Load journaled rows first: a completed unit is reused, never re-dispatched.
     const completedRows = indexCompletedRows(await withWorkflowRunsRepo((repo) => repo.getUnitsForStep(ctx.runId, plan.stepId)));
-    // Env resolution and worktree preflight run only when some unit will
-    // dispatch, so a fully-journaled step resumes even if an env asset or git is
-    // gone. Every unit is classified once; the preflight and dispatch share it.
+    // Env resolution runs only when some unit will dispatch, so a fully-journaled
+    // step resumes even if an env asset is gone. Every unit is classified once;
+    // the preflight and dispatch share it.
     const reuseDecisions = workUnits.map((unit) => classifyUnitReuse(unit, completedRows));
     const willDispatch = reuseDecisions.some((decision) => decision.kind === "dispatch");
     const prerequisites = await prepareStepDispatchPrerequisites({
         plan,
-        template,
         workUnits,
-        ctx,
         willDispatch,
         dispatched,
     });
     if (!prerequisites.ok)
         return prerequisites.result;
-    const { env, sensitiveValues, worktreeBase } = prerequisites;
+    const { env, sensitiveValues } = prerequisites;
     // Budget ceilings + lifetime-cap accounting, and the budget-chained abort
     // signal they trip. Extracted verbatim (behavior-identical) — see
     // {@link openDispatchBudget}.
     const { signal, budget, unchainSignal } = openDispatchBudget(ctx, dispatched);
     let outcomes;
-    // Worktree removals started by finished units and awaited below, before this
-    // step reports anything. Cleanup is best-effort, but "the step resolved" must
-    // still mean "its clean worktrees are gone" — only the WAIT moves off the
-    // unit's scheduler slot, not the guarantee.
-    const pendingWorktreeCleanups = [];
     const frozenTargetConcurrency = template.frozenTarget.kind === "command" ? template.frozenTarget.concurrency : undefined;
     try {
         outcomes = await scheduleUnits(workUnits, (workUnit, index) => runUnit({
@@ -284,12 +248,10 @@ async function executeStepPlanInConnection(plan, ctx) {
             workUnit,
             env,
             sensitiveValues,
-            ...(worktreeBase !== undefined ? { worktreeBase } : {}),
             ctx,
             signal,
             dispatcher,
             reuse: reuseDecisions[index],
-            pendingWorktreeCleanups,
             budget,
         }), {
             concurrency: workList.list.concurrency,
@@ -300,9 +262,6 @@ async function executeStepPlanInConnection(plan, ctx) {
     }
     finally {
         unchainSignal?.();
-        // The barrier. `allSettled` because each task already swallowed its own
-        // failure into a warn — nothing here can fail the step.
-        await Promise.allSettled(pendingWorktreeCleanups);
     }
     // Capture live-only diagnostics BEFORE any hard reduction replaces the unit
     // list with a failed-step envelope. Budget/cap and journal-write failures
@@ -358,11 +317,9 @@ async function runUnit(input) {
         prompt,
         frozenTarget: workUnit.frozenTarget,
         ...(workUnit.execContext ? { execContext: workUnit.execContext } : {}),
-        // A NON-isolated exec unit spawns in the engine invocation's working
-        // directory. `dispatchJournaledAttempt` overwrites this with the unit's
-        // fresh worktree when `isolation: worktree` is in play. Only exec units get
-        // it: handing an agent unit a cwd it never had would change harness
-        // behavior, and the agent path already takes its cwd from its profile.
+        // An exec unit spawns in the engine invocation's working directory. Only
+        // exec units get it: handing an agent unit a cwd it never had would change
+        // harness behavior, and the agent path already takes its cwd from its profile.
         ...(workUnit.frozenTarget.kind !== "command" && ctx.workDir !== undefined ? { cwd: ctx.workDir } : {}),
         timeoutMs: workUnit.timeoutMs,
         ...(workUnit.schema ? { schema: workUnit.schema } : {}),
@@ -370,7 +327,7 @@ async function runUnit(input) {
         ...(sensitiveValues ? { sensitiveValues } : {}),
         ...(input.signal ? { signal: input.signal } : {}),
         // F-1: forwarded to exec-unit.ts's childEnv for a
-        // "script"/"shell" unit, and to dispatchWorkflowExecution's
+        // "shell" unit, and to dispatchWorkflowExecution's
         // runExecution eventSource option (unit-dispatch.ts)
         // for a "command" unit — both arms observe it.
         ...(ctx.eventSource !== undefined ? { eventSource: ctx.eventSource } : {}),
@@ -424,8 +381,6 @@ async function runUnit(input) {
             request: { ...request, unitId: attemptId },
             attemptId,
             inputHash,
-            ...(input.worktreeBase !== undefined ? { worktreeBase: input.worktreeBase } : {}),
-            pendingWorktreeCleanups: input.pendingWorktreeCleanups,
         });
         // Attempts use `~r<n>` journal suffixes while durable step evidence remains
         // attached to the content-derived base identity.
@@ -463,30 +418,7 @@ function journaledUnitResultJson(outcome) {
         return null;
     return JSON.stringify(clip(parts.join("\n--- unit output ---\n"), WORKFLOW_UNIT_DIAGNOSTIC_CLIP));
 }
-async function prepareAttemptWorktree(input) {
-    if (input.worktreeBase === undefined)
-        return { ok: true, request: input.request };
-    const created = await createUnitWorktree(input.worktreeBase, input.ctx.runId, input.attemptId, 
-    // A child-workflow target has no commit of its own (its prepared worktree goes unused).
-    input.workUnit.frozenTarget.kind === "child-workflow" ? undefined : input.workUnit.frozenTarget.gitCommitOid);
-    if (created.preservedLeftover !== undefined) {
-        warn(`Workflow unit ${input.attemptId}: a previous attempt left uncollected work in its isolation worktree; ` +
-            `preserved at ${created.preservedLeftover}`);
-    }
-    if (!created.ok) {
-        return {
-            ok: false,
-            outcome: {
-                unitId: input.request.unitId,
-                ok: false,
-                failureReason: "worktree_failed",
-                error: created.error,
-            },
-        };
-    }
-    return { ok: true, request: { ...input.request, cwd: created.path }, worktreePath: created.path };
-}
-async function reserveJournaledDispatch(input, worktreePath, startedAt) {
+async function reserveJournaledDispatch(input, startedAt) {
     const { plan, workUnit, ctx, attemptId, inputHash } = input;
     let durableAttempt;
     await enqueueUnitWrite(async () => {
@@ -503,7 +435,6 @@ async function reserveJournaledDispatch(input, worktreePath, startedAt) {
                 engine: target.kind === "command" ? target.request.engine.name : null,
                 model: target.kind === "command" ? (target.request.model?.resolved ?? null) : null,
                 inputHash,
-                worktreePath: worktreePath ?? null,
                 now: startedAt,
             }).attempt;
         });
@@ -538,37 +469,14 @@ async function finishJournaledDispatch(input) {
         }
     }));
 }
-function queueAttemptWorktreeCleanup(input, worktreePath) {
-    if (worktreePath === undefined || input.worktreeBase === undefined)
-        return;
-    const worktreeBase = input.worktreeBase;
-    input.pendingWorktreeCleanups.push((async () => {
-        try {
-            const cleanup = await cleanupUnitWorktree(worktreeBase, worktreePath);
-            if (cleanup.dirty) {
-                warn(`Workflow unit ${input.attemptId} left uncommitted changes in its isolation worktree; retained at ${worktreePath}`);
-            }
-            else if (!cleanup.removed) {
-                warn(`Workflow unit ${input.attemptId}: could not clean up isolation worktree ${worktreePath}: ${cleanup.error}`);
-            }
-        }
-        catch (err) {
-            warn(`Workflow unit ${input.attemptId}: could not clean up isolation worktree ${worktreePath}: ${message(err)}`);
-        }
-    })());
-}
 /** Journal one dispatch attempt: insert row, events, dispatch, finish row. */
 async function dispatchJournaledAttempt(input) {
     const { workUnit, ctx, dispatcher, attemptId } = input;
-    const prepared = await prepareAttemptWorktree(input);
-    if (!prepared.ok)
-        return prepared.outcome;
-    let { request } = prepared;
-    const { worktreePath } = prepared;
+    let { request } = input;
     const startedAt = new Date().toISOString();
     let durableAttempt;
     try {
-        durableAttempt = await reserveJournaledDispatch(input, worktreePath, startedAt);
+        durableAttempt = await reserveJournaledDispatch(input, startedAt);
     }
     catch (err) {
         // A failed dispatch-row insert means NOTHING dispatched (the row is the
@@ -576,8 +484,6 @@ async function dispatchJournaledAttempt(input) {
         // letting the throw escape into the scheduler, where a swallowed worker
         // error is indistinguishable from "never claimed" and used to be
         // misreported as an aborted, never-dispatched unit.
-        if (worktreePath !== undefined && input.worktreeBase !== undefined)
-            await cleanupUnitWorktree(input.worktreeBase, worktreePath);
         return {
             unitId: request.unitId,
             ok: false,
@@ -632,9 +538,6 @@ async function dispatchJournaledAttempt(input) {
     catch (err) {
         journalError = err;
     }
-    // A clean worktree is removed, a dirty one kept and logged. Cleanup starts
-    // here and is awaited at the step barrier, never holding this scheduler slot.
-    queueAttemptWorktreeCleanup(input, worktreePath);
     // A journal-write failure AFTER a successful dispatch is its own loud
     // failure class: the unit's work ran (and may have succeeded), but its
     // terminal state could not be recorded, so the row may be stuck `running`.
@@ -796,44 +699,6 @@ async function dispatchUnit(request, dispatcher) {
  */
 export const defaultUnitDispatcher = async (request, feedback) => {
     const frozenTarget = request.frozenTarget;
-    if (frozenTarget.kind === "script") {
-        assertFrozenDirectoryContained(frozenTarget.cwdIdentity);
-        const materialized = materializeFrozenScript({
-            sourceRef: frozenTarget.ref,
-            interpreter: frozenTarget.interpreter,
-            extension: frozenTarget.extension,
-            bytesBase64: frozenTarget.bytesBase64,
-            byteLength: frozenTarget.byteLength,
-            sha256: frozenTarget.contentHash,
-        });
-        try {
-            const command = frozenScriptCommand({
-                sourceRef: frozenTarget.ref,
-                interpreter: frozenTarget.interpreter,
-                extension: frozenTarget.extension,
-                bytesBase64: frozenTarget.bytesBase64,
-                byteLength: frozenTarget.byteLength,
-                sha256: frozenTarget.contentHash,
-            }, materialized.file);
-            return await runExecUnit({
-                unitId: request.unitId,
-                exec: {
-                    ...frozenTarget.exec,
-                    command: command,
-                },
-                baseDir: request.cwd ?? frozenTarget.cwdIdentity.realCwd,
-                ...(request.env ? { env: request.env } : {}),
-                ...(request.execContext ? { context: request.execContext } : {}),
-                ...(request.schema ? { hasOutputSchema: true } : {}),
-                timeoutMs: request.timeoutMs,
-                ...(request.signal ? { signal: request.signal } : {}),
-                ...(request.eventSource !== undefined ? { eventSource: request.eventSource } : {}),
-            });
-        }
-        finally {
-            cleanupFrozenScript(materialized);
-        }
-    }
     if (frozenTarget.kind === "shell") {
         if (frozenTarget.cwdIdentity)
             assertFrozenDirectoryContained(frozenTarget.cwdIdentity);