akm-cli 0.9.31 → 0.10.261001-beta

package/dist/tasks/scheduler-sync.js

@@ -3,7 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * Scheduler reconciliation: compile the desired bindings from a bundle's
- * task and workflow sources, then diff them against the rows the native
+ * task sources, then diff them against the rows the native
  * scheduler holds.
  *
  * `compileSchedulerSources` reads each source once. One source that fails
@@ -17,14 +17,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { makeBundleRef, parseBundleRef } from "../core/asset/asset-ref.js";
 import { compareCodePoints, toPosix } from "../core/common.js";
-import { UsageError } from "../core/errors.js";
-import { canonicalizeWorkflowName, WORKFLOW_EXTENSIONS } from "../core/recognition-util.js";
-import { applyInputDefaults, validateInputs } from "../execution/input-contract.js";
-import { checkWorkflowPlan, compileWorkflowSource } from "../workflows/compile.js";
-import { WorkflowSourceCollisionError, WorkflowSourceNameError, workflowNameForSourcePath, } from "../workflows/source-files.js";
 import { prepareTaskV3Execution } from "./prepare/prepare.js";
-import { parseSchedule } from "./schedule.js";
-import { compileTaskSchedulerBindings, compileWorkflowSchedulerBindings, schedulerBindingNativeId, schedulerNativeBindingId, } from "./scheduler-binding.js";
+import { assertTaskScheduleCronValid, assertTaskScheduleInputsSatisfyContract } from "./schedule-gates.js";
+import { compileTaskSchedulerBindings, schedulerBindingNativeId, schedulerNativeBindingId, } from "./scheduler-binding.js";
 import { parseTaskSource } from "./source/parse-task-source.js";
 import { projectTaskSourceV4 } from "./source/project-v4.js";
 import { taskSourceErrorDetail } from "./source-v3.js";
@@ -37,7 +32,6 @@ export async function compileSchedulerSources(input) {
     const desired = [];
     const failures = [];
     await compileTaskSources({ ...input, sourceRoot }, desired, failures);
-    compileWorkflowSources({ ...input, sourceRoot }, desired, failures);
     return Object.freeze({
         desired: Object.freeze(desired),
         failures: Object.freeze(failures.sort((left, right) => compareCodePoints(left.path, right.path))),
@@ -107,67 +101,6 @@ function taskSourceFiles(sourceRoot, adapterId) {
         return walkFiles(sourceRoot).filter((file) => file.endsWith(".yml"));
     return [];
 }
-function compileWorkflowSources(input, desired, failures) {
-    if (input.adapterId !== "akm" && input.adapterId !== "akm-workflow")
-        return;
-    const root = input.adapterId === "akm" ? path.join(input.sourceRoot, "workflows") : input.sourceRoot;
-    const byName = new Map();
-    for (const file of walkFiles(root)) {
-        if (path.basename(file).toLowerCase() === "readme.md")
-            continue;
-        const authoredName = workflowNameForSourcePath(input.sourceRoot, input.adapterId, file);
-        if (authoredName === undefined)
-            continue;
-        const extension = path.posix.extname(authoredName).toLowerCase();
-        const stem = authoredName.slice(0, -extension.length).toLowerCase();
-        const nestedSuffix = WORKFLOW_EXTENSIONS.find((suffix) => stem.endsWith(suffix));
-        if (nestedSuffix) {
-            const relative = toPosix(path.relative(input.sourceRoot, file));
-            failures.push({ path: file, reason: new WorkflowSourceNameError(relative, nestedSuffix).message });
-            continue;
-        }
-        const canonicalName = canonicalizeWorkflowName(authoredName);
-        byName.set(canonicalName, [...(byName.get(canonicalName) ?? []), file]);
-    }
-    for (const [canonicalName, sources] of [...byName].sort(([left], [right]) => compareCodePoints(left, right))) {
-        const conceptId = input.adapterId === "akm" ? `workflows/${canonicalName}` : canonicalName;
-        const ref = sourceRef(input.bundleName, conceptId);
-        if (ref === undefined || (input.enabledRefs && !input.enabledRefs.has(ref)))
-            continue;
-        const file = sources[0];
-        try {
-            if (sources.length > 1) {
-                throw new WorkflowSourceCollisionError(conceptId, sources.map((source) => toPosix(path.relative(input.sourceRoot, source))));
-            }
-            const relative = toPosix(path.relative(input.sourceRoot, file));
-            const compiled = compileWorkflowSource(fs.readFileSync(file, "utf8"), {
-                path: relative,
-                workspaceRoot: input.sourceRoot,
-            });
-            if (!compiled.ok) {
-                throw new UsageError(compiled.errors
-                    .map((error) => `${error.path}:${error.line ?? 1} [${error.code}] ${error.message}`)
-                    .join("; "), "WORKFLOW_SOURCE_INVALID");
-            }
-            const planDraft = checkWorkflowPlan(compiled.plan);
-            if (!planDraft.ok) {
-                throw new UsageError(planDraft.errors.map((error) => `${relative}:${error.line} ${error.message}`).join("; "), "WORKFLOW_SOURCE_INVALID");
-            }
-            const schedules = (compiled.plan.schedules ?? []).map((schedule) => ({
-                cron: schedule.cron,
-                source: `${relative}:${schedule.line}`,
-                ordinal: schedule.ordinal,
-            }));
-            for (const binding of compileWorkflowSchedulerBindings({ qualifiedRef: ref, schedules })) {
-                parseSchedule(binding.cron, input.backend);
-                desired.push(binding);
-            }
-        }
-        catch (cause) {
-            failures.push({ path: file, ref, reason: errorMessage(cause) });
-        }
-    }
-}
 /** A file whose name cannot form a ref (a `#` in it) cannot be enabled, so it is not this sync's. */
 function sourceRef(bundleName, conceptId) {
     try {
@@ -213,33 +146,6 @@ function statOrUndefined(file) {
         return undefined;
     }
 }
-/**
- * Validate every v4 `schedule:` entry's `inputs` against the task's own
- * declared contract with defaults applied — the exact set of values a
- * compiled invocation delivers — so a violation is reported at sync rather
- * than when the scheduler fires. Shared with `akm task validate`.
- */
-export function assertTaskScheduleInputsSatisfyContract(v4, refLabel) {
-    const contract = v4.inputs ?? {};
-    for (const scheduleEntry of v4.schedule) {
-        const defaultedInputs = applyInputDefaults(contract, { ...scheduleEntry.inputs });
-        const errors = validateInputs(contract, defaultedInputs);
-        if (errors.length > 0) {
-            throw new UsageError(`Task ${JSON.stringify(refLabel)} schedule[${scheduleEntry.ordinal}].inputs does not satisfy ` +
-                `its declared inputs once defaults are applied: ${errors.join("; ")}`, "TASK_SOURCE_INVALID");
-        }
-    }
-}
-/**
- * Validate every v4 `schedule:` entry's `cron` against the active backend's
- * dialect: cron is the most permissive of the three, so a task authored on
- * Linux can carry an expression launchd/schtasks cannot translate. Shared
- * with `akm task validate`.
- */
-export function assertTaskScheduleCronValid(v4, backend) {
-    for (const scheduleEntry of v4.schedule)
-        parseSchedule(scheduleEntry.cron, backend);
-}
 export function installedRowNativeId(row) {
     return row.nativeId ?? schedulerNativeBindingId(row.id);
 }

package/dist/tasks/source/bounded-document.js

@@ -380,7 +380,7 @@ export function assertBoundedTaskYamlDocument(document, options) {
  * P4 (docs/plans/specs/p4-deletions-closeout.md §3.2) deleted task v3
  * acceptance from `src` entirely — `parseTaskV3Yaml` and its `"task v3
  * source"` label no longer exist here (the grammar survives only in the
- * vendored, frozen `src/tasks/source/task-source-v3-frozen.ts`
+ * vendored, frozen `scripts/akm-migrate/migrate/task-source-v3-frozen.ts`
  * copy, which does not call this function). The two live `src` callers
  * today: `parseTaskSourceV4`'s standalone YAML-string entry
  * (`task-source-v4.ts:790`) passes `sourceLabel: "task source v4"`; the

package/dist/tasks/source/task-source-v4.js

@@ -44,7 +44,7 @@ import { classifyTargetRef } from "../../execution/target-ref.js";
 import { detectSecretShapedParams } from "../../workflows/exec/param-secrets.js";
 import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_SCHEMA_BYTES } from "../../workflows/resource-limits.js";
 import { TASK_V3_HOST_SHELLS, TASK_V3_MAX_SCHEDULES } from "../source-v3.js";
-import { TASK_RUN_RESERVED_FLAG_NAMES, TASK_RUN_SELF_DIAGNOSED_FLAGS } from "../task-run-reserved-flags.js";
+import { TASK_RUN_RESERVED_FLAG_NAMES } from "../task-run-reserved-flags.js";
 import { asRecord, checkKeys, cloneBoundedJson, noGithubExpression, own, parseEnvironment, parseStringArray, presentJsonValue, readBoundedTaskSourceYaml, sourceError, stringField, TASK_V3_MAX_REDACT_NAMES, utf8Bytes, validateWorkingDirectory, } from "./bounded-document.js";
 // ── Closed constants (D1, D2-N3, D2-N7) ─────────────────────────────────────
 export const TASK_SOURCE_V4_VERSION = 4;
@@ -391,18 +391,8 @@ function parseInputDeclarations(value, ctx) {
         // checked against this same contract below, so a banned name can never
         // reach compileTaskSchedulerBindings's invocation tail either) — see
         // ../task-run-reserved-flags.ts's own header.
-        //
-        // 0.9.2 review round 2: `target` joins that set from the CLI's DIAGNOSTIC
-        // side rather than its declared-arg side. `rejectRetiredTaskTargetFlag`
-        // (../../commands/tasks/tasks-cli.ts) throws the 0.9 `--target` ->
-        // `--bundle` rename hint for every spelling of the name, before
-        // parseTaskInputFlags scans argv at all, so an input declared under that
-        // name could never be supplied either — it is the same unusable
-        // declaration, reached by a different route (TASK_RUN_SELF_DIAGNOSED_FLAGS).
         if (TASK_RUN_RESERVED_FLAG_NAMES.has(name)) {
-            sourceError(ctx, ["inputs", name], TASK_RUN_SELF_DIAGNOSED_FLAGS.includes(name)
-                ? `collides with the retired \`akm task --${name}\` spelling, which every task subcommand still rejects with a rename hint, so no --${name} flag can ever reach this input; declare the input under a different name.`
-                : `collides with akm task run's own --${name} flag; declare the input under a different name.`);
+            sourceError(ctx, ["inputs", name], `collides with akm task run's own --${name} flag; declare the input under a different name.`);
         }
         result[name] = parseInputDeclaration(name, input[name], ctx);
     }

package/dist/tasks/task-run-reserved-flags.js

@@ -26,9 +26,7 @@
  * `src/commands/tasks/tasks-cli.ts` re-exports `TASK_RUN_VALUE_FLAGS` /
  * `TASK_RUN_BOOLEAN_FLAGS` from here unchanged, so this module is the single
  * source of truth both the CLI's own argv scanner and the source parser read
- * — the two can never drift apart. `TASK_RUN_SELF_DIAGNOSED_FLAGS` (below)
- * covers the third category the scanner sets cannot express: a name the CLI
- * claims by REJECTING it rather than by declaring it. This file imports
+ * — the two can never drift apart. This file imports
  * nothing, and nothing it
  * exports depends on IO, config, or any other `src/tasks/**` module, so it
  * can be imported from either side of that boundary without participating in
@@ -45,35 +43,8 @@ export const TASK_RUN_BOOLEAN_FLAGS = [
     "no-quiet",
     "no-verbose",
 ];
-/**
- * Flag names `akm task` claims WITHOUT declaring them as citty args, so they
- * appear in neither list above and must be reserved separately.
- *
- * `target` is the only member: the 0.9 rename of `akm task --target` to
- * `--bundle` (S8.4) is self-diagnosed rather than merely dropped —
- * `rejectRetiredTaskTargetFlag` (`../commands/tasks/tasks-cli.ts`) throws the
- * rename hint for a `--target` in ANY spelling, bare or `--target=<value>`,
- * and the generic pre-dispatch gate exempts the name on every `task`
- * subcommand precisely so that handler can answer (`../cli/unknown-flags.ts`'s
- * `SELF_DIAGNOSED_FLAGS`). That rejection runs before `parseTaskInputFlags`
- * ever scans argv, so a declared input named `target` is unreachable through
- * every spelling of its own flag — the exact value-misrouting hole the union
- * below exists to close, just reached from the CLI's diagnostic side instead
- * of from its declared-arg side (0.9.2 review round 2). Rejecting the
- * DECLARATION keeps the rename hint intact for everyone typing the retired
- * spelling while making the unusable declaration impossible to author, rather
- * than trading one silent failure for another.
- *
- * It deliberately stays OUT of `TASK_RUN_VALUE_FLAGS` /
- * `TASK_RUN_BOOLEAN_FLAGS`: those two are `parseTaskInputFlags`' own scanner
- * sets (a value flag makes the scanner swallow the following token), and
- * `--target` must keep reaching the rename diagnostic rather than being
- * silently consumed as one of `akm task run`'s own flags.
- */
-export const TASK_RUN_SELF_DIAGNOSED_FLAGS = ["target"];
-/** The union of all three lists above, for a single membership check against a candidate input name. */
+/** The union of the two lists above, for a single membership check against a candidate input name. */
 export const TASK_RUN_RESERVED_FLAG_NAMES = new Set([
     ...TASK_RUN_VALUE_FLAGS,
     ...TASK_RUN_BOOLEAN_FLAGS,
-    ...TASK_RUN_SELF_DIAGNOSED_FLAGS,
 ]);

package/dist/workflows/authoring/authoring.js

@@ -41,13 +41,13 @@ function validateWorkflowContent(content, sourcePath) {
         throw new UsageError(formatWorkflowErrors(sourcePath, compiled.errors));
     }
 }
-/** Peer YAML is executable, but `akm workflow create` emits the Markdown authoring form only. */
+/** Workflows are Markdown; `akm workflow create` rejects a YAML suffix. */
 const YAML_SUFFIX_RE = /\.ya?ml$/i;
 export function assertWorkflowMarkdownName(name) {
     if (!YAML_SUFFIX_RE.test(name.trim()))
         return;
     throw new UsageError(`akm workflow create is markdown-only: it emits Markdown and cannot create "${name}". ` +
-        `Use a plain name (no ".yaml"/".yml" suffix), or author a peer GitHub-shaped ".yml" workflow directly.`);
+        `Use a plain name (no ".yaml"/".yml" suffix).`);
 }
 // 0.9.2 review round 2 (P4 sweep criterion-21 caveat, spec
 // docs/plans/specs/p4-deletions-closeout.md §4.1 row B-49): this return's
@@ -75,7 +75,7 @@ export function createWorkflowAsset(input) {
         path.isAbsolute(relativeAssetPath)) {
         throw new UsageError(`Resolved workflow path escapes the bundle: "${normalizedName}"`, "PATH_ESCAPE_VIOLATION");
     }
-    // A peer `.md` or `.yml` file whose canonical name matches already owns this
+    // A `.md` file whose canonical name matches already owns this
     // ref. Case variants (`upper.MD` vs `upper.md`) may also name one physical
     // file on a case-insensitive filesystem, so writing the Markdown create
     // target would silently clobber or shadow the existing asset.
@@ -160,9 +160,9 @@ export function formatWorkflowErrors(path, errors) {
 }
 /**
  * Every file under `typeRoot` whose canonical workflow name equals
- * `normalizedName`. Peer `.md`/`.yml` extension matching is case-INSENSITIVE,
- * so both cross-format owners and case variants are returned for the create
- * path to refuse rather than silently clobber or shadow them.
+ * `normalizedName`. `.md` extension matching is case-INSENSITIVE, so case
+ * variants are returned for the create path to refuse rather than silently
+ * clobber or shadow them.
  */
 function findExistingWorkflowPaths(typeRoot, normalizedName) {
     const parent = path.join(typeRoot, path.dirname(normalizedName));

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": {