akm-cli 0.9.16 → 0.9.17-alpha.10

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

@@ -2,42 +2,24 @@
 // 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 recursive child-workflow resolver (spec docs/plans/specs/
- * p3a-plan-v5-child-freeze.md §4). BOTH composition forms lower here:
- *
- *  - a direct step `uses: workflows/<ref>` (`resolve-steps.ts`'s
- *    `resolveStep`, `via: "direct"`);
- *  - a task-wrapped workflow target — a `uses: tasks/<ref>` step whose task's
- *    OWN target is a workflow (`targets/task.ts`'s `taskDispatch`,
- *    `via: "task"`).
- *
- * `childWorkflowDispatch` resolves and qualifies the child ref, enforces the
- * three composition bounds (depth, cycle, aggregate embedded bytes — all
- * FREEZE-time, before publication, `COMPOSITION_INVALID`), recursively
- * freezes the child COMPLETELY through the injected `ResolutionContext.freezeChild`
- * (never a direct import of `compileResolveFreezeWorkflowV4` —
- * `freeze/step-values.ts`'s `ChildCompositionContext` doc explains why: this
- * module is downstream of `ir/freeze-v4.ts`, so importing back from it would
- * close a static cycle), absorbs the child's own fresh source collector into
- * the parent's (A-N7), binds the composing step's effective inputs against
- * the child's declared `params:` (A-N8 — see `AuthoredChildInputs` below for
- * the two ways that mapping arrives), and returns the standard
- * `ResolvedDispatch` envelope carrying a `FrozenChildWorkflowTarget`
- * (`ir/schema-v4.ts`).
+ * 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.
  */
 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 { GuardedExecutionSourceCollector } from "../../../execution/guarded-source.js";
 import { workflowParamContract } from "../../ir/params.js";
 import { canonicalJson, canonicalPlanJson } from "../../ir/plan-hash.js";
-import { utf8Bytes } from "../../resource-limits.js";
 import { loadWorkflowAsset } from "../../runtime/workflow-asset-loader.js";
 import { resolveOwnedAsset } from "../environment.js";
-import { declaredParamNames, earlierStepIds } from "../step-values.js";
+import { declaredParamNames, earlierStepIds, } from "../step-values.js";
 import { freezeTaskInputBindings, rebindTaskInputBindings } from "../task-bindings.js";
-/** §3.5's exact `contentHash` formula — mirrors `ir/schema-v4.ts`'s private decode-side `childWorkflowContentHash` byte-for-byte (the decoder re-verifies what this produces); duplicated rather than imported so this freeze-side module needs no edit to Lane A's already-landed decoder file. */
+/** The child target's own content identity: its ref, embedded plan hash, route, and bindings. */
 function childWorkflowContentHash(fields) {
     return createHash("sha256")
         .update("akm.workflow.child-workflow\0v1\0")
@@ -50,19 +32,7 @@ function childWorkflowContentHash(fields) {
     }))
         .digest("hex");
 }
-/**
- * Code-review finding (see this file's `environment: []` return field): a
- * step composing a child workflow has no path to honor its own authored
- * `env:` — the child run carries its own frozen environment inside its own
- * plan, so `freezeEnvironment` (the ONE mechanism a step's `env:` reaches a
- * frozen unit through, `../environment.ts`) is never called for this
- * target. Leaving that silent would repeat exactly the defect A-N5 already
- * closed for `with:` on a non-binding surface — an authored construct that
- * cannot be honored on this composing target now rejects instead of
- * vanishing. Checks BOTH shapes a step's `env:` can take (`../environment.ts`'s
- * `freezeEnvironment`): literal `env:` values and `unit: {env: [...]}` refs.
- * An absent/empty `env:` is not authored and stays valid.
- */
+/** 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;
@@ -72,7 +42,7 @@ function warnIfStepEnvironment(stepId, childRef, source) {
         `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 (§4.5: a task target can never itself be a task, so no task->task chain exists to close one). */
+/** A workflow entry of a composition `refPath` — the only entries a cycle can close through. */
 function isWorkflowRef(ref) {
     try {
         return parseBundleRef(ref).conceptId.startsWith("workflows/");
@@ -91,20 +61,10 @@ function assertNoCompositionCycle(stepId, childRef, refPath) {
         `Path: ${compositionPath(refPath, childRef)}.`, "COMPOSITION_INVALID", "Break the cycle: remove or redirect one of the compositions in the path above so no workflow ends up " +
         "composing itself, directly or through intermediates.");
 }
-/**
- * Add the child's embedded plan bytes to the shared, tree-wide budget
- * (A-N6) and fail before publication if the AGGREGATE crosses the cap.
- * Mutates `budget` only on success — a rejected step leaves the running
- * total exactly as it was, matching every other freeze-time failure's
- * no-partial-effect shape.
- */
-function chargeEmbeddedBudget(_stepId, _childRef, childPlanBytes, budget) {
-    budget.embeddedBytes += childPlanBytes;
-}
 export async function childWorkflowDispatch(input) {
     const { source, baseUnit, childRefInput, context, via, taskRef, authoredInputs } = input;
-    // §4.2 step 1: resolve + qualify. Resolution failures propagate unchanged,
-    // in code and shape (row B-11) — the same authority every other
+    // resolve + qualify. Resolution failures propagate unchanged,
+    // in code and shape — the same authority every other
     // composition target (command/script/task) already resolves through.
     const owned = await resolveOwnedAsset(childRefInput, "workflow", context);
     const childAsset = await loadWorkflowAsset(owned.ref);
@@ -113,44 +73,15 @@ export async function childWorkflowDispatch(input) {
     // the child run — warn rather than vanish silently (see
     // warnIfStepEnvironment's doc comment).
     warnIfStepEnvironment(source.id, childRef, source);
-    // §4.2 step 2: the composition cycle check, before any child compilation.
-    assertNoCompositionCycle(source.id, childRef, context.composition.refPath);
-    const childDepth = context.composition.depth + 1;
-    // §4.2 step 4: freeze the child COMPLETELY (compile -> validate -> freeze),
-    // with its OWN fresh collector (A-N7) so its plan is a pure function of its
-    // own source, and the SAME mutable budget object so the aggregate bound
-    // sees every descendant across the whole tree.
-    const childRefPath = via === "task" && taskRef !== undefined
-        ? [...context.composition.refPath, taskRef, childRef]
-        : [...context.composition.refPath, childRef];
-    const child = await context.freezeChild({
-        asset: childAsset,
-        sourceCollector: new GuardedExecutionSourceCollector(),
-        composition: { depth: childDepth, refPath: childRefPath, budget: context.composition.budget },
-    });
-    // The embedded `frozenPlan` must be a PLAIN, symbol-free JSON structure —
-    // exactly the shape `decodeWorkflowPlanV4` will (recursively) re-verify it
-    // as, both right now (the PARENT's own top-level `decodeWorkflowPlanV4`
-    // call in `ir/freeze-v4.ts` walks straight into this target) and later,
-    // read back from a stored run's `plan_json`. `child.plan` — the in-memory
-    // result of the child's OWN already-decoded freeze — carries internal
-    // resolved-request construction brands (`execution/resolved-request.ts`)
-    // that `decodeResolvedExecutionRequest` deliberately rejects on ANY
-    // "fresh rehydrate" input; round-tripping through canonical JSON strips
-    // them, the same way persisting and re-reading `plan_json` naturally would.
+    // 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);
+    // Embed the child plan as plain canonical JSON, exactly as `plan_json` stores it.
     const embeddedPlanJson = canonicalPlanJson(child.plan);
     const frozenPlan = JSON.parse(embeddedPlanJson);
-    // §4.2 step 5.
-    chargeEmbeddedBudget(source.id, childRef, utf8Bytes(embeddedPlanJson), context.composition.budget);
-    // §4.2 step 6 (A-N7): absorb the child's captured sources so the parent's
-    // final pre-publication CAS (`revalidate()`) covers every child file too.
-    context.collector.absorb(child.sourceCollector);
-    // §4.2 step 7 (A-N8): bind the composing step's effective inputs against
-    // the child's declared params:. A genuinely authored `with:` goes through
-    // the SAME normalizer every other binding surface uses; an
-    // already-classified binding set (a v4 task's effective inputs) is
-    // RE-bound instead, never round-tripped back through the `with:` grammar
-    // (code-review finding — see AuthoredChildInputs above).
+    // Bind the step's effective inputs against the child's declared params.
     const inputBindings = authoredInputs.kind === "bindings"
         ? rebindTaskInputBindings({
             stepId: source.id,
@@ -163,10 +94,10 @@ export async function childWorkflowDispatch(input) {
             targetRef: childRef,
             with: authoredInputs.value,
             contract: workflowParamContract(frozenPlan),
-            earlierStepIds: earlierStepIds(context.sourceIr, source.id),
-            declaredParamNames: declaredParamNames(context.sourceIr),
+            earlierStepIds: earlierStepIds(context.plan, source.id),
+            declaredParamNames: declaredParamNames(context.plan),
         });
-    // §4.2 step 8: build the frozen target.
+    // build the frozen target.
     const planHash = createHash("sha256").update(embeddedPlanJson).digest("hex");
     const contentHash = childWorkflowContentHash({ ref: childRef, planHash, via, taskRef, inputBindings });
     const target = Object.freeze({
@@ -183,7 +114,7 @@ export async function childWorkflowDispatch(input) {
         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 (§4.2 step 8).
+        // above rejects one instead of it silently vanishing here.
         environment: [],
         unit: baseUnit,
         instructions: source.instructions ??

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

@@ -6,15 +6,12 @@ import { parseBuiltinCommandAction } from "../../../commands/command/builtin-act
 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 { freezeExecutableIdentity } from "../../../execution/executable-identity.js";
 import { canonicalResolvedExecutionRequest, } from "../../../execution/resolved-request.js";
 import { fallbackAnnouncement } from "../../../integrations/agent/engine-fallback.js";
-import { requireAuthorizedExecutionPlan } from "../../../integrations/agent/execution-cascade.js";
-import { lowerResolvedExecutionRequest } from "../../../integrations/agent/execution-lowering.js";
-import { prepareInlineExecution } from "../../../integrations/agent/inline-execution.js";
-import { freezeEnvironment, guardedExecutionSource } from "../environment.js";
+import { buildExecution } from "../../../integrations/agent/execution.js";
+import { freezeEnvironment, workflowExecutionSource } from "../environment.js";
 import { gitIdentity } from "../identity.js";
-import { durableRequest, executionUnitValues, executionValues, targetConcurrency, } from "../step-values.js";
+import { durableRequest, executionUnitValues, targetConcurrency, } from "../step-values.js";
 function inlineWorkflowCommandAction(action, commandMode) {
     if (commandMode !== "portable-template")
         return action;
@@ -27,41 +24,22 @@ export async function commandDispatch(source, baseUnit, action, context) {
     const prepared = await prepareCommandInvocation({
         action: inlineWorkflowCommandAction(action, source.commandMode),
         config: context.config,
-        invocationKind: "workflow",
-        ...(context.sourceIr.defaults
-            ? { invocationDefaults: executionUnitValues(context.sourceIr.defaults, context.asset.sourcePath) }
+        ...(context.plan.defaults
+            ? { invocationDefaults: executionUnitValues(context.plan.defaults, context.asset.sourcePath) }
             : {}),
         ...(source.commandMode === "literal" || source.commandMode === "portable-template"
             ? { inlineContentMode: "literal" }
             : {}),
-        current: executionValues(source, context.asset.sourcePath),
-        sourceLoader: (ref, kind) => guardedExecutionSource(ref, kind, context),
-    });
-    return commandResult(source, baseUnit, prepared, context);
-}
-export function inlineDispatch(source, baseUnit, context) {
-    const content = source.instructions ?? `Execute workflow step ${source.id}.`;
-    const prepared = prepareInlineExecution({
-        content,
-        config: context.config,
-        invocationKind: "workflow",
-        ...(context.sourceIr.defaults
-            ? { invocationDefaults: executionUnitValues(context.sourceIr.defaults, context.asset.sourcePath) }
-            : {}),
-        current: executionValues(source, context.asset.sourcePath),
+        current: executionUnitValues(source.unit, context.asset.sourcePath),
+        sourceLoader: (ref, kind) => workflowExecutionSource(ref, kind, context),
     });
     return commandResult(source, baseUnit, prepared, context);
 }
 export function commandResult(source, baseUnit, prepared, context, literals = []) {
-    const request = durableRequest(requireAuthorizedExecutionPlan(prepared.plan));
-    const lowered = lowerResolvedExecutionRequest(request, prepared.config);
+    const request = durableRequest(prepared.request);
+    const lowered = buildExecution(request, prepared.runner);
     const cwdIdentity = captureFrozenDirectoryIdentity(context.asset.sourcePath);
-    let runner = lowered.runner;
-    let executable;
-    if (runner.kind === "agent") {
-        executable = freezeExecutableIdentity(runner.profile.bin, { cwd: cwdIdentity.realCwd });
-        runner = Object.freeze({ ...runner, profile: Object.freeze({ ...runner.profile, bin: executable.absolutePath }) });
-    }
+    const runner = lowered.runner;
     const unit = {
         ...baseUnit,
         engine: request.engine.name,
@@ -79,7 +57,6 @@ export function commandResult(source, baseUnit, prepared, context, literals = []
         runner,
         ...(targetConcurrency(runner, context.config) ? { concurrency: targetConcurrency(runner, context.config) } : {}),
         cwdIdentity,
-        ...(executable ? { executable } : {}),
         ...gitIdentity(baseUnit, cwdIdentity.realRoot),
     });
     const engineAnnouncement = fallbackAnnouncement(prepared.fallbackEngineName, request.engine.name);

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

@@ -1,22 +1,18 @@
 // 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 { freezeExecutableIdentity } from "../../../execution/executable-identity.js";
+import fs from "node:fs";
 import { prepareScriptTarget } from "../../../tasks/prepare/prepare-script-target.js";
-import { captureOwned, freezeEnvironment, resolveOwnedAsset } from "../environment.js";
+import { freezeEnvironment, resolveOwnedAsset } from "../environment.js";
 import { gitIdentity, scriptExecutable } from "../identity.js";
-import { freezeExecSpec } from "../step-values.js";
+import { freezeExecSpec, } from "../step-values.js";
 export async function directScript(source, baseUnit, refInput, context) {
     const owned = await resolveOwnedAsset(refInput, "script", context);
-    captureOwned(owned, context.collector);
-    // Typed preparer (P1b spec §4.3) — no synthetic task YAML, no parseTaskV3Yaml
-    // call, no fabricated schedule/filePath/taskId/taskRef. The script's own
-    // owned identity (ref/file/bundleRoot) is all prepareScriptTarget needs.
     const captured = prepareScriptTarget({
         ref: owned.ref,
         file: owned.file,
         bundleRoot: owned.root,
-        readFile: () => context.collector.readBytes(owned.file, owned.root),
+        readFile: () => fs.readFileSync(owned.file),
     });
     return scriptResult(source, baseUnit, {
         sourceRef: captured.ref,
@@ -29,9 +25,7 @@ export async function directScript(source, baseUnit, refInput, context) {
     }, context, []);
 }
 export function scriptResult(source, baseUnit, prepared, context, literals) {
-    const requestedExecutable = scriptExecutable(prepared.interpreter);
-    const executable = freezeExecutableIdentity(requestedExecutable, { cwd: prepared.cwdIdentity.realCwd });
-    const authoredExec = { command: [executable.absolutePath, "<frozen-script>"] };
+    const authoredExec = { command: [scriptExecutable(prepared.interpreter), "<frozen-script>"] };
     const exec = freezeExecSpec(source, authoredExec, context);
     const environment = Object.freeze([...literals, ...freezeEnvironment(source, authoredExec, context)]);
     const target = Object.freeze({
@@ -45,7 +39,6 @@ export function scriptResult(source, baseUnit, prepared, context, literals) {
         byteLength: prepared.byteLength,
         cwdIdentity: prepared.cwdIdentity,
         materialization: "ephemeral-0700-delete",
-        executable,
         ...gitIdentity(baseUnit, prepared.cwdIdentity.realRoot),
     });
     return {

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

@@ -2,30 +2,27 @@
 // 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 { captureFrozenDirectoryIdentity } from "../../../execution/directory-identity.js";
-import { freezeExecutableIdentity } from "../../../execution/executable-identity.js";
 import { freezeEnvironment } from "../environment.js";
 import { gitIdentity } from "../identity.js";
-import { freezeExecSpec } from "../step-values.js";
+import { freezeExecSpec, } from "../step-values.js";
 export function directShell(source, baseUnit, context) {
     const authoredExec = baseUnit.exec;
     if (!authoredExec)
-        throw new Error(`workflow shell step ${source.id} lost its source-IR execution spec`);
+        throw new Error(`workflow shell step ${source.id} has no argv`);
     const exec = freezeExecSpec(source, authoredExec, context);
     const cwdIdentity = captureFrozenDirectoryIdentity(context.asset.sourcePath, authoredExec.cwd);
-    const executable = freezeExecutableIdentity(authoredExec.command[0], { cwd: cwdIdentity.realCwd });
     const environment = Object.freeze(freezeEnvironment(source, authoredExec, context));
     const target = Object.freeze({
         kind: "shell",
         contentHash: "",
         exec,
         cwdIdentity,
-        executable,
         ...gitIdentity(baseUnit, cwdIdentity.realRoot),
     });
     return {
         target,
         environment,
         unit: { ...baseUnit, exec },
-        instructions: source.instructions ?? `Run ${source.run ?? authoredExec.command.join(" ")}.`,
+        instructions: source.instructions ?? `Run ${authoredExec.command.join(" ")}.`,
     };
 }

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

@@ -1,101 +1,60 @@
 // 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 fs from "node:fs";
 import path from "node:path";
 import { parseBundleRef } from "../../../core/asset/asset-ref.js";
 import { UsageError } from "../../../core/errors.js";
-import { freezeExecutableIdentity } from "../../../execution/executable-identity.js";
 import { prepareTaskV3Execution } from "../../../tasks/prepare/prepare.js";
 import { parseTaskSource } from "../../../tasks/source/parse-task-source.js";
 import { projectTaskSourceV4 } from "../../../tasks/source/project-v4.js";
-import { workflowShellCommand } from "../../source-ir/program.js";
-import { captureOwned, freezeEnvironment, guardedExecutionSource, resolveOwnedAsset } from "../environment.js";
+import { workflowShellCommand } from "../../source-semantics.js";
+import { freezeEnvironment, resolveOwnedAsset, workflowExecutionSource } from "../environment.js";
 import { gitIdentity } from "../identity.js";
 import { declaredParamNames, earlierStepIds, freezeExecSpec, } from "../step-values.js";
 import { freezeTaskInputBindings } from "../task-bindings.js";
 import { childWorkflowDispatch } from "./child-workflow.js";
 import { commandResult } from "./command.js";
 import { scriptResult } from "./script.js";
-/** The one message shared by every "cannot prove this is a valid binding surface" rejection (A-N5). */
+/** The rejection for a `with:` on a task that declares no inputs (or does not resolve). */
 function noDeclaredInputsError(stepId, ref) {
     return new UsageError(`Workflow step ${stepId} cannot pass with: to task target ${ref}; ${ref} declares no inputs.`, "COMPOSITION_INVALID");
 }
 /**
- * A-N6 (spec docs/plans/specs/p2b-input-bindings.md §1.7): LC-N1's
- * peek-and-throw (p2a §1.5) is GONE — a version: 4 target now composes.
- * `parseTaskSource` parses the YAML ONCE and routes on the SAME {root,
- * lineAt} the v3 arm always used, so a v3 composition stays byte-identical
- * (B-07, B-08). `contract` is undefined for a v3 task (which can never
- * declare `inputs:`, P2a §1.2 D2) or a v4 task with no `inputs:` key at all —
- * either way, "no declared inputs" (A-N5).
- *
- * RECORDED TENSION (spec §0, Review log): A-N5's "no declared inputs"
- * rejection is reasoned from the target's PARSED `inputs:` contract, which
- * needs the target to resolve — yet `tests/workflows/with-rejection.test.ts`
- * B-02b pins `COMPOSITION_INVALID` (not an asset-resolution error) for an
- * UNRESOLVABLE task ref with an authored `with:`. Reconciled here: an
- * authored `with:` whose target cannot even be resolved/parsed "cannot be
- * proven a valid binding surface", so it is refused the same
- * no-declared-inputs way — a `with:`-free step's resolution failure is
- * untouched and propagates as before.
- *
- * Code-review finding: that reconciliation must stay scoped to ASSET
- * resolution (`resolveOwnedAsset`/`captureOwned`) only. Once the target
- * resolves to a real file, `parseTaskSource`/`projectTaskSourceV4` reports a
- * genuine, path-and-line-anchored defect in the composed task's OWN source
- * (e.g. `TASK_SOURCE_INVALID` for an unsupported `inputs.<name>` field) —
- * that is never "cannot be proven a valid binding surface" and must not be
- * repainted as `noDeclaredInputsError`. Parsing therefore happens OUTSIDE
- * the try/catch below, so its errors propagate unchanged regardless of
- * whether this step authored a `with:`.
+ * Resolve and parse the composed task. An authored `with:` whose target does
+ * not even resolve cannot be proven a valid binding surface, so it is refused
+ * the same no-declared-inputs way; a genuine defect in the resolved task's own
+ * source propagates unchanged.
  */
 async function resolveTaskForComposition(source, refInput, context) {
-    const { owned, retained } = await resolveAndCaptureTaskAsset(source, refInput, context);
-    const parsed = parseTaskSource({ yaml: retained.content, filePath: owned.file, workspaceRoot: owned.root });
-    const contract = parsed.v4.inputs;
-    const task = projectTaskSourceV4(parsed.v4);
-    return { owned, task, contract };
-}
-/** The asset-resolution-only half of {@link resolveTaskForComposition} — the sole failure mode an authored `with:` on an unresolvable ref may repaint as `noDeclaredInputsError` (A-N5's `with-rejection.test.ts` B-02b). */
-async function resolveAndCaptureTaskAsset(source, refInput, context) {
+    let owned;
+    let yaml;
     try {
-        const owned = await resolveOwnedAsset(refInput, "task", context);
-        const retained = captureOwned(owned, context.collector);
-        return { owned, retained };
+        owned = await resolveOwnedAsset(refInput, "task", context);
+        yaml = fs.readFileSync(owned.file, "utf8");
     }
     catch (cause) {
         if (source.with !== undefined)
             throw noDeclaredInputsError(source.id, refInput);
         throw cause;
     }
+    const parsed = parseTaskSource({ yaml, filePath: owned.file, workspaceRoot: owned.root });
+    return { owned, task: projectTaskSourceV4(parsed.v4), contract: parsed.v4.inputs };
 }
 export async function taskDispatch(source, baseUnit, refInput, context) {
     const { owned, task, contract } = await resolveTaskForComposition(source, refInput, context);
-    // A-N5: a with: on a target that declares no inputs: at all is
-    // COMPOSITION_INVALID. Fires on ANY authored with: shape, including `{}`
-    // (the check is `!== undefined`, not "non-empty").
+    // Any authored `with:` (even `{}`) on a task that declares no inputs is COMPOSITION_INVALID.
     if (source.with !== undefined && contract === undefined) {
         throw noDeclaredInputsError(source.id, refInput);
     }
-    // P3a (docs/plans/specs/p3a-plan-v5-child-freeze.md §4.2, row B-12): a task
-    // whose OWN target is `uses: workflows/<ref>` used to fast-fail here,
-    // before ever calling prepareTaskV3Execution. That rejection is REMOVED —
-    // flow continues to the bindings computation and the prepare call exactly
-    // as for any other task target, and `prepared.kind === "workflow"` below
-    // routes to the ONE child-workflow resolver instead.
-    // Lane A2 (§3.2-§3.5): normalize THIS step's own with: against THIS task's
-    // OWN declared inputs — no merge across a composition chain (B-29). A task
-    // with no inputs: has contract === undefined, so an empty {} contract is
-    // used; freezeTaskInputBindings then produces no bindings for it (there is
-    // nothing to bind, and the COMPOSITION_INVALID check above already fired
-    // for any authored with:).
+    // This step's own `with:` against this task's own declared inputs (none → no bindings).
     const bindings = freezeTaskInputBindings({
         stepId: source.id,
         targetRef: refInput,
         with: source.with,
         contract: contract ?? {},
-        earlierStepIds: earlierStepIds(context.sourceIr, source.id),
-        declaredParamNames: declaredParamNames(context.sourceIr),
+        earlierStepIds: earlierStepIds(context.plan, source.id),
+        declaredParamNames: declaredParamNames(context.plan),
     });
     const prepared = await prepareTaskV3Execution(task, {
         taskId: parseBundleRef(owned.ref).conceptId.slice("tasks/".length),
@@ -103,30 +62,18 @@ export async function taskDispatch(source, baseUnit, refInput, context) {
         bundleName: owned.bundle,
         bundleRoot: owned.root,
         config: context.config,
-        commandSourceLoader: (ref, kind) => guardedExecutionSource(ref, kind, context),
+        commandSourceLoader: (ref, kind) => workflowExecutionSource(ref, kind, context),
         resolveAsset: async ({ ref, type }) => {
             const target = await resolveOwnedAsset(ref, type, context);
-            captureOwned(target, context.collector);
             return { file: target.file, bundleRoot: target.root };
         },
-        readFile: (file, root = owned.root) => context.collector.readBytes(file, root),
     });
     if (prepared.kind === "workflow") {
-        // P3a (spec §4.2, rows B-12/B-13): routes to the ONE child-workflow
-        // resolver instead of rejecting. `prepared.ref`/`prepared.taskRef` are
-        // already qualified (§4.2 step 1 re-resolves and re-canonicalizes them
-        // regardless). Always hands over the bindings just computed above — this
-        // task's OWN effective inputs, already classified once against its own
-        // contract — to be RE-bound against the child's declared `params:`
-        // (never round-tripped through the `with:` grammar: doing so would let a
-        // literal value shaped like `{from: ...}` be silently reinterpreted as a
-        // reference, code-review finding). Task source v4 rejects `with:` on any
-        // target but `uses: akm/command` (row B-28), so a workflow-target task
-        // can no longer author `with:` at all — the `{kind:"with"}` arm this
-        // ternary used to reach for a v3 task, or a v4 task with no `inputs:`,
-        // is unreachable from here and deleted (P4 §3.2.7, row B-30).
-        // `AuthoredChildInputs`'s `{kind:"with"}` member itself stays — the
-        // DIRECT composition path (`resolve-steps.ts`) still produces it.
+        // A task whose own target is a workflow composes it as a child. This
+        // task's effective inputs, already classified against its own contract,
+        // are re-bound against the child's `params:` — never round-tripped through
+        // the `with:` grammar, which would reinterpret a literal shaped like
+        // `{from: ...}` as a reference.
         return childWorkflowDispatch({
             source,
             baseUnit,
@@ -150,13 +97,11 @@ export async function taskDispatch(source, baseUnit, refInput, context) {
         };
         const exec = freezeExecSpec(source, authoredExec, context);
         const environment = Object.freeze([...taskLiterals, ...freezeEnvironment(source, authoredExec, context)]);
-        const executable = freezeExecutableIdentity(exec.command[0], { cwd: prepared.cwdIdentity.realCwd });
         const target = Object.freeze({
             kind: "shell",
             contentHash: "",
             exec,
             cwdIdentity: prepared.cwdIdentity,
-            executable,
             ...gitIdentity(baseUnit, prepared.cwdIdentity.realRoot),
         });
         return withInputBindings({
@@ -168,7 +113,7 @@ export async function taskDispatch(source, baseUnit, refInput, context) {
     }
     return withInputBindings(scriptResult(source, baseUnit, prepared, context, taskLiterals), bindings);
 }
-/** Attach the frozen inputBindings (A-N7) to whichever target shape taskDispatch produced. Absent, never [], when empty. */
+/** Attach the frozen inputBindings to whichever target shape taskDispatch produced. Absent, never [], when empty. */
 function withInputBindings(resolved, bindings) {
     if (bindings.length === 0)
         return resolved;