akm-cli 0.9.31 → 0.10.26101002-alpha

package/dist/workflows/freeze/freeze.js

@@ -17,15 +17,10 @@ import { checkWorkflowPlan } from "../compile.js";
 import { defaultMapConcurrency, workflowMaxConcurrency } from "../concurrency-policy.js";
 import { canonicalJson } from "../ir/plan-hash.js";
 import { WORKFLOW_PLAN_VERSION, } from "../plan.js";
-import { classifyWorkflowStepUses } from "../source-semantics.js";
-import { assertChildOutputReferences } from "./child-output-references.js";
-import { qualifyRef } from "./environment.js";
 import { baseUnitOf } from "./step-values.js";
 import { childWorkflowDispatch } from "./targets/child-workflow.js";
 import { commandDispatch, commandResult } from "./targets/command.js";
-import { directScript } from "./targets/script.js";
 import { directShell } from "./targets/shell.js";
-import { taskDispatch } from "./targets/task.js";
 /** Resolve and freeze one workflow (and, recursively, every child it composes). */
 export async function freezeWorkflow(asset, config, refPath = [asset.ref]) {
     const compiled = asset.plan;
@@ -45,12 +40,9 @@ export async function freezeWorkflow(asset, config, refPath = [asset.ref]) {
     for (const step of compiled.steps) {
         const { spec, ...frozenStep } = step;
         const source = { ...(spec ?? { source: { path: asset.path, start: 1, end: 1 } }), id: step.stepId };
-        let root;
-        if (!step.route) {
-            const resolved = await resolveStep(source, context);
-            engineAnnouncement ??= resolved.engineAnnouncement;
-            root = frozenRoot(step.stepId, source, resolved, compiled, config);
-        }
+        const resolved = await resolveStep(source, context);
+        engineAnnouncement ??= resolved.engineAnnouncement;
+        const root = frozenRoot(step.stepId, source, resolved, compiled, config);
         let frozenJudge = null;
         if (step.gate.criteria.length > 0) {
             const judge = resolveJudge(source, step.gate.criteria[0] ?? "", context);
@@ -64,16 +56,14 @@ export async function freezeWorkflow(asset, config, refPath = [asset.ref]) {
                     "for `akm workflow resume` once it is reached.");
             }
         }
-        steps.push({ ...frozenStep, ...(root ? { root } : {}), gate: { ...step.gate, frozenJudge } });
+        steps.push({ ...frozenStep, root, gate: { ...step.gate, frozenJudge } });
     }
-    assertChildOutputReferences(steps);
     const plan = {
         irVersion: WORKFLOW_PLAN_VERSION,
         title: asset.title,
         ...(compiled.params ? { params: compiled.params } : {}),
         ...(compiled.paramSchemas ? { paramSchemas: compiled.paramSchemas } : {}),
         ...(compiled.budget ? { budget: compiled.budget } : {}),
-        ...(compiled.outputs ? { outputs: compiled.outputs } : {}),
         execution: { maxConcurrency: workflowMaxConcurrency(config.workflow?.maxConcurrency) },
         sourceHash: asset.sourceHash,
         steps,
@@ -84,33 +74,11 @@ async function resolveStep(source, context) {
     const baseUnit = baseUnitOf(source);
     if (source.exec)
         return directShell(source, baseUnit, context);
-    if (!source.uses)
-        throw new Error(`workflow step ${source.id} has neither exec nor uses`);
-    const target = classifyWorkflowStepUses(source.uses);
-    if (target.kind === "task")
-        return taskDispatch(source, baseUnit, target.ref, context);
-    if (target.kind === "workflow") {
-        return childWorkflowDispatch({
-            source,
-            baseUnit,
-            childRefInput: target.ref,
-            context,
-            via: "direct",
-            authoredInputs: { kind: "with", value: source.with },
-        });
-    }
-    // `commands/<ref>` and `scripts/<ref>` are not binding surfaces; `akm/command`'s
-    // `with:` is its own argument bag.
-    if (target.kind !== "builtin-command" && source.with !== undefined) {
-        const family = target.kind === "command" ? "commands" : "scripts";
-        throw new UsageError(`Workflow step ${source.id} cannot pass with: to ${family} target ${target.ref}; a ${target.kind} ref is not a binding surface.`, "COMPOSITION_INVALID");
+    if (source.workflow) {
+        return childWorkflowDispatch({ source, baseUnit, childRefInput: source.workflow, context });
     }
-    if (target.kind === "script")
-        return directScript(source, baseUnit, target.ref, context);
-    const action = target.kind === "builtin-command"
-        ? source.with
-        : { ref: qualifyRef(target.ref, "commands", context.asset, context.config) };
-    return commandDispatch(source, baseUnit, action, context);
+    // A prose step: its body is the `akm/command` literal content (`parser.ts` `stepSpec`).
+    return commandDispatch(source, baseUnit, source.with, context);
 }
 /** The gate judge's frozen command target, or undefined when no engine is available and none is configured. */
 function resolveJudge(source, rubric, context) {
@@ -153,7 +121,6 @@ function frozenRoot(stepId, source, resolved, plan, config) {
         ...(unit.retry ? { retry: { max: unit.retry.max, on: [...unit.retry.on] } } : {}),
         onError: unit.onError ?? plan.defaults?.onError ?? "fail",
         ...(unit.env ? { env: [...unit.env] } : {}),
-        isolation: unit.isolation ?? "none",
         source: { ...source.source },
         frozenTarget: target,
         environment: [...resolved.environment],

package/dist/workflows/freeze/targets/child-workflow.js

@@ -1,48 +1,31 @@
-// 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/.
 /**
- * The one child-workflow resolver. Both composition forms lower here: a direct
- * `uses: workflows/<ref>` step (`via: "direct"`) and a `uses: tasks/<ref>`
- * step whose task targets a workflow (`via: "task"`). It resolves the child,
- * refuses a composition cycle, freezes the child completely through the
- * injected `ResolutionContext.freezeChild`, binds the step's inputs against
- * the child's `params:`, and embeds the frozen child plan in the target.
+ * The one child-workflow resolver (`unit: { workflow: <ref> }`, Experimental).
+ * It resolves the child, refuses a composition cycle, freezes the child
+ * completely through the injected `ResolutionContext.freezeChild`, binds the
+ * step's `with:` against the child's `params:`, and embeds the frozen child
+ * plan in the target.
  */
 import { createHash } from "node:crypto";
 import { parseBundleRef } from "../../../core/asset/asset-ref.js";
 import { UsageError } from "../../../core/errors.js";
-import { warn } from "../../../core/warn.js";
 import { workflowParamContract } from "../../ir/params.js";
 import { canonicalJson, canonicalPlanJson } from "../../ir/plan-hash.js";
 import { loadWorkflowAsset } from "../../runtime/workflow-asset-loader.js";
 import { resolveOwnedAsset } from "../environment.js";
 import { declaredParamNames, earlierStepIds, } from "../step-values.js";
-import { freezeTaskInputBindings, rebindTaskInputBindings } from "../task-bindings.js";
-/** The child target's own content identity: its ref, embedded plan hash, route, and bindings. */
+import { freezeTaskInputBindings } from "../task-bindings.js";
+/** The child target's own content identity: its ref, embedded plan hash, and bindings. */
 function childWorkflowContentHash(fields) {
     return createHash("sha256")
-        .update("akm.workflow.child-workflow\0v1\0")
+        .update("akm.workflow.child-workflow\0v2\0")
         .update(canonicalJson({
         ref: fields.ref,
         planHash: fields.planHash,
-        via: fields.via,
-        taskRef: fields.taskRef ?? null,
         inputBindings: fields.inputBindings.length > 0 ? fields.inputBindings : null,
     }))
         .digest("hex");
 }
-/** A composing step's own `env:` (literal or `unit.env`) cannot reach the child run, so say so. */
-function warnIfStepEnvironment(stepId, childRef, source) {
-    const hasLiteralEnv = Object.keys(source.env ?? {}).length > 0;
-    const hasEnvRefs = (source.unit?.env ?? []).length > 0;
-    if (!hasLiteralEnv && !hasEnvRefs)
-        return;
-    warn(`Workflow step ${stepId} declares env: while composing ${childRef}: a child run carries its own frozen ` +
-        `environment inside its own plan, so this composing step's env: (or unit: env:) is not delivered into it ` +
-        `and has no effect. Set those variables inside ${childRef}'s own source instead.`);
-}
-/** A workflow entry of a composition `refPath` — the only entries a cycle can close through. */
+/** A workflow entry of a composition `refPath`. */
 function isWorkflowRef(ref) {
     try {
         return parseBundleRef(ref).conceptId.startsWith("workflows/");
@@ -62,62 +45,43 @@ function assertNoCompositionCycle(stepId, childRef, refPath) {
         "composing itself, directly or through intermediates.");
 }
 export async function childWorkflowDispatch(input) {
-    const { source, baseUnit, childRefInput, context, via, taskRef, authoredInputs } = input;
-    // resolve + qualify. Resolution failures propagate unchanged,
-    // in code and shape — the same authority every other
-    // composition target (command/script/task) already resolves through.
+    const { source, baseUnit, childRefInput, context } = input;
+    // Resolution failures propagate unchanged, in code and shape — the same
+    // authority every other asset reference resolves through.
     const owned = await resolveOwnedAsset(childRefInput, "workflow", context);
     const childAsset = await loadWorkflowAsset(owned.ref);
     const childRef = childAsset.ref;
-    // Issue 10: an authored env: on the composing step has no path to reach
-    // the child run — warn rather than vanish silently (see
-    // warnIfStepEnvironment's doc comment).
-    warnIfStepEnvironment(source.id, childRef, source);
-    // the composition cycle check, before any child compilation.
+    // The composition cycle check, before any child compilation.
     assertNoCompositionCycle(source.id, childRef, context.refPath);
     // Freeze the child completely; its plan is a pure function of its own source.
-    const childRefPath = via === "task" && taskRef !== undefined ? [...context.refPath, taskRef, childRef] : [...context.refPath, childRef];
-    const child = await context.freezeChild(childAsset, childRefPath);
+    const child = await context.freezeChild(childAsset, [...context.refPath, childRef]);
     // Embed the child plan as plain canonical JSON, exactly as `plan_json` stores it.
     const embeddedPlanJson = canonicalPlanJson(child.plan);
     const frozenPlan = JSON.parse(embeddedPlanJson);
-    // Bind the step's effective inputs against the child's declared params.
-    const inputBindings = authoredInputs.kind === "bindings"
-        ? rebindTaskInputBindings({
-            stepId: source.id,
-            targetRef: childRef,
-            bindings: authoredInputs.value,
-            contract: workflowParamContract(frozenPlan),
-        })
-        : freezeTaskInputBindings({
-            stepId: source.id,
-            targetRef: childRef,
-            with: authoredInputs.value,
-            contract: workflowParamContract(frozenPlan),
-            earlierStepIds: earlierStepIds(context.plan, source.id),
-            declaredParamNames: declaredParamNames(context.plan),
-        });
-    // build the frozen target.
+    // Bind the step's `with:` against the child's declared params.
+    const inputBindings = freezeTaskInputBindings({
+        stepId: source.id,
+        targetRef: childRef,
+        with: source.with,
+        contract: workflowParamContract(frozenPlan),
+        earlierStepIds: earlierStepIds(context.plan, source.id),
+        declaredParamNames: declaredParamNames(context.plan),
+    });
     const planHash = createHash("sha256").update(embeddedPlanJson).digest("hex");
-    const contentHash = childWorkflowContentHash({ ref: childRef, planHash, via, taskRef, inputBindings });
     const target = Object.freeze({
         kind: "child-workflow",
         ref: childRef,
         planHash,
         frozenPlan,
-        contentHash,
-        via,
-        ...(taskRef !== undefined ? { taskRef } : {}),
+        contentHash: childWorkflowContentHash({ ref: childRef, planHash, inputBindings }),
         ...(inputBindings.length > 0 ? { inputBindings } : {}),
     });
     return {
         target,
-        // A child run carries its own frozen environment inside its own plan.
-        // A composing step's own env: cannot reach it, so assertNoStepEnvironment
-        // above rejects one instead of it silently vanishing here.
+        // A child run carries its own frozen environment inside its own plan; the
+        // parser rejects an `env` beside `workflow`, so there is nothing to deliver.
         environment: [],
         unit: baseUnit,
-        instructions: source.instructions ??
-            (via === "task" && taskRef !== undefined ? `Run task ${taskRef}.` : `Run workflow ${childRef}.`),
+        instructions: source.instructions ?? `Run workflow ${childRef}.`,
     };
 }

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

@@ -2,34 +2,21 @@
 // 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 { createHash } from "node:crypto";
-import { parseBuiltinCommandAction } from "../../../commands/command/builtin-action.js";
 import { prepareCommandInvocation } from "../../../commands/command/command-execution.js";
-import { PORTABLE_ARGUMENTS_PLACEHOLDER } from "../../../commands/command/portable-template.js";
 import { captureFrozenDirectoryIdentity } from "../../../execution/directory-identity.js";
 import { canonicalResolvedExecutionRequest, } from "../../../execution/resolved-request.js";
 import { fallbackAnnouncement } from "../../../integrations/agent/engine-fallback.js";
 import { buildExecution } from "../../../integrations/agent/execution.js";
 import { freezeEnvironment, workflowExecutionSource } from "../environment.js";
-import { gitIdentity } from "../identity.js";
 import { durableRequest, executionUnitValues, targetConcurrency, } from "../step-values.js";
-function inlineWorkflowCommandAction(action, commandMode) {
-    if (commandMode !== "portable-template")
-        return action;
-    const parsed = parseBuiltinCommandAction(action);
-    if (parsed.kind !== "inline")
-        return action;
-    return { content: parsed.content.split(PORTABLE_ARGUMENTS_PLACEHOLDER).join(parsed.arguments ?? "") };
-}
 export async function commandDispatch(source, baseUnit, action, context) {
     const prepared = await prepareCommandInvocation({
-        action: inlineWorkflowCommandAction(action, source.commandMode),
+        action,
         config: context.config,
         ...(context.plan.defaults
             ? { invocationDefaults: executionUnitValues(context.plan.defaults, context.asset.sourcePath) }
             : {}),
-        ...(source.commandMode === "literal" || source.commandMode === "portable-template"
-            ? { inlineContentMode: "literal" }
-            : {}),
+        inlineContentMode: "literal",
         current: executionUnitValues(source.unit, context.asset.sourcePath),
         sourceLoader: (ref, kind) => workflowExecutionSource(ref, kind, context),
     });
@@ -57,7 +44,6 @@ export function commandResult(source, baseUnit, prepared, context, literals = []
         runner,
         ...(targetConcurrency(runner, context.config) ? { concurrency: targetConcurrency(runner, context.config) } : {}),
         cwdIdentity,
-        ...gitIdentity(baseUnit, cwdIdentity.realRoot),
     });
     const engineAnnouncement = fallbackAnnouncement(prepared.fallbackEngineName, request.engine.name);
     return {

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 =