@trailstep/core 0.1.0

package/dist/index.js

@@ -0,0 +1,4654 @@
+// src/contracts/failures/failure.ts
+var TrailStepFailureError = class extends Error {
+  failure;
+  constructor(failure) {
+    super(failure.message);
+    this.name = "TrailStepFailureError";
+    this.failure = failure;
+  }
+};
+function validationFailure(message, details) {
+  return {
+    code: "validation_failed",
+    message,
+    ...details === void 0 ? {} : { details }
+  };
+}
+
+// src/agent-targeting/parse-trailstep-config/expand-agent-refs.ts
+function expandAgentRefs(options) {
+  const expandedAgents = {};
+  const memo = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(options.agents)) {
+    expandedAgents[name] = expandTopLevelAgent({
+      name,
+      agents: options.agents,
+      memo,
+      stack: [],
+      rootRefPath: void 0
+    });
+  }
+  const expandedWorkflows = options.workflows === void 0 ? void 0 : Object.fromEntries(
+    Object.entries(options.workflows).map(([workflowId, workflow]) => {
+      const workflowAgents = workflow.agents === void 0 ? void 0 : Object.fromEntries(
+        Object.entries(workflow.agents).map(([roleName, targets]) => [
+          roleName,
+          expandTargetArray({
+            path: `workflows.${workflowId}.agents.${roleName}`,
+            targets,
+            agents: options.agents,
+            memo,
+            stack: [],
+            rootRefPath: void 0
+          })
+        ])
+      );
+      return [
+        workflowId,
+        {
+          ...workflowAgents === void 0 ? {} : { agents: workflowAgents },
+          ...workflow.settings === void 0 ? {} : { settings: workflow.settings }
+        }
+      ];
+    })
+  );
+  return { agents: expandedAgents, workflows: expandedWorkflows };
+}
+function expandTopLevelAgent(options) {
+  const memoized = options.memo.get(options.name);
+  if (memoized !== void 0) {
+    return memoized;
+  }
+  const targets = options.agents[options.name];
+  if (targets === void 0) {
+    throwUnknownRef(`agents.${options.name}`, options.name);
+  }
+  const expanded = expandTargetArray({
+    path: `agents.${options.name}`,
+    targets,
+    agents: options.agents,
+    memo: options.memo,
+    stack: [...options.stack, options.name],
+    rootRefPath: options.rootRefPath
+  });
+  options.memo.set(options.name, expanded);
+  return expanded;
+}
+function expandTargetArray(options) {
+  return options.targets.flatMap((target, index) => {
+    if ("provider" in target) {
+      return [target];
+    }
+    const refPath = `${options.path}[${index}].ref`;
+    const referencedTargets = options.agents[target.ref];
+    if (referencedTargets === void 0) {
+      throwUnknownRef(refPath, target.ref);
+    }
+    const existingRefIndex = options.stack.indexOf(target.ref);
+    if (existingRefIndex !== -1) {
+      throwCycle(options.rootRefPath ?? refPath, [
+        ...options.stack.slice(existingRefIndex),
+        target.ref
+      ]);
+    }
+    const memoized = options.memo.get(target.ref);
+    if (memoized !== void 0) {
+      return memoized;
+    }
+    const expanded = expandTargetArray({
+      path: `agents.${target.ref}`,
+      targets: referencedTargets,
+      agents: options.agents,
+      memo: options.memo,
+      stack: [...options.stack, target.ref],
+      rootRefPath: options.rootRefPath ?? refPath
+    });
+    options.memo.set(target.ref, expanded);
+    return expanded;
+  });
+}
+function throwUnknownRef(path, ref) {
+  throw new TrailStepFailureError({
+    code: "agent_ref_unknown",
+    message: "One or more agent refs reference an unknown top-level agent.",
+    details: { diagnostics: [`${path} references unknown agent '${ref}'.`] }
+  });
+}
+function throwCycle(path, cycle) {
+  throw new TrailStepFailureError({
+    code: "agent_ref_cycle",
+    message: "One or more agent refs create a cycle.",
+    details: { diagnostics: [`${path} creates an agent ref cycle: ${cycle.join(" -> ")}.`] }
+  });
+}
+
+// src/agent-targeting/parse-trailstep-config/parse-utils.ts
+function throwValidationFailure(diagnostics) {
+  throw new TrailStepFailureError(
+    validationFailure("Invalid .trailstep/config.json.", { diagnostics })
+  );
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseOptionalStringArray(path, value, diagnostics) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    diagnostics.push(`${path} must be an array of strings when present.`);
+    return void 0;
+  }
+  return value;
+}
+function parseOptionalStringRecord(path, value, diagnostics) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    diagnostics.push(`${path} must be an object when present.`);
+    return void 0;
+  }
+  const env = {};
+  for (const [key, envValue] of Object.entries(value)) {
+    if (typeof envValue !== "string") {
+      diagnostics.push(`${path}.${key} must be a string.`);
+    } else {
+      env[key] = envValue;
+    }
+  }
+  return env;
+}
+
+// src/agent-targeting/parse-trailstep-config/parse-agent-targets.ts
+var THINKING_LEVELS = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
+function parseTargetArray(path, value, diagnostics) {
+  if (!Array.isArray(value)) {
+    diagnostics.push(`${path} must be an array.`);
+    return [];
+  }
+  return value.flatMap((target, index) => {
+    const targetPath = `${path}[${index}]`;
+    if (!isRecord(target)) {
+      diagnostics.push(`${targetPath} must be an object.`);
+      return [];
+    }
+    if (target.ref !== void 0) {
+      if (typeof target.ref !== "string" || target.ref.length === 0) {
+        diagnostics.push(`${targetPath}.ref must be a non-empty string when present.`);
+        return [];
+      }
+      return [{ ref: target.ref }];
+    }
+    if (typeof target.provider !== "string" || target.provider.length === 0) {
+      diagnostics.push(`${targetPath}.provider must be a non-empty string.`);
+      return [];
+    }
+    if (target.model !== void 0 && typeof target.model !== "string") {
+      diagnostics.push(`${targetPath}.model must be a string when present.`);
+    }
+    if (target.thinking !== void 0 && !THINKING_LEVELS.has(target.thinking)) {
+      diagnostics.push(
+        `${targetPath}.thinking must be one of low, medium, high, xhigh, or max when present.`
+      );
+    }
+    const args = parseOptionalStringArray(`${targetPath}.args`, target.args, diagnostics);
+    return [
+      {
+        provider: target.provider,
+        ...typeof target.model === "string" ? { model: target.model } : {},
+        ...typeof target.thinking === "string" && THINKING_LEVELS.has(target.thinking) ? { thinking: target.thinking } : {},
+        ...args === void 0 ? {} : { args }
+      }
+    ];
+  });
+}
+
+// src/agent-targeting/parse-trailstep-config/parse-agent-mappings.ts
+function parseAgentMappings(path, value, diagnostics) {
+  const mappings = {};
+  if (!isRecord(value)) {
+    diagnostics.push(`${path} must be an object.`);
+    return mappings;
+  }
+  for (const [name, entry] of Object.entries(value)) {
+    mappings[name] = parseTargetArray(`${path}.${name}`, entry, diagnostics);
+  }
+  return mappings;
+}
+
+// src/agent-targeting/parse-trailstep-config/parse-custom-providers.ts
+function parseCustomProviders(value, diagnostics) {
+  const customProviders = {};
+  if (!isRecord(value)) {
+    diagnostics.push("customProviders must be an object.");
+    return customProviders;
+  }
+  for (const [name, providerConfig] of Object.entries(value)) {
+    if (!isRecord(providerConfig)) {
+      diagnostics.push(`customProviders.${name} must be an object.`);
+      continue;
+    }
+    if (typeof providerConfig.binary !== "string" || providerConfig.binary.length === 0) {
+      diagnostics.push(`customProviders.${name}.binary must be a non-empty string.`);
+      continue;
+    }
+    const args = parseOptionalStringArray(
+      `customProviders.${name}.args`,
+      providerConfig.args,
+      diagnostics
+    );
+    const interactiveArgs = parseOptionalStringArray(
+      `customProviders.${name}.interactiveArgs`,
+      providerConfig.interactiveArgs,
+      diagnostics
+    );
+    const env = parseOptionalStringRecord(
+      `customProviders.${name}.env`,
+      providerConfig.env,
+      diagnostics
+    );
+    if (providerConfig.cwd !== void 0 && typeof providerConfig.cwd !== "string") {
+      diagnostics.push(`customProviders.${name}.cwd must be a string when present.`);
+    }
+    customProviders[name] = {
+      binary: providerConfig.binary,
+      ...args === void 0 ? {} : { args },
+      ...interactiveArgs === void 0 ? {} : { interactiveArgs },
+      ...typeof providerConfig.cwd === "string" ? { cwd: providerConfig.cwd } : {},
+      ...env === void 0 ? {} : { env }
+    };
+  }
+  return customProviders;
+}
+
+// src/agent-targeting/parse-trailstep-config/parse-settings.ts
+function parseSettings(path, value, diagnostics) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    diagnostics.push(`${path} must be an object when present.`);
+    return void 0;
+  }
+  const settings = { ...value };
+  if (value.retry !== void 0) {
+    if (!isRecord(value.retry)) {
+      diagnostics.push(`${path}.retry must be an object when present.`);
+      delete settings.retry;
+    } else if (value.retry.maxAttempts === void 0) {
+      delete settings.retry;
+    } else {
+      settings.retry = { maxAttempts: value.retry.maxAttempts };
+    }
+  }
+  if (value.timeout !== void 0 && typeof value.timeout !== "number") {
+    diagnostics.push(`${path}.timeout must be a number when present.`);
+    delete settings.timeout;
+  }
+  return settings;
+}
+
+// src/agent-targeting/parse-trailstep-config/parse-workflow-agent-mappings.ts
+function parseWorkflows(value, diagnostics) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const workflows = {};
+  if (!isRecord(value)) {
+    diagnostics.push("workflows must be an object when present.");
+    return workflows;
+  }
+  for (const [workflowId, workflow] of Object.entries(value)) {
+    if (!isRecord(workflow)) {
+      diagnostics.push(`workflows.${workflowId} must be an object.`);
+      continue;
+    }
+    const agents = workflow.agents === void 0 ? void 0 : parseAgentMappings(`workflows.${workflowId}.agents`, workflow.agents, diagnostics);
+    const settings = parseSettings(
+      `workflows.${workflowId}.settings`,
+      workflow.settings,
+      diagnostics
+    );
+    workflows[workflowId] = {
+      ...agents === void 0 ? {} : { agents },
+      ...settings === void 0 ? {} : { settings }
+    };
+  }
+  return workflows;
+}
+
+// src/known-cli-providers/providers/claude/claude-provider.ts
+import { spawn } from "child_process";
+import { writeFile } from "fs/promises";
+import { performance } from "perf_hooks";
+
+// src/known-cli-providers/envelopes/envelope.ts
+function extractEnvelopeMetadata(rawStdout, options) {
+  const metadata = { harnessDurationMs: options.harnessDurationMs };
+  const envelope = parseEnvelopeObject(rawStdout);
+  if (envelope) {
+    const usage = camelCaseUsage(envelope.usage);
+    if (usage) {
+      metadata.usage = usage;
+    }
+    if (typeof envelope.total_cost_usd === "number") {
+      metadata.costUsd = envelope.total_cost_usd;
+    }
+    if (typeof envelope.duration_ms === "number") {
+      metadata.durationMs = envelope.duration_ms;
+    }
+    if (typeof envelope.num_turns === "number") {
+      metadata.turns = envelope.num_turns;
+    }
+    if (typeof envelope.session_id === "string") {
+      metadata.sessionId = envelope.session_id;
+    }
+  }
+  return metadata;
+}
+function extractEnvelopeOutput(rawStdout, options) {
+  const text = rawStdout.trim();
+  if (!text) {
+    throw new Error("Provider process returned empty stdout.");
+  }
+  const parsedEnvelope = parseJson(text);
+  if (isPlainObject(parsedEnvelope)) {
+    if (parsedEnvelope.is_error === true) {
+      throw new Error(
+        `Provider reported an error: ${String(parsedEnvelope[options.resultField] ?? text)}`
+      );
+    }
+    const resolved = resolveFieldValue(parsedEnvelope[options.resultField]);
+    if (resolved) {
+      return resolved;
+    }
+    if (typeof parsedEnvelope.content === "string") {
+      return parseObjectFromText(parsedEnvelope.content);
+    }
+  }
+  const streamResult = parseLastJsonLineResult(text, options.resultField);
+  if (streamResult) {
+    return streamResult;
+  }
+  return parseObjectFromText(text);
+}
+function extractEnvelopeText(rawStdout, options) {
+  const text = rawStdout.trim();
+  if (!text) {
+    throw new Error("Provider process returned empty stdout.");
+  }
+  const parsedEnvelope = parseJson(text);
+  if (isPlainObject(parsedEnvelope)) {
+    if (parsedEnvelope.is_error === true) {
+      throw new Error(
+        `Provider reported an error: ${String(parsedEnvelope[options.resultField] ?? text)}`
+      );
+    }
+    const resolved = resolveFieldText(parsedEnvelope[options.resultField]);
+    if (resolved !== void 0) {
+      return resolved;
+    }
+    if (typeof parsedEnvelope.content === "string") {
+      return parsedEnvelope.content;
+    }
+  }
+  const streamResult = parseLastJsonLineText(text, options.resultField);
+  if (streamResult !== void 0) {
+    return streamResult;
+  }
+  return text;
+}
+function parseLastJsonLineText(text, resultField) {
+  const lines = text.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+  for (const line of [...lines].reverse()) {
+    const parsed = parseJson(line);
+    if (!isPlainObject(parsed)) {
+      continue;
+    }
+    const resolved = resolveFieldText(parsed[resultField]);
+    if (resolved !== void 0) {
+      return resolved;
+    }
+    if (typeof parsed.content === "string") {
+      return parsed.content;
+    }
+  }
+  return void 0;
+}
+function resolveFieldText(fieldValue) {
+  if (typeof fieldValue === "string") {
+    return fieldValue;
+  }
+  if (isPlainObject(fieldValue)) {
+    return extractTextFromContentBlocks(fieldValue);
+  }
+  return void 0;
+}
+function parseLastJsonLineResult(text, resultField) {
+  const lines = text.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+  for (const line of [...lines].reverse()) {
+    const parsed = parseJson(line);
+    if (!isPlainObject(parsed)) {
+      continue;
+    }
+    const resolved = resolveFieldValue(parsed[resultField]);
+    if (resolved) {
+      return resolved;
+    }
+    if (typeof parsed.content === "string") {
+      return parseObjectFromText(parsed.content);
+    }
+  }
+  return void 0;
+}
+function resolveFieldValue(fieldValue) {
+  if (typeof fieldValue === "string") {
+    return parseObjectFromText(fieldValue);
+  }
+  if (isPlainObject(fieldValue)) {
+    const blockText = extractTextFromContentBlocks(fieldValue);
+    if (blockText !== void 0) {
+      return parseObjectFromText(blockText);
+    }
+    return fieldValue;
+  }
+  return void 0;
+}
+function extractTextFromContentBlocks(value) {
+  const content = value.content;
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const textParts = content.filter(isPlainObject).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text);
+  if (textParts.length === 0) {
+    return void 0;
+  }
+  return textParts.join("");
+}
+function parseObjectFromText(text) {
+  const parsed = parseJson(text.trim());
+  if (isPlainObject(parsed)) {
+    return parsed;
+  }
+  const firstBrace = text.indexOf("{");
+  const lastBrace = text.lastIndexOf("}");
+  if (firstBrace === -1 || lastBrace === -1 || lastBrace <= firstBrace) {
+    throw new Error(`Provider response did not contain a JSON object: ${text}`);
+  }
+  const extracted = parseJson(text.slice(firstBrace, lastBrace + 1));
+  if (!isPlainObject(extracted)) {
+    throw new Error("Provider response JSON was not an object.");
+  }
+  return extracted;
+}
+function parseEnvelopeObject(rawStdout) {
+  const text = rawStdout.trim();
+  const parsed = parseJson(text);
+  if (isPlainObject(parsed)) {
+    return parsed;
+  }
+  const lines = text.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+  for (const line of [...lines].reverse()) {
+    const parsedLine = parseJson(line);
+    if (isPlainObject(parsedLine)) {
+      return parsedLine;
+    }
+  }
+  return void 0;
+}
+function camelCaseUsage(value) {
+  if (!isPlainObject(value)) {
+    return void 0;
+  }
+  const usage = {};
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (typeof fieldValue === "number") {
+      usage[snakeToCamel(key)] = fieldValue;
+    }
+  }
+  return Object.keys(usage).length > 0 ? usage : void 0;
+}
+function snakeToCamel(value) {
+  return value.replace(/_([a-z])/gu, (_match, letter) => letter.toUpperCase());
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/known-cli-providers/providers/prompt-file-reference.ts
+function promptFileReference(promptFile) {
+  return `@${promptFile}`;
+}
+
+// src/known-cli-providers/providers/claude/claude-provider.ts
+var CLAUDE_BINARY = "claude";
+async function runWorking(request, runner = spawnClaudeCapturingStdout) {
+  const args = buildClaudeWorkingArgs(request);
+  let result;
+  const startedAt = performance.now();
+  try {
+    result = await runner({
+      command: CLAUDE_BINARY,
+      args,
+      cwd: request.cwd,
+      signal: request.signal
+    });
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_spawn_error",
+      message: "claude provider process could not be started.",
+      details: { cause: error instanceof Error ? error.message : String(error) }
+    });
+  }
+  const harnessDurationMs = Math.max(0, Math.round(performance.now() - startedAt));
+  if (result.exitCode !== 0) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_failed",
+      message: `claude provider process exited with code ${result.exitCode}.`,
+      details: { exitCode: result.exitCode }
+    });
+  }
+  await writeCapturedOutput({
+    stdout: result.stdout,
+    outputFile: request.outputFile,
+    usageFile: request.usageFile,
+    captureMode: request.captureMode,
+    harnessDurationMs,
+    context: "working"
+  });
+}
+function extractFailureContext(rawStdout) {
+  const metadata = extractEnvelopeMetadata(rawStdout, { harnessDurationMs: 0 });
+  let rawResultText;
+  try {
+    rawResultText = extractEnvelopeText(rawStdout, { resultField: "result" });
+  } catch {
+    rawResultText = void 0;
+  }
+  return {
+    ...metadata.sessionId === void 0 ? {} : { sessionId: metadata.sessionId },
+    ...rawResultText === void 0 ? {} : { rawResultText }
+  };
+}
+async function writeCapturedOutput(options) {
+  const label = options.context === "repair" ? "repair " : "";
+  if (options.captureMode === "raw-text") {
+    let text;
+    try {
+      text = extractEnvelopeText(options.stdout, { resultField: "result" });
+    } catch (error) {
+      throw new TrailStepFailureError({
+        code: "agent_provider_output_invalid",
+        message: `claude provider ${label}stdout did not contain a usable result.`,
+        details: {
+          cause: error instanceof Error ? error.message : String(error),
+          ...extractFailureContext(options.stdout)
+        }
+      });
+    }
+    await writeFile(options.outputFile, text, "utf8");
+  } else {
+    let output;
+    try {
+      output = extractEnvelopeOutput(options.stdout, { resultField: "result" });
+    } catch (error) {
+      throw new TrailStepFailureError({
+        code: "agent_provider_output_invalid",
+        message: `claude provider ${label}stdout did not contain a usable JSON result.`,
+        details: {
+          cause: error instanceof Error ? error.message : String(error),
+          ...extractFailureContext(options.stdout)
+        }
+      });
+    }
+    await writeFile(options.outputFile, `${JSON.stringify(output, null, 2)}
+`, "utf8");
+  }
+  if (options.usageFile) {
+    const metadata = extractEnvelopeMetadata(options.stdout, {
+      harnessDurationMs: options.harnessDurationMs
+    });
+    await writeFile(options.usageFile, `${JSON.stringify(metadata, null, 2)}
+`, "utf8");
+  }
+}
+async function repairOutput(request, runner = spawnClaudeCapturingStdout) {
+  const prompt = buildClaudeRepairPrompt(request);
+  const args = buildClaudeRepairArgs(request);
+  let result;
+  const startedAt = performance.now();
+  try {
+    result = await runner({
+      command: CLAUDE_BINARY,
+      args,
+      cwd: request.cwd,
+      stdin: prompt,
+      signal: request.signal
+    });
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_spawn_error",
+      message: "claude provider repair process could not be started.",
+      details: { cause: error instanceof Error ? error.message : String(error) }
+    });
+  }
+  const harnessDurationMs = Math.max(0, Math.round(performance.now() - startedAt));
+  if (result.exitCode !== 0) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_failed",
+      message: `claude provider repair process exited with code ${result.exitCode}.`,
+      details: { exitCode: result.exitCode }
+    });
+  }
+  await writeCapturedOutput({
+    stdout: result.stdout,
+    outputFile: request.outputFile,
+    usageFile: request.usageFile,
+    captureMode: request.captureMode,
+    harnessDurationMs,
+    context: "repair"
+  });
+}
+function buildClaudeRepairArgs(request) {
+  const args = [
+    "--resume",
+    request.sessionId,
+    "-p",
+    "--output-format",
+    "json",
+    "--dangerously-skip-permissions"
+  ];
+  if (request.model) {
+    args.push("--model", request.model);
+  }
+  if (request.thinking) {
+    args.push("--effort", request.thinking);
+  }
+  return args;
+}
+function buildClaudeRepairPrompt(request) {
+  if (request.captureMode === "raw-text") {
+    return [
+      "# TrailStep output repair",
+      "",
+      "Your previous final answer in this session could not be used as-is.",
+      "Do not redo the task or make any further changes - the work is already done.",
+      "Reply with the document content only, as your entire final answer: no JSON wrapper, no surrounding commentary, no markdown fences unless they are literally part of the document content itself.",
+      "",
+      "## Your previous final answer",
+      "",
+      request.rawResultText,
+      ""
+    ].join("\n");
+  }
+  return [
+    "# TrailStep output repair",
+    "",
+    "Your previous final answer in this session was not valid JSON matching the required schema.",
+    "Do not redo the task, re-read files, or make any further changes - the work is already done.",
+    "Reply with exactly one JSON object as your entire final answer: no prose, no markdown fences, no multiple JSON values.",
+    "",
+    "The JSON object must match this output schema:",
+    "",
+    "```json",
+    JSON.stringify(request.outputSchema, null, 2),
+    "```",
+    "",
+    "## Your previous final answer",
+    "",
+    request.rawResultText,
+    ""
+  ].join("\n");
+}
+function buildClaudeWorkingArgs(request) {
+  const args = [
+    "-p",
+    promptFileReference(request.promptFile),
+    "--output-format",
+    "json",
+    "--dangerously-skip-permissions"
+  ];
+  if (request.model) {
+    args.push("--model", request.model);
+  }
+  if (request.thinking) {
+    args.push("--effort", request.thinking);
+  }
+  return args;
+}
+async function runInteractive(request, runner = spawnClaudeInteractive) {
+  const args = [];
+  if (request.model) {
+    args.push("--model", request.model);
+  }
+  if (request.permissionMode !== "prompt") {
+    args.push("--dangerously-skip-permissions");
+  }
+  if (!request.systemPromptFile) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_invalid_request",
+      message: "claude provider's interactive mode requires systemPromptFile."
+    });
+  }
+  args.push("--append-system-prompt-file", request.systemPromptFile);
+  return await runner({
+    command: CLAUDE_BINARY,
+    args,
+    cwd: request.cwd,
+    shell: false,
+    stdio: "inherit",
+    env: request.env,
+    signal: request.signal
+  });
+}
+var spawnClaudeCapturingStdout = async ({
+  command,
+  args,
+  cwd,
+  stdin,
+  signal
+}) => {
+  return await new Promise((resolve2, reject) => {
+    const hasStdin = stdin !== void 0;
+    const child = spawn(command, args, {
+      cwd,
+      shell: false,
+      stdio: [hasStdin ? "pipe" : "ignore", "pipe", "inherit"],
+      detached: process.platform !== "win32"
+    });
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stdin?.on("error", reject);
+    signal?.addEventListener("abort", () => terminateChildProcessTree(child), { once: true });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ exitCode: code ?? 1, stdout }));
+    if (hasStdin) {
+      child.stdin?.end(stdin);
+    }
+  });
+};
+var spawnClaudeInteractive = async ({
+  command,
+  args,
+  cwd,
+  env,
+  signal
+}) => {
+  return await new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env,
+      signal,
+      detached: process.platform !== "win32",
+      shell: false,
+      stdio: "inherit"
+    });
+    signal?.addEventListener("abort", () => terminateChildProcessTree(child), { once: true });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ exitCode: code ?? 1 }));
+  });
+};
+function terminateChildProcessTree(child) {
+  if (!child.pid) {
+    return;
+  }
+  if (process.platform === "win32") {
+    spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on(
+      "error",
+      () => {
+        child.kill();
+      }
+    );
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGTERM");
+  } catch {
+    child.kill();
+  }
+}
+var claudeProvider = {
+  id: "claude",
+  runWorking,
+  repairOutput,
+  runInteractive
+};
+
+// src/known-cli-providers/providers/codex/codex-provider.ts
+import { spawn as spawn2 } from "child_process";
+var CODEX_BINARY = "codex";
+var SUPPORTED_CODEX_THINKING = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh"]);
+async function runWorking2(request, runner = spawnCodexInheritingStdio) {
+  const args = buildCodexWorkingArgs(request);
+  let result;
+  try {
+    result = await runner({
+      command: CODEX_BINARY,
+      args,
+      cwd: request.cwd,
+      signal: request.signal
+    });
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_spawn_error",
+      message: "codex provider process could not be started.",
+      details: { cause: error instanceof Error ? error.message : String(error) }
+    });
+  }
+  if (result.exitCode !== 0) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_failed",
+      message: `codex provider process exited with code ${result.exitCode}.`,
+      details: { exitCode: result.exitCode }
+    });
+  }
+}
+function buildCodexWorkingArgs(request) {
+  const args = ["exec", "--dangerously-bypass-approvals-and-sandbox"];
+  if (request.model) {
+    args.push("-m", request.model);
+  }
+  if (request.thinking) {
+    if (!SUPPORTED_CODEX_THINKING.has(request.thinking)) {
+      throw new TrailStepFailureError({
+        code: "agent_provider_thinking_unsupported",
+        message: `codex provider does not support thinking level '${request.thinking}'. Codex only supports low|medium|high|xhigh (no "max" tier).`,
+        details: { thinking: request.thinking }
+      });
+    }
+    args.push("-c", `model_reasoning_effort="${request.thinking}"`);
+  }
+  args.push("-o", request.outputFile);
+  args.push(promptFileReference(request.promptFile));
+  return args;
+}
+async function runInteractive2(request, runner = spawnCodexInteractive) {
+  const args = [];
+  if (request.model) {
+    args.push("--model", request.model);
+  }
+  args.push(
+    request.systemPromptFile ? promptFileReference(request.systemPromptFile) : request.prompt
+  );
+  return await runner({
+    command: CODEX_BINARY,
+    args,
+    cwd: request.cwd,
+    shell: false,
+    stdio: "inherit",
+    env: request.env,
+    signal: request.signal
+  });
+}
+var spawnCodexInheritingStdio = async ({ command, args, cwd, signal }) => {
+  return await new Promise((resolve2, reject) => {
+    const child = spawn2(command, args, {
+      cwd,
+      shell: false,
+      stdio: "inherit",
+      detached: process.platform !== "win32"
+    });
+    signal?.addEventListener("abort", () => terminateChildProcessTree2(child), { once: true });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ exitCode: code ?? 1, stdout: "" }));
+  });
+};
+var spawnCodexInteractive = async ({
+  command,
+  args,
+  cwd,
+  env,
+  signal
+}) => {
+  return await new Promise((resolve2, reject) => {
+    const child = spawn2(command, args, {
+      cwd,
+      env,
+      signal,
+      detached: process.platform !== "win32",
+      shell: false,
+      stdio: "inherit"
+    });
+    signal?.addEventListener("abort", () => terminateChildProcessTree2(child), { once: true });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ exitCode: code ?? 1 }));
+  });
+};
+function terminateChildProcessTree2(child) {
+  if (!child.pid) {
+    return;
+  }
+  if (process.platform === "win32") {
+    spawn2("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on(
+      "error",
+      () => {
+        child.kill();
+      }
+    );
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGTERM");
+  } catch {
+    child.kill();
+  }
+}
+var codexProvider = {
+  id: "codex",
+  runWorking: runWorking2,
+  runInteractive: runInteractive2
+};
+
+// src/known-cli-providers/providers/gemini/gemini-provider.ts
+import { spawn as spawn3 } from "child_process";
+import { writeFile as writeFile2 } from "fs/promises";
+var GEMINI_BINARY = "gemini";
+var GEMINI_RESULT_FIELD = "response";
+async function runWorking3(request, runner = spawnGeminiCapturingStdout) {
+  const args = buildGeminiWorkingArgs(request);
+  let result;
+  try {
+    result = await runner({
+      command: GEMINI_BINARY,
+      args,
+      cwd: request.cwd,
+      signal: request.signal
+    });
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_spawn_error",
+      message: "gemini provider process could not be started.",
+      details: { cause: error instanceof Error ? error.message : String(error) }
+    });
+  }
+  if (result.exitCode !== 0) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_failed",
+      message: `gemini provider process exited with code ${result.exitCode}.`,
+      details: { exitCode: result.exitCode }
+    });
+  }
+  if (request.captureMode === "raw-text") {
+    let text;
+    try {
+      text = extractEnvelopeText(result.stdout, { resultField: GEMINI_RESULT_FIELD });
+    } catch (error) {
+      throw new TrailStepFailureError({
+        code: "agent_provider_output_invalid",
+        message: "gemini provider stdout did not contain a usable result.",
+        details: { cause: error instanceof Error ? error.message : String(error) }
+      });
+    }
+    await writeFile2(request.outputFile, text, "utf8");
+  } else {
+    let output;
+    try {
+      output = extractEnvelopeOutput(result.stdout, { resultField: GEMINI_RESULT_FIELD });
+    } catch (error) {
+      throw new TrailStepFailureError({
+        code: "agent_provider_output_invalid",
+        message: "gemini provider stdout did not contain a usable JSON result.",
+        details: { cause: error instanceof Error ? error.message : String(error) }
+      });
+    }
+    await writeFile2(request.outputFile, `${JSON.stringify(output, null, 2)}
+`, "utf8");
+  }
+}
+function buildGeminiWorkingArgs(request) {
+  const args = ["-p", promptFileReference(request.promptFile), "--yolo"];
+  if (request.model) {
+    args.push("-m", request.model);
+  }
+  args.push("--output-format", "json");
+  return args;
+}
+async function runInteractive3(request, runner = spawnGeminiInteractive) {
+  const args = [];
+  if (request.model) {
+    args.push("-m", request.model);
+  }
+  args.push(
+    request.systemPromptFile ? promptFileReference(request.systemPromptFile) : request.prompt
+  );
+  return await runner({
+    command: GEMINI_BINARY,
+    args,
+    cwd: request.cwd,
+    shell: false,
+    stdio: "inherit",
+    env: request.env,
+    signal: request.signal
+  });
+}
+var spawnGeminiCapturingStdout = async ({
+  command,
+  args,
+  cwd,
+  signal
+}) => {
+  return await new Promise((resolve2, reject) => {
+    const child = spawn3(command, args, {
+      cwd,
+      shell: false,
+      stdio: ["ignore", "pipe", "inherit"],
+      detached: process.platform !== "win32"
+    });
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    signal?.addEventListener("abort", () => terminateChildProcessTree3(child), { once: true });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ exitCode: code ?? 1, stdout }));
+  });
+};
+var spawnGeminiInteractive = async ({
+  command,
+  args,
+  cwd,
+  env,
+  signal
+}) => {
+  return await new Promise((resolve2, reject) => {
+    const child = spawn3(command, args, {
+      cwd,
+      env,
+      signal,
+      detached: process.platform !== "win32",
+      shell: false,
+      stdio: "inherit"
+    });
+    signal?.addEventListener("abort", () => terminateChildProcessTree3(child), { once: true });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ exitCode: code ?? 1 }));
+  });
+};
+function terminateChildProcessTree3(child) {
+  if (!child.pid) {
+    return;
+  }
+  if (process.platform === "win32") {
+    spawn3("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on(
+      "error",
+      () => {
+        child.kill();
+      }
+    );
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGTERM");
+  } catch {
+    child.kill();
+  }
+}
+var geminiProvider = {
+  id: "gemini",
+  runWorking: runWorking3,
+  runInteractive: runInteractive3
+};
+
+// src/known-cli-providers/providers/pi/pi-provider.ts
+import { spawn as spawn4 } from "child_process";
+import { writeFile as writeFile3 } from "fs/promises";
+import { StringDecoder } from "string_decoder";
+
+// src/known-cli-providers/process/resolve-cli-command.ts
+import { constants } from "fs";
+import { access, readFile } from "fs/promises";
+import { dirname, extname, join } from "path";
+var WINDOWS_EXECUTABLE_EXTENSIONS = [".cmd", ".exe", ".bat", ""];
+async function resolveCliCommandForSpawn(request, options = {}) {
+  if ((options.platform ?? process.platform) !== "win32") {
+    return request;
+  }
+  const commandPath = await findWindowsCommandPath(request.command, request.env ?? process.env);
+  if (!commandPath) {
+    return request;
+  }
+  if (isWindowsCommandShim(commandPath)) {
+    const nodeScript = await readNpmCmdShimEntrypoint(commandPath);
+    if (nodeScript) {
+      return {
+        command: options.execPath ?? process.execPath,
+        args: [nodeScript, ...request.args]
+      };
+    }
+    return {
+      command: "cmd.exe",
+      args: ["/d", "/s", "/c", commandPath, ...request.args]
+    };
+  }
+  return { command: commandPath, args: request.args };
+}
+async function findWindowsCommandPath(command, env) {
+  const commandCandidates = windowsCommandCandidates(command);
+  if (hasPathSeparator(command)) {
+    return await firstExistingPath(commandCandidates);
+  }
+  const pathValue = readCaseInsensitiveEnv(env, "PATH");
+  if (!pathValue) {
+    return await firstExistingPath(commandCandidates);
+  }
+  for (const directory of pathValue.split(windowsPathDelimiter()).filter(Boolean)) {
+    const found = await firstExistingPath(
+      commandCandidates.map((candidate) => join(directory, candidate))
+    );
+    if (found) {
+      return found;
+    }
+  }
+  return void 0;
+}
+function windowsCommandCandidates(command) {
+  if (extname(command)) {
+    return [command];
+  }
+  return WINDOWS_EXECUTABLE_EXTENSIONS.map((extension) => `${command}${extension}`);
+}
+async function firstExistingPath(paths) {
+  for (const path of paths) {
+    try {
+      await access(path, constants.X_OK);
+      return path;
+    } catch {
+      try {
+        await access(path, constants.F_OK);
+        return path;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+async function readNpmCmdShimEntrypoint(commandPath) {
+  let shim;
+  try {
+    shim = await readFile(commandPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const match = shim.match(/"%dp0%\\?([^"]+?\.js)"\s+%\*/i);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  return join(dirname(commandPath), match[1].replace(/\\/g, "/"));
+}
+function isWindowsCommandShim(path) {
+  const extension = extname(path).toLowerCase();
+  return extension === ".cmd" || extension === ".bat";
+}
+function hasPathSeparator(command) {
+  return command.includes("/") || command.includes("\\");
+}
+function readCaseInsensitiveEnv(env, key) {
+  return Object.entries(env).find(([name]) => name.toLowerCase() === key.toLowerCase())?.[1];
+}
+function windowsPathDelimiter() {
+  return ";";
+}
+
+// src/known-cli-providers/providers/pi/pi-provider.ts
+var PI_BINARY = "pi";
+var PI_RESULT_FIELD = "message";
+var PI_STDOUT_FALLBACK_TAIL_CHARS = 128e3;
+async function runWorking4(request, runner = spawnPiCapturingStdout) {
+  const args = buildPiWorkingArgs(request);
+  let result;
+  try {
+    result = await runner({ command: PI_BINARY, args, cwd: request.cwd, signal: request.signal });
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_spawn_error",
+      message: "pi provider process could not be started.",
+      details: { cause: error instanceof Error ? error.message : String(error) }
+    });
+  }
+  if (request.captureMode === "raw-text") {
+    let text;
+    try {
+      text = extractEnvelopeText(result.stdout, { resultField: PI_RESULT_FIELD });
+    } catch (error) {
+      throwPiOutputFailure({ exitCode: result.exitCode, error, json: false });
+    }
+    await writeFile3(request.outputFile, text, "utf8");
+    return;
+  }
+  let output;
+  try {
+    output = extractEnvelopeOutput(result.stdout, { resultField: PI_RESULT_FIELD });
+  } catch (error) {
+    throwPiOutputFailure({ exitCode: result.exitCode, error, json: true });
+  }
+  await writeFile3(request.outputFile, `${JSON.stringify(output, null, 2)}
+`, "utf8");
+}
+function throwPiOutputFailure(options) {
+  if (options.exitCode !== 0) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_failed",
+      message: `pi provider process exited with code ${options.exitCode}.`,
+      details: { exitCode: options.exitCode }
+    });
+  }
+  throw new TrailStepFailureError({
+    code: "agent_provider_output_invalid",
+    message: options.json ? "pi provider stdout did not contain a usable JSON result." : "pi provider stdout did not contain a usable result.",
+    details: {
+      cause: options.error instanceof Error ? options.error.message : String(options.error)
+    }
+  });
+}
+function buildPiWorkingArgs(request) {
+  const args = ["-p"];
+  if (request.model) {
+    args.push("--model", request.model);
+  }
+  if (request.thinking) {
+    args.push("--thinking", request.thinking);
+  }
+  args.push(promptFileReference(request.promptFile));
+  args.push("--mode", "json");
+  return args;
+}
+async function runInteractive4(request, runner = spawnPiInteractive) {
+  const args = [];
+  if (request.model) {
+    args.push("--model", request.model);
+  }
+  args.push(
+    request.systemPromptFile ? promptFileReference(request.systemPromptFile) : request.prompt
+  );
+  return await runner({
+    command: PI_BINARY,
+    args,
+    cwd: request.cwd,
+    shell: false,
+    stdio: "inherit",
+    env: request.env,
+    signal: request.signal
+  });
+}
+var spawnPiCapturingStdout = async ({ command, args, cwd, signal }) => {
+  const executable = await resolveCliCommandForSpawn({ command, args });
+  return await new Promise((resolve2, reject) => {
+    const child = spawn4(executable.command, executable.args, {
+      cwd,
+      shell: false,
+      stdio: ["ignore", "pipe", "inherit"],
+      detached: process.platform !== "win32"
+    });
+    const stdout = createPiJsonStreamStdoutCollector();
+    child.stdout?.on("data", (chunk) => {
+      stdout.append(chunk);
+    });
+    signal?.addEventListener("abort", () => terminateChildProcessTree4(child), { once: true });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ exitCode: code ?? 1, stdout: stdout.finish() }));
+  });
+};
+function createPiJsonStreamStdoutCollector() {
+  const decoder = new StringDecoder("utf8");
+  let pendingLine = "";
+  let latestResultLine;
+  let fallbackTail = "";
+  function appendText(text) {
+    fallbackTail = trimFallbackTail(`${fallbackTail}${text}`);
+    pendingLine += text;
+    while (true) {
+      const newlineIndex = pendingLine.indexOf("\n");
+      if (newlineIndex === -1) {
+        return;
+      }
+      const line = pendingLine.slice(0, newlineIndex).replace(/\r$/u, "");
+      rememberLine(line);
+      pendingLine = pendingLine.slice(newlineIndex + 1);
+    }
+  }
+  return {
+    append(chunk) {
+      appendText(decoder.write(chunk));
+    },
+    finish() {
+      appendText(decoder.end());
+      rememberLine(pendingLine);
+      pendingLine = "";
+      return latestResultLine ?? fallbackTail;
+    }
+  };
+  function rememberLine(line) {
+    const trimmed = line.trim();
+    if (trimmed && isPiResultCandidateLine(trimmed)) {
+      latestResultLine = trimmed;
+    }
+  }
+}
+function trimFallbackTail(value) {
+  if (value.length <= PI_STDOUT_FALLBACK_TAIL_CHARS) {
+    return value;
+  }
+  return value.slice(-PI_STDOUT_FALLBACK_TAIL_CHARS);
+}
+function isPiResultCandidateLine(line) {
+  return line.includes(`"${PI_RESULT_FIELD}"`);
+}
+var spawnPiInteractive = async ({
+  command,
+  args,
+  cwd,
+  env,
+  signal
+}) => {
+  const executable = await resolveCliCommandForSpawn({ command, args, env });
+  return await new Promise((resolve2, reject) => {
+    const child = spawn4(executable.command, executable.args, {
+      cwd,
+      env,
+      signal,
+      detached: process.platform !== "win32",
+      shell: false,
+      stdio: "inherit"
+    });
+    signal?.addEventListener("abort", () => terminateChildProcessTree4(child), { once: true });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ exitCode: code ?? 1 }));
+  });
+};
+function terminateChildProcessTree4(child) {
+  if (!child.pid) {
+    return;
+  }
+  if (process.platform === "win32") {
+    spawn4("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on(
+      "error",
+      () => {
+        child.kill();
+      }
+    );
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGTERM");
+  } catch {
+    child.kill();
+  }
+}
+var piProvider = {
+  id: "pi",
+  runWorking: runWorking4,
+  runInteractive: runInteractive4
+};
+
+// src/known-cli-providers/registry/provider-registry.ts
+var providerRegistry = {
+  claude: claudeProvider,
+  codex: codexProvider,
+  pi: piProvider,
+  gemini: geminiProvider
+};
+function isProviderRegistryKey(provider) {
+  return Object.hasOwn(providerRegistry, provider);
+}
+
+// src/agent-targeting/parse-trailstep-config/validate-provider-references.ts
+function validateProviderReferences(options) {
+  const providerViolations = [];
+  validateAgentMappings("agents", options.agents, options.providerNames, providerViolations);
+  if (options.workflows !== void 0) {
+    for (const [workflowId, workflow] of Object.entries(options.workflows)) {
+      validateAgentMappings(
+        `workflows.${workflowId}.agents`,
+        workflow.agents,
+        options.providerNames,
+        providerViolations
+      );
+    }
+  }
+  if (providerViolations.length > 0) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_unknown",
+      message: "One or more agent targets reference a provider that is neither a built-in provider nor a declared customProviders entry.",
+      details: { diagnostics: providerViolations }
+    });
+  }
+}
+function validateAgentMappings(path, mappings, providerNames, diagnostics) {
+  if (mappings === void 0) {
+    return;
+  }
+  for (const [name, targets] of Object.entries(mappings)) {
+    validateTargetReferences(`${path}.${name}`, targets, providerNames, diagnostics);
+  }
+}
+function validateTargetReferences(path, targets, providerNames, diagnostics) {
+  for (const [index, target] of targets.entries()) {
+    if (!("provider" in target)) {
+      continue;
+    }
+    if (!providerNames.has(target.provider) && !isProviderRegistryKey(target.provider)) {
+      diagnostics.push(
+        `${path}[${index}].provider references unknown provider '${target.provider}'. Declare it under customProviders or use a built-in provider.`
+      );
+    }
+  }
+}
+
+// src/agent-targeting/parse-trailstep-config/parse-trailstep-config.ts
+var parsedConfigs = /* @__PURE__ */ new WeakSet();
+function isParsedTrailStepConfig(value) {
+  return isRecord(value) && parsedConfigs.has(value);
+}
+function parseTrailStepConfig(value) {
+  const diagnostics = [];
+  if (!isRecord(value)) {
+    throwValidationFailure(["config must be an object."]);
+  }
+  if (value.version !== 1) {
+    diagnostics.push("version must be 1.");
+  }
+  const customProviders = parseCustomProviders(value.customProviders, diagnostics);
+  const providerNames = new Set(Object.keys(customProviders));
+  const agents = parseAgentMappings("agents", value.agents, diagnostics);
+  const settings = parseSettings("settings", value.settings, diagnostics);
+  const workflows = parseWorkflows(value.workflows, diagnostics);
+  if (diagnostics.length > 0) {
+    throwValidationFailure(diagnostics);
+  }
+  validateProviderReferences({ agents, workflows, providerNames });
+  const expanded = expandAgentRefs({ agents, workflows });
+  const config = {
+    version: 1,
+    customProviders,
+    agents: expanded.agents,
+    ...settings === void 0 ? {} : { settings },
+    ...expanded.workflows === void 0 ? {} : { workflows: expanded.workflows }
+  };
+  parsedConfigs.add(config);
+  return config;
+}
+
+// src/agent-targeting/resolve-agent-targets/resolve-agent-targets.ts
+function resolveAgentTargets(options) {
+  const workflowMappings = options.config.workflows?.[options.workflowId]?.agents;
+  const targetLists = [
+    workflowMappings?.[options.roleName],
+    options.config.agents[options.roleSize],
+    options.config.agents.default
+  ];
+  const targets = targetLists.flatMap(
+    (targets2) => targets2 && targets2.length > 0 ? [...targets2] : []
+  );
+  if (targets.length > 0) {
+    return targets;
+  }
+  throw new TrailStepFailureError({
+    code: "agent_targets_unavailable",
+    message: `No agent targets found for role ${options.roleName} with size ${options.roleSize} in workflow ${options.workflowId}.`,
+    details: {
+      roleName: options.roleName,
+      roleSize: options.roleSize,
+      workflowId: options.workflowId
+    }
+  });
+}
+
+// src/runtime/artifacts/run-storage.ts
+import { appendFile, mkdir, readFile as readFile2, writeFile as writeFile4 } from "fs/promises";
+import { basename, dirname as dirname2, join as join2 } from "path";
+function defaultRunsRoot(cwd) {
+  return join2(cwd, ".trailstep", "runs");
+}
+async function createRunDirectory(options) {
+  const runsRoot = options.runsRoot ?? defaultRunsRoot(options.cwd);
+  await mkdir(runsRoot, { recursive: true });
+  await ensureTrailStepGitignoreForRunsRoot(runsRoot);
+  for (let suffix = 1; ; suffix += 1) {
+    const runId = suffix === 1 ? options.runName : `${options.runName}-${suffix}`;
+    const runDir = join2(runsRoot, runId);
+    try {
+      await mkdir(runDir);
+      return { runId, runDir };
+    } catch (error) {
+      if (isNodeError(error) && error.code === "EEXIST") {
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+async function appendEvent(runDir, event) {
+  await appendFile(join2(runDir, "events.jsonl"), `${JSON.stringify(event)}
+`, "utf8");
+}
+async function readRunEvents(runDir) {
+  let contents;
+  try {
+    contents = await readFile2(join2(runDir, "events.jsonl"), "utf8");
+  } catch (error) {
+    if (isNodeError(error)) {
+      throw new TrailStepFailureError({
+        code: "resume_target_not_found",
+        message: `Resume target not found or unreadable: ${join2(runDir, "events.jsonl")}.`,
+        details: { runDir, causeCode: error.code }
+      });
+    }
+    throw error;
+  }
+  const rawLines = contents.split("\n");
+  const lines = rawLines.filter((line, index) => line.length > 0 || index < rawLines.length - 1);
+  const events = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line) {
+      continue;
+    }
+    try {
+      events.push(JSON.parse(line));
+    } catch (error) {
+      const isTrailingLine = index === lines.length - 1;
+      if (isTrailingLine) {
+        return events;
+      }
+      throw error;
+    }
+  }
+  return events;
+}
+async function writeDocumentArtifact(dir, filename, content) {
+  await mkdir(dir, { recursive: true });
+  const documentPath = join2(dir, filename);
+  await writeFile4(documentPath, content, "utf8");
+  return documentPath;
+}
+async function readRunState(runDir) {
+  try {
+    const contents = await readFile2(join2(runDir, "state.json"), "utf8");
+    const parsed = JSON.parse(contents);
+    if (!isRunState(parsed)) {
+      throw new Error("run state must be a JSON object");
+    }
+    return parsed;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+async function writeRunState(runDir, state2) {
+  await writeFile4(join2(runDir, "state.json"), `${JSON.stringify(state2, null, 2)}
+`, "utf8");
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+function isRunState(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+async function ensureTrailStepGitignoreForRunsRoot(runsRoot) {
+  const trailstepRoot = dirname2(runsRoot);
+  if (basename(trailstepRoot) !== ".trailstep") {
+    return;
+  }
+  await ensureTrailStepGitignore(trailstepRoot);
+}
+async function ensureTrailStepGitignore(trailstepRoot) {
+  try {
+    await writeFile4(join2(trailstepRoot, ".gitignore"), "*\n!.gitignore\n", { flag: "wx" });
+  } catch (error) {
+    if (isNodeError(error) && error.code === "EEXIST") {
+      return;
+    }
+    throw error;
+  }
+}
+
+// src/runtime/run-context/run-context-storage.ts
+import { AsyncLocalStorage } from "async_hooks";
+var RUN_CONTEXT_STORAGE_KEY = /* @__PURE__ */ Symbol.for("trailstep.core.runContextStorage");
+var globalScope = globalThis;
+function getOrCreateRunContextStorage() {
+  const existing = globalScope[RUN_CONTEXT_STORAGE_KEY];
+  if (existing) {
+    return existing;
+  }
+  const created = new AsyncLocalStorage();
+  globalScope[RUN_CONTEXT_STORAGE_KEY] = created;
+  return created;
+}
+var runContextStorage = getOrCreateRunContextStorage();
+function currentRunContext() {
+  const runContext = runContextStorage.getStore();
+  if (!runContext) {
+    throw new Error("state.* called outside an active TrailStep run.");
+  }
+  return runContext;
+}
+
+// src/authoring/document/document.ts
+var Document = class _Document {
+  constructor(content, path) {
+    this.content = content;
+    this.path = path;
+  }
+  content;
+  path;
+  static captureMode = "raw-text";
+  static jsonSchema = {
+    type: "string",
+    description: "Document content, captured as raw text."
+  };
+  static validate(value) {
+    return isDocumentLike(value);
+  }
+  static diagnostics(value) {
+    if (isDocumentLike(value)) {
+      return [];
+    }
+    return [
+      { path: "/", message: "must be a document (an object with string content and path fields)" }
+    ];
+  }
+  /**
+   * Deliberately duck-types instead of checking `instanceof Document`: on
+   * resume, a completed step's recorded output is replayed from
+   * `events.jsonl` via `JSON.parse`, producing a plain deserialized object —
+   * never a live `Document` instance — before `assert` is called on it. An
+   * `instanceof` check would fail every such replay. `assert` reconstructs a
+   * genuine `Document` from any content/path-shaped value, so every
+   * consumer downstream — a live capture or a replayed value alike — always
+   * receives a real `Document` instance with working prototype methods.
+   */
+  static assert(value, label = "value") {
+    const valueDiagnostics = _Document.diagnostics(value);
+    if (valueDiagnostics.length > 0 || !isDocumentLike(value)) {
+      throw new TrailStepFailureError(
+        validationFailure(
+          `${label} failed schema validation: ${formatDiagnostics(valueDiagnostics)}`,
+          {
+            diagnostics: valueDiagnostics
+          }
+        )
+      );
+    }
+    return new _Document(value.content, value.path);
+  }
+};
+async function document(content) {
+  const { currentStep } = currentRunContext();
+  if (!currentStep) {
+    throw new Error(
+      "document(...) must be called from within a step's `.do()` callback; no active step context was found."
+    );
+  }
+  const index = currentStep.nextDocumentIndex();
+  const path = await writeDocumentArtifact(currentStep.dir, `document-${index}.md`, content);
+  return new Document(content, path);
+}
+function isDocumentLike(value) {
+  return typeof value === "object" && value !== null && typeof value.content === "string" && typeof value.path === "string";
+}
+function formatDiagnostics(diagnostics) {
+  return diagnostics.map((diagnostic) => `${diagnostic.path} ${diagnostic.message}`).join("; ");
+}
+
+// src/authoring/prompt-composition/prompt-composition.ts
+import { readFileSync } from "fs";
+import { join as join3 } from "path";
+function loadFragments(dir, files) {
+  const fragments = {};
+  for (const key of Object.keys(files)) {
+    fragments[key] = readFileSync(join3(dir, files[key]), "utf8").trimEnd();
+  }
+  return fragments;
+}
+function section(title, body) {
+  return body ? `## ${title}
+
+${body.trimEnd()}` : void 0;
+}
+function promptSections(...parts) {
+  return parts.filter((part) => Boolean(part)).join("\n\n");
+}
+function list(items) {
+  return items.map((item) => `- ${item}`).join("\n");
+}
+
+// src/authoring/prompt-template/prompt-template.ts
+function promptTemplate(path) {
+  return { kind: "promptTemplate", path };
+}
+
+// src/authoring/shape/json-schema.ts
+import { Ajv } from "ajv/dist/ajv.js";
+var ajv = new Ajv({ allErrors: true });
+function normalizeShape(shapeInput) {
+  if (isSchema(shapeInput)) {
+    return shapeInput;
+  }
+  return shape(shapeInput);
+}
+function shape(shapeObject) {
+  return jsonSchema({
+    type: "object",
+    properties: Object.fromEntries(
+      Object.entries(shapeObject).map(([key, type]) => [key, { type }])
+    ),
+    required: Object.keys(shapeObject),
+    additionalProperties: false
+  });
+}
+function jsonSchema(schema) {
+  const validateWithAjv = ajv.compile(schema);
+  return {
+    validate(value) {
+      return validateWithAjv(value);
+    },
+    diagnostics(value) {
+      if (!isPlainObject2(value)) {
+        return [{ path: "/", message: "must be a plain object" }];
+      }
+      if (validateWithAjv(value)) {
+        return [];
+      }
+      return diagnosticsFromAjvErrors(validateWithAjv.errors);
+    },
+    assert(value, label = "value") {
+      const diagnostics = this.diagnostics(value);
+      if (diagnostics.length > 0) {
+        throw new TrailStepFailureError(
+          validationFailure(
+            `${label} failed schema validation: ${formatDiagnostics2(diagnostics)}`,
+            { diagnostics }
+          )
+        );
+      }
+      return value;
+    },
+    jsonSchema: schema
+  };
+}
+function isSchema(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.validate === "function" && typeof candidate.diagnostics === "function" && typeof candidate.assert === "function";
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function diagnosticsFromAjvErrors(errors) {
+  if (!errors || errors.length === 0) {
+    return [{ path: "/", message: "is invalid" }];
+  }
+  return errors.map((error) => ({
+    path: error.instancePath || "/",
+    message: error.message ?? "is invalid"
+  }));
+}
+function formatDiagnostics2(diagnostics) {
+  return diagnostics.map((diagnostic) => `${diagnostic.path} ${diagnostic.message}`).join("; ");
+}
+
+// src/authoring/state/state.ts
+var state = {
+  async get(key) {
+    return currentRunContext().state.get(key);
+  },
+  async set(key, value) {
+    await currentRunContext().state.set(key, value);
+  },
+  get id() {
+    return currentRunContext().id;
+  },
+  get name() {
+    return currentRunContext().name;
+  },
+  get path() {
+    return currentRunContext().path;
+  },
+  get cwd() {
+    return currentRunContext().cwd;
+  }
+};
+
+// src/authoring/step/step-node.ts
+function step(config) {
+  const buildFactory = (prompt, promptOptions, onOutput, onError) => {
+    const factory = ((input) => ({
+      kind: "step",
+      config: {
+        ...config,
+        ...promptOptions,
+        prompt,
+        input: input ?? {}
+      },
+      onOutput,
+      onError
+    }));
+    factory.catch = (nextOnError) => buildFactory(prompt, promptOptions, onOutput, nextOnError);
+    return factory;
+  };
+  return {
+    prompt(source, options) {
+      if (hasRetryOption(options)) {
+        throw new TypeError("Retry config belongs on step(...), not .prompt(...) options.");
+      }
+      if (hasTimeoutOption(options)) {
+        throw new TypeError("Timeout config belongs on step(...), not .prompt(...) options.");
+      }
+      return {
+        do: (onOutput) => buildFactory(source, options, onOutput)
+      };
+    },
+    do(onOutput) {
+      return buildFactory(void 0, void 0, onOutput);
+    }
+  };
+}
+function done(output) {
+  return {
+    kind: "done",
+    output: output ?? {}
+  };
+}
+function fail(failure) {
+  return {
+    kind: "fail",
+    failure
+  };
+}
+function isStepNode(value) {
+  return isPlainObject3(value) && value.kind === "step";
+}
+function isDoneNode(value) {
+  return isPlainObject3(value) && value.kind === "done";
+}
+function isFailNode(value) {
+  return isPlainObject3(value) && value.kind === "fail";
+}
+function hasRetryOption(value) {
+  return isPlainObject3(value) && "retry" in value;
+}
+function hasTimeoutOption(value) {
+  return isPlainObject3(value) && "timeout" in value;
+}
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+
+// src/runtime/sub-prompts/run-sub-prompt.ts
+import { mkdir as mkdir4, writeFile as writeFile8 } from "fs/promises";
+
+// src/agent-execution/adapter-agent/run-adapter-agent-step/run-adapter-agent-step.ts
+var PROVIDER_NEUTRAL_ADAPTER_KEY = "custom";
+var PROVIDER_NEUTRAL_MODEL = "configured-agent";
+async function runAgentStep(options) {
+  const model = resolveAgentRequirements(options.step.requirements);
+  const adapter = resolveAgentAdapter(options.step.adapter);
+  let submittedOutput;
+  const tools = [
+    createSubmitOutputTool(options.step.output, async (output) => {
+      options.step.output.assert(output, `agent step ${options.step.id} submit_output`);
+      submittedOutput = output;
+      await options.onToolCall?.({
+        name: "submit_output",
+        input: output,
+        output: { accepted: true }
+      });
+    })
+  ];
+  const prompt = renderAgentPrompt(options.step.prompt, options.input);
+  await adapter({
+    messages: [{ role: "user", content: prompt }],
+    tools,
+    requirements: options.step.requirements,
+    model,
+    step: options.step,
+    input: options.input
+  });
+  if (submittedOutput === void 0) {
+    throw new TrailStepFailureError({
+      code: "agent_output_missing",
+      message: `Agent step ${options.step.id} did not call submit_output.`
+    });
+  }
+  return submittedOutput;
+}
+function renderAgentPrompt(prompt, input) {
+  return typeof prompt === "function" ? prompt({ input }) : prompt;
+}
+function resolveAgentRequirements(requirements) {
+  return {
+    adapterKey: PROVIDER_NEUTRAL_ADAPTER_KEY,
+    model: requirements.name ?? requirements.size ?? PROVIDER_NEUTRAL_MODEL
+  };
+}
+function resolveAgentAdapter(selection) {
+  if (typeof selection === "function") {
+    return selection;
+  }
+  if (typeof selection === "object" && selection !== null) {
+    return (request) => selection.runAgentStep(request);
+  }
+  throw new TrailStepFailureError({
+    code: "agent_adapter_unavailable",
+    message: "Agent steps that do not use a configured command runner require a custom adapter function or adapter object."
+  });
+}
+function createSubmitOutputTool(schema, onOutput) {
+  return {
+    name: "submit_output",
+    description: "Submit the typed output for this TrailStep agent step.",
+    schema,
+    async call(input) {
+      await onOutput(input);
+    }
+  };
+}
+
+// src/agent-execution/dispatch-agent-step/dispatch-agent-step.ts
+import { readFile as readFile5 } from "fs/promises";
+import { resolve } from "path";
+
+// src/runtime/artifacts/step-artifacts.ts
+import { join as join4 } from "path";
+function resolveStepArtifactPaths(options) {
+  const artifactStepId = `${String(options.stepIndex).padStart(4, "0")}-${sanitizeStepId(
+    options.stepId
+  )}`;
+  const runRelativeStepDir = `steps/${artifactStepId}`;
+  const runRelativeSessionDescriptionFile = `${runRelativeStepDir}/session-description.md`;
+  const stepDir = join4(options.runDir, "steps", artifactStepId);
+  return {
+    artifactStepId,
+    stepDir,
+    promptFile: join4(stepDir, "prompt.txt"),
+    outputFile: join4(stepDir, "output.json"),
+    usageFile: join4(stepDir, "usage.json"),
+    interactiveFile: join4(stepDir, "interactive.json"),
+    sessionDescriptionFile: join4(stepDir, "session-description.md"),
+    runRelativeStepDir,
+    runRelativeSessionDescriptionFile
+  };
+}
+function sanitizeStepId(stepId) {
+  return stepId.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "step";
+}
+
+// src/runtime/events/create-run-event.ts
+import { randomUUID } from "crypto";
+function createEvent(options) {
+  return {
+    id: `evt_${randomUUID()}`,
+    runId: options.runId,
+    workflowId: options.workflowId,
+    stepId: options.stepId,
+    type: options.type,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    schemaVersion: "v0",
+    payload: options.payload ?? {}
+  };
+}
+
+// src/agent-execution/interactive-agent/run-interactive-agent-command.ts
+import { spawn as spawn5 } from "child_process";
+import { mkdir as mkdir2, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+
+// src/runtime/interactive-session/interactive-session-protocol.ts
+import { readFile as readFile3 } from "fs/promises";
+import { setTimeout as delay } from "timers/promises";
+async function waitForInteractiveCompletion(interactiveFile, signal) {
+  while (!signal.aborted) {
+    if (await isInteractiveCompleted(interactiveFile)) {
+      return;
+    }
+    await delay(100, void 0, { signal }).catch(() => void 0);
+  }
+}
+async function isInteractiveCompleted(interactiveFile) {
+  try {
+    const protocol = await readPlainJsonFile(interactiveFile, {
+      readCode: "interactive_session_invalid",
+      invalidCode: "interactive_session_invalid",
+      message: "Interactive session protocol file is invalid."
+    });
+    return protocol.status === "completed" || protocol.status === "cancelled";
+  } catch {
+    return false;
+  }
+}
+async function readCompletedInteractiveOutput(options) {
+  const protocol = await readPlainJsonFile(options.interactiveFile, {
+    readCode: "interactive_session_invalid",
+    invalidCode: "interactive_session_invalid",
+    message: `Interactive agent step ${options.stepId} has an invalid interactive.json file.`
+  });
+  if (protocol.status === "cancelled") {
+    throw new TrailStepFailureError({
+      code: "interactive_session_cancelled",
+      message: `Interactive agent step ${options.stepId} was cancelled.`,
+      details: {
+        status: protocol.status,
+        ...typeof protocol.reason === "string" ? { reason: protocol.reason } : {}
+      }
+    });
+  }
+  if (protocol.status !== "completed") {
+    throw new TrailStepFailureError({
+      code: "interactive_session_incomplete",
+      message: `Interactive agent step ${options.stepId} did not complete the file-based protocol.`,
+      details: { status: protocol.status }
+    });
+  }
+  const outputFile = requireProtocolString(protocol.outputFile, "outputFile", options.stepId);
+  const output = await readPlainJsonFile(outputFile, {
+    readCode: "interactive_output_missing",
+    invalidCode: "interactive_output_invalid",
+    message: `Interactive agent step ${options.stepId} completed without a valid output.json file.`
+  });
+  const diagnostics = options.outputSchema.diagnostics(output);
+  if (diagnostics.length > 0) {
+    throw new TrailStepFailureError({
+      code: "interactive_output_invalid",
+      message: `Interactive agent step ${options.stepId} output.json failed schema validation: ${formatDiagnostics3(diagnostics)}`,
+      details: { diagnostics }
+    });
+  }
+  return output;
+}
+async function readPlainJsonFile(path, failure) {
+  let contents;
+  try {
+    contents = await readFile3(path, "utf8");
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: failure.readCode,
+      message: failure.message,
+      details: { path, cause: error instanceof Error ? error.message : String(error) }
+    });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: failure.invalidCode,
+      message: failure.message,
+      details: { path, cause: error instanceof Error ? error.message : String(error) }
+    });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new TrailStepFailureError({
+      code: failure.invalidCode,
+      message: `${failure.message} Expected a plain JSON object.`,
+      details: { path }
+    });
+  }
+  return parsed;
+}
+function requireProtocolString(value, field, stepId) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  throw new TrailStepFailureError({
+    code: "interactive_session_invalid",
+    message: `Interactive agent step ${stepId} interactive.json is missing ${field}.`
+  });
+}
+function formatDiagnostics3(diagnostics) {
+  return diagnostics.map((diagnostic) => `${diagnostic.path} ${diagnostic.message}`).join("; ");
+}
+
+// src/agent-execution/interactive-agent/run-interactive-agent-command.ts
+async function runInteractiveAgentCommand(options) {
+  const [target] = resolveAgentTargets({
+    config: options.config,
+    workflowId: options.workflowId,
+    roleName: options.roleName,
+    roleSize: options.role.size
+  });
+  if (!target) {
+    throw new TrailStepFailureError({
+      code: "agent_targets_unavailable",
+      message: `No interactive agent targets found for role ${options.roleName} with size ${options.role.size} in workflow ${options.workflowId}.`
+    });
+  }
+  return await runInteractiveAgentTarget({ ...options, target });
+}
+async function runInteractiveAgentTarget(options) {
+  const files = options.artifactPaths;
+  await prepareInteractiveArtifacts({
+    files,
+    runDir: options.runDir,
+    stepId: options.stepId,
+    outputSchema: options.outputSchema,
+    outputMode: options.outputMode
+  });
+  const prompt = buildInteractivePrompt({
+    renderedPrompt: options.renderedPrompt,
+    files,
+    outputSchema: options.outputSchema,
+    outputMode: options.outputMode
+  });
+  const env = { ...definedProcessEnv(), TRAILSTEP_INTERACTIVE_FILE: files.interactiveFile };
+  const abortController = new AbortController();
+  options.signal?.addEventListener("abort", () => abortController.abort(), { once: true });
+  const provider = providerRegistry[options.target.provider];
+  if (provider) {
+    return await runProcessUntilExitOrCompletion({
+      stepId: options.stepId,
+      target: options.target.provider,
+      interactiveFile: files.interactiveFile,
+      abortController,
+      readOutput: async () => await readCompletedOutput(options),
+      runProcess: async () => {
+        await writeFile5(files.promptFile, prompt, "utf8");
+        return await provider.runInteractive(
+          {
+            prompt,
+            systemPromptFile: files.promptFile,
+            cwd: files.stepDir,
+            env,
+            signal: abortController.signal,
+            ...options.target.model === void 0 ? {} : { model: options.target.model },
+            ...options.target.permissionMode === void 0 ? {} : { permissionMode: options.target.permissionMode }
+          },
+          options.runner
+        );
+      }
+    });
+  }
+  const agentConfig = options.config.customProviders[options.target.provider];
+  if (!agentConfig) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_unavailable",
+      message: `Interactive agent target '${options.target.provider}' does not reference a configured custom agent.`,
+      details: { provider: options.target.provider }
+    });
+  }
+  if (!agentConfig.interactiveArgs) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_interactive_unsupported",
+      message: `Custom provider '${options.target.provider}' cannot run interactive agent steps because customProviders.${options.target.provider}.interactiveArgs is not declared.`,
+      details: { provider: options.target.provider }
+    });
+  }
+  const args = await substitutePromptPlaceholders({
+    argv: options.target.args ?? agentConfig.interactiveArgs,
+    prompt,
+    promptFile: files.promptFile,
+    model: options.target.model
+  });
+  return await runProcessUntilExitOrCompletion({
+    stepId: options.stepId,
+    target: options.target.provider,
+    interactiveFile: files.interactiveFile,
+    abortController,
+    readOutput: async () => await readCompletedOutput(options),
+    mapSpawnError: (error) => new TrailStepFailureError({
+      code: "interactive_command_spawn_error",
+      message: `Interactive agent step ${options.stepId} could not start target '${options.target.provider}'.`,
+      details: {
+        target: options.target.provider,
+        ...options.target.model === void 0 ? {} : { model: options.target.model },
+        cause: error instanceof Error ? error.message : String(error)
+      }
+    }),
+    runProcess: async () => await (options.runner ?? spawnInteractiveProcess)({
+      command: agentConfig.binary,
+      args,
+      cwd: files.stepDir,
+      shell: false,
+      stdio: "inherit",
+      env,
+      signal: abortController.signal
+    })
+  });
+}
+function definedProcessEnv() {
+  return Object.fromEntries(
+    Object.entries(process.env).filter(
+      (entry) => entry[1] !== void 0
+    )
+  );
+}
+async function runProcessUntilExitOrCompletion(options) {
+  const processPromise = options.runProcess();
+  void processPromise.catch(() => void 0);
+  const watcherAbortController = new AbortController();
+  const winner = await Promise.race([
+    processPromise.then(
+      (result) => ({ type: "process", result }),
+      (error) => ({ type: "processError", error })
+    ),
+    waitForInteractiveCompletion(options.interactiveFile, watcherAbortController.signal).then(
+      () => ({ type: "completed" })
+    )
+  ]);
+  watcherAbortController.abort();
+  if (winner.type === "processError") {
+    throw options.mapSpawnError?.(winner.error) ?? winner.error;
+  }
+  if (winner.type === "process") {
+    if (await isInteractiveCompleted(options.interactiveFile)) {
+      return { exitCode: 0, output: await options.readOutput() };
+    }
+    if (winner.result.exitCode !== 0) {
+      throw new TrailStepFailureError({
+        code: "interactive_session_failed",
+        message: `Interactive agent step ${options.stepId} exited with code ${winner.result.exitCode}.`,
+        details: { exitCode: winner.result.exitCode, target: options.target }
+      });
+    }
+    return { exitCode: winner.result.exitCode, output: await options.readOutput() };
+  }
+  options.abortController.abort();
+  return { exitCode: 0, output: await options.readOutput() };
+}
+async function prepareInteractiveArtifacts(options) {
+  await mkdir2(options.files.stepDir, { recursive: true });
+  await writeFile5(
+    options.files.interactiveFile,
+    `${JSON.stringify(
+      {
+        status: "active",
+        stepId: options.stepId,
+        artifactStepId: options.files.artifactStepId,
+        outputMode: options.outputMode,
+        runDir: options.runDir,
+        stepDir: options.files.stepDir,
+        promptFile: options.files.promptFile,
+        outputFile: options.files.outputFile,
+        interactiveFile: options.files.interactiveFile,
+        ...options.outputMode === "session-file" ? {
+          sessionDescriptionFile: options.files.sessionDescriptionFile,
+          runRelativeSessionDescriptionFile: options.files.runRelativeSessionDescriptionFile
+        } : {},
+        runRelativeStepDir: options.files.runRelativeStepDir,
+        outputSchema: options.outputSchema.jsonSchema
+      },
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+}
+function buildInteractivePrompt(options) {
+  const preamble = options.outputMode === "session-file" ? [
+    "You are running inside a TrailStep interactive step.",
+    "Write a dense session description to session-description.md in the current directory.",
+    "preserve as much usable context as possible.",
+    "describe the conversation rather than aggressively summarize it.",
+    "include decisions, rejected options, tradeoffs, constraints, side comments, terminology, open questions, assumptions, file paths, commands, APIs, package names, examples, preferences, reasoning, and abandoned options.",
+    "The goal is context preservation, not polish.",
+    "Do not omit low-importance details merely because they seem minor.",
+    "When complete, run: trailstep continue --session-file session-description.md"
+  ] : [
+    "You are running inside a TrailStep interactive step.",
+    "Submit a JSON object matching this schema:",
+    JSON.stringify(options.outputSchema.jsonSchema, null, 2),
+    "When complete, run one of:",
+    "  trailstep continue --json-file output.json",
+    `  trailstep continue --json '${JSON.stringify(exampleJsonObject(options.outputSchema.jsonSchema))}'`,
+    "If validation fails, update the JSON so it matches the schema and run trailstep continue again."
+  ];
+  return [...preamble, "", "## Original prompt", options.renderedPrompt].join("\n");
+}
+async function readCompletedOutput(options) {
+  return await readCompletedInteractiveOutput({
+    stepId: options.stepId,
+    interactiveFile: options.artifactPaths.interactiveFile,
+    outputSchema: options.outputSchema
+  });
+}
+function exampleJsonObject(schema) {
+  const properties = typeof schema.properties === "object" && schema.properties !== null && !Array.isArray(schema.properties) ? schema.properties : {};
+  return Object.fromEntries(
+    Object.entries(properties).map(([key, property]) => {
+      const type = typeof property === "object" && property !== null && "type" in property ? property.type : void 0;
+      if (type === "boolean") {
+        return [key, true];
+      }
+      if (type === "number") {
+        return [key, 1];
+      }
+      return [key, "string"];
+    })
+  );
+}
+async function substitutePromptPlaceholders(options) {
+  let needsPromptFile = false;
+  const substituted = options.argv.map((arg) => {
+    if (arg === "{{prompt}}") {
+      return options.prompt;
+    }
+    if (arg === "{{promptFile}}") {
+      needsPromptFile = true;
+      return options.promptFile;
+    }
+    if (arg === "{{model}}") {
+      return options.model ?? "";
+    }
+    if (arg.includes("{{prompt}}") || arg.includes("{{promptFile}}") || arg.includes("{{model}}")) {
+      throw new TrailStepFailureError({
+        code: "interactive_command_invalid",
+        message: "Interactive prompt placeholders must be whole argv values."
+      });
+    }
+    return arg;
+  });
+  if (needsPromptFile) {
+    await mkdir2(dirname3(options.promptFile), { recursive: true });
+    await writeFile5(options.promptFile, options.prompt, "utf8");
+  }
+  return substituted;
+}
+var spawnInteractiveProcess = async ({
+  command,
+  args,
+  cwd,
+  env,
+  signal
+}) => {
+  return await new Promise((resolve2, reject) => {
+    const child = spawn5(command, args, {
+      cwd,
+      env,
+      signal,
+      detached: process.platform !== "win32",
+      shell: false,
+      stdio: "inherit"
+    });
+    signal?.addEventListener("abort", () => terminateChildProcessTree5(child), { once: true });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ exitCode: code ?? 1 }));
+  });
+};
+function terminateChildProcessTree5(child) {
+  if (!child.pid) {
+    return;
+  }
+  if (process.platform === "win32") {
+    spawn5("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on(
+      "error",
+      () => {
+        child.kill();
+      }
+    );
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGTERM");
+  } catch {
+    child.kill();
+  }
+}
+
+// src/agent-execution/working-agent/run-working-agent-command.ts
+import { mkdir as mkdir3, writeFile as writeFile7 } from "fs/promises";
+
+// src/agent-execution/working-agent/artifacts/resolve-step-agent-files.ts
+import { join as join5 } from "path";
+function resolveStepAgentFiles(options) {
+  const artifactPaths = resolveStepArtifactPaths(options);
+  return {
+    stepDir: artifactPaths.stepDir,
+    promptFile: join5(artifactPaths.stepDir, "prompt.md"),
+    outputFile: artifactPaths.outputFile,
+    usageFile: artifactPaths.usageFile
+  };
+}
+
+// src/agent-execution/working-agent/prompts/build-working-agent-prompt.ts
+function buildWorkingAgentPrompt(options) {
+  if (options.captureMode === "raw-text") {
+    return [
+      "# TrailStep working-agent task",
+      "",
+      "Run the task described below and write the document content to the output file.",
+      "Print the document content directly as your entire response \u2014 no JSON wrapper, no surrounding commentary, no markdown fences unless they are literally part of the document content itself.",
+      "",
+      `Output file: ${options.outputFile}`,
+      "",
+      "## Original prompt",
+      "",
+      options.prompt,
+      ""
+    ].join("\n");
+  }
+  return [
+    "# TrailStep working-agent task",
+    "",
+    "Run the task described below and write exactly one JSON object to the output file.",
+    "Do not write prose, markdown fences, or multiple JSON values to the output file.",
+    "",
+    `Output file: ${options.outputFile}`,
+    "",
+    "The JSON object must match this output schema:",
+    "",
+    "```json",
+    JSON.stringify(options.outputSchema, null, 2),
+    "```",
+    "",
+    "## Original prompt",
+    "",
+    options.prompt,
+    ""
+  ].join("\n");
+}
+
+// src/agent-execution/working-agent/targets/run-working-agent-target-attempt.ts
+import { rm } from "fs/promises";
+
+// src/agent-execution/working-agent/output/read-working-agent-output.ts
+import { readFile as readFile4 } from "fs/promises";
+async function readWorkingAgentOutput(options) {
+  let raw;
+  try {
+    raw = await readFile4(options.outputFile, "utf8");
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: "agent_output_unreadable",
+      message: `Working agent step ${options.stepId} output.json could not be read.`,
+      details: error instanceof Error ? { path: options.outputFile, cause: error.message } : { path: options.outputFile }
+    });
+  }
+  if (options.step.output.captureMode === "raw-text") {
+    const capturedDocument = await document(raw);
+    return options.step.output.assert(capturedDocument, `step ${options.stepId} output`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: "agent_output_invalid_json",
+      message: `Working agent step ${options.stepId} output.json must contain one JSON object.`,
+      details: error instanceof Error ? { path: options.outputFile, cause: error.message } : { path: options.outputFile }
+    });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new TrailStepFailureError({
+      code: "agent_output_invalid_json",
+      message: `Working agent step ${options.stepId} output.json must contain one JSON object.`,
+      details: { path: options.outputFile }
+    });
+  }
+  return options.step.output.assert(parsed, `step ${options.stepId} output`);
+}
+
+// src/agent-execution/working-agent/targets/custom-provider/build-working-agent-args.ts
+function buildWorkingAgentArgs(options) {
+  if (!options.argv) {
+    return [
+      "--prompt-file",
+      options.promptFile,
+      "--output-file",
+      options.outputFile,
+      ...options.model ? ["--model", options.model] : []
+    ];
+  }
+  return options.argv.map((arg) => {
+    switch (arg) {
+      case "{{promptFile}}":
+        return options.promptFile;
+      case "{{outputFile}}":
+        return options.outputFile;
+      case "{{model}}":
+        return options.model ?? "";
+      default:
+        if (arg.includes("{{promptFile}}") || arg.includes("{{outputFile}}") || arg.includes("{{model}}")) {
+          throw new TrailStepFailureError({
+            code: "agent_provider_invalid",
+            message: "Working agent command placeholders must be whole argv values."
+          });
+        }
+        return arg;
+    }
+  });
+}
+
+// src/agent-execution/working-agent/targets/custom-provider/spawn-working-agent-process.ts
+import { spawn as spawn6 } from "child_process";
+var spawnWorkingAgentProcess = async ({
+  command,
+  args,
+  cwd,
+  signal
+}) => {
+  return await new Promise((resolve2, reject) => {
+    const child = spawn6(command, args, {
+      cwd,
+      shell: false,
+      stdio: "inherit",
+      detached: process.platform !== "win32"
+    });
+    signal?.addEventListener("abort", () => terminateChildProcessTree6(child), { once: true });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ exitCode: code ?? 1 }));
+  });
+};
+function terminateChildProcessTree6(child) {
+  if (!child.pid) {
+    return;
+  }
+  if (process.platform === "win32") {
+    spawn6("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on(
+      "error",
+      () => {
+        child.kill();
+      }
+    );
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGTERM");
+  } catch {
+    child.kill();
+  }
+}
+
+// src/agent-execution/working-agent/targets/custom-provider/run-custom-working-provider.ts
+async function runCustomWorkingProvider(options) {
+  const agentConfig = options.config.customProviders[options.target.provider];
+  if (!agentConfig) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_unavailable",
+      message: `Working agent target '${options.target.provider}' does not reference a configured custom agent.`,
+      details: { provider: options.target.provider }
+    });
+  }
+  const args = buildWorkingAgentArgs({
+    argv: options.target.args ?? agentConfig.args,
+    promptFile: options.files.promptFile,
+    outputFile: options.files.outputFile,
+    model: options.target.model
+  });
+  let result;
+  try {
+    result = await (options.runner ?? spawnWorkingAgentProcess)({
+      command: agentConfig.binary,
+      args,
+      cwd: options.cwd,
+      shell: false,
+      stdio: "inherit",
+      promptFile: options.files.promptFile,
+      outputFile: options.files.outputFile,
+      ...options.target.model === void 0 ? {} : { model: options.target.model },
+      signal: options.signal
+    });
+  } catch (error) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_spawn_error",
+      message: `Working agent step ${options.step.id} could not start target '${options.target.provider}'.`,
+      details: {
+        target: options.target.provider,
+        ...options.target.model === void 0 ? {} : { model: options.target.model },
+        cause: error instanceof Error ? error.message : String(error)
+      }
+    });
+  }
+  if (result.exitCode !== 0) {
+    throw new TrailStepFailureError({
+      code: "agent_provider_failed",
+      message: `Working agent step ${options.step.id} target '${options.target.provider}' exited with code ${result.exitCode}.`,
+      details: {
+        exitCode: result.exitCode,
+        provider: agentConfig.binary,
+        target: options.target.provider,
+        ...options.target.model === void 0 ? {} : { model: options.target.model }
+      }
+    });
+  }
+  return readWorkingAgentOutput({
+    stepId: options.step.id,
+    outputFile: options.files.outputFile,
+    step: options.step
+  });
+}
+
+// src/agent-execution/working-agent/targets/registry-provider/run-registry-working-provider.ts
+import { writeFile as writeFile6 } from "fs/promises";
+
+// src/agent-execution/working-agent/prompts/build-provider-working-prompt.ts
+function buildProviderWorkingPrompt(options) {
+  if (options.captureMode === "raw-text") {
+    return [
+      "# TrailStep working-agent task",
+      "",
+      "Print the document content directly as your entire response \u2014 no JSON wrapper, no surrounding commentary, no markdown fences unless they are literally part of the document content itself.",
+      "Do not write output to a file.",
+      "",
+      "## Original prompt",
+      "",
+      options.prompt,
+      ""
+    ].join("\n");
+  }
+  return [
+    "# TrailStep working-agent task",
+    "",
+    "Respond with exactly one JSON object as your entire final answer, and nothing else.",
+    "Do not write output to a file. Do not include prose, markdown fences, or multiple JSON values in your final answer - only the JSON object itself. This instruction applies to your literal final message, not just the work you do to get there.",
+    "",
+    "The JSON object must match this output schema:",
+    "",
+    "```json",
+    JSON.stringify(options.outputSchema, null, 2),
+    "```",
+    "",
+    "## Original prompt",
+    "",
+    options.prompt,
+    ""
+  ].join("\n");
+}
+
+// src/agent-execution/working-agent/targets/registry-provider/repair-provider-output.ts
+var MAX_OUTPUT_REPAIR_ATTEMPTS = 1;
+async function attemptProviderOutputRepair(options) {
+  if (!options.provider.repairOutput) {
+    return false;
+  }
+  const repairable = extractRepairableFailure(options.error);
+  if (!repairable || MAX_OUTPUT_REPAIR_ATTEMPTS < 1) {
+    return false;
+  }
+  try {
+    await options.provider.repairOutput(
+      {
+        sessionId: repairable.sessionId,
+        rawResultText: repairable.rawResultText ?? "",
+        outputFile: options.files.outputFile,
+        usageFile: options.files.usageFile,
+        cwd: options.cwd,
+        ...options.model === void 0 ? {} : { model: options.model },
+        ...options.thinking === void 0 ? {} : { thinking: options.thinking },
+        outputSchema: options.outputSchema,
+        captureMode: options.captureMode,
+        signal: options.signal
+      },
+      options.providerWorkingRunner
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractRepairableFailure(error) {
+  if (!(error instanceof TrailStepFailureError)) {
+    return void 0;
+  }
+  if (error.failure.code !== "agent_provider_output_invalid") {
+    return void 0;
+  }
+  const details = error.failure.details;
+  if (typeof details !== "object" || details === null) {
+    return void 0;
+  }
+  const sessionId = details.sessionId;
+  if (typeof sessionId !== "string") {
+    return void 0;
+  }
+  const rawResultText = details.rawResultText;
+  return {
+    sessionId,
+    ...typeof rawResultText === "string" ? { rawResultText } : {}
+  };
+}
+
+// src/agent-execution/working-agent/targets/registry-provider/run-registry-working-provider.ts
+async function runRegistryWorkingProvider(options) {
+  await writeFile6(
+    options.files.promptFile,
+    buildProviderWorkingPrompt({
+      prompt: options.renderedPrompt,
+      outputSchema: options.step.output.jsonSchema,
+      captureMode: options.step.output.captureMode
+    }),
+    "utf8"
+  );
+  const thinking = resolveWorkingThinking(options.target, options.role);
+  try {
+    await options.provider.runWorking(
+      {
+        promptFile: options.files.promptFile,
+        outputFile: options.files.outputFile,
+        usageFile: options.files.usageFile,
+        cwd: options.cwd,
+        ...options.target.model === void 0 ? {} : { model: options.target.model },
+        ...thinking === void 0 ? {} : { thinking },
+        captureMode: options.step.output.captureMode,
+        signal: options.signal
+      },
+      options.providerWorkingRunner
+    );
+  } catch (error) {
+    const repaired = await attemptProviderOutputRepair({
+      provider: options.provider,
+      error,
+      model: options.target.model,
+      thinking,
+      outputSchema: options.step.output.jsonSchema,
+      captureMode: options.step.output.captureMode,
+      files: options.files,
+      cwd: options.cwd,
+      providerWorkingRunner: options.providerWorkingRunner,
+      signal: options.signal
+    });
+    if (!repaired) {
+      throw error;
+    }
+  }
+  return readWorkingAgentOutput({
+    stepId: options.step.id,
+    outputFile: options.files.outputFile,
+    step: options.step
+  });
+}
+function resolveWorkingThinking(target, role) {
+  return target.thinking ?? role.thinking;
+}
+
+// src/agent-execution/working-agent/targets/run-working-agent-target-attempt.ts
+async function runWorkingAgentTargetAttempt(options) {
+  await rm(options.files.outputFile, { force: true });
+  await rm(options.files.usageFile, { force: true });
+  const provider = providerRegistry[options.target.provider];
+  if (provider) {
+    return runRegistryWorkingProvider({
+      provider,
+      role: options.role,
+      step: options.step,
+      renderedPrompt: options.renderedPrompt,
+      cwd: options.cwd,
+      providerWorkingRunner: options.providerWorkingRunner,
+      target: options.target,
+      files: options.files,
+      signal: options.signal
+    });
+  }
+  return runCustomWorkingProvider({
+    config: options.config,
+    step: options.step,
+    cwd: options.cwd,
+    runner: options.runner,
+    target: options.target,
+    files: options.files,
+    signal: options.signal
+  });
+}
+
+// src/agent-execution/working-agent/targets/target-failures.ts
+function summarizeWorkingAgentAttemptFailure(target, error) {
+  if (error instanceof TrailStepFailureError) {
+    return {
+      target: target.provider,
+      ...target.model === void 0 ? {} : { model: target.model },
+      code: error.failure.code,
+      message: error.failure.message,
+      ...error.failure.details === void 0 ? {} : { details: error.failure.details }
+    };
+  }
+  return {
+    target: target.provider,
+    ...target.model === void 0 ? {} : { model: target.model },
+    code: "agent_target_failed",
+    message: error instanceof Error ? error.message : "Working agent target failed."
+  };
+}
+
+// src/agent-execution/working-agent/run-working-agent-command.ts
+async function runWorkingAgentCommand(options) {
+  const targets = resolveAgentTargets({
+    config: options.config,
+    workflowId: options.workflowId,
+    roleName: options.roleName,
+    roleSize: options.role.size
+  });
+  const files = options.files ?? resolveStepAgentFiles({
+    runDir: options.runDir,
+    stepId: options.step.id,
+    stepIndex: options.stepIndex
+  });
+  await mkdir3(files.stepDir, { recursive: true });
+  await writeFile7(
+    files.promptFile,
+    buildWorkingAgentPrompt({
+      prompt: options.renderedPrompt,
+      outputFile: files.outputFile,
+      outputSchema: options.step.output.jsonSchema,
+      captureMode: options.step.output.captureMode
+    }),
+    "utf8"
+  );
+  const failures = [];
+  for (const target of targets) {
+    try {
+      return await runWorkingAgentTargetAttempt({ ...options, target, files });
+    } catch (error) {
+      failures.push(summarizeWorkingAgentAttemptFailure(target, error));
+    }
+  }
+  throw new TrailStepFailureError({
+    code: "agent_target_exhausted",
+    message: `Working agent step ${options.step.id} for role ${options.roleName} exhausted ${failures.length} target(s).`,
+    details: {
+      stepId: options.step.id,
+      roleName: options.roleName,
+      attempts: failures
+    }
+  });
+}
+
+// src/agent-execution/dispatch-agent-step/dispatch-agent-step.ts
+async function dispatchAgentStep(options) {
+  const { config, outputSchema } = options;
+  const resolvedRole = resolveWorkflowAgentRole({
+    agent: config.agent,
+    workflowAgents: options.workflowAgents,
+    workflowId: options.workflowId,
+    stepId: config.id
+  });
+  const renderedPrompt = await resolvePromptSource(config.prompt, config.input, options.cwd);
+  const agentMode = config.mode ?? "working";
+  const agentStep = {
+    kind: "agent",
+    id: config.id,
+    output: outputSchema,
+    prompt: renderedPrompt,
+    requirements: resolvedRole.role,
+    adapter: config.adapter
+  };
+  if (!options.trailstepConfig && config.adapter === void 0) {
+    throwMissingAgentConfig({
+      workflowId: options.workflowId,
+      stepId: config.id,
+      agent: resolvedRole.roleName,
+      mode: agentMode
+    });
+  }
+  if (options.trailstepConfig && agentMode === "interactive") {
+    await options.emit(
+      createEvent({
+        runId: options.runId,
+        workflowId: options.workflowId,
+        stepId: config.id,
+        type: "interactive.sessionStarted",
+        payload: { roleName: resolvedRole.roleName, stepIndex: options.stepIndex }
+      })
+    );
+    const artifactPaths = resolveStepArtifactPaths({
+      runDir: options.runDir,
+      stepId: config.id,
+      stepIndex: options.stepIndex
+    });
+    const interactiveResult = await runInteractiveAgentCommand({
+      config: options.trailstepConfig,
+      workflowId: options.workflowId,
+      roleName: resolvedRole.roleName,
+      role: resolvedRole.role,
+      stepId: config.id,
+      renderedPrompt,
+      runDir: options.runDir,
+      runner: options.processRunner,
+      outputSchema,
+      outputMode: options.interactiveOutputMode,
+      artifactPaths,
+      signal: options.signal
+    });
+    await options.emit(
+      createEvent({
+        runId: options.runId,
+        workflowId: options.workflowId,
+        stepId: config.id,
+        type: "interactive.sessionCompleted",
+        payload: {
+          exitCode: interactiveResult.exitCode,
+          outputMode: options.interactiveOutputMode,
+          stepDir: artifactPaths.runRelativeStepDir
+        }
+      })
+    );
+    return interactiveResult.output;
+  }
+  return options.trailstepConfig && agentMode === "working" ? await runWorkingAgentCommand({
+    config: options.trailstepConfig,
+    workflowId: options.workflowId,
+    roleName: resolvedRole.roleName,
+    role: resolvedRole.role,
+    step: agentStep,
+    renderedPrompt,
+    runDir: options.runDir,
+    cwd: options.cwd,
+    runner: options.workingAgentProcessRunner,
+    providerWorkingRunner: options.providerWorkingRunner,
+    stepIndex: options.stepIndex,
+    signal: options.signal
+  }) : await runAgentStep({
+    step: agentStep,
+    input: config.input,
+    onToolCall: async (toolCall) => {
+      await options.emit(
+        createEvent({
+          runId: options.runId,
+          workflowId: options.workflowId,
+          stepId: config.id,
+          type: "agent.toolCall",
+          payload: { ...toolCall }
+        })
+      );
+    }
+  });
+}
+async function resolvePromptSource(source, input, cwd) {
+  if (isPromptTemplateSource(source)) {
+    return await readFile5(resolve(cwd, source.path), "utf8");
+  }
+  return renderAgentPrompt(source, input);
+}
+function isPromptTemplateSource(source) {
+  return typeof source === "object" && source !== null && source.kind === "promptTemplate";
+}
+function throwMissingAgentConfig(options) {
+  throw new TrailStepFailureError({
+    code: "missing_agent_config",
+    message: `Missing .trailstep/config.json: workflow ${options.workflowId} step ${options.stepId} needs configured ${options.mode} agent '${options.agent}'.`,
+    details: {
+      workflowId: options.workflowId,
+      stepId: options.stepId,
+      agent: options.agent,
+      mode: options.mode
+    }
+  });
+}
+var DEFAULT_AGENT_ROLE_NAME = "default";
+var BUILTIN_DEFAULT_AGENT_ROLE = { size: "default" };
+function resolveWorkflowAgentRole(options) {
+  const roleName = options.agent ?? DEFAULT_AGENT_ROLE_NAME;
+  const role = options.workflowAgents[roleName];
+  if (role) {
+    return { role, roleName };
+  }
+  if (options.agent === void 0) {
+    return { role: BUILTIN_DEFAULT_AGENT_ROLE, roleName: DEFAULT_AGENT_ROLE_NAME };
+  }
+  throw new TrailStepFailureError({
+    code: "agent_role_unknown",
+    message: `Step ${options.stepId} references unknown agent role '${options.agent}' in workflow ${options.workflowId}. Declare workflow.agents.${options.agent} before referencing it with step agent.`,
+    details: {
+      workflowId: options.workflowId,
+      stepId: options.stepId,
+      agent: options.agent,
+      declaredAgents: Object.keys(options.workflowAgents)
+    }
+  });
+}
+
+// src/runtime/sub-prompts/sub-prompt-artifacts.ts
+import { join as join6, relative } from "path";
+function resolveSubPromptArtifactPaths(options) {
+  const artifactSubPromptId = `${String(options.ordinal).padStart(4, "0")}-${options.fingerprint.slice(0, 12)}`;
+  const subPromptDir = join6(options.stepDir, "subPrompts", artifactSubPromptId);
+  const promptFile = join6(subPromptDir, "prompt.txt");
+  const outputFile = join6(subPromptDir, "output.json");
+  const usageFile = join6(subPromptDir, "usage.json");
+  return {
+    subPromptDir,
+    promptFile,
+    outputFile,
+    usageFile,
+    runRelative: {
+      subPromptDir: toRunRelativePath(options.runDir, subPromptDir),
+      promptFile: toRunRelativePath(options.runDir, promptFile),
+      outputFile: toRunRelativePath(options.runDir, outputFile)
+    }
+  };
+}
+function toRunRelativePath(runDir, path) {
+  return relative(runDir, path).replaceAll("\\", "/");
+}
+
+// src/runtime/failures/failure-like.ts
+function isFailureLikeError(error) {
+  return typeof error === "object" && error !== null && "failure" in error && typeof error.failure === "object" && error.failure !== null && "code" in error.failure && typeof error.failure.code === "string" && "message" in error.failure && typeof error.failure.message === "string";
+}
+
+// src/runtime/sub-prompts/sub-prompt-failures.ts
+async function emitSubPromptFailed(options) {
+  await options.context.emit?.(
+    createEvent({
+      runId: options.context.id,
+      workflowId: options.context.workflowId ?? "",
+      stepId: options.parentStepId,
+      type: "subPrompt.failed",
+      payload: {
+        parentStepId: options.parentStepId,
+        ordinal: options.ordinal,
+        ...options.fingerprint === void 0 ? {} : { fingerprint: options.fingerprint },
+        ...options.artifactPaths === void 0 ? {} : { artifactPaths: options.artifactPaths },
+        failure: options.failure
+      }
+    })
+  );
+}
+function maxSubPromptsGuardError(maxSubPrompts) {
+  return new TrailStepFailureError({
+    code: "max_sub_prompts_exceeded",
+    message: `workflow exceeded maxSubPrompts guard (${maxSubPrompts})`
+  });
+}
+function throwMissingSubPromptAgentConfig(options) {
+  throw new TrailStepFailureError({
+    code: "missing_agent_config",
+    message: `Missing .trailstep/config.json: workflow ${options.workflowId} parent step ${options.parentStepId} subPrompt ${options.subPromptId} needs configured working agent '${options.agent}'.`,
+    details: {
+      workflowId: options.workflowId,
+      parentStepId: options.parentStepId,
+      subPromptId: options.subPromptId,
+      agent: options.agent,
+      mode: "working"
+    }
+  });
+}
+function subPromptFailureError(error) {
+  if (error instanceof TrailStepFailureError) {
+    if (error.failure.code === "validation_failed") {
+      return new TrailStepFailureError({
+        ...error.failure,
+        message: normalizeSubPromptValidationMessage(error.failure.message)
+      });
+    }
+    return error;
+  }
+  if (isFailureLikeError(error)) {
+    return new TrailStepFailureError(error.failure);
+  }
+  return new TrailStepFailureError({
+    code: "sub_prompt_failed",
+    message: error instanceof Error ? error.message : "subPrompt failed.",
+    ...error instanceof Error ? { details: { name: error.name } } : error === void 0 ? {} : { details: { cause: error } }
+  });
+}
+function normalizeSubPromptValidationMessage(message) {
+  if (message.startsWith("subPrompt output failed schema validation")) {
+    return message;
+  }
+  const diagnostics = message.match(/failed schema validation: (.*)$/)?.[1];
+  return diagnostics === void 0 ? `subPrompt output failed schema validation: ${message}` : `subPrompt output failed schema validation: ${diagnostics}`;
+}
+
+// src/runtime/sub-prompts/sub-prompt-fingerprint.ts
+import { createHash } from "crypto";
+function fingerprintSubPrompt(options) {
+  return createHash("sha256").update(stableJsonStringify(options)).digest("hex");
+}
+function stableJsonStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableJsonStringify(item)).join(",")}]`;
+  }
+  if (isPlainObject4(value)) {
+    const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${stableJsonStringify(entryValue)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function isPlainObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+
+// src/runtime/sub-prompts/sub-prompt-replay.ts
+function findCompletedSubPromptEvent(events, parentStepId, ordinal, fingerprint) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (event?.type !== "subPrompt.completed") {
+      continue;
+    }
+    const payload = event.payload;
+    if (payload.parentStepId === parentStepId && payload.ordinal === ordinal && payload.fingerprint === fingerprint && isPlainObject5(payload.output)) {
+      return event;
+    }
+  }
+  return void 0;
+}
+function isPlainObject5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+
+// src/runtime/sub-prompts/run-sub-prompt.ts
+function resolveMaxSubPrompts(value) {
+  if (value === void 0) {
+    return 25;
+  }
+  if (Number.isInteger(value) && typeof value === "number" && value > 0) {
+    return value;
+  }
+  throw new TrailStepFailureError({
+    code: "invalid_max_sub_prompts",
+    message: "maxSubPrompts must be a positive integer."
+  });
+}
+async function runSubPrompt(source, options, input) {
+  const resolvedInput = input ?? {};
+  const context = runContextStorage.getStore();
+  if (!context?.currentStep) {
+    throw new TrailStepFailureError({
+      code: "sub_prompt_outside_step_context",
+      message: "subPrompt requires an active TrailStep step run context."
+    });
+  }
+  if (!context.workflowId || !context.workflowAgents || !context.cwd || !context.emit) {
+    throw new TrailStepFailureError({
+      code: "sub_prompt_context_unavailable",
+      message: "subPrompt requires a full active TrailStep step run context."
+    });
+  }
+  const parentStep = context.currentStep;
+  if (options.output === void 0) {
+    throw new TrailStepFailureError({
+      code: "sub_prompt_output_required",
+      message: `subPrompt in step ${parentStep.id} with a prompt requires an output shape`
+    });
+  }
+  const outputSchema = normalizeShape(options.output);
+  const ordinal = parentStep.nextSubPromptIndex();
+  const maxSubPrompts = resolveMaxSubPrompts(options.maxSubPrompts ?? parentStep.maxSubPrompts);
+  if (ordinal > maxSubPrompts) {
+    const failureError = maxSubPromptsGuardError(maxSubPrompts);
+    await emitSubPromptFailed({
+      context,
+      parentStepId: parentStep.id,
+      ordinal,
+      failure: failureError.failure
+    });
+    throw failureError;
+  }
+  const renderedPrompt = await resolvePromptSource(source, resolvedInput, context.cwd);
+  const fingerprint = fingerprintSubPrompt({ input: resolvedInput, prompt: renderedPrompt });
+  const cachedEvent = findCompletedSubPromptEvent(
+    context.events?.() ?? [],
+    parentStep.id,
+    ordinal,
+    fingerprint
+  );
+  if (cachedEvent) {
+    return outputSchema.assert(cachedEvent.payload.output, "subPrompt output");
+  }
+  const artifactPaths = resolveSubPromptArtifactPaths({
+    runDir: context.path,
+    stepDir: parentStep.dir,
+    ordinal,
+    fingerprint
+  });
+  await mkdir4(artifactPaths.subPromptDir, { recursive: true });
+  await writeFile8(artifactPaths.promptFile, renderedPrompt, "utf8");
+  const resolvedRole = resolveWorkflowAgentRole({
+    agent: options.agent,
+    workflowAgents: context.workflowAgents,
+    workflowId: context.workflowId,
+    stepId: parentStep.id
+  });
+  await context.emit(
+    createEvent({
+      runId: context.id,
+      workflowId: context.workflowId,
+      stepId: parentStep.id,
+      type: "subPrompt.started",
+      payload: {
+        parentStepId: parentStep.id,
+        ordinal,
+        fingerprint,
+        artifactPaths: artifactPaths.runRelative
+      }
+    })
+  );
+  try {
+    const agentStep = {
+      kind: "agent",
+      id: `${parentStep.id}.subPrompt.${ordinal}`,
+      output: outputSchema,
+      prompt: renderedPrompt,
+      requirements: resolvedRole.role,
+      adapter: options.adapter
+    };
+    if (!context.trailstepConfig && options.adapter === void 0) {
+      throwMissingSubPromptAgentConfig({
+        workflowId: context.workflowId,
+        parentStepId: parentStep.id,
+        subPromptId: agentStep.id,
+        agent: resolvedRole.roleName
+      });
+    }
+    const rawOutput = context.trailstepConfig && options.adapter === void 0 ? await runWorkingAgentCommand({
+      config: context.trailstepConfig,
+      workflowId: context.workflowId,
+      roleName: resolvedRole.roleName,
+      role: resolvedRole.role,
+      step: agentStep,
+      renderedPrompt,
+      runDir: context.path,
+      cwd: context.cwd,
+      runner: context.workingAgentProcessRunner,
+      providerWorkingRunner: context.providerWorkingRunner,
+      stepIndex: ordinal,
+      files: {
+        stepDir: artifactPaths.subPromptDir,
+        promptFile: artifactPaths.promptFile,
+        outputFile: artifactPaths.outputFile,
+        usageFile: artifactPaths.usageFile
+      }
+    }) : await runAgentStep({
+      step: agentStep,
+      input: resolvedInput,
+      onToolCall: async (toolCall) => {
+        await context.emit?.(
+          createEvent({
+            runId: context.id,
+            workflowId: context.workflowId ?? "",
+            stepId: parentStep.id,
+            type: "agent.toolCall",
+            payload: { ...toolCall }
+          })
+        );
+      }
+    });
+    const output = outputSchema.assert(rawOutput, "subPrompt output");
+    await writeFile8(artifactPaths.outputFile, `${JSON.stringify(output, null, 2)}
+`, "utf8");
+    await context.emit(
+      createEvent({
+        runId: context.id,
+        workflowId: context.workflowId,
+        stepId: parentStep.id,
+        type: "subPrompt.completed",
+        payload: {
+          parentStepId: parentStep.id,
+          ordinal,
+          fingerprint,
+          output,
+          artifactPaths: artifactPaths.runRelative
+        }
+      })
+    );
+    return output;
+  } catch (error) {
+    const failureError = subPromptFailureError(error);
+    await emitSubPromptFailed({
+      context,
+      parentStepId: parentStep.id,
+      ordinal,
+      fingerprint,
+      artifactPaths: artifactPaths.runRelative,
+      failure: failureError.failure
+    });
+    throw failureError;
+  }
+}
+
+// src/authoring/step/sub-prompt.ts
+function subPrompt(source, options) {
+  const run = (input) => runSubPrompt(source, options, input);
+  return run;
+}
+
+// src/deprecations/deprecation-manifest.ts
+import { lte } from "semver";
+var deprecationManifest = [];
+function findDeprecationsAsOf(manifest, query) {
+  return manifest.filter((entry) => entry.package === query.package && lte(entry.deprecatedSince, query.version)).map((entry) => toDeprecationStatus(entry, query.version));
+}
+function toDeprecationStatus(entry, version) {
+  const isRemoved = entry.removedIn !== void 0 && lte(entry.removedIn, version);
+  return { ...entry, severity: isRemoved ? "blocking" : "warning" };
+}
+
+// src/runtime/retry/latest-unresolved-failure.ts
+function selectLatestUnresolvedFailure(events) {
+  const startedEvent = events.find((event) => event.type === "workflow.started");
+  const workflowInput = startedEvent ? readPlainPayload(startedEvent, "input") : void 0;
+  const resolvedFailures = events.flatMap(
+    (event) => event.type === "workflow.retryStarted" ? readResolvedFailureIdentity(event) : []
+  );
+  let workflowFailureFallback;
+  let laterWorkflowTerminalSeen = false;
+  const laterTerminalStepIds = /* @__PURE__ */ new Set();
+  for (let replayPosition = events.length - 1; replayPosition >= 0; replayPosition -= 1) {
+    const event = events[replayPosition];
+    if (!event) {
+      continue;
+    }
+    if (event.type === "workflow.completed") {
+      return void 0;
+    }
+    if (event.type === "step.completed") {
+      rememberTerminalStep(event, laterTerminalStepIds);
+      continue;
+    }
+    if (event.type === "step.failed") {
+      rememberTerminalStep(event, laterTerminalStepIds);
+      if (isResolvedFailure(event, replayPosition, resolvedFailures)) {
+        continue;
+      }
+      return toLatestUnresolvedFailure(event, replayPosition, workflowInput);
+    }
+    if (event.type === "workflow.failed") {
+      laterWorkflowTerminalSeen = true;
+      if (!workflowFailureFallback) {
+        if (isResolvedFailure(event, replayPosition, resolvedFailures)) {
+          continue;
+        }
+        workflowFailureFallback = toLatestUnresolvedFailure(event, replayPosition, workflowInput);
+      }
+      continue;
+    }
+    if (event.type === "step.started" && event.stepId && !laterWorkflowTerminalSeen && !laterTerminalStepIds.has(event.stepId)) {
+      if (isResolvedFailure(event, replayPosition, resolvedFailures)) {
+        continue;
+      }
+      return toLatestUnresolvedFailure(event, replayPosition, workflowInput);
+    }
+  }
+  return workflowFailureFallback;
+}
+function rememberTerminalStep(event, stepIds) {
+  if (event.stepId) {
+    stepIds.add(event.stepId);
+  }
+}
+function readResolvedFailureIdentity(event) {
+  const { sourceFailureEventId, sourceFailureReplayPosition } = event.payload;
+  if (typeof sourceFailureEventId !== "string" && typeof sourceFailureReplayPosition !== "number") {
+    return [];
+  }
+  return [
+    {
+      eventId: typeof sourceFailureEventId === "string" ? sourceFailureEventId : void 0,
+      replayPosition: typeof sourceFailureReplayPosition === "number" ? sourceFailureReplayPosition : void 0
+    }
+  ];
+}
+function isResolvedFailure(event, replayPosition, resolvedFailures) {
+  return resolvedFailures.some((resolvedFailure) => {
+    if (resolvedFailure.replayPosition !== void 0) {
+      return resolvedFailure.replayPosition === replayPosition;
+    }
+    return resolvedFailure.eventId !== void 0 && resolvedFailure.eventId === event.id;
+  });
+}
+function toLatestUnresolvedFailure(event, replayPosition, workflowInput) {
+  return {
+    event,
+    replayPosition,
+    sourceFailureEventId: typeof event.id === "string" ? event.id : void 0,
+    workflowId: event.workflowId,
+    workflowInput,
+    stepId: event.stepId
+  };
+}
+function readPlainPayload(event, key) {
+  const value = event.payload[key];
+  return isPlainObject6(value) ? value : void 0;
+}
+function isPlainObject6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+
+// src/runtime/retry/retry-policy.ts
+var BUILT_IN_RETRY_POLICY = { maxAttempts: 2 };
+function resolveRetryPolicy(options) {
+  return validateRetryPolicy(
+    firstConfiguredPolicy(options.step, options.workflow, options.global) ?? BUILT_IN_RETRY_POLICY
+  );
+}
+function validateRetryPolicy(input) {
+  const maxAttempts = input.maxAttempts ?? BUILT_IN_RETRY_POLICY.maxAttempts;
+  if (typeof maxAttempts !== "number" || !Number.isInteger(maxAttempts) || maxAttempts < 1) {
+    throw new TypeError("retry.maxAttempts must be an integer greater than or equal to 1.");
+  }
+  return { maxAttempts };
+}
+function firstConfiguredPolicy(...policies) {
+  return policies.find((policy) => policy?.maxAttempts !== void 0);
+}
+
+// src/runtime/run-workflow/run-workflow.ts
+import { basename as basename3 } from "path";
+
+// src/runtime/failures/step-execution-failure.ts
+function stepExecutionFailure(error) {
+  if (isFailureLikeError(error)) {
+    return error.failure;
+  }
+  return {
+    code: "step_execution_failed",
+    message: error instanceof Error ? error.message : "Step execution failed.",
+    ...error instanceof Error ? {
+      details: {
+        name: error.name
+      }
+    } : error === void 0 ? {} : { details: { cause: error } }
+  };
+}
+
+// src/runtime/run-context/with-step-context.ts
+async function withStepContext(stepId, stepDir, fn, options = {}) {
+  const parentContext = runContextStorage.getStore();
+  if (!parentContext) {
+    return await fn();
+  }
+  let nextDocumentIndex = 0;
+  let nextSubPromptIndex = 0;
+  const stepContext = {
+    ...parentContext,
+    currentStep: {
+      id: stepId,
+      dir: stepDir,
+      maxSubPrompts: options.maxSubPrompts,
+      nextDocumentIndex() {
+        nextDocumentIndex += 1;
+        return nextDocumentIndex;
+      },
+      nextSubPromptIndex() {
+        nextSubPromptIndex += 1;
+        return nextSubPromptIndex;
+      }
+    }
+  };
+  return await runContextStorage.run(stepContext, fn);
+}
+
+// src/runtime/timeout/timeout-policy.ts
+var BUILT_IN_TIMEOUT_POLICY = {};
+function resolveTimeoutPolicy(options) {
+  const configured = firstConfiguredPolicy2(options.step, options.workflow, options.global);
+  return configured !== void 0 ? validateTimeoutPolicy(configured) : BUILT_IN_TIMEOUT_POLICY;
+}
+function validateTimeoutPolicy(input) {
+  if (typeof input !== "number" || !Number.isInteger(input) || input < 1) {
+    throw new TypeError(
+      "timeout must be an integer number of milliseconds greater than or equal to 1."
+    );
+  }
+  return { timeoutMs: input };
+}
+function firstConfiguredPolicy2(...policies) {
+  return policies.find((policy) => policy !== void 0);
+}
+
+// src/runtime/interactive-session/default-interactive-output-shape.ts
+var DEFAULT_INTERACTIVE_OUTPUT_SHAPE = { sessionFile: "string" };
+
+// src/runtime/continuation/resolve-step-output-schema/resolve-step-output-schema.ts
+function resolveStepOutputSchema(config) {
+  const effectiveOutput = config.output ?? (config.mode === "interactive" ? DEFAULT_INTERACTIVE_OUTPUT_SHAPE : void 0);
+  return effectiveOutput ? normalizeShape(effectiveOutput) : void 0;
+}
+
+// src/runtime/continuation/run-continuation/run-continuation.ts
+async function runContinuation(options) {
+  let node = options.node;
+  let source = options.initialSource;
+  let executedSteps = options.initialExecutedSteps ?? 0;
+  const trailstepConfig = options.trailstepConfig;
+  while (true) {
+    if (isDoneNode(node)) {
+      return { status: "success", output: node.output };
+    }
+    if (isFailNode(node)) {
+      return { status: "failure", failure: node.failure };
+    }
+    if (!isStepNode(node)) {
+      return {
+        status: "failure",
+        failure: continuationFailure(source)
+      };
+    }
+    if (executedSteps >= options.maxSteps) {
+      return {
+        status: "failure",
+        failure: stepExecutionFailure(
+          new Error(`workflow exceeded maxSteps guard (${options.maxSteps})`)
+        )
+      };
+    }
+    executedSteps += 1;
+    const stepIndex = executedSteps;
+    const stepNode = node;
+    const { config } = stepNode;
+    const hasPrompt = config.prompt !== void 0;
+    const timeoutPolicy = resolveTimeoutPolicy({
+      global: trailstepConfig?.settings?.timeout,
+      workflow: options.workflowTimeout ?? trailstepConfig?.workflows?.[options.workflowId]?.settings?.timeout,
+      step: config.timeout
+    });
+    const maxSubPrompts = config.maxSubPrompts ?? trailstepConfig?.workflows?.[options.workflowId]?.settings?.maxSubPrompts;
+    await options.emit(
+      createEvent({
+        runId: options.runId,
+        workflowId: options.workflowId,
+        stepId: config.id,
+        type: "step.started",
+        payload: { stepName: config.id, kind: hasPrompt ? "agent" : "code" }
+      })
+    );
+    try {
+      const stepDir = resolveStepArtifactPaths({
+        runDir: options.runDir,
+        stepId: config.id,
+        stepIndex
+      }).stepDir;
+      const nextNode = await runWithStepTimeout({
+        stepId: config.id,
+        timeoutMs: timeoutPolicy.timeoutMs,
+        run: async (signal) => await withStepContext(
+          config.id,
+          stepDir,
+          async () => {
+            let paramForNext;
+            if (hasPrompt) {
+              const outputSchema = resolveStepOutputSchema(config);
+              if (!outputSchema) {
+                throw new Error(`step ${config.id} with a prompt requires an output shape`);
+              }
+              const rawOutput = await dispatchAgentStep({
+                config,
+                outputSchema,
+                interactiveOutputMode: config.mode === "interactive" && config.output !== void 0 ? "json" : "session-file",
+                runId: options.runId,
+                workflowId: options.workflowId,
+                emit: options.emit,
+                workflowAgents: options.workflowAgents,
+                runDir: options.runDir,
+                cwd: options.cwd,
+                trailstepConfig,
+                workingAgentProcessRunner: options.workingAgentProcessRunner,
+                providerWorkingRunner: options.providerWorkingRunner,
+                processRunner: options.processRunner,
+                stepIndex,
+                signal
+              });
+              throwIfStepTimedOut(signal, config.id, timeoutPolicy.timeoutMs);
+              paramForNext = outputSchema.assert(rawOutput, `step ${config.id} output`);
+              await options.emit(
+                createEvent({
+                  runId: options.runId,
+                  workflowId: options.workflowId,
+                  stepId: config.id,
+                  type: "step.completed",
+                  payload: { output: paramForNext }
+                })
+              );
+            } else {
+              paramForNext = config.input;
+            }
+            const nextNode2 = await stepNode.onOutput(paramForNext, config.input);
+            throwIfStepTimedOut(signal, config.id, timeoutPolicy.timeoutMs);
+            if (isFailNode(nextNode2)) {
+              await options.emit(
+                createEvent({
+                  runId: options.runId,
+                  workflowId: options.workflowId,
+                  stepId: config.id,
+                  type: "step.failed",
+                  payload: { failure: nextNode2.failure }
+                })
+              );
+              return nextNode2;
+            }
+            if (!hasPrompt) {
+              await options.emit(
+                createEvent({
+                  runId: options.runId,
+                  workflowId: options.workflowId,
+                  stepId: config.id,
+                  type: "step.completed",
+                  payload: {}
+                })
+              );
+            }
+            throwIfStepTimedOut(signal, config.id, timeoutPolicy.timeoutMs);
+            return nextNode2;
+          },
+          { maxSubPrompts }
+        )
+      });
+      if (!isStepNode(nextNode) && !isDoneNode(nextNode) && !isFailNode(nextNode)) {
+        const failure = continuationFailure(`step ${config.id}`);
+        await options.emit(
+          createEvent({
+            runId: options.runId,
+            workflowId: options.workflowId,
+            stepId: config.id,
+            type: "step.failed",
+            payload: { failure }
+          })
+        );
+        return { status: "failure", failure };
+      }
+      if (isFailNode(nextNode)) {
+        return { status: "failure", failure: nextNode.failure };
+      }
+      node = nextNode;
+      source = `step ${config.id}`;
+    } catch (error) {
+      const failure = stepExecutionFailure(error);
+      await options.emit(
+        createEvent({
+          runId: options.runId,
+          workflowId: options.workflowId,
+          stepId: config.id,
+          type: "step.failed",
+          payload: { failure }
+        })
+      );
+      if (!stepNode.onError) {
+        return { status: "failure", failure };
+      }
+      try {
+        const nextNode = stepNode.onError(failure);
+        if (!isStepNode(nextNode) && !isDoneNode(nextNode) && !isFailNode(nextNode)) {
+          return {
+            status: "failure",
+            failure: continuationFailure(`error continuation for step ${config.id}`)
+          };
+        }
+        node = nextNode;
+        source = `error continuation for step ${config.id}`;
+      } catch (errorContinuationError) {
+        return {
+          status: "failure",
+          failure: stepExecutionFailure(
+            new Error(
+              `error continuation for step ${config.id} failed: ${errorMessage(errorContinuationError)}`
+            )
+          )
+        };
+      }
+    }
+  }
+}
+async function runWithStepTimeout(options) {
+  if (options.timeoutMs === void 0) {
+    return await options.run();
+  }
+  const timeoutMs = options.timeoutMs;
+  const abortController = new AbortController();
+  let timeout;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeout = setTimeout(() => {
+      abortController.abort();
+      reject(stepTimeoutFailure(options.stepId, timeoutMs));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([options.run(abortController.signal), timeoutPromise]);
+  } finally {
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+  }
+}
+function throwIfStepTimedOut(signal, stepId, timeoutMs) {
+  if (signal?.aborted && timeoutMs !== void 0) {
+    throw stepTimeoutFailure(stepId, timeoutMs);
+  }
+}
+function stepTimeoutFailure(stepId, timeoutMs) {
+  return new TrailStepFailureError({
+    code: "step_timeout",
+    message: `Step ${stepId} timed out after ${timeoutMs}ms.`,
+    details: { stepId, timeoutMs }
+  });
+}
+function errorMessage(error) {
+  if (error instanceof TrailStepFailureError) {
+    return error.message;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Error continuation failed.";
+}
+function continuationFailure(source) {
+  return {
+    code: "invalid_continuation",
+    message: `${source} returned an invalid continuation node.`
+  };
+}
+
+// src/runtime/failures/workflow-failure.ts
+function workflowFailure(error) {
+  if (isFailureLikeError(error)) {
+    return error.failure;
+  }
+  return {
+    code: "workflow_failed",
+    message: error instanceof Error ? error.message : "Unknown workflow failure.",
+    ...error === void 0 ? {} : { details: { cause: error } }
+  };
+}
+
+// src/runtime/resume/replay-completed-steps/replay-completed-steps.ts
+async function replayCompletedSteps(options) {
+  let node = options.workflow.start(options.input);
+  const completedStepEvents = options.events.filter((event) => event.type === "step.completed");
+  for (const [completedIndex, completedEvent] of completedStepEvents.entries()) {
+    const stepIndex = completedIndex + 1;
+    if (!isStepNode(node)) {
+      return {
+        status: "failure",
+        failure: replayFailure(
+          "resume_step_id_drift",
+          "Completed history continues after the current workflow reaches done."
+        )
+      };
+    }
+    if (node.config.id !== completedEvent.stepId) {
+      return {
+        status: "failure",
+        failure: replayFailure(
+          "resume_step_id_drift",
+          `Expected completed step ${node.config.id} but found ${completedEvent.stepId ?? "<missing>"}.`
+        )
+      };
+    }
+    if (node.config.prompt !== void 0) {
+      const recordedOutput = readPlainPayload2(completedEvent, "output");
+      if (!recordedOutput) {
+        return {
+          status: "failure",
+          failure: replayFailure(
+            "resume_missing_step_output",
+            `Completed step ${node.config.id} has no recorded output to resume from.`
+          )
+        };
+      }
+      const outputSchema = resolveStepOutputSchema(node.config);
+      if (!outputSchema) {
+        return {
+          status: "failure",
+          failure: replayFailure(
+            "resume_output_schema_unresolvable",
+            `Step ${node.config.id} has no resolvable output schema to replay with.`
+          )
+        };
+      }
+      const validatedOutput = outputSchema.assert(recordedOutput, `step ${node.config.id} output`);
+      const stepDir = resolveStepArtifactPaths({
+        runDir: options.runDir,
+        stepId: node.config.id,
+        stepIndex
+      }).stepDir;
+      const completedNode = node;
+      node = await withStepContext(
+        completedNode.config.id,
+        stepDir,
+        async () => completedNode.onOutput(validatedOutput, completedNode.config.input)
+      );
+    } else {
+      const stepDir = resolveStepArtifactPaths({
+        runDir: options.runDir,
+        stepId: node.config.id,
+        stepIndex
+      }).stepDir;
+      const completedNode = node;
+      node = await withStepContext(
+        completedNode.config.id,
+        stepDir,
+        async () => completedNode.onOutput(completedNode.config.input, completedNode.config.input)
+      );
+    }
+  }
+  if (!isStepNode(node) || node.config.id !== options.targetStepId) {
+    return {
+      status: "failure",
+      failure: replayFailure(
+        "resume_step_id_drift",
+        `Target step ${options.targetStepId} is not the next live step.`
+      )
+    };
+  }
+  return { status: "success", node };
+}
+function readPlainPayload2(event, key) {
+  const value = event.payload[key];
+  return isPlainObject7(value) ? value : void 0;
+}
+function isPlainObject7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function replayFailure(code, message) {
+  return { code, message };
+}
+
+// src/runtime/resume/reattach-in-progress-step/reattach-in-progress-step.ts
+function findDanglingInteractiveSessionStart(events) {
+  const anchor = events.at(-1);
+  if (anchor?.type !== "interactive.sessionStarted" || !anchor.stepId) {
+    return void 0;
+  }
+  const hasTerminalWorkflowEvent = events.some(
+    (event) => event.type === "workflow.failed" || event.type === "workflow.completed"
+  );
+  return hasTerminalWorkflowEvent ? void 0 : anchor;
+}
+async function reattachInProgressStep(options) {
+  const anchor = findDanglingInteractiveSessionStart(options.events);
+  if (!anchor?.stepId) {
+    return {
+      status: "failure",
+      failure: resumeFailure(
+        "resume_target_not_dangling",
+        "Resume target has no dangling interactive.sessionStarted event to reattach."
+      )
+    };
+  }
+  const stepIndex = anchor.payload.stepIndex;
+  if (typeof stepIndex !== "number") {
+    return {
+      status: "failure",
+      failure: resumeFailure(
+        "resume_missing_step_index",
+        `Dangling interactive.sessionStarted event for step ${anchor.stepId} has no recorded stepIndex.`
+      )
+    };
+  }
+  const startedEvent = options.events.find((event) => event.type === "workflow.started");
+  if (!startedEvent) {
+    return {
+      status: "failure",
+      failure: resumeFailure(
+        "resume_target_not_found",
+        "Resume target has no workflow.started event."
+      )
+    };
+  }
+  if (startedEvent.workflowId !== options.workflow.id) {
+    return {
+      status: "failure",
+      failure: resumeFailure(
+        "resume_workflow_mismatch",
+        `Resume target workflow ${startedEvent.workflowId} does not match ${options.workflow.id}.`
+      )
+    };
+  }
+  const input = readPlainPayload3(startedEvent, "input");
+  if (!input) {
+    return {
+      status: "failure",
+      failure: resumeFailure(
+        "resume_target_not_found",
+        "workflow.started payload is missing input."
+      )
+    };
+  }
+  const replay = await replayCompletedSteps({
+    workflow: options.workflow,
+    events: options.events,
+    input,
+    targetStepId: anchor.stepId,
+    runDir: options.runDir
+  });
+  if (replay.status === "failure") {
+    return replay;
+  }
+  const { node } = replay;
+  const artifactPaths = resolveStepArtifactPaths({
+    runDir: options.runDir,
+    stepId: anchor.stepId,
+    stepIndex
+  });
+  const outputSchema = resolveStepOutputSchema(node.config);
+  if (!outputSchema) {
+    return {
+      status: "failure",
+      failure: resumeFailure(
+        "resume_output_schema_unresolvable",
+        `Step ${node.config.id} has no resolvable output schema to reattach with.`
+      )
+    };
+  }
+  const reattached = await readReattachedInteractiveOutput({
+    stepId: anchor.stepId,
+    interactiveFile: artifactPaths.interactiveFile,
+    outputSchema
+  });
+  if (reattached.status === "failure") {
+    return reattached;
+  }
+  const nextNode = await withStepContext(
+    anchor.stepId,
+    artifactPaths.stepDir,
+    async () => node.onOutput(
+      outputSchema.assert(reattached.output, `step ${node.config.id} output`),
+      node.config.input
+    )
+  );
+  return {
+    status: "success",
+    input,
+    node: nextNode,
+    resumedStepId: anchor.stepId,
+    sourceFailureEventId: anchor.id
+  };
+}
+async function readReattachedInteractiveOutput(options) {
+  const first = await tryReadCompletedInteractiveOutput(options);
+  if (first.status !== "still-active") {
+    return first;
+  }
+  const abortController = new AbortController();
+  await waitForInteractiveCompletion(options.interactiveFile, abortController.signal);
+  const second = await tryReadCompletedInteractiveOutput(options);
+  if (second.status !== "still-active") {
+    return second;
+  }
+  throw new TrailStepFailureError({
+    code: "interactive_session_incomplete",
+    message: `Interactive agent step ${options.stepId} did not complete after reattaching.`
+  });
+}
+async function tryReadCompletedInteractiveOutput(options) {
+  try {
+    return { status: "success", output: await readCompletedInteractiveOutput(options) };
+  } catch (error) {
+    if (error instanceof TrailStepFailureError) {
+      if (error.failure.code === "interactive_session_incomplete") {
+        return { status: "still-active" };
+      }
+      if (error.failure.code === "interactive_session_cancelled") {
+        return {
+          status: "failure",
+          failure: resumeFailure(
+            "resume_interactive_session_cancelled",
+            `Interactive agent step ${options.stepId} was cancelled and cannot be resumed.`
+          )
+        };
+      }
+      if (error.failure.code === "interactive_session_invalid") {
+        return {
+          status: "failure",
+          failure: resumeFailure(
+            "resume_interactive_protocol_missing",
+            `Interactive agent step ${options.stepId} has no readable interactive.json to reattach to.`
+          )
+        };
+      }
+    }
+    throw error;
+  }
+}
+function readPlainPayload3(event, key) {
+  const value = event.payload[key];
+  return isPlainObject8(value) ? value : void 0;
+}
+function isPlainObject8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function resumeFailure(code, message) {
+  return { code, message };
+}
+
+// src/runtime/resume/replay-to-failed-step/replay-to-failed-step.ts
+async function replayToFailedStep(options) {
+  const startedEvent = options.events.find((event) => event.type === "workflow.started");
+  if (!startedEvent) {
+    return {
+      status: "failure",
+      failure: resumeFailure2(
+        "resume_target_not_found",
+        "Resume target has no workflow.started event."
+      )
+    };
+  }
+  if (startedEvent.workflowId !== options.workflow.id) {
+    return {
+      status: "failure",
+      failure: resumeFailure2(
+        "resume_workflow_mismatch",
+        `Resume target workflow ${startedEvent.workflowId} does not match ${options.workflow.id}.`
+      )
+    };
+  }
+  const terminalEvent = options.events.at(-1);
+  if (terminalEvent?.type !== "workflow.failed") {
+    return {
+      status: "failure",
+      failure: resumeFailure2(
+        "resume_target_not_failed",
+        "Resume target must end in workflow.failed."
+      )
+    };
+  }
+  const recoveredFailedStep = options.events.find(
+    (event, index) => event.type === "step.failed" && options.events.slice(index + 1).some(
+      (laterEvent) => laterEvent.type === "step.completed" && laterEvent.stepId === event.stepId
+    )
+  );
+  if (recoveredFailedStep) {
+    return {
+      status: "failure",
+      failure: resumeFailure2(
+        "resume_unsupported_history",
+        `Resume does not support recovered onError history for step ${recoveredFailedStep.stepId ?? "<missing>"}.`
+      )
+    };
+  }
+  const failedStepEvents = options.events.filter((event) => event.type === "step.failed");
+  if (failedStepEvents.length !== 1) {
+    return {
+      status: "failure",
+      failure: resumeFailure2(
+        "resume_multiple_failed_steps",
+        "Resume target must contain exactly one failed step."
+      )
+    };
+  }
+  const failedStepEvent = failedStepEvents[0];
+  if (!failedStepEvent) {
+    return {
+      status: "failure",
+      failure: resumeFailure2("resume_target_not_failed", "Resume target has no failed step.")
+    };
+  }
+  if (!failedStepEvent.stepId) {
+    return {
+      status: "failure",
+      failure: resumeFailure2("resume_target_not_failed", "Failed step event has no step id.")
+    };
+  }
+  const input = readPlainPayload4(startedEvent, "input");
+  if (!input) {
+    return {
+      status: "failure",
+      failure: resumeFailure2(
+        "resume_target_not_found",
+        "workflow.started payload is missing input."
+      )
+    };
+  }
+  const replay = await replayCompletedSteps({
+    workflow: options.workflow,
+    events: options.events,
+    input,
+    targetStepId: failedStepEvent.stepId,
+    runDir: options.runDir
+  });
+  if (replay.status === "failure") {
+    return replay;
+  }
+  const { node } = replay;
+  if (node.onError) {
+    return {
+      status: "failure",
+      failure: resumeFailure2(
+        "resume_unsupported_history",
+        `Resume does not support onError history for step ${node.config.id}.`
+      )
+    };
+  }
+  return {
+    status: "success",
+    input,
+    node,
+    resumedStepId: failedStepEvent.stepId,
+    sourceFailureEventId: failedStepEvent.id
+  };
+}
+function readPlainPayload4(event, key) {
+  const value = event.payload[key];
+  return isPlainObject9(value) ? value : void 0;
+}
+function isPlainObject9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function resumeFailure2(code, message) {
+  return { code, message };
+}
+
+// src/runtime/retry/replay-to-retry-failure.ts
+async function replayToRetryFailure(options) {
+  const failure = selectLatestUnresolvedFailure(options.events);
+  if (!failure) {
+    return {
+      status: "failure",
+      failure: retryFailure(
+        "retry_target_not_failed",
+        "Retry target has no latest unresolved failure."
+      )
+    };
+  }
+  if (failure.workflowId !== options.workflow.id) {
+    return {
+      status: "failure",
+      failure: retryFailure(
+        "retry_workflow_mismatch",
+        `Retry target workflow ${failure.workflowId} does not match ${options.workflow.id}.`
+      )
+    };
+  }
+  if (!failure.workflowInput) {
+    return {
+      status: "failure",
+      failure: retryFailure("retry_target_not_found", "workflow.started payload is missing input.")
+    };
+  }
+  if (!failure.stepId) {
+    return {
+      status: "failure",
+      failure: retryFailure(
+        "retry_target_not_failed",
+        failure.event.type === "workflow.failed" ? "Workflow failure has no associated step ID. This run may use unsupported historical retry metadata." : "Failed retry target event has no step ID."
+      )
+    };
+  }
+  const replay = await replayCompletedSteps({
+    workflow: options.workflow,
+    events: eventsBeforeRetryTarget(options.events, failure.replayPosition, failure.stepId),
+    input: failure.workflowInput,
+    targetStepId: failure.stepId,
+    runDir: options.runDir
+  });
+  if (replay.status === "failure") {
+    return replay;
+  }
+  const { node } = replay;
+  if (node.onError) {
+    return {
+      status: "failure",
+      failure: retryFailure(
+        "retry_unsupported_history",
+        `Retry does not support onError history for step ${node.config.id}.`
+      )
+    };
+  }
+  return {
+    status: "success",
+    input: failure.workflowInput,
+    node,
+    retriedStepId: failure.stepId,
+    sourceFailureEventId: failure.sourceFailureEventId ?? failure.event.id,
+    sourceFailureReplayPosition: failure.replayPosition
+  };
+}
+function eventsBeforeRetryTarget(events, replayPosition, targetStepId) {
+  const eventsBeforeFailure = events.slice(0, replayPosition);
+  let targetAttemptStartPosition = -1;
+  for (let index = eventsBeforeFailure.length - 1; index >= 0; index -= 1) {
+    const event = eventsBeforeFailure[index];
+    if (event?.type === "step.started" && event.stepId === targetStepId) {
+      targetAttemptStartPosition = index;
+      break;
+    }
+  }
+  if (targetAttemptStartPosition === -1) {
+    return eventsBeforeFailure;
+  }
+  return eventsBeforeFailure.filter(
+    (event, index) => index <= targetAttemptStartPosition || event.type !== "step.completed" || event.stepId !== targetStepId
+  );
+}
+function retryFailure(code, message) {
+  return { code, message };
+}
+
+// src/runtime/run-context/create-run-context.ts
+function createRunContext(options) {
+  let cache;
+  let loadPromise;
+  let writeQueue = Promise.resolve();
+  function ensureLoaded() {
+    if (cache) return Promise.resolve(cache);
+    loadPromise ??= readRunState(options.runDir).then((state2) => cache = state2);
+    return loadPromise;
+  }
+  function enqueueWrite() {
+    const next = writeQueue.then(async () => {
+      const state2 = await ensureLoaded();
+      await writeRunState(options.runDir, state2);
+    });
+    writeQueue = next.catch(() => {
+    });
+    return next;
+  }
+  return {
+    id: options.runId,
+    name: options.runName,
+    path: options.runDir,
+    workflowId: options.workflowId,
+    workflowAgents: options.workflowAgents,
+    cwd: options.cwd,
+    trailstepConfig: options.trailstepConfig,
+    workingAgentProcessRunner: options.workingAgentProcessRunner,
+    providerWorkingRunner: options.providerWorkingRunner,
+    emit: options.emit,
+    events: options.events,
+    state: {
+      async get(key) {
+        const state2 = await ensureLoaded();
+        return state2[key];
+      },
+      async set(key, value) {
+        const state2 = await ensureLoaded();
+        state2[key] = value;
+        await enqueueWrite();
+      }
+    }
+  };
+}
+
+// src/runtime/run-workflow/initialize-run.ts
+import { basename as basename2 } from "path";
+async function initializeRun(options) {
+  const existingRunDir = options.resume?.runDir ?? options.retry?.runDir;
+  if (existingRunDir) {
+    const previousEvents = await readRunEvents(existingRunDir);
+    const startedEvent = previousEvents.find((event) => event.type === "workflow.started");
+    return {
+      runId: startedEvent?.runId ?? basename2(existingRunDir),
+      runName: startedEvent?.runId ?? basename2(existingRunDir),
+      runDir: existingRunDir,
+      previousEvents
+    };
+  }
+  const cwd = options.cwd ?? process.cwd();
+  const runName = options.runName;
+  if (runName === void 0) {
+    throw new Error("Expected runName for a new workflow run.");
+  }
+  const { runId, runDir } = await createRunDirectory({
+    cwd,
+    runName,
+    runsRoot: options.runsRoot
+  });
+  return { runId, runName, runDir, previousEvents: [] };
+}
+
+// src/runtime/run-workflow/trailstep-config-input.ts
+function parseTrailStepConfigInput(value) {
+  if (isParsedTrailStepConfig(value) || isFlattenedTrailStepConfig(value)) {
+    return value;
+  }
+  return parseTrailStepConfig(value);
+}
+function isFlattenedTrailStepConfig(value) {
+  if (!isPlainRecord(value) || value.version !== 1) {
+    return false;
+  }
+  if (!isPlainRecord(value.customProviders) || !isFlattenedAgentMappings(value.agents)) {
+    return false;
+  }
+  if (value.settings !== void 0 && !isFlattenedSettings(value.settings)) {
+    return false;
+  }
+  if (value.workflows === void 0) {
+    return true;
+  }
+  if (!isPlainRecord(value.workflows)) {
+    return false;
+  }
+  return Object.values(value.workflows).every(
+    (workflow) => isPlainRecord(workflow) && (workflow.agents === void 0 || isFlattenedAgentMappings(workflow.agents)) && (workflow.settings === void 0 || isFlattenedSettings(workflow.settings))
+  );
+}
+function isFlattenedSettings(value) {
+  return isPlainRecord(value) && (value.retry === void 0 || isPlainRecord(value.retry)) && (value.timeout === void 0 || typeof value.timeout === "number");
+}
+function isFlattenedAgentMappings(value) {
+  return isPlainRecord(value) && Object.values(value).every(
+    (targets) => Array.isArray(targets) && targets.every(isFlattenedAgentTarget)
+  );
+}
+function isFlattenedAgentTarget(value) {
+  return isPlainRecord(value) && typeof value.provider === "string";
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/runtime/run-workflow/run-workflow.ts
+async function runWorkflow(options) {
+  const maxSteps = options.maxSteps ?? 1e3;
+  const isResume = options.resume !== void 0;
+  const isRetry = options.retry !== void 0;
+  const initialized = await initializeRun(options).catch((error) => {
+    const existingRunDir = options.resume?.runDir ?? options.retry?.runDir;
+    if (existingRunDir && isFailureLikeError(error)) {
+      return {
+        status: "failure",
+        runId: basename3(existingRunDir),
+        runName: basename3(existingRunDir),
+        runDir: existingRunDir,
+        previousEvents: [],
+        failure: workflowFailure(error)
+      };
+    }
+    throw error;
+  });
+  if ("status" in initialized && initialized.status === "failure") {
+    return {
+      status: "failure",
+      runId: initialized.runId,
+      runDir: initialized.runDir,
+      failure: initialized.failure,
+      events: initialized.previousEvents
+    };
+  }
+  const { runId, runName, runDir, previousEvents } = initialized;
+  const trailstepConfig = options.trailstepConfig === void 0 ? void 0 : parseTrailStepConfigInput(options.trailstepConfig);
+  const cwd = options.cwd ?? process.cwd();
+  const events = [...previousEvents];
+  const emit = async (event) => {
+    events.push(event);
+    await appendEvent(runDir, event);
+    await options.eventSink?.(event);
+  };
+  const runContext = createRunContext({
+    runId,
+    runName,
+    runDir,
+    workflowId: options.workflow.id,
+    workflowAgents: options.workflow.agents ?? {},
+    cwd,
+    trailstepConfig,
+    workingAgentProcessRunner: options.workingAgentProcessRunner,
+    providerWorkingRunner: options.providerWorkingRunner,
+    emit,
+    events: () => events
+  });
+  const failWorkflow = async (failure) => {
+    await emit(
+      createEvent({
+        runId,
+        workflowId: options.workflow.id,
+        type: "workflow.failed",
+        payload: { failure }
+      })
+    );
+    return {
+      status: "failure",
+      runId,
+      runDir,
+      failure,
+      events
+    };
+  };
+  const failResumeValidation = (failure) => ({
+    status: "failure",
+    runId,
+    runDir,
+    failure,
+    events
+  });
+  try {
+    return await runContextStorage.run(runContext, () => runWorkflowBody());
+  } catch (error) {
+    return await failWorkflow(workflowFailure(error));
+  }
+  async function runWorkflowBody() {
+    const inputSchema = options.workflow.inputShape ? normalizeShape(options.workflow.inputShape) : options.workflow.input;
+    let workflowInput;
+    let startNode;
+    if (isResume) {
+      const danglingAnchor = findDanglingInteractiveSessionStart(previousEvents);
+      const replay = danglingAnchor ? await reattachInProgressStep({
+        workflow: options.workflow,
+        events: previousEvents,
+        runDir
+      }) : await replayToFailedStep({
+        workflow: options.workflow,
+        events: previousEvents,
+        runDir
+      });
+      if (replay.status === "failure") {
+        return failResumeValidation(replay.failure);
+      }
+      workflowInput = inputSchema ? inputSchema.assert(replay.input, "workflow input") : replay.input;
+      startNode = replay.node;
+      await emit(
+        createEvent({
+          runId,
+          workflowId: options.workflow.id,
+          type: "workflow.resumed",
+          payload: {
+            resumedFromRunDir: runDir,
+            resumedStepId: replay.resumedStepId,
+            sourceFailureEventId: replay.sourceFailureEventId
+          }
+        })
+      );
+    } else if (isRetry) {
+      const replay = await replayToRetryFailure({
+        workflow: options.workflow,
+        events: previousEvents,
+        runDir
+      });
+      if (replay.status === "failure") {
+        return failResumeValidation(replay.failure);
+      }
+      workflowInput = inputSchema ? inputSchema.assert(replay.input, "workflow input") : replay.input;
+      startNode = replay.node;
+      await emit(
+        createEvent({
+          runId,
+          workflowId: options.workflow.id,
+          type: "workflow.retryStarted",
+          payload: {
+            retryKind: options.retry.kind,
+            retriedFromRunDir: runDir,
+            retriedStepId: replay.retriedStepId,
+            sourceFailureEventId: replay.sourceFailureEventId,
+            sourceFailureReplayPosition: replay.sourceFailureReplayPosition
+          }
+        })
+      );
+    } else {
+      workflowInput = inputSchema ? inputSchema.assert(options.input, "workflow input") : options.input;
+      await emit(
+        createEvent({
+          runId,
+          workflowId: options.workflow.id,
+          type: "workflow.started",
+          payload: { input: workflowInput }
+        })
+      );
+    }
+    const continuationResult = await runContinuation({
+      node: startNode ?? options.workflow.start(workflowInput),
+      runId,
+      workflowId: options.workflow.id,
+      emit,
+      maxSteps,
+      initialSource: isRetry ? `retry for workflow ${options.workflow.id}` : isResume ? `resume for workflow ${options.workflow.id}` : `workflow.start for workflow ${options.workflow.id}`,
+      // The original run already used one step-index slot per step.started
+      // event ever recorded (successful or failed) -- newly-dispatched steps
+      // after resume must continue that sequence, not restart at 1, or their
+      // artifact directories collide with the pre-resume steps' directories.
+      initialExecutedSteps: isResume || isRetry ? previousEvents.filter((event) => event.type === "step.started").length : void 0,
+      workflowAgents: options.workflow.agents ?? {},
+      workflowTimeout: options.workflow.timeout,
+      runDir,
+      cwd,
+      trailstepConfig,
+      workingAgentProcessRunner: options.workingAgentProcessRunner,
+      providerWorkingRunner: options.providerWorkingRunner,
+      processRunner: options.processRunner
+    });
+    if (continuationResult.status === "failure") {
+      return await failWorkflow(continuationResult.failure);
+    }
+    const current = continuationResult.output;
+    const outputSchema = options.workflow.outputShape ? normalizeShape(options.workflow.outputShape) : options.workflow.output;
+    const output = outputSchema ? outputSchema.assert(current, "workflow output") : current;
+    await emit(
+      createEvent({
+        runId,
+        workflowId: options.workflow.id,
+        type: "workflow.completed",
+        payload: { output }
+      })
+    );
+    return {
+      status: "success",
+      runId,
+      runDir,
+      output,
+      events
+    };
+  }
+}
+
+// src/runtime/runs/run-summaries.ts
+import { readdir } from "fs/promises";
+import { join as join7 } from "path";
+async function listRunSummaries(options) {
+  const runsRoot = options.runsRoot ?? defaultRunsRoot(options.cwd);
+  let entries;
+  try {
+    entries = await readdir(runsRoot, { withFileTypes: true });
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const summaries = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const runId = entry.name;
+    const runDir = join7(runsRoot, runId);
+    try {
+      summaries.push(summarizeReadableRun({ runId, runDir, events: await readRunEvents(runDir) }));
+    } catch (error) {
+      summaries.push({
+        runId,
+        runDir,
+        status: "unknown",
+        warning: `Warning: Could not read run ${runId}: ${readErrorMessage(error)}`
+      });
+    }
+  }
+  return summaries.sort(newestFirst);
+}
+function selectRecentFailedRunSummaries(summaries, options = {}) {
+  const cutoffMs = (options.now ?? /* @__PURE__ */ new Date()).getTime() - 7 * 24 * 60 * 60 * 1e3;
+  return summaries.filter((summary) => {
+    if (summary.status !== "failed" || !summary.latestFailure) {
+      return false;
+    }
+    const failureTime = Date.parse(summary.latestFailure.event.timestamp);
+    return Number.isFinite(failureTime) && failureTime >= cutoffMs;
+  }).sort(newestFirst).slice(0, 10);
+}
+function newestFirst(left, right) {
+  return compareTimestampDescending(left.lastTimestamp, right.lastTimestamp) || left.runId.localeCompare(right.runId);
+}
+function summarizeReadableRun(options) {
+  const latestFailure = selectLatestUnresolvedFailure(options.events);
+  const terminalStatus = selectTerminalStatus(options.events);
+  const lastEvent = options.events.at(-1);
+  const workflowId = lastEvent?.workflowId ?? options.events.find((event) => event.workflowId)?.workflowId;
+  if (terminalStatus === "completed") {
+    return {
+      ...options,
+      status: "completed",
+      workflowId,
+      lastTimestamp: lastEvent?.timestamp
+    };
+  }
+  if (latestFailure) {
+    return {
+      ...options,
+      status: "failed",
+      workflowId: latestFailure.workflowId,
+      lastTimestamp: latestFailure.event.timestamp,
+      latestFailure
+    };
+  }
+  return {
+    ...options,
+    status: terminalStatus ?? "active",
+    workflowId,
+    lastTimestamp: lastEvent?.timestamp
+  };
+}
+function selectTerminalStatus(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (event?.type === "workflow.completed") {
+      return "completed";
+    }
+    if (event?.type === "workflow.failed") {
+      return "failed";
+    }
+  }
+  return void 0;
+}
+function compareTimestampDescending(left, right) {
+  const leftTime = left ? Date.parse(left) : Number.NEGATIVE_INFINITY;
+  const rightTime = right ? Date.parse(right) : Number.NEGATIVE_INFINITY;
+  return rightTime - leftTime;
+}
+function readErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+export {
+  Document,
+  TrailStepFailureError,
+  defaultRunsRoot,
+  deprecationManifest,
+  document,
+  done,
+  fail,
+  findDeprecationsAsOf,
+  isDoneNode,
+  isFailNode,
+  isStepNode,
+  jsonSchema,
+  list,
+  listRunSummaries,
+  loadFragments,
+  newestFirst,
+  normalizeShape,
+  parseTrailStepConfig,
+  promptSections,
+  promptTemplate,
+  providerRegistry,
+  readRunEvents,
+  readRunState,
+  resolveAgentTargets,
+  resolveRetryPolicy,
+  resolveTimeoutPolicy,
+  runWorkflow,
+  section,
+  selectLatestUnresolvedFailure,
+  selectRecentFailedRunSummaries,
+  shape,
+  state,
+  step,
+  subPrompt,
+  validateRetryPolicy,
+  validateTimeoutPolicy,
+  writeRunState
+};
+//# sourceMappingURL=index.js.map