@agent-compose/sdk 0.5.8 → 0.6.0

package/dist/runtimes/openai-desktop.js

@@ -330,1485 +330,1629 @@ class RequestContext {
   }
 }
 
-// src/utils/errors.ts
-function formatError(err) {
-  return err instanceof Error ? err.message : String(err);
+// src/pause/pause-core.ts
+import { createHash } from "node:crypto";
+
+// src/step-invocation/types.ts
+import { z as z3 } from "zod";
+var StepPauseRequestSchema = z3.object({
+  reason: z3.string().min(1),
+  kind: z3.enum(["decision", "sleep", "event", "custom"]),
+  payload: z3.record(z3.string(), z3.unknown()).optional(),
+  ttlMs: z3.number().int().positive().optional(),
+  correlationKey: z3.string().min(1).optional(),
+  snapshot: z3.boolean().optional()
+});
+
+class StepExecutionError extends Error {
+  kind;
+  exitCode;
+  constructor(error, stepLabel) {
+    super(`[${error.kind}] ${stepLabel}: ${error.message}`);
+    this.name = "StepExecutionError";
+    this.kind = error.kind;
+    this.exitCode = error.kind === "runner-exit" ? error.exitCode : undefined;
+  }
 }
 
-// src/runtimes/vercel.ts
-function now() {
-  return new Date().toISOString();
+// src/active-step.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var activeStepStorage = new AsyncLocalStorage;
+var fallbackActive = null;
+var BRIDGE_KEY = Symbol.for("agent-compose.activeStep.bridge");
+function bridgeSlot() {
+  const g = globalThis;
+  return g[BRIDGE_KEY] ??= { state: null };
 }
-function serialiseOutput(value) {
-  return typeof value === "string" ? value : JSON.stringify(value ?? "");
+function makeState(step) {
+  return {
+    stepIndex: step.stepIndex,
+    nextAgentCallIndex: 0,
+    pauseOrdinalByScope: new Map
+  };
 }
-function toAgentMessages(part) {
-  const ts = now();
-  switch (part.type) {
-    case "text-delta":
-    case "text":
-      return [{ type: "text", text: String(part.text ?? ""), timestamp: ts }];
-    case "reasoning-delta":
-    case "reasoning":
-      return [{ type: "thinking", text: String(part.text ?? ""), timestamp: ts }];
-    case "tool-call":
-      return [{
-        type: "tool_use",
-        toolName: String(part.toolName ?? ""),
-        toolInput: part.input ?? {},
-        toolUseId: String(part.toolCallId ?? ""),
-        timestamp: ts
-      }];
-    case "tool-result":
-      return [{
-        type: "tool_result",
-        toolUseId: String(part.toolCallId ?? ""),
-        output: serialiseOutput(part.output),
-        isError: false,
-        timestamp: ts
-      }];
-    case "tool-error":
-      return [{
-        type: "tool_result",
-        toolUseId: String(part.toolCallId ?? ""),
-        output: formatError(part.error),
-        isError: true,
-        timestamp: ts
-      }];
-    case "error":
-      return [{ type: "error", text: formatError(part.error), timestamp: ts }];
-    default:
-      return [];
-  }
+function currentState() {
+  return activeStepStorage.getStore() ?? bridgeSlot().state ?? fallbackActive;
+}
+async function runWithActiveStep(step, fn) {
+  return activeStepStorage.run(makeState(step), fn);
+}
+function setActiveStepBridge(step) {
+  const slot = bridgeSlot();
+  const prev = { state: slot.state };
+  slot.state = step ? makeState(step) : null;
+  return prev;
+}
+function restoreActiveStepBridge(prev) {
+  bridgeSlot().state = prev.state;
+}
+function getActiveStep() {
+  const state = currentState();
+  return state ? { stepIndex: state.stepIndex } : null;
+}
+function nextAgentCallInActiveStep() {
+  const state = currentState();
+  if (!state)
+    return null;
+  const callIndex = state.nextAgentCallIndex;
+  state.nextAgentCallIndex += 1;
+  return { stepIndex: state.stepIndex, callIndex };
+}
+function nextPauseOrdinalInActiveStep(scope) {
+  const state = currentState();
+  if (!state)
+    return null;
+  const next = state.pauseOrdinalByScope.get(scope) ?? 0;
+  state.pauseOrdinalByScope.set(scope, next + 1);
+  return next;
 }
 
-class VercelRunner {
-  sandbox;
-  options;
-  config;
-  supportsToolCallProcessor = true;
-  kind;
-  model;
-  tools;
-  messages = [];
-  constructor(sandbox, options, config) {
-    this.sandbox = sandbox;
-    this.options = options;
-    this.config = config;
-    this.tools = config.tools ?? codingTools;
-    this.kind = config.kind;
-    this.model = config.modelId;
+// src/pause/state-dir.ts
+import { promises as fs } from "node:fs";
+import { join as join2 } from "node:path";
+import { randomBytes } from "node:crypto";
+function getStateDir() {
+  return process.env.AGENT_COMPOSE_STATE_DIR ?? "/tmp/wf/state";
+}
+var checkpointsDir = () => join2(getStateDir(), "checkpoints");
+var pausesDir = () => join2(getStateDir(), "pauses");
+var agentStatePath = (agentInstanceId) => join2(getStateDir(), `agent-${agentInstanceId}.json`);
+var runtimeStatePath = (agentInstanceId) => join2(getStateDir(), `runtime-${agentInstanceId}.json`);
+var checkpointPath = (name) => join2(checkpointsDir(), `${name}.json`);
+var pausePath = (pauseId) => join2(pausesDir(), `${pauseId}.json`);
+var NAME_RE = /^[a-zA-Z0-9_][a-zA-Z0-9_.-]*$/;
+function assertSafeName(label, name) {
+  if (!NAME_RE.test(name)) {
+    throw new Error(`${label} name must match ${NAME_RE} (got ${JSON.stringify(name)})`);
   }
-  async gateToolCall(call, ctx) {
-    const verdict = await runProcessorChain(this.options.processors ?? [], (p) => p.processToolCall, call, ctx);
-    if (verdict.kind === "continue")
-      return { kind: "allow", call: verdict.value };
-    return verdict;
+}
+function assertSafeCheckpointName(name) {
+  assertSafeName("checkpoint", name);
+}
+async function ensureDirs() {
+  await fs.mkdir(checkpointsDir(), { recursive: true });
+  await fs.mkdir(pausesDir(), { recursive: true });
+}
+async function atomicWriteJSON(path, value) {
+  await ensureDirs();
+  const tmp = `${path}.tmp.${randomBytes(6).toString("hex")}`;
+  const payload = JSON.stringify(value);
+  if (payload === undefined) {
+    throw new Error("pause state values must be JSON-serialisable");
   }
-  captureCheckpoint() {
-    return { messages: [...this.messages] };
+  const handle = await fs.open(tmp, "w");
+  try {
+    await handle.writeFile(payload, { encoding: "utf8" });
+    await handle.sync();
+  } finally {
+    await handle.close();
   }
-  restoreCheckpoint(blob) {
-    if (!blob || typeof blob !== "object") {
-      throw new Error("Vercel runtime checkpoint is invalid: expected an object with messages[]");
+  await fs.rename(tmp, path);
+}
+async function readJSON(path) {
+  try {
+    const raw = await fs.readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return null;
+    throw err;
+  }
+}
+async function readJSONWithPresence(path) {
+  try {
+    const raw = await fs.readFile(path, "utf8");
+    return { found: true, value: JSON.parse(raw) };
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return { found: false };
+    throw err;
+  }
+}
+async function readAgentState(agentInstanceId) {
+  assertSafeName("agent", agentInstanceId);
+  return readJSON(agentStatePath(agentInstanceId));
+}
+async function writeAgentState(agentInstanceId, state) {
+  assertSafeName("agent", agentInstanceId);
+  await atomicWriteJSON(agentStatePath(agentInstanceId), state);
+}
+async function readRuntimeCheckpoint(agentInstanceId) {
+  assertSafeName("runtime", agentInstanceId);
+  return readJSON(runtimeStatePath(agentInstanceId));
+}
+async function writeRuntimeCheckpoint(agentInstanceId, blob) {
+  assertSafeName("runtime", agentInstanceId);
+  await atomicWriteJSON(runtimeStatePath(agentInstanceId), blob);
+}
+async function readCheckpoint(name) {
+  assertSafeCheckpointName(name);
+  return readJSONWithPresence(checkpointPath(name));
+}
+async function writeCheckpoint(name, value) {
+  assertSafeCheckpointName(name);
+  await atomicWriteJSON(checkpointPath(name), value);
+}
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function validatePauseRecord(value, expectedPauseId) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`pause record ${expectedPauseId} is malformed: expected object`);
+  }
+  const record = value;
+  if (record.pauseId !== undefined && record.pauseId !== expectedPauseId) {
+    throw new Error(`pause record ${expectedPauseId} is malformed: pauseId mismatch`);
+  }
+  if (record.resolved === true) {
+    if (typeof record.expired !== "boolean") {
+      throw new Error(`pause record ${expectedPauseId} is malformed: resolved records require boolean expired`);
     }
-    const incoming = blob.messages;
-    if (!Array.isArray(incoming)) {
-      throw new Error("Vercel runtime checkpoint is invalid: expected messages[]");
+    if (!hasOwn(record, "resumePayload") || record.resumePayload === undefined) {
+      throw new Error(`pause record ${expectedPauseId} is malformed: resolved records require resumePayload`);
     }
-    this.messages.length = 0;
-    this.messages.push(...incoming);
+    return {
+      pauseId: expectedPauseId,
+      request: hasOwn(record, "request") ? record.request : null,
+      ...record
+    };
   }
-  buildTools(iteration, signal) {
-    const set = {};
-    for (const t of this.tools) {
-      if (this.options.allowedTools && !this.options.allowedTools.includes(t.name))
-        continue;
-      set[t.name] = tool({
-        description: t.description,
-        inputSchema: t.inputSchema,
-        execute: async (input, execOpts) => {
-          const call = {
-            toolName: t.name,
-            toolInput: input,
-            toolUseId: execOpts.toolCallId ?? `${t.name}-${Date.now()}`
-          };
-          const requestContext = this.options.requestContext ?? RequestContext.fromReserved({
-            teamId: "",
-            runId: "",
-            workflowId: "",
-            factoryId: null,
-            apiKeyScopes: [],
-            parentRunId: null
-          });
-          const gate = await this.gateToolCall(call, {
-            requestContext,
-            abortSignal: execOpts.abortSignal ?? signal ?? new AbortController().signal,
-            retryCount: 0,
-            agentId: this.options.agentId ?? "agent",
-            iteration
-          });
-          if (gate.kind === "deny")
-            return gate.reason;
-          if (gate.kind === "abort")
-            throw new Error(gate.reason);
-          return t.execute(gate.call.toolInput, {
-            sandbox: this.sandbox,
-            cwd: this.options.cwd,
-            abortSignal: execOpts.abortSignal ?? signal
-          });
-        }
-      });
-    }
-    return set;
+  if (record.pauseId !== expectedPauseId) {
+    throw new Error(`pause record ${expectedPauseId} is malformed: unresolved records require matching pauseId`);
   }
-  async* sendMessage(opts) {
-    const sessionId = opts.sessionId ?? `vercel-${Date.now()}`;
-    yield { type: "init", sessionId, timestamp: now() };
-    const inputMessages = [...this.messages, { role: "user", content: opts.prompt }];
-    const result = streamText({
-      model: this.config.model,
-      ...this.config.system ? { system: this.config.system } : {},
-      messages: inputMessages,
-      tools: this.buildTools(opts.iteration ?? 1, opts.signal),
-      stopWhen: stepCountIs(this.options.maxTurns ?? 40),
-      abortSignal: opts.signal
-    });
-    try {
-      for await (const part of result.fullStream) {
-        for (const msg of toAgentMessages(part))
-          yield msg;
-      }
-      const response = await result.response;
-      const responseMessages = response.messages;
-      if (responseMessages) {
-        this.messages.length = 0;
-        this.messages.push(...responseMessages);
-      }
-      let usage;
-      try {
-        usage = await result.usage;
-      } catch {
-        usage = undefined;
-      }
-      if (usage) {
-        yield {
-          type: "usage",
-          inputTokens: usage.inputTokens ?? 0,
-          outputTokens: usage.outputTokens ?? 0,
-          cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
-          cacheCreationTokens: usage.inputTokenDetails?.cacheWriteTokens ?? 0,
-          durationMs: 0,
-          numTurns: opts.iteration ?? 1,
-          timestamp: now()
-        };
-      }
-    } catch (err) {
-      yield { type: "error", text: formatError(err), timestamp: now() };
-      return;
-    }
-    yield { type: "done", sessionId, timestamp: now() };
+  if (!hasOwn(record, "request") || record.request === undefined) {
+    throw new Error(`pause record ${expectedPauseId} is malformed: unresolved records require request`);
+  }
+  if (record.resolved !== undefined && record.resolved !== false) {
+    throw new Error(`pause record ${expectedPauseId} is malformed: resolved must be true, false, or absent`);
+  }
+  if (hasOwn(record, "expired") || hasOwn(record, "resumePayload")) {
+    throw new Error(`pause record ${expectedPauseId} is malformed: unresolved records must not include resolution fields`);
   }
+  return record;
 }
-function createVercelRuntime(config) {
-  return defineRuntime({
-    create: (sandbox, opts) => new VercelRunner(sandbox, opts, config)
-  });
+async function readPauseRecord(pauseId) {
+  assertSafeName("pause", pauseId);
+  const record = await readJSON(pausePath(pauseId));
+  return record === null ? null : validatePauseRecord(record, pauseId);
 }
-async function listVercelRuntimeModels() {
-  const { models } = await gateway.getAvailableModels();
-  return models.filter((m) => m.modelType == null || m.modelType === "language").map((m) => ({ id: m.id, name: m.name })).sort((a, b) => a.id.localeCompare(b.id));
+async function writePauseRecord(record) {
+  assertSafeName("pause", record.pauseId);
+  validatePauseRecord(record, record.pauseId);
+  await atomicWriteJSON(pausePath(record.pauseId), record);
 }
-// src/types/workflow.ts
-import { z as z3 } from "zod";
 
-// src/workflow-steps/types.ts
-var WORKFLOW_BRAND = Symbol.for("@agent-compose/sdk.Workflow");
+// src/pause/errors.ts
+class PauseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+}
 
-// src/types/workflow-metadata.ts
-function extractMetadata(source) {
-  const out = {};
-  if (source.description !== undefined)
-    out.description = source.description;
-  if (source.networkPolicy !== undefined)
-    out.networkPolicy = freezeMetadataValue(source.networkPolicy);
-  if (source.placeholders !== undefined)
-    out.placeholders = Object.freeze({ ...source.placeholders });
-  if (source.inputSchema !== undefined)
-    out.inputSchema = freezeMetadataValue(source.inputSchema);
-  if (source.outputSchema !== undefined)
-    out.outputSchema = freezeMetadataValue(source.outputSchema);
-  if (source.snapshots !== undefined)
-    out.snapshots = Object.freeze({ ...source.snapshots });
-  if (source.resources !== undefined)
-    out.resources = Object.freeze({ ...source.resources });
-  if (source.processors !== undefined)
-    out.processors = Object.freeze([...source.processors]);
-  if (source.connectors !== undefined)
-    out.connectors = freezeMetadataValue(source.connectors);
-  if (source.connectorOperation !== undefined)
-    out.connectorOperation = Object.freeze({ ...source.connectorOperation });
-  if (source.invokePolicy !== undefined)
-    out.invokePolicy = freezeMetadataValue(source.invokePolicy);
-  return Object.freeze(out);
+class PauseExpiredError extends PauseError {
+  code = "pause_expired";
+  constructor(message = "pause expired before it was resolved") {
+    super(message);
+  }
 }
-function freezeMetadataValue(value) {
-  if (value === null || typeof value !== "object")
-    return value;
-  if (Array.isArray(value)) {
-    for (const v of value)
-      freezeMetadataValue(v);
-    return Object.freeze(value);
+
+class PauseSchemaError extends PauseError {
+  code = "pause_schema";
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
   }
-  for (const v of Object.values(value)) {
-    freezeMetadataValue(v);
+}
+
+class PauseRequestError extends PauseError {
+  code = "pause_request";
+  constructor(message = "pause request is invalid") {
+    super(message);
   }
-  return Object.freeze(value);
 }
 
-// src/workflow-steps/workflow.ts
-function createStepWorkflow(opts) {
-  if (!opts.id)
-    throw new Error("defineWorkflow: 'id' is required for step-based workflows");
-  const build = (steps) => ({
-    step(step) {
-      return build([...steps, step]);
-    },
-    build() {
-      if (steps.length === 0) {
-        throw new Error(`defineWorkflow("${opts.id}").build: no steps registered — add at least one with .step(step)`);
-      }
-      const finalStep = steps[steps.length - 1];
-      if (finalStep.output !== opts.output) {
-        throw new Error(`defineWorkflow("${opts.id}").build: final step "${finalStep.name}" output schema is not the same Zod schema instance as the workflow's declared output schema. ` + `Pass the same schema reference to both the final step and defineWorkflow.`);
-      }
-      const workflow = {
-        id: opts.id,
-        input: opts.input,
-        output: opts.output,
-        steps: Object.freeze([...steps]),
-        metadata: extractMetadata(opts)
-      };
-      Object.defineProperty(workflow, WORKFLOW_BRAND, { value: true, enumerable: false });
-      return Object.freeze(workflow);
-    }
-  });
-  return build([]);
+// src/pause/pause-core.ts
+var PAUSE_SIGNAL_BRAND = Symbol.for("agent-compose.PauseSignal");
+
+class PauseSignal {
+  pauseId;
+  pauseRequest;
+  observability;
+  [PAUSE_SIGNAL_BRAND] = true;
+  constructor(pauseId, pauseRequest, observability) {
+    this.pauseId = pauseId;
+    this.pauseRequest = pauseRequest;
+    this.observability = observability;
+  }
 }
-function isWorkflow(value) {
-  return typeof value === "object" && value !== null && value[WORKFLOW_BRAND] === true;
+function isPauseSignal(err) {
+  return typeof err === "object" && err !== null && err[PAUSE_SIGNAL_BRAND] === true;
 }
-
-// src/types/workflow.ts
-function compileRunForm(def, metadata) {
-  const unknownSchema = z3.unknown();
-  const inputSchema = def.input ?? unknownSchema;
-  const outputSchema = def.output ?? unknownSchema;
-  const step = {
-    name: "run",
-    input: inputSchema,
-    output: outputSchema,
-    run: async (stepCtx) => {
-      const workflowCtx = {
-        input: stepCtx.input,
-        run: stepCtx.run,
-        requestContext: stepCtx.requestContext,
-        invokeChild: stepCtx.invokeChild,
-        setMetadata: stepCtx.setMetadata,
-        step: stepCtx.step,
-        agentEvents: stepCtx.agentEvents,
-        checkpoint: stepCtx.checkpoint,
-        pause: stepCtx.pause,
-        sleep: stepCtx.sleep,
-        waitForEvent: stepCtx.waitForEvent,
-        processors: metadata.processors ?? []
-      };
-      const sandbox = stepCtx.sandbox;
-      if (!sandbox)
-        throw new Error("legacy run-form workflow requires a sandbox in StepContext");
-      return def.run(workflowCtx, sandbox);
+function boundProcessorPause(boundary, scope) {
+  return (req) => {
+    if (!boundary) {
+      return Promise.reject(new PauseRequestError("ctx.pause is unavailable here: no pause boundary is wired (a processor can " + "only pause inside a sandboxed workflow step, not in a local/unit-test run)"));
     }
+    return boundary(req, scope);
   };
-  const workflow = {
-    id: "@run-form",
-    input: inputSchema,
-    output: outputSchema,
-    steps: Object.freeze([step]),
-    metadata
-  };
-  Object.defineProperty(workflow, WORKFLOW_BRAND, { value: true, enumerable: false });
-  return Object.freeze(workflow);
 }
-function defineWorkflow(def) {
-  if ("run" in def)
-    return compileRunForm(def, extractMetadata(def));
-  return createStepWorkflow(def);
+var PAUSE_NAMESPACE = "5f3e2b8a-0c41-4e9d-9a7b-6d2c1f8e3a40";
+function uuidToBytes(uuid) {
+  return Buffer.from(uuid.replace(/-/g, ""), "hex");
 }
-// src/types/sandbox-environment.ts
-function defineSandboxEnvironment(env) {
-  if (typeof env.setup !== "function") {
-    throw new Error(`defineSandboxEnvironment(${env.name}): 'setup' must be a function`);
-  }
-  return defineWorkflow({
-    ...env.description !== undefined ? { description: env.description } : {},
-    snapshots: env.snapshots ?? { saveLatest: true },
-    run: async (_ctx, sandbox) => env.setup(sandbox)
-  });
+function bytesToUuid(b) {
+  const h = b.toString("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
 }
-// src/processors/processor.ts
-var Verdict = {
-  continue: (value) => ({ kind: "continue", value }),
-  deny: (reason) => ({ kind: "deny", reason }),
-  abort: (reason) => ({ kind: "abort", reason })
-};
-// src/processors/builtins.ts
-function denyTools(names) {
-  const banned = new Set(names);
-  return {
-    name: "denyTools",
-    processToolCall: (call) => banned.has(call.toolName) ? Verdict.deny(`tool "${call.toolName}" is denied by policy`) : Verdict.continue(call)
-  };
+function uuidv5(name, namespace) {
+  const hash = createHash("sha1").update(uuidToBytes(namespace)).update(Buffer.from(name, "utf8")).digest();
+  const bytes = Buffer.from(hash.subarray(0, 16));
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  return bytesToUuid(bytes);
 }
-function requireScope(required) {
-  return {
-    name: "requireScope",
-    processInput: (prompt, ctx) => {
-      const missing = required.filter((s) => !ctx.requestContext.hasScope(s));
-      return missing.length === 0 ? Verdict.continue(prompt) : Verdict.abort(`API key is missing required scopes: ${missing.join(", ")}`);
-    }
-  };
+function scopeOf(coord) {
+  return coord.agentScope ? `${coord.runId}:${coord.stepIndex}:${coord.agentScope.agentId}:${coord.agentScope.iteration}` : `${coord.runId}:${coord.stepIndex}:bare`;
 }
-function redactPattern(pattern, replacement = "[REDACTED]") {
-  return {
-    name: "redactPattern",
-    processOutput: (message) => {
-      if (message.type === "text" || message.type === "thinking") {
-        const redacted = message.text.replace(pattern, replacement);
-        if (redacted !== message.text) {
-          return Verdict.continue({ ...message, text: redacted });
-        }
-      }
-      return Verdict.continue(message);
+var pauseOrdinalByScope = new Map;
+function nextPauseOrdinal(scope) {
+  const activeOrdinal = nextPauseOrdinalInActiveStep(scope);
+  if (activeOrdinal !== null)
+    return activeOrdinal;
+  const next = pauseOrdinalByScope.get(scope) ?? 0;
+  pauseOrdinalByScope.set(scope, next + 1);
+  return next;
+}
+function nextPauseId(coord) {
+  const scope = scopeOf(coord);
+  const ordinal = nextPauseOrdinal(scope);
+  return uuidv5(`${scope}:${ordinal}`, PAUSE_NAMESPACE);
+}
+function nonJsonPath(value, path = "$", seen = new Set) {
+  if (value === null)
+    return null;
+  const kind = typeof value;
+  if (kind === "string" || kind === "boolean")
+    return null;
+  if (kind === "number")
+    return Number.isFinite(value) ? null : path;
+  if (kind === "undefined" || kind === "bigint" || kind === "function" || kind === "symbol")
+    return path;
+  if (kind !== "object")
+    return path;
+  const obj = value;
+  if (seen.has(obj))
+    return path;
+  seen.add(obj);
+  if (Array.isArray(value)) {
+    for (let i = 0;i < value.length; i++) {
+      const child = nonJsonPath(value[i], `${path}[${i}]`, seen);
+      if (child)
+        return child;
     }
-  };
+    seen.delete(obj);
+    return null;
+  }
+  const proto = Object.getPrototypeOf(obj);
+  if (proto !== Object.prototype && proto !== null)
+    return path;
+  for (const key of Reflect.ownKeys(obj)) {
+    if (typeof key !== "string")
+      return `${path}.${String(key)}`;
+    const desc = Object.getOwnPropertyDescriptor(obj, key);
+    if (!desc?.enumerable)
+      return `${path}.${key}`;
+    const child = nonJsonPath(value[key], `${path}.${key}`, seen);
+    if (child)
+      return child;
+  }
+  seen.delete(obj);
+  return null;
 }
-// src/client.ts
-import { ofetch } from "ofetch";
-
-// src/errors.ts
-class AgentComposeError extends Error {
-  status;
-  constructor(status, message) {
-    super(message);
-    this.status = status;
-    this.name = "AgentComposeError";
+function toWireRequest(req, kind) {
+  const wire = {
+    reason: req.reason,
+    kind,
+    ...req.payload !== undefined ? { payload: req.payload } : {},
+    ...req.ttlMs !== undefined ? { ttlMs: req.ttlMs } : {},
+    ...req.correlationKey !== undefined ? { correlationKey: req.correlationKey } : {},
+    ...req.snapshot !== undefined ? { snapshot: req.snapshot } : {}
+  };
+  const parsed = StepPauseRequestSchema.safeParse(wire);
+  if (!parsed.success) {
+    throw new PauseRequestError(`pause request failed validation: ${parsed.error.message}`);
+  }
+  const badPath = nonJsonPath(parsed.data);
+  if (badPath) {
+    throw new PauseRequestError(`pause request must be JSON-serializable (invalid value at ${badPath})`);
   }
+  return parsed.data;
 }
-
-// src/sse.ts
-async function* parseSseStream(body) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder;
-  let buffer = "";
-  let event = "";
-  let seq = 0;
-  let dataLines = [];
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split(`
-`);
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        if (line.startsWith("id:")) {
-          seq = Number(line.slice(3).trim());
-          continue;
-        }
-        if (line.startsWith("event:")) {
-          event = line.slice(6).trim();
-          continue;
-        }
-        if (line.startsWith("data:")) {
-          dataLines.push(line.slice(5).trim());
-          continue;
-        }
-        if (line === "" && dataLines.length > 0) {
-          let data;
-          try {
-            data = JSON.parse(dataLines.join(`
-`));
-          } catch (err) {
-            throw new Error(`Malformed SSE JSON payload for event "${event || "message"}": ${err instanceof Error ? err.message : String(err)}`);
-          }
-          yield { id: seq, event, data };
-          event = "";
-          seq = 0;
-          dataLines = [];
-        }
-      }
+async function corePause(req, coord, kind = "custom") {
+  const wire = toWireRequest(req, kind);
+  const pauseId = nextPauseId(coord);
+  const record = await readPauseRecord(pauseId);
+  if (record === null || record.resolved !== true) {
+    await writePauseRecord({ pauseId, request: wire });
+    throw new PauseSignal(pauseId, wire);
+  }
+  if (record.expired === true) {
+    const onExpiry = req.onExpiry ?? { mode: "throw" };
+    if (onExpiry.mode === "resolve")
+      return onExpiry.value;
+    throw new PauseExpiredError(`pause "${req.reason}" expired before it was resolved`);
+  }
+  const payload = record.resumePayload ?? null;
+  if (req.schema) {
+    const parsed = req.schema.safeParse(payload);
+    if (!parsed.success) {
+      throw new PauseSchemaError(`resume payload for pause "${req.reason}" failed schema validation: ${parsed.error.message}`, parsed.error.issues);
     }
-  } finally {
-    reader.releaseLock();
+    return parsed.data;
   }
+  return payload;
 }
 
-// src/client.ts
-var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var DEFAULT_FACTORY = "default";
-function detectAmbientParentRunId() {
-  const envRunId = typeof process !== "undefined" ? process.env?.RUN_ID : undefined;
-  return envRunId && UUID_REGEX.test(envRunId) ? envRunId : null;
+// src/utils/errors.ts
+function formatError(err) {
+  return err instanceof Error ? err.message : String(err);
 }
-function templatePath(factorySlug, ...rest) {
-  const tail = rest.length > 0 ? "/" + rest.map(encodeURIComponent).join("/") : "";
-  return `/api/v1/factories/${encodeURIComponent(factorySlug)}/templates${tail}`;
+
+// src/runtimes/vercel.ts
+function now() {
+  return new Date().toISOString();
 }
-var PUBLIC_API_HOST = "https://api.agentcompose.ai";
-function steerAnswerPayload(message, actor) {
-  if (typeof message !== "string" || message.trim().length === 0) {
-    throw new Error("answerSteer: `message` must be a non-empty string");
-  }
-  return { message, ...actor !== undefined ? { actor } : {} };
+function serialiseOutput(value) {
+  return typeof value === "string" ? value : JSON.stringify(value ?? "");
 }
-
-class AgentComposeClient {
-  fetch;
-  baseUrl;
-  apiKey;
-  constructor(options = {}) {
-    const apiKey = options.apiKey ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_API_KEY : undefined) ?? "";
-    if (!apiKey) {
-      throw new Error("AgentComposeClient: `apiKey` is required. Pass it as `{ apiKey }` " + "or set the AGENT_COMPOSE_API_KEY env var.");
-    }
-    const baseUrl = options.baseUrl ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_URL : undefined) ?? PUBLIC_API_HOST;
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.apiKey = apiKey;
-    this.fetch = ofetch.create({
-      baseURL: this.baseUrl,
-      headers: { Authorization: `Bearer ${apiKey}` },
-      async onResponseError({ response }) {
-        const body = response._data;
-        throw new AgentComposeError(response.status, body?.error ?? response.statusText);
-      }
-    });
-  }
-  register(payload) {
-    const { factorySlug = DEFAULT_FACTORY, ...body } = payload;
-    return this.fetch(templatePath(factorySlug), { method: "POST", body });
-  }
-  invoke(name, input, opts) {
-    const parentRunId = opts?.parentRunId === undefined ? detectAmbientParentRunId() : opts.parentRunId;
-    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
-    const headers = {};
-    if (opts?.idempotencyKey)
-      headers["Idempotency-Key"] = opts.idempotencyKey;
-    return this.fetch(templatePath(factorySlug, name, "invoke"), {
-      method: "POST",
-      ...opts?.idempotencyKey ? { headers } : {},
-      body: {
-        input,
-        ...opts?.snapshots !== undefined ? { snapshots: opts.snapshots } : {},
-        ...opts?.networkPolicy !== undefined ? { networkPolicy: opts.networkPolicy } : {},
-        ...opts?.placeholders !== undefined ? { placeholders: opts.placeholders } : {},
-        ...opts?.size !== undefined ? { size: opts.size } : {},
-        ...parentRunId ? { parentRunId } : {},
-        ...opts?.agentId ? { agentId: opts.agentId } : {}
-      }
-    });
-  }
-  async invokeAndWait(name, input, opts) {
-    const timeoutMs = opts?.timeoutMs ?? 30 * 60 * 1000;
-    const pollMs = opts?.pollIntervalMs ?? 1000;
-    const { id: runId } = await this.invoke(name, input, opts);
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      const status = await this.getStatus(runId);
-      if (status.status === "success" || status.status === "failed" || status.status === "abandoned") {
-        return status;
-      }
-      await new Promise((r) => setTimeout(r, pollMs));
-    }
-    throw new AgentComposeError(504, `invokeAndWait: run ${runId} did not settle within ${timeoutMs}ms`);
-  }
-  async listSnapshots(opts) {
-    const body = await this.listSnapshotsPage(opts);
-    return body.data;
-  }
-  async listSnapshotsPage(opts) {
-    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
-    const q2 = new URLSearchParams;
-    if (opts?.workflow)
-      q2.set("workflow", opts.workflow);
-    if (opts?.limit != null)
-      q2.set("limit", String(opts.limit));
-    if (opts?.before)
-      q2.set("before", opts.before);
-    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/snapshots${q2.toString() ? `?${q2}` : ""}`);
+function toAgentMessages(part) {
+  const ts = now();
+  switch (part.type) {
+    case "text-delta":
+    case "text":
+      return [{ type: "text", text: String(part.text ?? ""), timestamp: ts }];
+    case "reasoning-delta":
+    case "reasoning":
+      return [{ type: "thinking", text: String(part.text ?? ""), timestamp: ts }];
+    case "tool-call":
+      return [{
+        type: "tool_use",
+        toolName: String(part.toolName ?? ""),
+        toolInput: part.input ?? {},
+        toolUseId: String(part.toolCallId ?? ""),
+        timestamp: ts
+      }];
+    case "tool-result":
+      return [{
+        type: "tool_result",
+        toolUseId: String(part.toolCallId ?? ""),
+        output: serialiseOutput(part.output),
+        isError: false,
+        timestamp: ts
+      }];
+    case "tool-error":
+      return [{
+        type: "tool_result",
+        toolUseId: String(part.toolCallId ?? ""),
+        output: formatError(part.error),
+        isError: true,
+        timestamp: ts
+      }];
+    case "error":
+      return [{ type: "error", text: formatError(part.error), timestamp: ts }];
+    default:
+      return [];
   }
-  deleteSnapshot(runId) {
-    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/snapshot`, { method: "DELETE" });
+}
+
+class VercelRunner {
+  sandbox;
+  options;
+  config;
+  supportsToolCallProcessor = true;
+  kind;
+  model;
+  tools;
+  messages = [];
+  constructor(sandbox, options, config) {
+    this.sandbox = sandbox;
+    this.options = options;
+    this.config = config;
+    this.tools = config.tools ?? codingTools;
+    this.kind = config.kind;
+    this.model = config.modelId;
   }
-  async listRunSnapshots(runId) {
-    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/snapshots`);
-    return body.data;
+  async gateToolCall(call, ctx) {
+    const verdict = await runProcessorChain(this.options.processors ?? [], (p) => p.processToolCall, call, ctx);
+    if (verdict.kind === "continue")
+      return { kind: "allow", call: verdict.value };
+    return verdict;
   }
-  deleteRunSnapshot(runId, snapshotId) {
-    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/snapshots/${encodeURIComponent(snapshotId)}`, { method: "DELETE" });
+  captureCheckpoint() {
+    return { messages: [...this.messages] };
   }
-  getStatus(runId) {
-    return this.fetch(`/api/v1/workflows/${runId}/status`);
+  restoreCheckpoint(blob) {
+    if (!blob || typeof blob !== "object") {
+      throw new Error("Vercel runtime checkpoint is invalid: expected an object with messages[]");
+    }
+    const incoming = blob.messages;
+    if (!Array.isArray(incoming)) {
+      throw new Error("Vercel runtime checkpoint is invalid: expected messages[]");
+    }
+    this.messages.length = 0;
+    this.messages.push(...incoming);
   }
-  async resumePause(runId, pauseId, payload, opts) {
-    const headers = {};
-    if (opts?.idempotencyKey)
-      headers["Idempotency-Key"] = opts.idempotencyKey;
-    return this.fetch(`/api/v1/runs/${encodeURIComponent(runId)}/pauses/${encodeURIComponent(pauseId)}/resume`, {
-      method: "POST",
-      body: { resumePayload: payload },
-      ...Object.keys(headers).length ? { headers } : {},
-      ...opts?.signal ? { signal: opts.signal } : {}
-    });
+  buildTools(iteration, signal) {
+    const set = {};
+    for (const t of this.tools) {
+      if (this.options.allowedTools && !this.options.allowedTools.includes(t.name))
+        continue;
+      set[t.name] = tool({
+        description: t.description,
+        inputSchema: t.inputSchema,
+        execute: async (input, execOpts) => {
+          const call = {
+            toolName: t.name,
+            toolInput: input,
+            toolUseId: execOpts.toolCallId ?? `${t.name}-${Date.now()}`
+          };
+          const requestContext = this.options.requestContext ?? RequestContext.fromReserved({
+            teamId: "",
+            runId: "",
+            workflowId: "",
+            factoryId: null,
+            apiKeyScopes: [],
+            parentRunId: null
+          });
+          const gateAgentId = this.options.agentId ?? "agent";
+          const gate = await this.gateToolCall(call, {
+            requestContext,
+            abortSignal: execOpts.abortSignal ?? signal ?? new AbortController().signal,
+            retryCount: 0,
+            agentId: gateAgentId,
+            iteration,
+            pause: boundProcessorPause(this.options.pause, { agentId: gateAgentId, iteration })
+          });
+          if (gate.kind === "deny")
+            return gate.reason;
+          if (gate.kind === "abort")
+            throw new Error(gate.reason);
+          return t.execute(gate.call.toolInput, {
+            sandbox: this.sandbox,
+            cwd: this.options.cwd,
+            abortSignal: execOpts.abortSignal ?? signal
+          });
+        }
+      });
+    }
+    return set;
   }
-  async resumePauseByKey(runId, correlationKey, payload, opts) {
-    const headers = {};
-    if (opts?.idempotencyKey)
-      headers["Idempotency-Key"] = opts.idempotencyKey;
-    return this.fetch(`/api/v1/runs/${encodeURIComponent(runId)}/pauses/by-key/${encodeURIComponent(correlationKey)}/resume`, {
-      method: "POST",
-      body: { resumePayload: payload },
-      ...Object.keys(headers).length ? { headers } : {},
-      ...opts?.signal ? { signal: opts.signal } : {}
+  async* sendMessage(opts) {
+    const sessionId = opts.sessionId ?? `vercel-${Date.now()}`;
+    yield { type: "init", sessionId, timestamp: now() };
+    const inputMessages = [...this.messages, { role: "user", content: opts.prompt }];
+    const result = streamText({
+      model: this.config.model,
+      ...this.config.system ? { system: this.config.system } : {},
+      messages: inputMessages,
+      tools: this.buildTools(opts.iteration ?? 1, opts.signal),
+      stopWhen: stepCountIs(this.options.maxTurns ?? 40),
+      abortSignal: opts.signal
     });
+    try {
+      for await (const part of result.fullStream) {
+        for (const msg of toAgentMessages(part))
+          yield msg;
+      }
+      const response = await result.response;
+      const responseMessages = response.messages;
+      if (responseMessages) {
+        this.messages.length = 0;
+        this.messages.push(...responseMessages);
+      }
+      let usage;
+      try {
+        usage = await result.usage;
+      } catch {
+        usage = undefined;
+      }
+      if (usage) {
+        yield {
+          type: "usage",
+          inputTokens: usage.inputTokens ?? 0,
+          outputTokens: usage.outputTokens ?? 0,
+          cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+          cacheCreationTokens: usage.inputTokenDetails?.cacheWriteTokens ?? 0,
+          durationMs: 0,
+          numTurns: opts.iteration ?? 1,
+          timestamp: now()
+        };
+      }
+    } catch (err) {
+      yield { type: "error", text: formatError(err), timestamp: now() };
+      return;
+    }
+    yield { type: "done", sessionId, timestamp: now() };
   }
-  async answerSteerByKey(runId, correlationKey, message, opts) {
-    return this.resumePauseByKey(runId, correlationKey, steerAnswerPayload(message, opts?.actor), opts);
-  }
-  async answerSteer(runId, pauseId, message, opts) {
-    return this.resumePause(runId, pauseId, steerAnswerPayload(message, opts?.actor), opts);
+}
+function createVercelRuntime(config) {
+  return defineRuntime({
+    create: (sandbox, opts) => new VercelRunner(sandbox, opts, config)
+  });
+}
+async function listVercelRuntimeModels() {
+  const { models } = await gateway.getAvailableModels();
+  return models.filter((m) => m.modelType == null || m.modelType === "language").map((m) => ({ id: m.id, name: m.name })).sort((a, b) => a.id.localeCompare(b.id));
+}
+// src/types/workflow.ts
+import { z as z4 } from "zod";
+
+// src/workflow-steps/types.ts
+var WORKFLOW_BRAND = Symbol.for("@agent-compose/sdk.Workflow");
+
+// src/types/workflow-metadata.ts
+function extractMetadata(source) {
+  const out = {};
+  if (source.description !== undefined)
+    out.description = source.description;
+  if (source.networkPolicy !== undefined)
+    out.networkPolicy = freezeMetadataValue(source.networkPolicy);
+  if (source.placeholders !== undefined)
+    out.placeholders = Object.freeze({ ...source.placeholders });
+  if (source.inputSchema !== undefined)
+    out.inputSchema = freezeMetadataValue(source.inputSchema);
+  if (source.outputSchema !== undefined)
+    out.outputSchema = freezeMetadataValue(source.outputSchema);
+  if (source.snapshots !== undefined)
+    out.snapshots = Object.freeze({ ...source.snapshots });
+  if (source.resources !== undefined)
+    out.resources = Object.freeze({ ...source.resources });
+  if (source.processors !== undefined)
+    out.processors = Object.freeze([...source.processors]);
+  if (source.connectors !== undefined)
+    out.connectors = freezeMetadataValue(source.connectors);
+  if (source.connectorOperation !== undefined)
+    out.connectorOperation = Object.freeze({ ...source.connectorOperation });
+  if (source.invokePolicy !== undefined)
+    out.invokePolicy = freezeMetadataValue(source.invokePolicy);
+  if (source.environmentBuild !== undefined)
+    out.environmentBuild = source.environmentBuild;
+  return Object.freeze(out);
+}
+function freezeMetadataValue(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Array.isArray(value)) {
+    for (const v of value)
+      freezeMetadataValue(v);
+    return Object.freeze(value);
   }
-  async requestAgentPause(runId, agentId, opts) {
-    const body = {};
-    if (opts?.reason !== undefined)
-      body.reason = opts.reason;
-    if (opts?.correlationKey !== undefined)
-      body.correlationKey = opts.correlationKey;
-    return this.fetch(`/api/v1/runs/${encodeURIComponent(runId)}/agents/${encodeURIComponent(agentId)}/pause`, {
-      method: "POST",
-      body,
-      ...opts?.signal ? { signal: opts.signal } : {}
-    });
+  for (const v of Object.values(value)) {
+    freezeMetadataValue(v);
   }
-  async sendAgentMessage(runId, agentId, message, opts) {
-    const body = { message };
-    if (opts?.senderName !== undefined)
-      body.senderName = opts.senderName;
-    return this.fetch(`/api/v1/runs/${encodeURIComponent(runId)}/agents/${encodeURIComponent(agentId)}/messages`, {
-      method: "POST",
-      body,
-      ...opts?.signal ? { signal: opts.signal } : {}
-    });
+  return Object.freeze(value);
+}
+
+// src/workflow-steps/workflow.ts
+function createStepWorkflow(opts) {
+  if (!opts.id)
+    throw new Error("defineWorkflow: 'id' is required for step-based workflows");
+  const build = (steps) => ({
+    step(step) {
+      return build([...steps, step]);
+    },
+    build() {
+      if (steps.length === 0) {
+        throw new Error(`defineWorkflow("${opts.id}").build: no steps registered — add at least one with .step(step)`);
+      }
+      const finalStep = steps[steps.length - 1];
+      if (finalStep.output !== opts.output) {
+        throw new Error(`defineWorkflow("${opts.id}").build: final step "${finalStep.name}" output schema is not the same Zod schema instance as the workflow's declared output schema. ` + `Pass the same schema reference to both the final step and defineWorkflow.`);
+      }
+      const workflow = {
+        id: opts.id,
+        input: opts.input,
+        output: opts.output,
+        steps: Object.freeze([...steps]),
+        metadata: extractMetadata(opts)
+      };
+      Object.defineProperty(workflow, WORKFLOW_BRAND, { value: true, enumerable: false });
+      return Object.freeze(workflow);
+    }
+  });
+  return build([]);
+}
+function isWorkflow(value) {
+  return typeof value === "object" && value !== null && value[WORKFLOW_BRAND] === true;
+}
+
+// src/types/workflow.ts
+function compileRunForm(def, metadata) {
+  const unknownSchema = z4.unknown();
+  const inputSchema = def.input ?? unknownSchema;
+  const outputSchema = def.output ?? unknownSchema;
+  const step = {
+    name: "run",
+    input: inputSchema,
+    output: outputSchema,
+    run: async (stepCtx) => {
+      const workflowCtx = {
+        input: stepCtx.input,
+        run: stepCtx.run,
+        requestContext: stepCtx.requestContext,
+        invokeChild: stepCtx.invokeChild,
+        setMetadata: stepCtx.setMetadata,
+        step: stepCtx.step,
+        agentEvents: stepCtx.agentEvents,
+        pause: stepCtx.pause,
+        sleep: stepCtx.sleep,
+        waitForEvent: stepCtx.waitForEvent,
+        processors: metadata.processors ?? []
+      };
+      const sandbox = stepCtx.sandbox;
+      if (!sandbox)
+        throw new Error("legacy run-form workflow requires a sandbox in StepContext");
+      return def.run(workflowCtx, sandbox);
+    }
+  };
+  const workflow = {
+    id: "@run-form",
+    input: inputSchema,
+    output: outputSchema,
+    steps: Object.freeze([step]),
+    metadata
+  };
+  Object.defineProperty(workflow, WORKFLOW_BRAND, { value: true, enumerable: false });
+  return Object.freeze(workflow);
+}
+function defineWorkflow(def) {
+  if ("run" in def)
+    return compileRunForm(def, extractMetadata(def));
+  return createStepWorkflow(def);
+}
+// src/types/sandbox-environment.ts
+function defineSandboxEnvironment(env) {
+  if (typeof env.setup !== "function") {
+    throw new Error(`defineSandboxEnvironment(${env.name}): 'setup' must be a function`);
   }
-  getRun(runId) {
-    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}`);
+  return defineWorkflow({
+    ...env.description !== undefined ? { description: env.description } : {},
+    ...env.resources !== undefined ? { resources: env.resources } : {},
+    snapshots: env.snapshots ?? { saveLatest: true },
+    environmentBuild: true,
+    run: async (_ctx, sandbox) => env.setup(sandbox)
+  });
+}
+// src/processors/processor.ts
+var Verdict = {
+  continue: (value) => ({ kind: "continue", value }),
+  deny: (reason) => ({ kind: "deny", reason }),
+  abort: (reason) => ({ kind: "abort", reason })
+};
+// src/processors/builtins.ts
+import { z as z5 } from "zod";
+function denyTools(names) {
+  const banned = new Set(names);
+  return {
+    name: "denyTools",
+    processToolCall: (call) => banned.has(call.toolName) ? Verdict.deny(`tool "${call.toolName}" is denied by policy`) : Verdict.continue(call)
+  };
+}
+var ApprovalDecision = z5.object({
+  approved: z5.boolean(),
+  reason: z5.string().optional()
+});
+function humanApproval(opts) {
+  const gated = opts?.tools ? new Set(opts.tools) : null;
+  return {
+    name: "humanApproval",
+    async processToolCall(call, ctx) {
+      if (gated && !gated.has(call.toolName))
+        return Verdict.continue(call);
+      const decision = await ctx.pause({
+        reason: opts?.reason?.(call) ?? `Approve tool call: ${call.toolName}`,
+        payload: { tool: call.toolName, input: call.toolInput, toolUseId: call.toolUseId },
+        schema: ApprovalDecision
+      });
+      return decision.approved ? Verdict.continue(call) : Verdict.deny(decision.reason ?? `tool "${call.toolName}" denied by human reviewer`);
+    }
+  };
+}
+function requireScope(required) {
+  return {
+    name: "requireScope",
+    processInput: (prompt, ctx) => {
+      const missing = required.filter((s) => !ctx.requestContext.hasScope(s));
+      return missing.length === 0 ? Verdict.continue(prompt) : Verdict.abort(`API key is missing required scopes: ${missing.join(", ")}`);
+    }
+  };
+}
+function redactPattern(pattern, replacement = "[REDACTED]") {
+  return {
+    name: "redactPattern",
+    processOutput: (message) => {
+      if (message.type === "text" || message.type === "thinking") {
+        const redacted = message.text.replace(pattern, replacement);
+        if (redacted !== message.text) {
+          return Verdict.continue({ ...message, text: redacted });
+        }
+      }
+      return Verdict.continue(message);
+    }
+  };
+}
+// src/agent/pause-client.ts
+var isAbort = (signal) => Boolean(signal?.aborted);
+async function requestPauseAndAwait(opts, fetchImpl = fetch) {
+  const base = opts.baseUrl.replace(/\/+$/, "");
+  const headers = {
+    authorization: `Bearer ${opts.token}`,
+    "content-type": "application/json",
+    accept: "application/json"
+  };
+  const createRes = await fetchImpl(`${base}/api/v1/runs/${opts.runId}/pauses`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      reason: opts.reason,
+      ...opts.ttlMs !== undefined ? { ttlMs: opts.ttlMs } : {},
+      ...opts.options ? { options: opts.options } : {},
+      ...opts.action ? { action: opts.action } : {},
+      ...opts.correlationKey ? { correlationKey: opts.correlationKey } : {}
+    }),
+    ...opts.signal ? { signal: opts.signal } : {}
+  });
+  if (!createRes.ok) {
+    const text = await createRes.text().catch(() => "");
+    throw new Error(`pause create failed (${createRes.status}): ${text.slice(0, 300)}`);
   }
-  async getRunTimeline(runId, opts) {
-    const q2 = new URLSearchParams;
-    if (opts?.limit !== undefined)
-      q2.set("limit", String(opts.limit));
-    if (opts?.offset !== undefined)
-      q2.set("offset", String(opts.offset));
-    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/timeline${q2.toString() ? `?${q2}` : ""}`);
-    return body.events;
+  const { pauseId } = await createRes.json();
+  const pollUrl = `${base}/api/v1/runs/${opts.runId}/pauses/${pauseId}`;
+  let backoffMs = 0;
+  for (;; ) {
+    if (isAbort(opts.signal))
+      throw new Error("pause wait aborted");
+    if (backoffMs > 0)
+      await new Promise((r) => setTimeout(r, backoffMs));
+    let res;
+    try {
+      res = await fetchImpl(pollUrl, { method: "GET", headers, ...opts.signal ? { signal: opts.signal } : {} });
+    } catch (err) {
+      if (isAbort(opts.signal))
+        throw err;
+      backoffMs = Math.min(8000, (backoffMs || 500) * 2);
+      continue;
+    }
+    if (!res.ok) {
+      backoffMs = Math.min(8000, (backoffMs || 500) * 2);
+      continue;
+    }
+    backoffMs = 0;
+    const body = await res.json();
+    if (body.status === "pending")
+      continue;
+    return { status: body.status, decision: body.resumePayload ?? null };
   }
-  async reportEvent(runId, input) {
-    const body = {
-      ...input,
-      ...input.timestamp instanceof Date ? { timestamp: input.timestamp.toISOString() } : {}
-    };
-    const response = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/events`, {
-      method: "POST",
-      body
-    });
-    return response.event;
+}
+
+// src/processors/gate-pause.ts
+var DENY_ANSWERS = new Set(["deny", "no", "reject", "decline", "block"]);
+function answerText(decision) {
+  const raw = decision !== null && typeof decision === "object" && "decision" in decision ? decision.decision : decision;
+  return typeof raw === "string" ? raw.trim() : raw == null ? "" : JSON.stringify(raw);
+}
+function createGatePauseProcessor(opts) {
+  return {
+    name: "gate-pause",
+    async processToolCall(call, ctx) {
+      const approval = await opts.policy(call, ctx);
+      if (!approval)
+        return Verdict.continue(call);
+      const conn = opts.connection ?? {
+        baseUrl: process.env.AGENT_COMPOSE_URL ?? "",
+        token: process.env.AGENT_COMPOSE_RUN_TOKEN ?? "",
+        runId: process.env.RUN_ID ?? ""
+      };
+      if (!conn.baseUrl || !conn.token || !conn.runId)
+        return Verdict.continue(call);
+      const decision = await requestPauseAndAwait({
+        baseUrl: conn.baseUrl,
+        token: conn.token,
+        runId: conn.runId,
+        reason: approval.reason,
+        action: { tool: call.toolName, input: call.toolInput },
+        options: approval.options ?? [{ id: "approve", label: "Approve" }, { id: "deny", label: "Deny" }],
+        signal: ctx.abortSignal
+      });
+      const answer = answerText(decision.decision);
+      if (decision.status === "resolved" && !DENY_ANSWERS.has(answer.toLowerCase())) {
+        return Verdict.continue(call);
+      }
+      const why = decision.status === "resolved" ? `denied: ${answer}` : `${decision.status} with no approval`;
+      return Verdict.deny(`Human ${why}. Tool "${call.toolName}" was not run — adjust course or ask again.`);
+    }
+  };
+}
+// src/client.ts
+import { ofetch } from "ofetch";
+
+// src/errors.ts
+class AgentComposeError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "AgentComposeError";
   }
-  async listRunEvents(runId) {
-    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/events`);
-    return body.events;
+}
+
+// src/sse.ts
+async function* parseSseStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let event = "";
+  let seq = 0;
+  let dataLines = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.startsWith("id:")) {
+          seq = Number(line.slice(3).trim());
+          continue;
+        }
+        if (line.startsWith("event:")) {
+          event = line.slice(6).trim();
+          continue;
+        }
+        if (line.startsWith("data:")) {
+          dataLines.push(line.slice(5).trim());
+          continue;
+        }
+        if (line === "" && dataLines.length > 0) {
+          let data;
+          try {
+            data = JSON.parse(dataLines.join(`
+`));
+          } catch (err) {
+            throw new Error(`Malformed SSE JSON payload for event "${event || "message"}": ${err instanceof Error ? err.message : String(err)}`);
+          }
+          yield { id: seq, event, data };
+          event = "";
+          seq = 0;
+          dataLines = [];
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
   }
-  async listRunArtifacts(runId) {
-    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/artifacts`);
-    return body.artifacts.map((a) => ({
-      path: a.path,
-      factorySlug: a.factory_slug,
-      sizeBytes: a.size_bytes,
-      lastWriteAt: a.last_write_at,
-      preview: a.preview
-    }));
+}
+
+// src/client.ts
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var DEFAULT_FACTORY = "default";
+function detectAmbientParentRunId() {
+  const envRunId = typeof process !== "undefined" ? process.env?.RUN_ID : undefined;
+  return envRunId && UUID_REGEX.test(envRunId) ? envRunId : null;
+}
+function templatePath(factorySlug, ...rest) {
+  const tail = rest.length > 0 ? "/" + rest.map(encodeURIComponent).join("/") : "";
+  return `/api/v1/factories/${encodeURIComponent(factorySlug)}/templates${tail}`;
+}
+var PUBLIC_API_HOST = "https://api.agentcompose.ai";
+function steerAnswerPayload(message, actor) {
+  if (typeof message !== "string" || message.trim().length === 0) {
+    throw new Error("answerSteer: `message` must be a non-empty string");
   }
-  async putFactoryFile(path, content, opts) {
-    const factorySlug = opts?.factorySlug ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_FACTORY : undefined) ?? DEFAULT_FACTORY;
-    const runToken = typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_RUN_TOKEN : undefined;
-    const wire = await this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/content?path=${encodeURIComponent(path)}`, {
-      method: "PUT",
-      body: content,
-      headers: {
-        "content-type": opts?.contentType ?? "text/plain; charset=utf-8",
-        ...runToken ? { "x-run-token": runToken } : {}
+  return { message, ...actor !== undefined ? { actor } : {} };
+}
+
+class AgentComposeClient {
+  fetch;
+  baseUrl;
+  apiKey;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_API_KEY : undefined) ?? "";
+    if (!apiKey) {
+      throw new Error("AgentComposeClient: `apiKey` is required. Pass it as `{ apiKey }` " + "or set the AGENT_COMPOSE_API_KEY env var.");
+    }
+    const baseUrl = options.baseUrl ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_URL : undefined) ?? PUBLIC_API_HOST;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.apiKey = apiKey;
+    this.fetch = ofetch.create({
+      baseURL: this.baseUrl,
+      headers: { Authorization: `Bearer ${apiKey}` },
+      async onResponseError({ response }) {
+        const body = response._data;
+        throw new AgentComposeError(response.status, body?.error ?? response.statusText);
       }
     });
-    return {
-      path: wire.path,
-      contentHash: wire.content_hash,
-      sizeBytes: wire.size_bytes,
-      created: wire.created
-    };
-  }
-  async getFactoryFile(path, opts) {
-    const factorySlug = opts?.factorySlug ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_FACTORY : undefined) ?? DEFAULT_FACTORY;
-    const q2 = new URLSearchParams({ path });
-    if (opts?.revision !== undefined)
-      q2.set("revision", String(opts.revision));
-    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/content?${q2}`, { responseType: "text" });
   }
-  async listMembers() {
-    const body = await this.fetch("/api/v1/team/members");
-    return body.members;
+  register(payload) {
+    const { factorySlug = DEFAULT_FACTORY, ...body } = payload;
+    return this.fetch(templatePath(factorySlug), { method: "POST", body });
   }
-  async createMentions(input) {
-    const factorySlug = input.factorySlug ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_FACTORY : undefined) ?? DEFAULT_FACTORY;
-    const runToken = typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_RUN_TOKEN : undefined;
-    const { factorySlug: _omit, ...payload } = input;
-    const body = await this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/mentions`, {
+  invoke(name, input, opts) {
+    const parentRunId = opts?.parentRunId === undefined ? detectAmbientParentRunId() : opts.parentRunId;
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    const headers = {};
+    if (opts?.idempotencyKey)
+      headers["Idempotency-Key"] = opts.idempotencyKey;
+    return this.fetch(templatePath(factorySlug, name, "invoke"), {
       method: "POST",
-      body: payload,
-      ...runToken ? { headers: { "x-run-token": runToken } } : {}
+      ...opts?.idempotencyKey ? { headers } : {},
+      body: {
+        input,
+        ...opts?.snapshots !== undefined ? { snapshots: opts.snapshots } : {},
+        ...opts?.networkPolicy !== undefined ? { networkPolicy: opts.networkPolicy } : {},
+        ...opts?.placeholders !== undefined ? { placeholders: opts.placeholders } : {},
+        ...opts?.size !== undefined ? { size: opts.size } : {},
+        ...parentRunId ? { parentRunId } : {},
+        ...opts?.agentId ? { agentId: opts.agentId } : {}
+      }
     });
-    return body.mentions;
   }
-  async listFactoryEvents(opts) {
+  async invokeAndWait(name, input, opts) {
+    const timeoutMs = opts?.timeoutMs ?? 30 * 60 * 1000;
+    const pollMs = opts?.pollIntervalMs ?? 1000;
+    const { id: runId } = await this.invoke(name, input, opts);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const status = await this.getStatus(runId);
+      if (status.status === "success" || status.status === "failed" || status.status === "abandoned") {
+        return status;
+      }
+      await new Promise((r) => setTimeout(r, pollMs));
+    }
+    throw new AgentComposeError(504, `invokeAndWait: run ${runId} did not settle within ${timeoutMs}ms`);
+  }
+  async listSnapshots(opts) {
+    const body = await this.listSnapshotsPage(opts);
+    return body.data;
+  }
+  async listSnapshotsPage(opts) {
     const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
     const q2 = new URLSearchParams;
+    if (opts?.workflow)
+      q2.set("workflow", opts.workflow);
     if (opts?.limit != null)
       q2.set("limit", String(opts.limit));
-    if (opts?.name)
-      q2.set("name", opts.name);
-    if (opts?.from)
-      q2.set("from", opts.from);
     if (opts?.before)
       q2.set("before", opts.before);
-    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/events${q2.toString() ? `?${q2}` : ""}`);
-  }
-  async listRunLogs(runId, opts) {
-    const q2 = new URLSearchParams;
-    if (opts?.afterId !== undefined)
-      q2.set("afterId", String(opts.afterId));
-    if (opts?.limit !== undefined)
-      q2.set("limit", String(opts.limit));
-    if (opts?.direction !== undefined)
-      q2.set("direction", opts.direction);
-    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/logs${q2.toString() ? `?${q2}` : ""}`);
-    return body.logs;
-  }
-  async listTemplates(opts) {
-    const path = opts?.factorySlug ? templatePath(opts.factorySlug) : "/api/v1/templates";
-    const body = await this.fetch(path);
-    return body.templates;
-  }
-  async listFactories() {
-    const body = await this.fetch("/api/v1/factories");
-    return body.factories;
-  }
-  createFactory(payload) {
-    return this.fetch("/api/v1/factories", { method: "POST", body: payload });
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/snapshots${q2.toString() ? `?${q2}` : ""}`);
   }
-  getFactory(slug) {
-    return this.fetch(`/api/v1/factories/${encodeURIComponent(slug)}`);
+  deleteSnapshot(runId) {
+    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/snapshot`, { method: "DELETE" });
   }
-  updateFactory(slug, updates) {
-    return this.fetch(`/api/v1/factories/${encodeURIComponent(slug)}`, { method: "PATCH", body: updates });
+  async listRunSnapshots(runId) {
+    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/snapshots`);
+    return body.data;
   }
-  deleteFactory(slug) {
-    return this.fetch(`/api/v1/factories/${encodeURIComponent(slug)}`, { method: "DELETE" });
+  deleteRunSnapshot(runId, snapshotId) {
+    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/snapshots/${encodeURIComponent(snapshotId)}`, { method: "DELETE" });
   }
-  async listSchedules(factorySlug = "default") {
-    const body = await this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/schedules`);
-    return body.schedules;
+  getStatus(runId) {
+    return this.fetch(`/api/v1/workflows/${runId}/status`);
   }
-  createSchedule(payload) {
-    const factorySlug = payload.factorySlug ?? "default";
-    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/schedules`, {
+  async resumePause(runId, pauseId, payload, opts) {
+    const headers = {};
+    if (opts?.idempotencyKey)
+      headers["Idempotency-Key"] = opts.idempotencyKey;
+    return this.fetch(`/api/v1/runs/${encodeURIComponent(runId)}/pauses/${encodeURIComponent(pauseId)}/resume`, {
       method: "POST",
-      body: { name: payload.name, workflow: payload.workflow, cron: payload.cron }
+      body: { resumePayload: payload },
+      ...Object.keys(headers).length ? { headers } : {},
+      ...opts?.signal ? { signal: opts.signal } : {}
     });
   }
-  deleteSchedule(id, factorySlug = "default") {
-    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/schedules/${encodeURIComponent(id)}`, { method: "DELETE" });
-  }
-  setSecret(workflowName, key, value, opts) {
-    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
-    return this.fetch(templatePath(factorySlug, workflowName, "secrets"), {
+  async resumePauseByKey(runId, correlationKey, payload, opts) {
+    const headers = {};
+    if (opts?.idempotencyKey)
+      headers["Idempotency-Key"] = opts.idempotencyKey;
+    return this.fetch(`/api/v1/runs/${encodeURIComponent(runId)}/pauses/by-key/${encodeURIComponent(correlationKey)}/resume`, {
       method: "POST",
-      body: { key, value }
+      body: { resumePayload: payload },
+      ...Object.keys(headers).length ? { headers } : {},
+      ...opts?.signal ? { signal: opts.signal } : {}
     });
   }
-  async listSecrets(workflowName, opts) {
-    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
-    const body = await this.fetch(templatePath(factorySlug, workflowName, "secrets"));
-    return body.secrets.map((s) => ({ key: s.secretKey, createdAt: s.createdAt, updatedAt: s.updatedAt }));
-  }
-  deleteSecret(workflowName, key, opts) {
-    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
-    return this.fetch(templatePath(factorySlug, workflowName, "secrets", key), { method: "DELETE" });
-  }
-  createApiKey(input) {
-    return this.fetch("/api-keys", { method: "POST", body: input });
-  }
-  async listApiKeys() {
-    const body = await this.fetch("/api-keys");
-    return body.data;
-  }
-  getUsage(from, to) {
-    const qs = `?from=${encodeURIComponent(from.toISOString())}&to=${encodeURIComponent(to.toISOString())}`;
-    return this.fetch(`/api/v1/usage${qs}`);
+  async answerSteerByKey(runId, correlationKey, message, opts) {
+    return this.resumePauseByKey(runId, correlationKey, steerAnswerPayload(message, opts?.actor), opts);
   }
-  cancelRun(runId) {
-    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/cancel`, { method: "POST" });
+  async answerSteer(runId, pauseId, message, opts) {
+    return this.resumePause(runId, pauseId, steerAnswerPayload(message, opts?.actor), opts);
   }
-  async* streamRunLogs(runId, opts) {
-    const headers = { Authorization: `Bearer ${this.apiKey}` };
-    if (opts?.lastEventId && opts.lastEventId > 0) {
-      headers["Last-Event-ID"] = String(opts.lastEventId);
-    }
-    const res = await fetch(`${this.baseUrl}/api/v1/workflows/${encodeURIComponent(runId)}/stream`, {
-      headers,
+  async requestAgentPause(runId, agentId, opts) {
+    const body = {};
+    if (opts?.reason !== undefined)
+      body.reason = opts.reason;
+    if (opts?.correlationKey !== undefined)
+      body.correlationKey = opts.correlationKey;
+    return this.fetch(`/api/v1/runs/${encodeURIComponent(runId)}/agents/${encodeURIComponent(agentId)}/pause`, {
+      method: "POST",
+      body,
       ...opts?.signal ? { signal: opts.signal } : {}
     });
-    if (!res.ok || !res.body) {
-      let message = res.statusText;
-      try {
-        const body = await res.json();
-        if (body.error)
-          message = body.error;
-      } catch {}
-      throw new AgentComposeError(res.status, message);
-    }
-    for await (const ev of parseSseStream(res.body)) {
-      yield ev.data;
-    }
-  }
-}
-// src/utils/bundler.ts
-import { createHash } from "node:crypto";
-import { parse as babelParse } from "@babel/parser";
-
-// src/utils/source-loader.ts
-import { dirname } from "path";
-import { writeFile, rm, mkdir } from "node:fs/promises";
-var TMP_DIR = process.env.TMP_DIR ?? "/tmp/agent-compose";
-var LATEST_VERSION = "$LATEST";
-async function importSourceModule(source, tmpPath) {
-  await mkdir(dirname(tmpPath), { recursive: true });
-  await writeFile(tmpPath, source, "utf8");
-  const mod = await import(tmpPath);
-  const cleanup = () => rm(tmpPath, { force: true });
-  return { mod, cleanup };
-}
-
-// src/types/workflow-plan.ts
-function workflowPlan(steps) {
-  return { steps };
-}
-
-// src/utils/bundler.ts
-var BUNDLER_VERSION = 2;
-
-class WorkflowSourceValidationError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "WorkflowSourceValidationError";
-  }
-}
-async function bundle(path, label) {
-  const bun = globalThis;
-  if (!bun.Bun?.build)
-    throw new Error("bundleWorkflow requires the Bun runtime (Bun.build)");
-  const result = await bun.Bun.build({ entrypoints: [path], format: "esm", target: "node" });
-  if (!result.success) {
-    throw new Error(`Failed to bundle ${label}:
-${result.logs.map((l) => l.message).join(`
-`)}`);
-  }
-  return result.outputs[0].text();
-}
-async function extractFromBundle(source, label, pick) {
-  const tmpPath = `/tmp/agentc-${label}-${Date.now()}-${Math.random().toString(36).slice(2)}.js`;
-  try {
-    const loaded = await importSourceModule(source, tmpPath);
-    try {
-      return pick(loaded.mod.default);
-    } finally {
-      await loaded.cleanup();
-    }
-  } catch (err) {
-    throw new WorkflowSourceValidationError(`Bundled ${label} could not be evaluated: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-var DEFINE_WORKFLOW_CALLEE = /^(?:defineWorkflow|defineSandboxEnvironment)\d*$/;
-function isDefineWorkflowCall(node) {
-  if (node.callee.type === "Identifier") {
-    return DEFINE_WORKFLOW_CALLEE.test(node.callee.name);
   }
-  if (node.callee.type === "MemberExpression" && node.callee.object.type === "CallExpression") {
-    return isDefineWorkflowCall(node.callee.object);
-  }
-  return false;
-}
-function assertDefaultExportIsDefineWorkflow(source, label) {
-  let ast;
-  try {
-    ast = babelParse(source, {
-      sourceType: "module",
-      plugins: [],
-      errorRecovery: false
+  async sendAgentMessage(runId, agentId, message, opts) {
+    const body = { message };
+    if (opts?.senderName !== undefined)
+      body.senderName = opts.senderName;
+    return this.fetch(`/api/v1/runs/${encodeURIComponent(runId)}/agents/${encodeURIComponent(agentId)}/messages`, {
+      method: "POST",
+      body,
+      ...opts?.signal ? { signal: opts.signal } : {}
     });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new WorkflowSourceValidationError(`Bundled workflow ${label} failed to parse as JavaScript: ${msg}. ` + `If you registered raw .ts source, switch to \`agentc register <file.ts>\` so the source is bundled first.`);
-  }
-  const defaultExpr = findDefaultExportExpression(ast.program.body);
-  if (!defaultExpr) {
-    throw new WorkflowSourceValidationError(`Bundled workflow ${label} has no default export. ` + `Use \`export default defineWorkflow({ run: ... })\`.`);
-  }
-  if (defaultExpr.type !== "CallExpression" || !isDefineWorkflowCall(defaultExpr)) {
-    throw new WorkflowSourceValidationError(`Bundled workflow ${label} default export must be a \`defineWorkflow({...})\` call ` + `(or a \`defineWorkflow(...).step(...).build()\` chain). ` + `Got: ${defaultExpr.type}. Wrap your workflow with \`defineWorkflow\` from "@agent-compose/sdk".`);
   }
-}
-function findDefaultExportExpression(body) {
-  const defaultDecl = body.find((node) => node.type === "ExportDefaultDeclaration");
-  if (defaultDecl) {
-    return defaultDecl.declaration;
+  getRun(runId) {
+    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}`);
   }
-  const exportNamed = body.find((node) => node.type === "ExportNamedDeclaration" && node.specifiers.some((spec2) => spec2.type === "ExportSpecifier" && spec2.exported.type === "Identifier" && spec2.exported.name === "default"));
-  if (!exportNamed || exportNamed.type !== "ExportNamedDeclaration")
-    return null;
-  const spec = exportNamed.specifiers.find((s) => s.type === "ExportSpecifier" && s.exported.type === "Identifier" && s.exported.name === "default");
-  if (!spec || spec.type !== "ExportSpecifier" || spec.local.type !== "Identifier")
-    return null;
-  const localName = spec.local.name;
-  for (const stmt of body) {
-    if (stmt.type !== "VariableDeclaration")
-      continue;
-    for (const decl of stmt.declarations) {
-      if (decl.id.type === "Identifier" && decl.id.name === localName && decl.init && decl.init.type !== "TSSatisfiesExpression") {
-        return decl.init;
-      }
-    }
+  async getRunTimeline(runId, opts) {
+    const q2 = new URLSearchParams;
+    if (opts?.limit !== undefined)
+      q2.set("limit", String(opts.limit));
+    if (opts?.offset !== undefined)
+      q2.set("offset", String(opts.offset));
+    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/timeline${q2.toString() ? `?${q2}` : ""}`);
+    return body.events;
   }
-  return null;
-}
-function sha256(text) {
-  return createHash("sha256").update(text, "utf8").digest("hex");
-}
-async function bundleWorkflow(workflowPath, overrides) {
-  const label = `"${workflowPath}"`;
-  const source = await bundle(workflowPath, `workflow ${label}`);
-  assertDefaultExportIsDefineWorkflow(source, label);
-  const workflow = await extractFromBundle(source, "workflow", (wf) => isWorkflow(wf) ? wf : undefined);
-  if (!workflow) {
-    throw new WorkflowSourceValidationError(`Bundled workflow ${label} default export is not a Workflow. ` + `Wrap your workflow with \`defineWorkflow\` from "@agent-compose/sdk" — ` + `raw \`export default async function\` is no longer supported.`);
+  async reportEvent(runId, input) {
+    const body = {
+      ...input,
+      ...input.timestamp instanceof Date ? { timestamp: input.timestamp.toISOString() } : {}
+    };
+    const response = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/events`, {
+      method: "POST",
+      body
+    });
+    return response.event;
   }
-  const { metadata } = workflow;
-  const plan = workflowPlan(workflow.steps.map((step, index) => ({ index, name: step.name })));
-  const manifest = {
-    definitionBrand: true,
-    sourceHash: sha256(source),
-    bundlerVersion: BUNDLER_VERSION
-  };
-  const inputSchema = extractIOSchema(workflow.input);
-  const outputSchema = extractIOSchema(workflow.output);
-  return {
-    source,
-    manifest,
-    workflowPlan: plan,
-    networkPolicy: overrides?.networkPolicy ?? metadata.networkPolicy,
-    placeholders: overrides?.placeholders ?? metadata.placeholders,
-    ...metadata.description !== undefined ? { description: metadata.description } : {},
-    ...inputSchema !== undefined ? { inputSchema } : {},
-    ...outputSchema !== undefined ? { outputSchema } : {},
-    ...metadata.snapshots !== undefined ? { snapshots: metadata.snapshots } : {},
-    ...metadata.resources !== undefined ? { resources: metadata.resources } : {},
-    ...metadata.connectors !== undefined ? { connectors: metadata.connectors } : {},
-    ...metadata.connectorOperation !== undefined ? { connectorOperation: metadata.connectorOperation } : {},
-    ...metadata.invokePolicy !== undefined ? { invokePolicy: metadata.invokePolicy } : {}
-  };
-}
-function extractIOSchema(zodSchema) {
-  let json;
-  try {
-    const z4 = __require("zod");
-    if (!z4.toJSONSchema)
-      return;
-    json = z4.toJSONSchema(zodSchema);
-  } catch {
-    return;
+  async listRunEvents(runId) {
+    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/events`);
+    return body.events;
   }
-  if (!json || typeof json !== "object")
-    return;
-  if (Object.keys(json).filter((k) => k !== "$schema").length === 0)
-    return;
-  const out = {};
-  if (json.type !== undefined)
-    out.type = json.type;
-  if (json.description !== undefined)
-    out.description = String(json.description);
-  if (json.properties && typeof json.properties === "object") {
-    const props = {};
-    for (const [key, raw] of Object.entries(json.properties)) {
-      if (raw && typeof raw === "object") {
-        const r = raw;
-        props[key] = {};
-        if (r.type !== undefined)
-          props[key].type = r.type;
-        if (r.description !== undefined)
-          props[key].description = String(r.description);
-      }
-    }
-    if (Object.keys(props).length > 0)
-      out.properties = props;
+  async listRunArtifacts(runId) {
+    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/artifacts`);
+    return body.artifacts.map((a) => ({
+      path: a.path,
+      factorySlug: a.factory_slug,
+      sizeBytes: a.size_bytes,
+      lastWriteAt: a.last_write_at,
+      preview: a.preview
+    }));
   }
-  if (Array.isArray(json.required))
-    out.required = json.required.map(String);
-  return out;
-}
-// src/utils/schemas.ts
-import { z as z4 } from "zod";
-var AgentStatusSchema = z4.object({
-  summary: z4.string(),
-  completed: z4.array(z4.string()),
-  blockers: z4.array(z4.string()),
-  exit_signal: z4.boolean(),
-  needs_input: z4.boolean().optional(),
-  question: z4.string().optional()
-});
-// src/runtimes/claude.ts
-import { query } from "@anthropic-ai/claude-agent-sdk";
-
-// src/agent/agent-loop.ts
-import { z as z9 } from "zod";
-
-// src/agent/protocol.ts
-import { z as z5 } from "zod";
-var AgentMessageSchema = z5.object({
-  type: z5.enum(["init", "text", "thinking", "tool_use", "tool_result", "done", "error", "usage"]),
-  timestamp: z5.string()
-}).passthrough();
-function parseAgentResponse(text) {
-  const match = text.match(/<response>([\s\S]*?)<\/response>/);
-  if (!match)
-    return null;
-  try {
-    return JSON.parse(match[1].trim());
-  } catch {
-    return null;
+  async putFactoryFile(path, content, opts) {
+    const factorySlug = opts?.factorySlug ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_FACTORY : undefined) ?? DEFAULT_FACTORY;
+    const runToken = typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_RUN_TOKEN : undefined;
+    const wire = await this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/content?path=${encodeURIComponent(path)}`, {
+      method: "PUT",
+      body: content,
+      headers: {
+        "content-type": opts?.contentType ?? "text/plain; charset=utf-8",
+        ...runToken ? { "x-run-token": runToken } : {}
+      }
+    });
+    return {
+      path: wire.path,
+      contentHash: wire.content_hash,
+      sizeBytes: wire.size_bytes,
+      created: wire.created
+    };
   }
-}
-
-// src/agent/agent-loop.ts
-import { randomUUID } from "node:crypto";
-
-// src/pause/manager.ts
-import { z as z6 } from "zod";
-
-// src/pause/state-dir.ts
-import { promises as fs } from "node:fs";
-import { join as join2 } from "node:path";
-import { randomBytes } from "node:crypto";
-function getStateDir() {
-  return process.env.AGENT_COMPOSE_STATE_DIR ?? "/tmp/wf/state";
-}
-var checkpointsDir = () => join2(getStateDir(), "checkpoints");
-var pausesDir = () => join2(getStateDir(), "pauses");
-var agentStatePath = (agentInstanceId) => join2(getStateDir(), `agent-${agentInstanceId}.json`);
-var runtimeStatePath = (agentInstanceId) => join2(getStateDir(), `runtime-${agentInstanceId}.json`);
-var checkpointPath = (name) => join2(checkpointsDir(), `${name}.json`);
-var pausePath = (pauseId) => join2(pausesDir(), `${pauseId}.json`);
-var NAME_RE = /^[a-zA-Z0-9_][a-zA-Z0-9_.-]*$/;
-function assertSafeName(label, name) {
-  if (!NAME_RE.test(name)) {
-    throw new Error(`${label} name must match ${NAME_RE} (got ${JSON.stringify(name)})`);
+  async getFactoryFile(path, opts) {
+    const factorySlug = opts?.factorySlug ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_FACTORY : undefined) ?? DEFAULT_FACTORY;
+    const q2 = new URLSearchParams({ path });
+    if (opts?.revision !== undefined)
+      q2.set("revision", String(opts.revision));
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/content?${q2}`, { responseType: "text" });
   }
-}
-function assertSafeCheckpointName(name) {
-  assertSafeName("checkpoint", name);
-}
-async function ensureDirs() {
-  await fs.mkdir(checkpointsDir(), { recursive: true });
-  await fs.mkdir(pausesDir(), { recursive: true });
-}
-async function atomicWriteJSON(path, value) {
-  await ensureDirs();
-  const tmp = `${path}.tmp.${randomBytes(6).toString("hex")}`;
-  const payload = JSON.stringify(value);
-  if (payload === undefined) {
-    throw new Error("pause state values must be JSON-serialisable");
+  async listMembers() {
+    const body = await this.fetch("/api/v1/team/members");
+    return body.members;
   }
-  const handle = await fs.open(tmp, "w");
-  try {
-    await handle.writeFile(payload, { encoding: "utf8" });
-    await handle.sync();
-  } finally {
-    await handle.close();
+  async createMentions(input) {
+    const factorySlug = input.factorySlug ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_FACTORY : undefined) ?? DEFAULT_FACTORY;
+    const runToken = typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_RUN_TOKEN : undefined;
+    const { factorySlug: _omit, ...payload } = input;
+    const body = await this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/mentions`, {
+      method: "POST",
+      body: payload,
+      ...runToken ? { headers: { "x-run-token": runToken } } : {}
+    });
+    return body.mentions;
   }
-  await fs.rename(tmp, path);
-}
-async function readJSON(path) {
-  try {
-    const raw = await fs.readFile(path, "utf8");
-    return JSON.parse(raw);
-  } catch (err) {
-    if (err.code === "ENOENT")
-      return null;
-    throw err;
+  async listFactoryEvents(opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    const q2 = new URLSearchParams;
+    if (opts?.limit != null)
+      q2.set("limit", String(opts.limit));
+    if (opts?.name)
+      q2.set("name", opts.name);
+    if (opts?.from)
+      q2.set("from", opts.from);
+    if (opts?.before)
+      q2.set("before", opts.before);
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/events${q2.toString() ? `?${q2}` : ""}`);
   }
-}
-async function readJSONWithPresence(path) {
-  try {
-    const raw = await fs.readFile(path, "utf8");
-    return { found: true, value: JSON.parse(raw) };
-  } catch (err) {
-    if (err.code === "ENOENT")
-      return { found: false };
-    throw err;
+  async listRunLogs(runId, opts) {
+    const q2 = new URLSearchParams;
+    if (opts?.afterId !== undefined)
+      q2.set("afterId", String(opts.afterId));
+    if (opts?.limit !== undefined)
+      q2.set("limit", String(opts.limit));
+    if (opts?.direction !== undefined)
+      q2.set("direction", opts.direction);
+    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/logs${q2.toString() ? `?${q2}` : ""}`);
+    return body.logs;
   }
-}
-async function readAgentState(agentInstanceId) {
-  assertSafeName("agent", agentInstanceId);
-  return readJSON(agentStatePath(agentInstanceId));
-}
-async function writeAgentState(agentInstanceId, state) {
-  assertSafeName("agent", agentInstanceId);
-  await atomicWriteJSON(agentStatePath(agentInstanceId), state);
-}
-async function readRuntimeCheckpoint(agentInstanceId) {
-  assertSafeName("runtime", agentInstanceId);
-  return readJSON(runtimeStatePath(agentInstanceId));
-}
-async function writeRuntimeCheckpoint(agentInstanceId, blob) {
-  assertSafeName("runtime", agentInstanceId);
-  await atomicWriteJSON(runtimeStatePath(agentInstanceId), blob);
-}
-async function readCheckpoint(name) {
-  assertSafeCheckpointName(name);
-  return readJSONWithPresence(checkpointPath(name));
-}
-async function writeCheckpoint(name, value) {
-  assertSafeCheckpointName(name);
-  await atomicWriteJSON(checkpointPath(name), value);
-}
-function hasOwn(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
-}
-function validatePauseRecord(value, expectedPauseId) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`pause record ${expectedPauseId} is malformed: expected object`);
+  async listTemplates(opts) {
+    const path = opts?.factorySlug ? templatePath(opts.factorySlug) : "/api/v1/templates";
+    const body = await this.fetch(path);
+    return body.templates;
   }
-  const record = value;
-  if (record.pauseId !== undefined && record.pauseId !== expectedPauseId) {
-    throw new Error(`pause record ${expectedPauseId} is malformed: pauseId mismatch`);
+  async listFactories() {
+    const body = await this.fetch("/api/v1/factories");
+    return body.factories;
   }
-  if (record.resolved === true) {
-    if (typeof record.expired !== "boolean") {
-      throw new Error(`pause record ${expectedPauseId} is malformed: resolved records require boolean expired`);
-    }
-    if (!hasOwn(record, "resumePayload") || record.resumePayload === undefined) {
-      throw new Error(`pause record ${expectedPauseId} is malformed: resolved records require resumePayload`);
-    }
-    return {
-      pauseId: expectedPauseId,
-      request: hasOwn(record, "request") ? record.request : null,
-      ...record
-    };
+  createFactory(payload) {
+    return this.fetch("/api/v1/factories", { method: "POST", body: payload });
   }
-  if (record.pauseId !== expectedPauseId) {
-    throw new Error(`pause record ${expectedPauseId} is malformed: unresolved records require matching pauseId`);
+  getFactory(slug) {
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(slug)}`);
   }
-  if (!hasOwn(record, "request") || record.request === undefined) {
-    throw new Error(`pause record ${expectedPauseId} is malformed: unresolved records require request`);
+  updateFactory(slug, updates) {
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(slug)}`, { method: "PATCH", body: updates });
   }
-  if (record.resolved !== undefined && record.resolved !== false) {
-    throw new Error(`pause record ${expectedPauseId} is malformed: resolved must be true, false, or absent`);
+  deleteFactory(slug) {
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(slug)}`, { method: "DELETE" });
   }
-  if (hasOwn(record, "expired") || hasOwn(record, "resumePayload")) {
-    throw new Error(`pause record ${expectedPauseId} is malformed: unresolved records must not include resolution fields`);
+  async listSchedules(factorySlug = "default") {
+    const body = await this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/schedules`);
+    return body.schedules;
   }
-  return record;
-}
-async function readPauseRecord(pauseId) {
-  assertSafeName("pause", pauseId);
-  const record = await readJSON(pausePath(pauseId));
-  return record === null ? null : validatePauseRecord(record, pauseId);
-}
-async function writePauseRecord(record) {
-  assertSafeName("pause", record.pauseId);
-  validatePauseRecord(record, record.pauseId);
-  await atomicWriteJSON(pausePath(record.pauseId), record);
-}
-
-// src/pause/manager.ts
-var AGENT_LOOP_STATE_SCHEMA_VERSION = 2;
-var SUPPORTED_AGENT_LOOP_STATE_VERSIONS = z6.union([z6.literal(1), z6.literal(2)]);
-var RunningAgentLoopStateSchema = z6.object({
-  schemaVersion: SUPPORTED_AGENT_LOOP_STATE_VERSIONS,
-  phase: z6.literal("running"),
-  iteration: z6.number().int().nonnegative(),
-  completedIterations: z6.number().int().nonnegative(),
-  lastSessionId: z6.string(),
-  lastStatus: AgentStatusSchema.nullable(),
-  lastResponseText: z6.string(),
-  lastResponseValidationError: z6.string(),
-  iterationsWithoutStatus: z6.number().int().nonnegative(),
-  blockerStreak: z6.object({ key: z6.string(), count: z6.number().int().nonnegative() }).nullable(),
-  pendingSteerPause: z6.object({ reason: z6.string(), correlationKey: z6.string().nullable(), at: z6.number().int() }).nullable().default(null)
-});
-var SettledAgentLoopStateSchema = z6.object({
-  schemaVersion: SUPPORTED_AGENT_LOOP_STATE_VERSIONS,
-  phase: z6.literal("settled"),
-  result: z6.object({
-    sessionId: z6.string(),
-    lastStatus: AgentStatusSchema.nullable(),
-    iterations: z6.number().int().nonnegative(),
-    response: z6.unknown().optional()
-  })
-});
-var AgentLoopStateSchema = z6.discriminatedUnion("phase", [
-  RunningAgentLoopStateSchema,
-  SettledAgentLoopStateSchema
-]);
-function toProgressState(state) {
-  return {
-    iteration: state.iteration,
-    completedIterations: state.completedIterations,
-    lastSessionId: state.lastSessionId,
-    lastStatus: state.lastStatus,
-    lastResponseText: state.lastResponseText,
-    lastResponseValidationError: state.lastResponseValidationError,
-    iterationsWithoutStatus: state.iterationsWithoutStatus,
-    blockerStreak: state.blockerStreak,
-    pendingSteerPause: state.pendingSteerPause
-  };
-}
-
-class PauseManager {
-  agentId;
-  constructor(agentId) {
-    this.agentId = agentId;
+  createSchedule(payload) {
+    const factorySlug = payload.factorySlug ?? "default";
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/schedules`, {
+      method: "POST",
+      body: { name: payload.name, workflow: payload.workflow, cron: payload.cron }
+    });
   }
-  async restoreAgentLoop(runtime) {
-    const priorState = await readAgentState(this.agentId);
-    if (priorState === null)
-      return { kind: "fresh" };
-    const parsed = AgentLoopStateSchema.safeParse(priorState);
-    if (!parsed.success)
-      return { kind: "invalid", error: parsed.error.message };
-    const state = parsed.data;
-    if (state.phase === "settled") {
-      return {
-        kind: "settled",
-        result: {
-          sessionId: state.result.sessionId,
-          lastStatus: state.result.lastStatus,
-          iterations: state.result.iterations,
-          ...Object.prototype.hasOwnProperty.call(state.result, "response") ? { response: state.result.response } : {}
-        }
-      };
-    }
-    const runtimeBlob = await readRuntimeCheckpoint(this.agentId);
-    if (runtimeBlob !== null && !runtime.restoreCheckpoint) {
-      throw new Error(`runtime checkpoint exists for resumed agentId=${this.agentId}, but runtime cannot restore it`);
-    }
-    if (runtime.restoreCheckpoint && runtimeBlob === null) {
-      throw new Error(`missing runtime checkpoint for resumed agentId=${this.agentId}`);
-    }
-    if (runtimeBlob !== null)
-      runtime.restoreCheckpoint?.(runtimeBlob);
-    return { kind: "running", state: toProgressState(state) };
+  deleteSchedule(id, factorySlug = "default") {
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/schedules/${encodeURIComponent(id)}`, { method: "DELETE" });
   }
-  async saveRunningAgentLoop(state, runtime) {
-    await writeAgentState(this.agentId, {
-      schemaVersion: AGENT_LOOP_STATE_SCHEMA_VERSION,
-      phase: "running",
-      ...state
+  setSecret(workflowName, key, value, opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    return this.fetch(templatePath(factorySlug, workflowName, "secrets"), {
+      method: "POST",
+      body: { key, value }
     });
-    if (runtime.captureCheckpoint) {
-      const blob = runtime.captureCheckpoint();
-      if (blob !== undefined)
-        await writeRuntimeCheckpoint(this.agentId, blob);
-    }
   }
-  async saveSettledAgentLoop(result) {
-    await writeAgentState(this.agentId, {
-      schemaVersion: AGENT_LOOP_STATE_SCHEMA_VERSION,
-      phase: "settled",
-      result: {
-        sessionId: result.sessionId,
-        lastStatus: result.lastStatus,
-        iterations: result.iterations,
-        ...result.response !== undefined ? { response: result.response } : {}
-      }
+  async listSecrets(workflowName, opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    const body = await this.fetch(templatePath(factorySlug, workflowName, "secrets"));
+    return body.secrets.map((s) => ({ key: s.secretKey, createdAt: s.createdAt, updatedAt: s.updatedAt }));
+  }
+  deleteSecret(workflowName, key, opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    return this.fetch(templatePath(factorySlug, workflowName, "secrets", key), { method: "DELETE" });
+  }
+  setFactorySecret(key, value, opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/secrets`, {
+      method: "POST",
+      body: { key, value }
     });
   }
-}
-
-// src/pause/pause-core.ts
-import { createHash as createHash2 } from "node:crypto";
-
-// src/step-invocation/types.ts
-import { z as z7 } from "zod";
-var StepPauseRequestSchema = z7.object({
-  reason: z7.string().min(1),
-  kind: z7.enum(["decision", "sleep", "event", "custom"]),
-  payload: z7.record(z7.string(), z7.unknown()).optional(),
-  ttlMs: z7.number().int().positive().optional(),
-  correlationKey: z7.string().min(1).optional(),
-  snapshot: z7.boolean().optional()
-});
-
-class StepExecutionError extends Error {
-  kind;
-  exitCode;
-  constructor(error, stepLabel) {
-    super(`[${error.kind}] ${stepLabel}: ${error.message}`);
-    this.name = "StepExecutionError";
-    this.kind = error.kind;
-    this.exitCode = error.kind === "runner-exit" ? error.exitCode : undefined;
+  async listFactorySecrets(opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    const body = await this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/secrets`);
+    return body.secrets.map((s) => ({ key: s.secretKey, createdAt: s.createdAt, updatedAt: s.updatedAt }));
+  }
+  deleteFactorySecret(key, opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/secrets/${encodeURIComponent(key)}`, { method: "DELETE" });
+  }
+  createApiKey(input) {
+    return this.fetch("/api-keys", { method: "POST", body: input });
+  }
+  async listApiKeys() {
+    const body = await this.fetch("/api-keys");
+    return body.data;
+  }
+  getUsage(from, to) {
+    const qs = `?from=${encodeURIComponent(from.toISOString())}&to=${encodeURIComponent(to.toISOString())}`;
+    return this.fetch(`/api/v1/usage${qs}`);
+  }
+  cancelRun(runId) {
+    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/cancel`, { method: "POST" });
+  }
+  async* streamRunLogs(runId, opts) {
+    const headers = { Authorization: `Bearer ${this.apiKey}` };
+    if (opts?.lastEventId && opts.lastEventId > 0) {
+      headers["Last-Event-ID"] = String(opts.lastEventId);
+    }
+    const res = await fetch(`${this.baseUrl}/api/v1/workflows/${encodeURIComponent(runId)}/stream`, {
+      headers,
+      ...opts?.signal ? { signal: opts.signal } : {}
+    });
+    if (!res.ok || !res.body) {
+      let message = res.statusText;
+      try {
+        const body = await res.json();
+        if (body.error)
+          message = body.error;
+      } catch {}
+      throw new AgentComposeError(res.status, message);
+    }
+    for await (const ev of parseSseStream(res.body)) {
+      yield ev.data;
+    }
   }
 }
-
-// src/active-step.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var activeStepStorage = new AsyncLocalStorage;
-var fallbackActive = null;
-var BRIDGE_KEY = Symbol.for("agent-compose.activeStep.bridge");
-function bridgeSlot() {
-  const g = globalThis;
-  return g[BRIDGE_KEY] ??= { state: null };
-}
-function makeState(step) {
-  return {
-    stepIndex: step.stepIndex,
-    nextAgentCallIndex: 0,
-    pauseOrdinalByScope: new Map
-  };
-}
-function currentState() {
-  return activeStepStorage.getStore() ?? bridgeSlot().state ?? fallbackActive;
-}
-async function runWithActiveStep(step, fn) {
-  return activeStepStorage.run(makeState(step), fn);
-}
-function setActiveStepBridge(step) {
-  const slot = bridgeSlot();
-  const prev = { state: slot.state };
-  slot.state = step ? makeState(step) : null;
-  return prev;
-}
-function restoreActiveStepBridge(prev) {
-  bridgeSlot().state = prev.state;
-}
-function getActiveStep() {
-  const state = currentState();
-  return state ? { stepIndex: state.stepIndex } : null;
-}
-function nextAgentCallInActiveStep() {
-  const state = currentState();
-  if (!state)
-    return null;
-  const callIndex = state.nextAgentCallIndex;
-  state.nextAgentCallIndex += 1;
-  return { stepIndex: state.stepIndex, callIndex };
+// src/utils/bundler.ts
+import { createHash as createHash2 } from "node:crypto";
+import { parse as babelParse } from "@babel/parser";
+
+// src/utils/source-loader.ts
+import { dirname } from "path";
+import { writeFile, rm, mkdir } from "node:fs/promises";
+var TMP_DIR = process.env.TMP_DIR ?? "/tmp/agent-compose";
+var LATEST_VERSION = "$LATEST";
+async function importSourceModule(source, tmpPath) {
+  await mkdir(dirname(tmpPath), { recursive: true });
+  await writeFile(tmpPath, source, "utf8");
+  const mod = await import(tmpPath);
+  const cleanup = () => rm(tmpPath, { force: true });
+  return { mod, cleanup };
 }
-function nextPauseOrdinalInActiveStep(scope) {
-  const state = currentState();
-  if (!state)
-    return null;
-  const next = state.pauseOrdinalByScope.get(scope) ?? 0;
-  state.pauseOrdinalByScope.set(scope, next + 1);
-  return next;
+
+// src/types/workflow-plan.ts
+function workflowPlan(steps) {
+  return { steps };
 }
 
-// src/pause/errors.ts
-class PauseError extends Error {
+// src/utils/bundler.ts
+var BUNDLER_VERSION = 2;
+
+class WorkflowSourceValidationError extends Error {
   constructor(message) {
     super(message);
-    this.name = new.target.name;
+    this.name = "WorkflowSourceValidationError";
   }
 }
-
-class PauseExpiredError extends PauseError {
-  code = "pause_expired";
-  constructor(message = "pause expired before it was resolved") {
-    super(message);
+async function bundle(path, label) {
+  const bun = globalThis;
+  if (!bun.Bun?.build)
+    throw new Error("bundleWorkflow requires the Bun runtime (Bun.build)");
+  const result = await bun.Bun.build({ entrypoints: [path], format: "esm", target: "node" });
+  if (!result.success) {
+    throw new Error(`Failed to bundle ${label}:
+${result.logs.map((l) => l.message).join(`
+`)}`);
   }
+  return result.outputs[0].text();
 }
-
-class PauseSchemaError extends PauseError {
-  code = "pause_schema";
-  issues;
-  constructor(message, issues) {
-    super(message);
-    this.issues = issues;
+async function extractFromBundle(source, label, pick) {
+  const tmpPath = `/tmp/agentc-${label}-${Date.now()}-${Math.random().toString(36).slice(2)}.js`;
+  try {
+    const loaded = await importSourceModule(source, tmpPath);
+    try {
+      return pick(loaded.mod.default);
+    } finally {
+      await loaded.cleanup();
+    }
+  } catch (err) {
+    throw new WorkflowSourceValidationError(`Bundled ${label} could not be evaluated: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-
-class PauseRequestError extends PauseError {
-  code = "pause_request";
-  constructor(message = "pause request is invalid") {
-    super(message);
+var DEFINE_WORKFLOW_CALLEE = /^(?:defineWorkflow|defineSandboxEnvironment)\d*$/;
+function isDefineWorkflowCall(node) {
+  if (node.callee.type === "Identifier") {
+    return DEFINE_WORKFLOW_CALLEE.test(node.callee.name);
   }
-}
-
-// src/pause/pause-core.ts
-var PAUSE_SIGNAL_BRAND = Symbol.for("agent-compose.PauseSignal");
-
-class PauseSignal {
-  pauseId;
-  pauseRequest;
-  observability;
-  [PAUSE_SIGNAL_BRAND] = true;
-  constructor(pauseId, pauseRequest, observability) {
-    this.pauseId = pauseId;
-    this.pauseRequest = pauseRequest;
-    this.observability = observability;
+  if (node.callee.type === "MemberExpression" && node.callee.object.type === "CallExpression") {
+    return isDefineWorkflowCall(node.callee.object);
   }
+  return false;
 }
-function isPauseSignal(err) {
-  return typeof err === "object" && err !== null && err[PAUSE_SIGNAL_BRAND] === true;
-}
-var PAUSE_NAMESPACE = "5f3e2b8a-0c41-4e9d-9a7b-6d2c1f8e3a40";
-function uuidToBytes(uuid) {
-  return Buffer.from(uuid.replace(/-/g, ""), "hex");
-}
-function bytesToUuid(b) {
-  const h = b.toString("hex");
-  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+function assertDefaultExportIsDefineWorkflow(source, label) {
+  let ast;
+  try {
+    ast = babelParse(source, {
+      sourceType: "module",
+      plugins: [],
+      errorRecovery: false
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new WorkflowSourceValidationError(`Bundled workflow ${label} failed to parse as JavaScript: ${msg}. ` + `If you registered raw .ts source, switch to \`agentc register <file.ts>\` so the source is bundled first.`);
+  }
+  const defaultExpr = findDefaultExportExpression(ast.program.body);
+  if (!defaultExpr) {
+    throw new WorkflowSourceValidationError(`Bundled workflow ${label} has no default export. ` + `Use \`export default defineWorkflow({ run: ... })\`.`);
+  }
+  if (defaultExpr.type !== "CallExpression" || !isDefineWorkflowCall(defaultExpr)) {
+    throw new WorkflowSourceValidationError(`Bundled workflow ${label} default export must be a \`defineWorkflow({...})\` call ` + `(or a \`defineWorkflow(...).step(...).build()\` chain). ` + `Got: ${defaultExpr.type}. Wrap your workflow with \`defineWorkflow\` from "@agent-compose/sdk".`);
+  }
 }
-function uuidv5(name, namespace) {
-  const hash = createHash2("sha1").update(uuidToBytes(namespace)).update(Buffer.from(name, "utf8")).digest();
-  const bytes = Buffer.from(hash.subarray(0, 16));
-  bytes[6] = bytes[6] & 15 | 80;
-  bytes[8] = bytes[8] & 63 | 128;
-  return bytesToUuid(bytes);
+function findDefaultExportExpression(body) {
+  const defaultDecl = body.find((node) => node.type === "ExportDefaultDeclaration");
+  if (defaultDecl) {
+    return defaultDecl.declaration;
+  }
+  const exportNamed = body.find((node) => node.type === "ExportNamedDeclaration" && node.specifiers.some((spec2) => spec2.type === "ExportSpecifier" && spec2.exported.type === "Identifier" && spec2.exported.name === "default"));
+  if (!exportNamed || exportNamed.type !== "ExportNamedDeclaration")
+    return null;
+  const spec = exportNamed.specifiers.find((s) => s.type === "ExportSpecifier" && s.exported.type === "Identifier" && s.exported.name === "default");
+  if (!spec || spec.type !== "ExportSpecifier" || spec.local.type !== "Identifier")
+    return null;
+  const localName = spec.local.name;
+  for (const stmt of body) {
+    if (stmt.type !== "VariableDeclaration")
+      continue;
+    for (const decl of stmt.declarations) {
+      if (decl.id.type === "Identifier" && decl.id.name === localName && decl.init && decl.init.type !== "TSSatisfiesExpression") {
+        return decl.init;
+      }
+    }
+  }
+  return null;
 }
-function scopeOf(coord) {
-  return coord.agentScope ? `${coord.runId}:${coord.stepIndex}:${coord.agentScope.agentId}:${coord.agentScope.iteration}` : `${coord.runId}:${coord.stepIndex}:bare`;
+function sha256(text) {
+  return createHash2("sha256").update(text, "utf8").digest("hex");
 }
-var pauseOrdinalByScope = new Map;
-function nextPauseOrdinal(scope) {
-  const activeOrdinal = nextPauseOrdinalInActiveStep(scope);
-  if (activeOrdinal !== null)
-    return activeOrdinal;
-  const next = pauseOrdinalByScope.get(scope) ?? 0;
-  pauseOrdinalByScope.set(scope, next + 1);
-  return next;
+async function bundleWorkflow(workflowPath, overrides) {
+  const label = `"${workflowPath}"`;
+  const source = await bundle(workflowPath, `workflow ${label}`);
+  assertDefaultExportIsDefineWorkflow(source, label);
+  const workflow = await extractFromBundle(source, "workflow", (wf) => isWorkflow(wf) ? wf : undefined);
+  if (!workflow) {
+    throw new WorkflowSourceValidationError(`Bundled workflow ${label} default export is not a Workflow. ` + `Wrap your workflow with \`defineWorkflow\` from "@agent-compose/sdk" — ` + `raw \`export default async function\` is no longer supported.`);
+  }
+  const { metadata } = workflow;
+  const plan = workflowPlan(workflow.steps.map((step, index) => ({ index, name: step.name })));
+  const manifest = {
+    definitionBrand: true,
+    sourceHash: sha256(source),
+    bundlerVersion: BUNDLER_VERSION
+  };
+  const inputSchema = extractIOSchema(workflow.input);
+  const outputSchema = extractIOSchema(workflow.output);
+  return {
+    source,
+    manifest,
+    workflowPlan: plan,
+    networkPolicy: overrides?.networkPolicy ?? metadata.networkPolicy,
+    placeholders: overrides?.placeholders ?? metadata.placeholders,
+    ...metadata.description !== undefined ? { description: metadata.description } : {},
+    ...inputSchema !== undefined ? { inputSchema } : {},
+    ...outputSchema !== undefined ? { outputSchema } : {},
+    ...metadata.snapshots !== undefined ? { snapshots: metadata.snapshots } : {},
+    ...metadata.resources !== undefined ? { resources: metadata.resources } : {},
+    ...metadata.connectors !== undefined ? { connectors: metadata.connectors } : {},
+    ...metadata.connectorOperation !== undefined ? { connectorOperation: metadata.connectorOperation } : {},
+    ...metadata.invokePolicy !== undefined ? { invokePolicy: metadata.invokePolicy } : {},
+    ...metadata.environmentBuild !== undefined ? { environmentBuild: metadata.environmentBuild } : {}
+  };
 }
-function nextPauseId(coord) {
-  const scope = scopeOf(coord);
-  const ordinal = nextPauseOrdinal(scope);
-  return uuidv5(`${scope}:${ordinal}`, PAUSE_NAMESPACE);
+function extractIOSchema(zodSchema) {
+  let json;
+  try {
+    const z6 = __require("zod");
+    if (!z6.toJSONSchema)
+      return;
+    json = z6.toJSONSchema(zodSchema);
+  } catch {
+    return;
+  }
+  if (!json || typeof json !== "object")
+    return;
+  if (Object.keys(json).filter((k) => k !== "$schema").length === 0)
+    return;
+  const out = {};
+  if (json.type !== undefined)
+    out.type = json.type;
+  if (json.description !== undefined)
+    out.description = String(json.description);
+  if (json.properties && typeof json.properties === "object") {
+    const props = {};
+    for (const [key, raw] of Object.entries(json.properties)) {
+      if (raw && typeof raw === "object") {
+        const r = raw;
+        props[key] = {};
+        if (r.type !== undefined)
+          props[key].type = r.type;
+        if (r.description !== undefined)
+          props[key].description = String(r.description);
+      }
+    }
+    if (Object.keys(props).length > 0)
+      out.properties = props;
+  }
+  if (Array.isArray(json.required))
+    out.required = json.required.map(String);
+  return out;
 }
-function nonJsonPath(value, path = "$", seen = new Set) {
-  if (value === null)
-    return null;
-  const kind = typeof value;
-  if (kind === "string" || kind === "boolean")
+// src/utils/schemas.ts
+import { z as z6 } from "zod";
+var AgentStatusSchema = z6.object({
+  summary: z6.string(),
+  completed: z6.array(z6.string()),
+  blockers: z6.array(z6.string()),
+  exit_signal: z6.boolean(),
+  needs_input: z6.boolean().optional(),
+  question: z6.string().optional()
+});
+// src/runtimes/claude.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// src/agent/agent-loop.ts
+import { z as z10 } from "zod";
+
+// src/agent/protocol.ts
+import { z as z7 } from "zod";
+var AgentMessageSchema = z7.object({
+  type: z7.enum(["init", "text", "thinking", "tool_use", "tool_result", "done", "error", "usage"]),
+  timestamp: z7.string()
+}).passthrough();
+function parseAgentResponse(text) {
+  const match = text.match(/<response>([\s\S]*?)<\/response>/);
+  if (!match)
     return null;
-  if (kind === "number")
-    return Number.isFinite(value) ? null : path;
-  if (kind === "undefined" || kind === "bigint" || kind === "function" || kind === "symbol")
-    return path;
-  if (kind !== "object")
-    return path;
-  const obj = value;
-  if (seen.has(obj))
-    return path;
-  seen.add(obj);
-  if (Array.isArray(value)) {
-    for (let i = 0;i < value.length; i++) {
-      const child = nonJsonPath(value[i], `${path}[${i}]`, seen);
-      if (child)
-        return child;
-    }
-    seen.delete(obj);
+  try {
+    return JSON.parse(match[1].trim());
+  } catch {
     return null;
   }
-  const proto = Object.getPrototypeOf(obj);
-  if (proto !== Object.prototype && proto !== null)
-    return path;
-  for (const key of Reflect.ownKeys(obj)) {
-    if (typeof key !== "string")
-      return `${path}.${String(key)}`;
-    const desc = Object.getOwnPropertyDescriptor(obj, key);
-    if (!desc?.enumerable)
-      return `${path}.${key}`;
-    const child = nonJsonPath(value[key], `${path}.${key}`, seen);
-    if (child)
-      return child;
-  }
-  seen.delete(obj);
-  return null;
 }
-function toWireRequest(req, kind) {
-  const wire = {
-    reason: req.reason,
-    kind,
-    ...req.payload !== undefined ? { payload: req.payload } : {},
-    ...req.ttlMs !== undefined ? { ttlMs: req.ttlMs } : {},
-    ...req.correlationKey !== undefined ? { correlationKey: req.correlationKey } : {},
-    ...req.snapshot !== undefined ? { snapshot: req.snapshot } : {}
+
+// src/agent/agent-loop.ts
+import { randomUUID } from "node:crypto";
+
+// src/pause/manager.ts
+import { z as z8 } from "zod";
+var AGENT_LOOP_STATE_SCHEMA_VERSION = 2;
+var SUPPORTED_AGENT_LOOP_STATE_VERSIONS = z8.union([z8.literal(1), z8.literal(2)]);
+var RunningAgentLoopStateSchema = z8.object({
+  schemaVersion: SUPPORTED_AGENT_LOOP_STATE_VERSIONS,
+  phase: z8.literal("running"),
+  iteration: z8.number().int().nonnegative(),
+  completedIterations: z8.number().int().nonnegative(),
+  lastSessionId: z8.string(),
+  lastStatus: AgentStatusSchema.nullable(),
+  lastResponseText: z8.string(),
+  lastResponseValidationError: z8.string(),
+  iterationsWithoutStatus: z8.number().int().nonnegative(),
+  blockerStreak: z8.object({ key: z8.string(), count: z8.number().int().nonnegative() }).nullable(),
+  pendingSteerPause: z8.object({ reason: z8.string(), correlationKey: z8.string().nullable(), at: z8.number().int(), payload: z8.record(z8.string(), z8.unknown()).optional() }).nullable().default(null)
+});
+var SettledAgentLoopStateSchema = z8.object({
+  schemaVersion: SUPPORTED_AGENT_LOOP_STATE_VERSIONS,
+  phase: z8.literal("settled"),
+  result: z8.object({
+    sessionId: z8.string(),
+    lastStatus: AgentStatusSchema.nullable(),
+    iterations: z8.number().int().nonnegative(),
+    response: z8.unknown().optional()
+  })
+});
+var AgentLoopStateSchema = z8.discriminatedUnion("phase", [
+  RunningAgentLoopStateSchema,
+  SettledAgentLoopStateSchema
+]);
+function toProgressState(state) {
+  return {
+    iteration: state.iteration,
+    completedIterations: state.completedIterations,
+    lastSessionId: state.lastSessionId,
+    lastStatus: state.lastStatus,
+    lastResponseText: state.lastResponseText,
+    lastResponseValidationError: state.lastResponseValidationError,
+    iterationsWithoutStatus: state.iterationsWithoutStatus,
+    blockerStreak: state.blockerStreak,
+    pendingSteerPause: state.pendingSteerPause
   };
-  const parsed = StepPauseRequestSchema.safeParse(wire);
-  if (!parsed.success) {
-    throw new PauseRequestError(`pause request failed validation: ${parsed.error.message}`);
-  }
-  const badPath = nonJsonPath(parsed.data);
-  if (badPath) {
-    throw new PauseRequestError(`pause request must be JSON-serializable (invalid value at ${badPath})`);
-  }
-  return parsed.data;
 }
-async function corePause(req, coord, kind = "custom") {
-  const wire = toWireRequest(req, kind);
-  const pauseId = nextPauseId(coord);
-  const record = await readPauseRecord(pauseId);
-  if (record === null || record.resolved !== true) {
-    await writePauseRecord({ pauseId, request: wire });
-    throw new PauseSignal(pauseId, wire);
+
+class PauseManager {
+  agentId;
+  constructor(agentId) {
+    this.agentId = agentId;
   }
-  if (record.expired === true) {
-    const onExpiry = req.onExpiry ?? { mode: "throw" };
-    if (onExpiry.mode === "resolve")
-      return onExpiry.value;
-    throw new PauseExpiredError(`pause "${req.reason}" expired before it was resolved`);
+  async restoreAgentLoop(runtime) {
+    const priorState = await readAgentState(this.agentId);
+    if (priorState === null)
+      return { kind: "fresh" };
+    const parsed = AgentLoopStateSchema.safeParse(priorState);
+    if (!parsed.success)
+      return { kind: "invalid", error: parsed.error.message };
+    const state = parsed.data;
+    if (state.phase === "settled") {
+      return {
+        kind: "settled",
+        result: {
+          sessionId: state.result.sessionId,
+          lastStatus: state.result.lastStatus,
+          iterations: state.result.iterations,
+          ...Object.prototype.hasOwnProperty.call(state.result, "response") ? { response: state.result.response } : {}
+        }
+      };
+    }
+    const runtimeBlob = await readRuntimeCheckpoint(this.agentId);
+    if (runtimeBlob !== null && !runtime.restoreCheckpoint) {
+      throw new Error(`runtime checkpoint exists for resumed agentId=${this.agentId}, but runtime cannot restore it`);
+    }
+    if (runtime.restoreCheckpoint && runtimeBlob === null) {
+      throw new Error(`missing runtime checkpoint for resumed agentId=${this.agentId}`);
+    }
+    if (runtimeBlob !== null)
+      runtime.restoreCheckpoint?.(runtimeBlob);
+    return { kind: "running", state: toProgressState(state) };
   }
-  const payload = record.resumePayload ?? null;
-  if (req.schema) {
-    const parsed = req.schema.safeParse(payload);
-    if (!parsed.success) {
-      throw new PauseSchemaError(`resume payload for pause "${req.reason}" failed schema validation: ${parsed.error.message}`, parsed.error.issues);
+  async saveRunningAgentLoop(state, runtime) {
+    await writeAgentState(this.agentId, {
+      schemaVersion: AGENT_LOOP_STATE_SCHEMA_VERSION,
+      phase: "running",
+      ...state
+    });
+    if (runtime.captureCheckpoint) {
+      const blob = runtime.captureCheckpoint();
+      if (blob !== undefined)
+        await writeRuntimeCheckpoint(this.agentId, blob);
     }
-    return parsed.data;
   }
-  return payload;
+  async saveSettledAgentLoop(result) {
+    await writeAgentState(this.agentId, {
+      schemaVersion: AGENT_LOOP_STATE_SCHEMA_VERSION,
+      phase: "settled",
+      result: {
+        sessionId: result.sessionId,
+        lastStatus: result.lastStatus,
+        iterations: result.iterations,
+        ...result.response !== undefined ? { response: result.response } : {}
+      }
+    });
+  }
 }
 
 // src/agent/steer-control.ts
-import { z as z8 } from "zod";
-var SteerDecisionSchema = z8.object({
-  message: z8.string().min(1),
-  actor: z8.string().nullish()
+import { z as z9 } from "zod";
+var SteerDecisionSchema = z9.object({
+  message: z9.string().min(1).optional(),
+  decision: z9.string().min(1).optional(),
+  actor: z9.string().nullish()
+}).transform((d) => ({ message: (d.message ?? d.decision ?? "").trim(), actor: d.actor ?? null })).refine((d) => d.message.length > 0, {
+  message: "a steer/resume answer needs a non-empty `message` or `decision`"
 });
 var steerPending = new Map;
 function signalSteerPending(agentId, payload) {
@@ -1921,6 +2065,8 @@ function summarizeAgentMessage(msg) {
       return { type: "done", sessionId: msg.sessionId };
     case "error":
       return { type: "error", text: truncate(msg.text) };
+    case "plan":
+      return { type: "plan", entries: msg.entries };
   }
 }
 async function agentLoop(opts) {
@@ -1946,7 +2092,8 @@ async function agentLoop(opts) {
     abortSignal: loopAbort.signal,
     retryCount: 0,
     agentId,
-    iteration
+    iteration,
+    pause: boundProcessorPause(opts.pause, { agentId, iteration })
   });
   if (!opts.runtime)
     throw new Error("agentLoop: opts.runtime is required");
@@ -1958,7 +2105,8 @@ async function agentLoop(opts) {
     processors,
     requestContext,
     agentId,
-    ...opts.responseSchema ? { outputFormat: { type: "json_schema", schema: z9.toJSONSchema(opts.responseSchema) } } : {}
+    ...opts.pause ? { pause: opts.pause } : {},
+    ...opts.responseSchema ? { outputFormat: { type: "json_schema", schema: z10.toJSONSchema(opts.responseSchema) } } : {}
   });
   if (processors.some((p) => p.processToolCall) && !client.supportsToolCallProcessor) {
     process.stderr.write(`${logLabel} processToolCall registered but runtime does not support pre-tool-use gating — hook is dormant
@@ -2052,6 +2200,7 @@ async function agentLoop(opts) {
           steerDecision = await opts.pause({
             reason: pendingSteerPause.reason,
             ...pendingSteerPause.correlationKey !== null ? { correlationKey: pendingSteerPause.correlationKey } : {},
+            ...pendingSteerPause.payload !== undefined ? { payload: pendingSteerPause.payload } : {},
             schema: SteerDecisionSchema
           }, { agentId, iteration });
           pendingSteerPause = null;
@@ -2088,6 +2237,7 @@ Re-emit the COMPLETE corrected <response> JSON now: every required field present
         prompt,
         sessionId: lastSessionId ?? undefined,
         iteration: iteration + 1,
+        signal: loopAbort.signal,
         ...opts.inbox ? { inboxStream: opts.inbox } : {}
       })) {
         const outputVerdict = await runProcessorChain(processors, (p) => p.processOutput, rawMsg, procCtx);
@@ -2405,12 +2555,15 @@ class ClaudeRunner {
         toolInput: pre.tool_input ?? {},
         toolUseId: toolUseId ?? `${pre.tool_name}-${Date.now()}`
       };
+      const gateAgentId = this.options.agentId ?? "agent";
+      const gateIteration = opts.iteration ?? 1;
       const gate = await this.gateToolCall(call, {
         requestContext,
         abortSignal: signal ?? opts.signal ?? new AbortController().signal,
         retryCount: 0,
-        agentId: this.options.agentId ?? "agent",
-        iteration: opts.iteration ?? 1
+        agentId: gateAgentId,
+        iteration: gateIteration,
+        pause: boundProcessorPause(this.options.pause, { agentId: gateAgentId, iteration: gateIteration })
       });
       if (gate.kind === "allow")
         return { hookSpecificOutput: { hookEventName: pre.hook_event_name, permissionDecision: "allow", updatedInput: gate.call.toolInput } };
@@ -2441,6 +2594,17 @@ class ClaudeRunner {
       })();
     }
     const promptForQuery = inboxQueue ?? opts.prompt;
+    const queryAbort = new AbortController;
+    const onLoopAbort = () => queryAbort.abort();
+    if (opts.signal) {
+      if (opts.signal.aborted)
+        queryAbort.abort();
+      else
+        opts.signal.addEventListener("abort", onLoopAbort, { once: true });
+    }
+    const systemPromptAppend = [this.config.claudeMdContent, this.options.agentManual].filter((s) => Boolean(s && s.trim())).join(`
+
+`);
     try {
       let emittedAssistantText = false;
       for await (const message of query({
@@ -2454,9 +2618,10 @@ class ClaudeRunner {
           thinking: resolveThinking(this.model, this.config.thinking),
           effort: this.config.effort,
           cwd: this.options.cwd,
+          abortController: queryAbort,
           env: { ...process.env, ...this.config.env ?? {} },
           pathToClaudeCodeExecutable: this.config.pathToClaudeCodeExecutable ?? process.env.CLAUDE_CODE_EXECUTABLE ?? DEFAULT_CLAUDE_PATH,
-          ...this.config.claudeMdContent ? { systemPrompt: { type: "preset", preset: "claude_code", append: this.config.claudeMdContent } } : {},
+          ...systemPromptAppend ? { systemPrompt: { type: "preset", preset: "claude_code", append: systemPromptAppend } } : {},
           skills: this.config.skills ?? "all",
           resume: opts.sessionId,
           mcpServers: this.config.mcpServers,
@@ -2477,30 +2642,314 @@ class ClaudeRunner {
           inboxQueue.close();
       }
     } catch (err) {
-      const text = formatError(err);
-      if (/maximum number of turns/i.test(text)) {
-        yield { type: "done", sessionId: opts.sessionId ?? "", timestamp: now2() };
-      } else {
-        yield { type: "error", text, timestamp: now2() };
+      const text = formatError(err);
+      if (/maximum number of turns/i.test(text)) {
+        yield { type: "done", sessionId: opts.sessionId ?? "", timestamp: now2() };
+      } else {
+        yield { type: "error", text, timestamp: now2() };
+      }
+    } finally {
+      inboxQueue?.close();
+      opts.signal?.removeEventListener("abort", onLoopAbort);
+    }
+  }
+}
+function createClaudeRuntime(config = {}) {
+  return defineRuntime({
+    create: (sandbox, opts) => new ClaudeRunner(sandbox, opts, config)
+  });
+}
+var claude_default = createClaudeRuntime();
+// src/runtimes/_cli-agent.ts
+import { ndJsonStream } from "@agentclientprotocol/sdk";
+
+// src/runtimes/_acp-client.ts
+import {
+  ClientSideConnection,
+  RequestError
+} from "@agentclientprotocol/sdk";
+function now3() {
+  return new Date().toISOString();
+}
+var ACP_PROTOCOL_VERSION = 1;
+var OPTION_KIND_FOR_VERDICT = {
+  allow: ["allow_once", "allow_always"],
+  deny: ["reject_once", "reject_always"]
+};
+function contentBlockText(block) {
+  if (!block)
+    return "";
+  return block.type === "text" ? block.text : "";
+}
+function renderToolContent(content) {
+  const parts = [];
+  const diffs = [];
+  for (const block of content ?? []) {
+    if (block.type === "content") {
+      parts.push(contentBlockText(block.content));
+    } else if (block.type === "diff") {
+      diffs.push({ path: block.path, oldText: block.oldText ?? null, newText: block.newText });
+      const header = block.oldText == null ? `--- (new file)
++++ ${block.path}` : `--- ${block.path}
++++ ${block.path}`;
+      parts.push(`${header}
+${block.newText}`);
+    } else if (block.type === "terminal") {
+      parts.push(`[terminal ${block.terminalId}]`);
+    }
+  }
+  return { output: parts.filter((p) => p !== "").join(`
+`), diffs };
+}
+function mapLocations(locations) {
+  if (!locations || locations.length === 0)
+    return;
+  return locations.map((l) => l.line != null ? { path: l.path, line: l.line } : { path: l.path });
+}
+function terminalToolResult(args) {
+  const { output, diffs } = renderToolContent(args.content);
+  const locations = mapLocations(args.locations);
+  return {
+    type: "tool_result",
+    toolUseId: args.toolCallId,
+    output,
+    isError: args.status === "failed",
+    timestamp: args.timestamp,
+    ...diffs.length > 0 ? { diffs } : {},
+    ...locations ? { locations } : {}
+  };
+}
+function normalizeSessionUpdate(update) {
+  const ts = now3();
+  switch (update.sessionUpdate) {
+    case "agent_message_chunk":
+      return [{ type: "text", text: contentBlockText(update.content), timestamp: ts }];
+    case "agent_thought_chunk":
+      return [{ type: "thinking", text: contentBlockText(update.content), timestamp: ts }];
+    case "tool_call": {
+      const messages = [{
+        type: "tool_use",
+        toolName: update.title || update.kind || "tool",
+        toolInput: update.rawInput ?? {},
+        toolUseId: update.toolCallId,
+        timestamp: ts
+      }];
+      if (update.status === "completed" || update.status === "failed") {
+        messages.push(terminalToolResult({
+          toolCallId: update.toolCallId,
+          status: update.status,
+          content: update.content,
+          locations: update.locations,
+          timestamp: ts
+        }));
+      }
+      return messages;
+    }
+    case "tool_call_update": {
+      if (update.status !== "completed" && update.status !== "failed")
+        return [];
+      return [terminalToolResult({
+        toolCallId: update.toolCallId,
+        status: update.status,
+        content: update.content,
+        locations: update.locations,
+        timestamp: ts
+      })];
+    }
+    case "plan":
+      return [{
+        type: "plan",
+        entries: update.entries.map((e) => ({ content: e.content, priority: e.priority, status: e.status })),
+        timestamp: ts
+      }];
+    case "user_message_chunk":
+    case "available_commands_update":
+    case "current_mode_update":
+    case "usage_update":
+    case "plan_update":
+    case "plan_removed":
+    case "config_option_update":
+    case "session_info_update":
+      return [];
+    default:
+      return [];
+  }
+}
+
+class AcpClientPeer {
+  deps;
+  conn;
+  updates = new AsyncQueue;
+  sessionId;
+  pendingPause = null;
+  cancelled = false;
+  abortPrompt = null;
+  constructor(deps) {
+    this.deps = deps;
+    const handler = {
+      sessionUpdate: (params) => {
+        for (const msg of normalizeSessionUpdate(params.update))
+          this.updates.push(msg);
+      },
+      requestPermission: (params) => this.onRequestPermission(params)
+    };
+    this.conn = new ClientSideConnection((_agent) => handler, this.deps.stream);
+    if (this.deps.signal) {
+      if (this.deps.signal.aborted)
+        this.cancel();
+      else
+        this.deps.signal.addEventListener("abort", () => this.cancel(), { once: true });
+    }
+  }
+  async initialize() {
+    const res = await this.conn.initialize({
+      protocolVersion: ACP_PROTOCOL_VERSION,
+      clientCapabilities: {
+        fs: { readTextFile: false, writeTextFile: false },
+        terminal: false
+      }
+    });
+    return { protocolVersion: res.protocolVersion };
+  }
+  async startSession(cwd) {
+    const res = await this.conn.newSession({ cwd, mcpServers: [] });
+    this.sessionId = res.sessionId;
+    return res.sessionId;
+  }
+  async* prompt(text) {
+    if (!this.sessionId)
+      throw new Error("AcpClientPeer.prompt called before startSession");
+    const updates = new AsyncQueue;
+    this.updates = updates;
+    const aborted = new Promise((resolve) => {
+      this.abortPrompt = () => {
+        resolve();
+        updates.close();
+      };
+    });
+    if (this.cancelled)
+      this.abortPrompt();
+    const promptPromise = this.conn.prompt({ sessionId: this.sessionId, prompt: [{ type: "text", text }] }).then((res) => {
+      updates.close();
+      return { ok: true, res };
+    }, (err) => {
+      updates.close();
+      return { ok: false, err };
+    });
+    for await (const msg of updates) {
+      yield msg;
+    }
+    if (this.pendingPause !== null) {
+      const pause = this.pendingPause;
+      this.pendingPause = null;
+      this.abortPrompt = null;
+      throw pause;
+    }
+    const settled = await Promise.race([
+      promptPromise.then((o) => ({ kind: "prompt", o })),
+      aborted.then(() => ({ kind: "aborted" }))
+    ]);
+    this.abortPrompt = null;
+    if (settled.kind === "aborted")
+      return;
+    const outcome = settled.o;
+    if (!outcome.ok) {
+      yield { type: "error", text: formatError(outcome.err), timestamp: now3() };
+      return;
+    }
+    const stopReason = outcome.res.stopReason;
+    if (stopReason === "refusal") {
+      yield { type: "error", text: "agent refused the request", timestamp: now3() };
+      return;
+    }
+    const usage = outcome.res.usage;
+    if (usage) {
+      yield {
+        type: "usage",
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadTokens: usage.cachedReadTokens ?? 0,
+        cacheCreationTokens: usage.cachedWriteTokens ?? 0,
+        durationMs: 0,
+        numTurns: 1,
+        timestamp: now3()
+      };
+    }
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  cancel() {
+    if (this.cancelled) {
+      this.abortPrompt?.();
+      return;
+    }
+    this.cancelled = true;
+    if (this.sessionId) {
+      this.conn.cancel({ sessionId: this.sessionId }).catch(() => {});
+    }
+    this.abortPrompt?.();
+  }
+  close() {
+    this.abortPrompt?.();
+    this.updates.close();
+  }
+  async onRequestPermission(params) {
+    if (this.cancelled || this.deps.signal?.aborted) {
+      return { outcome: { outcome: "cancelled" } };
+    }
+    const tc = params.toolCall;
+    const call = {
+      toolName: tc.title || tc.kind || "tool",
+      toolInput: tc.rawInput ?? {},
+      toolUseId: tc.toolCallId
+    };
+    let verdict;
+    try {
+      verdict = await this.deps.gateToolCall(call, this.deps.procCtx());
+    } catch (err) {
+      if (isPauseSignal(err)) {
+        this.pendingPause = err;
+        this.cancel();
+        return { outcome: { outcome: "cancelled" } };
       }
-    } finally {
-      inboxQueue?.close();
+      throw err;
+    }
+    if (verdict.kind === "abort") {
+      this.cancel();
+      return { outcome: { outcome: "cancelled" } };
     }
+    const wantedKinds = verdict.kind === "allow" ? OPTION_KIND_FOR_VERDICT.allow : OPTION_KIND_FOR_VERDICT.deny;
+    const option = params.options.find((o) => wantedKinds.includes(o.kind)) ?? params.options[0];
+    if (!option) {
+      return { outcome: { outcome: "cancelled" } };
+    }
+    return { outcome: { outcome: "selected", optionId: option.optionId } };
   }
 }
-function createClaudeRuntime(config = {}) {
-  return defineRuntime({
-    create: (sandbox, opts) => new ClaudeRunner(sandbox, opts, config)
-  });
-}
-var claude_default = createClaudeRuntime();
+
 // src/runtimes/_cli-agent.ts
-function now3() {
+function now4() {
   return new Date().toISOString();
 }
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+var ACP_FALLBACK = Symbol("acp-fallback");
+var ACP_HANDSHAKE_TIMEOUT_MS = Number(process.env.AC_ACP_HANDSHAKE_TIMEOUT_MS) || 1e4;
+var ACP_TRANSPORT_READY = true;
+async function withHandshakeTimeout(p, ms) {
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error(`ACP handshake timed out after ${ms}ms`)), ms);
+  });
+  try {
+    return await Promise.race([p, timeout]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
 
 class CliAgentRunner {
   sandbox;
@@ -2508,6 +2957,16 @@ class CliAgentRunner {
   spec;
   configModel;
   kind;
+  get acpCapable() {
+    return this.spec.acp !== undefined && this.acpTransportReady && typeof this.sandbox.commands.spawnDuplex === "function";
+  }
+  get supportsToolCallProcessor() {
+    return this.acpCapable;
+  }
+  acpDecision;
+  acpSession;
+  currentAcpProcCtx;
+  acpTransportReady = ACP_TRANSPORT_READY;
   constructor(sandbox, options, spec, configModel) {
     this.sandbox = sandbox;
     this.options = options;
@@ -2515,9 +2974,37 @@ class CliAgentRunner {
     this.configModel = configModel;
     this.kind = spec.kind;
   }
+  enableAcpForTesting() {
+    this.acpTransportReady = true;
+  }
   get model() {
     return this.configModel ?? this.options.model ?? this.spec.defaultModel;
   }
+  async gateToolCall(call, ctx) {
+    const verdict = await runProcessorChain(this.options.processors ?? [], (p) => p.processToolCall, call, ctx);
+    if (verdict.kind === "continue")
+      return { kind: "allow", call: verdict.value };
+    return verdict;
+  }
+  buildProcCtx(signal, iteration) {
+    const agentId = this.options.agentId ?? "agent";
+    const iter = iteration ?? 1;
+    return {
+      requestContext: this.options.requestContext ?? RequestContext.fromReserved({
+        teamId: "",
+        runId: "",
+        workflowId: "",
+        factoryId: null,
+        apiKeyScopes: [],
+        parentRunId: null
+      }),
+      abortSignal: signal ?? new AbortController().signal,
+      retryCount: 0,
+      agentId,
+      iteration: iter,
+      pause: boundProcessorPause(this.options.pause, { agentId, iteration: iter })
+    };
+  }
   installed = false;
   async ensureInstalled() {
     if (this.installed)
@@ -2534,7 +3021,133 @@ class CliAgentRunner {
     this.installed = true;
   }
   async* sendMessage(opts) {
-    yield { type: "init", sessionId: opts.sessionId ?? "", timestamp: now3() };
+    yield { type: "init", sessionId: opts.sessionId ?? "", timestamp: now4() };
+    if (this.acpCapable && this.acpDecision !== "jsonl") {
+      let fellBack = false;
+      try {
+        for await (const ev of this.sendMessageAcp(opts)) {
+          if (ev === ACP_FALLBACK) {
+            fellBack = true;
+            break;
+          }
+          yield ev;
+        }
+      } catch (err) {
+        if (isPauseSignal(err))
+          throw err;
+        yield { type: "error", text: formatError(err), timestamp: now4() };
+        return;
+      }
+      if (!fellBack) {
+        this.acpDecision = "acp";
+        return;
+      }
+      this.acpDecision = "jsonl";
+    }
+    yield* this.sendMessageJsonl(opts);
+  }
+  async teardownAcp(proc, peer) {
+    peer.close();
+    try {
+      await proc.stream.writable.close();
+    } catch {}
+    proc.kill();
+    proc.exited.catch(() => {});
+  }
+  async ensureAcpSession(opts) {
+    if (this.acpSession)
+      return this.acpSession;
+    await this.ensureInstalled();
+    const acp = this.spec.acp;
+    const proc = this.spawnAcpProcess(acp, opts.signal);
+    const peer = new AcpClientPeer({
+      stream: proc.stream,
+      gateToolCall: (call, ctx) => this.gateToolCall(call, ctx),
+      procCtx: () => this.currentAcpProcCtx ?? this.buildProcCtx(opts.signal, opts.iteration),
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    let negotiated;
+    try {
+      ({ protocolVersion: negotiated } = await withHandshakeTimeout(peer.initialize(), ACP_HANDSHAKE_TIMEOUT_MS));
+    } catch {
+      await this.teardownAcp(proc, peer);
+      return null;
+    }
+    if (negotiated !== ACP_PROTOCOL_VERSION) {
+      await this.teardownAcp(proc, peer);
+      return null;
+    }
+    let sessionId;
+    try {
+      sessionId = await withHandshakeTimeout(peer.startSession(this.options.cwd ?? "/"), ACP_HANDSHAKE_TIMEOUT_MS);
+    } catch {
+      await this.teardownAcp(proc, peer);
+      return null;
+    }
+    this.acpSession = { proc, peer, sessionId };
+    return this.acpSession;
+  }
+  async* sendMessageAcp(opts) {
+    this.currentAcpProcCtx = this.buildProcCtx(opts.signal, opts.iteration);
+    const session = await this.ensureAcpSession(opts);
+    if (!session) {
+      yield ACP_FALLBACK;
+      return;
+    }
+    const { proc, peer, sessionId } = session;
+    let sawError = false;
+    let stalled = false;
+    let watchdog;
+    const armWatchdog = () => {
+      if (watchdog)
+        clearTimeout(watchdog);
+      watchdog = setTimeout(() => {
+        stalled = true;
+        peer.cancel();
+      }, ACP_HANDSHAKE_TIMEOUT_MS);
+    };
+    try {
+      armWatchdog();
+      for await (const msg of peer.prompt(opts.prompt)) {
+        armWatchdog();
+        if (msg.type === "error")
+          sawError = true;
+        yield msg;
+      }
+    } finally {
+      if (watchdog)
+        clearTimeout(watchdog);
+    }
+    if (stalled && !sawError) {
+      await this.teardownAcp(proc, peer);
+      this.acpSession = undefined;
+      yield { type: "error", text: `${this.spec.kind} prompt turn stalled (no activity for ${ACP_HANDSHAKE_TIMEOUT_MS}ms)`, timestamp: now4() };
+      return;
+    }
+    if (!sawError)
+      yield { type: "done", sessionId: peer.currentSessionId ?? sessionId, timestamp: now4() };
+  }
+  spawnAcpProcess(acp, signal) {
+    const spawnDuplex = this.sandbox.commands.spawnDuplex;
+    if (!spawnDuplex) {
+      throw new Error("spawnAcpProcess called on a provider without commands.spawnDuplex");
+    }
+    const cmd = `${acp.command} ${acp.args.map(shellQuote).join(" ")}`.trim();
+    const agentEnv = { ...acp.env };
+    const proc = spawnDuplex.call(this.sandbox.commands, cmd, {
+      ...this.options.cwd ? { cwd: this.options.cwd } : {},
+      ...Object.keys(agentEnv).length > 0 ? { envs: agentEnv } : {}
+    });
+    const kill = () => proc.kill();
+    if (signal) {
+      if (signal.aborted)
+        kill();
+      else
+        signal.addEventListener("abort", kill, { once: true });
+    }
+    return { stream: ndJsonStream(proc.stdin, proc.stdout), exited: proc.exited, kill };
+  }
+  async* sendMessageJsonl(opts) {
     let sessionId = opts.sessionId;
     let sawError = false;
     try {
@@ -2592,13 +3205,13 @@ class CliAgentRunner {
       const res = await runPromise;
       if (res.exitCode !== 0 && !sawError) {
         const tail = (res.stderr ?? "").slice(-2000);
-        yield { type: "error", text: `${this.spec.kind} exited with code ${res.exitCode}${tail ? `: ${tail}` : ""}`, timestamp: now3() };
+        yield { type: "error", text: `${this.spec.kind} exited with code ${res.exitCode}${tail ? `: ${tail}` : ""}`, timestamp: now4() };
         return;
       }
       if (!sawError)
-        yield { type: "done", sessionId: sessionId ?? "", timestamp: now3() };
+        yield { type: "done", sessionId: sessionId ?? "", timestamp: now4() };
     } catch (err) {
-      yield { type: "error", text: formatError(err), timestamp: now3() };
+      yield { type: "error", text: formatError(err), timestamp: now4() };
     }
   }
 }
@@ -2609,13 +3222,19 @@ function createCliAgentRuntime(spec, configModel) {
 }
 
 // src/runtimes/codex.ts
-function now4() {
+function now5() {
   return new Date().toISOString();
 }
+var CODEX_ACP_ADAPTER = "@agentclientprotocol/codex-acp@0.1.0";
 var codexSpec = {
   kind: "codex",
   authEnv: "CODEX_API_KEY",
   bin: "codex",
+  acp: {
+    command: "npx",
+    args: ["-y", CODEX_ACP_ADAPTER],
+    ...process.env.CODEX_PATH ? { env: { CODEX_PATH: process.env.CODEX_PATH } } : {}
+  },
   install: 'sudo npm install -g @openai/codex && (command -v codex >/dev/null 2>&1 || sudo ln -sf "$(npm prefix -g)/bin/codex" /usr/local/bin/codex)',
   promptPayload: (prompt) => prompt,
   buildCommand: ({ promptPath, sessionId, model, cwd }) => {
@@ -2631,7 +3250,7 @@ var codexSpec = {
   },
   extractSessionId: (p) => p.type === "thread.started" && typeof p.thread_id === "string" ? p.thread_id : undefined,
   mapEvent: (p) => {
-    const ts = now4();
+    const ts = now5();
     switch (p.type) {
       case "item.started":
       case "item.completed": {
@@ -2686,7 +3305,7 @@ function createCodexRuntime(config = {}) {
 }
 var codex_default = createCodexRuntime();
 // src/runtimes/amp.ts
-function now5() {
+function now6() {
   return new Date().toISOString();
 }
 function blocks(msg) {
@@ -2706,7 +3325,7 @@ var ampSpec = {
   },
   extractSessionId: (p) => typeof p.session_id === "string" ? p.session_id : undefined,
   mapEvent: (p) => {
-    const ts = now5();
+    const ts = now6();
     if (p.type === "assistant") {
       return blocks(p).flatMap((b) => {
         if (b.type === "text")
@@ -2751,6 +3370,7 @@ var amp_default = createAmpRuntime();
 import { promises as fs2 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
 import { spawn } from "node:child_process";
+import { Readable, Writable } from "node:stream";
 import { Sandbox, SandboxNotFoundError, RateLimitError } from "e2b";
 import { Sandbox as Desktop } from "@e2b/desktop";
 import pRetry from "p-retry";
@@ -2779,6 +3399,26 @@ var SANDBOX_VCPUS = {
   "32vcpu-64gb": 32
 };
 var DEFAULT_SANDBOX_SIZE = "2vcpu-4gb";
+var E2B_TEMPLATE_SIZES = [
+  "2vcpu-4gb",
+  "4vcpu-8gb"
+];
+function isE2bSupportedSize(size) {
+  return E2B_TEMPLATE_SIZES.includes(size);
+}
+function e2bMachineSpec(size) {
+  const cpuCount = SANDBOX_VCPUS[size];
+  return { cpuCount, memoryMB: cpuCount * 2048 };
+}
+function e2bBaseTemplate(size) {
+  return `agent-compose-base-${size}`;
+}
+function e2bAgentEnvTemplate(size) {
+  return `agent-env-${size}`;
+}
+function isPlatformE2bTemplateAlias(id) {
+  return E2B_TEMPLATE_SIZES.some((size) => id === e2bBaseTemplate(size) || id === e2bAgentEnvTemplate(size));
+}
 function makeSandboxProvider(sb) {
   const commands = sb.commands;
   return {
@@ -2786,18 +3426,33 @@ function makeSandboxProvider(sb) {
     commands: {
       async run(cmd, opts) {
         let stderr = "";
-        const result = await commands.run(cmd, {
-          ...opts,
+        const { sudo, ...rest } = opts ?? {};
+        const runOpts = {
+          ...rest,
+          ...sudo ? { user: "root" } : {},
           onStderr: (chunk) => {
             stderr += chunk;
             opts?.onStderr?.(chunk);
           }
-        });
-        return {
-          exitCode: result.exitCode,
-          stdout: result.stdout,
-          stderr: typeof result.stderr === "string" ? result.stderr : stderr
         };
+        try {
+          const result = await commands.run(cmd, runOpts);
+          return {
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: typeof result.stderr === "string" ? result.stderr : stderr
+          };
+        } catch (e) {
+          const ce = e;
+          if (typeof ce.exitCode === "number") {
+            return {
+              exitCode: ce.exitCode,
+              stdout: typeof ce.stdout === "string" ? ce.stdout : "",
+              stderr: typeof ce.stderr === "string" ? ce.stderr : stderr
+            };
+          }
+          throw e;
+        }
       }
     },
     files: {
@@ -2805,7 +3460,9 @@ function makeSandboxProvider(sb) {
         await sb.files.write(path, content);
       }
     },
-    kill: () => sb.kill()
+    async kill() {
+      await sb.kill();
+    }
   };
 }
 function e2bMaxSandboxMs() {
@@ -2826,12 +3483,66 @@ function withSnapshotRetry(p) {
   const snapshot = p.snapshot.bind(p);
   return { ...p, snapshot: () => withSandboxRetry(snapshot) };
 }
+function wrapE2bBackgroundProcess(handle) {
+  return {
+    pid: handle.pid,
+    async wait() {
+      try {
+        const r = await handle.wait();
+        return { exitCode: r.exitCode ?? 0, stdout: r.stdout, stderr: r.stderr };
+      } catch (e) {
+        const ce = e;
+        if (typeof ce.exitCode === "number") {
+          return {
+            exitCode: ce.exitCode,
+            stdout: typeof ce.stdout === "string" ? ce.stdout : "",
+            stderr: typeof ce.stderr === "string" ? ce.stderr : ""
+          };
+        }
+        throw e;
+      }
+    },
+    async kill() {
+      await handle.kill();
+    }
+  };
+}
 function makeE2bSandboxProvider(sb) {
+  const base = makeSandboxProvider(sb);
   return {
-    ...makeSandboxProvider(sb),
+    ...base,
+    commands: {
+      ...base.commands,
+      async runBackground(cmd, opts) {
+        const { sudo, onStdout, onStderr, ...rest } = opts ?? {};
+        const handle = await sb.commands.run(cmd, {
+          ...rest,
+          background: true,
+          ...sudo ? { user: "root" } : {},
+          ...onStdout ? { onStdout } : {},
+          ...onStderr ? { onStderr } : {}
+        });
+        return wrapE2bBackgroundProcess(handle);
+      },
+      async connectProcess(pid, opts) {
+        const handle = await sb.commands.connect(pid, {
+          ...opts?.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {},
+          ...opts?.onStdout ? { onStdout: opts.onStdout } : {},
+          ...opts?.onStderr ? { onStderr: opts.onStderr } : {}
+        });
+        return wrapE2bBackgroundProcess(handle);
+      }
+    },
     async snapshot() {
       const { snapshotId } = await sb.createSnapshot();
       return { snapshotId };
+    },
+    async pauseProcess() {
+      await sb.pause();
+      return { resumeHandle: sb.sandboxId };
+    },
+    async updateNetworkPolicy(policy) {
+      await sb.updateNetwork(toE2bNetwork(policy));
     }
   };
 }
@@ -2923,6 +3634,31 @@ function toVercelNetworkPolicy(policy) {
   }
   return { ...policy, allow };
 }
+function toE2bNetwork(policy) {
+  if (policy === "allow-all")
+    return {};
+  if (policy === "deny-all")
+    return { denyOut: ({ allTraffic }) => [allTraffic] };
+  const allowHosts = Array.isArray(policy.allow) ? [...policy.allow] : Object.keys(policy.allow ?? {});
+  const subnetAllow = policy.subnets?.allow ?? [];
+  const allowOut = [...new Set([...allowHosts, ...subnetAllow])];
+  const network = {
+    denyOut: ({ allTraffic }) => [allTraffic]
+  };
+  if (allowOut.length > 0)
+    network.allowOut = allowOut;
+  if (!Array.isArray(policy.allow) && policy.allow) {
+    const rules = {};
+    for (const [host, hostRules] of Object.entries(policy.allow)) {
+      const hostTransforms = hostRules.flatMap((rule) => (rule.transform ?? []).filter((t) => t.headers && Object.keys(t.headers).length > 0).map((t) => ({ transform: { headers: t.headers } })));
+      if (hostTransforms.length > 0)
+        rules[host] = hostTransforms;
+    }
+    if (Object.keys(rules).length > 0)
+      network.rules = rules;
+  }
+  return network;
+}
 var VERCEL_MAX_TAGS = 5;
 function buildVercelTags(metadata) {
   const tags = { ...metadata, executor: AGENT_COMPOSE_TAG };
@@ -3031,6 +3767,38 @@ function makeLocalSandboxProvider() {
           proc.on("error", reject);
           proc.on("close", (code) => resolve({ exitCode: code ?? 0, stdout, stderr }));
         });
+      },
+      spawnDuplex(cmd, opts) {
+        const proc = spawn("sh", ["-c", cmd], {
+          ...opts?.cwd ? { cwd: opts.cwd } : {},
+          env: { ...process.env, ...opts?.envs ?? {} },
+          stdio: ["pipe", "pipe", "pipe"],
+          detached: true
+        });
+        let stderr = "";
+        proc.stderr.setEncoding("utf8");
+        proc.stderr.on("data", (chunk) => {
+          stderr += chunk;
+        });
+        const exited = new Promise((resolve, reject) => {
+          proc.on("error", reject);
+          proc.on("close", (code) => resolve({ exitCode: code ?? 0, stderr }));
+        });
+        return {
+          stdin: Writable.toWeb(proc.stdin),
+          stdout: Readable.toWeb(proc.stdout),
+          exited,
+          kill() {
+            if (proc.pid === undefined)
+              return;
+            try {
+              process.kill(-proc.pid, "SIGTERM");
+            } catch (err) {
+              if (err.code !== "ESRCH")
+                throw err;
+            }
+          }
+        };
       }
     },
     files: {
@@ -3098,17 +3866,36 @@ var SANDBOX_PROVIDERS = {
       const creds = { token: env.VERCEL_ACCESS_TOKEN, teamId: env.VERCEL_TEAM_ID, projectId: env.VERCEL_PROJECT_ID };
       const snap = await Snapshot.get({ snapshotId, ...creds });
       await snap.delete();
+    },
+    snapshotExists: async (snapshotId, env) => {
+      const { Snapshot } = await import("@vercel/sandbox");
+      const creds = { token: env.VERCEL_ACCESS_TOKEN, teamId: env.VERCEL_TEAM_ID, projectId: env.VERCEL_PROJECT_ID };
+      try {
+        await Snapshot.get({ snapshotId, ...creds });
+        return true;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err ?? "");
+        const status = err?.status ?? err?.statusCode;
+        if (status === 404 || /\b404\b|not[\s_-]?found|no such snapshot/i.test(message))
+          return false;
+        throw err;
+      }
     }
   },
   e2b: {
     requiredEnv: { E2B_API_KEY: "E2B API key — e2b.dev/dashboard" },
-    create: async ({ template, timeoutMs, networkPolicy: _np, size: _size, ...rest }) => {
+    create: async ({ template, timeoutMs, networkPolicy, size, ...rest }) => {
       const maxMs = e2bMaxSandboxMs();
       if (timeoutMs > maxMs) {
         console.warn(`[sandbox] e2b create timeout clamped: requested ${timeoutMs}ms exceeds the plan cap ${maxMs}ms — ` + `the sandbox dies at the cap, not the requested deadline. Raise E2B_MAX_SANDBOX_MS on plans that allow more.`);
       }
-      const sandboxOpts = { ...rest, timeoutMs: Math.min(timeoutMs, maxMs) };
-      const tmpl = template ?? process.env.E2B_DEFAULT_TEMPLATE;
+      const sandboxOpts = {
+        ...rest,
+        timeoutMs: Math.min(timeoutMs, maxMs),
+        ...networkPolicy ? { network: toE2bNetwork(networkPolicy) } : {}
+      };
+      const resolvedSize = size ?? DEFAULT_SANDBOX_SIZE;
+      const tmpl = template ?? (isE2bSupportedSize(resolvedSize) ? e2bBaseTemplate(resolvedSize) : undefined) ?? process.env.E2B_DEFAULT_TEMPLATE;
       return makeE2bSandboxProvider(await (tmpl ? Sandbox.create(tmpl, sandboxOpts) : Sandbox.create(sandboxOpts)));
     },
     reconnect: async (sandboxId) => makeE2bSandboxProvider(await Sandbox.connect(sandboxId, { apiKey: process.env.E2B_API_KEY ?? "", timeoutMs: 3600000 })),
@@ -3144,10 +3931,16 @@ var SANDBOX_PROVIDERS = {
   },
   "e2b-desktop": {
     requiredEnv: { E2B_API_KEY: "E2B API key — e2b.dev/dashboard" },
-    create: async ({ template, timeoutMs, networkPolicy: _np, size: _size, ...rest }) => {
+    create: async ({ template, timeoutMs, networkPolicy, size: _size, ...rest }) => {
       if (!template)
         throw new Error("E2B Desktop provider requires an explicit `template` (Dockerfile-based — no default base image)");
-      return makeDesktopSandboxProvider(await Desktop.create(template, { ...rest, timeoutMs: Math.min(timeoutMs, e2bMaxSandboxMs()) }));
+      if (networkPolicy && networkPolicy !== "allow-all") {
+        throw new Error("E2B Desktop provider cannot enforce an egress network policy — `@e2b/desktop` bundles an e2b version that predates the native firewall. " + "e2b-desktop is registry-only and must not run with a confined policy.");
+      }
+      return makeDesktopSandboxProvider(await Desktop.create(template, {
+        ...rest,
+        timeoutMs: Math.min(timeoutMs, e2bMaxSandboxMs())
+      }));
     }
   }
 };
@@ -3180,6 +3973,17 @@ ${missing.join(`
 `)}`);
   return def.deleteSnapshot(snapshotId, Object.fromEntries(Object.keys(def.requiredEnv).map((k) => [k, process.env[k]])));
 }
+async function snapshotResolves(provider, snapshotId) {
+  const def = SANDBOX_PROVIDERS[provider];
+  if (!def?.snapshotExists)
+    throw new Error(`Provider "${provider}" does not support snapshotExists`);
+  const missing = Object.entries(def.requiredEnv).filter(([k]) => !process.env[k]).map(([k, desc]) => `  ${k} — ${desc}`);
+  if (missing.length > 0)
+    throw new Error(`Sandbox provider "${provider}" requires env vars:
+${missing.join(`
+`)}`);
+  return def.snapshotExists(snapshotId, Object.fromEntries(Object.keys(def.requiredEnv).map((k) => [k, process.env[k]])));
+}
 async function getSandboxQuotas() {
   const out = {};
   await Promise.all(Object.entries(SANDBOX_PROVIDERS).map(async ([name, def]) => {
@@ -3235,17 +4039,34 @@ class StepObservabilityCollector {
   events = [];
   subSteps = [];
   liveEmitter;
+  memoize;
+  usedStepNames = new Set;
   ackedSeqs = new Set;
   inFlight = new Set;
   constructor(opts = {}) {
     this.liveEmitter = opts.liveEmitter;
+    this.memoize = opts.memoize;
   }
   setMetadata = async (data) => {
     Object.assign(this.metadata, data);
   };
   step = async (name, fn) => {
+    if (this.usedStepNames.has(name)) {
+      throw new Error(`ctx.step("${name}", …) reuses a step name already used in this step body. ` + `Durable step names must be unique — they key the resume-time memoise file.`);
+    }
+    this.usedStepNames.add(name);
     const startedAt = Date.now();
     try {
+      if (this.memoize) {
+        const { value, restored } = await this.memoize(name, fn);
+        this.subSteps.push({
+          name,
+          startedAt,
+          durationMs: restored ? 0 : Date.now() - startedAt,
+          status: restored ? "restored" : "completed"
+        });
+        return value;
+      }
       const result = await fn();
       this.subSteps.push({
         name,
@@ -3309,19 +4130,19 @@ class StepObservabilityCollector {
 }
 
 // src/pause/checkpoint.ts
-async function checkpoint(name, fn) {
+async function memoize(name, fn) {
   const existing = await readCheckpoint(name);
   if (existing.found)
-    return existing.value;
+    return { value: existing.value, restored: true };
   const value = await fn();
   await writeCheckpoint(name, value);
-  return value;
+  return { value, restored: false };
 }
-function scopedCheckpoint(scope) {
+function scopedMemoize(scope) {
   assertSafeCheckpointName(scope);
   return async (name, fn) => {
     assertSafeCheckpointName(name);
-    return checkpoint(`${scope}.${name}`, fn);
+    return memoize(`${scope}.${name}`, fn);
   };
 }
 
@@ -3389,7 +4210,10 @@ async function runWorkflowSingleStep(opts) {
   const parsedInput = step.input.safeParse(opts.input);
   if (!parsedInput.success)
     throw new StepValidationError(step.name, "input", parsedInput.error);
-  const collector = new StepObservabilityCollector({ liveEmitter: opts.liveAgentEventEmitter });
+  const collector = new StepObservabilityCollector({
+    liveEmitter: opts.liveAgentEventEmitter,
+    memoize: scopedMemoize(`step${opts.stepIndex}`)
+  });
   const coord = { runId: opts.run.id, stepIndex: opts.stepIndex };
   const pauseWithKind = function(req, kind) {
     return corePause(req, coord, kind);
@@ -3410,7 +4234,6 @@ async function runWorkflowSingleStep(opts) {
     setMetadata: collector.setMetadata,
     step: collector.step,
     agentEvents: collector.agentEvents,
-    checkpoint: scopedCheckpoint(`step${opts.stepIndex}`),
     pause,
     ...buildPauseWrappers(pauseWithKind)
   };
@@ -3466,7 +4289,10 @@ async function runWorkflowSteps(opts) {
       await opts.onStepFailed?.(i, step.name, err, 0);
       throw err;
     }
-    const collector = new StepObservabilityCollector({ liveEmitter: opts.liveAgentEventEmitter });
+    const collector = new StepObservabilityCollector({
+      liveEmitter: opts.liveAgentEventEmitter,
+      memoize: scopedMemoize(`step${i}`)
+    });
     const coord = { runId: run.id, stepIndex: i };
     const pauseWithKind = function(req, kind) {
       return corePause(req, coord, kind);
@@ -3485,7 +4311,6 @@ async function runWorkflowSteps(opts) {
       setMetadata: collector.setMetadata,
       step: collector.step,
       agentEvents: collector.agentEvents,
-      checkpoint: scopedCheckpoint(`step${i}`),
       pause,
       ...buildPauseWrappers(pauseWithKind)
     };
@@ -3682,32 +4507,32 @@ function stepResultFilePath(token) {
 }
 // src/step-invocation/invoker.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { z as z10 } from "zod";
-var StepObservabilitySchema = z10.object({
-  metadata: z10.record(z10.string(), z10.unknown()).optional(),
-  events: z10.array(z10.unknown()).optional(),
-  subSteps: z10.array(z10.object({
-    name: z10.string(),
-    startedAt: z10.number(),
-    durationMs: z10.number(),
-    status: z10.enum(["completed", "failed"]),
-    error: z10.string().optional()
+import { z as z11 } from "zod";
+var StepObservabilitySchema = z11.object({
+  metadata: z11.record(z11.string(), z11.unknown()).optional(),
+  events: z11.array(z11.unknown()).optional(),
+  subSteps: z11.array(z11.object({
+    name: z11.string(),
+    startedAt: z11.number(),
+    durationMs: z11.number(),
+    status: z11.enum(["completed", "failed"]),
+    error: z11.string().optional()
   })).optional()
 }).passthrough();
-var StepResultEnvelopeSchema = z10.discriminatedUnion("ok", [
-  z10.object({
-    ok: z10.literal(true),
-    output: z10.unknown().optional(),
+var StepResultEnvelopeSchema = z11.discriminatedUnion("ok", [
+  z11.object({
+    ok: z11.literal(true),
+    output: z11.unknown().optional(),
     observability: StepObservabilitySchema.optional()
   }),
-  z10.object({
-    ok: z10.literal(false),
-    kind: z10.enum(["protocol", "user-step"]),
-    error: z10.string().optional()
+  z11.object({
+    ok: z11.literal(false),
+    kind: z11.enum(["protocol", "user-step"]),
+    error: z11.string().optional()
   })
 ]);
-var StepPauseEnvelopeSchema = z10.object({
-  pauseId: z10.string().min(1),
+var StepPauseEnvelopeSchema = z11.object({
+  pauseId: z11.string().min(1),
   pauseRequest: StepPauseRequestSchema,
   observability: StepObservabilitySchema.optional()
 });
@@ -3786,25 +4611,11 @@ function parseStepResult(stdout, resultToken) {
   const message = baseMessage;
   return { ok: false, error: { kind, message } };
 }
-async function invokeStep(sandbox, request, opts) {
-  const resultToken = randomBytes2(16).toString("hex");
-  await Promise.all([
-    sandbox.files.write(stepInputPath(request.stepIndex), JSON.stringify(request.input)),
-    sandbox.files.write(requestContextPath(request.stepIndex), JSON.stringify(request.requestContext))
-  ]);
-  const envs = {
-    ...opts?.envs ?? {},
-    ...buildStepEnvs({
-      runId: request.runId,
-      stepIndex: request.stepIndex,
-      resultToken,
-      isResume: opts?.isResume
-    })
-  };
+function makeStreamSplitters(opts, resultToken) {
   const resultSentinel = stepResultLinePrefix(resultToken);
   const pauseSentinel = stepPauseLinePrefix(resultToken);
   const isSentinel = (line) => line.startsWith(resultSentinel) || line.startsWith(pauseSentinel);
-  const makeLineSplitter = (sink, filterSentinel) => {
+  const make = (sink, filterSentinel) => {
     if (!sink)
       return { onChunk: undefined, flush: () => {} };
     let buf = "";
@@ -3832,29 +4643,19 @@ async function invokeStep(sandbox, request, opts) {
       }
     };
   };
-  const stdoutSplitter = makeLineSplitter(opts?.onStdout, true);
-  const stderrSplitter = makeLineSplitter(opts?.onStderr, false);
-  let result;
-  try {
-    result = await sandbox.commands.run(RUNNER_COMMAND, {
-      envs,
-      timeoutMs: 0,
-      ...stdoutSplitter.onChunk ? { onStdout: stdoutSplitter.onChunk } : {},
-      ...stderrSplitter.onChunk ? { onStderr: stderrSplitter.onChunk } : {}
-    });
-  } catch (e) {
-    if (e instanceof SandboxUnavailableError)
-      throw e;
-    const ce = e;
-    result = {
-      stdout: ce.stdout ?? ce.result?.stdout ?? "",
-      stderr: ce.stderr ?? ce.result?.stderr ?? (e instanceof Error ? e.message : String(e)),
-      exitCode: ce.exitCode ?? ce.result?.exitCode ?? 1
-    };
-  }
-  stdoutSplitter.flush();
-  stderrSplitter.flush();
-  const parsed = parseStepResult(result.stdout, resultToken);
+  const stdout = make(opts?.onStdout, true);
+  const stderr = make(opts?.onStderr, false);
+  return {
+    ...stdout.onChunk ? { onStdout: stdout.onChunk } : {},
+    ...stderr.onChunk ? { onStderr: stderr.onChunk } : {},
+    flush: () => {
+      stdout.flush();
+      stderr.flush();
+    }
+  };
+}
+async function classifyRunnerOutcome(sandbox, output, resultToken) {
+  const parsed = parseStepResult(output.stdout, resultToken);
   if (parsed)
     return parsed;
   const fileRead = await sandbox.commands.run(`cat ${stepResultFilePath(resultToken)} 2>/dev/null || true`).catch(() => null);
@@ -3863,9 +4664,9 @@ async function invokeStep(sandbox, request, opts) {
     if (fromFile)
       return fromFile;
   }
-  if (result.exitCode !== 0) {
-    const stderrTail = result.stderr.trim().slice(-2000);
-    const stdoutTail = result.stdout.trim().slice(-2000);
+  if (output.exitCode !== 0) {
+    const stderrTail = output.stderr.trim().slice(-2000);
+    const stdoutTail = output.stdout.trim().slice(-2000);
     const details = [
       stderrTail ? `stderr:
 ${stderrTail}` : "",
@@ -3877,13 +4678,13 @@ ${stdoutTail}` : ""
       ok: false,
       error: {
         kind: "runner-exit",
-        message: `runner subprocess exited ${result.exitCode} before emitting a step result${details ? `
+        message: `runner subprocess exited ${output.exitCode} before emitting a step result${details ? `
 ${details}` : ""}`,
-        exitCode: result.exitCode
+        exitCode: output.exitCode
       }
     };
   }
-  const tail = result.stdout.trim().slice(-500);
+  const tail = output.stdout.trim().slice(-500);
   return {
     ok: false,
     error: {
@@ -3894,6 +4695,99 @@ ${tail}` : ""}`
     }
   };
 }
+async function prepareStepLaunch(sandbox, request, opts) {
+  const resultToken = randomBytes2(16).toString("hex");
+  await Promise.all([
+    sandbox.files.write(stepInputPath(request.stepIndex), JSON.stringify(request.input)),
+    sandbox.files.write(requestContextPath(request.stepIndex), JSON.stringify(request.requestContext))
+  ]);
+  const envs = {
+    ...opts?.envs ?? {},
+    ...buildStepEnvs({ runId: request.runId, stepIndex: request.stepIndex, resultToken, isResume: opts?.isResume })
+  };
+  return { resultToken, envs };
+}
+async function invokeStep(sandbox, request, opts) {
+  const { resultToken, envs } = await prepareStepLaunch(sandbox, request, opts);
+  const splitters = makeStreamSplitters(opts, resultToken);
+  let result;
+  try {
+    result = await sandbox.commands.run(RUNNER_COMMAND, {
+      envs,
+      timeoutMs: 0,
+      ...splitters.onStdout ? { onStdout: splitters.onStdout } : {},
+      ...splitters.onStderr ? { onStderr: splitters.onStderr } : {}
+    });
+  } catch (e) {
+    if (e instanceof SandboxUnavailableError)
+      throw e;
+    const ce = e;
+    result = {
+      stdout: ce.stdout ?? ce.result?.stdout ?? "",
+      stderr: ce.stderr ?? ce.result?.stderr ?? (e instanceof Error ? e.message : String(e)),
+      exitCode: ce.exitCode ?? ce.result?.exitCode ?? 1
+    };
+  }
+  splitters.flush();
+  return classifyRunnerOutcome(sandbox, result, resultToken);
+}
+async function launchStep(sandbox, request, opts) {
+  if (!sandbox.commands.runBackground) {
+    throw new Error("launchStep requires a provider with background-command support (commands.runBackground)");
+  }
+  const { resultToken, envs } = await prepareStepLaunch(sandbox, request, opts);
+  const splitters = makeStreamSplitters(opts, resultToken);
+  const proc = await sandbox.commands.runBackground(RUNNER_COMMAND, {
+    envs,
+    timeoutMs: 0,
+    ...splitters.onStdout ? { onStdout: splitters.onStdout } : {},
+    ...splitters.onStderr ? { onStderr: splitters.onStderr } : {}
+  });
+  return {
+    runnerPid: proc.pid,
+    resultToken,
+    async wait() {
+      const result = await proc.wait();
+      splitters.flush();
+      return classifyRunnerOutcome(sandbox, result, resultToken);
+    }
+  };
+}
+async function reconnectStep(sandbox, resume, opts) {
+  if (!sandbox.commands.connectProcess) {
+    throw new Error("reconnectStep requires a provider with background-command support (commands.connectProcess)");
+  }
+  const { runnerPid, resultToken } = resume;
+  const splitters = makeStreamSplitters(opts, resultToken);
+  let proc = null;
+  try {
+    proc = await sandbox.commands.connectProcess(runnerPid, {
+      ...splitters.onStdout ? { onStdout: splitters.onStdout } : {},
+      ...splitters.onStderr ? { onStderr: splitters.onStderr } : {}
+    });
+  } catch (e) {
+    if (e instanceof SandboxUnavailableError)
+      throw e;
+  }
+  const attached = proc;
+  return {
+    runnerPid,
+    resultToken,
+    async wait() {
+      let output = { stdout: "", stderr: "", exitCode: 0 };
+      if (attached) {
+        try {
+          output = await attached.wait();
+        } catch (e) {
+          if (e instanceof SandboxUnavailableError)
+            throw e;
+        }
+      }
+      splitters.flush();
+      return classifyRunnerOutcome(sandbox, output, resultToken);
+    }
+  };
+}
 // src/step-invocation/server.ts
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 function writeSentinelLine(line) {
@@ -4001,7 +4895,7 @@ async function serveStep(handler) {
   process.exit(exitCode);
 }
 // src/agent/run-agent.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/agent/agent-context.ts
@@ -4065,11 +4959,19 @@ Use \`/ac:generate-workflow\` / \`/ac:generate-agent\` to scaffold, then
 
 ## Pausing to ask the human — \`agentc pause\`
 
-When you can't or shouldn't proceed without a human, run \`agentc pause\`. It
-blocks until they answer on the dashboard, then prints their answer to stdout:
+When you can't or shouldn't proceed without a human, run \`agentc pause\`, then
+**END YOUR TURN**:
+
+    agentc pause --reason "Notion returned 401 — connect Notion to continue" \\
+                 --option retry --option skip
 
-    ANSWER=$(agentc pause --reason "Notion returned 401 — connect Notion to continue" \\
-                          --option retry --option skip)
+\`agentc pause\` does NOT block and does NOT print the answer. It records your
+question and returns immediately. The moment you end your turn, the run pauses
+(your sandbox is snapshotted and compute stops while the human decides) and the
+human's answer is delivered to you as your **next message** — you pick up
+exactly where you left off, with the answer in hand. So: ask, end your turn,
+and wait. Do NOT keep working, do NOT call more tools, and do NOT mark the task
+complete after pausing.
 
 Reach for it the moment you hit — or foresee — any of these:
 - **A wall only a human can clear:** a 401/403, a missing credential, an
@@ -4083,8 +4985,8 @@ Reach for it the moment you hit — or foresee — any of these:
   several valid paths, a conflict with existing state, missing input only they have.
 
 You compose the \`--reason\` (the ask) yourself; pass \`--option\` choices when
-there are clear ones, omit them for a free-form answer. Read the printed answer
-and act on it. Each agent pauses independently — pausing doesn't stop the others.
+there are clear ones, omit them for a free-form answer. Each agent pauses
+independently — pausing doesn't stop the others.
 
 ## Credentials
 
@@ -4206,29 +5108,29 @@ function stripFrontmatter(content) {
   return end === -1 ? content : content.slice(end + 4).trimStart();
 }
 function zodTypeName(schema) {
-  if (schema instanceof z11.ZodString)
+  if (schema instanceof z12.ZodString)
     return "string";
-  if (schema instanceof z11.ZodNumber)
+  if (schema instanceof z12.ZodNumber)
     return "number";
-  if (schema instanceof z11.ZodBoolean)
+  if (schema instanceof z12.ZodBoolean)
     return "boolean";
-  if (schema instanceof z11.ZodArray)
+  if (schema instanceof z12.ZodArray)
     return `${zodTypeName(schema.element)}[]`;
-  if (schema instanceof z11.ZodEnum)
+  if (schema instanceof z12.ZodEnum)
     return schema.options.map((o) => `"${o}"`).join(" | ");
-  if (schema instanceof z11.ZodOptional)
+  if (schema instanceof z12.ZodOptional)
     return `${zodTypeName(schema.unwrap())} (optional)`;
-  if (schema instanceof z11.ZodNullable)
+  if (schema instanceof z12.ZodNullable)
     return `${zodTypeName(schema.unwrap())} | null`;
-  if (schema instanceof z11.ZodLiteral)
+  if (schema instanceof z12.ZodLiteral)
     return `"${String(schema.value)}"`;
-  if (schema instanceof z11.ZodObject)
+  if (schema instanceof z12.ZodObject)
     return "object";
   return "any";
 }
 function buildResponseFormatAppendix(schema) {
   const header = ["## Response Format", "", "When you emit `exit_signal: true` in your `<status>` block, also include a `<response>` block containing JSON immediately after `<status>`:", ""];
-  const shape = schema instanceof z11.ZodObject ? schema.shape : null;
+  const shape = schema instanceof z12.ZodObject ? schema.shape : null;
   const body = shape ? (() => {
     const entries = Object.entries(shape);
     const example = Object.fromEntries(entries.map(([k, v]) => [k, `<${zodTypeName(v)}>`]));
@@ -4320,7 +5222,7 @@ async function agent(opts) {
   const mode = opts.mode ?? "auto";
   try {
     return await agentLoop({
-      runtime: (runtimeOpts) => opts.runtime.create(opts.sandbox, runtimeOpts),
+      runtime: (runtimeOpts) => opts.runtime.create(opts.sandbox, { ...runtimeOpts, agentManual: buildAgentContextDoc(process.env) }),
       agentId,
       ...opts.label !== undefined ? { label: opts.label } : {},
       ...opts.budget?.turnsPerIteration !== undefined ? { turnsPerIteration: opts.budget.turnsPerIteration } : {},