@trailstep/core 0.2.0 → 0.3.0

package/dist/index.js

@@ -121,7 +121,8 @@ var PLACEHOLDER_NAMES = /* @__PURE__ */ new Set([
   "promptFile",
   "outputFile",
   "model",
-  "thinking"
+  "thinking",
+  "sessionId"
 ]);
 var CONDITIONAL_NAMES = /* @__PURE__ */ new Set(["model", "thinking"]);
 var TEMPLATE_TOKEN_PATTERN = /^{{([#/]?)([A-Za-z][A-Za-z0-9]*)}}$/;
@@ -131,7 +132,8 @@ function renderCustomProviderArgs(options) {
     ...options.values.promptFile === void 0 ? {} : { promptFile: options.values.promptFile },
     ...options.values.outputFile === void 0 ? {} : { outputFile: options.values.outputFile },
     ...optionalNonEmptyString(options.values.model) === void 0 ? {} : { model: optionalNonEmptyString(options.values.model) },
-    ...options.values.thinking === void 0 ? {} : { thinking: options.values.thinking }
+    ...options.values.thinking === void 0 ? {} : { thinking: options.values.thinking },
+    ...options.values.sessionId === void 0 ? {} : { sessionId: options.values.sessionId }
   };
   return renderRange({
     argv: options.argv,
@@ -665,10 +667,54 @@ function parseWorking(path, value, diagnostics) {
   const args = parseOptionalStringArray(`${path}.args`, value.args, diagnostics);
   const prompt = parsePrompt(`${path}.prompt`, value.prompt, diagnostics);
   const output = parseOutput(`${path}.output`, value.output, diagnostics);
-  if (command === void 0 || prompt === void 0 || output === void 0) {
+  const followUp = parseFollowUp(`${path}.followUp`, value.followUp, diagnostics);
+  if (command === void 0 || prompt === void 0 || output === void 0 || followUp === null) {
     return void 0;
   }
-  return { supported: true, command, ...args === void 0 ? {} : { args }, prompt, output };
+  return {
+    supported: true,
+    command,
+    ...args === void 0 ? {} : { args },
+    prompt,
+    output,
+    ...followUp === void 0 ? {} : { followUp }
+  };
+}
+function parseFollowUp(path, value, diagnostics) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value) || typeof value.supported !== "boolean") {
+    diagnostics.push(`${path} must be an object with a boolean supported field.`);
+    return null;
+  }
+  if (!value.supported) {
+    return {
+      supported: false,
+      ...typeof value.reason === "string" ? { reason: value.reason } : {}
+    };
+  }
+  const sessionIdFlag = parseOptionalNonEmptyString(
+    `${path}.sessionIdFlag`,
+    value.sessionIdFlag,
+    diagnostics
+  );
+  if (sessionIdFlag === null) {
+    return null;
+  }
+  let resumeArgs;
+  if (value.resumeArgs !== void 0) {
+    if (!Array.isArray(value.resumeArgs) || value.resumeArgs.some((item) => typeof item !== "string")) {
+      diagnostics.push(`${path}.resumeArgs must be an array of strings when present.`);
+      return null;
+    }
+    resumeArgs = value.resumeArgs;
+  }
+  return {
+    supported: true,
+    ...sessionIdFlag === void 0 ? {} : { sessionIdFlag },
+    ...resumeArgs === void 0 ? {} : { resumeArgs }
+  };
 }
 function parseLegacyInteractive(path, value, diagnostics) {
   const parsed = parseSupportedObject(path, value, diagnostics);
@@ -2892,6 +2938,7 @@ function isPlainObject4(value) {
 
 // src/runtime/sub-prompts/run-sub-prompt.ts
 import { mkdir as mkdir6, writeFile as writeFile7 } from "fs/promises";
+import { join as join10 } from "path";
 
 // src/agent-execution/adapter-agent/run-adapter-agent-step/run-adapter-agent-step.ts
 var PROVIDER_NEUTRAL_ADAPTER_KEY = "custom";
@@ -2961,7 +3008,7 @@ function createSubmitOutputTool(schema, onOutput) {
 }
 
 // src/agent-execution/dispatch-agent-step/dispatch-agent-step.ts
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 import { resolve } from "path";
 
 // src/runtime/artifacts/step-artifacts.ts
@@ -3375,8 +3422,9 @@ var spawnInteractiveProcess2 = async ({
   env,
   signal
 }) => {
+  const executable = await resolveCliCommandForSpawn({ command, args, env });
   return await new Promise((resolve2, reject) => {
-    const child = spawn2(command, args, {
+    const child = spawn2(executable.command, executable.args, {
       cwd,
       env,
       signal,
@@ -3420,7 +3468,9 @@ function resolveStepAgentFiles(options) {
     stepDir: artifactPaths.stepDir,
     promptFile: join8(artifactPaths.stepDir, "prompt.md"),
     outputFile: artifactPaths.outputFile,
-    usageFile: artifactPaths.usageFile
+    usageFile: artifactPaths.usageFile,
+    workFile: join8(artifactPaths.stepDir, "work.txt"),
+    repairPromptFile: join8(artifactPaths.stepDir, "repair-prompt.md")
   };
 }
 
@@ -3597,9 +3647,13 @@ async function runCustomWorkingProvider(options) {
   });
   let result;
   try {
-    result = await (options.runner ?? spawnWorkingAgentProcess)({
+    const executable = await resolveCliCommandForSpawn({
       command: agentConfig.binary,
-      args,
+      args
+    });
+    result = await (options.runner ?? spawnWorkingAgentProcess)({
+      command: executable.command,
+      args: executable.args,
       cwd: options.cwd,
       shell: false,
       stdio: "inherit",
@@ -3639,7 +3693,8 @@ async function runCustomWorkingProvider(options) {
 }
 
 // src/agent-execution/working-agent/targets/manifest-provider/run-manifest-working-provider.ts
-import { writeFile as writeFile5 } from "fs/promises";
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
 
 // src/cli-provider-runtime/envelopes/envelope.ts
 function extractEnvelopeOutput(rawStdout, options) {
@@ -3788,6 +3843,50 @@ function isPlainObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/agent-execution/working-agent/prompts/build-two-phase-prompts.ts
+function buildWorkPrompt(options) {
+  return [
+    "# TrailStep working-agent task",
+    "",
+    "Do the task described below.",
+    "",
+    "When you are done, report what you did as your final answer in natural prose or markdown:",
+    "what you changed or found, the key facts a formatter would need (status intent,",
+    "summary, files changed, results), and any question you need answered if blocked.",
+    "",
+    "## Original prompt",
+    "",
+    options.prompt,
+    ""
+  ].join("\n");
+}
+function buildFormatPrompt(options) {
+  const lines = [
+    "# TrailStep format follow-up",
+    "",
+    "Reformat your last answer in THIS session to exactly one JSON object as your entire final answer, and nothing else.",
+    "Do not redo the work. Do not include prose, markdown fences, or multiple JSON values - only the JSON object itself.",
+    "",
+    "The JSON object must match this output schema:",
+    "",
+    "```json",
+    JSON.stringify(options.outputSchema, null, 2),
+    "```"
+  ];
+  if (options.validationErrors !== void 0 && options.validationErrors.length > 0) {
+    lines.push(
+      "",
+      "Your previous reformatted answer failed validation with these errors:",
+      "",
+      ...options.validationErrors.map((error) => `- ${error}`),
+      "",
+      "Fix only the formatting to satisfy the schema."
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
 // src/agent-execution/working-agent/targets/manifest-provider/run-manifest-working-provider.ts
 async function runManifestWorkingProvider(options) {
   const registration = options.config.providers?.[options.target.provider];
@@ -3802,6 +3901,18 @@ async function runManifestWorkingProvider(options) {
   }
   const thinking = options.target.thinking ?? options.role.thinking;
   const model = optionalNonEmptyString3(options.target.model);
+  const followUp = working.followUp;
+  if (followUp?.supported === true) {
+    return runTwoPhaseManifestWorking({
+      options,
+      manifest,
+      working,
+      followUp,
+      extractOutputHook: registration?.manifest.hooks?.extractOutput,
+      thinking,
+      model
+    });
+  }
   const args = renderCustomProviderArgs({
     argv: working.args ?? defaultManifestWorkingArgs({
       manifest,
@@ -3822,9 +3933,10 @@ async function runManifestWorkingProvider(options) {
   const captureStdout = working.output?.style !== "provider-output-file";
   let result;
   try {
+    const executable = await resolveCliCommandForSpawn({ command: working.command, args });
     result = await (options.runner ?? spawnWorkingAgentProcess)({
-      command: working.command,
-      args,
+      command: executable.command,
+      args: executable.args,
       cwd: options.cwd,
       shell: false,
       stdio: captureStdout ? "pipe" : "inherit",
@@ -3871,6 +3983,219 @@ async function runManifestWorkingProvider(options) {
     step: options.step
   });
 }
+async function runTwoPhaseManifestWorking(context) {
+  const { options, working, followUp } = context;
+  const { files, step: step2, target } = options;
+  const sessionId = randomUUID2();
+  const captureStdout = working.output?.style !== "provider-output-file";
+  const resumeArgs = followUp.resumeArgs;
+  if (resumeArgs === void 0) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_invalid",
+      message: `Working agent step ${step2.id} target '${target.provider}' declares followUp.supported without followUp.resumeArgs for the format phase.`,
+      details: { provider: target.provider }
+    });
+  }
+  await writeFile5(files.promptFile, buildWorkPrompt({ prompt: options.renderedPrompt }), "utf8");
+  const phase1Template = working.args ?? defaultManifestWorkingArgs({
+    manifest: context.manifest,
+    promptFile: files.promptFile,
+    outputFile: files.workFile,
+    model: context.model,
+    thinking: context.thinking
+  });
+  const phase1Args = renderCustomProviderArgs({
+    argv: phase1Template,
+    values: {
+      promptFile: files.promptFile,
+      outputFile: files.workFile,
+      sessionId,
+      ...context.model === void 0 ? {} : { model: context.model },
+      ...context.thinking === void 0 ? {} : { thinking: context.thinking }
+    },
+    errorCode: "agent_provider_invalid",
+    commandDescription: "Manifest working provider command"
+  });
+  if (followUp.sessionIdFlag !== void 0 && !phase1Template.some((arg) => arg.includes("{{sessionId}}"))) {
+    phase1Args.push(followUp.sessionIdFlag, sessionId);
+  }
+  const phase1Result = await spawnManifestPhase({
+    phase: "work",
+    stepId: step2.id,
+    provider: target.provider,
+    command: working.command ?? "",
+    args: phase1Args,
+    cwd: options.cwd,
+    model: context.model,
+    promptFile: files.promptFile,
+    outputFile: files.workFile,
+    stdio: captureStdout ? "pipe" : "inherit",
+    runner: options.runner,
+    signal: options.signal
+  });
+  if (phase1Result.exitCode !== 0) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_failed",
+      message: `Working agent step ${step2.id} target '${target.provider}' exited with code ${phase1Result.exitCode}.`,
+      details: {
+        phase: "work",
+        exitCode: phase1Result.exitCode,
+        provider: working.command,
+        target: target.provider,
+        ...context.model === void 0 ? {} : { model: context.model }
+      }
+    });
+  }
+  if (captureStdout) {
+    await writeFile5(files.workFile, phase1Result.stdout ?? "", "utf8");
+  }
+  const phase1Tail = await readPhase1Tail(files.workFile);
+  await writePhaseUsageFile({
+    usageFile: files.usageFile,
+    sessionId,
+    provider: target.provider,
+    model: context.model
+  });
+  const phase2Args = renderCustomProviderArgs({
+    argv: resumeArgs,
+    values: {
+      sessionId,
+      promptFile: files.repairPromptFile,
+      outputFile: files.outputFile,
+      ...context.model === void 0 ? {} : { model: context.model },
+      ...context.thinking === void 0 ? {} : { thinking: context.thinking }
+    },
+    errorCode: "agent_provider_invalid",
+    commandDescription: "Manifest follow-up resume command"
+  });
+  const validationDiagnostics = [];
+  let formatFailureMessage = "";
+  for (let attempt = 1; attempt <= MAX_FORMAT_ATTEMPTS; attempt += 1) {
+    await writeFile5(
+      files.repairPromptFile,
+      buildFormatPrompt({
+        outputSchema: step2.output.jsonSchema,
+        ...attempt === 1 ? {} : { validationErrors: [formatFailureMessage] }
+      }),
+      "utf8"
+    );
+    const phase2Result = await spawnManifestPhase({
+      phase: "format",
+      stepId: step2.id,
+      provider: target.provider,
+      command: working.command ?? "",
+      args: phase2Args,
+      cwd: options.cwd,
+      model: context.model,
+      promptFile: files.repairPromptFile,
+      outputFile: files.outputFile,
+      stdio: captureStdout ? "pipe" : "inherit",
+      runner: options.runner,
+      signal: options.signal
+    });
+    if (phase2Result.exitCode !== 0) {
+      throw new TrailStepFailureError({
+        code: "agent_provider_failed",
+        message: `Working agent step ${step2.id} target '${target.provider}' exited with code ${phase2Result.exitCode}.`,
+        details: {
+          phase: "format",
+          attempt,
+          sessionId,
+          exitCode: phase2Result.exitCode,
+          provider: working.command,
+          target: target.provider,
+          ...context.model === void 0 ? {} : { model: context.model }
+        }
+      });
+    }
+    try {
+      await writeCapturedStdoutOutput({
+        provider: target.provider,
+        stepId: step2.id,
+        outputFile: files.outputFile,
+        captureMode: step2.output.captureMode,
+        stdout: phase2Result.stdout,
+        output: working.output,
+        extractOutputHook: context.extractOutputHook
+      });
+      return await readWorkingAgentOutput({ stepId: step2.id, outputFile: files.outputFile, step: step2 });
+    } catch (error) {
+      formatFailureMessage = error instanceof Error ? error.message : String(error);
+      validationDiagnostics.push(`format attempt ${attempt}: ${formatFailureMessage}`);
+    }
+  }
+  throw new TrailStepFailureError({
+    code: "agent_target_failed",
+    message: `Working agent step ${step2.id} target '${target.provider}' failed output validation after ${MAX_FORMAT_ATTEMPTS} format attempts in session ${sessionId}.`,
+    details: {
+      provider: target.provider,
+      sessionId,
+      attempts: MAX_FORMAT_ATTEMPTS,
+      validationDiagnostics,
+      phase1Tail
+    }
+  });
+}
+var MAX_FORMAT_ATTEMPTS = 3;
+var PHASE_1_TAIL_LIMIT = 2e3;
+async function spawnManifestPhase(options) {
+  const executable = await resolveCliCommandForSpawn({
+    command: options.command,
+    args: options.args
+  });
+  try {
+    return await (options.runner ?? spawnWorkingAgentProcess)({
+      command: executable.command,
+      args: executable.args,
+      cwd: options.cwd,
+      shell: false,
+      stdio: options.stdio,
+      promptFile: options.promptFile,
+      outputFile: options.outputFile,
+      ...options.model === void 0 ? {} : { model: options.model },
+      signal: options.signal
+    });
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_spawn_error",
+      message: `Working agent step ${options.stepId} could not start target '${options.provider}'.`,
+      details: {
+        phase: options.phase,
+        target: options.provider,
+        ...options.model === void 0 ? {} : { model: options.model },
+        cause: error instanceof Error ? error.message : String(error)
+      }
+    });
+  }
+}
+async function readPhase1Tail(workFile) {
+  try {
+    const workText = await readFile8(workFile, "utf8");
+    return workText.length > PHASE_1_TAIL_LIMIT ? workText.slice(-PHASE_1_TAIL_LIMIT) : workText;
+  } catch {
+    return "";
+  }
+}
+async function writePhaseUsageFile(options) {
+  try {
+    await writeFile5(
+      options.usageFile,
+      `${JSON.stringify(
+        {
+          sessionId: options.sessionId,
+          provider: options.provider,
+          ...options.model === void 0 ? {} : { model: options.model },
+          phases: 2
+        },
+        null,
+        2
+      )}
+`,
+      "utf8"
+    );
+  } catch {
+  }
+}
 async function writeCapturedStdoutOutput(options) {
   if (options.stdout === void 0) {
     return;
@@ -3984,6 +4309,7 @@ async function runWorkingAgentTargetAttempt(options) {
       runner: options.runner,
       target: options.target,
       files: options.files,
+      renderedPrompt: options.renderedPrompt,
       signal: options.signal
     });
   }
@@ -4178,7 +4504,7 @@ async function dispatchAgentStep(options) {
 }
 async function resolvePromptSource(source, input, cwd) {
   if (isPromptTemplateSource(source)) {
-    return await readFile8(resolve(cwd, source.path), "utf8");
+    return await readFile9(resolve(cwd, source.path), "utf8");
   }
   return renderAgentPrompt(source, input);
 }
@@ -4474,7 +4800,9 @@ async function runSubPrompt(source, options, input) {
         stepDir: artifactPaths.subPromptDir,
         promptFile: artifactPaths.promptFile,
         outputFile: artifactPaths.outputFile,
-        usageFile: artifactPaths.usageFile
+        usageFile: artifactPaths.usageFile,
+        workFile: join10(artifactPaths.subPromptDir, "work.txt"),
+        repairPromptFile: join10(artifactPaths.subPromptDir, "repair-prompt.md")
       }
     }) : await runAgentStep({
       step: agentStep,
@@ -4616,8 +4944,8 @@ function toDeprecationStatus(entry, version) {
 }
 
 // src/runtime/cancellation/cancellation.ts
-import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
-import { join as join10 } from "path";
+import { mkdir as mkdir7, readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
+import { join as join11 } from "path";
 var CANCELLATION_MARKER_FILE = "cancel.json";
 var WorkflowCancellationError = class extends Error {
   cancellation;
@@ -4628,12 +4956,12 @@ var WorkflowCancellationError = class extends Error {
   }
 };
 function cancellationMarkerPath(runDir) {
-  return join10(runDir, CANCELLATION_MARKER_FILE);
+  return join11(runDir, CANCELLATION_MARKER_FILE);
 }
 async function readCancellationMarker(runDir) {
   let contents;
   try {
-    contents = await readFile9(cancellationMarkerPath(runDir), "utf8");
+    contents = await readFile10(cancellationMarkerPath(runDir), "utf8");
   } catch (error) {
     if (isNodeError6(error) && error.code === "ENOENT") {
       return void 0;
@@ -4716,12 +5044,12 @@ function firstConfiguredPolicy(...policies) {
 }
 
 // src/runtime/run-workflow/run-workflow.ts
-import { readFile as readFile13 } from "fs/promises";
-import { basename as basename4, join as join14 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { basename as basename4, join as join15 } from "path";
 
 // src/runtime/continuation/run-continuation/run-continuation.ts
-import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile9 } from "fs/promises";
-import { join as join11 } from "path";
+import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
+import { join as join12 } from "path";
 
 // src/runtime/failures/step-execution-failure.ts
 function stepExecutionFailure(error) {
@@ -5740,7 +6068,7 @@ async function handleResumedWaitPhase(options) {
   }
 }
 function joinRunPath(runDir, runRelativePath) {
-  return join11(runDir, ...runRelativePath.split("/"));
+  return join12(runDir, ...runRelativePath.split("/"));
 }
 async function resolveWaitDefinition(phase, context) {
   if (typeof phase.wait !== "function") {
@@ -5818,7 +6146,7 @@ function validateWaitDefinition(wait, stepId, phaseIndex) {
 }
 async function readTextIfExists(path) {
   try {
-    return { status: "found", value: await readFile10(path, "utf8") };
+    return { status: "found", value: await readFile11(path, "utf8") };
   } catch (error) {
     if (isNodeError7(error) && error.code === "ENOENT") {
       return { status: "missing" };
@@ -6570,8 +6898,8 @@ function resumeFailure2(code, message) {
 }
 
 // src/runtime/resume/replay-to-waiting-step/replay-to-waiting-step.ts
-import { readFile as readFile11 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join13 } from "path";
 async function replayToWaitingStep(options) {
   const startedEvent = options.events.find((event) => event.type === "workflow.started");
   if (!startedEvent) {
@@ -6601,7 +6929,21 @@ async function replayToWaitingStep(options) {
       )
     };
   }
-  const pendingWait = findLatestPendingWait(options.events);
+  const scopeBranchId = options.branchId;
+  if (scopeBranchId !== void 0) {
+    try {
+      await readBranchRunState(options.runDir, scopeBranchId);
+    } catch (error) {
+      return {
+        status: "failure",
+        failure: resumeFailure3(
+          "continue_target_not_found",
+          `Branch ${scopeBranchId} run state is missing or unreadable: ${error instanceof Error ? error.message : String(error)}`
+        )
+      };
+    }
+  }
+  const pendingWait = findLatestPendingWait(options.events, scopeBranchId);
   if (!pendingWait?.stepId) {
     return {
       status: "failure",
@@ -6625,7 +6967,7 @@ async function replayToWaitingStep(options) {
       failure: resumeFailure3("continue_wait_invalid", "Pending wait event has no wait id.")
     };
   }
-  const stepIndex = readStepIndex(pendingWait) ?? stepStartedOrdinalBefore(options.events, pendingWait);
+  const stepIndex = options.stepIndex ?? readStepIndex(pendingWait) ?? stepStartedOrdinalBefore(options.events, pendingWait);
   if (stepIndex === void 0) {
     return {
       status: "failure",
@@ -6645,9 +6987,10 @@ async function replayToWaitingStep(options) {
       )
     };
   }
+  const replaySourceEvents = options.events.slice(0, targetStepStartedIndex);
   const replay = await replayCompletedSteps({
     workflow: options.workflow,
-    events: options.events.slice(0, targetStepStartedIndex),
+    events: scopeBranchId === void 0 ? replaySourceEvents : branchScopedReplayEvents(replaySourceEvents, scopeBranchId),
     input,
     targetStepId: pendingWait.stepId,
     runDir: options.runDir
@@ -6662,7 +7005,8 @@ async function replayToWaitingStep(options) {
       node: replay.node,
       events: options.events,
       targetStepStartedIndex,
-      pendingWait
+      pendingWait,
+      branchId: scopeBranchId
     })
   );
   if (prefix.status === "failure") {
@@ -6683,6 +7027,7 @@ async function replayToWaitingStep(options) {
     phaseValue: prefix.phaseValue,
     waitOutputs: prefix.waitOutputs,
     seenWaitIds: prefix.seenWaitIds,
+    ...scopeBranchId === void 0 ? {} : { branchId: scopeBranchId },
     wait: wait.wait
   };
 }
@@ -6700,7 +7045,7 @@ async function readResumedWaitDetails(runDir, waitEvent, waitId) {
   let request;
   try {
     request = JSON.parse(
-      await readFile11(join12(runDir, ...artifactPaths.requestFile.split("/")), "utf8")
+      await readFile12(join13(runDir, ...artifactPaths.requestFile.split("/")), "utf8")
     );
   } catch {
     return {
@@ -6733,12 +7078,15 @@ async function readResumedWaitDetails(runDir, waitEvent, waitId) {
     }
   };
 }
-function findLatestPendingWait(events) {
+function findLatestPendingWait(events, branchId) {
   for (let index = events.length - 1; index >= 0; index -= 1) {
     const event = events[index];
     if (event?.type !== "wait.started") {
       continue;
     }
+    if (branchId !== void 0 && event.payload.branchId !== branchId) {
+      continue;
+    }
     const key = waitEventKey(event);
     if (!key) {
       continue;
@@ -6757,11 +7105,12 @@ async function replayWaitingStepPrefix(options) {
   const targetPhaseIndex = typeof options.pendingWait.payload.phaseIndex === "number" ? options.pendingWait.payload.phaseIndex : void 0;
   const pendingWaitIndex = options.events.indexOf(options.pendingWait);
   const inStepEvents = options.events.slice(options.targetStepStartedIndex + 1, pendingWaitIndex);
+  const belongsToScopedBranch = (event) => options.branchId === void 0 || event.payload.branchId === void 0 || event.payload.branchId === options.branchId;
   const promptOutputs = inStepEvents.filter(
-    (event) => event.type === "step.completed" && event.stepId === options.node.config.id && isPlainObject14(event.payload.output)
+    (event) => event.type === "step.completed" && event.stepId === options.node.config.id && belongsToScopedBranch(event) && isPlainObject14(event.payload.output)
   );
   const satisfiedWaits = inStepEvents.filter(
-    (event) => event.type === "wait.satisfied" && event.stepId === options.node.config.id && isPlainObject14(event.payload.output) && typeof event.payload.waitId === "string"
+    (event) => event.type === "wait.satisfied" && event.stepId === options.node.config.id && belongsToScopedBranch(event) && isPlainObject14(event.payload.output) && typeof event.payload.waitId === "string"
   );
   let phaseValue = options.node.config.input;
   let promptOutputIndex = 0;
@@ -6909,7 +7258,7 @@ function readStepIndex(event) {
 }
 function stepDirForIndex(runDir, event, stepIndex) {
   const artifactStepId = readArtifactStepId(event) ?? `${String(stepIndex).padStart(4, "0")}-${event.stepId ?? "step"}`;
-  return join12(runDir, "steps", artifactStepId);
+  return join13(runDir, "steps", artifactStepId);
 }
 function readArtifactStepId(event) {
   const artifactPaths = readWaitArtifactPaths(event);
@@ -6928,6 +7277,22 @@ function readWaitArtifactPaths(event) {
   }
   return { requestFile, answerFile };
 }
+function branchScopedReplayEvents(events, branchId) {
+  let foreignOrdinal = 0;
+  const scoped = [];
+  for (const event of events) {
+    const eventBranchId = typeof event.payload.branchId === "string" ? event.payload.branchId : void 0;
+    if (eventBranchId === void 0 || eventBranchId === branchId) {
+      scoped.push(event);
+      continue;
+    }
+    if (event.type === "step.started") {
+      foreignOrdinal += 1;
+      scoped.push({ ...event, stepId: `__foreign_branch_${foreignOrdinal}__` });
+    }
+  }
+  return scoped;
+}
 function waitEventKey(event) {
   const artifactPaths = event.payload.artifactPaths;
   if (isPlainObject14(artifactPaths) && typeof artifactPaths.answerFile === "string") {
@@ -7251,9 +7616,9 @@ async function initializeRun(options) {
 }
 
 // src/runtime/run-workflow/root-continuation-array-scheduler.ts
-import { mkdir as mkdir9, readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
+import { mkdir as mkdir9, readFile as readFile13, writeFile as writeFile10 } from "fs/promises";
 import { availableParallelism } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 async function runRootContinuationArrayScheduler(options) {
   const resolvedWorkers = resolveSchedulerWorkerCount(options.workers);
   if (!resolvedWorkers.ok) {
@@ -7499,7 +7864,7 @@ async function runRootContinuationArrayScheduler(options) {
             });
             await mkdir9(stepArtifacts.stepDir, { recursive: true });
           }
-          await options.emit(decorateBranchEvent(event, options.runId, branch));
+          await options.emit(decorateBranchEvent(event, options.runId, branch, splitOccurred));
         },
         maxSteps: options.maxSteps,
         initialSource: !splitOccurred && branch.branchId === rootBranchId ? source : `${source} branch ${branch.branchId}`,
@@ -7513,7 +7878,8 @@ async function runRootContinuationArrayScheduler(options) {
         trailstepConfig: options.trailstepConfig,
         workingAgentProcessRunner: options.workingAgentProcessRunner,
         providerWorkingRunner: options.providerWorkingRunner,
-        processRunner: options.processRunner
+        processRunner: options.processRunner,
+        ...options.waitResumeBranches?.[branch.branchId] === void 0 ? {} : { resumeWait: options.waitResumeBranches[branch.branchId] }
       })
     );
     branch.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -7640,44 +8006,44 @@ async function runRootContinuationArrayScheduler(options) {
     return branchResultWasSplit ? { status: "success", output: {} } : branchResult;
   }
   async function enqueueSatisfiedJoins(branch) {
-    for (const join15 of pendingJoins) {
-      if (!join15.childBranchIds.includes(branch.branchId)) {
+    for (const join16 of pendingJoins) {
+      if (!join16.childBranchIds.includes(branch.branchId)) {
         continue;
       }
-      const settlement = branchSettlementForJoin(branch, join15.failurePolicy);
+      const settlement = branchSettlementForJoin(branch, join16.failurePolicy);
       if (settlement === void 0) {
         continue;
       }
-      join15.completed = { ...join15.completed, [branch.branchId]: settlement };
-      if (Object.keys(join15.completed).length !== join15.childBranchIds.length) {
+      join16.completed = { ...join16.completed, [branch.branchId]: settlement };
+      if (Object.keys(join16.completed).length !== join16.childBranchIds.length) {
         continue;
       }
       let nextNode;
       try {
-        nextNode = await join15.postContinuation({ status: "completed", branches: join15.completed });
+        nextNode = await join16.postContinuation({ status: "completed", branches: join16.completed });
       } catch (error) {
         await terminalizeTrack({
           status: "failure",
           failure: {
             code: "step_execution_failed",
-            message: `parallel post failed for ${join15.source}: ${String(error)}`
+            message: `parallel post failed for ${join16.source}: ${String(error)}`
           }
         });
         continue;
       }
       const postBranch = enqueue(
         nextNode,
-        join15.parentBranchId,
-        `post for ${join15.source}`,
+        join16.parentBranchId,
+        `post for ${join16.source}`,
         false,
         true
       );
-      if (join15.afterPostContinuation !== void 0) {
-        const afterPostContinuation = join15.afterPostContinuation;
+      if (join16.afterPostContinuation !== void 0) {
+        const afterPostContinuation = join16.afterPostContinuation;
         pendingJoins.push({
-          parentBranchId: join15.parentBranchId,
+          parentBranchId: join16.parentBranchId,
           childBranchIds: [postBranch.branchId],
-          source: `post for ${join15.source}`,
+          source: `post for ${join16.source}`,
           failurePolicy: "fail-fast",
           postContinuation: async (aggregateOutput) => {
             const branches2 = aggregateOutput.branches;
@@ -7877,8 +8243,10 @@ function resolveSchedulerWorkerCount(workers) {
   }
   return { ok: true, workers };
 }
-function decorateBranchEvent(event, trackId, branch) {
-  if (event.type !== "step.started" && event.type !== "step.completed") {
+function decorateBranchEvent(event, trackId, branch, decorateWaits) {
+  const isStepEvent = event.type === "step.started" || event.type === "step.completed";
+  const isWaitEvent = event.type === "wait.started" || event.type === "wait.satisfied" || event.type === "wait.failed";
+  if (!isStepEvent && !isWaitEvent || isWaitEvent && !decorateWaits) {
     return event;
   }
   const stepArtifactPaths = event.stepId === void 0 || branch.latestStepIndex < 1 ? void 0 : resolveStepArtifactPaths({
@@ -7904,7 +8272,7 @@ function decorateBranchEvent(event, trackId, branch) {
 async function createPersistedTrackRetryPlan(input) {
   let track;
   try {
-    track = JSON.parse(await readFile12(join13(input.runDir, "track.json"), "utf8"));
+    track = JSON.parse(await readFile13(join14(input.runDir, "track.json"), "utf8"));
   } catch (error) {
     return {
       status: "failure",
@@ -7929,7 +8297,7 @@ async function createPersistedTrackRetryPlan(input) {
     track.branches.map(
       async (branchId) => branchFromJson(
         JSON.parse(
-          await readFile12(join13(input.runDir, "branches", `${branchId}.json`), "utf8")
+          await readFile13(join14(input.runDir, "branches", `${branchId}.json`), "utf8")
         )
       )
     )
@@ -7970,10 +8338,12 @@ async function createPersistedTrackRetryPlan(input) {
     }
     branch.status = "queued";
     branch.failure = void 0;
-    branch.wait = void 0;
     branch.terminalKind = void 0;
     branch.message = void 0;
     branch.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (input.track?.mode !== "wait-answered") {
+      branch.wait = void 0;
+    }
     const rootParallelBranchIndex = retryRootParallelNode === void 0 ? void 0 : branches.filter((candidate) => candidate.parentBranchId === track.rootBranchId).findIndex((candidate) => candidate.branchId === branch.branchId);
     const node = (branch.requestedBranchId === void 0 ? void 0 : nodesByRequestedBranchId.get(branch.requestedBranchId)) ?? (rootParallelBranchIndex === void 0 || rootParallelBranchIndex < 0 ? retryCandidateNodes[index] : retryCandidateNodes[rootParallelBranchIndex]);
     if (node === void 0) {
@@ -8046,6 +8416,16 @@ function selectPersistedBranchesForRetry(branches, track) {
       )
     };
   }
+  if (track.mode === "wait-answered") {
+    return {
+      status: "success",
+      branchIds: new Set(
+        branches.filter(
+          (branch2) => branch2.status === "waiting" && branch2.wait !== void 0 && typeof branch2.wait === "object" && typeof branch2.wait.artifactPaths?.answerFile === "string"
+        ).map((branch2) => branch2.branchId)
+      )
+    };
+  }
   if (track.mode !== "branch") {
     return {
       status: "failure",
@@ -8121,7 +8501,7 @@ async function persistTrack(options, workers, rootBranchId, branches, status, sp
     ...terminalOutput === void 0 ? {} : { terminalOutput },
     ...failure === void 0 ? {} : { failure }
   };
-  await writeJson(join13(options.runDir, "track.json"), trackState);
+  await writeJson(join14(options.runDir, "track.json"), trackState);
 }
 async function persistBranch(runDir, branch) {
   const branchState = {
@@ -8144,10 +8524,10 @@ async function persistBranch(runDir, branch) {
     latestStepIndex: branch.latestStepIndex,
     ...branch.latestStepId === void 0 ? {} : { latestStepId: branch.latestStepId }
   };
-  await writeJson(join13(runDir, "branches", `${branch.branchId}.json`), branchState);
+  await writeJson(join14(runDir, "branches", `${branch.branchId}.json`), branchState);
 }
 async function writeJson(path, value) {
-  await mkdir9(join13(path, ".."), { recursive: true });
+  await mkdir9(join14(path, ".."), { recursive: true });
   await writeFile10(path, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
@@ -8329,6 +8709,8 @@ async function runWorkflow(options) {
     let workflowInput;
     let startNode;
     let waitResume;
+    let isWaitContinueTrackResume = false;
+    let branchResumes = {};
     let isTrackRetry = false;
     if (isResume) {
       const danglingAnchor = findDanglingInteractiveSessionStart(previousEvents);
@@ -8363,40 +8745,105 @@ async function runWorkflow(options) {
         })
       );
     } else if (isWaitContinue) {
-      if (await hasSupportedRootParallelTrackRetryMetadata(runDir)) {
-        return failResumeValidation({
-          code: "continue_parallel_track_unsupported",
-          message: "Continuing a waiting parallel track is not yet supported; retry the run or restart the workflow instead."
-        });
-      }
-      const replay = await replayWithoutClobberingStateOnFailure(
-        runDir,
-        () => replayToWaitingStep({
-          workflow: options.workflow,
-          events: previousEvents,
-          runDir
-        })
-      );
-      if (replay.status === "failure") {
-        return failResumeValidation(replay.failure);
-      }
-      await runContext.state.hydratePersisted();
-      workflowInput = inputSchema ? inputSchema.assert(replay.input, "workflow input") : replay.input;
-      startNode = replay.node;
-      waitResume = replay;
-      await emit(
-        createEvent({
-          runId,
-          workflowId: options.workflow.id,
-          type: "workflow.resumed",
-          payload: {
-            resumeKind: "wait",
-            resumedFromRunDir: runDir,
-            resumedStepId: replay.resumedStepId,
-            sourceWaitEventId: replay.sourceWaitEventId
+      const hasParallelTrack = await hasSupportedRootParallelTrackRetryMetadata(runDir);
+      if (hasParallelTrack) {
+        const answeredBranches = await findAnsweredParallelBranches(runDir);
+        if (answeredBranches.length === 0) {
+          return failResumeValidation({
+            code: "continue_parallel_track_unsupported",
+            message: "Continuing a waiting parallel track is not yet supported; retry the run or restart the workflow instead."
+          });
+        }
+        const persistedInput = readWorkflowStartedInput(previousEvents);
+        if (persistedInput === void 0) {
+          return failResumeValidation({
+            code: "continue_target_not_found",
+            message: "Continue target workflow started payload missing input."
+          });
+        }
+        await runContext.state.hydratePersisted();
+        await runContext.globalState.hydratePersisted();
+        workflowInput = inputSchema ? inputSchema.assert(persistedInput, "workflow input") : persistedInput;
+        startNode = options.workflow.start(workflowInput);
+        isWaitContinueTrackResume = true;
+        waitResume = void 0;
+        branchResumes = {};
+        for (const branchId of answeredBranches) {
+          const replay = await replayWithoutClobberingStateOnFailure(
+            runDir,
+            () => replayToWaitingStep({
+              workflow: options.workflow,
+              events: previousEvents,
+              runDir,
+              branchId
+            })
+          );
+          if (replay.status === "success") {
+            branchResumes[branchId] = {
+              stepId: replay.resumedStepId,
+              stepIndex: replay.stepIndex,
+              phaseIndex: replay.phaseIndex,
+              phaseValue: replay.phaseValue,
+              waitOutputs: replay.waitOutputs,
+              seenWaitIds: replay.seenWaitIds,
+              wait: replay.wait
+            };
           }
-        })
-      );
+        }
+        const firstReplay = await replayWithoutClobberingStateOnFailure(
+          runDir,
+          () => replayToWaitingStep({
+            workflow: options.workflow,
+            events: previousEvents,
+            runDir,
+            branchId: answeredBranches[0]
+          })
+        );
+        if (firstReplay.status === "success") {
+          await emit(
+            createEvent({
+              runId,
+              workflowId: options.workflow.id,
+              type: "workflow.resumed",
+              payload: {
+                resumeKind: "wait",
+                resumedFromRunDir: runDir,
+                resumedStepId: firstReplay.resumedStepId,
+                sourceWaitEventId: firstReplay.sourceWaitEventId
+              }
+            })
+          );
+        }
+      } else {
+        const replay = await replayWithoutClobberingStateOnFailure(
+          runDir,
+          () => replayToWaitingStep({
+            workflow: options.workflow,
+            events: previousEvents,
+            runDir
+          })
+        );
+        if (replay.status === "failure") {
+          return failResumeValidation(replay.failure);
+        }
+        await runContext.state.hydratePersisted();
+        workflowInput = inputSchema ? inputSchema.assert(replay.input, "workflow input") : replay.input;
+        startNode = replay.node;
+        waitResume = replay;
+        await emit(
+          createEvent({
+            runId,
+            workflowId: options.workflow.id,
+            type: "workflow.resumed",
+            payload: {
+              resumeKind: "wait",
+              resumedFromRunDir: runDir,
+              resumedStepId: replay.resumedStepId,
+              sourceWaitEventId: replay.sourceWaitEventId
+            }
+          })
+        );
+      }
     } else if (isRetry) {
       if (await hasSupportedRootParallelTrackRetryMetadata(runDir)) {
         const persistedInput = readWorkflowStartedInput(previousEvents);
@@ -8465,7 +8912,7 @@ async function runWorkflow(options) {
     }
     const rootNode = startNode ?? options.workflow.start(workflowInput);
     const rootNodes = Array.isArray(rootNode) ? rootNode : [rootNode];
-    const shouldUseRootArrayScheduler = !isResume && !isRetry && !isWaitContinue || isTrackRetry;
+    const shouldUseRootArrayScheduler = !isResume && !isRetry && !isWaitContinue || isTrackRetry || isWaitContinueTrackResume;
     const continuationResult = shouldUseRootArrayScheduler ? await runRootContinuationArrayScheduler({
       nodes: rootNodes,
       ...Array.isArray(rootNode) ? { rootIsArray: true } : {},
@@ -8491,6 +8938,16 @@ async function runWorkflow(options) {
           ).length,
           track: options.retry?.track
         }
+      } : isWaitContinueTrackResume ? {
+        retry: {
+          initialExecutedSteps: previousEvents.filter(
+            (event) => event.type === "step.started"
+          ).length,
+          track: {
+            mode: "wait-answered"
+          }
+        },
+        waitResumeBranches: branchResumes
       } : {}
     }) : await runContinuation({
       node: rootNode,
@@ -8579,14 +9036,14 @@ async function replayWithoutClobberingStateOnFailure(runDir, replay) {
 }
 async function hasSupportedRootParallelTrackRetryMetadata(runDir) {
   try {
-    const track = JSON.parse(await readFile13(join14(runDir, "track.json"), "utf8"));
+    const track = JSON.parse(await readFile14(join15(runDir, "track.json"), "utf8"));
     if (track.splitOccurred !== true || typeof track.rootBranchId !== "string" || !Array.isArray(track.branches) || !track.branches.every((branchId) => typeof branchId === "string")) {
       return false;
     }
     const branches = await Promise.all(
       track.branches.map(async (branchId) => {
         const branch = JSON.parse(
-          await readFile13(join14(runDir, "branches", `${branchId}.json`), "utf8")
+          await readFile14(join15(runDir, "branches", `${branchId}.json`), "utf8")
         );
         return branch;
       })
@@ -8601,6 +9058,41 @@ async function hasSupportedRootParallelTrackRetryMetadata(runDir) {
     throw error;
   }
 }
+async function findAnsweredParallelBranches(runDir) {
+  try {
+    const track = JSON.parse(await readFile14(join15(runDir, "track.json"), "utf8"));
+    if (track.splitOccurred !== true || !Array.isArray(track.branches)) {
+      return [];
+    }
+    const answered = [];
+    for (const branchId of track.branches) {
+      if (typeof branchId !== "string") continue;
+      let branchState;
+      try {
+        branchState = JSON.parse(
+          await readFile14(join15(runDir, "branches", `${branchId}.json`), "utf8")
+        );
+      } catch {
+        continue;
+      }
+      if (branchState?.status !== "waiting") continue;
+      if (branchState.wait === void 0 || typeof branchState.wait !== "object" || branchState.wait === null) {
+        continue;
+      }
+      const wait = branchState.wait;
+      const answerFile = wait.artifactPaths?.answerFile;
+      if (typeof answerFile !== "string") continue;
+      try {
+        await readFile14(join15(runDir, answerFile), "utf8");
+        answered.push(branchId);
+      } catch {
+      }
+    }
+    return answered;
+  } catch {
+    return [];
+  }
+}
 function readWorkflowStartedInput(events) {
   const started = events.find((event) => event.type === "workflow.started");
   const input = started?.payload.input;
@@ -8686,6 +9178,7 @@ export {
   readRunState,
   readStorageLifecycleStatus,
   resolveAgentTargets,
+  resolveCliCommandForSpawn,
   resolveRetryPolicy,
   resolveTimeoutPolicy,
   restoreArchivedRun,