fix(workflow): honor nested workflow context

Author: Waishnav

src/workflow-api.ts

@@ -172,6 +172,7 @@ export interface WorkflowApiDeps {
     nestDepth: number;
   }) => Promise<unknown>;
   nestDepth?: number;
+  runtime?: WorkflowApiRuntime;
 }
 
 export interface WorkflowApi extends WorkflowSandboxApi {
@@ -242,6 +243,18 @@ export class WorkflowSemaphore {
   }
 }
 
+export interface WorkflowApiRuntime {
+  semaphore: WorkflowSemaphore;
+  callIndex: number;
+}
+
+export function createWorkflowApiRuntime(concurrency: number): WorkflowApiRuntime {
+  return {
+    semaphore: new WorkflowSemaphore(Math.max(1, concurrency)),
+    callIndex: 0,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // API factory
 // ---------------------------------------------------------------------------
@@ -250,8 +263,8 @@ const phaseAls = new AsyncLocalStorage<string>();
 
 export function createWorkflowApi(deps: WorkflowApiDeps): WorkflowApi {
   const nestDepth = deps.nestDepth ?? 0;
-  const semaphore = new WorkflowSemaphore(Math.max(1, deps.concurrency));
-  let callIndex = 0;
+  const runtime = deps.runtime ?? createWorkflowApiRuntime(deps.concurrency);
+  const semaphore = runtime.semaphore;
 
   const agent = async (prompt: unknown, opts: unknown = {}): Promise<unknown> => {
     if (typeof prompt !== "string" || !prompt.trim()) {
@@ -272,8 +285,8 @@ export function createWorkflowApi(deps: WorkflowApiDeps): WorkflowApi {
     const phase = agentOpts.phase ?? phaseAls.getStore();
     const isolation: AgentIsolationMode =
       agentOpts.isolation === "worktree" ? "worktree" : "shared";
-    const index = callIndex;
-    callIndex += 1;
+    const index = runtime.callIndex;
+    runtime.callIndex += 1;
 
     const cacheKeyInput = buildAgentCacheKeyInput({
       prompt,
@@ -664,7 +677,7 @@ export function createWorkflowApi(deps: WorkflowApiDeps): WorkflowApi {
     budget: createStubBudget(),
     workflow: workflow as WorkflowSandboxApi["workflow"],
     meta: deps.meta,
-    getCallCount: () => callIndex,
+    getCallCount: () => runtime.callIndex,
     getNestDepth: () => nestDepth,
   };
 }

src/workflow-engine.test.ts

@@ -522,25 +522,27 @@ import type { LocalAgentProfile } from "./local-agent-profiles.js";
   await writeFile(
     childPath,
     `
-export const meta = { name: 'child', description: 'nested' }
+export const meta = { name: 'child', description: 'nested', defaultProvider: 'claude' }
 return await agent('nested-prompt')
 `,
   );
 
   const prompts: string[] = [];
+  const providers: string[] = [];
   const { result, callCount } = await executeWorkflow({
     source: `
-export const meta = { name: 'parent', description: 'p' }
+export const meta = { name: 'parent', description: 'p', defaultProvider: 'codex' }
 const a = await agent('parent-prompt')
 const nested = await workflow({ scriptPath: ${JSON.stringify(childPath)} })
 return { a, nested }
 `,
     runId: run.id,
     journal: store,
     workspaceRoot: dir,
-    enabledProviders: ["codex"],
+    enabledProviders: ["codex", "claude"],
     runProvider: async (input) => {
       prompts.push(input.prompt);
+      providers.push(input.provider);
       return { finalResponse: `R:${input.prompt}` };
     },
     resolveNestedSource: async (ref) => {
@@ -558,6 +560,7 @@ return { a, nested }
   });
   assert.equal(callCount, 2);
   assert.deepEqual(prompts, ["parent-prompt", "nested-prompt"]);
+  assert.deepEqual(providers, ["codex", "claude"]);
 
   // depth 2 must fail
   await assert.rejects(

src/workflow-engine.ts

@@ -8,8 +8,10 @@ import { parseWorkflowScript, type ParsedWorkflowScript } from "./workflow-scrip
 import { runWorkflowSandbox } from "./workflow-sandbox.js";
 import {
   createWorkflowApi,
+  createWorkflowApiRuntime,
   type CreateAgentWorktree,
   type WorkflowApi,
+  type WorkflowApiRuntime,
   type WorkflowJournal,
   type WorkflowReplay,
   type WorkflowRunProvider,
@@ -46,6 +48,8 @@ export interface ExecuteWorkflowOptions {
   resolveNestedSource?: (nameOrRef: string | { scriptPath: string }) => string | Promise<string>;
   nestDepth?: number;
   timeoutMs?: number;
+  /** Shared call counter/semaphore for nested workflow execution. */
+  runtime?: WorkflowApiRuntime;
   /** Optional hooks after API construction (tests). */
   onApi?: (api: WorkflowApi) => void;
 }
@@ -73,6 +77,7 @@ export async function executeWorkflow(
     resolveWorkflowConcurrency(parsed.meta.concurrency, availableParallelism());
 
   const resolveNestedSource = options.resolveNestedSource;
+  const runtime = options.runtime ?? createWorkflowApiRuntime(concurrency);
 
   // Shared callIndex/semaphore for nested scripts via parent API path.
   const api = createWorkflowApi({
@@ -89,17 +94,25 @@ export async function executeWorkflow(
     runProvider: options.runProvider,
     createWorktree: options.createWorktree,
     replay: options.replay,
+    runtime,
     nestDepth,
     resolveNestedSource,
     executeNested: resolveNestedSource
       ? async (input) =>
-          executeNestedOnApi({
-            parentOptions: options,
-            parentApi: api,
-            source: input.source,
-            args: input.args,
-            nestDepth: input.nestDepth,
-          })
+          (
+            await executeWorkflow({
+              ...options,
+              parsed: undefined,
+              source: input.source,
+              filename: "workflow:nested",
+              args: input.args,
+              signal,
+              concurrency,
+              runtime,
+              nestDepth: input.nestDepth,
+              onApi: undefined,
+            })
+          ).result
       : undefined,
   });
   options.onApi?.(api);
@@ -136,62 +149,6 @@ export async function executeWorkflow(
   }
 }
 
-/**
- * Nested script execution reusing parent's agent() call counter + semaphore
- * by constructing a child API that shares internal state via re-entry.
- *
- * Implementation: run child sandbox with a new API that has nestDepth+1 but
- * delegates agent/parallel/pipeline to the parent API (same callIndex).
- */
-async function executeNestedOnApi(input: {
-  parentOptions: ExecuteWorkflowOptions;
-  parentApi: WorkflowApi;
-  source: string;
-  args: JsonValue | undefined;
-  nestDepth: number;
-}): Promise<unknown> {
-  if (input.nestDepth > WORKFLOW_MAX_NEST_DEPTH_LOCAL) {
-    throw new WorkflowEngineError(
-      "nest_depth",
-      `workflow() nesting limited to ${WORKFLOW_MAX_NEST_DEPTH_LOCAL} level`,
-    );
-  }
-  const parsed = parseWorkflowScript(input.source, {
-    filename: "workflow:nested",
-  });
-
-  // Child surface: reuse parent agent/parallel/pipeline/phase/log/budget/workflow
-  // so callIndex + semaphore stay shared. Override args + meta for the child body.
-  const childApi: WorkflowApi = {
-    agent: input.parentApi.agent,
-    parallel: input.parentApi.parallel,
-    pipeline: input.parentApi.pipeline,
-    phase: input.parentApi.phase,
-    log: input.parentApi.log,
-    args: input.args,
-    budget: input.parentApi.budget,
-    // Child workflow() must see nestDepth via a wrapper that throws at depth>1.
-    workflow: async (...args: unknown[]) => {
-      throw new WorkflowEngineError(
-        "nest_depth",
-        `workflow() nesting limited to ${WORKFLOW_MAX_NEST_DEPTH_LOCAL} level`,
-      );
-    },
-    meta: parsed.meta,
-    getCallCount: () => input.parentApi.getCallCount(),
-    getNestDepth: () => input.nestDepth,
-  };
-
-  return runWorkflowSandbox({
-    parsed,
-    api: childApi,
-    timeoutMs: input.parentOptions.timeoutMs ?? WORKFLOW_HOST_TIMEOUT_MS,
-    signal: input.parentOptions.signal,
-  });
-}
-
-const WORKFLOW_MAX_NEST_DEPTH_LOCAL = 1;
-
 export function mapEngineErrorKind(error: unknown): WorkflowErrorKind {
   if (error instanceof WorkflowEngineError) {
     return error.kind;