akm-cli 0.9.31 → 0.10.261002-beta

package/dist/workflows/freeze/targets/shell.js

@@ -3,7 +3,6 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { captureFrozenDirectoryIdentity } from "../../../execution/directory-identity.js";
 import { freezeEnvironment } from "../environment.js";
-import { gitIdentity } from "../identity.js";
 import { freezeExecSpec, } from "../step-values.js";
 export function directShell(source, baseUnit, context) {
     const authoredExec = baseUnit.exec;
@@ -17,7 +16,6 @@ export function directShell(source, baseUnit, context) {
         contentHash: "",
         exec,
         cwdIdentity,
-        ...gitIdentity(baseUnit, cwdIdentity.realRoot),
     });
     return {
         target,

package/dist/workflows/freeze/task-bindings.js

@@ -4,10 +4,8 @@
 /**
  * Pure freeze-time binding of a composing step's inputs.
  * {@link freezeTaskInputBindings} classifies an authored `with:` against a
- * contract; {@link rebindTaskInputBindings} re-binds already-classified
- * bindings by name against another contract (a task's effective inputs
- * against a child workflow's `params:`) without re-deriving their kind. A
- * reference's resolved value is validated before each attempt (`exec/step-work.ts`).
+ * child workflow's `params:` contract. A reference's resolved value is
+ * validated before each attempt (`exec/step-work.ts`).
  * See docs/architecture/decisions/0008-task-binding-normalization.md.
  */
 import { isRecord } from "../../core/common.js";
@@ -41,30 +39,6 @@ export function freezeTaskInputBindings(input) {
     }
     return finalizeBindings(stepId, targetRef, contract, byName);
 }
-/**
- * Re-bind already-normalized bindings by name against a different contract,
- * keeping each entry's kind (a literal shaped like `{from}` stays a literal).
- * A literal is validated against the new contract; a reference keeps its
- * `from` and takes the new contract's schema; undeclared names are
- * `INPUT_BINDING_INVALID`; missing keys are defaulted or required as usual.
- */
-export function rebindTaskInputBindings(input) {
-    const { stepId, targetRef, contract } = input;
-    const declaredNames = Object.keys(contract).sort();
-    const byName = new Map();
-    for (const binding of input.bindings ?? []) {
-        if (!Object.hasOwn(contract, binding.name)) {
-            throw unknownBindingNameError(stepId, targetRef, binding.name, declaredNames);
-        }
-        const declaration = contract[binding.name];
-        if (!declaration)
-            throw inputBindingInvalid(`Workflow step ${stepId} targets ${targetRef} with.${binding.name} is invalid.`);
-        byName.set(binding.name, binding.kind === "literal"
-            ? binding
-            : Object.freeze({ kind: "reference", name: binding.name, from: binding.from, schema: declaration.schema }));
-    }
-    return finalizeBindings(stepId, targetRef, contract, byName);
-}
 /** Shared tail: apply defaults (or require), schema-validate every literal, and sort by name. */
 function finalizeBindings(stepId, targetRef, contract, byName) {
     for (const [name, declaration] of Object.entries(contract)) {

package/dist/workflows/ir/params.js

@@ -7,13 +7,16 @@
  * every declared param is optional, and the messages are the workflow ones.
  */
 import { UsageError } from "../../core/errors.js";
-import { materializeInputFlags, validateInputs, } from "../../execution/input-contract.js";
+import { applyInputDefaults, materializeInputFlags, validateInputs, } from "../../execution/input-contract.js";
 /** Every declared workflow param as an `InputDeclaration`, `required: false` — workflow params declare nothing required. */
 function contractFromPlan(plan) {
     const names = plan.params ?? Object.keys(plan.paramSchemas ?? {});
     const contract = {};
     for (const name of names) {
-        contract[name] = { schema: plan.paramSchemas?.[name] ?? {}, required: false };
+        const schema = plan.paramSchemas?.[name] ?? {};
+        contract[name] = Object.hasOwn(schema, "default")
+            ? { schema, default: schema.default, required: false }
+            : { schema, required: false };
     }
     return contract;
 }
@@ -45,6 +48,13 @@ export function materializeWorkflowParameterFlags(plan, flags) {
         return {};
     return materializeInputFlags(contractFromPlan(plan), flags, WORKFLOW_PARAMETER_DIAGNOSTICS);
 }
+/**
+ * Fill each declared param the run did not supply with its `default:`. An
+ * explicit value always wins; params without a default stay absent.
+ */
+export function applyWorkflowParamDefaults(plan, params) {
+    return applyInputDefaults(contractFromPlan(plan), params);
+}
 /**
  * Validate a run's supplied params against the plan's frozen param schemas.
  * Returns a flat list of human-readable, path-prefixed error strings (empty =

package/dist/workflows/parser.js

@@ -19,8 +19,8 @@
  *
  *   1. Every level-2 heading must be `## <step-id>` for a DECLARED step,
  *      exactly (fenced code blocks are skipped when scanning for headings).
- *   2. A unit/map step MUST have a section (its instructions, byte-exact to
- *      the next H2 or EOF); a route step MAY. Everything before the first H2
+ *   2. A step MUST have a section (its instructions, byte-exact to
+ *      the next H2 or EOF). Everything before the first H2
  *      is free preamble.
  *   3. Inside a step section, an optional `### gate` sub-heading starts the
  *      step's gate rubric (to the section end) — the format's single
@@ -28,24 +28,24 @@
  *
  * Prose (instructions, gate rubrics, preamble) is NEVER templated or scanned
  * for reference syntax — it reaches the dispatched unit byte-exact. Only
- * three whole-value frontmatter positions carry the closed reference grammar
- * (`program/expressions.ts`): `map.over`, `route.input`, `inputs[]`.
+ * two whole-value frontmatter positions carry the closed reference grammar
+ * (`program/expressions.ts`): `map.over`, `inputs[]`.
  */
 import { LineCounter, parseDocument } from "yaml";
 import { bundleRefToString, parseBundleRef } from "../core/asset/asset-ref.js";
 import { parseFrontmatterBlock } from "../core/asset/frontmatter.js";
 import { parseMarkdownToc } from "../core/asset/markdown.js";
-import { compareCodePoints, isContainedRelativePath, isRecord } from "../core/common.js";
+import { isContainedRelativePath, isRecord } from "../core/common.js";
 import { formatExtraParamsIssue, validateExtraParams } from "../core/extra-params.js";
 import { checkJsonSchemaDefinition, JSON_SCHEMA_SUBSET_SUPPORTED_KEYWORDS } from "../core/json-schema.js";
 import { INPUT_NAME_PATTERN } from "../execution/input-contract.js";
+import { classifyTargetRef } from "../execution/target-ref.js";
 import { WORKFLOW_PLAN_VERSION, } from "./plan.js";
 import { parseReference } from "./program/expressions.js";
 import { jsonBytes, utf8Bytes, WORKFLOW_ENGINE_NAME_PATTERN, WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_CONCURRENCY, WORKFLOW_MAX_ENGINE_NAME_LENGTH, WORKFLOW_MAX_EXTRA_PARAMS_BYTES, WORKFLOW_MAX_INSTRUCTION_BYTES, WORKFLOW_MAX_SCHEMA_BYTES, WORKFLOW_MAX_SOURCE_BYTES, WORKFLOW_MAX_TIMEOUT_MS, } from "./resource-limits.js";
 // ── The Markdown grammar's vocabulary (pinned against schemas/akm-workflow.json) ──
 export const PROGRAM_REDUCERS = ["collect", "vote"];
 export const PROGRAM_ON_ERROR = ["fail", "continue"];
-export const PROGRAM_ISOLATION_KINDS = ["none", "worktree"];
 /** `retry.on`: exactly the persisted `AgentFailureReason` taxonomy (the `satisfies` fails typecheck on drift). */
 const RETRY_REASON_SET = {
     timeout: true,
@@ -86,22 +86,30 @@ const ENVELOPE_KEYS = [
     "status",
     "stale_after",
 ];
-const WORKFLOW_KEYS = ["params", "outputs", "defaults", "budget", "steps"];
+const WORKFLOW_KEYS = ["params", "defaults", "budget", "steps"];
 const TOP_LEVEL_KEYS = [...ENVELOPE_KEYS, ...WORKFLOW_KEYS];
 const DEFAULTS_KEYS = ["engine", "model", "timeout", "on_error", "llm"];
 const BUDGET_KEYS = ["max_tokens", "max_units"];
-const STEP_KEYS = ["id", "unit", "map", "route", "inputs", "output", "gate"];
-const UNIT_KEYS = ["exec", "engine", "model", "llm", "timeout", "retry", "on_error", "output", "env", "isolation"];
+const STEP_KEYS = ["id", "unit", "map", "inputs", "output", "gate"];
+const UNIT_KEYS = [
+    "exec",
+    "workflow",
+    "with",
+    "engine",
+    "model",
+    "llm",
+    "timeout",
+    "retry",
+    "on_error",
+    "output",
+    "env",
+];
 const EXEC_KEYS = ["command", "cwd", "pass_env"];
 /** Unit keys that name an ENGINE dispatch and therefore cannot appear beside `exec:`. */
 const UNIT_ENGINE_KEYS = ["engine", "model", "llm"];
 const MAP_KEYS = ["over", "concurrency", "reducer", "unit"];
-const ROUTE_KEYS = ["input", "when", "default"];
 const RETRY_KEYS = ["max", "on"];
 const GATE_KEYS = ["max_loops"];
-const ROUTE_BRANCH_KEYS = ["match", "step"];
-/** Closed key set of one `outputs:` entry — mirrors `params:`'s bare-schema shape, plus `from`. */
-const OUTPUT_ENTRY_KEYS = ["from", "schema"];
 const ACTOR_STAMP_KEYS = ["by", "at"];
 const TIMEOUT_VALUE = /^(\d+)(ms|s|m)?$/;
 const TIMEOUT_HINT = `Use "<n>ms", "<n>s", "<n>m" (e.g. "10m"), or "none"`;
@@ -206,7 +214,6 @@ export function parseWorkflow(markdown, source) {
     const description = typeof root.description === "string" ? root.description : undefined;
     readTags(ctx, root.tags, frontmatterEndLine);
     const params = parseParams(ctx, root.params);
-    const outputs = parseOutputs(ctx, root.outputs);
     const defaults = parseDefaults(ctx, root.defaults);
     const budget = parseBudget(ctx, root.budget);
     const parsedSteps = parseSteps(ctx, root.steps);
@@ -217,14 +224,12 @@ export function parseWorkflow(markdown, source) {
     const steps = parsedSteps.map((step, index) => {
         const section = sections.get(step.id);
         if (!section) {
-            if (step.route === undefined) {
-                errors.push({
-                    line: step.source.start,
-                    message: `Step "${step.id}" is a unit/map step and must have a "## ${step.id}" body section with its instructions.`,
-                });
-            }
+            errors.push({
+                line: step.source.start,
+                message: `Step "${step.id}" must have a "## ${step.id}" body section with its instructions.`,
+            });
         }
-        else if (step.route === undefined && !section.instructions) {
+        else if (!section.instructions) {
             errors.push({
                 line: section.headingLine,
                 message: `Step "${step.id}" section ("## ${step.id}") is empty. Add the step's instructions below the heading.`,
@@ -244,15 +249,6 @@ export function parseWorkflow(markdown, source) {
             title: step.id,
             sequenceIndex: index,
             spec: stepSpec(step, section),
-            ...(step.route
-                ? {
-                    route: {
-                        input: step.route.input,
-                        when: Object.fromEntries(step.route.branches.map((branch) => [branch.match, branch.stepId])),
-                        ...(step.route.defaultStepId !== undefined ? { defaultStepId: step.route.defaultStepId } : {}),
-                    },
-                }
-                : {}),
             ...(step.output !== undefined ? { outputSchema: step.output } : {}),
             gate: {
                 kind: "gate",
@@ -272,7 +268,6 @@ export function parseWorkflow(markdown, source) {
         irVersion: WORKFLOW_PLAN_VERSION,
         title: source.title ?? path.replace(/^.*[\\/]/, "").replace(/\.[^.]*$/, ""),
         ...(params && paramNames.length > 0 ? { params: paramNames, paramSchemas: params } : {}),
-        ...(outputs ? { outputs: sortedByName(outputs) } : {}),
         ...(budget ? { budget } : {}),
         ...(defaults ? { defaults } : {}),
         ...(description ? { description } : {}),
@@ -284,14 +279,18 @@ export function parseWorkflow(markdown, source) {
 /** The authored step as the plan carries it. A prose step is inline `akm/command` literal content. */
 function stepSpec(step, section) {
     const prose = section?.instructions?.text;
-    if (step.route)
-        return { ...(prose?.trim() ? { instructions: prose } : {}), source: step.source };
     const dispatchUnit = step.map?.unit ?? step.unit;
-    const { exec, source: _unitSource, ...unit } = dispatchUnit ?? { source: step.source };
+    const { exec, workflow, with: childWith, source: _unitSource, ...unit } = dispatchUnit ?? { source: step.source };
     return {
-        ...(exec
-            ? { exec: { ...exec }, ...(prose?.trim() ? { instructions: prose } : {}) }
-            : { uses: "akm/command", commandMode: "literal", with: { content: prose ?? "" } }),
+        ...(workflow
+            ? {
+                workflow,
+                ...(childWith ? { with: childWith } : {}),
+                ...(prose?.trim() ? { instructions: prose } : {}),
+            }
+            : exec
+                ? { exec: { ...exec }, ...(prose?.trim() ? { instructions: prose } : {}) }
+                : { uses: "akm/command", with: { content: prose ?? "" } }),
         ...(Object.keys(unit).length > 0 ? { unit } : {}),
         ...(step.map
             ? {
@@ -306,12 +305,6 @@ function stepSpec(step, section) {
         source: step.source,
     };
 }
-/** `outputs:` in canonical wire order (code-point ascending by name). */
-function sortedByName(entries) {
-    return Object.fromEntries(Object.keys(entries)
-        .sort(compareCodePoints)
-        .map((name) => [name, entries[name]]));
-}
 /** `xrefs` entries must be canonical asset refs. */
 function checkCanonicalXrefs(value, line, errors) {
     if (!Array.isArray(value))
@@ -521,71 +514,6 @@ function parseParams(ctx, raw) {
     }
     return Object.keys(params).length > 0 ? params : undefined;
 }
-/**
- * `outputs:`: named, optionally schema-validated projections
- * of step artifacts, exported when the run completes. Symmetrical with
- * `parseParams` above — same authoring surface, same name grammar,
- * same schema-subset validator, same per-schema byte bound — but each entry
- * is a STRUCTURED `{from, schema?}` mapping rather than a bare JSON Schema.
- *
- * `from` is validated for GRAMMAR only here: it must parse and it must be a
- * `steps.<id>.output(.<seg>)*` reference (never `params.<name>` — an output
- * projects a step artifact, never a param, B-07). Whether the named step is
- * actually DECLARED in this document is a semantic, cross-step check left to
- * `compile.ts`'s `checkWorkflowPlan`, mirroring how `inputs[]` /
- * `map.over` / `route.input` already split "syntax here, semantics there".
- */
-function parseOutputs(ctx, raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!isRecord(raw)) {
-        ctx.err(["outputs"], `"outputs" must be a mapping of output name to { from, schema? } (e.g. report: { from: steps.summarize.output }).`);
-        return undefined;
-    }
-    const outputs = {};
-    for (const [outputName, value] of Object.entries(raw)) {
-        const path = ["outputs", outputName];
-        if (!PROGRAM_PARAM_NAME_PATTERN.test(outputName)) {
-            ctx.err(path, `Output name "${outputName}" is invalid. Use letters, digits, and underscores, starting with a letter or ` +
-                `underscore, so "steps.<child>.output.${outputName}" can address it.`);
-            continue;
-        }
-        if (!isRecord(value)) {
-            ctx.err(path, `Output "${outputName}" must be a mapping with "from" (and optional "schema").`);
-            continue;
-        }
-        checkUnknownKeys(ctx, value, path, OUTPUT_ENTRY_KEYS, `output "${outputName}"`);
-        if (typeof value.from !== "string" || value.from.trim() === "") {
-            ctx.err([...path, "from"], `Output "${outputName}" must declare "from": a steps.<id>.output(.<seg>)* reference.`);
-            continue;
-        }
-        const parsedFrom = parseReference(value.from);
-        if (!parsedFrom.ok) {
-            ctx.err([...path, "from"], `Output "${outputName}" "from": ${parsedFrom.message}`);
-            continue;
-        }
-        if (parsedFrom.expr.kind !== "stepOutput") {
-            ctx.err([...path, "from"], `Output "${outputName}" "from" must reference a step output (steps.<id>.output...), not a param — an ` +
-                `output projects a step artifact, never a param (got "${value.from}").`);
-            continue;
-        }
-        const entry = { from: value.from };
-        if (value.schema !== undefined) {
-            if (!isRecord(value.schema)) {
-                ctx.err([...path, "schema"], `Output "${outputName}" "schema" must be a JSON Schema object.`);
-            }
-            else {
-                if (jsonBytes(value.schema) > WORKFLOW_MAX_SCHEMA_BYTES) {
-                    ctx.err([...path, "schema"], `Output "${outputName}" schema exceeds the 256 KiB resource limit.`);
-                }
-                checkSchemaDefinition(ctx, value.schema, [...path, "schema"], `Output "${outputName}" schema`);
-                entry.schema = value.schema;
-            }
-        }
-        outputs[outputName] = entry;
-    }
-    return Object.keys(outputs).length > 0 ? outputs : undefined;
-}
 function parseDefaults(ctx, raw) {
     if (raw === undefined)
         return undefined;
@@ -651,17 +579,8 @@ function parseSteps(ctx, raw) {
         ctx.err(["steps"], `"steps" is required and must be a list with at least one step.`);
         return [];
     }
-    // First pass: collect ids so route targets can be checked against ALL steps
-    // (including ones that fail their own validation).
-    const idIndex = new Map();
-    raw.forEach((rawStep, index) => {
-        if (isRecord(rawStep) && typeof rawStep.id === "string" && !idIndex.has(rawStep.id)) {
-            idIndex.set(rawStep.id, index);
-        }
-    });
     const steps = [];
     const seenIds = new Map();
-    const routeChecks = [];
     raw.forEach((rawStep, index) => {
         const path = ["steps", index];
         if (!isRecord(rawStep)) {
@@ -689,27 +608,13 @@ function parseSteps(ctx, raw) {
                 seenIds.set(id, index);
             }
         }
-        const declaredKinds = ["map", "route"].filter((kind) => rawStep[kind] !== undefined);
-        if (declaredKinds.length > 1) {
-            ctx.err(path, `${label} must declare at most one of "map" or "route" (found ${declaredKinds.join(" + ")}).`);
-        }
-        const isRoute = rawStep.route !== undefined;
         const isMapStep = rawStep.map !== undefined;
-        if (isRoute && rawStep.unit !== undefined) {
-            ctx.err(path, `${label} is a route step and cannot also declare "unit" (route steps dispatch no unit).`);
-        }
         if (isMapStep && rawStep.unit !== undefined) {
             ctx.err(path, `${label} is a map step; the per-item dispatch-override bag belongs at "map.unit", not top-level "unit".`);
         }
-        if (isRoute && rawStep.inputs !== undefined) {
-            ctx.err(path, `${label} is a route step and cannot declare "inputs" (route steps dispatch no unit).`);
-        }
-        const unit = rawStep.unit !== undefined && !isRoute && !isMapStep
-            ? parseUnit(ctx, rawStep.unit, [...path, "unit"], label)
-            : undefined;
+        const unit = rawStep.unit !== undefined && !isMapStep ? parseUnit(ctx, rawStep.unit, [...path, "unit"], label) : undefined;
         const map = isMapStep ? parseMap(ctx, rawStep.map, [...path, "map"], label) : undefined;
-        const route = isRoute ? parseRoute(ctx, rawStep.route, [...path, "route"], label, index, routeChecks) : undefined;
-        const inputs = !isRoute ? parseInputs(ctx, rawStep.inputs, [...path, "inputs"], label) : undefined;
+        const inputs = parseInputs(ctx, rawStep.inputs, [...path, "inputs"], label);
         const output = parseSchemaObject(ctx, rawStep.output, [...path, "output"], `${label} "output"`);
         const gate = rawStep.gate !== undefined ? parseGate(ctx, rawStep.gate, [...path, "gate"], label) : undefined;
         const step = { id, source: ctx.refAt(path) };
@@ -717,8 +622,6 @@ function parseSteps(ctx, raw) {
             step.unit = unit;
         if (map)
             step.map = map;
-        if (route)
-            step.route = route;
         if (inputs)
             step.inputs = inputs;
         if (output !== undefined)
@@ -727,31 +630,12 @@ function parseSteps(ctx, raw) {
             step.gate = gate;
         steps.push(step);
     });
-    // Route target post-pass: targets exist, come after the routing step, and
-    // never point back at it.
-    for (const check of routeChecks) {
-        const targets = [...check.branches.map((b) => ({ stepId: b.stepId, line: b.line }))];
-        if (check.defaultTarget)
-            targets.push(check.defaultTarget);
-        for (const target of targets) {
-            const targetIndex = idIndex.get(target.stepId);
-            if (targetIndex === undefined) {
-                ctx.errAtLine(target.line, `${check.stepLabel} routes to unknown step "${target.stepId}". Route targets must name a step id in this workflow.`);
-            }
-            else if (targetIndex === check.stepIndex) {
-                ctx.errAtLine(target.line, `${check.stepLabel} must not route to itself.`);
-            }
-            else if (targetIndex < check.stepIndex) {
-                ctx.errAtLine(target.line, `${check.stepLabel} routes backward to "${target.stepId}" (step ${targetIndex + 1}). Route targets must come after the routing step.`);
-            }
-        }
-    }
     return steps;
 }
 // ---------------------------------------------------------------------------
 // Step blocks
 // ---------------------------------------------------------------------------
-function parseUnit(ctx, raw, path, stepLabel) {
+function parseUnit(ctx, raw, path, stepLabel, allowWorkflow = true) {
     if (!isRecord(raw)) {
         ctx.err(path, `${stepLabel} "unit" must be a mapping (a dispatch-override bag).`);
         return undefined;
@@ -772,6 +656,32 @@ function parseUnit(ctx, raw, path, stepLabel) {
                 `reaches an engine, so "${key}" would have no effect — remove one of the two.`);
         }
     }
+    if (raw.workflow !== undefined) {
+        const workflow = parseChildWorkflowRef(ctx, raw.workflow, [...path, "workflow"], stepLabel, allowWorkflow);
+        if (workflow !== undefined)
+            unit.workflow = workflow;
+        if (raw.exec !== undefined) {
+            ctx.err([...path, "workflow"], `${stepLabel} "unit" declares both "exec" and "workflow" — a unit runs one or the other.`);
+        }
+        // A workflow unit starts a child run: it reaches no engine and the child carries its own environment.
+        for (const key of [...UNIT_ENGINE_KEYS, "env"]) {
+            if (raw[key] === undefined)
+                continue;
+            ctx.err([...path, key], `${stepLabel} "unit" declares both "workflow" and "${key}". A workflow unit starts a child run and never ` +
+                `reaches an engine or an environment of its own, so "${key}" would have no effect — set it in the child workflow.`);
+        }
+    }
+    if (raw.with !== undefined) {
+        if (raw.workflow === undefined) {
+            ctx.err([...path, "with"], `${stepLabel} "unit" declares "with" without "workflow" — it binds a child workflow's params.`);
+        }
+        else if (!isRecord(raw.with)) {
+            ctx.err([...path, "with"], `${stepLabel} "with" must be a mapping of the child's param name to a literal value or { from: <reference> }.`);
+        }
+        else {
+            unit.with = raw.with;
+        }
+    }
     if (raw.engine !== undefined) {
         const engine = parseEngineName(ctx, raw.engine, [...path, "engine"], `${stepLabel} "engine"`);
         if (engine !== undefined)
@@ -815,11 +725,24 @@ function parseUnit(ctx, raw, path, stepLabel) {
             ctx.err([...path, "env"], `${stepLabel} "env" must be a list of non-empty env asset refs.`);
         }
     }
-    const isolation = parseEnumField(ctx, raw.isolation, [...path, "isolation"], `${stepLabel} "isolation"`, PROGRAM_ISOLATION_KINDS);
-    if (isolation !== undefined)
-        unit.isolation = isolation;
     return unit;
 }
+/** `unit.workflow` (Experimental): the canonical ref of a child workflow, `workflows/<name>` or `<bundle>//workflows/<name>`. */
+function parseChildWorkflowRef(ctx, raw, path, stepLabel, allowed) {
+    if (!allowed) {
+        ctx.err(path, `${stepLabel} "workflow" is not supported inside "map.unit": a child workflow runs once per step.`);
+        return undefined;
+    }
+    try {
+        if (typeof raw === "string" && classifyTargetRef(raw).kind === "workflow")
+            return raw;
+    }
+    catch {
+        // falls through to the message below
+    }
+    ctx.err(path, `${stepLabel} "workflow" must be a canonical workflow ref such as "workflows/<name>".`);
+    return undefined;
+}
 /**
  * Parse `unit.exec` — the argv-array shell-command surface.
  *
@@ -952,7 +875,7 @@ function parseMap(ctx, raw, path, stepLabel) {
         }
     }
     const reducer = parseEnumField(ctx, raw.reducer, [...path, "reducer"], `${stepLabel} "reducer"`, PROGRAM_REDUCERS);
-    const unit = raw.unit !== undefined ? parseUnit(ctx, raw.unit, [...path, "unit"], stepLabel) : undefined;
+    const unit = raw.unit !== undefined ? parseUnit(ctx, raw.unit, [...path, "unit"], stepLabel, false) : undefined;
     const map = { over };
     if (concurrency !== undefined)
         map.concurrency = concurrency;
@@ -962,79 +885,6 @@ function parseMap(ctx, raw, path, stepLabel) {
         map.unit = unit;
     return map;
 }
-function parseRoute(ctx, raw, path, stepLabel, stepIndex, routeChecks) {
-    if (!isRecord(raw)) {
-        ctx.err(path, `${stepLabel} "route" must be a mapping with "input" and "when" keys.`);
-        return undefined;
-    }
-    checkUnknownKeys(ctx, raw, path, ROUTE_KEYS, `${stepLabel} "route"`);
-    let input = "";
-    if (typeof raw.input === "string" && raw.input.trim() !== "") {
-        input = raw.input.trim();
-        checkReferenceSyntax(ctx, input, [...path, "input"], `${stepLabel} "route.input"`);
-    }
-    else {
-        ctx.err([...path, "input"], `${stepLabel} "route" requires "input": a reference naming the value to route on.`);
-    }
-    const check = { stepIndex, stepLabel, branches: [] };
-    const whenPath = [...path, "when"];
-    if (!Array.isArray(raw.when) || raw.when.length === 0) {
-        ctx.err(whenPath, `${stepLabel} "route" requires "when": a non-empty list of { match, step } branches (e.g. when: [{ match: pass, step: ship }]).`);
-    }
-    else {
-        const seenMatches = new Map();
-        raw.when.forEach((branch, i) => {
-            const branchPath = [...whenPath, i];
-            if (!isRecord(branch)) {
-                ctx.err(branchPath, `${stepLabel} "when[${i}]" must be a mapping: { match, step }.`);
-                return;
-            }
-            checkUnknownKeys(ctx, branch, branchPath, ROUTE_BRANCH_KEYS, `${stepLabel} "when[${i}]"`);
-            const matchLine = ctx.lineAt([...branchPath, "match"]);
-            if (branch.match === undefined ||
-                (typeof branch.match !== "string" && typeof branch.match !== "number" && typeof branch.match !== "boolean")) {
-                ctx.err([...branchPath, "match"], `${stepLabel} "when[${i}].match" must be a string, number, or boolean.`);
-                return;
-            }
-            const match = String(branch.match);
-            // The frozen-plan decoder requires every `when` key to be non-empty, so an
-            // empty match parsed and linted clean and then failed the run with an
-            // unlocated "Invalid frozen workflow plan". Reject it here, at the line.
-            if (match === "") {
-                ctx.errAtLine(matchLine, `${stepLabel} "when[${i}].match" must not be empty.`);
-                return;
-            }
-            if (typeof branch.step !== "string" || branch.step.trim() === "") {
-                ctx.err([...branchPath, "step"], `${stepLabel} "when[${i}].step" must be a step id string.`);
-                return;
-            }
-            const stepId = branch.step.trim();
-            const stepLine = ctx.lineAt([...branchPath, "step"]);
-            const firstLine = seenMatches.get(match);
-            if (firstLine !== undefined) {
-                ctx.errAtLine(matchLine, `${stepLabel} has a duplicate "when" match "${match}" (first declared on line ${firstLine}). Matches must be unique.`);
-                return;
-            }
-            seenMatches.set(match, matchLine);
-            check.branches.push({ match, stepId, line: stepLine });
-        });
-    }
-    let defaultStepId;
-    if (raw.default !== undefined) {
-        if (typeof raw.default === "string" && raw.default.trim() !== "") {
-            defaultStepId = raw.default.trim();
-            check.defaultTarget = { stepId: defaultStepId, line: ctx.lineAt([...path, "default"]) };
-        }
-        else {
-            ctx.err([...path, "default"], `${stepLabel} "route.default" must be a step id string.`);
-        }
-    }
-    routeChecks.push(check);
-    const route = { input, branches: check.branches.map(({ match, stepId }) => ({ match, stepId })) };
-    if (defaultStepId !== undefined)
-        route.defaultStepId = defaultStepId;
-    return route;
-}
 function parseInputs(ctx, raw, path, stepLabel) {
     if (raw === undefined)
         return undefined;

package/dist/workflows/plan.js

@@ -1,5 +1,5 @@
 // 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/.
-/** Stored plans record this; earlier releases wrote 4 and 5, which still decode. */
+/** Stored plans record this; 0.9.15 and 0.9.16 wrote 5, which still decodes (the 0.9.15 floor, #1091). */
 export const WORKFLOW_PLAN_VERSION = 6;

package/dist/workflows/renderer.js

@@ -2,15 +2,15 @@
 // 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/.
 /**
- * Show renderer for peer workflow sources. `.md` and `.yml` both compile
- * through `compileWorkflowSource` into a plan, which is projected down to the
- * public `ShowResponse` shape, including a compact per-step orchestration
- * summary (engine/model or an exec unit's argv, `map.over` reference, route
- * table) when the step declares one.
+ * Show renderer for workflow sources. A `.md` source compiles through
+ * `compileWorkflowSource` into a plan, which is projected down to the public
+ * `ShowResponse` shape, including a compact per-step orchestration summary
+ * (engine/model or an exec unit's argv, `map.over` reference) when the step
+ * declares one.
  */
 import { displayRef } from "../core/asset/resolve-ref.js";
 import { UsageError } from "../core/errors.js";
-import { compileWorkflowSource, routeDescription, workflowStepInstructions } from "./compile.js";
+import { compileWorkflowSource, workflowStepInstructions } from "./compile.js";
 function shellQuote(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -45,7 +45,7 @@ function projectParameters(plan) {
  * Compact, show-facing orchestration summary for one step. Field mapping:
  * `engine`/`model`/`timeoutMs` merge the run-level `defaults` exactly like the
  * compiler does (per-unit override wins), `fanOut.over` carries the raw
- * reference string, and `route` carries the explicit input + branch table.
+ * reference string.
  * Returns undefined when the step declares nothing worth summarizing.
  *
  * ## exec units
@@ -54,8 +54,8 @@ function projectParameters(plan) {
  * `engine`/`model`/`llm` alongside `exec:`. Merging `defaults.engine` into its
  * summary would make `show` state something untrue about what will run, so the
  * two fields are suppressed and the argv is projected instead, under `exec`
- * (field presence carries the dispatch kind, exactly like `fanOut`/`route`
- * carry the step kind).
+ * (field presence carries the dispatch kind, exactly like `fanOut`
+ * carries the step kind).
  *
  * `timeoutMs` still merges the defaults: an exec unit really does inherit
  * `defaults.timeout`, so that number stays true for it.
@@ -94,15 +94,6 @@ function summarizeStepOrchestration(step, defaults) {
             : {}),
         ...(unit?.output !== undefined || step.outputSchema !== undefined ? { hasSchema: true } : {}),
         ...(unit?.env !== undefined ? { env: [...unit.env] } : {}),
-        ...(step.route
-            ? {
-                route: {
-                    input: step.route.input,
-                    branches: Object.entries(step.route.when).map(([match, stepId]) => ({ match, stepId })),
-                    ...(step.route.defaultStepId !== undefined ? { defaultStepId: step.route.defaultStepId } : {}),
-                },
-            }
-            : {}),
     };
     return Object.keys(summary).length > 0 ? summary : undefined;
 }
@@ -113,7 +104,7 @@ function projectStepDefinitions(plan) {
         return {
             id: step.stepId,
             title: step.stepId,
-            instructions: instructions || (step.route ? routeDescription(step.route) : ""),
+            instructions,
             ...(step.gate.criteria.length > 0 ? { completionCriteria: [...step.gate.criteria] } : {}),
             sequenceIndex,
             ...(orchestration ? { orchestration } : {}),