@assemble-dev/sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,3877 @@
+// src/agents/agent-definition.ts
+function agent(config) {
+  return Object.freeze({
+    ...config,
+    maxSteps: config.maxSteps ?? 1
+  });
+}
+
+// src/agents/agent-runner.ts
+import { AppErrorCode as AppErrorCode3 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError3 } from "@assemble-dev/shared-utils/errors";
+
+// src/agents/agent-messages.ts
+function serializeAgentInputToText(input) {
+  return typeof input === "string" ? input : JSON.stringify(input);
+}
+async function buildAgentChatMessages(definition, input, threadMemory) {
+  const priorThreadMessages = threadMemory === void 0 ? [] : await threadMemory.listThreadMessages();
+  return [
+    { role: "system", content: definition.instructions },
+    ...priorThreadMessages.map(mapRunMessageToChatMessage),
+    { role: "user", content: serializeAgentInputToText(input) }
+  ];
+}
+function mapRunMessageToChatMessage(message) {
+  if (message.toolName === void 0) {
+    return { role: message.role, content: message.content };
+  }
+  return {
+    role: message.role,
+    content: message.content,
+    toolName: message.toolName
+  };
+}
+async function appendAgentExchangeToThreadMemory(threadMemory, agentName, input, assistantText, now) {
+  if (threadMemory === void 0) {
+    return;
+  }
+  await threadMemory.appendThreadMessage({
+    role: "user",
+    content: serializeAgentInputToText(input),
+    timestamp: now().toISOString()
+  });
+  await threadMemory.appendThreadMessage({
+    role: "assistant",
+    content: assistantText,
+    agentName,
+    timestamp: now().toISOString()
+  });
+}
+
+// src/agents/agent-output-generation.ts
+import { AppErrorCode as AppErrorCode2 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError2 } from "@assemble-dev/shared-utils/errors";
+import { z } from "zod";
+
+// src/agents/agent-model-timeout.ts
+import { AppErrorCode } from "@assemble-dev/shared-types/errors";
+import { AppError } from "@assemble-dev/shared-utils/errors";
+var agentTimeoutErrorCode = "AGENT_TIMEOUT";
+async function raceModelCallAgainstTimeout(modelCall, timeoutMs, agentName) {
+  if (timeoutMs === void 0) {
+    return await modelCall;
+  }
+  return await new Promise((resolve, reject) => {
+    const timeoutHandle = setTimeout(() => {
+      reject(buildAgentTimeoutError(agentName, timeoutMs));
+    }, timeoutMs);
+    void modelCall.then(
+      (modelResult) => {
+        clearTimeout(timeoutHandle);
+        resolve(modelResult);
+      },
+      (modelError) => {
+        clearTimeout(timeoutHandle);
+        reject(modelError);
+      }
+    );
+  });
+}
+function buildAgentTimeoutError(agentName, timeoutMs) {
+  return new AppError({
+    code: AppErrorCode.InternalServerError,
+    message: `Agent "${agentName}" timed out after ${timeoutMs}ms`,
+    statusCode: 504,
+    details: {
+      errorCode: agentTimeoutErrorCode,
+      timeoutMs
+    }
+  });
+}
+
+// src/agents/agent-output-generation.ts
+async function generateAgentOutput(definition, input, threadMemory) {
+  const messages = await buildAgentChatMessages(definition, input, threadMemory);
+  const outputSchema = definition.outputSchema;
+  if (outputSchema === void 0) {
+    const completion = await raceModelCallAgainstTimeout(
+      definition.model.generateChatCompletion({ messages }),
+      definition.timeoutMs,
+      definition.name
+    );
+    return {
+      output: completion.content,
+      rawText: completion.content,
+      tokenUsage: completion.tokenUsage
+    };
+  }
+  return await generateStructuredAgentOutput(definition, outputSchema, messages);
+}
+async function generateStructuredAgentOutput(definition, outputSchema, messages) {
+  try {
+    return await requestStructuredAgentOutput(definition, outputSchema, messages);
+  } catch (error) {
+    if (!(error instanceof AppError2) || error.code !== AppErrorCode2.ValidationFailed) {
+      throw error;
+    }
+    return await retryStructuredAgentOutput(definition, outputSchema, messages, error);
+  }
+}
+async function retryStructuredAgentOutput(definition, outputSchema, messages, validationError) {
+  const retryMessages = [
+    ...messages,
+    buildSchemaCorrectionMessage(validationError.message)
+  ];
+  try {
+    return await requestStructuredAgentOutput(definition, outputSchema, retryMessages);
+  } catch (retryError) {
+    if (!(retryError instanceof AppError2) || retryError.code !== AppErrorCode2.ValidationFailed) {
+      throw retryError;
+    }
+    throw new AppError2({
+      code: AppErrorCode2.ValidationFailed,
+      message: `Agent "${definition.name}" structured output failed schema validation after one retry: ${retryError.message}`,
+      statusCode: 422,
+      cause: retryError
+    });
+  }
+}
+async function requestStructuredAgentOutput(definition, outputSchema, messages) {
+  try {
+    const structuredResult = await raceModelCallAgainstTimeout(
+      definition.model.generateStructuredOutput({
+        messages,
+        schema: outputSchema
+      }),
+      definition.timeoutMs,
+      definition.name
+    );
+    return {
+      output: structuredResult.value,
+      rawText: JSON.stringify(structuredResult.value),
+      tokenUsage: structuredResult.tokenUsage
+    };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      throw new AppError2({
+        code: AppErrorCode2.ValidationFailed,
+        message: `Structured output failed schema validation: ${error.message}`,
+        statusCode: 422
+      });
+    }
+    throw error;
+  }
+}
+function buildSchemaCorrectionMessage(validationErrorMessage) {
+  return {
+    role: "user",
+    content: `The previous response failed schema validation: ${validationErrorMessage}. Respond again with JSON that matches the required schema exactly.`
+  };
+}
+
+// src/agents/agent-trace-events.ts
+import { JsonValueSchema } from "@assemble-dev/shared-types/json";
+import { generateTraceEventId } from "@assemble-dev/shared-utils/ids";
+function buildAgentEventBase(eventContext, parentEventId) {
+  const runState = eventContext.traceBus.getRunState();
+  return {
+    id: generateTraceEventId(),
+    runId: runState.runId,
+    workflowName: runState.workflowName,
+    timestamp: eventContext.now().toISOString(),
+    parentEventId,
+    redacted: false
+  };
+}
+function emitAgentStartedEvent(eventContext, input, parentEventId) {
+  return eventContext.traceBus.emitTraceEvent({
+    ...buildAgentEventBase(eventContext, parentEventId),
+    type: "agent.started",
+    agentName: eventContext.agentName,
+    input
+  });
+}
+function emitAgentCompletedEvent(eventContext, startedEventId, output, latencyMs) {
+  eventContext.traceBus.emitTraceEvent({
+    ...buildAgentEventBase(eventContext, startedEventId),
+    type: "agent.completed",
+    agentName: eventContext.agentName,
+    output: JsonValueSchema.parse(output),
+    latencyMs
+  });
+}
+function emitAgentFailedEvent(eventContext, parentEventId, error, latencyMs) {
+  eventContext.traceBus.emitTraceEvent({
+    ...buildAgentEventBase(eventContext, parentEventId),
+    type: "agent.failed",
+    agentName: eventContext.agentName,
+    error: {
+      message: error.message,
+      code: resolveAgentTraceErrorCode(error)
+    },
+    latencyMs
+  });
+}
+function resolveAgentTraceErrorCode(error) {
+  const detailsErrorCode = error.details?.errorCode;
+  return typeof detailsErrorCode === "string" ? detailsErrorCode : error.code;
+}
+
+// src/agents/agent-runner.ts
+async function runAgent(runInput) {
+  const now = runInput.now ?? (() => /* @__PURE__ */ new Date());
+  const eventContext = {
+    traceBus: runInput.traceBus,
+    agentName: runInput.definition.name,
+    now
+  };
+  const startedAtMs = now().getTime();
+  const validatedInput = validateAgentInput(runInput, eventContext, startedAtMs);
+  const startedEvent = emitAgentStartedEvent(
+    eventContext,
+    validatedInput,
+    runInput.parentEventId ?? null
+  );
+  invokeAgentStartHook(runInput.definition, validatedInput);
+  try {
+    return await completeAgentRun(
+      runInput,
+      eventContext,
+      validatedInput,
+      startedEvent.id,
+      startedAtMs
+    );
+  } catch (error) {
+    const appError = mapCaughtErrorToAppError(
+      error instanceof Error ? error : new Error(String(error))
+    );
+    emitAgentFailedEvent(
+      eventContext,
+      startedEvent.id,
+      appError,
+      now().getTime() - startedAtMs
+    );
+    invokeAgentErrorHook(runInput.definition, appError);
+    throw appError;
+  }
+}
+async function completeAgentRun(runInput, eventContext, validatedInput, startedEventId, startedAtMs) {
+  const generation = await generateAgentOutput(
+    runInput.definition,
+    validatedInput,
+    runInput.threadMemory
+  );
+  await appendAgentExchangeToThreadMemory(
+    runInput.threadMemory,
+    runInput.definition.name,
+    validatedInput,
+    generation.rawText,
+    eventContext.now
+  );
+  const latencyMs = eventContext.now().getTime() - startedAtMs;
+  emitAgentCompletedEvent(eventContext, startedEventId, generation.output, latencyMs);
+  invokeAgentCompleteHook(runInput.definition, generation.output);
+  return {
+    output: generation.output,
+    rawText: generation.rawText,
+    tokenUsage: generation.tokenUsage,
+    latencyMs,
+    agentCallEventId: startedEventId
+  };
+}
+function validateAgentInput(runInput, eventContext, startedAtMs) {
+  const inputSchema = runInput.definition.inputSchema;
+  if (inputSchema === void 0) {
+    return runInput.input;
+  }
+  const parsedInput = inputSchema.safeParse(runInput.input);
+  if (parsedInput.success) {
+    return parsedInput.data;
+  }
+  const validationError = new AppError3({
+    code: AppErrorCode3.ValidationFailed,
+    message: `Agent "${runInput.definition.name}" input failed schema validation: ${parsedInput.error.message}`,
+    statusCode: 422
+  });
+  emitAgentFailedEvent(
+    eventContext,
+    runInput.parentEventId ?? null,
+    validationError,
+    eventContext.now().getTime() - startedAtMs
+  );
+  invokeAgentErrorHook(runInput.definition, validationError);
+  throw validationError;
+}
+function mapCaughtErrorToAppError(error) {
+  if (error instanceof AppError3) {
+    return error;
+  }
+  return new AppError3({
+    code: AppErrorCode3.InternalServerError,
+    message: error.message,
+    statusCode: 500,
+    cause: error
+  });
+}
+function invokeAgentStartHook(definition, input) {
+  invokeAgentHookSafely(
+    () => definition.onAgentStart?.({ agentName: definition.name, input })
+  );
+}
+function invokeAgentCompleteHook(definition, output) {
+  invokeAgentHookSafely(
+    () => definition.onAgentComplete?.({ agentName: definition.name, output })
+  );
+}
+function invokeAgentErrorHook(definition, error) {
+  invokeAgentHookSafely(
+    () => definition.onAgentError?.({ agentName: definition.name, error })
+  );
+}
+function invokeAgentHookSafely(invokeHook) {
+  try {
+    invokeHook();
+  } catch {
+    return;
+  }
+}
+
+// src/tools/tool-definition.ts
+import { z as z2 } from "zod";
+var ToolRetryConfigSchema = z2.object({
+  maxAttempts: z2.number().int().min(1)
+});
+var ToolDefinitionOptionsSchema = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().min(1),
+  allowedAgentNames: z2.array(z2.string().min(1)).optional(),
+  requiresApproval: z2.boolean().optional(),
+  retry: ToolRetryConfigSchema.optional(),
+  timeoutMs: z2.number().int().positive().optional(),
+  sensitiveFieldNames: z2.array(z2.string().min(1)).optional(),
+  dryRun: z2.boolean().optional()
+});
+var defaultToolRetryConfig = Object.freeze({
+  maxAttempts: 1
+});
+function tool(config) {
+  const parsedOptions = ToolDefinitionOptionsSchema.parse({
+    name: config.name,
+    description: config.description,
+    allowedAgentNames: config.allowedAgentNames,
+    requiresApproval: config.requiresApproval,
+    retry: config.retry,
+    timeoutMs: config.timeoutMs,
+    sensitiveFieldNames: config.sensitiveFieldNames,
+    dryRun: config.dryRun
+  });
+  return Object.freeze({
+    name: parsedOptions.name,
+    description: parsedOptions.description,
+    inputSchema: config.inputSchema,
+    outputSchema: config.outputSchema ?? null,
+    execute: config.execute,
+    allowedAgentNames: parsedOptions.allowedAgentNames ?? null,
+    requiresApproval: parsedOptions.requiresApproval ?? false,
+    retry: parsedOptions.retry ?? defaultToolRetryConfig,
+    timeoutMs: parsedOptions.timeoutMs ?? null,
+    sensitiveFieldNames: parsedOptions.sensitiveFieldNames ?? [],
+    dryRun: parsedOptions.dryRun ?? false
+  });
+}
+
+// src/tools/tool-broker.ts
+import { AppErrorCode as AppErrorCode4 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError4 } from "@assemble-dev/shared-utils/errors";
+import { generateApprovalId, generateTraceEventId as generateTraceEventId3 } from "@assemble-dev/shared-utils";
+import {
+  resolveRedactionMode
+} from "@assemble-dev/shared-utils/redaction";
+
+// src/policies/policy-engine.ts
+import {
+  PolicyDecisionSchema
+} from "@assemble-dev/shared-types/runs";
+
+// src/policies/tool-policy.ts
+var toolPolicyEffectNames = [
+  "block",
+  "requireApproval",
+  "redact",
+  "logOnly"
+];
+
+// src/policies/policy-engine.ts
+var defaultPolicyName = "default-policy";
+var policyActionPrecedence = [
+  "block",
+  "requireApproval",
+  "redact",
+  "logOnly",
+  "allow"
+];
+function evaluateToolPolicies(input) {
+  const applicablePolicies = input.policies.filter(
+    (policy2) => doesPolicyApplyToTool(policy2, input.context.toolName)
+  );
+  const [firstPolicy, ...remainingPolicies] = applicablePolicies;
+  if (firstPolicy === void 0) {
+    return buildDefaultAllowEvaluation(input.context, input.timestamp);
+  }
+  const firstDecision = evaluateSingleToolPolicy(
+    firstPolicy,
+    input.context,
+    input.timestamp
+  );
+  const remainingDecisions = remainingPolicies.map(
+    (policy2) => evaluateSingleToolPolicy(policy2, input.context, input.timestamp)
+  );
+  const strongestDecision = resolveStrongestPolicyDecision(
+    firstDecision,
+    remainingDecisions
+  );
+  return {
+    action: strongestDecision.action,
+    reason: strongestDecision.reason,
+    policyName: strongestDecision.policyName,
+    decisions: [firstDecision, ...remainingDecisions]
+  };
+}
+function doesPolicyApplyToTool(policy2, toolName) {
+  if (policy2.appliesToToolNames === void 0) {
+    return true;
+  }
+  return policy2.appliesToToolNames.includes(toolName);
+}
+function evaluateSingleToolPolicy(policy2, context, timestamp) {
+  for (const effectName of toolPolicyEffectNames) {
+    const triggeredOutcome = executeToolPolicyRule(policy2, effectName, context);
+    if (triggeredOutcome !== null) {
+      return buildPolicyDecision({
+        policyName: policy2.name,
+        action: triggeredOutcome.action,
+        reason: triggeredOutcome.reason,
+        context,
+        timestamp
+      });
+    }
+  }
+  return buildPolicyDecision({
+    policyName: policy2.name,
+    action: "allow",
+    reason: "no rules matched",
+    context,
+    timestamp
+  });
+}
+function executeToolPolicyRule(policy2, effectName, context) {
+  const evaluateRule = policy2[effectName];
+  if (evaluateRule === void 0) {
+    return null;
+  }
+  try {
+    const ruleResult = evaluateRule(context);
+    if (ruleResult === false) {
+      return null;
+    }
+    if (ruleResult === true) {
+      return {
+        action: effectName,
+        reason: buildGeneratedEffectReason(effectName, policy2.name)
+      };
+    }
+    return {
+      action: effectName,
+      reason: ruleResult
+    };
+  } catch (caughtError) {
+    const errorMessage = caughtError instanceof Error ? caughtError.message : String(caughtError);
+    return {
+      action: "block",
+      reason: `blocked by policy ${policy2.name}: ${effectName} rule threw: ${errorMessage}`
+    };
+  }
+}
+function buildGeneratedEffectReason(effectName, policyName) {
+  const reasonsByEffectName = {
+    block: `blocked by policy ${policyName}`,
+    requireApproval: `approval required by policy ${policyName}`,
+    redact: `redacted by policy ${policyName}`,
+    logOnly: `logged by policy ${policyName}`
+  };
+  return reasonsByEffectName[effectName];
+}
+function buildPolicyDecision(input) {
+  return PolicyDecisionSchema.parse({
+    policyName: input.policyName,
+    action: input.action,
+    agentName: input.context.agentName,
+    toolName: input.context.toolName,
+    reason: input.reason,
+    timestamp: input.timestamp
+  });
+}
+function buildDefaultAllowEvaluation(context, timestamp) {
+  const defaultDecision = buildPolicyDecision({
+    policyName: defaultPolicyName,
+    action: "allow",
+    reason: `no policies matched tool ${context.toolName}`,
+    context,
+    timestamp
+  });
+  return {
+    action: defaultDecision.action,
+    reason: defaultDecision.reason,
+    policyName: defaultDecision.policyName,
+    decisions: [defaultDecision]
+  };
+}
+function resolveStrongestPolicyDecision(firstDecision, remainingDecisions) {
+  let strongestDecision = firstDecision;
+  for (const decision of remainingDecisions) {
+    const decisionRank = policyActionPrecedence.indexOf(decision.action);
+    const strongestRank = policyActionPrecedence.indexOf(
+      strongestDecision.action
+    );
+    if (decisionRank < strongestRank) {
+      strongestDecision = decision;
+    }
+  }
+  return strongestDecision;
+}
+
+// src/policies/policy-evaluated-event.ts
+import {
+  PolicyEvaluatedEventSchema
+} from "@assemble-dev/shared-types/trace-events";
+function buildPolicyEvaluatedEvent(input) {
+  return PolicyEvaluatedEventSchema.parse({
+    type: "policy.evaluated",
+    id: input.id,
+    runId: input.runId,
+    workflowName: input.workflowName,
+    timestamp: input.timestamp,
+    parentEventId: input.parentEventId,
+    redacted: input.redacted,
+    policyName: input.policyName,
+    action: input.action,
+    reason: input.reason,
+    toolName: input.toolName,
+    agentName: input.agentName
+  });
+}
+function buildPolicyEvaluatedEvents(input) {
+  return input.decisionEvents.map(
+    (decisionEvent) => buildPolicyEvaluatedEvent({
+      id: decisionEvent.id,
+      runId: input.runId,
+      workflowName: input.workflowName,
+      timestamp: input.timestamp,
+      parentEventId: input.parentEventId,
+      redacted: input.redacted,
+      policyName: decisionEvent.decision.policyName,
+      action: decisionEvent.decision.action,
+      reason: decisionEvent.decision.reason,
+      toolName: input.toolName,
+      agentName: input.agentName
+    })
+  );
+}
+
+// src/tools/tool-execution.ts
+function buildToolValidationFailureMessage(target, toolName, issues) {
+  const issueSummary = issues.map((issue) => issue.message).join("; ");
+  return `${target} validation failed for tool ${toolName}: ${issueSummary}`;
+}
+async function runToolExecutionAttempts(toolDefinition, input) {
+  let lastError = {
+    code: "EXECUTION_FAILED",
+    message: `tool ${toolDefinition.name} failed before executing`
+  };
+  for (let attempt = 1; attempt <= toolDefinition.retry.maxAttempts; attempt += 1) {
+    try {
+      return { output: await executeToolAttemptWithTimeout(toolDefinition, input) };
+    } catch (caughtError) {
+      lastError = {
+        code: "EXECUTION_FAILED",
+        message: caughtError instanceof Error ? caughtError.message : String(caughtError)
+      };
+    }
+  }
+  return { error: lastError };
+}
+function validateToolExecutionOutput(toolDefinition, output) {
+  if (toolDefinition.outputSchema === null) {
+    return { output };
+  }
+  const parsedOutput = toolDefinition.outputSchema.safeParse(output);
+  if (parsedOutput.success) {
+    return { output: parsedOutput.data };
+  }
+  return {
+    error: {
+      code: "VALIDATION_FAILED",
+      message: buildToolValidationFailureMessage(
+        "output",
+        toolDefinition.name,
+        parsedOutput.error.issues
+      )
+    }
+  };
+}
+async function executeToolAttemptWithTimeout(toolDefinition, input) {
+  const timeoutMs = toolDefinition.timeoutMs;
+  if (timeoutMs === null) {
+    return await toolDefinition.execute(input);
+  }
+  return await new Promise((resolveAttempt, rejectAttempt) => {
+    const timeoutHandle = setTimeout(() => {
+      rejectAttempt(
+        new Error(
+          `tool ${toolDefinition.name} timed out after ${timeoutMs}ms`
+        )
+      );
+    }, timeoutMs);
+    const settleWithOutput = (output) => {
+      clearTimeout(timeoutHandle);
+      resolveAttempt(output);
+    };
+    const settleWithError = (executionError) => {
+      clearTimeout(timeoutHandle);
+      rejectAttempt(executionError);
+    };
+    void toolDefinition.execute(input).then(settleWithOutput, settleWithError);
+  });
+}
+
+// src/tools/tool-trace-events.ts
+import { generateTraceEventId as generateTraceEventId2 } from "@assemble-dev/shared-utils";
+import {
+  redactTracePayload
+} from "@assemble-dev/shared-utils/redaction";
+function buildToolEventBase(context, parentEventId, redacted) {
+  return {
+    id: generateTraceEventId2(),
+    runId: context.runId,
+    workflowName: context.workflowName,
+    timestamp: context.now().toISOString(),
+    parentEventId,
+    redacted
+  };
+}
+function emitToolRequestedEvent(context, input, mode) {
+  const redaction = redactTracePayload(input, {
+    mode,
+    sensitiveFieldNames: context.sensitiveFieldNames
+  });
+  const emittedEvent = context.traceBus.emitTraceEvent({
+    ...buildToolEventBase(context, context.parentEventId, redaction.redacted),
+    type: "tool.requested",
+    toolName: context.toolName,
+    agentName: context.agentName,
+    input: redaction.payload
+  });
+  return emittedEvent.id;
+}
+function emitToolBlockedEvent(context, requestEventId, policyName, reason) {
+  context.traceBus.emitTraceEvent({
+    ...buildToolEventBase(context, requestEventId, false),
+    type: "tool.blocked",
+    toolName: context.toolName,
+    agentName: context.agentName,
+    policyName,
+    reason
+  });
+}
+function emitToolCompletedEvent(context, requestEventId, output, latencyMs) {
+  const redaction = redactTracePayload(output, {
+    mode: context.redactionMode,
+    sensitiveFieldNames: context.sensitiveFieldNames
+  });
+  context.traceBus.emitTraceEvent({
+    ...buildToolEventBase(context, requestEventId, redaction.redacted),
+    type: "tool.completed",
+    toolName: context.toolName,
+    agentName: context.agentName,
+    output: redaction.payload,
+    latencyMs
+  });
+}
+function emitToolFailedEvent(context, requestEventId, error, latencyMs) {
+  const redaction = redactTracePayload(error.message, {
+    mode: context.redactionMode,
+    sensitiveFieldNames: context.sensitiveFieldNames
+  });
+  const message = typeof redaction.payload === "string" ? redaction.payload : JSON.stringify(redaction.payload);
+  context.traceBus.emitTraceEvent({
+    ...buildToolEventBase(context, requestEventId, redaction.redacted),
+    type: "tool.failed",
+    toolName: context.toolName,
+    agentName: context.agentName,
+    error: { message, code: error.code },
+    latencyMs
+  });
+}
+function emitToolApprovedEvent(context, toolRequestEventId, approvalId) {
+  const emittedEvent = context.traceBus.emitTraceEvent({
+    ...buildToolEventBase(context, toolRequestEventId, false),
+    type: "tool.approved",
+    toolName: context.toolName,
+    agentName: context.agentName,
+    approvalId
+  });
+  return emittedEvent.id;
+}
+function emitApprovalRequiredEvent(context, toolRequestEventId, approvalId, reason) {
+  context.traceBus.emitTraceEvent({
+    ...buildToolEventBase(context, toolRequestEventId, false),
+    type: "approval.required",
+    approvalId,
+    toolName: context.toolName,
+    agentName: context.agentName,
+    reason
+  });
+}
+
+// src/tools/tool-execution-outcome.ts
+async function executeToolAndEmitOutcome(context, toolDefinition, input, requestEventId, mockExecution) {
+  const startedAtMs = context.now().getTime();
+  if (toolDefinition.dryRun || mockExecution !== void 0) {
+    return completeToolCallWithoutExecution(
+      context,
+      toolDefinition,
+      input,
+      requestEventId,
+      mockExecution,
+      startedAtMs
+    );
+  }
+  const executionResult = await runToolExecutionAttempts(toolDefinition, input);
+  if ("error" in executionResult) {
+    return failToolCallAfterRequest(
+      context,
+      requestEventId,
+      executionResult.error,
+      calculateElapsedMs(context, startedAtMs)
+    );
+  }
+  const validatedOutput = validateToolExecutionOutput(
+    toolDefinition,
+    executionResult.output
+  );
+  if ("error" in validatedOutput) {
+    return failToolCallAfterRequest(
+      context,
+      requestEventId,
+      validatedOutput.error,
+      calculateElapsedMs(context, startedAtMs)
+    );
+  }
+  const latencyMs = calculateElapsedMs(context, startedAtMs);
+  emitToolCompletedEvent(context, requestEventId, validatedOutput.output, latencyMs);
+  return {
+    status: "completed",
+    output: validatedOutput.output,
+    toolRequestEventId: requestEventId,
+    latencyMs
+  };
+}
+function completeToolCallWithoutExecution(context, toolDefinition, input, requestEventId, mockExecution, startedAtMs) {
+  const output = mockExecution !== void 0 ? mockExecution(input) : { dryRun: true, toolName: toolDefinition.name };
+  const latencyMs = calculateElapsedMs(context, startedAtMs);
+  emitToolCompletedEvent(context, requestEventId, output, latencyMs);
+  return {
+    status: "completed",
+    output,
+    toolRequestEventId: requestEventId,
+    latencyMs
+  };
+}
+function failToolCallAfterRequest(context, requestEventId, error, latencyMs) {
+  emitToolFailedEvent(context, requestEventId, error, latencyMs);
+  return { status: "failed", error };
+}
+function calculateElapsedMs(context, startedAtMs) {
+  return Math.max(0, context.now().getTime() - startedAtMs);
+}
+
+// src/tools/tool-broker.ts
+var agentAllowlistPolicyName = "agent-allowlist";
+var staticApprovalReason = "tool requires approval";
+async function executeToolCall(callInput) {
+  const context = buildToolBrokerContext(callInput);
+  const parsedInput = callInput.tool.inputSchema.safeParse(callInput.input);
+  if (!parsedInput.success) {
+    return failToolCallForInvalidInput(
+      context,
+      callInput.input,
+      parsedInput.error.issues
+    );
+  }
+  if (callInput.grantedApproval !== void 0) {
+    return await executeGrantedApprovalToolCall(
+      context,
+      callInput,
+      parsedInput.data,
+      callInput.grantedApproval
+    );
+  }
+  if (!isAgentAllowedToUseTool(callInput.tool, callInput.agentName)) {
+    return blockToolCallForDisallowedAgent(context, parsedInput.data);
+  }
+  const evaluation = evaluatePoliciesForToolCall(
+    context,
+    callInput.policies,
+    parsedInput.data
+  );
+  if (evaluation !== null && evaluation.action === "block") {
+    return blockToolCallByPolicy(context, parsedInput.data, evaluation);
+  }
+  const requestEventId = emitToolRequestedEvent(
+    context,
+    parsedInput.data,
+    resolveInputRedactionMode(context, evaluation)
+  );
+  const approvalReason = resolveApprovalReason(callInput.tool, evaluation);
+  if (approvalReason !== null) {
+    return requireApprovalForToolCall(context, requestEventId, approvalReason);
+  }
+  return await executeToolAndEmitOutcome(
+    context,
+    callInput.tool,
+    parsedInput.data,
+    requestEventId,
+    callInput.mockExecution
+  );
+}
+function buildToolBrokerContext(callInput) {
+  const runState = callInput.traceBus.getRunState();
+  return {
+    toolName: callInput.tool.name,
+    agentName: callInput.agentName,
+    runId: runState.runId,
+    workflowName: runState.workflowName,
+    parentEventId: callInput.parentEventId ?? null,
+    traceBus: callInput.traceBus,
+    now: callInput.now ?? (() => /* @__PURE__ */ new Date()),
+    redactionMode: resolveRedactionMode(callInput.redactionMode),
+    sensitiveFieldNames: callInput.tool.sensitiveFieldNames
+  };
+}
+function isAgentAllowedToUseTool(toolDefinition, agentName) {
+  if (toolDefinition.allowedAgentNames === null) {
+    return true;
+  }
+  return toolDefinition.allowedAgentNames.includes(agentName);
+}
+function resolveInputRedactionMode(context, evaluation) {
+  if (evaluation !== null && evaluation.action === "redact") {
+    return "redacted";
+  }
+  return context.redactionMode;
+}
+function resolveApprovalReason(toolDefinition, evaluation) {
+  if (evaluation !== null && evaluation.action === "requireApproval") {
+    return evaluation.reason;
+  }
+  if (toolDefinition.requiresApproval) {
+    return staticApprovalReason;
+  }
+  return null;
+}
+function evaluatePoliciesForToolCall(context, policies, input) {
+  if (policies === void 0) {
+    return null;
+  }
+  const timestamp = context.now().toISOString();
+  const evaluation = evaluateToolPolicies({
+    policies,
+    context: {
+      toolName: context.toolName,
+      agentName: context.agentName,
+      input
+    },
+    timestamp
+  });
+  const policyEvents = buildPolicyEvaluatedEvents({
+    runId: context.runId,
+    workflowName: context.workflowName,
+    timestamp,
+    parentEventId: context.parentEventId,
+    redacted: false,
+    toolName: context.toolName,
+    agentName: context.agentName,
+    decisionEvents: evaluation.decisions.map((decision) => ({
+      id: generateTraceEventId3(),
+      decision
+    }))
+  });
+  for (const policyEvent of policyEvents) {
+    context.traceBus.emitTraceEvent(policyEvent);
+  }
+  return evaluation;
+}
+function failToolCallForInvalidInput(context, rawInput, issues) {
+  const requestEventId = emitToolRequestedEvent(
+    context,
+    rawInput,
+    context.redactionMode
+  );
+  const error = {
+    code: "VALIDATION_FAILED",
+    message: buildToolValidationFailureMessage(
+      "input",
+      context.toolName,
+      issues
+    )
+  };
+  emitToolFailedEvent(context, requestEventId, error, 0);
+  return { status: "failed", error };
+}
+function blockToolCallForDisallowedAgent(context, input) {
+  const reason = `agent ${context.agentName} is not allowed to use tool ${context.toolName}`;
+  const requestEventId = emitToolRequestedEvent(
+    context,
+    input,
+    context.redactionMode
+  );
+  emitToolBlockedEvent(context, requestEventId, agentAllowlistPolicyName, reason);
+  return { status: "blocked", reason };
+}
+function blockToolCallByPolicy(context, input, evaluation) {
+  const requestEventId = emitToolRequestedEvent(
+    context,
+    input,
+    context.redactionMode
+  );
+  emitToolBlockedEvent(
+    context,
+    requestEventId,
+    evaluation.policyName,
+    evaluation.reason
+  );
+  return { status: "blocked", reason: evaluation.reason };
+}
+function requireApprovalForToolCall(context, toolRequestEventId, reason) {
+  const approvalId = generateApprovalId();
+  emitApprovalRequiredEvent(context, toolRequestEventId, approvalId, reason);
+  return { status: "awaiting_approval", approvalId, toolRequestEventId };
+}
+function ensureGrantedApprovalIsKnown(context, grantedApproval) {
+  const runApproval = context.traceBus.getRunState().approvals.find((approval) => approval.id === grantedApproval.approvalId);
+  if (runApproval === void 0 || runApproval.status === "rejected") {
+    throw new AppError4({
+      code: AppErrorCode4.Forbidden,
+      message: `granted approval "${grantedApproval.approvalId}" does not match a grantable approval for run "${context.runId}"; the tool call cannot use this grant`,
+      statusCode: 403,
+      details: {
+        approvalId: grantedApproval.approvalId,
+        toolName: context.toolName,
+        agentName: context.agentName,
+        runId: context.runId
+      }
+    });
+  }
+}
+async function executeGrantedApprovalToolCall(context, callInput, input, grantedApproval) {
+  ensureGrantedApprovalIsKnown(context, grantedApproval);
+  if (!isAgentAllowedToUseTool(callInput.tool, callInput.agentName)) {
+    return blockToolCallForDisallowedAgent(context, input);
+  }
+  const evaluation = evaluatePoliciesForToolCall(
+    context,
+    callInput.policies,
+    input
+  );
+  if (evaluation !== null && evaluation.action === "block") {
+    return blockToolCallByPolicy(context, input, evaluation);
+  }
+  const approvedEventId = emitToolApprovedEvent(
+    context,
+    grantedApproval.toolRequestEventId,
+    grantedApproval.approvalId
+  );
+  const requestEventId = grantedApproval.toolRequestEventId ?? approvedEventId;
+  return await executeToolAndEmitOutcome(
+    context,
+    callInput.tool,
+    input,
+    requestEventId,
+    callInput.mockExecution
+  );
+}
+
+// src/teams/team-definition.ts
+import { AppErrorCode as AppErrorCode5 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError5 } from "@assemble-dev/shared-utils/errors";
+function team(config) {
+  ensureTeamNameIsPresent(config.name);
+  ensureTeamHasAgents(config.name, config.agents);
+  ensureTeamAgentNamesAreUnique(config.name, config.agents);
+  return Object.freeze({
+    name: config.name,
+    description: config.description ?? "",
+    agents: Object.freeze([...config.agents]),
+    agentNames: Object.freeze(config.agents.map((member) => member.name))
+  });
+}
+function ensureTeamNameIsPresent(name) {
+  if (name.trim() !== "") {
+    return;
+  }
+  throw new AppError5({
+    code: AppErrorCode5.BadRequest,
+    message: "team name must not be empty",
+    statusCode: 400
+  });
+}
+function ensureTeamHasAgents(teamName, agents) {
+  if (agents.length > 0) {
+    return;
+  }
+  throw new AppError5({
+    code: AppErrorCode5.BadRequest,
+    message: `team "${teamName}" must include at least one agent`,
+    statusCode: 400
+  });
+}
+function ensureTeamAgentNamesAreUnique(teamName, agents) {
+  const seenAgentNames = /* @__PURE__ */ new Set();
+  for (const member of agents) {
+    if (seenAgentNames.has(member.name)) {
+      throw new AppError5({
+        code: AppErrorCode5.BadRequest,
+        message: `team "${teamName}" contains duplicate agent name "${member.name}"`,
+        statusCode: 400
+      });
+    }
+    seenAgentNames.add(member.name);
+  }
+}
+
+// src/teams/team-presets.ts
+function buildPipelineTeamWorkflowConfig(input) {
+  return {
+    name: input.name,
+    inputSchema: input.inputSchema,
+    outputSchema: input.outputSchema,
+    agents: [...input.team.agents],
+    topology: { kind: "pipeline" }
+  };
+}
+function buildSupervisorTeamWorkflowConfig(input) {
+  return {
+    name: input.name,
+    inputSchema: input.inputSchema,
+    outputSchema: input.outputSchema,
+    agents: [...input.team.agents],
+    topology: {
+      kind: "supervisor",
+      supervisorName: input.supervisorName,
+      route: input.route,
+      maxSteps: input.maxSteps
+    }
+  };
+}
+function buildReviewPanelWorkflowConfig(input) {
+  return {
+    name: input.name,
+    inputSchema: input.inputSchema,
+    agents: [...input.team.agents],
+    topology: { kind: "parallel" }
+  };
+}
+
+// src/policies/policy-definition.ts
+import { AppErrorCode as AppErrorCode6 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError6 } from "@assemble-dev/shared-utils/errors";
+function policy(config) {
+  ensurePolicyNameIsPresent(config.name);
+  ensurePolicyDefinesAtLeastOneRule(config);
+  return Object.freeze({ ...config });
+}
+function ensurePolicyNameIsPresent(name) {
+  if (name.trim() !== "") {
+    return;
+  }
+  throw new AppError6({
+    code: AppErrorCode6.BadRequest,
+    message: "policy name must not be empty",
+    statusCode: 400
+  });
+}
+function ensurePolicyDefinesAtLeastOneRule(config) {
+  const hasRule = toolPolicyEffectNames.some(
+    (effectName) => config[effectName] !== void 0
+  );
+  if (hasRule) {
+    return;
+  }
+  throw new AppError6({
+    code: AppErrorCode6.BadRequest,
+    message: `policy "${config.name}" must define at least one rule (${toolPolicyEffectNames.join(", ")})`,
+    statusCode: 400
+  });
+}
+
+// src/workflows/workflow-runtime.ts
+import { AppErrorCode as AppErrorCode12 } from "@assemble-dev/shared-types/errors";
+import { generateRunId } from "@assemble-dev/shared-utils/ids";
+import { AppError as AppError12 } from "@assemble-dev/shared-utils/errors";
+
+// src/memory/artifact-store.ts
+import { JsonObjectSchema } from "@assemble-dev/shared-types/json";
+import { RunArtifactSchema } from "@assemble-dev/shared-types/runs";
+function buildRunArtifactsMemoryKey(runId) {
+  return `run:${runId}:artifacts`;
+}
+function mapRunArtifactToJsonValue(artifact) {
+  const artifactValue = {
+    key: artifact.key,
+    value: artifact.value,
+    createdAt: artifact.createdAt
+  };
+  if (artifact.producedByAgentName !== void 0) {
+    artifactValue.producedByAgentName = artifact.producedByAgentName;
+  }
+  return artifactValue;
+}
+async function loadRunArtifactsRecord(provider, memoryKey) {
+  const storedArtifacts = await provider.getMemoryValue(memoryKey);
+  if (storedArtifacts === null) {
+    return {};
+  }
+  return JsonObjectSchema.parse(storedArtifacts);
+}
+function createArtifactStore(options) {
+  const memoryKey = buildRunArtifactsMemoryKey(options.runId);
+  return {
+    async saveRunArtifact(artifact) {
+      const artifactsRecord = await loadRunArtifactsRecord(
+        options.provider,
+        memoryKey
+      );
+      artifactsRecord[artifact.key] = mapRunArtifactToJsonValue(artifact);
+      await options.provider.setMemoryValue(memoryKey, artifactsRecord);
+    },
+    async getRunArtifact(key) {
+      const artifactsRecord = await loadRunArtifactsRecord(
+        options.provider,
+        memoryKey
+      );
+      const storedArtifact = artifactsRecord[key];
+      if (storedArtifact === void 0) {
+        return null;
+      }
+      return RunArtifactSchema.parse(storedArtifact);
+    },
+    async listRunArtifacts() {
+      const artifactsRecord = await loadRunArtifactsRecord(
+        options.provider,
+        memoryKey
+      );
+      return Object.values(artifactsRecord).map(
+        (storedArtifact) => RunArtifactSchema.parse(storedArtifact)
+      );
+    }
+  };
+}
+
+// src/memory/memory-provider.ts
+function buildAppendedMemoryValue(existingValue, appendedValue) {
+  if (existingValue === void 0) {
+    return [appendedValue];
+  }
+  if (Array.isArray(existingValue)) {
+    return [...existingValue, appendedValue];
+  }
+  return [existingValue, appendedValue];
+}
+
+// src/memory/in-memory-provider.ts
+function cloneJsonValue(value) {
+  return structuredClone(value);
+}
+function createInMemoryMemoryProvider() {
+  const memoryEntries = /* @__PURE__ */ new Map();
+  return {
+    async getMemoryValue(key) {
+      const storedValue = memoryEntries.get(key);
+      if (storedValue === void 0) {
+        return await Promise.resolve(null);
+      }
+      return await Promise.resolve(cloneJsonValue(storedValue));
+    },
+    async setMemoryValue(key, value) {
+      memoryEntries.set(key, cloneJsonValue(value));
+      await Promise.resolve();
+    },
+    async appendMemoryValue(key, value) {
+      memoryEntries.set(
+        key,
+        buildAppendedMemoryValue(memoryEntries.get(key), cloneJsonValue(value))
+      );
+      await Promise.resolve();
+    },
+    async listMemoryKeys() {
+      return await Promise.resolve([...memoryEntries.keys()]);
+    }
+  };
+}
+
+// src/memory/memory-config.ts
+function resolveWorkflowMemoryConfig(config) {
+  if (config !== void 0) {
+    return { provider: config.provider };
+  }
+  return { provider: createInMemoryMemoryProvider() };
+}
+
+// src/memory/thread-memory.ts
+import { RunMessageSchema } from "@assemble-dev/shared-types/runs";
+function buildThreadMessagesMemoryKey(threadKey) {
+  return `thread:${threadKey}:messages`;
+}
+function mapRunMessageToJsonValue(message) {
+  const messageValue = {
+    role: message.role,
+    content: message.content,
+    timestamp: message.timestamp
+  };
+  if (message.agentName !== void 0) {
+    messageValue.agentName = message.agentName;
+  }
+  if (message.toolName !== void 0) {
+    messageValue.toolName = message.toolName;
+  }
+  return messageValue;
+}
+function createThreadMemory(options) {
+  const memoryKey = buildThreadMessagesMemoryKey(options.threadKey);
+  return {
+    async appendThreadMessage(message) {
+      await options.provider.appendMemoryValue(
+        memoryKey,
+        mapRunMessageToJsonValue(message)
+      );
+    },
+    async listThreadMessages() {
+      const storedMessages = await options.provider.getMemoryValue(memoryKey);
+      if (storedMessages === null) {
+        return [];
+      }
+      return RunMessageSchema.array().parse(storedMessages);
+    }
+  };
+}
+
+// src/tracing/trace-bus.ts
+import {
+  TraceEventSchema
+} from "@assemble-dev/shared-types/trace-events";
+
+// src/tracing/run-state-error-mapper.ts
+function mapEventError(error, timestamp, agentName, toolName) {
+  return {
+    message: error.message,
+    code: error.code,
+    agentName,
+    toolName,
+    timestamp
+  };
+}
+
+// src/tracing/run-state-agent-tool-reducers.ts
+function applyAgentStarted(state, event) {
+  const agentCall = {
+    id: event.id,
+    agentName: event.agentName,
+    status: "running",
+    input: event.input,
+    output: null,
+    error: null,
+    startedAt: event.timestamp,
+    completedAt: null,
+    latencyMs: null
+  };
+  return { ...state, agentCalls: [...state.agentCalls, agentCall] };
+}
+function applyAgentCompleted(state, event) {
+  return updateAgentCall(state, event.parentEventId, event.agentName, {
+    status: "completed",
+    output: event.output,
+    completedAt: event.timestamp,
+    latencyMs: event.latencyMs
+  });
+}
+function applyAgentFailed(state, event) {
+  const failedState = updateAgentCall(
+    state,
+    event.parentEventId,
+    event.agentName,
+    {
+      status: "failed",
+      error: mapEventError(event.error, event.timestamp, event.agentName),
+      completedAt: event.timestamp,
+      latencyMs: event.latencyMs
+    }
+  );
+  return {
+    ...failedState,
+    errors: [
+      ...failedState.errors,
+      mapEventError(event.error, event.timestamp, event.agentName)
+    ]
+  };
+}
+function applyToolRequested(state, event) {
+  const toolCall = {
+    id: event.id,
+    toolName: event.toolName,
+    agentName: event.agentName,
+    status: "requested",
+    input: event.input,
+    output: null,
+    error: null,
+    requestedAt: event.timestamp,
+    completedAt: null,
+    latencyMs: null
+  };
+  return { ...state, toolCalls: [...state.toolCalls, toolCall] };
+}
+function applyToolBlocked(state, event) {
+  return applyToolStatus(state, event.parentEventId, event.toolName, {
+    status: "blocked",
+    completedAt: event.timestamp
+  });
+}
+function applyToolCompleted(state, event) {
+  return applyToolStatus(state, event.parentEventId, event.toolName, {
+    status: "completed",
+    output: event.output,
+    completedAt: event.timestamp,
+    latencyMs: event.latencyMs
+  });
+}
+function applyToolFailed(state, event) {
+  return applyToolStatus(state, event.parentEventId, event.toolName, {
+    status: "failed",
+    error: mapEventError(event.error, event.timestamp, void 0, event.toolName),
+    completedAt: event.timestamp,
+    latencyMs: event.latencyMs
+  });
+}
+function updateAgentCall(state, parentEventId, agentName, update) {
+  const targetIndex = findCallIndexByParentThenPredicate(
+    state.agentCalls,
+    parentEventId,
+    (call) => call.agentName === agentName && call.status === "running"
+  );
+  if (targetIndex === -1) {
+    return state;
+  }
+  const agentCalls = state.agentCalls.map(
+    (call, index) => index === targetIndex ? { ...call, ...update } : call
+  );
+  return { ...state, agentCalls };
+}
+function applyToolStatus(state, parentEventId, toolName, update) {
+  const targetIndex = findCallIndexByParentThenPredicate(
+    state.toolCalls,
+    parentEventId,
+    (call) => call.toolName === toolName && (call.status === "requested" || call.status === "approved")
+  );
+  if (targetIndex === -1) {
+    return state;
+  }
+  const toolCalls = state.toolCalls.map(
+    (call, index) => index === targetIndex ? { ...call, ...update } : call
+  );
+  return { ...state, toolCalls };
+}
+function findCallIndexByParentThenPredicate(calls, parentEventId, fallbackPredicate) {
+  if (parentEventId !== null) {
+    const parentIndex = findLastIndex(
+      calls,
+      (call) => call.id === parentEventId
+    );
+    if (parentIndex !== -1) {
+      return parentIndex;
+    }
+  }
+  return findLastIndex(calls, fallbackPredicate);
+}
+function findLastIndex(items, predicate) {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    const item = items[index];
+    if (item !== void 0 && predicate(item)) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+// src/tracing/run-state-approval-routing-reducers.ts
+function applyPolicyEvaluated(state, event) {
+  return {
+    ...state,
+    policyDecisions: [
+      ...state.policyDecisions,
+      {
+        policyName: event.policyName,
+        action: event.action,
+        agentName: event.agentName,
+        toolName: event.toolName,
+        reason: event.reason,
+        timestamp: event.timestamp
+      }
+    ]
+  };
+}
+function applyRouteSelected(state, event) {
+  return {
+    ...state,
+    routingDecisions: [
+      ...state.routingDecisions,
+      {
+        supervisorName: event.supervisorName,
+        selectedAgentName: event.selectedAgentName,
+        candidateAgentNames: event.candidateAgentNames,
+        reason: event.reason,
+        timestamp: event.timestamp
+      }
+    ]
+  };
+}
+function applyApprovalRequired(state, event) {
+  return {
+    ...state,
+    status: "awaiting_approval",
+    approvals: [
+      ...state.approvals,
+      {
+        id: event.approvalId,
+        status: "pending",
+        toolCallId: event.parentEventId,
+        toolName: event.toolName,
+        agentName: event.agentName,
+        reason: event.reason,
+        requestedAt: event.timestamp,
+        decidedAt: null,
+        decidedBy: null
+      }
+    ]
+  };
+}
+function applyApprovalDecision(state, event, status, reason) {
+  const approvals = state.approvals.map(
+    (approval) => approval.id === event.approvalId ? {
+      ...approval,
+      status,
+      reason: reason ?? approval.reason,
+      decidedAt: event.timestamp,
+      decidedBy: event.decidedBy
+    } : approval
+  );
+  const hasPendingApprovals = approvals.some(
+    (approval) => approval.status === "pending"
+  );
+  return {
+    ...state,
+    approvals,
+    status: hasPendingApprovals ? "awaiting_approval" : "running"
+  };
+}
+
+// src/tracing/run-state-reducer.ts
+function createInitialRunState(input) {
+  return {
+    runId: input.runId,
+    workflowName: input.workflowName,
+    status: "pending",
+    input: input.input,
+    messages: [],
+    agentCalls: [],
+    toolCalls: [],
+    policyDecisions: [],
+    routingDecisions: [],
+    approvals: [],
+    artifacts: [],
+    errors: [],
+    metrics: {
+      totalLatencyMs: null,
+      tokenUsage: null,
+      agentCallCount: 0,
+      toolCallCount: 0,
+      policyDecisionCount: 0,
+      approvalCount: 0
+    },
+    finalOutput: null,
+    createdAt: input.createdAt,
+    startedAt: null,
+    completedAt: null
+  };
+}
+function applyTraceEventToRunState(state, event) {
+  const nextState = reduceTraceEvent(state, event);
+  return {
+    ...nextState,
+    metrics: {
+      ...nextState.metrics,
+      agentCallCount: nextState.agentCalls.length,
+      toolCallCount: nextState.toolCalls.length,
+      policyDecisionCount: nextState.policyDecisions.length,
+      approvalCount: nextState.approvals.length
+    }
+  };
+}
+function reduceTraceEvent(state, event) {
+  switch (event.type) {
+    case "run.started":
+      return applyRunStarted(state, event);
+    case "run.completed":
+      return applyRunCompleted(state, event);
+    case "run.failed":
+      return applyRunFailed(state, event);
+    case "agent.started":
+      return applyAgentStarted(state, event);
+    case "agent.completed":
+      return applyAgentCompleted(state, event);
+    case "agent.failed":
+      return applyAgentFailed(state, event);
+    case "tool.requested":
+      return applyToolRequested(state, event);
+    case "tool.approved":
+      return applyToolStatus(state, event.parentEventId, event.toolName, {
+        status: "approved"
+      });
+    case "tool.blocked":
+      return applyToolBlocked(state, event);
+    case "tool.completed":
+      return applyToolCompleted(state, event);
+    case "tool.failed":
+      return applyToolFailed(state, event);
+    case "policy.evaluated":
+      return applyPolicyEvaluated(state, event);
+    case "route.selected":
+      return applyRouteSelected(state, event);
+    case "approval.required":
+      return applyApprovalRequired(state, event);
+    case "approval.approved":
+      return applyApprovalDecision(state, event, "approved", null);
+    case "approval.rejected":
+      return applyApprovalDecision(state, event, "rejected", event.reason);
+    case "eval.started":
+    case "eval.completed":
+    case "replay.started":
+    case "replay.completed":
+      return state;
+  }
+}
+function applyRunStarted(state, event) {
+  return {
+    ...state,
+    status: "running",
+    input: event.input,
+    startedAt: event.timestamp
+  };
+}
+function applyRunCompleted(state, event) {
+  return {
+    ...state,
+    status: "completed",
+    finalOutput: event.output,
+    completedAt: event.timestamp,
+    metrics: { ...state.metrics, totalLatencyMs: event.latencyMs }
+  };
+}
+function applyRunFailed(state, event) {
+  return {
+    ...state,
+    status: "failed",
+    completedAt: event.timestamp,
+    errors: [...state.errors, mapEventError(event.error, event.timestamp)],
+    metrics: { ...state.metrics, totalLatencyMs: event.latencyMs }
+  };
+}
+
+// src/tracing/trace-bus.ts
+function buildSinkFailure(sinkName, operation, thrownError) {
+  return { sinkName, operation, error: thrownError };
+}
+function reportSinkFailure(onSinkError, failure) {
+  if (onSinkError !== void 0) {
+    onSinkError(failure);
+  }
+}
+function writeTraceEventToSinkSafely(sink, event, onSinkError) {
+  try {
+    Promise.resolve(sink.writeTraceEvent(event)).catch(
+      (thrownError) => {
+        reportSinkFailure(
+          onSinkError,
+          buildSinkFailure(sink.name, "write", thrownError)
+        );
+      }
+    );
+  } catch (thrownError) {
+    reportSinkFailure(
+      onSinkError,
+      buildSinkFailure(
+        sink.name,
+        "write",
+        thrownError instanceof Error ? thrownError : new Error(String(thrownError))
+      )
+    );
+  }
+}
+async function flushSinkSafely(sink, onSinkError) {
+  if (sink.flush === void 0) {
+    return;
+  }
+  try {
+    await sink.flush();
+  } catch (thrownError) {
+    reportSinkFailure(
+      onSinkError,
+      buildSinkFailure(
+        sink.name,
+        "flush",
+        thrownError instanceof Error ? thrownError : new Error(String(thrownError))
+      )
+    );
+  }
+}
+function createTraceBus(busInput) {
+  const now = busInput.now ?? (() => /* @__PURE__ */ new Date());
+  const events = [];
+  let runState = busInput.initialRunState ?? createInitialRunState({
+    runId: busInput.runId,
+    workflowName: busInput.workflowName,
+    input: busInput.input,
+    createdAt: now().toISOString()
+  });
+  function emitTraceEvent(event) {
+    const validatedEvent = TraceEventSchema.parse(event);
+    events.push(validatedEvent);
+    runState = applyTraceEventToRunState(runState, validatedEvent);
+    for (const sink of busInput.sinks) {
+      writeTraceEventToSinkSafely(sink, validatedEvent, busInput.onSinkError);
+    }
+    return validatedEvent;
+  }
+  async function flushSinks() {
+    for (const sink of busInput.sinks) {
+      await flushSinkSafely(sink, busInput.onSinkError);
+    }
+  }
+  function closeSinks() {
+    for (const sink of busInput.sinks) {
+      if (sink.close !== void 0) {
+        sink.close();
+      }
+    }
+  }
+  return {
+    emitTraceEvent,
+    getRunState: () => runState,
+    listTraceEvents: () => [...events],
+    flushSinks,
+    closeSinks
+  };
+}
+
+// src/workflows/workflow-approval.ts
+import { AppErrorCode as AppErrorCode9 } from "@assemble-dev/shared-types/errors";
+import { JsonValueSchema as JsonValueSchema2 } from "@assemble-dev/shared-types/json";
+import { AppError as AppError9 } from "@assemble-dev/shared-utils/errors";
+import { z as z3 } from "zod";
+
+// src/workflows/run-state-store.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { RunStateSchema } from "@assemble-dev/shared-types/runs";
+var defaultRunStateDirectory = join(".assemble", "runs");
+function resolveRunStateFilePath(runId, directory = defaultRunStateDirectory) {
+  return join(directory, `${runId}.json`);
+}
+function saveRunStateFile(input) {
+  const directory = input.directory ?? defaultRunStateDirectory;
+  const filePath = resolveRunStateFilePath(input.runState.runId, directory);
+  const validatedRunState = RunStateSchema.parse(input.runState);
+  mkdirSync(directory, { recursive: true });
+  writeFileSync(filePath, JSON.stringify(validatedRunState, null, 2), "utf8");
+  return filePath;
+}
+function loadRunStateFile(input) {
+  const filePath = resolveRunStateFilePath(input.runId, input.directory);
+  const rawContents = readFileSync(filePath, "utf8");
+  return RunStateSchema.parse(JSON.parse(rawContents));
+}
+
+// src/workflows/workflow-runtime-context.ts
+async function persistWorkflowRunState(context) {
+  if (!context.persistRunState) {
+    return;
+  }
+  saveRunStateFile({
+    runState: await buildWorkflowRunState(context),
+    directory: context.runStateDirectory
+  });
+}
+async function buildWorkflowRunState(context) {
+  return {
+    ...context.traceBus.getRunState(),
+    artifacts: await context.artifactStore.listRunArtifacts()
+  };
+}
+function buildWorkflowEventContext(context) {
+  return {
+    traceBus: context.traceBus,
+    runId: context.runId,
+    workflowName: context.definition.name,
+    now: context.now
+  };
+}
+function calculateWorkflowElapsedMs(context) {
+  return Math.max(0, context.now().getTime() - context.startedAtMs);
+}
+
+// src/workflows/workflow-step-execution.ts
+import { AppErrorCode as AppErrorCode7 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError7 } from "@assemble-dev/shared-utils/errors";
+
+// src/workflows/workflow-trace-events.ts
+import { generateTraceEventId as generateTraceEventId4 } from "@assemble-dev/shared-utils/ids";
+function buildWorkflowEventBase(eventContext, parentEventId) {
+  return {
+    id: generateTraceEventId4(),
+    runId: eventContext.runId,
+    workflowName: eventContext.workflowName,
+    timestamp: eventContext.now().toISOString(),
+    parentEventId,
+    redacted: false
+  };
+}
+function emitRunStartedEvent(eventContext, input) {
+  return eventContext.traceBus.emitTraceEvent({
+    ...buildWorkflowEventBase(eventContext, null),
+    type: "run.started",
+    input
+  });
+}
+function emitRunCompletedEvent(eventContext, runStartedEventId, output, latencyMs) {
+  eventContext.traceBus.emitTraceEvent({
+    ...buildWorkflowEventBase(eventContext, runStartedEventId),
+    type: "run.completed",
+    output,
+    latencyMs
+  });
+}
+function emitRouteSelectedEvent(eventContext, runStartedEventId, routeSelection) {
+  eventContext.traceBus.emitTraceEvent({
+    ...buildWorkflowEventBase(eventContext, runStartedEventId),
+    type: "route.selected",
+    supervisorName: routeSelection.supervisorName,
+    selectedAgentName: routeSelection.selectedAgentName,
+    candidateAgentNames: routeSelection.candidateAgentNames,
+    reason: routeSelection.reason
+  });
+}
+function emitApprovalApprovedEvent(eventContext, decision) {
+  eventContext.traceBus.emitTraceEvent({
+    ...buildWorkflowEventBase(eventContext, decision.parentEventId),
+    type: "approval.approved",
+    approvalId: decision.approvalId,
+    decidedBy: decision.decidedBy
+  });
+}
+function emitApprovalRejectedEvent(eventContext, decision, reason) {
+  eventContext.traceBus.emitTraceEvent({
+    ...buildWorkflowEventBase(eventContext, decision.parentEventId),
+    type: "approval.rejected",
+    approvalId: decision.approvalId,
+    decidedBy: decision.decidedBy,
+    reason
+  });
+}
+function emitRunFailedEvent(eventContext, runStartedEventId, error, latencyMs) {
+  eventContext.traceBus.emitTraceEvent({
+    ...buildWorkflowEventBase(eventContext, runStartedEventId),
+    type: "run.failed",
+    error,
+    latencyMs
+  });
+}
+
+// src/workflows/workflow-step-execution.ts
+async function executeWorkflowStep(context, stepIndex, stepAgent, stepInput) {
+  try {
+    const agentResult = await runAgent({
+      definition: stepAgent,
+      input: stepInput,
+      traceBus: context.traceBus,
+      parentEventId: context.runStartedEventId,
+      threadMemory: context.threadMemory,
+      now: context.now
+    });
+    await saveWorkflowStepArtifact(
+      context,
+      stepIndex,
+      stepAgent.name,
+      agentResult.output
+    );
+    return agentResult.output;
+  } catch (thrownError) {
+    const stepError = mapCaughtWorkflowErrorToAppError(
+      thrownError instanceof Error ? thrownError : new Error(String(thrownError))
+    );
+    return await resolveWorkflowStepFailure(
+      context,
+      stepIndex,
+      stepAgent.name,
+      stepError,
+      stepInput
+    );
+  }
+}
+async function resolveWorkflowStepFailure(context, stepIndex, agentName, stepError, previousStepOutput) {
+  if (context.definition.continueOnAgentFailure) {
+    return previousStepOutput;
+  }
+  const failureError = new AppError7({
+    code: stepError.code,
+    message: `step ${stepIndex} (${agentName}) failed: ${stepError.message}`,
+    statusCode: stepError.statusCode,
+    details: { stepIndex, agentName, reason: stepError.message },
+    cause: stepError
+  });
+  await failWorkflowRun(context, failureError);
+  throw failureError;
+}
+function shouldStopWorkflowRun(context, stepIndex) {
+  if (context.definition.stopCondition === null) {
+    return false;
+  }
+  return context.definition.stopCondition({
+    state: context.traceBus.getRunState(),
+    stepIndex
+  });
+}
+async function saveWorkflowStepArtifact(context, stepIndex, agentName, stepOutput) {
+  await context.artifactStore.saveRunArtifact({
+    key: `step-${stepIndex}:${agentName}`,
+    value: stepOutput,
+    producedByAgentName: agentName,
+    createdAt: context.now().toISOString()
+  });
+}
+async function failWorkflowRun(context, failureError) {
+  emitRunFailedEvent(
+    buildWorkflowEventContext(context),
+    context.runStartedEventId,
+    { message: failureError.message, code: failureError.code },
+    calculateWorkflowElapsedMs(context)
+  );
+  await persistWorkflowRunState(context);
+  await context.traceBus.flushSinks();
+}
+function mapCaughtWorkflowErrorToAppError(thrownError) {
+  if (thrownError instanceof AppError7) {
+    return thrownError;
+  }
+  return new AppError7({
+    code: AppErrorCode7.InternalServerError,
+    message: thrownError.message,
+    statusCode: 500,
+    cause: thrownError
+  });
+}
+
+// src/workflows/workflow-tool-execution.ts
+import { AppErrorCode as AppErrorCode8 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError8 } from "@assemble-dev/shared-utils/errors";
+async function executeWorkflowTool(toolInput) {
+  const runtimeContext = toolInput.runtimeContext;
+  const workflowTool = findWorkflowToolByName(
+    runtimeContext.definition,
+    toolInput.toolName
+  );
+  const workflowPolicies = runtimeContext.definition.policies;
+  const outcome = await executeToolCall({
+    tool: workflowTool,
+    agentName: toolInput.agentName,
+    input: toolInput.input,
+    policies: workflowPolicies.length > 0 ? [...workflowPolicies] : void 0,
+    traceBus: runtimeContext.traceBus,
+    parentEventId: runtimeContext.parentEventId ?? void 0,
+    now: runtimeContext.now,
+    grantedApproval: toolInput.grantedApproval
+  });
+  if (toolInput.throwOnUnsuccessfulOutcome === false) {
+    return outcome;
+  }
+  return ensureWorkflowToolOutcomeSucceeded(toolInput, outcome);
+}
+function findWorkflowToolByName(definition, toolName) {
+  const workflowTool = definition.tools.find(
+    (candidateTool) => candidateTool.name === toolName
+  );
+  if (workflowTool !== void 0) {
+    return workflowTool;
+  }
+  const registeredToolNames = definition.tools.map((registeredTool) => registeredTool.name).join(", ");
+  throw new AppError8({
+    code: AppErrorCode8.NotFound,
+    message: `tool "${toolName}" is not registered on workflow "${definition.name}"; registered tools: [${registeredToolNames}]. Add the tool to the workflow definition before calling it`,
+    statusCode: 404,
+    details: { toolName, workflowName: definition.name }
+  });
+}
+function ensureWorkflowToolOutcomeSucceeded(toolInput, outcome) {
+  const stepIndex = toolInput.runtimeContext.stepIndex;
+  if (outcome.status === "blocked") {
+    throw new AppError8({
+      code: AppErrorCode8.Forbidden,
+      message: `tool "${toolInput.toolName}" was blocked at step ${stepIndex} for agent "${toolInput.agentName}": ${outcome.reason}`,
+      statusCode: 403,
+      details: { toolName: toolInput.toolName, stepIndex, reason: outcome.reason }
+    });
+  }
+  if (outcome.status === "failed") {
+    throw new AppError8({
+      code: mapToolCallErrorCodeToAppErrorCode(outcome.error.code),
+      message: `tool "${toolInput.toolName}" failed at step ${stepIndex} for agent "${toolInput.agentName}": ${outcome.error.message}`,
+      statusCode: outcome.error.code === "VALIDATION_FAILED" ? 422 : 500,
+      details: {
+        toolName: toolInput.toolName,
+        stepIndex,
+        reason: outcome.error.message
+      }
+    });
+  }
+  return outcome;
+}
+function mapToolCallErrorCodeToAppErrorCode(toolCallErrorCode) {
+  return toolCallErrorCode === "VALIDATION_FAILED" ? AppErrorCode8.ValidationFailed : AppErrorCode8.InternalServerError;
+}
+
+// src/workflows/workflow-approval.ts
+var pendingApprovalArtifactKey = "workflow:pending-approval";
+var PendingWorkflowApprovalSchema = z3.object({
+  stepIndex: z3.number().int().nonnegative(),
+  agentName: z3.string().min(1),
+  toolName: z3.string().min(1),
+  toolInput: JsonValueSchema2,
+  approvalId: z3.string().min(1),
+  toolRequestEventId: z3.string().nullable(),
+  agentOutput: JsonValueSchema2,
+  runStartedEventId: z3.string().min(1)
+});
+function buildBoundToolArtifactKey(stepIndex, agentName, toolName) {
+  return `step-${stepIndex}:${agentName}:tool:${toolName}`;
+}
+function buildWorkflowStepContext(context, stepIndex) {
+  return {
+    definition: context.definition,
+    traceBus: context.traceBus,
+    stepIndex,
+    parentEventId: context.runStartedEventId,
+    artifactStore: context.artifactStore,
+    threadMemory: context.threadMemory,
+    now: context.now
+  };
+}
+async function applyAgentToolBindingAfterStep(context, stepIndex, agentName, agentOutput) {
+  const binding = findAgentToolBinding(context, agentName);
+  if (binding === null) {
+    return { status: "continue" };
+  }
+  const toolInput = binding.buildToolInput({
+    state: await buildWorkflowRunState(context),
+    stepIndex,
+    agentOutput
+  });
+  const outcome = await executeBoundToolOrFailRun(
+    context,
+    stepIndex,
+    binding,
+    toolInput
+  );
+  if (outcome.status === "awaiting_approval") {
+    return await pauseWorkflowRunForApproval(context, {
+      stepIndex,
+      agentName,
+      toolName: binding.toolName,
+      toolInput,
+      approvalId: outcome.approvalId,
+      toolRequestEventId: outcome.toolRequestEventId,
+      agentOutput,
+      runStartedEventId: context.runStartedEventId
+    });
+  }
+  if (outcome.status === "completed") {
+    await saveBoundToolArtifact(
+      context,
+      stepIndex,
+      agentName,
+      binding.toolName,
+      outcome.output
+    );
+  }
+  return { status: "continue" };
+}
+async function executeApprovedWorkflowTool(context, pendingApproval) {
+  const outcome = await executeBoundToolOrFailRun(
+    context,
+    pendingApproval.stepIndex,
+    {
+      agentName: pendingApproval.agentName,
+      toolName: pendingApproval.toolName,
+      buildToolInput: () => pendingApproval.toolInput
+    },
+    pendingApproval.toolInput,
+    {
+      approvalId: pendingApproval.approvalId,
+      toolRequestEventId: pendingApproval.toolRequestEventId
+    }
+  );
+  if (outcome.status === "completed") {
+    await saveBoundToolArtifact(
+      context,
+      pendingApproval.stepIndex,
+      pendingApproval.agentName,
+      pendingApproval.toolName,
+      outcome.output
+    );
+  }
+}
+async function executeBoundToolOrFailRun(context, stepIndex, binding, toolInput, grantedApproval) {
+  try {
+    const outcome = await executeWorkflowTool({
+      runtimeContext: buildWorkflowStepContext(context, stepIndex),
+      toolName: binding.toolName,
+      agentName: binding.agentName,
+      input: toolInput,
+      grantedApproval
+    });
+    if (outcome.status === "completed") {
+      return { status: "completed", output: outcome.output };
+    }
+    if (outcome.status === "awaiting_approval") {
+      return outcome;
+    }
+    throw new AppError9({
+      code: AppErrorCode9.InternalServerError,
+      message: `tool "${binding.toolName}" returned unexpected outcome "${outcome.status}" at step ${stepIndex} for agent "${binding.agentName}"`,
+      statusCode: 500,
+      details: { toolName: binding.toolName, stepIndex }
+    });
+  } catch (thrownError) {
+    const bindingError = thrownError instanceof AppError9 ? thrownError : new AppError9({
+      code: AppErrorCode9.InternalServerError,
+      message: `tool "${binding.toolName}" threw at step ${stepIndex} for agent "${binding.agentName}": ${String(thrownError)}`,
+      statusCode: 500,
+      details: { toolName: binding.toolName, stepIndex }
+    });
+    await failWorkflowRun(context, bindingError);
+    throw bindingError;
+  }
+}
+async function pauseWorkflowRunForApproval(context, pendingApproval) {
+  await context.artifactStore.saveRunArtifact({
+    key: pendingApprovalArtifactKey,
+    value: PendingWorkflowApprovalSchema.parse(pendingApproval),
+    producedByAgentName: pendingApproval.agentName,
+    createdAt: context.now().toISOString()
+  });
+  await persistWorkflowRunState(context);
+  await context.traceBus.flushSinks();
+  return { status: "paused", approvalId: pendingApproval.approvalId };
+}
+async function saveBoundToolArtifact(context, stepIndex, agentName, toolName, toolOutput) {
+  await context.artifactStore.saveRunArtifact({
+    key: buildBoundToolArtifactKey(stepIndex, agentName, toolName),
+    value: toolOutput,
+    producedByAgentName: agentName,
+    createdAt: context.now().toISOString()
+  });
+}
+function findAgentToolBinding(context, agentName) {
+  const binding = context.definition.agentToolBindings.find(
+    (candidateBinding) => candidateBinding.agentName === agentName
+  );
+  return binding ?? null;
+}
+
+// src/workflows/workflow-parallel-execution.ts
+import { AppErrorCode as AppErrorCode10 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError10 } from "@assemble-dev/shared-utils/errors";
+
+// src/workflows/workflow-topology.ts
+import { z as z4 } from "zod";
+var finishWorkflow = "__finish__";
+var defaultSupervisorMaxSteps = 10;
+var defaultParallelMergedArtifactKey = "parallel:merged";
+var PipelineTopologySchema = z4.object({
+  kind: z4.literal("pipeline")
+});
+var SupervisorTopologySchema = z4.object({
+  kind: z4.literal("supervisor"),
+  supervisorName: z4.string().min(1),
+  route: z4.custom(
+    (value) => typeof value === "function"
+  ),
+  maxSteps: z4.number().int().min(1).optional(),
+  stopWhen: z4.custom((value) => typeof value === "function").optional()
+});
+var ParallelTopologySchema = z4.object({
+  kind: z4.literal("parallel"),
+  agentNames: z4.array(z4.string().min(1)).min(1).optional(),
+  mergedArtifactKey: z4.string().min(1).optional()
+});
+var WorkflowTopologySchema = z4.discriminatedUnion("kind", [
+  PipelineTopologySchema,
+  SupervisorTopologySchema,
+  ParallelTopologySchema
+]);
+var defaultWorkflowTopology = Object.freeze({
+  kind: "pipeline"
+});
+
+// src/workflows/workflow-parallel-execution.ts
+function buildParallelThreadKey(runId, agentName) {
+  return `${runId}:${agentName}`;
+}
+async function executeParallelSteps(context, topology, start) {
+  const fanOutAgents = await resolveParallelFanOutAgents(context, topology);
+  const branchContext = {
+    ...context,
+    artifactStore: buildSerializedArtifactStore(context.artifactStore)
+  };
+  const branchPromises = fanOutAgents.map(
+    async (fanOutAgent, fanOutIndex) => await executeParallelBranch(
+      branchContext,
+      fanOutIndex,
+      fanOutAgent,
+      start.input
+    )
+  );
+  const branchResults = await collectSettledParallelBranchResults(
+    branchPromises
+  );
+  await ensureAllParallelBranchesSucceeded(context, branchResults);
+  const mergedOutput = mergeParallelBranchOutputs(branchResults);
+  await saveMergedParallelArtifact(context, topology, mergedOutput);
+  await persistWorkflowRunState(context);
+  return { status: "completed", output: mergedOutput };
+}
+function buildSerializedArtifactStore(artifactStore) {
+  let pendingWrite = Promise.resolve();
+  return {
+    async saveRunArtifact(artifact) {
+      pendingWrite = pendingWrite.then(
+        async () => await artifactStore.saveRunArtifact(artifact)
+      );
+      return await pendingWrite;
+    },
+    async getRunArtifact(key) {
+      return await artifactStore.getRunArtifact(key);
+    },
+    async listRunArtifacts() {
+      return await artifactStore.listRunArtifacts();
+    }
+  };
+}
+async function collectSettledParallelBranchResults(branchPromises) {
+  const branchResults = [];
+  for (const branchPromise of branchPromises) {
+    branchResults.push(await branchPromise);
+  }
+  return branchResults;
+}
+async function resolveParallelFanOutAgents(context, topology) {
+  if (topology.agentNames === void 0) {
+    return [...context.definition.agents];
+  }
+  const fanOutAgents = [];
+  for (const agentName of topology.agentNames) {
+    const fanOutAgent = context.definition.agents.find(
+      (agentDefinition) => agentDefinition.name === agentName
+    );
+    if (fanOutAgent === void 0) {
+      return await failParallelRunForUnknownAgent(context, agentName);
+    }
+    fanOutAgents.push(fanOutAgent);
+  }
+  return fanOutAgents;
+}
+async function failParallelRunForUnknownAgent(context, agentName) {
+  const validAgentNames = context.definition.agents.map((agentDefinition) => agentDefinition.name).join(", ");
+  const unknownAgentError = new AppError10({
+    code: AppErrorCode10.BadRequest,
+    message: `workflow "${context.definition.name}" parallel topology selected unknown agent "${agentName}"; valid agent names: ${validAgentNames}`,
+    statusCode: 400,
+    details: {
+      workflowName: context.definition.name,
+      agentName,
+      validAgentNames
+    }
+  });
+  await failWorkflowRun(context, unknownAgentError);
+  throw unknownAgentError;
+}
+async function executeParallelBranch(context, fanOutIndex, fanOutAgent, workflowInput) {
+  try {
+    const agentResult = await runAgent({
+      definition: fanOutAgent,
+      input: workflowInput,
+      traceBus: context.traceBus,
+      parentEventId: context.runStartedEventId,
+      threadMemory: createThreadMemory({
+        provider: context.memoryProvider,
+        threadKey: buildParallelThreadKey(context.runId, fanOutAgent.name)
+      }),
+      now: context.now
+    });
+    await saveParallelBranchArtifact(
+      context,
+      fanOutIndex,
+      fanOutAgent.name,
+      agentResult.output
+    );
+    await applyParallelAgentToolBinding(
+      context,
+      fanOutIndex,
+      fanOutAgent.name,
+      agentResult.output
+    );
+    return {
+      status: "completed",
+      agentName: fanOutAgent.name,
+      output: agentResult.output
+    };
+  } catch (thrownError) {
+    const branchError = thrownError instanceof Error ? thrownError : new Error(String(thrownError));
+    return {
+      status: "failed",
+      agentName: fanOutAgent.name,
+      error: mapParallelBranchErrorToAppError(branchError)
+    };
+  }
+}
+async function applyParallelAgentToolBinding(context, fanOutIndex, agentName, agentOutput) {
+  const bindingOutcome = await applyAgentToolBindingAfterStep(
+    context,
+    fanOutIndex,
+    agentName,
+    agentOutput
+  );
+  if (bindingOutcome.status !== "paused") {
+    return;
+  }
+  throw new AppError10({
+    code: AppErrorCode10.Conflict,
+    message: `workflow "${context.definition.name}" agent "${agentName}" has a tool binding that requires approval, which is not supported inside parallel fan-out; run this agent in a pipeline or supervisor topology, or remove the approval requirement from the bound tool`,
+    statusCode: 409,
+    details: {
+      workflowName: context.definition.name,
+      agentName,
+      fanOutIndex,
+      approvalId: bindingOutcome.approvalId
+    }
+  });
+}
+async function ensureAllParallelBranchesSucceeded(context, branchResults) {
+  const failures = branchResults.filter(
+    (branchResult) => branchResult.status === "failed"
+  );
+  const firstFailure = failures[0];
+  if (firstFailure === void 0) {
+    return;
+  }
+  const failedAgentNames = failures.map((failure) => failure.agentName).join(", ");
+  const failureReasons = failures.map((failure) => `${failure.agentName}: ${failure.error.message}`).join("; ");
+  const parallelError = new AppError10({
+    code: firstFailure.error.code,
+    message: `workflow "${context.definition.name}" parallel fan-out failed for agent(s) [${failedAgentNames}]: ${failureReasons}`,
+    statusCode: firstFailure.error.statusCode,
+    details: {
+      workflowName: context.definition.name,
+      failedAgentNames,
+      failedAgentCount: failures.length
+    },
+    cause: firstFailure.error
+  });
+  await failWorkflowRun(context, parallelError);
+  throw parallelError;
+}
+function mergeParallelBranchOutputs(branchResults) {
+  const mergedOutput = {};
+  for (const branchResult of branchResults) {
+    if (branchResult.status === "completed") {
+      mergedOutput[branchResult.agentName] = branchResult.output;
+    }
+  }
+  return mergedOutput;
+}
+async function saveParallelBranchArtifact(context, fanOutIndex, agentName, branchOutput) {
+  await context.artifactStore.saveRunArtifact({
+    key: `step-${fanOutIndex}:${agentName}`,
+    value: branchOutput,
+    producedByAgentName: agentName,
+    createdAt: context.now().toISOString()
+  });
+}
+async function saveMergedParallelArtifact(context, topology, mergedOutput) {
+  await context.artifactStore.saveRunArtifact({
+    key: topology.mergedArtifactKey ?? defaultParallelMergedArtifactKey,
+    value: mergedOutput,
+    createdAt: context.now().toISOString()
+  });
+}
+function mapParallelBranchErrorToAppError(branchError) {
+  if (branchError instanceof AppError10) {
+    return branchError;
+  }
+  return new AppError10({
+    code: AppErrorCode10.InternalServerError,
+    message: branchError.message,
+    statusCode: 500,
+    cause: branchError
+  });
+}
+
+// src/workflows/workflow-supervisor-execution.ts
+import { AppErrorCode as AppErrorCode11 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError11 } from "@assemble-dev/shared-utils/errors";
+async function executeSupervisorSteps(context, topology, start) {
+  let loopState = {
+    stepIndex: start.startStepIndex,
+    lastAgentName: start.lastAgentName,
+    lastOutput: start.lastAgentName === null ? null : start.input,
+    currentOutput: start.input
+  };
+  for (; ; ) {
+    const routeContext = buildWorkflowRouteContext(context, loopState);
+    if (topology.stopWhen !== void 0 && topology.stopWhen(routeContext)) {
+      return { status: "completed", output: loopState.currentOutput };
+    }
+    const routeDecision = await resolveSupervisorRouteDecision(
+      context,
+      topology,
+      routeContext
+    );
+    if (routeDecision.agentName === finishWorkflow) {
+      return { status: "completed", output: loopState.currentOutput };
+    }
+    const stepOutput = await executeSupervisorStep(
+      context,
+      topology,
+      loopState,
+      routeDecision
+    );
+    const bindingOutcome = await applyAgentToolBindingAfterStep(
+      context,
+      loopState.stepIndex,
+      routeDecision.agentName,
+      stepOutput
+    );
+    if (bindingOutcome.status === "paused") {
+      return bindingOutcome;
+    }
+    if (shouldStopWorkflowRun(context, loopState.stepIndex)) {
+      return { status: "completed", output: stepOutput };
+    }
+    loopState = {
+      stepIndex: loopState.stepIndex + 1,
+      lastAgentName: routeDecision.agentName,
+      lastOutput: stepOutput,
+      currentOutput: stepOutput
+    };
+  }
+}
+async function executeSupervisorStep(context, topology, loopState, routeDecision) {
+  const selectedAgent = await resolveRoutedWorkflowAgent(
+    context,
+    topology,
+    routeDecision,
+    loopState.stepIndex
+  );
+  await ensureSupervisorStepBudget(context, topology, loopState.stepIndex);
+  emitRouteSelectedEvent(
+    buildWorkflowEventContext(context),
+    context.runStartedEventId,
+    {
+      supervisorName: topology.supervisorName,
+      selectedAgentName: selectedAgent.name,
+      candidateAgentNames: listWorkflowAgentNames(context),
+      reason: routeDecision.reason
+    }
+  );
+  const stepOutput = await executeWorkflowStep(
+    context,
+    loopState.stepIndex,
+    selectedAgent,
+    loopState.currentOutput
+  );
+  await persistWorkflowRunState(context);
+  return stepOutput;
+}
+async function resolveSupervisorRouteDecision(context, topology, routeContext) {
+  try {
+    const routeTarget = await topology.route(routeContext);
+    return normalizeWorkflowRouteTarget(routeTarget);
+  } catch (thrownError) {
+    const causeError = thrownError instanceof Error ? thrownError : new Error(String(thrownError));
+    return await failSupervisorRun(
+      context,
+      new AppError11({
+        code: AppErrorCode11.InternalServerError,
+        message: `workflow "${context.definition.name}" supervisor "${topology.supervisorName}" route function threw at step ${routeContext.stepIndex}: ${causeError.message}; fix the route function to return an agent name or finishWorkflow`,
+        statusCode: 500,
+        details: {
+          workflowName: context.definition.name,
+          supervisorName: topology.supervisorName,
+          stepIndex: routeContext.stepIndex,
+          reason: causeError.message
+        },
+        cause: causeError
+      })
+    );
+  }
+}
+async function resolveRoutedWorkflowAgent(context, topology, routeDecision, stepIndex) {
+  const selectedAgent = context.definition.agents.find(
+    (agentDefinition) => agentDefinition.name === routeDecision.agentName
+  );
+  if (selectedAgent !== void 0) {
+    return selectedAgent;
+  }
+  const validAgentNames = listWorkflowAgentNames(context).join(", ");
+  return await failSupervisorRun(
+    context,
+    new AppError11({
+      code: AppErrorCode11.BadRequest,
+      message: `workflow "${context.definition.name}" supervisor "${topology.supervisorName}" routed to unknown agent "${routeDecision.agentName}" at step ${stepIndex}; valid agent names: ${validAgentNames}`,
+      statusCode: 400,
+      details: {
+        workflowName: context.definition.name,
+        supervisorName: topology.supervisorName,
+        selectedAgentName: routeDecision.agentName,
+        validAgentNames,
+        stepIndex
+      }
+    })
+  );
+}
+async function ensureSupervisorStepBudget(context, topology, stepIndex) {
+  const maxSteps = topology.maxSteps ?? defaultSupervisorMaxSteps;
+  if (stepIndex < maxSteps) {
+    return;
+  }
+  await failSupervisorRun(
+    context,
+    new AppError11({
+      code: AppErrorCode11.Conflict,
+      message: `workflow "${context.definition.name}" supervisor "${topology.supervisorName}" exceeded ${maxSteps} steps; return finishWorkflow from the route function, add a stopWhen condition, or increase maxSteps`,
+      statusCode: 409,
+      details: {
+        workflowName: context.definition.name,
+        supervisorName: topology.supervisorName,
+        maxSteps
+      }
+    })
+  );
+}
+async function failSupervisorRun(context, supervisorError) {
+  await failWorkflowRun(context, supervisorError);
+  throw supervisorError;
+}
+function normalizeWorkflowRouteTarget(routeTarget) {
+  if (typeof routeTarget === "string") {
+    return {
+      agentName: routeTarget,
+      reason: `route function selected ${routeTarget}`
+    };
+  }
+  return routeTarget;
+}
+function listWorkflowAgentNames(context) {
+  return context.definition.agents.map(
+    (agentDefinition) => agentDefinition.name
+  );
+}
+function buildWorkflowRouteContext(context, loopState) {
+  return {
+    state: context.traceBus.getRunState(),
+    stepIndex: loopState.stepIndex,
+    lastAgentName: loopState.lastAgentName,
+    lastOutput: loopState.lastOutput
+  };
+}
+
+// src/workflows/workflow-runtime.ts
+async function runWorkflow(runInput) {
+  const validatedInput = validateWorkflowInput(
+    runInput.definition,
+    runInput.input
+  );
+  const context = createWorkflowRuntimeContext(
+    runInput.definition,
+    validatedInput,
+    runInput.options
+  );
+  await persistWorkflowRunState(context);
+  return await continueWorkflowRunFromStep(context, {
+    input: validatedInput,
+    startStepIndex: 0,
+    lastAgentName: null
+  });
+}
+async function continueWorkflowRunFromStep(context, start) {
+  const outcome = await executeWorkflowTopologySteps(context, start);
+  if (outcome.status === "paused") {
+    return await buildAwaitingApprovalRunResult(context, outcome.approvalId);
+  }
+  return await completeWorkflowRun(context, outcome.output);
+}
+async function executeWorkflowTopologySteps(context, start) {
+  const topology = context.definition.topology;
+  if (topology.kind === "supervisor") {
+    return await executeSupervisorSteps(context, topology, start);
+  }
+  if (topology.kind === "parallel") {
+    return await executeParallelSteps(context, topology, start);
+  }
+  return await executePipelineSteps(context, start);
+}
+function validateWorkflowInput(definition, input) {
+  const parsedInput = definition.inputSchema.safeParse(input);
+  if (parsedInput.success) {
+    return parsedInput.data;
+  }
+  throw new AppError12({
+    code: AppErrorCode12.ValidationFailed,
+    message: `workflow "${definition.name}" input failed schema validation: ${parsedInput.error.message}`,
+    statusCode: 422
+  });
+}
+function createWorkflowRuntimeContext(definition, validatedInput, options) {
+  const now = options?.now ?? (() => /* @__PURE__ */ new Date());
+  const runId = options?.runId ?? generateRunId();
+  const startedAtMs = now().getTime();
+  const traceBus = createTraceBus({
+    runId,
+    workflowName: definition.name,
+    input: validatedInput,
+    sinks: options?.sinks ?? [],
+    now
+  });
+  const memoryConfig = resolveWorkflowMemoryConfig(definition.memory ?? void 0);
+  const runStartedEvent = emitRunStartedEvent(
+    { traceBus, runId, workflowName: definition.name, now },
+    validatedInput
+  );
+  return {
+    definition,
+    traceBus,
+    runId,
+    runStartedEventId: runStartedEvent.id,
+    threadMemory: createThreadMemory({
+      provider: memoryConfig.provider,
+      threadKey: runId
+    }),
+    memoryProvider: memoryConfig.provider,
+    artifactStore: createArtifactStore({
+      provider: memoryConfig.provider,
+      runId
+    }),
+    now,
+    startedAtMs,
+    persistRunState: options?.persistRunState ?? true,
+    runStateDirectory: options?.runStateDirectory ?? defaultRunStateDirectory
+  };
+}
+async function executePipelineSteps(context, start) {
+  const stepAgents = context.definition.agents;
+  let currentStepInput = start.input;
+  for (let stepIndex = start.startStepIndex; stepIndex < stepAgents.length; stepIndex += 1) {
+    const stepAgent = stepAgents[stepIndex];
+    if (stepAgent === void 0) {
+      break;
+    }
+    currentStepInput = await executeWorkflowStep(
+      context,
+      stepIndex,
+      stepAgent,
+      currentStepInput
+    );
+    await persistWorkflowRunState(context);
+    const bindingOutcome = await applyAgentToolBindingAfterStep(
+      context,
+      stepIndex,
+      stepAgent.name,
+      currentStepInput
+    );
+    if (bindingOutcome.status === "paused") {
+      return bindingOutcome;
+    }
+    if (stepIndex < stepAgents.length - 1 && shouldStopWorkflowRun(context, stepIndex)) {
+      break;
+    }
+  }
+  return { status: "completed", output: currentStepInput };
+}
+async function buildAwaitingApprovalRunResult(context, approvalId) {
+  return {
+    status: "awaiting_approval",
+    runId: context.runId,
+    approvalId,
+    state: await buildWorkflowRunState(context),
+    events: context.traceBus.listTraceEvents()
+  };
+}
+async function completeWorkflowRun(context, lastStepOutput) {
+  const finalOutput = await validateWorkflowOutput(context, lastStepOutput);
+  emitRunCompletedEvent(
+    buildWorkflowEventContext(context),
+    context.runStartedEventId,
+    finalOutput,
+    calculateWorkflowElapsedMs(context)
+  );
+  await persistWorkflowRunState(context);
+  await context.traceBus.flushSinks();
+  return {
+    status: "completed",
+    runId: context.runId,
+    output: finalOutput,
+    state: await buildWorkflowRunState(context),
+    events: context.traceBus.listTraceEvents()
+  };
+}
+async function validateWorkflowOutput(context, lastStepOutput) {
+  if (context.definition.outputSchema === null) {
+    return lastStepOutput;
+  }
+  const parsedOutput = context.definition.outputSchema.safeParse(lastStepOutput);
+  if (parsedOutput.success) {
+    return parsedOutput.data;
+  }
+  const validationError = new AppError12({
+    code: AppErrorCode12.ValidationFailed,
+    message: `workflow "${context.definition.name}" output failed schema validation: ${parsedOutput.error.message}`,
+    statusCode: 422
+  });
+  await failWorkflowRun(context, validationError);
+  throw validationError;
+}
+
+// src/workflows/workflow-definition.ts
+function workflow(config) {
+  const definition = Object.freeze({
+    name: config.name,
+    inputSchema: config.inputSchema,
+    outputSchema: config.outputSchema ?? null,
+    agents: Object.freeze([...config.agents]),
+    tools: Object.freeze([...config.tools ?? []]),
+    agentToolBindings: Object.freeze([...config.agentToolBindings ?? []]),
+    topology: config.topology ?? defaultWorkflowTopology,
+    policies: Object.freeze([...config.policies ?? []]),
+    memory: config.memory ?? null,
+    stopCondition: config.stopCondition ?? null,
+    continueOnAgentFailure: config.continueOnAgentFailure ?? false,
+    run: async (input, options) => {
+      return await runWorkflow({ definition, input, options });
+    }
+  });
+  return definition;
+}
+
+// src/workflows/resume-run.ts
+import { existsSync } from "fs";
+import { AppErrorCode as AppErrorCode13 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError13 } from "@assemble-dev/shared-utils/errors";
+async function resumeRun(resumeInput) {
+  const directory = resumeInput.options?.runStateDirectory ?? defaultRunStateDirectory;
+  const persistedState = loadPersistedRunStateForResume(
+    resumeInput.runId,
+    directory
+  );
+  const pendingApproval = findPendingWorkflowApproval(persistedState);
+  const context = await createResumedWorkflowRuntimeContext(
+    resumeInput.definition,
+    persistedState,
+    pendingApproval,
+    resumeInput.options
+  );
+  if (!resumeInput.decision.approved) {
+    return await rejectPendingWorkflowApproval(
+      context,
+      pendingApproval,
+      resumeInput.decision
+    );
+  }
+  return await approvePendingWorkflowApproval(
+    context,
+    pendingApproval,
+    resumeInput.decision
+  );
+}
+function loadPersistedRunStateForResume(runId, directory) {
+  const filePath = resolveRunStateFilePath(runId, directory);
+  if (!existsSync(filePath)) {
+    throw new AppError13({
+      code: AppErrorCode13.NotFound,
+      message: `run state file not found at "${filePath}" for run "${runId}"; the run was never persisted or the runStateDirectory is wrong`,
+      statusCode: 404,
+      details: { runId, filePath }
+    });
+  }
+  const persistedState = loadRunStateFile({ runId, directory });
+  if (persistedState.status !== "awaiting_approval") {
+    throw new AppError13({
+      code: AppErrorCode13.Conflict,
+      message: `run "${runId}" has status "${persistedState.status}" and cannot be resumed; only runs with status "awaiting_approval" can be resumed`,
+      statusCode: 409,
+      details: { runId, status: persistedState.status }
+    });
+  }
+  return persistedState;
+}
+function findPendingWorkflowApproval(persistedState) {
+  const pendingArtifact = persistedState.artifacts.find(
+    (artifact) => artifact.key === pendingApprovalArtifactKey
+  );
+  if (pendingArtifact === void 0) {
+    throw new AppError13({
+      code: AppErrorCode13.Conflict,
+      message: `run "${persistedState.runId}" is awaiting approval but has no "${pendingApprovalArtifactKey}" artifact; the persisted state is incomplete and the run cannot be resumed`,
+      statusCode: 409,
+      details: { runId: persistedState.runId }
+    });
+  }
+  return PendingWorkflowApprovalSchema.parse(pendingArtifact.value);
+}
+async function createResumedWorkflowRuntimeContext(definition, persistedState, pendingApproval, options) {
+  const now = options?.now ?? (() => /* @__PURE__ */ new Date());
+  const traceBus = createTraceBus({
+    runId: persistedState.runId,
+    workflowName: definition.name,
+    input: persistedState.input,
+    sinks: options?.sinks ?? [],
+    now,
+    initialRunState: persistedState
+  });
+  const memoryConfig = resolveWorkflowMemoryConfig(definition.memory ?? void 0);
+  const artifactStore = createArtifactStore({
+    provider: memoryConfig.provider,
+    runId: persistedState.runId
+  });
+  for (const artifact of persistedState.artifacts) {
+    await artifactStore.saveRunArtifact(artifact);
+  }
+  return {
+    definition,
+    traceBus,
+    runId: persistedState.runId,
+    runStartedEventId: pendingApproval.runStartedEventId,
+    threadMemory: createThreadMemory({
+      provider: memoryConfig.provider,
+      threadKey: persistedState.runId
+    }),
+    memoryProvider: memoryConfig.provider,
+    artifactStore,
+    now,
+    startedAtMs: resolveResumedRunStartedAtMs(persistedState, now),
+    persistRunState: options?.persistRunState ?? true,
+    runStateDirectory: options?.runStateDirectory ?? defaultRunStateDirectory
+  };
+}
+function resolveResumedRunStartedAtMs(persistedState, now) {
+  if (persistedState.startedAt === null) {
+    return now().getTime();
+  }
+  return new Date(persistedState.startedAt).getTime();
+}
+async function rejectPendingWorkflowApproval(context, pendingApproval, decision) {
+  const rejectionReason = decision.reason ?? "approval rejected";
+  emitApprovalRejectedEvent(
+    buildWorkflowEventContext(context),
+    {
+      approvalId: pendingApproval.approvalId,
+      decidedBy: decision.approvedBy,
+      parentEventId: pendingApproval.toolRequestEventId
+    },
+    rejectionReason
+  );
+  await failWorkflowRun(
+    context,
+    new AppError13({
+      code: AppErrorCode13.Forbidden,
+      message: `tool "${pendingApproval.toolName}" at step ${pendingApproval.stepIndex} was rejected by "${decision.approvedBy}": ${rejectionReason}`,
+      statusCode: 403,
+      details: {
+        toolName: pendingApproval.toolName,
+        stepIndex: pendingApproval.stepIndex,
+        decidedBy: decision.approvedBy,
+        reason: rejectionReason
+      }
+    })
+  );
+  await context.traceBus.flushSinks();
+  return {
+    status: "rejected",
+    runId: context.runId,
+    state: await buildWorkflowRunState(context),
+    events: context.traceBus.listTraceEvents()
+  };
+}
+async function approvePendingWorkflowApproval(context, pendingApproval, decision) {
+  emitApprovalApprovedEvent(buildWorkflowEventContext(context), {
+    approvalId: pendingApproval.approvalId,
+    decidedBy: decision.approvedBy,
+    parentEventId: pendingApproval.toolRequestEventId
+  });
+  await executeApprovedWorkflowTool(context, pendingApproval);
+  const result = await continueWorkflowRunFromStep(context, {
+    input: pendingApproval.agentOutput,
+    startStepIndex: pendingApproval.stepIndex + 1,
+    lastAgentName: pendingApproval.agentName
+  });
+  await context.traceBus.flushSinks();
+  return result;
+}
+
+// src/memory/json-file-provider.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname } from "path";
+import { JsonObjectSchema as JsonObjectSchema2 } from "@assemble-dev/shared-types/json";
+function parseMemoryFileContents(rawContents) {
+  try {
+    const parsedContents = JsonObjectSchema2.parse(JSON.parse(rawContents));
+    return new Map(Object.entries(parsedContents));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function loadMemoryEntriesFromFile(filePath) {
+  if (!existsSync2(filePath)) {
+    return /* @__PURE__ */ new Map();
+  }
+  return parseMemoryFileContents(readFileSync2(filePath, "utf8"));
+}
+function writeMemoryEntriesToFile(filePath, memoryEntries) {
+  mkdirSync2(dirname(filePath), { recursive: true });
+  writeFileSync2(
+    filePath,
+    JSON.stringify(Object.fromEntries(memoryEntries)),
+    "utf8"
+  );
+}
+function createJsonFileMemoryProvider(options) {
+  let memoryEntries = null;
+  const ensureMemoryEntriesLoaded = () => {
+    if (memoryEntries === null) {
+      memoryEntries = loadMemoryEntriesFromFile(options.filePath);
+    }
+    return memoryEntries;
+  };
+  return {
+    async getMemoryValue(key) {
+      return await Promise.resolve(
+        ensureMemoryEntriesLoaded().get(key) ?? null
+      );
+    },
+    async setMemoryValue(key, value) {
+      const loadedEntries = ensureMemoryEntriesLoaded();
+      loadedEntries.set(key, value);
+      writeMemoryEntriesToFile(options.filePath, loadedEntries);
+      await Promise.resolve();
+    },
+    async appendMemoryValue(key, value) {
+      const loadedEntries = ensureMemoryEntriesLoaded();
+      loadedEntries.set(key, buildAppendedMemoryValue(loadedEntries.get(key), value));
+      writeMemoryEntriesToFile(options.filePath, loadedEntries);
+      await Promise.resolve();
+    },
+    async listMemoryKeys() {
+      return await Promise.resolve([...ensureMemoryEntriesLoaded().keys()]);
+    }
+  };
+}
+
+// src/tracing/console-sink.ts
+var ansiCodes = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m"
+};
+var colorByEventCategory = {
+  run: "magenta",
+  agent: "blue",
+  tool: "cyan",
+  policy: "yellow",
+  route: "yellow",
+  approval: "yellow",
+  eval: "green",
+  replay: "green"
+};
+function createConsoleSink(options = {}) {
+  const writeLine = options.writeLine ?? ((line) => process.stdout.write(`${line}
+`));
+  const useColor = options.useColor ?? true;
+  return {
+    name: "console",
+    writeTraceEvent(event) {
+      writeLine(formatTraceEventLine(event, useColor));
+    }
+  };
+}
+function formatTraceEventLine(event, useColor) {
+  const time = event.timestamp.slice(11, 23);
+  const category = event.type.split(".")[0] ?? "run";
+  const detail = formatTraceEventDetail(event);
+  const suffix = detail === "" ? "" : ` ${detail}`;
+  if (!useColor) {
+    return `[${time}] ${event.type}${suffix}`;
+  }
+  const color = ansiCodes[colorByEventCategory[category] ?? "blue"];
+  const failed = event.type.endsWith(".failed") || event.type.endsWith(".blocked");
+  const typeColor = failed ? ansiCodes.red : color;
+  return `${ansiCodes.dim}[${time}]${ansiCodes.reset} ${typeColor}${event.type}${ansiCodes.reset}${suffix}`;
+}
+function formatTraceEventDetail(event) {
+  const parts = [];
+  if ("agentName" in event && event.agentName !== void 0) {
+    parts.push(`agent=${event.agentName}`);
+  }
+  if ("toolName" in event && event.toolName !== void 0) {
+    parts.push(`tool=${event.toolName}`);
+  }
+  if ("selectedAgentName" in event) {
+    parts.push(`selected=${event.selectedAgentName}`);
+  }
+  if ("action" in event) {
+    parts.push(`action=${event.action}`);
+  }
+  if ("approvalId" in event) {
+    parts.push(`approval=${event.approvalId}`);
+  }
+  if ("latencyMs" in event) {
+    parts.push(`${Math.round(event.latencyMs)}ms`);
+  }
+  if ("error" in event) {
+    parts.push(`error="${event.error.message}"`);
+  }
+  if ("reason" in event) {
+    parts.push(`reason="${event.reason}"`);
+  }
+  return parts.join(" ");
+}
+
+// src/tracing/jsonl-sink.ts
+import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join2 } from "path";
+var defaultTraceDirectory = join2(".assemble", "runs");
+function resolveTraceFilePath(runId, directory = defaultTraceDirectory) {
+  return join2(directory, `${runId}.jsonl`);
+}
+function createJsonlSink(options) {
+  const directory = options.directory ?? defaultTraceDirectory;
+  const filePath = resolveTraceFilePath(options.runId, directory);
+  mkdirSync3(directory, { recursive: true });
+  return {
+    name: "jsonl",
+    writeTraceEvent(event) {
+      appendFileSync(filePath, `${JSON.stringify(event)}
+`, "utf8");
+    }
+  };
+}
+
+// src/platform/platform-trace-sink.ts
+import {
+  resolveRedactionMode as resolveRedactionMode3
+} from "@assemble-dev/shared-utils/redaction";
+
+// src/platform/platform-config.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { z as z5 } from "zod";
+var defaultPlatformBaseUrl = "https://api.assemble.dev";
+var defaultPlatformDashboardUrl = "https://app.assemble.dev";
+var PlatformEnvSchema = z5.object({
+  ASSEMBLE_API_KEY: z5.string().min(1).optional(),
+  ASSEMBLE_BASE_URL: z5.string().min(1).optional(),
+  ASSEMBLE_DASHBOARD_URL: z5.string().min(1).optional()
+});
+var PlatformConfigFileSchema = z5.object({
+  apiKey: z5.string().min(1).optional(),
+  baseUrl: z5.string().min(1).optional()
+});
+var PlatformConfigSchema = z5.object({
+  apiKey: z5.string().min(1).nullable(),
+  baseUrl: z5.string().min(1),
+  dashboardUrl: z5.string().min(1)
+});
+function resolvePlatformConfigFilePath(homeDirectory) {
+  return join3(homeDirectory, ".assemble", "config.json");
+}
+function parsePlatformEnvironment(environmentVariables) {
+  const parsedEnvironment = PlatformEnvSchema.safeParse(environmentVariables);
+  if (parsedEnvironment.success) {
+    return parsedEnvironment.data;
+  }
+  return {};
+}
+function isMissingConfigFileError(failure) {
+  return "code" in failure && failure.code === "ENOENT";
+}
+function readPlatformConfigFile(homeDirectory) {
+  const configFilePath = resolvePlatformConfigFilePath(homeDirectory);
+  try {
+    const rawContents = readFileSync3(configFilePath, "utf8");
+    return PlatformConfigFileSchema.parse(JSON.parse(rawContents));
+  } catch (caughtError) {
+    const failure = caughtError instanceof Error ? caughtError : new Error(String(caughtError));
+    if (!isMissingConfigFileError(failure)) {
+      console.error(
+        `assemble platform config: failed to load config file at ${configFilePath}: ${failure.message}`
+      );
+    }
+    return {};
+  }
+}
+function resolvePlatformConfig(options) {
+  const environment = parsePlatformEnvironment(
+    options?.environmentVariables ?? process.env
+  );
+  const configFile = readPlatformConfigFile(
+    options?.homeDirectory ?? homedir()
+  );
+  return PlatformConfigSchema.parse({
+    apiKey: options?.apiKey ?? environment.ASSEMBLE_API_KEY ?? configFile.apiKey ?? null,
+    baseUrl: options?.baseUrl ?? environment.ASSEMBLE_BASE_URL ?? configFile.baseUrl ?? defaultPlatformBaseUrl,
+    dashboardUrl: options?.dashboardUrl ?? environment.ASSEMBLE_DASHBOARD_URL ?? defaultPlatformDashboardUrl
+  });
+}
+
+// src/platform/redact-trace-event.ts
+import {
+  TraceEventErrorSchema,
+  TraceEventSchema as TraceEventSchema2
+} from "@assemble-dev/shared-types/trace-events";
+import {
+  redactTracePayload as redactTracePayload2,
+  redactedValue,
+  resolveRedactionMode as resolveRedactionMode2
+} from "@assemble-dev/shared-utils/redaction";
+function buildErrorJsonPayload(error) {
+  const payload = { message: error.message };
+  if (error.code !== void 0) {
+    payload.code = error.code;
+  }
+  if (error.stack !== void 0) {
+    payload.stack = error.stack;
+  }
+  return payload;
+}
+function redactTraceEventReason(reason, mode, sensitiveFieldNames) {
+  const stringPreservingMode = mode === "metadata-only" ? "redacted" : mode;
+  const outcome = redactTracePayload2(reason, {
+    mode: stringPreservingMode,
+    sensitiveFieldNames
+  });
+  if (typeof outcome.payload === "string") {
+    return {
+      reason: outcome.payload,
+      redacted: outcome.payload !== reason
+    };
+  }
+  return { reason: redactedValue, redacted: true };
+}
+function redactTraceEventError(error, mode, sensitiveFieldNames) {
+  const outcome = redactTracePayload2(buildErrorJsonPayload(error), {
+    mode,
+    sensitiveFieldNames
+  });
+  const parsedError = TraceEventErrorSchema.safeParse(outcome.payload);
+  if (parsedError.success) {
+    return { error: parsedError.data, redacted: outcome.redacted };
+  }
+  return { error: { message: redactedValue }, redacted: true };
+}
+function redactTraceEventPayloads(event, mode, sensitiveFieldNames) {
+  const resolvedMode = resolveRedactionMode2(mode);
+  const redactedEvent = { ...event };
+  let payloadWasRedacted = false;
+  if ("input" in redactedEvent) {
+    const outcome = redactTracePayload2(redactedEvent.input, {
+      mode: resolvedMode,
+      sensitiveFieldNames
+    });
+    redactedEvent.input = outcome.payload;
+    payloadWasRedacted = payloadWasRedacted || outcome.redacted;
+  }
+  if ("output" in redactedEvent) {
+    const outcome = redactTracePayload2(redactedEvent.output, {
+      mode: resolvedMode,
+      sensitiveFieldNames
+    });
+    redactedEvent.output = outcome.payload;
+    payloadWasRedacted = payloadWasRedacted || outcome.redacted;
+  }
+  if ("reason" in redactedEvent) {
+    const outcome = redactTraceEventReason(
+      redactedEvent.reason,
+      resolvedMode,
+      sensitiveFieldNames
+    );
+    redactedEvent.reason = outcome.reason;
+    payloadWasRedacted = payloadWasRedacted || outcome.redacted;
+  }
+  if ("error" in redactedEvent) {
+    const outcome = redactTraceEventError(
+      redactedEvent.error,
+      resolvedMode,
+      sensitiveFieldNames
+    );
+    redactedEvent.error = outcome.error;
+    payloadWasRedacted = payloadWasRedacted || outcome.redacted;
+  }
+  return TraceEventSchema2.parse({
+    ...redactedEvent,
+    redacted: redactedEvent.redacted || payloadWasRedacted || resolvedMode !== "full"
+  });
+}
+
+// src/platform/platform-trace-sink.ts
+var defaultTraceBatchSize = 20;
+var defaultTraceQueueSize = 1e3;
+function resolveTraceIngestUrl(baseUrl) {
+  return `${baseUrl}/v1/ingest/trace-events`;
+}
+function buildPlatformSinkContext(options) {
+  return {
+    ingestUrl: resolveTraceIngestUrl(options.baseUrl ?? defaultPlatformBaseUrl),
+    apiKey: options.apiKey,
+    runId: options.runId,
+    workflowName: options.workflowName,
+    redactionMode: resolveRedactionMode3(options.redactionMode),
+    sensitiveFieldNames: options.sensitiveFieldNames,
+    batchSize: options.batchSize ?? defaultTraceBatchSize,
+    maxQueueSize: options.maxQueueSize ?? defaultTraceQueueSize,
+    fetchImplementation: options.fetchImplementation ?? fetch,
+    onUploadError: options.onUploadError,
+    queuedEvents: [],
+    uploadStats: {
+      uploadedEventCount: 0,
+      droppedEventCount: 0,
+      failedBatchCount: 0
+    },
+    uploadPromiseChain: Promise.resolve(),
+    isClosed: false
+  };
+}
+function reportUploadError(context, uploadError) {
+  if (context.onUploadError !== void 0) {
+    context.onUploadError(uploadError);
+  }
+}
+function buildTraceEventBatchRequest(context, eventsToUpload) {
+  return {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${context.apiKey}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      runId: context.runId,
+      workflowName: context.workflowName,
+      events: eventsToUpload
+    })
+  };
+}
+async function attemptTraceEventBatchUpload(context, eventsToUpload) {
+  try {
+    const response = await context.fetchImplementation(
+      context.ingestUrl,
+      buildTraceEventBatchRequest(context, eventsToUpload)
+    );
+    if (response.ok) {
+      return true;
+    }
+    reportUploadError(
+      context,
+      new Error(`trace event upload failed with status ${response.status}`)
+    );
+    return false;
+  } catch (caughtError) {
+    reportUploadError(
+      context,
+      caughtError instanceof Error ? caughtError : new Error(String(caughtError))
+    );
+    return false;
+  }
+}
+async function uploadTraceEventBatchWithSingleRetry(context, eventsToUpload) {
+  const uploadedOnFirstAttempt = await attemptTraceEventBatchUpload(
+    context,
+    eventsToUpload
+  );
+  const uploaded = uploadedOnFirstAttempt || await attemptTraceEventBatchUpload(context, eventsToUpload);
+  if (uploaded) {
+    context.uploadStats.uploadedEventCount += eventsToUpload.length;
+    return;
+  }
+  context.uploadStats.failedBatchCount += 1;
+  context.uploadStats.droppedEventCount += eventsToUpload.length;
+}
+function enqueueTraceEventBatchUpload(context, eventsToUpload) {
+  context.uploadPromiseChain = context.uploadPromiseChain.then(async () => {
+    await uploadTraceEventBatchWithSingleRetry(context, eventsToUpload);
+  });
+}
+function dropOldestQueuedEventsBeyondLimit(context) {
+  while (context.queuedEvents.length > context.maxQueueSize) {
+    context.queuedEvents.shift();
+    context.uploadStats.droppedEventCount += 1;
+  }
+}
+function scheduleFullBatchUploads(context) {
+  while (context.queuedEvents.length >= context.batchSize) {
+    enqueueTraceEventBatchUpload(
+      context,
+      context.queuedEvents.splice(0, context.batchSize)
+    );
+  }
+}
+function writeTraceEventToPlatformQueue(context, event) {
+  if (context.isClosed) {
+    return;
+  }
+  try {
+    context.queuedEvents.push(
+      redactTraceEventPayloads(
+        event,
+        context.redactionMode,
+        context.sensitiveFieldNames
+      )
+    );
+  } catch (caughtError) {
+    context.uploadStats.droppedEventCount += 1;
+    reportUploadError(
+      context,
+      caughtError instanceof Error ? caughtError : new Error(String(caughtError))
+    );
+    return;
+  }
+  dropOldestQueuedEventsBeyondLimit(context);
+  scheduleFullBatchUploads(context);
+}
+async function flushQueuedTraceEvents(context) {
+  if (context.queuedEvents.length > 0) {
+    enqueueTraceEventBatchUpload(
+      context,
+      context.queuedEvents.splice(0, context.queuedEvents.length)
+    );
+  }
+  await context.uploadPromiseChain;
+}
+function createPlatformTraceSink(options) {
+  const context = buildPlatformSinkContext(options);
+  return {
+    name: "platform",
+    writeTraceEvent: (event) => {
+      writeTraceEventToPlatformQueue(context, event);
+    },
+    flush: async () => {
+      await flushQueuedTraceEvents(context);
+    },
+    close: () => {
+      context.isClosed = true;
+    },
+    getUploadStats: () => ({ ...context.uploadStats })
+  };
+}
+
+// src/platform/platform-messages.ts
+var platformKeySignupUrl = "https://app.assemble.dev/app/keys";
+function buildMissingKeyMessage() {
+  return `Get a free developer key to see this trace hosted \u2192 ${platformKeySignupUrl}`;
+}
+function buildHostedTraceUrl(input) {
+  return `${input.dashboardUrl}/app/runs/${input.runId}`;
+}
+
+// src/replay/replay-engine.ts
+import { generateRunId as generateRunId2, generateTraceEventId as generateTraceEventId5 } from "@assemble-dev/shared-utils/ids";
+
+// src/replay/replay-plan.ts
+import { AppErrorCode as AppErrorCode15 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError15 } from "@assemble-dev/shared-utils/errors";
+
+// src/replay/replay-mocks.ts
+import { mockModel } from "@assemble-dev/providers";
+import { AppErrorCode as AppErrorCode14 } from "@assemble-dev/shared-types/errors";
+import { AppError as AppError14 } from "@assemble-dev/shared-utils/errors";
+function buildReplayToolMocks(events) {
+  const queuesByToolName = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "tool.completed") {
+      continue;
+    }
+    const queue = queuesByToolName.get(event.toolName) ?? {
+      remaining: [],
+      recordedCount: 0
+    };
+    queue.remaining.push(event.output);
+    queue.recordedCount += 1;
+    queuesByToolName.set(event.toolName, queue);
+  }
+  return {
+    takeNextRecordedToolOutput(toolName) {
+      const queue = queuesByToolName.get(toolName);
+      const nextOutput = queue?.remaining.shift();
+      if (nextOutput === void 0) {
+        throw buildReplayTraceExhaustionError(
+          "tool",
+          toolName,
+          "tool.completed",
+          queue?.recordedCount ?? 0
+        );
+      }
+      return nextOutput;
+    }
+  };
+}
+function buildReplayAgentModels(events) {
+  const scriptedResponsesByAgentName = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "agent.completed") {
+      continue;
+    }
+    const scriptedResponses = scriptedResponsesByAgentName.get(event.agentName) ?? [];
+    scriptedResponses.push(serializeRecordedAgentOutput(event.output));
+    scriptedResponsesByAgentName.set(event.agentName, scriptedResponses);
+  }
+  const adaptersByAgentName = /* @__PURE__ */ new Map();
+  return {
+    resolveReplayModelForAgent(agentName) {
+      const existingAdapter = adaptersByAgentName.get(agentName);
+      if (existingAdapter !== void 0) {
+        return existingAdapter;
+      }
+      const adapter = buildScriptedReplayModel(
+        agentName,
+        scriptedResponsesByAgentName.get(agentName) ?? []
+      );
+      adaptersByAgentName.set(agentName, adapter);
+      return adapter;
+    }
+  };
+}
+function buildScriptedReplayModel(agentName, scriptedResponses) {
+  const recordedCount = scriptedResponses.length;
+  return mockModel({
+    name: `replay:${agentName}`,
+    scriptedResponses: [...scriptedResponses],
+    respond: () => {
+      throw buildReplayTraceExhaustionError(
+        "agent",
+        agentName,
+        "agent.completed",
+        recordedCount
+      );
+    }
+  });
+}
+function serializeRecordedAgentOutput(output) {
+  return typeof output === "string" ? output : JSON.stringify(output);
+}
+function buildReplayTraceExhaustionError(kind, name, eventType, recordedCount) {
+  return new AppError14({
+    code: AppErrorCode14.Conflict,
+    message: `replay requested recorded output ${recordedCount + 1} for ${kind} "${name}" but the source trace only holds ${recordedCount} "${eventType}" event(s) for it; the replay diverged from the source run, and a replay may only consume outputs the source run recorded. Record a new source run that covers this call, replay from an earlier step, or disable mocking for this ${kind}`,
+    statusCode: 409,
+    details: { kind, name, recordedCount }
+  });
+}
+
+// src/replay/replay-plan.ts
+function buildReplayStartPlan(definition, sourceRunId, source, fromStepIndex) {
+  if (fromStepIndex === 0) {
+    return {
+      startInput: validateReplayStartInput(definition, sourceRunId, source.state),
+      lastAgentName: null,
+      fromEventId: null,
+      replayEvents: source.events,
+      seedSteps: []
+    };
+  }
+  const startedEvents = source.events.filter(
+    (event) => event.type === "agent.started"
+  );
+  const completedEvents = source.events.filter(
+    (event) => event.type === "agent.completed"
+  );
+  const fromStepEvent = startedEvents[fromStepIndex];
+  const previousStepEvent = completedEvents[fromStepIndex - 1];
+  if (fromStepEvent === void 0 || previousStepEvent === void 0) {
+    throw buildFromStepOutOfRangeError(
+      sourceRunId,
+      fromStepIndex,
+      startedEvents.length
+    );
+  }
+  return {
+    startInput: previousStepEvent.output,
+    lastAgentName: previousStepEvent.agentName,
+    fromEventId: fromStepEvent.id,
+    replayEvents: source.events.slice(source.events.indexOf(fromStepEvent)),
+    seedSteps: buildReplaySeedSteps(
+      sourceRunId,
+      startedEvents,
+      completedEvents,
+      fromStepIndex
+    )
+  };
+}
+function buildReplaySeedSteps(sourceRunId, startedEvents, completedEvents, fromStepIndex) {
+  const seedSteps = [];
+  for (let stepIndex = 0; stepIndex < fromStepIndex; stepIndex += 1) {
+    const startedEvent = startedEvents[stepIndex];
+    const completedEvent = completedEvents[stepIndex];
+    if (startedEvent === void 0 || completedEvent === void 0) {
+      throw buildFromStepOutOfRangeError(
+        sourceRunId,
+        fromStepIndex,
+        startedEvents.length
+      );
+    }
+    seedSteps.push({
+      agentName: completedEvent.agentName,
+      input: startedEvent.input,
+      output: completedEvent.output
+    });
+  }
+  return seedSteps;
+}
+function buildFromStepOutOfRangeError(sourceRunId, fromStepIndex, recordedStepCount) {
+  return new AppError15({
+    code: AppErrorCode15.BadRequest,
+    message: `fromStepIndex ${fromStepIndex} is out of range for source run "${sourceRunId}"; the source trace recorded ${recordedStepCount} completed agent step(s), so fromStepIndex must be between 0 and ${Math.max(0, recordedStepCount - 1)}`,
+    statusCode: 400,
+    details: { sourceRunId, fromStepIndex, recordedStepCount }
+  });
+}
+function validateReplayStartInput(definition, sourceRunId, sourceState) {
+  const parsedInput = definition.inputSchema.safeParse(sourceState.input);
+  if (parsedInput.success) {
+    return parsedInput.data;
+  }
+  throw new AppError15({
+    code: AppErrorCode15.ValidationFailed,
+    message: `source run "${sourceRunId}" input failed workflow "${definition.name}" input schema validation: ${parsedInput.error.message}`,
+    statusCode: 422,
+    details: { sourceRunId, workflowName: definition.name }
+  });
+}
+function buildMockedReplayDefinition(definition, replayEvents, mockTools) {
+  const agentModels = buildReplayAgentModels(replayEvents);
+  const toolMocks = buildReplayToolMocks(replayEvents);
+  return workflow({
+    name: definition.name,
+    inputSchema: definition.inputSchema,
+    outputSchema: definition.outputSchema ?? void 0,
+    agents: definition.agents.map((agentDefinition) => ({
+      ...agentDefinition,
+      model: agentModels.resolveReplayModelForAgent(agentDefinition.name)
+    })),
+    tools: definition.tools.map(
+      (toolDefinition) => mockTools ? {
+        ...toolDefinition,
+        execute: async () => await Promise.resolve(
+          toolMocks.takeNextRecordedToolOutput(toolDefinition.name)
+        )
+      } : toolDefinition
+    ),
+    agentToolBindings: [...definition.agentToolBindings],
+    topology: definition.topology,
+    policies: [...definition.policies],
+    memory: definition.memory ?? void 0,
+    stopCondition: definition.stopCondition ?? void 0,
+    continueOnAgentFailure: definition.continueOnAgentFailure
+  });
+}
+
+// src/replay/replay-source.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { AppErrorCode as AppErrorCode16 } from "@assemble-dev/shared-types/errors";
+import { TraceEventSchema as TraceEventSchema3 } from "@assemble-dev/shared-types/trace-events";
+import { AppError as AppError16 } from "@assemble-dev/shared-utils/errors";
+function loadReplaySource(input) {
+  const runStateDirectory = input.runStateDirectory ?? defaultRunStateDirectory;
+  const traceDirectory = input.traceDirectory ?? defaultTraceDirectory;
+  return {
+    state: loadSourceRunState(input.runId, runStateDirectory),
+    events: loadSourceTraceEvents(input.runId, traceDirectory)
+  };
+}
+function loadSourceRunState(runId, directory) {
+  const filePath = resolveRunStateFilePath(runId, directory);
+  if (!existsSync3(filePath)) {
+    throw new AppError16({
+      code: AppErrorCode16.NotFound,
+      message: `run state file not found at "${filePath}" for run "${runId}"; the run was never persisted or the runStateDirectory is wrong`,
+      statusCode: 404,
+      details: { runId, filePath }
+    });
+  }
+  return loadRunStateFile({ runId, directory });
+}
+function loadSourceTraceEvents(runId, directory) {
+  const filePath = resolveTraceFilePath(runId, directory);
+  if (!existsSync3(filePath)) {
+    throw new AppError16({
+      code: AppErrorCode16.NotFound,
+      message: `trace file not found at "${filePath}" for run "${runId}"; run the workflow with a jsonl sink or fix the traceDirectory`,
+      statusCode: 404,
+      details: { runId, filePath }
+    });
+  }
+  const lines = readFileSync4(filePath, "utf8").split("\n");
+  const events = [];
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
+    if (line === void 0 || line.trim().length === 0) {
+      continue;
+    }
+    events.push(parseTraceEventLine(line, lineIndex + 1, filePath));
+  }
+  return events;
+}
+function parseTraceEventLine(line, lineNumber, filePath) {
+  try {
+    return TraceEventSchema3.parse(JSON.parse(line));
+  } catch (thrownError) {
+    const reason = thrownError instanceof Error ? thrownError.message : String(thrownError);
+    throw new AppError16({
+      code: AppErrorCode16.ValidationFailed,
+      message: `trace file "${filePath}" has an invalid trace event on line ${lineNumber}: ${reason}`,
+      statusCode: 422,
+      details: { filePath, lineNumber }
+    });
+  }
+}
+
+// src/replay/replay-engine.ts
+async function replayRun(replayInput) {
+  const settings = resolveReplaySettings(replayInput.options);
+  const source = loadReplaySource({
+    runId: replayInput.sourceRunId,
+    runStateDirectory: settings.runStateDirectory,
+    traceDirectory: settings.traceDirectory
+  });
+  const plan = buildReplayStartPlan(
+    replayInput.definition,
+    replayInput.sourceRunId,
+    source,
+    settings.fromStepIndex
+  );
+  const replayDefinition = buildMockedReplayDefinition(
+    replayInput.definition,
+    plan.replayEvents,
+    settings.mockTools
+  );
+  const context = createReplayRuntimeContext(
+    replayDefinition,
+    source,
+    settings,
+    replayInput.sourceRunId,
+    plan.fromEventId
+  );
+  await persistWorkflowRunState(context);
+  await seedReplayContextFromSource(context, source, plan, settings.fromStepIndex);
+  const runResult = await continueWorkflowRunFromStep(context, {
+    input: plan.startInput,
+    startStepIndex: settings.fromStepIndex,
+    lastAgentName: plan.lastAgentName
+  });
+  return await finishReplayRun(context, replayInput.sourceRunId, runResult);
+}
+function resolveReplaySettings(options) {
+  return {
+    fromStepIndex: options?.fromStepIndex ?? 0,
+    mockTools: options?.mockTools ?? true,
+    sinks: options?.sinks ?? [],
+    runStateDirectory: options?.runStateDirectory ?? defaultRunStateDirectory,
+    traceDirectory: options?.traceDirectory ?? defaultTraceDirectory,
+    now: options?.now ?? (() => /* @__PURE__ */ new Date()),
+    replayRunId: options?.replayRunId ?? null
+  };
+}
+function createReplayRuntimeContext(replayDefinition, source, settings, sourceRunId, fromEventId) {
+  const runId = settings.replayRunId ?? generateRunId2();
+  const traceBus = createTraceBus({
+    runId,
+    workflowName: replayDefinition.name,
+    input: source.state.input,
+    sinks: settings.sinks,
+    now: settings.now
+  });
+  emitReplayStartedEvent(traceBus, runId, replayDefinition.name, settings.now, {
+    sourceRunId,
+    fromEventId
+  });
+  const runStartedEvent = emitRunStartedEvent(
+    { traceBus, runId, workflowName: replayDefinition.name, now: settings.now },
+    source.state.input
+  );
+  const memoryConfig = resolveWorkflowMemoryConfig(
+    replayDefinition.memory ?? void 0
+  );
+  return {
+    definition: replayDefinition,
+    traceBus,
+    runId,
+    runStartedEventId: runStartedEvent.id,
+    threadMemory: createThreadMemory({
+      provider: memoryConfig.provider,
+      threadKey: runId
+    }),
+    memoryProvider: memoryConfig.provider,
+    artifactStore: createArtifactStore({
+      provider: memoryConfig.provider,
+      runId
+    }),
+    now: settings.now,
+    startedAtMs: settings.now().getTime(),
+    persistRunState: true,
+    runStateDirectory: settings.runStateDirectory
+  };
+}
+function emitReplayStartedEvent(traceBus, runId, workflowName, now, replayLink) {
+  traceBus.emitTraceEvent({
+    id: generateTraceEventId5(),
+    runId,
+    workflowName,
+    timestamp: now().toISOString(),
+    parentEventId: null,
+    redacted: false,
+    type: "replay.started",
+    sourceRunId: replayLink.sourceRunId,
+    fromEventId: replayLink.fromEventId
+  });
+}
+async function seedReplayContextFromSource(context, source, plan, fromStepIndex) {
+  if (fromStepIndex === 0) {
+    return;
+  }
+  for (const artifact of source.state.artifacts) {
+    const artifactStep = parseArtifactStepIndex(artifact.key);
+    if (artifactStep !== null && artifactStep < fromStepIndex) {
+      await context.artifactStore.saveRunArtifact(artifact);
+    }
+  }
+  for (const seedStep of plan.seedSteps) {
+    await appendAgentExchangeToThreadMemory(
+      context.threadMemory,
+      seedStep.agentName,
+      seedStep.input,
+      serializeAgentInputToText(seedStep.output),
+      context.now
+    );
+  }
+}
+function parseArtifactStepIndex(artifactKey) {
+  const match = /^step-(\d+):/.exec(artifactKey);
+  const capturedStepIndex = match?.[1];
+  if (capturedStepIndex === void 0) {
+    return null;
+  }
+  return Number(capturedStepIndex);
+}
+async function finishReplayRun(context, sourceRunId, runResult) {
+  context.traceBus.emitTraceEvent({
+    id: generateTraceEventId5(),
+    runId: context.runId,
+    workflowName: context.definition.name,
+    timestamp: context.now().toISOString(),
+    parentEventId: context.runStartedEventId,
+    redacted: false,
+    type: "replay.completed",
+    sourceRunId,
+    latencyMs: calculateWorkflowElapsedMs(context)
+  });
+  await context.traceBus.flushSinks();
+  return {
+    status: runResult.status,
+    runId: context.runId,
+    sourceRunId,
+    output: runResult.status === "completed" ? runResult.output : null,
+    approvalId: runResult.status === "awaiting_approval" ? runResult.approvalId : null,
+    state: await buildWorkflowRunState(context),
+    events: context.traceBus.listTraceEvents()
+  };
+}
+
+// src/replay/replay-comparison.ts
+var maxReplayOutputDiffCount = 50;
+function compareRunToReplay(input) {
+  const outputDiff = collectJsonLeafDiffs(
+    "$",
+    input.original.finalOutput,
+    input.replay.finalOutput,
+    []
+  );
+  return {
+    statusMatches: input.original.status === input.replay.status,
+    originalStatus: input.original.status,
+    replayStatus: input.replay.status,
+    outputMatches: outputDiff.length === 0,
+    outputDiff,
+    latency: compareRunLatency(input.original, input.replay),
+    tokenUsage: {
+      original: input.original.metrics.tokenUsage,
+      replay: input.replay.metrics.tokenUsage
+    },
+    routingMatches: compareRoutingSequences(input.original, input.replay)
+  };
+}
+function compareRunLatency(original, replay) {
+  const originalMs = original.metrics.totalLatencyMs;
+  const replayMs = replay.metrics.totalLatencyMs;
+  return {
+    originalMs,
+    replayMs,
+    deltaMs: originalMs !== null && replayMs !== null ? replayMs - originalMs : null
+  };
+}
+function compareRoutingSequences(original, replay) {
+  const originalSequence = original.routingDecisions.map(
+    (decision) => decision.selectedAgentName
+  );
+  const replaySequence = replay.routingDecisions.map(
+    (decision) => decision.selectedAgentName
+  );
+  if (originalSequence.length !== replaySequence.length) {
+    return false;
+  }
+  return originalSequence.every(
+    (selectedAgentName, index) => selectedAgentName === replaySequence[index]
+  );
+}
+function collectJsonLeafDiffs(path, original, replay, diffs) {
+  if (diffs.length >= maxReplayOutputDiffCount) {
+    return diffs;
+  }
+  if (isJsonObject(original) && isJsonObject(replay)) {
+    return collectJsonObjectDiffs(path, original, replay, diffs);
+  }
+  if (Array.isArray(original) && Array.isArray(replay)) {
+    return collectJsonArrayDiffs(path, original, replay, diffs);
+  }
+  if (!jsonValuesEqual(original, replay)) {
+    diffs.push({ path, original, replay });
+  }
+  return diffs;
+}
+function collectJsonObjectDiffs(path, original, replay, diffs) {
+  const keys = [
+    .../* @__PURE__ */ new Set([...Object.keys(original), ...Object.keys(replay)])
+  ].sort();
+  for (const key of keys) {
+    collectJsonLeafDiffs(
+      `${path}.${key}`,
+      original[key] ?? null,
+      replay[key] ?? null,
+      diffs
+    );
+  }
+  return diffs;
+}
+function collectJsonArrayDiffs(path, original, replay, diffs) {
+  const length = Math.max(original.length, replay.length);
+  for (let index = 0; index < length; index += 1) {
+    collectJsonLeafDiffs(
+      `${path}[${index}]`,
+      original[index] ?? null,
+      replay[index] ?? null,
+      diffs
+    );
+  }
+  return diffs;
+}
+function jsonValuesEqual(original, replay) {
+  if (original === replay) {
+    return true;
+  }
+  if (Array.isArray(original) && Array.isArray(replay)) {
+    return original.length === replay.length && original.every(
+      (item, index) => jsonValuesEqual(item, replay[index] ?? null)
+    );
+  }
+  if (isJsonObject(original) && isJsonObject(replay)) {
+    const originalKeys = Object.keys(original).sort();
+    const replayKeys = Object.keys(replay).sort();
+    return originalKeys.length === replayKeys.length && originalKeys.every(
+      (key, index) => key === replayKeys[index] && jsonValuesEqual(original[key] ?? null, replay[key] ?? null)
+    );
+  }
+  return false;
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  agent,
+  applyTraceEventToRunState,
+  buildHostedTraceUrl,
+  buildMissingKeyMessage,
+  buildPipelineTeamWorkflowConfig,
+  buildReviewPanelWorkflowConfig,
+  buildSupervisorTeamWorkflowConfig,
+  compareRunToReplay,
+  createArtifactStore,
+  createConsoleSink,
+  createInMemoryMemoryProvider,
+  createInitialRunState,
+  createJsonFileMemoryProvider,
+  createJsonlSink,
+  createPlatformTraceSink,
+  createThreadMemory,
+  createTraceBus,
+  defaultParallelMergedArtifactKey,
+  defaultRunStateDirectory,
+  defaultSupervisorMaxSteps,
+  defaultTraceDirectory,
+  defaultWorkflowTopology,
+  evaluateToolPolicies,
+  executeToolCall,
+  finishWorkflow,
+  formatTraceEventLine,
+  loadReplaySource,
+  loadRunStateFile,
+  maxReplayOutputDiffCount,
+  policy,
+  replayRun,
+  resolvePlatformConfig,
+  resolveRunStateFilePath,
+  resolveTraceFilePath,
+  resolveWorkflowMemoryConfig,
+  resumeRun,
+  runAgent,
+  runWorkflow,
+  team,
+  tool,
+  workflow
+};