@bastani/atomic 0.9.0-alpha.1 → 0.9.0-alpha.3

package/dist/builtin/workflows/src/engine/runtime.ts

@@ -0,0 +1,160 @@
+import type { RunSnapshot } from "../shared/store-types.js";
+import type { Store } from "../shared/store.js";
+import type { StageOptions } from "../shared/types.js";
+import type { ConcurrencyLimiter } from "../runs/shared/concurrency.js";
+import type { ParallelFailFastScope } from "../runs/foreground/executor-types.js";
+import type { WorkflowExitManager } from "../runs/foreground/executor-exit-manager.js";
+import type { ContinuationReplayIndex } from "../runs/foreground/executor-continuation.js";
+import type { StageScheduler } from "../runs/foreground/executor-scheduler.js";
+import type { StageControlRegistry } from "../runs/foreground/stage-control-registry.js";
+import type { StageAdapters } from "../runs/foreground/stage-runner.js";
+import type { LiveStageRuntime, StageMcpScope, StageContextWithMeta } from "../runs/foreground/executor-stage-types.js";
+import { createWorkflowStageFactory } from "../runs/foreground/executor-stage-factory.js";
+import { createWorkflowBoundaryFactory, type WorkflowBoundaryStage } from "../runs/foreground/executor-child-boundary.js";
+import type { GraphFrontierTracker } from "./graph-inference.js";
+import type { EngineChildRunOptions, EngineStageRuntimeOptions, EngineWorkflowBoundaryOptions } from "./options.js";
+
+export interface EngineRuntimeInput {
+  readonly runId: string;
+  readonly depth: number;
+  readonly runSnapshot: RunSnapshot;
+  readonly activeStore: Store;
+  readonly stageOptions: EngineStageRuntimeOptions;
+  readonly workflowBoundaryOptions: EngineWorkflowBoundaryOptions;
+  readonly childRunOptions: EngineChildRunOptions;
+  readonly parentRootRunId?: string;
+  readonly adapters: StageAdapters;
+  readonly signal: AbortSignal;
+  readonly tracker: GraphFrontierTracker;
+  readonly scheduler: StageScheduler;
+  readonly replayIndex: ContinuationReplayIndex;
+  readonly limiter: ConcurrencyLimiter;
+  readonly inputRuntimeDefaults: Partial<StageOptions>;
+  readonly workflowInvocationCwd: string;
+  readonly stageRegistry: StageControlRegistry;
+  readonly exit: WorkflowExitManager;
+  readonly classifyExecutorFailure: LiveStageRuntime["classifyExecutorFailure"];
+}
+
+export interface EngineSpawnAgentStageOptions {
+  readonly kind?: "agent";
+  readonly options?: StageOptions;
+  readonly failFastScope?: ParallelFailFastScope;
+}
+
+export interface EngineSpawnWorkflowBoundaryOptions {
+  readonly kind: "workflow-boundary";
+  readonly replayKey: string;
+}
+
+export type EngineSpawnStageOptions = EngineSpawnAgentStageOptions | EngineSpawnWorkflowBoundaryOptions;
+
+export interface EngineAgentStageHandle {
+  readonly kind: "agent";
+  readonly context: StageContextWithMeta;
+}
+
+export interface EngineWorkflowBoundaryHandle {
+  readonly kind: "workflow-boundary";
+  readonly boundary: WorkflowBoundaryStage;
+}
+
+export type StageHandle = EngineAgentStageHandle | EngineWorkflowBoundaryHandle;
+
+export class EngineRuntime {
+  readonly runId: string;
+  readonly depth: number;
+  readonly activeStore: Store;
+  readonly childRunOptions: EngineChildRunOptions;
+  readonly parentRootRunId?: string;
+  readonly adapters: StageAdapters;
+  readonly signal: AbortSignal;
+  readonly tracker: GraphFrontierTracker;
+  readonly exit: WorkflowExitManager;
+  readonly inputRuntimeDefaults: Partial<StageOptions>;
+  readonly workflowInvocationCwd: string;
+
+  private readonly spawnAgentStage: (
+    name: string,
+    options?: StageOptions,
+    stageFailFastScope?: ParallelFailFastScope,
+  ) => StageContextWithMeta;
+  private readonly spawnWorkflowBoundary: (name: string, replayKey: string) => WorkflowBoundaryStage;
+
+  constructor(input: EngineRuntimeInput) {
+    this.runId = input.runId;
+    this.depth = input.depth;
+    this.activeStore = input.activeStore;
+    this.childRunOptions = input.childRunOptions;
+    this.parentRootRunId = input.parentRootRunId;
+    this.adapters = input.adapters;
+    this.signal = input.signal;
+    this.tracker = input.tracker;
+    this.exit = input.exit;
+    this.inputRuntimeDefaults = input.inputRuntimeDefaults;
+    this.workflowInvocationCwd = input.workflowInvocationCwd;
+
+    // The runtime only wires host-injected ports; stage sessions are still
+    // created lazily by the stage runner through input.adapters.agentSession.
+    this.spawnAgentStage = createWorkflowStageFactory({
+      runId: input.runId,
+      activeStore: input.activeStore,
+      opts: input.stageOptions,
+      adapters: input.adapters,
+      signal: input.signal,
+      tracker: input.tracker,
+      scheduler: input.scheduler,
+      replayIndex: input.replayIndex,
+      limiter: input.limiter,
+      inputRuntimeDefaults: input.inputRuntimeDefaults,
+      workflowInvocationCwd: input.workflowInvocationCwd,
+      stageRegistry: input.stageRegistry,
+      exit: input.exit,
+      classifyExecutorFailure: input.classifyExecutorFailure,
+      createMcpScope: (stageId, options) => this.createMcpScope(stageId, options),
+    });
+    this.spawnWorkflowBoundary = createWorkflowBoundaryFactory({
+      runId: input.runId,
+      runSnapshot: input.runSnapshot,
+      activeStore: input.activeStore,
+      opts: input.workflowBoundaryOptions,
+      tracker: input.tracker,
+      replayIndex: input.replayIndex,
+      registerWorkflowExitCleanup: input.exit.registerWorkflowExitCleanup,
+      workflowExitSkippedReason: input.exit.workflowExitSkippedReason,
+      classifyExecutorFailure: input.classifyExecutorFailure,
+    });
+  }
+
+  spawnStage(name: string, opts: EngineSpawnWorkflowBoundaryOptions): EngineWorkflowBoundaryHandle;
+  spawnStage(name: string, opts?: EngineSpawnAgentStageOptions): EngineAgentStageHandle;
+  spawnStage(name: string, opts: EngineSpawnStageOptions = {}): StageHandle {
+    if (opts.kind === "workflow-boundary") {
+      return { kind: "workflow-boundary", boundary: this.spawnWorkflowBoundary(name, opts.replayKey) };
+    }
+    return { kind: "agent", context: this.spawnAgentStage(name, opts.options, opts.failFastScope) };
+  }
+
+  readonly stage = (name: string, options?: StageOptions, failFastScope?: ParallelFailFastScope): StageContextWithMeta => {
+    const handle = this.spawnStage(name, {
+      kind: "agent",
+      ...(options !== undefined ? { options } : {}),
+      ...(failFastScope !== undefined ? { failFastScope } : {}),
+    });
+    return handle.context;
+  };
+
+  private createMcpScope(stageId: string, options: StageOptions | undefined): StageMcpScope {
+    const allow = options?.mcp?.allow ?? null;
+    const deny = options?.mcp?.deny ?? null;
+    const hasScope = allow !== null || deny !== null;
+    return {
+      apply: () => {
+        if (this.childRunOptions.mcp && hasScope) this.childRunOptions.mcp.setScope(stageId, allow, deny);
+      },
+      clear: () => {
+        if (this.childRunOptions.mcp && hasScope) this.childRunOptions.mcp.clearScope(stageId);
+      },
+    };
+  }
+}

package/dist/builtin/workflows/src/extension/workflow-module-loader.ts

@@ -7,8 +7,9 @@
  */
 
 import { createJiti } from "jiti/static";
+import * as typeboxModule from "typebox";
 import * as workflowsSdkSurface from "../sdk-surface.js";
-import { isBrandedWorkflowDefinition } from "../workflows/define-workflow.js";
+import { isBrandedWorkflowDefinition } from "../authoring/workflow.js";
 import deepResearchCodebase from "../../builtin/deep-research-codebase.js";
 import goal from "../../builtin/goal.js";
 import openClaudeDesign from "../../builtin/open-claude-design.js";
@@ -16,6 +17,7 @@ import ralph from "../../builtin/ralph.js";
 
 const WORKFLOWS_MODULE_SPECIFIER = "@bastani/workflows";
 const WORKFLOWS_BUILTIN_MODULE_SPECIFIER = `${WORKFLOWS_MODULE_SPECIFIER}/builtin`;
+const TYPEBOX_MODULE_SPECIFIER = "typebox";
 // Keep this in sync with index.ts through sdk-surface.ts.
 const WORKFLOWS_SDK_MODULE: Record<string, unknown> = {
   ...workflowsSdkSurface,
@@ -26,9 +28,13 @@ const WORKFLOWS_BUILTIN_MODULE: Record<string, unknown> = {
   openClaudeDesign,
   ralph,
 };
+const TYPEBOX_MODULE: Record<string, unknown> = {
+  ...typeboxModule,
+};
 const WORKFLOWS_VIRTUAL_MODULES: Record<string, unknown> = {
   [WORKFLOWS_MODULE_SPECIFIER]: WORKFLOWS_SDK_MODULE,
   [WORKFLOWS_BUILTIN_MODULE_SPECIFIER]: WORKFLOWS_BUILTIN_MODULE,
+  [TYPEBOX_MODULE_SPECIFIER]: TYPEBOX_MODULE,
   [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/deep-research-codebase`]: { default: deepResearchCodebase },
   [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/goal`]: { default: goal },
   [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/open-claude-design`]: { default: openClaudeDesign },
@@ -95,10 +101,10 @@ export function validateWorkflowDefinitionShape(value: unknown): string | null {
   const d = value as Record<string, unknown>;
 
   if (d["__piWorkflow"] !== true) {
-    return "missing or incorrect __piWorkflow sentinel (expected true); export a workflow from defineWorkflow(...).compile()";
+    return "missing or incorrect __piWorkflow sentinel (expected true); export a workflow from workflow({...})";
   }
   if (!isBrandedWorkflowDefinition(value)) {
-    return "workflow definition is not produced by defineWorkflow(...).compile(); hand-rolled __piWorkflow objects are not supported";
+    return "workflow definition is not produced by workflow({...}); hand-rolled __piWorkflow objects are not supported";
   }
   if (typeof d["name"] !== "string" || (d["name"] as string).trim().length === 0) {
     return "name must be a non-empty string";

package/dist/builtin/workflows/src/extension/workflow-prompts.ts

@@ -19,5 +19,7 @@ export const DEFAULT_PROMPT_GUIDANCE: string[] = [
   - For transcripts, avoid reading whole session transcripts at once. Use \`stages\` or \`stage\` to get \`sessionFile\`/\`transcriptPath\`, quote the exact path without rewriting separators (preserve Windows backslashes), search it with \`rg\`/\`grep\`, and read small relevant ranges; use \`transcript\` with explicit \`tail\` or \`limit\` only for quick recent-context checks.
   - If a user asks to create or edit a workflow, use the create-spec skill when available and ask detailed clarifying questions until you understand its purpose, inputs, stages, handoffs, validation, success criteria, and selected starter pattern. Then read the workflow docs/examples and implement the workflow from the created spec directly as a TypeScript definition. After you implement the workflow, reload it to access it and run it with test inputs to validate it works as intended before presenting it to the user.
     - Tip: when designing workflows, implement it in a way that you pass information from stage to stage by writing it to a file or artifact (either deterministic or model-driven), pass the path with \`reads\`, and explicitly prompt the downstream agent with wording like \`Read the file at <path>...\`; do not inject large \`previous\` payloads or session history into the next prompt unless explicitly requested to.
-  - If you run \`ralph\` or \`goal\` workflow, define an objective that includes tight scope, concrete and verifiable done criteria, and validation steps; then monitor progress as above instead of doing parallel implementation yourself.`,
+  - Prefer using the \`goal\` workflow for small fixes/quick fixes and the \`ralph\` workflow for tasks that are non-trivial (over 2K LoC estimated diff).
+    - Adjust the \`max_loops\` based on task complexity (estimated LoC and number of unique files that are touched).
+    - Define an objective that includes tight scope, concrete and verifiable done criteria, and validation steps; then monitor progress as above instead of doing parallel implementation yourself.`,
 ];

package/dist/builtin/workflows/src/extension/workflow-schema.ts

@@ -43,23 +43,6 @@ const JsonSchemaObject = Type.Unsafe<Record<string, unknown>>({
   description: "Plain JSON Schema used as final-answer tool arguments for this workflow item.",
 });
 
-const BashCommandRuleSchema = Type.Union([
-  Type.String(),
-  Type.Object({ prefix: Type.String() }, { additionalProperties: false }),
-  Type.Object({ glob: Type.String() }, { additionalProperties: false }),
-  Type.Object({
-    regex: Type.String(),
-    flags: Type.Optional(Type.String()),
-  }, { additionalProperties: false }),
-]);
-
-const BashCommandPolicySchema = Type.Object({
-  default: Type.Optional(Type.Union([Type.Literal("allow"), Type.Literal("deny")])),
-  allow: Type.Optional(Type.Array(BashCommandRuleSchema)),
-  deny: Type.Optional(Type.Array(BashCommandRuleSchema)),
-  match: Type.Optional(Type.Union([Type.Literal("whole"), Type.Literal("segments")])),
-}, { additionalProperties: false });
-
 const StageSessionOptionProperties = {
   schema: Type.Optional(JsonSchemaObject),
   cwd: Type.Optional(Type.String()),
@@ -76,7 +59,6 @@ const StageSessionOptionProperties = {
   })),
   tools: Type.Optional(Type.Array(Type.String())),
   customTools: Type.Optional(Type.Array(SdkSessionOptionArrayElementSchema("customTools"))),
-  bashPolicy: Type.Optional(BashCommandPolicySchema),
   resourceLoader: Type.Optional(SdkSessionOptionSchema("resourceLoader")),
   sessionManager: Type.Optional(SdkSessionOptionSchema("sessionManager")),
   settingsManager: Type.Optional(SdkSessionOptionSchema("settingsManager")),

package/dist/builtin/workflows/src/index.ts

@@ -6,5 +6,3 @@
 // Add new non-cyclic public runtime exports to sdk-surface.ts so the Bun
 // virtual SDK used by workflow discovery stays in lockstep with this entry.
 export * from "./sdk-surface.js";
-
-// Note: `Type` / `Static` / `TSchema` are re-exported via ./sdk-surface.js.

package/dist/builtin/workflows/src/runs/background/runner.ts

@@ -14,7 +14,7 @@
  * cross-ref: spec detached-runner
  */
 
-import type { WorkflowDefinition, WorkflowExecutionMode, WorkflowInputValues } from "../../shared/types.js";
+import type { WorkflowDefinition, WorkflowExecutionMode, WorkflowInputValues, WorkflowOutputValues } from "../../shared/types.js";
 import type { RunOpts, RunResult } from "../foreground/executor.js";
 import type { CancellationRegistry } from "./cancellation-registry.js";
 import type { JobTracker } from "./job-tracker.js";
@@ -85,8 +85,11 @@ export function buildDetachedAccepted(
  * the store remains source of truth for run status. Cancellation is wired
  * through the provided (or default) CancellationRegistry.
  */
-export function runDetached<TInputs extends WorkflowInputValues>(
-  def: WorkflowDefinition<TInputs>,
+export function runDetached<
+  TInputs extends WorkflowInputValues,
+  TRunInputs extends WorkflowInputValues = TInputs,
+>(
+  def: WorkflowDefinition<TInputs, WorkflowOutputValues, TRunInputs>,
   inputs: Readonly<Record<string, unknown>>,
   opts: DetachedRunOpts = {},
 ): DetachedAccepted {

package/dist/builtin/workflows/src/runs/foreground/executor-child-boundary.ts

@@ -4,12 +4,12 @@ import type { WorkflowChildResult } from "../../shared/types.js";
 import { appendStageEnd, appendStageStart } from "../../shared/persistence-session-entries.js";
 import { elapsedStageMs } from "../../shared/timing.js";
 import type { WorkflowFailure } from "../../shared/workflow-failures.js";
-import type { RunOpts } from "./executor-types.js";
+import type { EngineWorkflowBoundaryOptions } from "../../engine/options.js";
 import type { ContinuationReplayIndex } from "./executor-continuation.js";
 import { sameStringSet } from "./executor-continuation.js";
 import { applyFailureToStage, stageReplayFields } from "./executor-lifecycle.js";
 import { cloneWorkflowChildReplaySnapshot, cloneWorkflowChildValue } from "./executor-child-helpers.js";
-import type { GraphFrontierTracker } from "../shared/graph-inference.js";
+import type { GraphFrontierTracker } from "../../engine/graph-inference.js";
 import type { WorkflowExitCleanup } from "./executor-types.js";
 import { makeParentWorkflowExitAbortReason } from "./executor-abort.js";
 
@@ -71,7 +71,7 @@ export function createWorkflowBoundaryFactory(input: {
   readonly runId: string;
   readonly runSnapshot: RunSnapshot;
   readonly activeStore: Store;
-  readonly opts: RunOpts;
+  readonly opts: EngineWorkflowBoundaryOptions;
   readonly tracker: GraphFrontierTracker;
   readonly replayIndex: ContinuationReplayIndex;
   readonly registerWorkflowExitCleanup: (stageId: string, cleanup: WorkflowExitCleanup) => () => void;

package/dist/builtin/workflows/src/runs/foreground/executor-child-helpers.ts

@@ -1,4 +1,4 @@
-import { isBrandedWorkflowDefinition } from "../../workflows/define-workflow.js";
+import { isBrandedWorkflowDefinition } from "../../authoring/workflow.js";
 import type {
   WorkflowChildResult,
   WorkflowDefinition,
@@ -16,7 +16,7 @@ function workflowChildSerializationMessage(err: unknown): string {
 }
 
 export function isWorkflowDefinition(value: unknown): value is WorkflowDefinition {
-  if (!isBrandedWorkflowDefinition(value)) return false;
+  if (value === null || typeof value !== "object" || !isBrandedWorkflowDefinition(value)) return false;
   const record = value as Partial<WorkflowDefinition>;
   return record.__piWorkflow === true &&
     typeof record.name === "string" && record.name.trim().length > 0 &&
@@ -27,9 +27,9 @@ export function isWorkflowDefinition(value: unknown): value is WorkflowDefinitio
 
 export function workflowDefinitionRequirementMessage(callSite: string, value: unknown): string {
   if (value !== null && typeof value === "object" && (value as { __piWorkflow?: unknown }).__piWorkflow === true) {
-    return `atomic-workflows: ${callSite} requires a compiled workflow definition produced by defineWorkflow(...).compile(); hand-rolled __piWorkflow objects are not supported`;
+    return `atomic-workflows: ${callSite} requires a workflow definition produced by workflow({...}); hand-rolled __piWorkflow objects are not supported`;
   }
-  return `atomic-workflows: ${callSite} requires a compiled workflow definition`;
+  return `atomic-workflows: ${callSite} requires a workflow definition`;
 }
 
 export function cloneWorkflowChildReplaySnapshot(snapshot: WorkflowChildReplaySnapshot): WorkflowChildReplaySnapshot {

package/dist/builtin/workflows/src/runs/foreground/executor-child-workflow.ts

@@ -1,158 +1 @@
-import type {
-  WorkflowChildResult,
-  WorkflowDefinition,
-  WorkflowInputValues,
-  WorkflowOutputValues,
-  WorkflowRunChildOptions,
-} from "../../shared/types.js";
-import type { WorkflowChildRunRef } from "../../shared/store-types.js";
-import type { RunOpts, RunResult } from "./executor-types.js";
-import type { WorkflowExitManager } from "./executor-exit-manager.js";
-import type { WorkflowBoundaryStage } from "./executor-child-boundary.js";
-import { findWorkflowExitSignal, isWorkflowExitStatus, makeParentWorkflowExitAbortReason } from "./executor-abort.js";
-import { selectWorkflowOutputs } from "./executor-outputs.js";
-import { resolveAndValidateInputs } from "./executor-inputs.js";
-import {
-  isWorkflowDefinition,
-  workflowChildReplaySnapshot,
-  workflowDefinitionRequirementMessage,
-} from "./executor-child-helpers.js";
-
-export function createChildWorkflowRunner(input: {
-  readonly runId: string;
-  readonly depth: number;
-  readonly opts: RunOpts;
-  readonly exit: WorkflowExitManager;
-  readonly ownController: AbortController;
-  readonly resolveWorkflowCwd: () => string;
-  readonly nextWorkflowBoundaryReplayKey: (name: string) => string;
-  readonly startWorkflowBoundaryStage: (name: string, replayKey: string) => WorkflowBoundaryStage;
-  readonly runWorkflow: <TInputs extends WorkflowInputValues>(
-    def: WorkflowDefinition<TInputs>,
-    inputs: Readonly<Record<string, unknown>>,
-    opts?: RunOpts,
-  ) => Promise<RunResult>;
-}): <TChildInputs extends WorkflowInputValues, TChildOutputs extends WorkflowOutputValues>(
-  child: WorkflowDefinition<TChildInputs, TChildOutputs>,
-  options?: WorkflowRunChildOptions<TChildInputs>,
-) => Promise<WorkflowChildResult<TChildOutputs>> {
-  return async <TChildInputs extends WorkflowInputValues, TChildOutputs extends WorkflowOutputValues>(
-    child: WorkflowDefinition<TChildInputs, TChildOutputs>,
-    options: WorkflowRunChildOptions<TChildInputs> = {},
-  ): Promise<WorkflowChildResult<TChildOutputs>> => {
-    input.exit.throwIfWorkflowExitSelected();
-    if (!isWorkflowDefinition(child)) throw new Error(workflowDefinitionRequirementMessage("ctx.workflow(definition)", child));
-    const childName = child.normalizedName;
-    const boundaryName = options.stageName ?? `workflow:${childName}`;
-    const boundaryReplayKey = input.nextWorkflowBoundaryReplayKey(boundaryName);
-    const boundary = input.startWorkflowBoundaryStage(boundaryName, boundaryReplayKey);
-    let childRunId: string | undefined;
-    let detachParentAbort: (() => void) | undefined;
-    try {
-      if (boundary.replayedChild !== undefined) {
-        await Promise.resolve();
-        input.exit.throwIfWorkflowExitSelected();
-        boundary.finalizeReplay();
-        return boundary.replayedChild as WorkflowChildResult<TChildOutputs>;
-      }
-
-      const childInputs = resolveAndValidateInputs(child.inputs, options.inputs ?? {}, `child workflow "${childName}" (${child.name})`);
-      input.exit.throwIfWorkflowExitSelected();
-
-      childRunId = crypto.randomUUID();
-      const childController = new AbortController();
-      const childRef: WorkflowChildRunRef = { alias: childName, workflow: child.normalizedName, runId: childRunId };
-      boundary.linkChildRun(childRef, childController);
-
-      const abortChildFromParent = (): void => {
-        const parentExit = findWorkflowExitSignal(input.ownController.signal.reason, input.exit.exitScope);
-        childController.abort(parentExit !== undefined ? makeParentWorkflowExitAbortReason(parentExit.reason) : input.ownController.signal.reason);
-      };
-      if (input.ownController.signal.aborted) abortChildFromParent();
-      else {
-        input.ownController.signal.addEventListener("abort", abortChildFromParent, { once: true });
-        detachParentAbort = () => input.ownController.signal.removeEventListener("abort", abortChildFromParent);
-      }
-      input.exit.throwIfWorkflowExitSelected();
-      input.opts.cancellation?.register(childRunId, childController);
-      input.exit.throwIfWorkflowExitSelected();
-
-      const {
-        runId: _parentRunId,
-        continuation: _parentContinuation,
-        deferWorkflowStart: _parentDeferWorkflowStart,
-        parentRun: _parentRun,
-        onRunStart: _parentOnRunStart,
-        onRunEnd: _parentOnRunEnd,
-        ...childBaseOpts
-      } = input.opts;
-      const childRunPromise = input.runWorkflow(child, childInputs, {
-        ...childBaseOpts,
-        runId: childRunId,
-        cwd: input.resolveWorkflowCwd(),
-        depth: input.depth + 1,
-        ...(input.opts.registry !== undefined ? { registry: input.opts.registry } : {}),
-        parentRun: {
-          runId: input.runId,
-          stageId: boundary.id,
-          rootRunId: input.opts.parentRun?.rootRunId ?? input.runId,
-        },
-        signal: childController.signal,
-        deferWorkflowStart: false,
-      });
-      boundary.observeChildRun(childRunPromise);
-      const childRun = await childRunPromise;
-      input.exit.throwIfWorkflowExitSelected();
-
-      if (!isWorkflowExitStatus(childRun.status)) {
-        const failedChildStage = childRun.stages.find((stage) => stage.failureKind !== undefined);
-        throw new Error(
-          `atomic-workflows: child workflow "${childName}" (${child.name}) failed with status ${childRun.status}${childRun.error !== undefined ? `: ${childRun.error}` : ""}`,
-          {
-            cause: {
-              ...(failedChildStage?.failureKind !== undefined ? { code: failedChildStage.failureKind } : {}),
-              ...(failedChildStage?.failureMessage !== undefined ? { message: failedChildStage.failureMessage } : {}),
-            },
-          },
-        );
-      }
-
-      const outputs = selectWorkflowOutputs(child, childRun.result);
-      const childExited = childRun.exited === true || childRun.status !== "completed";
-      const childResult: WorkflowChildResult<TChildOutputs> = childExited
-        ? {
-            workflow: child.normalizedName,
-            runId: childRun.runId,
-            status: childRun.status,
-            exited: true,
-            outputs: outputs as Partial<TChildOutputs>,
-            ...(childRun.exitReason !== undefined ? { exitReason: childRun.exitReason } : {}),
-          }
-        : {
-            workflow: child.normalizedName,
-            runId: childRun.runId,
-            status: "completed",
-            exited: false,
-            outputs: outputs as TChildOutputs,
-          };
-      const workflowChild = workflowChildReplaySnapshot(childName, childResult);
-      const outputKeys = Object.keys(outputs);
-      boundary.complete(
-        `Workflow "${child.name}" ${childRun.status} (runId: ${childRun.runId}; outputs: ${outputKeys.length > 0 ? outputKeys.join(", ") : "(none)"})`,
-        workflowChild,
-      );
-      return childResult;
-    } catch (err) {
-      const exit = findWorkflowExitSignal(err, input.exit.exitScope) ?? findWorkflowExitSignal(input.ownController.signal.reason, input.exit.exitScope);
-      if (exit !== undefined) {
-        await boundary.skipForWorkflowExit(exit.reason);
-        throw exit;
-      }
-      boundary.fail(err);
-      throw err;
-    } finally {
-      detachParentAbort?.();
-      if (childRunId !== undefined) input.opts.cancellation?.unregister(childRunId);
-    }
-  };
-}
+export { createChildWorkflowRunner } from "../../engine/primitives/workflow.js";

package/dist/builtin/workflows/src/runs/foreground/executor-direct-helpers.ts

@@ -15,7 +15,7 @@ import type {
   WorkflowTaskResult,
   WorkflowTaskStep,
 } from "../../shared/types.js";
-import { stampWorkflowDefinition } from "../../workflows/define-workflow.js";
+import { stampWorkflowDefinition } from "../../authoring/workflow.js";
 import { classifyWorkflowFailure } from "../../shared/workflow-failures.js";
 import { buildModelCandidatesFromCatalog, validateWorkflowModels, workflowModelId } from "../shared/model-fallback.js";
 import {

package/dist/builtin/workflows/src/runs/foreground/executor-outputs.ts

@@ -31,7 +31,7 @@ function assertWorkflowOutputsExplicit(
   for (const key of Object.keys(sourceOutput)) {
     if (!hasOwnWorkflowOutput(declarations, key)) {
       throw new Error(
-        `atomic-workflows: ${scope} returned undeclared output "${key}"; declare it with .output("${key}", Type....) or remove it from the .run() return`,
+        `atomic-workflows: ${scope} returned undeclared output "${key}"; declare it in outputs: { "${key}": Type.... } or remove it from the .run() return`,
       );
     }
   }
@@ -119,7 +119,7 @@ export function assertWorkflowExitOutputs(
   for (const key of Object.keys(sourceOutput)) {
     if (!hasOwnWorkflowOutput(declarations, key)) {
       throw new Error(
-        `atomic-workflows: ${scope} provided undeclared output "${key}"; declare it with .output("${key}", Type....) or remove it from ctx.exit({ outputs })`,
+        `atomic-workflows: ${scope} provided undeclared output "${key}"; declare it in outputs: { "${key}": Type.... } or remove it from ctx.exit({ outputs })`,
       );
     }
   }

package/dist/builtin/workflows/src/runs/foreground/executor-prompt-nodes.ts

@@ -5,7 +5,7 @@ import { stageUiBroker } from "../../shared/stage-ui-broker.js";
 import { appendStageEnd, appendStageStart } from "../../shared/persistence-session-entries.js";
 import { elapsedStageMs } from "../../shared/timing.js";
 import type { WorkflowFailure } from "../../shared/workflow-failures.js";
-import type { GraphFrontierTracker } from "../shared/graph-inference.js";
+import type { GraphFrontierTracker } from "../../engine/graph-inference.js";
 import type { RunOpts, WorkflowExitCleanup } from "./executor-types.js";
 import type { ContinuationReplayIndex } from "./executor-continuation.js";
 import { getPromptAnswerState, sameStringSet } from "./executor-continuation.js";