@agent-compose/sdk 0.6.0 → 0.8.0

package/dist/runtimes/openai-desktop.js

@@ -717,7 +717,28 @@ async function corePause(req, coord, kind = "custom") {
 
 // src/utils/errors.ts
 function formatError(err) {
-  return err instanceof Error ? err.message : String(err);
+  if (!(err instanceof Error)) {
+    if (typeof err === "object" && err !== null) {
+      const msg = err.message;
+      if (typeof msg === "string" && msg.length > 0)
+        return msg;
+      try {
+        return JSON.stringify(err) ?? String(err);
+      } catch {
+        return String(err);
+      }
+    }
+    return String(err);
+  }
+  const parts = [err.message];
+  const seen = new Set([err]);
+  let cause = err.cause;
+  while (cause != null && !seen.has(cause)) {
+    seen.add(cause);
+    parts.push(cause instanceof Error ? cause.message : String(cause));
+    cause = cause instanceof Error ? cause.cause : undefined;
+  }
+  return parts.join(": ");
 }
 
 // src/runtimes/vercel.ts
@@ -906,9 +927,6 @@ 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");
 
@@ -929,6 +947,8 @@ function extractMetadata(source) {
     out.snapshots = Object.freeze({ ...source.snapshots });
   if (source.resources !== undefined)
     out.resources = Object.freeze({ ...source.resources });
+  if (source.mergePolicy !== undefined)
+    out.mergePolicy = source.mergePolicy;
   if (source.processors !== undefined)
     out.processors = Object.freeze([...source.processors]);
   if (source.connectors !== undefined)
@@ -989,61 +1009,39 @@ function isWorkflow(value) {
 }
 
 // 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));
+  if ("run" in def) {
+    throw new Error("defineWorkflow: the legacy run-form (`defineWorkflow({ run(ctx, sandbox) { … } })`) has been removed. " + "Author workflows in step-form — `defineWorkflow({ id, input, output }).step(defineStep(...)).build()` — " + "or run /ac:generate-workflow to scaffold the current shape.");
+  }
   return createStepWorkflow(def);
 }
 // src/types/sandbox-environment.ts
+import { z as z4 } from "zod";
 function defineSandboxEnvironment(env) {
   if (typeof env.setup !== "function") {
     throw new Error(`defineSandboxEnvironment(${env.name}): 'setup' must be a function`);
   }
-  return defineWorkflow({
+  const input = z4.unknown();
+  const output = z4.unknown();
+  return createStepWorkflow({
+    id: env.name,
     ...env.description !== undefined ? { description: env.description } : {},
     ...env.resources !== undefined ? { resources: env.resources } : {},
+    input,
+    output,
     snapshots: env.snapshots ?? { saveLatest: true },
-    environmentBuild: true,
-    run: async (_ctx, sandbox) => env.setup(sandbox)
-  });
+    environmentBuild: true
+  }).step({
+    name: "setup",
+    input,
+    output,
+    run: async (ctx) => {
+      const sandbox = ctx.sandbox;
+      if (!sandbox)
+        throw new Error(`defineSandboxEnvironment(${env.name}): setup requires a sandbox in StepContext`);
+      await env.setup(sandbox);
+    }
+  }).build();
 }
 // src/processors/processor.ts
 var Verdict = {
@@ -1195,18 +1193,106 @@ function createGatePauseProcessor(opts) {
     }
   };
 }
+// src/processors/ask-human.ts
+var ASK_USER_QUESTION_TOOL = "AskUserQuestion";
+function parseAsk(input) {
+  const questions = Array.isArray(input.questions) ? input.questions : [];
+  const first = questions[0] ?? {};
+  const head = typeof first.question === "string" && first.question.trim() ? first.question.trim() : "The agent needs your input to continue.";
+  const extra = questions.length > 1 ? ` (+${questions.length - 1} more question${questions.length > 2 ? "s" : ""})` : "";
+  const options = Array.isArray(first.options) ? first.options.map((o) => String(o?.label ?? "").trim()).filter(Boolean).map((label) => ({ id: label, label })) : [];
+  return { reason: head + extra, options };
+}
+function answerText2(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 parseAgentcPause(command) {
+  if (!/(^|\s|&&|;|\|)\s*agentc\s+pause(\s|$)/.test(command))
+    return null;
+  const r = command.match(/--reason(?:=|\s+)(?:"([^"]*)"|'([^']*)'|(\S+))/);
+  const reason = (r?.[1] ?? r?.[2] ?? r?.[3] ?? "The agent needs your input to continue.").trim();
+  const options = [...command.matchAll(/--option(?:=|\s+)(?:"([^"]*)"|'([^']*)'|(\S+))/g)].map((m) => (m[1] ?? m[2] ?? m[3] ?? "").trim()).filter(Boolean).map((label) => ({ id: label, label }));
+  return { reason, options };
+}
+function extractAsk(call) {
+  if (call.toolName === ASK_USER_QUESTION_TOOL)
+    return parseAsk(call.toolInput);
+  if (call.toolName === "Bash") {
+    const cmd = call.toolInput?.command;
+    return typeof cmd === "string" ? parseAgentcPause(cmd) : null;
+  }
+  return null;
+}
+function createAskHumanProcessor(opts = {}) {
+  return {
+    name: "ask-human",
+    async processToolCall(call, ctx) {
+      const ask = extractAsk(call);
+      if (!ask)
+        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);
+      let decision;
+      try {
+        decision = await requestPauseAndAwait({
+          baseUrl: conn.baseUrl,
+          token: conn.token,
+          runId: conn.runId,
+          reason: ask.reason,
+          ...ask.options.length ? { options: ask.options } : {},
+          action: { tool: call.toolName, input: call.toolInput },
+          signal: ctx.abortSignal
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return Verdict.abort(`Could not ask the human — the run could not be paused (${msg}). Stopping rather than guessing an answer.`);
+      }
+      if (decision.status === "resolved") {
+        const answer = answerText2(decision.decision);
+        return Verdict.deny(`The human answered: ${answer || "(no text returned)"}. Continue using this answer.`);
+      }
+      return Verdict.deny(`No answer came back (${decision.status}). Do NOT assume an answer — ask again, or stop and report exactly what you need from a human.`);
+    }
+  };
+}
 // src/client.ts
 import { ofetch } from "ofetch";
 
 // src/errors.ts
 class AgentComposeError extends Error {
   status;
-  constructor(status, message) {
+  retryAfterMs;
+  code;
+  capability;
+  constructor(status, message, opts) {
     super(message);
     this.status = status;
     this.name = "AgentComposeError";
+    if (opts?.retryAfterMs !== undefined)
+      this.retryAfterMs = opts.retryAfterMs;
+    if (opts?.code !== undefined)
+      this.code = opts.code;
+    if (opts?.capability !== undefined)
+      this.capability = opts.capability;
   }
 }
+function parseRetryAfterMs(header) {
+  if (!header)
+    return;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1000);
+  const date = Date.parse(header);
+  if (!Number.isNaN(date))
+    return Math.max(0, date - Date.now());
+  return;
+}
 
 // src/sse.ts
 async function* parseSseStream(body) {
@@ -1258,6 +1344,19 @@ async function* parseSseStream(body) {
   }
 }
 
+// src/types/conversation-stream.ts
+function normalizeConversationStreamEvent(eventName, data, sseId) {
+  const name = eventName || (typeof data.event === "string" ? data.event : "message");
+  const dataId = typeof data.id === "number" && Number.isFinite(data.id) ? data.id : undefined;
+  const durableId = sseId !== undefined && Number.isFinite(sseId) && sseId > 0 ? sseId : dataId !== undefined && dataId > 0 ? dataId : undefined;
+  const ev = { ...data, event: name };
+  if (durableId !== undefined)
+    ev.id = durableId;
+  else
+    delete ev.id;
+  return ev;
+}
+
 // 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";
@@ -1294,10 +1393,39 @@ class AgentComposeClient {
       headers: { Authorization: `Bearer ${apiKey}` },
       async onResponseError({ response }) {
         const body = response._data;
-        throw new AgentComposeError(response.status, body?.error ?? response.statusText);
+        throw new AgentComposeError(response.status, body?.error ?? response.statusText, {
+          retryAfterMs: parseRetryAfterMs(response.headers.get("retry-after")),
+          ...body?.code ? { code: body.code } : {},
+          ...body?.capability ? { capability: body.capability } : {}
+        });
       }
     });
   }
+  async* openSseStream(path, opts) {
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: "text/event-stream"
+    };
+    if (opts?.lastEventId && opts.lastEventId > 0) {
+      headers["Last-Event-ID"] = String(opts.lastEventId);
+    }
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      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, {
+        retryAfterMs: parseRetryAfterMs(res.headers.get("retry-after"))
+      });
+    }
+    yield* parseSseStream(res.body);
+  }
   register(payload) {
     const { factorySlug = DEFAULT_FACTORY, ...body } = payload;
     return this.fetch(templatePath(factorySlug), { method: "POST", body });
@@ -1417,6 +1545,22 @@ class AgentComposeClient {
   getRun(runId) {
     return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}`);
   }
+  async listRuns(opts = {}) {
+    const q2 = new URLSearchParams;
+    if (opts.workflow)
+      q2.set("workflow", opts.workflow);
+    if (opts.search)
+      q2.set("search", opts.search);
+    if (opts.outcome)
+      q2.set("outcome", opts.outcome);
+    if (opts.sort)
+      q2.set("sort", opts.sort);
+    if (opts.limit !== undefined)
+      q2.set("limit", String(opts.limit));
+    const slug = encodeURIComponent(opts.factorySlug ?? "default");
+    const body = await this.fetch(`/api/v1/factories/${slug}/runs${q2.toString() ? `?${q2}` : ""}`);
+    return body.workflows;
+  }
   async getRunTimeline(runId, opts) {
     const q2 = new URLSearchParams;
     if (opts?.limit !== undefined)
@@ -1426,6 +1570,9 @@ class AgentComposeClient {
     const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/timeline${q2.toString() ? `?${q2}` : ""}`);
     return body.events;
   }
+  async getRunFunding(runId) {
+    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/funding`);
+  }
   async reportEvent(runId, input) {
     const body = {
       ...input,
@@ -1469,12 +1616,151 @@ class AgentComposeClient {
       created: wire.created
     };
   }
-  async getFactoryFile(path, opts) {
+  async getFactoryFileBytes(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" });
+    const buf = await this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/content?${q2}`, { responseType: "arrayBuffer" });
+    return new Uint8Array(buf);
+  }
+  async getFactoryFile(path, opts) {
+    return new TextDecoder().decode(await this.getFactoryFileBytes(path, opts));
+  }
+  listConversations(opts) {
+    const q2 = new URLSearchParams;
+    if (opts?.cursor)
+      q2.set("cursor", opts.cursor);
+    return this.fetch(`/api/v1/conversations${q2.toString() ? `?${q2}` : ""}`);
+  }
+  listSessions(factoryId, opts) {
+    const q2 = new URLSearchParams({ factoryId });
+    if (opts?.cursor)
+      q2.set("cursor", opts.cursor);
+    return this.fetch(`/api/v1/sessions?${q2}`);
+  }
+  getConversation(id) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(id)}`);
+  }
+  createCloudSession(input) {
+    return this.fetch(`/api/v1/sessions/cloud`, {
+      method: "POST",
+      body: {
+        ...input.type ? { type: input.type } : {},
+        ...input.runtime ? { runtime: input.runtime } : {},
+        factoryId: input.factoryId,
+        ...input.presetId ? { presetId: input.presetId } : {},
+        ...input.preStart ? { preStart: input.preStart } : {},
+        ...input.title ? { title: input.title } : {},
+        ...input.repoUrl ? { repoUrl: input.repoUrl } : {},
+        ...input.repoBranch ? { repoBranch: input.repoBranch } : {},
+        ...input.channelId ? { channelId: input.channelId } : {},
+        ...input.templateId ? { templateId: input.templateId } : {},
+        ...input.sandboxSize ? { sandboxSize: input.sandboxSize } : {},
+        ...input.networkPolicy !== undefined ? { networkPolicy: input.networkPolicy } : {},
+        ...input.connectorProfileId !== undefined ? { connectorProfileId: input.connectorProfileId } : {}
+      }
+    });
+  }
+  getConversationThread(conversationId, rootId) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/threads/${encodeURIComponent(rootId)}`);
+  }
+  async listChannelSessions(channelId) {
+    const body = await this.fetch(`/api/v1/conversations/${encodeURIComponent(channelId)}/sessions`);
+    return body.sessions;
+  }
+  async attachChannelSession(channelId, sessionConversationId) {
+    await this.fetch(`/api/v1/conversations/${encodeURIComponent(channelId)}/sessions`, { method: "POST", body: { sessionConversationId } });
+  }
+  async detachChannelSession(channelId, sessionConversationId) {
+    await this.fetch(`/api/v1/conversations/${encodeURIComponent(channelId)}/sessions/${encodeURIComponent(sessionConversationId)}`, { method: "DELETE" });
+  }
+  postSessionChannelMessage(channelId, input) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(channelId)}/session-messages`, { method: "POST", body: { text: input.text, ...input.threadRootId ? { threadRootId: input.threadRootId } : {} } });
+  }
+  openPreview(conversationId, input) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/preview`, {
+      method: "POST",
+      body: {
+        port: input.port,
+        ...input.name ? { name: input.name } : {},
+        ...input.path ? { path: input.path } : {}
+      }
+    });
+  }
+  async listPreviews(conversationId) {
+    const body = await this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/previews`);
+    return body.previews;
+  }
+  async closePreview(conversationId, port) {
+    const body = await this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/preview/${port}`, { method: "DELETE" });
+    return body.closed;
+  }
+  forkSession(conversationId, input) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/fork`, { method: "POST", body: input?.title ? { title: input.title } : {} });
+  }
+  getSessionChanges(conversationId) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/changes`);
+  }
+  mergeSessionChanges(conversationId, opts = {}) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/changes/merge`, { method: "POST", body: opts.branch ? { branch: opts.branch } : {} });
+  }
+  discardSessionChanges(conversationId, opts = {}) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/changes/discard`, { method: "POST", body: opts.branch ? { branch: opts.branch } : {} });
+  }
+  async getConversationMembers(conversationId) {
+    const body = await this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/members`);
+    return body.members;
+  }
+  async addConversationMembers(conversationId, members) {
+    const body = await this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/members`, { method: "POST", body: { members } });
+    return body.members;
+  }
+  async removeConversationMember(conversationId, userId) {
+    const body = await this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/members/${encodeURIComponent(userId)}`, { method: "DELETE" });
+    return body.members;
+  }
+  async setConversationMemberRole(conversationId, userId, role) {
+    const body = await this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/members/${encodeURIComponent(userId)}`, { method: "PATCH", body: { role } });
+    return body.members;
+  }
+  sendConversationMessage(conversationId, input) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/messages`, {
+      method: "POST",
+      body: {
+        text: input.text,
+        ...input.threadRootId ? { threadRootId: input.threadRootId } : {},
+        ...input.pageContext ? { pageContext: input.pageContext } : {}
+      }
+    });
+  }
+  prewarmConversation(conversationId) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/prewarm`, { method: "POST", body: {} });
+  }
+  cancelConversationTurn(conversationId) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/cancel-turn`, { method: "POST", body: {} });
+  }
+  heartbeatConversationPresence(conversationId, input) {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(conversationId)}/presence`, { method: "POST", body: input });
+  }
+  async* streamConversation(conversationId, opts) {
+    const path = `/api/v1/conversations/${encodeURIComponent(conversationId)}/stream`;
+    for await (const ev of this.openSseStream(path, opts)) {
+      yield normalizeConversationStreamEvent(ev.event, ev.data, ev.id > 0 ? ev.id : undefined);
+    }
+  }
+  async listAgents() {
+    const body = await this.fetch("/api/v1/agents");
+    return body.agents;
+  }
+  searchFactoryFiles(query, opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    const q2 = new URLSearchParams({ q: query });
+    if (opts?.limit != null)
+      q2.set("limit", String(opts.limit));
+    if (opts?.cursor)
+      q2.set("cursor", opts.cursor);
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/search?${q2}`);
   }
   async listMembers() {
     const body = await this.fetch("/api/v1/team/members");
@@ -1520,6 +1806,88 @@ class AgentComposeClient {
     const body = await this.fetch(path);
     return body.templates;
   }
+  getTemplate(name, opts) {
+    return this.fetch(templatePath(opts?.factorySlug ?? DEFAULT_FACTORY, name));
+  }
+  setTemplateScope(name, input, opts) {
+    return this.fetch(templatePath(opts?.factorySlug ?? DEFAULT_FACTORY, name, "scope"), {
+      method: "PUT",
+      body: {
+        grants: input.grants,
+        ...input.conversationId !== undefined ? { conversationId: input.conversationId } : {}
+      }
+    });
+  }
+  setFileScope(path, input, opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/scope`, { method: "PUT", body: { path, grants: input.grants } });
+  }
+  async shareFileWithSession(factorySlug, input) {
+    await this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/session-grants`, { method: "POST", body: { path: input.path, conversationId: input.conversationId } });
+  }
+  async unshareFileWithSession(factorySlug, input) {
+    await this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/session-grants`, { method: "DELETE", body: { path: input.path, conversationId: input.conversationId } });
+  }
+  listProjects(opts) {
+    const q2 = new URLSearchParams;
+    if (opts?.cursor)
+      q2.set("cursor", opts.cursor);
+    return this.fetch(`/api/v1/projects${q2.toString() ? `?${q2}` : ""}`);
+  }
+  async createProject(name) {
+    const body = await this.fetch("/api/v1/projects", {
+      method: "POST",
+      body: { name }
+    });
+    return body.project;
+  }
+  async getProject(id) {
+    const body = await this.fetch(`/api/v1/projects/${encodeURIComponent(id)}`);
+    return body.project;
+  }
+  async renameProject(id, name) {
+    const body = await this.fetch(`/api/v1/projects/${encodeURIComponent(id)}`, { method: "PATCH", body: { name } });
+    return body.project;
+  }
+  async deleteProject(id) {
+    await this.fetch(`/api/v1/projects/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+  }
+  async getProjectMembers(id) {
+    const body = await this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/members`);
+    return body.members;
+  }
+  async addProjectMembers(id, members) {
+    const body = await this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/members`, { method: "POST", body: { members } });
+    return body.members;
+  }
+  async removeProjectMember(id, userId) {
+    const body = await this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/members/${encodeURIComponent(userId)}`, { method: "DELETE" });
+    return body.members;
+  }
+  async setProjectMemberRole(id, userId, role) {
+    const body = await this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/members/${encodeURIComponent(userId)}`, { method: "PATCH", body: { role } });
+    return body.members;
+  }
+  listProjectObjects(id, opts) {
+    const q2 = new URLSearchParams;
+    if (opts?.cursor)
+      q2.set("cursor", opts.cursor);
+    return this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/objects${q2.toString() ? `?${q2}` : ""}`);
+  }
+  previewProjectObject(id, input) {
+    return this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/objects/preview`, { method: "POST", body: { type: "session", conversationId: input.conversationId } });
+  }
+  addProjectObject(id, input) {
+    return this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/objects`, { method: "POST", body: input });
+  }
+  refreshProjectObject(id, objectId) {
+    return this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/objects/${encodeURIComponent(objectId)}/refresh`, { method: "POST", body: {} });
+  }
+  async removeProjectObject(id, objectId) {
+    await this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/objects/${encodeURIComponent(objectId)}`, { method: "DELETE" });
+  }
   async listFactories() {
     const body = await this.fetch("/api/v1/factories");
     return body.factories;
@@ -1557,15 +1925,32 @@ class AgentComposeClient {
       body: { key, value }
     });
   }
-  async listSecrets(workflowName, opts) {
-    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
-    const body = await this.fetch(templatePath(factorySlug, workflowName, "secrets"));
+  async listSecretEntries(path) {
+    const body = await this.fetch(path);
     return body.secrets.map((s) => ({ key: s.secretKey, createdAt: s.createdAt, updatedAt: s.updatedAt }));
   }
+  listSecrets(workflowName, opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    return this.listSecretEntries(templatePath(factorySlug, workflowName, "secrets"));
+  }
   deleteSecret(workflowName, key, opts) {
     const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
     return this.fetch(templatePath(factorySlug, workflowName, "secrets", key), { method: "DELETE" });
   }
+  async listRepoLinks(opts) {
+    const slug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    const body = await this.fetch(`/api/v1/factories/${encodeURIComponent(slug)}/repo-links`);
+    return body.links;
+  }
+  async createRepoLink(input, opts) {
+    const slug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    const body = await this.fetch(`/api/v1/factories/${encodeURIComponent(slug)}/repo-links`, { method: "POST", body: input });
+    return body.link;
+  }
+  deleteRepoLink(linkId, opts) {
+    const slug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(slug)}/repo-links/${encodeURIComponent(linkId)}`, { method: "DELETE" });
+  }
   setFactorySecret(key, value, opts) {
     const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
     return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/secrets`, {
@@ -1573,10 +1958,9 @@ class AgentComposeClient {
       body: { key, value }
     });
   }
-  async listFactorySecrets(opts) {
+  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 }));
+    return this.listSecretEntries(`/api/v1/factories/${encodeURIComponent(factorySlug)}/secrets`);
   }
   deleteFactorySecret(key, opts) {
     const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
@@ -1596,94 +1980,555 @@ class AgentComposeClient {
   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 } : {}
+  async requestComplianceSession(input) {
+    const body = await this.fetch("/api/v1/compliance/sessions", {
+      method: "POST",
+      body: {
+        scopeKind: input.scopeKind,
+        reason: input.reason,
+        ttlSeconds: input.ttlSeconds,
+        ...input.scopeRef != null ? { scopeRef: input.scopeRef } : {}
+      }
     });
-    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;
-    }
+    return body.session;
   }
-}
-// 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 };
-}
-
-// 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 approveComplianceSession(sessionId) {
+    const body = await this.fetch(`/api/v1/compliance/sessions/${encodeURIComponent(sessionId)}/approve`, { method: "POST" });
+    return body.session;
   }
-}
-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(`
-`)}`);
+  async revokeComplianceSession(sessionId) {
+    const body = await this.fetch(`/api/v1/compliance/sessions/${encodeURIComponent(sessionId)}/revoke`, { method: "POST" });
+    return body.session;
   }
-  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)}`);
+  listComplianceSessions(opts) {
+    const q2 = new URLSearchParams;
+    if (opts?.status)
+      q2.set("status", opts.status);
+    if (opts?.limit != null)
+      q2.set("limit", String(opts.limit));
+    if (opts?.cursor)
+      q2.set("cursor", opts.cursor);
+    return this.fetch(`/api/v1/compliance/sessions${q2.toString() ? `?${q2}` : ""}`);
   }
-}
-var DEFINE_WORKFLOW_CALLEE = /^(?:defineWorkflow|defineSandboxEnvironment)\d*$/;
-function isDefineWorkflowCall(node) {
-  if (node.callee.type === "Identifier") {
-    return DEFINE_WORKFLOW_CALLEE.test(node.callee.name);
+  listComplianceAccesses(sessionId, opts) {
+    const q2 = new URLSearchParams;
+    if (opts?.limit != null)
+      q2.set("limit", String(opts.limit));
+    if (opts?.cursor)
+      q2.set("cursor", opts.cursor);
+    return this.fetch(`/api/v1/compliance/sessions/${encodeURIComponent(sessionId)}/accesses${q2.toString() ? `?${q2}` : ""}`);
   }
-  if (node.callee.type === "MemberExpression" && node.callee.object.type === "CallExpression") {
-    return isDefineWorkflowCall(node.callee.object);
+  async* streamRunLogs(runId, opts) {
+    const path = `/api/v1/workflows/${encodeURIComponent(runId)}/stream`;
+    for await (const ev of this.openSseStream(path, opts)) {
+      yield ev.data;
+    }
   }
-  return false;
+}
+// src/directives.ts
+var DIRECTIVE_MARKER_PREFIX = "[[ac:directive:v1 ";
+var DIRECTIVE_MARKER_SUFFIX = "]]";
+var MAX_DIRECTIVES_PER_OUTPUT = 4;
+var RUN_ID_RE = /^(latest|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+var REVISION_SELECTOR_RE = /^(\d{1,12}|head|prev|head~[1-9]\d{0,2})$/;
+var DIRECTIVE_PATH_MAX = 512;
+var ASK_DIRECTIVE_PROMPT_MAX = 500;
+var ASK_DIRECTIVE_MAX_OPTIONS = 6;
+var ASK_DIRECTIVE_OPTION_ID_MAX = 50;
+var ASK_DIRECTIVE_OPTION_LABEL_MAX = 60;
+var ASK_APPROVER_MIN = 3;
+var ASK_APPROVER_MAX = 320;
+function validDirectivePath(v) {
+  return typeof v === "string" && v.length >= 1 && v.length <= DIRECTIVE_PATH_MAX ? v : null;
+}
+function renderDirectiveMarker(directive) {
+  return `${DIRECTIVE_MARKER_PREFIX}${JSON.stringify(directive)}${DIRECTIVE_MARKER_SUFFIX}`;
+}
+function validDirective(value) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const d = value;
+  if (d.kind === "navigate") {
+    const url = d.url;
+    if (typeof url !== "string" || url.length === 0 || url.length > 400)
+      return null;
+    if (!url.startsWith("/") || url.startsWith("//"))
+      return null;
+    return { kind: "navigate", url };
+  }
+  if (d.kind === "run" || d.kind === "run_changes") {
+    const runId = d.runId;
+    if (typeof runId !== "string" || !RUN_ID_RE.test(runId))
+      return null;
+    const workflow = d.workflow;
+    if (workflow !== undefined && (typeof workflow !== "string" || workflow.length === 0 || workflow.length > 255)) {
+      return null;
+    }
+    return { kind: d.kind, runId, ...workflow !== undefined ? { workflow } : {} };
+  }
+  if (d.kind === "preview" || d.kind === "table_file") {
+    const path = validDirectivePath(d.path);
+    if (!path)
+      return null;
+    if (d.kind === "table_file" && !/\.(csv|json)$/i.test(path))
+      return null;
+    return { kind: d.kind, path };
+  }
+  if (d.kind === "file_diff") {
+    const path = validDirectivePath(d.path);
+    if (!path)
+      return null;
+    const { from, to } = d;
+    if (typeof from !== "string" || !REVISION_SELECTOR_RE.test(from))
+      return null;
+    if (typeof to !== "string" || !REVISION_SELECTOR_RE.test(to))
+      return null;
+    return { kind: "file_diff", path, from, to };
+  }
+  if (d.kind === "ask") {
+    const { prompt, approver } = d;
+    if (typeof prompt !== "string" || prompt.length < 1 || prompt.length > ASK_DIRECTIVE_PROMPT_MAX)
+      return null;
+    if (typeof approver !== "string" || approver.length < ASK_APPROVER_MIN || approver.length > ASK_APPROVER_MAX) {
+      return null;
+    }
+    let options;
+    if (d.options !== undefined) {
+      if (!Array.isArray(d.options) || d.options.length === 0 || d.options.length > ASK_DIRECTIVE_MAX_OPTIONS) {
+        return null;
+      }
+      options = [];
+      for (const raw of d.options) {
+        if (typeof raw !== "object" || raw === null)
+          return null;
+        const { id, label } = raw;
+        if (typeof id !== "string" || id.length < 1 || id.length > ASK_DIRECTIVE_OPTION_ID_MAX)
+          return null;
+        if (typeof label !== "string" || label.length < 1 || label.length > ASK_DIRECTIVE_OPTION_LABEL_MAX) {
+          return null;
+        }
+        options.push({ id, label });
+      }
+    }
+    return { kind: "ask", prompt, approver, ...options !== undefined ? { options } : {} };
+  }
+  return null;
+}
+function parseDirectiveMarkers(text) {
+  const out = [];
+  let from = 0;
+  while (out.length < MAX_DIRECTIVES_PER_OUTPUT) {
+    const start = text.indexOf(DIRECTIVE_MARKER_PREFIX, from);
+    if (start < 0)
+      break;
+    const bodyStart = start + DIRECTIVE_MARKER_PREFIX.length;
+    const end = text.indexOf(DIRECTIVE_MARKER_SUFFIX, bodyStart);
+    if (end < 0)
+      break;
+    from = end + DIRECTIVE_MARKER_SUFFIX.length;
+    const body = text.slice(bodyStart, end);
+    if (body.length > 1024)
+      continue;
+    try {
+      const directive = validDirective(JSON.parse(body));
+      if (directive)
+        out.push(directive);
+    } catch {}
+  }
+  return out;
+}
+// src/runtimes/_acp-client.ts
+import {
+  ClientSideConnection,
+  RequestError
+} from "@agentclientprotocol/sdk";
+
+// src/agent/async-queue.ts
+class AsyncQueue {
+  buffer = [];
+  resolvers = [];
+  done = false;
+  push(value) {
+    if (this.done)
+      return;
+    const resolve = this.resolvers.shift();
+    if (resolve) {
+      resolve({ value, done: false });
+    } else {
+      this.buffer.push(value);
+    }
+  }
+  close() {
+    if (this.done)
+      return;
+    this.done = true;
+    while (this.resolvers.length > 0) {
+      const resolve = this.resolvers.shift();
+      resolve({ value: undefined, done: true });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const buffered = this.buffer.shift();
+        if (buffered !== undefined)
+          return Promise.resolve({ value: buffered, done: false });
+        if (this.done)
+          return Promise.resolve({ value: undefined, done: true });
+        return new Promise((resolve) => {
+          this.resolvers.push(resolve);
+        });
+      },
+      return: () => {
+        this.close();
+        return Promise.resolve({ value: undefined, done: true });
+      }
+    };
+  }
+}
+
+// src/runtimes/_acp-client.ts
+function now2() {
+  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 = now2();
+  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) => {
+        if (params.update.sessionUpdate === "available_commands_update") {
+          this.deps.onAvailableCommands?.(params.update.availableCommands.map((c) => ({
+            name: c.name,
+            description: c.description
+          })));
+          return;
+        }
+        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,
+      caps: {
+        loadSession: res.agentCapabilities?.loadSession ?? false,
+        resume: res.agentCapabilities?.sessionCapabilities?.resume != null
+      }
+    };
+  }
+  async startSession(cwd) {
+    const res = await this.conn.newSession({ cwd, mcpServers: [] });
+    this.sessionId = res.sessionId;
+    return res.sessionId;
+  }
+  async resumeSession(cwd, acpSessionId) {
+    await this.conn.resumeSession({ sessionId: acpSessionId, cwd, mcpServers: [] });
+    this.sessionId = acpSessionId;
+  }
+  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: now2() };
+      return;
+    }
+    const stopReason = outcome.res.stopReason;
+    if (stopReason === "refusal") {
+      yield { type: "error", text: "agent refused the request", timestamp: now2() };
+      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: now2()
+      };
+    }
+  }
+  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" } };
+      }
+      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 } };
+  }
+}
+// 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 };
+}
+
+// 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;
@@ -1731,6 +2576,19 @@ function findDefaultExportExpression(body) {
 function sha256(text) {
   return createHash2("sha256").update(text, "utf8").digest("hex");
 }
+function extractWorkflowPlan(workflow) {
+  return workflowPlan(workflow.steps.map((step, index) => ({
+    index,
+    name: step.name,
+    ...step.summary !== undefined ? { summary: step.summary } : {},
+    ...step.deliverables?.length ? {
+      deliverables: step.deliverables.map((d) => ({
+        path: d.path,
+        ...d.description !== undefined ? { description: d.description } : {}
+      }))
+    } : {}
+  })));
+}
 async function bundleWorkflow(workflowPath, overrides) {
   const label = `"${workflowPath}"`;
   const source = await bundle(workflowPath, `workflow ${label}`);
@@ -1740,7 +2598,7 @@ async function bundleWorkflow(workflowPath, overrides) {
     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 plan = extractWorkflowPlan(workflow);
   const manifest = {
     definitionBrand: true,
     sourceHash: sha256(source),
@@ -1759,6 +2617,7 @@ async function bundleWorkflow(workflowPath, overrides) {
     ...outputSchema !== undefined ? { outputSchema } : {},
     ...metadata.snapshots !== undefined ? { snapshots: metadata.snapshots } : {},
     ...metadata.resources !== undefined ? { resources: metadata.resources } : {},
+    ...metadata.mergePolicy !== undefined ? { mergePolicy: metadata.mergePolicy } : {},
     ...metadata.connectors !== undefined ? { connectors: metadata.connectors } : {},
     ...metadata.connectorOperation !== undefined ? { connectorOperation: metadata.connectorOperation } : {},
     ...metadata.invokePolicy !== undefined ? { invokePolicy: metadata.invokePolicy } : {},
@@ -2029,6 +2888,10 @@ function parseAgentStatus(text) {
   }
 }
 var DEFAULT_ALLOWED_TOOLS = ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "WebFetch"];
+function runtimeJsonSchema(schema) {
+  const { $schema: _$schema, ...rest } = z10.toJSONSchema(schema);
+  return rest;
+}
 function truncate(value) {
   return value.length > MESSAGE_PREVIEW_CHARS ? `${value.slice(0, MESSAGE_PREVIEW_CHARS)}…` : value;
 }
@@ -2075,7 +2938,7 @@ async function agentLoop(opts) {
   const logLabel = opts.label ?? "[Agent Loop]";
   const startedAt = Date.now();
   const turnsPerIteration = opts.turnsPerIteration;
-  const maxIterations = opts.maxIterations ?? (turnsPerIteration === undefined ? 1 : 8);
+  const maxIterations = opts.maxIterations ?? (turnsPerIteration === undefined ? 3 : 8);
   let schemaRetriesLeft = 10;
   const processors = opts.processors ?? [];
   const requestContext = opts.requestContext ?? RequestContext.fromReserved({
@@ -2106,7 +2969,7 @@ async function agentLoop(opts) {
     requestContext,
     agentId,
     ...opts.pause ? { pause: opts.pause } : {},
-    ...opts.responseSchema ? { outputFormat: { type: "json_schema", schema: z10.toJSONSchema(opts.responseSchema) } } : {}
+    ...opts.responseSchema ? { outputFormat: { type: "json_schema", schema: runtimeJsonSchema(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
@@ -2240,6 +3103,8 @@ Re-emit the COMPLETE corrected <response> JSON now: every required field present
         signal: loopAbort.signal,
         ...opts.inbox ? { inboxStream: opts.inbox } : {}
       })) {
+        if (rawMsg.type === "text_delta" || rawMsg.type === "usage_delta")
+          continue;
         const outputVerdict = await runProcessorChain(processors, (p) => p.processOutput, rawMsg, procCtx);
         if (outputVerdict.kind === "abort") {
           loopAbort.abort();
@@ -2251,6 +3116,8 @@ Re-emit the COMPLETE corrected <response> JSON now: every required field present
           continue;
         }
         const msg = outputVerdict.value;
+        if (msg.type === "text_delta" || msg.type === "usage_delta")
+          continue;
         opts.onAgentEvent?.(iteration, msg);
         const summary = summarizeAgentMessage(msg);
         opts.onAgentLifecycleEvent?.({
@@ -2396,56 +3263,12 @@ function parseRawJsonResponse(text) {
   }
 }
 
-// src/agent/async-queue.ts
-class AsyncQueue {
-  buffer = [];
-  resolvers = [];
-  done = false;
-  push(value) {
-    if (this.done)
-      return;
-    const resolve = this.resolvers.shift();
-    if (resolve) {
-      resolve({ value, done: false });
-    } else {
-      this.buffer.push(value);
-    }
-  }
-  close() {
-    if (this.done)
-      return;
-    this.done = true;
-    while (this.resolvers.length > 0) {
-      const resolve = this.resolvers.shift();
-      resolve({ value: undefined, done: true });
-    }
-  }
-  [Symbol.asyncIterator]() {
-    return {
-      next: () => {
-        const buffered = this.buffer.shift();
-        if (buffered !== undefined)
-          return Promise.resolve({ value: buffered, done: false });
-        if (this.done)
-          return Promise.resolve({ value: undefined, done: true });
-        return new Promise((resolve) => {
-          this.resolvers.push(resolve);
-        });
-      },
-      return: () => {
-        this.close();
-        return Promise.resolve({ value: undefined, done: true });
-      }
-    };
-  }
-}
-
 // src/runtimes/claude.ts
-function now2() {
+function now3() {
   return new Date().toISOString();
 }
 function translateMessage(message) {
-  const ts = now2();
+  const ts = now3();
   const msgs = [];
   if (message.type === "system" && message.subtype === "init") {
     msgs.push({ type: "init", sessionId: String(message.session_id ?? ""), timestamp: ts });
@@ -2519,6 +3342,22 @@ function resolveThinking(model, thinking) {
     return;
   return thinking;
 }
+var STDERR_TAIL_CAP = 2000;
+
+class StderrTail {
+  buf = "";
+  append(data) {
+    this.buf = (this.buf + data).slice(-STDERR_TAIL_CAP);
+  }
+  get text() {
+    return this.buf.trim();
+  }
+  decorate(message) {
+    return this.text ? `${message}
+stderr tail:
+${this.text}` : message;
+  }
+}
 var DEFAULT_CLAUDE_PATH = "/usr/local/bin/claude";
 
 class ClaudeRunner {
@@ -2605,6 +3444,7 @@ class ClaudeRunner {
     const systemPromptAppend = [this.config.claudeMdContent, this.options.agentManual].filter((s) => Boolean(s && s.trim())).join(`
 
 `);
+    const stderrTail = new StderrTail;
     try {
       let emittedAssistantText = false;
       for await (const message of query({
@@ -2619,6 +3459,7 @@ class ClaudeRunner {
           effort: this.config.effort,
           cwd: this.options.cwd,
           abortController: queryAbort,
+          stderr: (data) => stderrTail.append(data),
           env: { ...process.env, ...this.config.env ?? {} },
           pathToClaudeCodeExecutable: this.config.pathToClaudeCodeExecutable ?? process.env.CLAUDE_CODE_EXECUTABLE ?? DEFAULT_CLAUDE_PATH,
           ...systemPromptAppend ? { systemPrompt: { type: "preset", preset: "claude_code", append: systemPromptAppend } } : {},
@@ -2636,7 +3477,7 @@ class ClaudeRunner {
             continue;
           if (msg.type === "text" && raw.type === "assistant")
             emittedAssistantText = true;
-          yield msg;
+          yield msg.type === "error" ? { ...msg, text: stderrTail.decorate(msg.text) } : msg;
         }
         if (raw.type === "result" && inboxQueue)
           inboxQueue.close();
@@ -2644,9 +3485,9 @@ class ClaudeRunner {
     } catch (err) {
       const text = formatError(err);
       if (/maximum number of turns/i.test(text)) {
-        yield { type: "done", sessionId: opts.sessionId ?? "", timestamp: now2() };
+        yield { type: "done", sessionId: opts.sessionId ?? "", timestamp: now3() };
       } else {
-        yield { type: "error", text, timestamp: now2() };
+        yield { type: "error", text: stderrTail.decorate(text), timestamp: now3() };
       }
     } finally {
       inboxQueue?.close();
@@ -2663,269 +3504,112 @@ 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}]`);
-    }
+// src/runtimes/_jsonl-guard.ts
+var JSONL_GUARD_LINE_CAP_BYTES = Number(process.env.AC_JSONL_LINE_CAP_BYTES) || 131072;
+var JSONL_GUARD_KEEP_BYTES = Number(process.env.AC_JSONL_KEEP_BYTES) || 32768;
+var JSONL_GUARD_NO_SENTINEL_EXIT = 121;
+function capJsonlLine(line, maxBytes, keepBytes) {
+  if (Buffer.byteLength(line, "utf8") <= maxBytes)
+    return line;
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    parsed = undefined;
   }
-  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
-        }));
+  if (parsed !== null && typeof parsed === "object") {
+    const truncate2 = (value, budget) => {
+      const bytes = Buffer.byteLength(value, "utf8");
+      if (bytes <= budget)
+        return value;
+      let head = Buffer.from(value, "utf8").subarray(0, budget).toString("utf8");
+      while (head.endsWith("�"))
+        head = head.slice(0, -1);
+      if (budget < 2048) {
+        return head + `
+[agent-compose: PAYLOAD ELIDED IN TRANSIT - kept first ` + budget + " of " + bytes + " bytes; full content remains in the sandbox]";
       }
-      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 [];
-  }
-}
+      return head + `
 
-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" } };
+[agent-compose: PAYLOAD ELIDED IN TRANSIT - this content was ` + bytes + " bytes; only the first " + budget + " bytes are shown. It was cut to protect the" + " session's transport, NOT because the source is short: the full content still exists" + " inside this sandbox (the file on disk / the command's output). Do not guess the" + " elided part - re-read the source file, or re-run the command with narrower output" + " (head, tail, grep, offset+limit), to see it.]";
+    };
+    const walk = (node, budget) => {
+      if (typeof node === "string")
+        return truncate2(node, budget);
+      if (Array.isArray(node))
+        return node.map((item) => walk(item, budget));
+      if (node !== null && typeof node === "object") {
+        const out = {};
+        for (const key of Object.keys(node)) {
+          out[key] = walk(node[key], budget);
+        }
+        return out;
+      }
+      return node;
+    };
+    for (const shrink of [1, 8, 64]) {
+      const budget = Math.max(64, Math.floor(keepBytes / shrink));
+      try {
+        const capped = JSON.stringify(walk(parsed, budget));
+        if (typeof capped === "string" && Buffer.byteLength(capped, "utf8") <= maxBytes) {
+          return capped;
+        }
+      } catch {
+        break;
       }
-      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 } };
   }
+  let raw = Buffer.from(line, "utf8").subarray(0, maxBytes).toString("utf8");
+  while (raw.endsWith("�"))
+    raw = raw.slice(0, -1);
+  return raw;
+}
+function jsonlGuardScript() {
+  return [
+    "'use strict';",
+    `const capJsonlLine = ${capJsonlLine.toString()};`,
+    `const NO_SENTINEL_EXIT = ${JSONL_GUARD_NO_SENTINEL_EXIT};`,
+    "const sentinel = process.argv[2];",
+    "const maxBytes = Number(process.argv[3]);",
+    "const keepBytes = Number(process.argv[4]);",
+    "let sawSentinel = false;",
+    "let buf = '';",
+    "// Downstream (the command-stream consumer) going away must never crash",
+    "// the pipe with EPIPE noise — the producer is being killed anyway.",
+    "process.stdout.on('error', () => process.exit(0));",
+    "function handle(line) {",
+    "  const t = line.trim();",
+    "  if (sentinel && t.startsWith(sentinel)) {",
+    "    const code = Number(t.slice(sentinel.length).trim());",
+    "    process.exitCode = Number.isFinite(code) ? code : 0;",
+    "    sawSentinel = true;",
+    "    return;",
+    "  }",
+    "  process.stdout.write(capJsonlLine(line, maxBytes, keepBytes) + '\\n');",
+    "}",
+    "process.stdin.setEncoding('utf8');",
+    "process.stdin.on('data', (d) => {",
+    "  buf += d;",
+    "  let nl;",
+    "  while ((nl = buf.indexOf('\\n')) >= 0) {",
+    "    const line = buf.slice(0, nl);",
+    "    buf = buf.slice(nl + 1);",
+    "    if (line.length > 0) handle(line);",
+    "  }",
+    "});",
+    "process.stdin.on('end', () => {",
+    "  if (buf.trim().length > 0) handle(buf);",
+    "  if (!sawSentinel) process.exitCode = NO_SENTINEL_EXIT;",
+    "});"
+  ].join(`
+`);
+}
+function quote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function wrapJsonlCommand(args) {
+  const { cmd, guardPath, sentinel, maxBytes, keepBytes } = args;
+  return `if command -v node >/dev/null 2>&1; then ` + `{ ( ${cmd} ); printf '\\n%s %s\\n' ${quote(sentinel)} "$?"; } ` + `| node ${quote(guardPath)} ${quote(sentinel)} ${maxBytes} ${keepBytes}; ` + `else ${cmd}; fi`;
 }
 
 // src/runtimes/_cli-agent.ts
@@ -2935,8 +3619,14 @@ function now4() {
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+var promptFileCounter = 0;
+function uniquePromptPath(kind, agentId, iteration) {
+  const unique = `${Date.now().toString(36)}-${(promptFileCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  return `/tmp/ac-${kind}-${agentId}-${iteration}-${unique}.in`;
+}
 var ACP_FALLBACK = Symbol("acp-fallback");
 var ACP_HANDSHAKE_TIMEOUT_MS = Number(process.env.AC_ACP_HANDSHAKE_TIMEOUT_MS) || 1e4;
+var ACP_TURN_IDLE_TIMEOUT_MS = Number(process.env.AC_ACP_TURN_IDLE_TIMEOUT_MS) || 120000;
 var ACP_TRANSPORT_READY = true;
 async function withHandshakeTimeout(p, ms) {
   let timer;
@@ -2956,6 +3646,7 @@ class CliAgentRunner {
   options;
   spec;
   configModel;
+  configEffort;
   kind;
   get acpCapable() {
     return this.spec.acp !== undefined && this.acpTransportReady && typeof this.sandbox.commands.spawnDuplex === "function";
@@ -2967,11 +3658,12 @@ class CliAgentRunner {
   acpSession;
   currentAcpProcCtx;
   acpTransportReady = ACP_TRANSPORT_READY;
-  constructor(sandbox, options, spec, configModel) {
+  constructor(sandbox, options, spec, configModel, configEffort) {
     this.sandbox = sandbox;
     this.options = options;
     this.spec = spec;
     this.configModel = configModel;
+    this.configEffort = configEffort;
     this.kind = spec.kind;
   }
   enableAcpForTesting() {
@@ -3104,7 +3796,7 @@ class CliAgentRunner {
       watchdog = setTimeout(() => {
         stalled = true;
         peer.cancel();
-      }, ACP_HANDSHAKE_TIMEOUT_MS);
+      }, ACP_TURN_IDLE_TIMEOUT_MS);
     };
     try {
       armWatchdog();
@@ -3121,7 +3813,7 @@ class CliAgentRunner {
     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() };
+      yield { type: "error", text: `${this.spec.kind} prompt turn stalled (no activity for ${ACP_TURN_IDLE_TIMEOUT_MS}ms)`, timestamp: now4() };
       return;
     }
     if (!sawError)
@@ -3151,14 +3843,27 @@ class CliAgentRunner {
     let sessionId = opts.sessionId;
     let sawError = false;
     try {
+      if (opts.signal?.aborted)
+        return;
       await this.ensureInstalled();
-      const promptPath = `/tmp/ac-${this.spec.kind}-${this.options.agentId ?? "agent"}-${opts.iteration ?? 0}.in`;
+      const promptPath = uniquePromptPath(this.spec.kind, this.options.agentId ?? "agent", opts.iteration ?? 0);
       await this.sandbox.files.write(promptPath, this.spec.promptPayload(opts.prompt));
       const cmd = this.spec.buildCommand({
         promptPath,
         sessionId: opts.sessionId,
         model: this.model,
-        cwd: this.options.cwd
+        cwd: this.options.cwd,
+        effort: this.configEffort
+      });
+      const guardPath = `${promptPath}.guard.js`;
+      const sentinel = `__AC_JSONL_EXIT_${Math.random().toString(36).slice(2, 10)}__`;
+      await this.sandbox.files.write(guardPath, jsonlGuardScript());
+      const guardedCmd = wrapJsonlCommand({
+        cmd,
+        guardPath,
+        sentinel,
+        maxBytes: JSONL_GUARD_LINE_CAP_BYTES,
+        keepBytes: JSONL_GUARD_KEEP_BYTES
       });
       const lines = new AsyncQueue;
       let buf = "";
@@ -3173,51 +3878,83 @@ class CliAgentRunner {
             lines.push(line);
         }
       };
-      const runPromise = this.sandbox.commands.run(cmd, {
+      const runOpts = {
         ...this.options.cwd ? { cwd: this.options.cwd } : {},
-        onStdout
-      }).then((res2) => {
+        onStdout,
+        timeoutMs: 0
+      };
+      let exited = false;
+      const settle = (res) => {
+        exited = true;
         const tail = buf.trim();
         if (tail)
           lines.push(tail);
         lines.close();
-        return res2;
-      }, (err) => {
+        return res;
+      };
+      const fail = (err) => {
+        exited = true;
         lines.close();
         throw err;
-      });
-      for await (const line of lines) {
-        let parsed;
-        try {
-          parsed = JSON.parse(line);
-        } catch {
-          continue;
+      };
+      let kill;
+      let runPromise;
+      if (this.sandbox.commands.runBackground) {
+        const handle = await this.sandbox.commands.runBackground(guardedCmd, runOpts);
+        kill = () => handle.kill();
+        runPromise = handle.wait().then(settle, fail);
+      } else {
+        runPromise = this.sandbox.commands.run(guardedCmd, runOpts).then(settle, fail);
+      }
+      runPromise.catch(() => {});
+      const reap = () => {
+        if (!exited)
+          kill?.().catch(() => {});
+      };
+      if (opts.signal) {
+        if (opts.signal.aborted)
+          reap();
+        else
+          opts.signal.addEventListener("abort", reap, { once: true });
+      }
+      try {
+        for await (const line of lines) {
+          let parsed;
+          try {
+            parsed = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          const sid = this.spec.extractSessionId(parsed);
+          if (sid)
+            sessionId = sid;
+          for (const msg of this.spec.mapEvent(parsed)) {
+            if (msg.type === "error")
+              sawError = true;
+            yield msg;
+          }
         }
-        const sid = this.spec.extractSessionId(parsed);
-        if (sid)
-          sessionId = sid;
-        for (const msg of this.spec.mapEvent(parsed)) {
-          if (msg.type === "error")
-            sawError = true;
-          yield msg;
+        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: now4() };
+          return;
         }
+        if (!sawError)
+          yield { type: "done", sessionId: sessionId ?? "", timestamp: now4() };
+      } finally {
+        opts.signal?.removeEventListener("abort", reap);
+        reap();
+        this.sandbox.commands.run(`rm -f ${shellQuote(promptPath)} ${shellQuote(guardPath)}`, { timeoutMs: 1e4 }).catch(() => {});
       }
-      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: now4() };
-        return;
-      }
-      if (!sawError)
-        yield { type: "done", sessionId: sessionId ?? "", timestamp: now4() };
     } catch (err) {
       yield { type: "error", text: formatError(err), timestamp: now4() };
     }
   }
 }
-function createCliAgentRuntime(spec, configModel) {
+function createCliAgentRuntime(spec, configModel, configEffort) {
   return defineRuntime({
-    create: (sandbox, opts) => new CliAgentRunner(sandbox, opts, spec, configModel)
+    create: (sandbox, opts) => new CliAgentRunner(sandbox, opts, spec, configModel, configEffort)
   });
 }
 
@@ -3226,6 +3963,12 @@ function now5() {
   return new Date().toISOString();
 }
 var CODEX_ACP_ADAPTER = "@agentclientprotocol/codex-acp@0.1.0";
+var CODEX_ADVISORY_PATTERNS = [
+  /Model metadata for .+ not found\. Defaulting to fallback metadata/
+];
+function isCodexAdvisoryNoise(text) {
+  return CODEX_ADVISORY_PATTERNS.some((re) => re.test(text));
+}
 var codexSpec = {
   kind: "codex",
   authEnv: "CODEX_API_KEY",
@@ -3237,12 +3980,13 @@ var codexSpec = {
   },
   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 }) => {
+  buildCommand: ({ promptPath, sessionId, model, cwd, effort }) => {
     const flags = [
       "--json",
       "--skip-git-repo-check",
       "--dangerously-bypass-approvals-and-sandbox",
       ...model ? ["-m", shellQuote(model)] : [],
+      ...effort ? ["-c", `model_reasoning_effort=${effort}`] : [],
       ...cwd ? ["-C", shellQuote(cwd)] : []
     ].join(" ");
     const exec = sessionId ? `codex exec resume ${shellQuote(sessionId)} ${flags}` : `codex exec ${flags}`;
@@ -3272,6 +4016,16 @@ var codexSpec = {
           const failed = item.status === "failed" || typeof item.exit_code === "number" && item.exit_code !== 0;
           return [{ type: "tool_result", toolUseId: id, output: String(item.aggregated_output ?? item.output ?? ""), isError: failed, timestamp: ts }];
         }
+        if (itype === "error") {
+          if (p.type !== "item.completed")
+            return [];
+          const text = formatError(item.message ?? item);
+          if (isCodexAdvisoryNoise(text)) {
+            console.warn(`[codex] advisory (kept out of transcript): ${text}`);
+            return [];
+          }
+          return [{ type: "error", text, timestamp: ts }];
+        }
         if (p.type === "item.completed") {
           return [{ type: "tool_use", toolName: itype || "item", toolInput: item, toolUseId: String(item.id ?? ""), timestamp: ts }];
         }
@@ -3301,7 +4055,7 @@ var codexSpec = {
   }
 };
 function createCodexRuntime(config = {}) {
-  return createCliAgentRuntime(codexSpec, config.model);
+  return createCliAgentRuntime(codexSpec, config.model, config.effort);
 }
 var codex_default = createCodexRuntime();
 // src/runtimes/amp.ts
@@ -3366,59 +4120,353 @@ function createAmpRuntime(config = {}) {
   return createCliAgentRuntime(ampSpec, config.model);
 }
 var amp_default = createAmpRuntime();
-// src/sandbox.ts
-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";
-
-// src/sandbox-errors.ts
-var SANDBOX_UNAVAILABLE_PREFIX = "[sandbox-unavailable";
+// src/runtimes/opencode.ts
+function now7() {
+  return new Date().toISOString();
+}
+var opencodeSpec = {
+  kind: "opencode",
+  authEnv: "OPENROUTER_API_KEY",
+  bin: "opencode",
+  defaultModel: "openrouter/z-ai/glm-5.2",
+  acp: { command: "opencode", args: ["acp"] },
+  install: 'sudo npm install -g opencode-ai && (command -v opencode >/dev/null 2>&1 || sudo ln -sf "$(npm prefix -g)/bin/opencode" /usr/local/bin/opencode)',
+  promptPayload: (prompt) => prompt,
+  buildCommand: ({ promptPath, model, cwd }) => `${cwd ? `cd ${shellQuote(cwd)} && ` : ""}opencode run ${model ? `--model ${shellQuote(model)} ` : ""}"$(cat ${shellQuote(promptPath)})"`,
+  extractSessionId: () => {
+    return;
+  },
+  mapEvent: (p) => {
+    const ts = now7();
+    const text = typeof p.text === "string" ? p.text : typeof p.content === "string" ? p.content : "";
+    return text ? [{ type: "text", text, timestamp: ts }] : [];
+  }
+};
+function createOpencodeRuntime(config = {}) {
+  return createCliAgentRuntime(opencodeSpec, config.model ?? opencodeSpec.defaultModel);
+}
+var opencode_default = createOpencodeRuntime();
+// src/runtimes/cursor.ts
+function now8() {
+  return new Date().toISOString();
+}
+var cursorSpec = {
+  kind: "cursor",
+  authEnv: "CURSOR_API_KEY",
+  bin: "cursor-agent",
+  defaultModel: "auto",
+  acp: { command: "cursor-agent", args: ["acp"] },
+  install: 'curl https://cursor.com/install -fsS | bash && (command -v cursor-agent >/dev/null 2>&1 || sudo ln -sf "$HOME/.local/bin/cursor-agent" /usr/local/bin/cursor-agent)',
+  promptPayload: (prompt) => prompt,
+  buildCommand: ({ promptPath, model, cwd }) => `${cwd ? `cd ${shellQuote(cwd)} && ` : ""}cursor-agent -p --force ${model ? `--model ${shellQuote(model)} ` : ""}--output-format text "$(cat ${shellQuote(promptPath)})"`,
+  extractSessionId: () => {
+    return;
+  },
+  mapEvent: (p) => {
+    const ts = now8();
+    const text = typeof p.text === "string" ? p.text : typeof p.content === "string" ? p.content : "";
+    return text ? [{ type: "text", text, timestamp: ts }] : [];
+  }
+};
+function createCursorRuntime(config = {}) {
+  return createCliAgentRuntime(cursorSpec, config.model ?? cursorSpec.defaultModel);
+}
+var cursor_default = createCursorRuntime();
+// src/runtimes/droid.ts
+function now9() {
+  return new Date().toISOString();
+}
+var droidSpec = {
+  kind: "droid",
+  authEnv: "OPENROUTER_API_KEY",
+  bin: "droid",
+  defaultModel: "custom:GLM-5.2-OR-0",
+  install: 'curl -fsSL https://app.factory.ai/cli | sh && (command -v droid >/dev/null 2>&1 || sudo ln -sf "$HOME/.local/bin/droid" /usr/local/bin/droid)',
+  promptPayload: (prompt) => prompt,
+  buildCommand: ({ promptPath, model, cwd }) => `${cwd ? `cd ${shellQuote(cwd)} && ` : ""}droid exec --auto medium ${model ? `--model ${shellQuote(model)} ` : ""}--output-format json -f ${shellQuote(promptPath)}`,
+  extractSessionId: (p) => typeof p.session_id === "string" ? p.session_id : undefined,
+  mapEvent: (p) => {
+    const ts = now9();
+    const text = p.type === "result" && typeof p.result === "string" ? p.result : typeof p.text === "string" ? p.text : typeof p.content === "string" ? p.content : "";
+    return text ? [{ type: "text", text, timestamp: ts }] : [];
+  }
+};
+function createDroidRuntime(config = {}) {
+  return createCliAgentRuntime(droidSpec, config.model ?? droidSpec.defaultModel);
+}
+var droid_default = createDroidRuntime();
+// src/runtimes/claude-code.ts
+function now10() {
+  return new Date().toISOString();
+}
+var CLAUDE_CODE_ACP_ADAPTER = "@zed-industries/claude-code-acp@0.16.2";
+function toolResultText(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => typeof b?.text === "string" ? b.text : "").join("");
+  }
+  return content == null ? "" : JSON.stringify(content) ?? "";
+}
+var CLAUDE_CODE_THINKING_TOKENS = { low: 2048, medium: 8192, high: 16384 };
+var claudeCodeSpec = {
+  kind: "claude-code",
+  authEnv: "ANTHROPIC_API_KEY",
+  bin: "claude",
+  acp: { command: "npx", args: ["--yes", CLAUDE_CODE_ACP_ADAPTER] },
+  install: "curl -fsSL https://claude.ai/install.sh | bash && " + 'REAL=$(readlink -f "$HOME/.local/bin/claude") && test -f "$REAL" && ' + 'sudo cp "$REAL" /usr/local/bin/claude && sudo chmod 0755 /usr/local/bin/claude',
+  promptPayload: (prompt) => prompt,
+  buildCommand: ({ promptPath, sessionId, model, cwd, effort }) => {
+    const flags = [
+      "-p",
+      "--output-format stream-json",
+      "--verbose",
+      "--include-partial-messages",
+      "--dangerously-skip-permissions",
+      ...model ? [`--model ${shellQuote(model)}`] : [],
+      ...sessionId ? [`--resume ${shellQuote(sessionId)}`] : []
+    ].join(" ");
+    const thinking = effort ? `MAX_THINKING_TOKENS=${CLAUDE_CODE_THINKING_TOKENS[effort]} ` : "";
+    return `${cwd ? `cd ${shellQuote(cwd)} && ` : ""}${thinking}IS_SANDBOX=1 claude ${flags} < ${shellQuote(promptPath)}`;
+  },
+  extractSessionId: (p) => typeof p.session_id === "string" ? p.session_id : undefined,
+  mapEvent: (p) => {
+    const ts = now10();
+    switch (p.type) {
+      case "assistant": {
+        const message = p.message;
+        const blocks2 = Array.isArray(message?.content) ? message.content : [];
+        return blocks2.flatMap((b) => {
+          if (b.type === "text" && typeof b.text === "string" && b.text.length > 0) {
+            return [{ type: "text", text: b.text, timestamp: ts }];
+          }
+          if (b.type === "thinking" && typeof b.thinking === "string" && b.thinking.length > 0) {
+            return [{ type: "thinking", text: b.thinking, timestamp: ts }];
+          }
+          if (b.type === "tool_use") {
+            return [{
+              type: "tool_use",
+              toolName: String(b.name ?? "tool"),
+              toolInput: b.input ?? {},
+              toolUseId: String(b.id ?? ""),
+              timestamp: ts
+            }];
+          }
+          return [];
+        });
+      }
+      case "user": {
+        const message = p.message;
+        const blocks2 = Array.isArray(message?.content) ? message.content : [];
+        return blocks2.flatMap((b) => b.type === "tool_result" ? [{
+          type: "tool_result",
+          toolUseId: String(b.tool_use_id ?? ""),
+          output: toolResultText(b.content),
+          isError: b.is_error === true,
+          timestamp: ts
+        }] : []);
+      }
+      case "stream_event": {
+        const ev = p.event;
+        if (ev?.type === "content_block_delta" && ev.delta?.type === "text_delta" && typeof ev.delta.text === "string" && ev.delta.text.length > 0) {
+          return [{ type: "text_delta", text: ev.delta.text, timestamp: ts }];
+        }
+        if (ev?.type === "message_start" && ev.message?.usage) {
+          const u = ev.message.usage;
+          return [{
+            type: "usage_delta",
+            boundary: "call_start",
+            inputTokens: u.input_tokens ?? 0,
+            outputTokens: u.output_tokens ?? 0,
+            cacheReadTokens: u.cache_read_input_tokens ?? 0,
+            cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+            timestamp: ts
+          }];
+        }
+        if (ev?.type === "message_delta" && ev.usage && typeof ev.usage.output_tokens === "number") {
+          return [{
+            type: "usage_delta",
+            boundary: "call_delta",
+            inputTokens: 0,
+            outputTokens: ev.usage.output_tokens,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            timestamp: ts
+          }];
+        }
+        return [];
+      }
+      case "result": {
+        if (p.is_error === true) {
+          return [{ type: "error", text: formatError(p.result ?? p.subtype ?? p), timestamp: ts }];
+        }
+        const u = p.usage;
+        if (!u)
+          return [];
+        return [{
+          type: "usage",
+          inputTokens: u.input_tokens ?? 0,
+          outputTokens: u.output_tokens ?? 0,
+          cacheReadTokens: u.cache_read_input_tokens ?? 0,
+          cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+          durationMs: typeof p.duration_ms === "number" ? p.duration_ms : 0,
+          numTurns: typeof p.num_turns === "number" ? p.num_turns : 1,
+          timestamp: ts
+        }];
+      }
+      default:
+        return [];
+    }
+  }
+};
+function createClaudeCodeRuntime(config = {}) {
+  return createCliAgentRuntime(claudeCodeSpec, config.model, config.effort);
+}
+var claude_code_default = createClaudeCodeRuntime();
+// src/sandbox/network-policy.ts
+var DOT_SEGMENT_PATH_RE2 = ".*(?:^|/|%2[fF])(?:\\.|%2[eE]){2}(?:/|%2[fF]|$).*";
+var DOT_SEGMENT_RE = /(?:^|\/|%2f)(?:\.|%2e){2}(?:\/|%2f|$)/i;
+function assertSafePathPrefix(domain, prefix) {
+  if (!prefix.startsWith("/") || DOT_SEGMENT_RE.test(prefix)) {
+    throw new Error(`Invalid Tier-2 pathPrefix ${JSON.stringify(prefix)} for "${domain}": prefixes must start with "/" and contain no dot-segments`);
+  }
+}
+function toVercelNetworkPolicy(policy) {
+  if (typeof policy === "string" || !policy.allow || Array.isArray(policy.allow)) {
+    return policy;
+  }
+  const allow = {};
+  for (const [domain, rules] of Object.entries(policy.allow)) {
+    const translated = rules.flatMap((rule) => {
+      const { requestRules, ...rest } = rule;
+      const methods = requestRules?.methods ?? [];
+      const prefixes = requestRules?.pathPrefixes ?? [];
+      if (methods.length === 0 && prefixes.length === 0)
+        return [rest];
+      const methodMatch = methods.length > 0 ? { method: methods } : {};
+      if (prefixes.length === 0)
+        return [{ ...rest, match: methodMatch }];
+      for (const prefix of prefixes)
+        assertSafePathPrefix(domain, prefix);
+      return prefixes.map((prefix) => ({ ...rest, match: { ...methodMatch, path: { startsWith: prefix } } }));
+    });
+    const hasPathGate = rules.some((rule) => (rule.requestRules?.pathPrefixes?.length ?? 0) > 0);
+    allow[domain] = hasPathGate ? [{ match: { path: { regex: DOT_SEGMENT_PATH_RE2 } } }, ...translated] : translated;
+  }
+  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;
+}
 
-class SandboxUnavailableError extends Error {
-  retryable;
-  sandboxId;
-  constructor(detail, opts) {
-    super(`${SANDBOX_UNAVAILABLE_PREFIX}:${opts.retryable ? "retryable" : "terminal"}] ${detail}`);
-    this.name = "SandboxUnavailableError";
-    this.retryable = opts.retryable;
-    this.sandboxId = opts.sandboxId;
+// src/sandbox/sizes.ts
+var SANDBOX_VCPUS = {
+  "2vcpu-4gb": 2,
+  "4vcpu-8gb": 4,
+  "8vcpu-16gb": 8,
+  "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));
+}
+// src/sandbox/devbox.ts
+var E2B_DEVBOX_TEMPLATE = "agent-compose-devbox";
+var E2B_DEVBOX_SPEC = {
+  cpuCount: 8,
+  memoryMB: 8192
+};
+var E2B_DEVBOX_RECIPE_VERSION = "1";
+function e2bDevboxTemplateRef() {
+  return `${E2B_DEVBOX_TEMPLATE}@${E2B_DEVBOX_RECIPE_VERSION}`;
+}
+// src/sandbox/provider-def.ts
+var AGENT_COMPOSE_TAG = process.env.AGENT_COMPOSE_TAG ?? `agent-compose-${process.env.AGENT_COMPOSE_ENV ?? "dev"}`;
+// src/sandbox/exec-stream.ts
+async function parseSseExecStream(body, opts) {
+  let stdout = "", stderr = "", exitCode = 0, exited = false;
+  const reader = body.getReader(), decoder = new TextDecoder;
+  let buf = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buf += decoder.decode(value, { stream: true });
+    const lines = buf.replace(/\r\n/g, `
+`).split(`
+`);
+    buf = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data: "))
+        continue;
+      let event;
+      try {
+        event = JSON.parse(line.slice(6));
+      } catch (err) {
+        throw new Error(`Malformed sandbox exec event: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (event.type === "stdout") {
+        stdout += event.data ?? "";
+        opts?.onStdout?.(event.data ?? "");
+      } else if (event.type === "stderr") {
+        stderr += event.data ?? "";
+        opts?.onStderr?.(event.data ?? "");
+      } else if (event.type === "exit") {
+        exitCode = event.exitCode ?? 0;
+        exited = true;
+      } else if (event.type === "error") {
+        throw new Error(`Sandbox exec error: ${event.data}`);
+      }
+    }
+    if (exited)
+      break;
   }
+  if (!exited)
+    throw new Error("Sandbox exec stream ended without an exit event");
+  return { exitCode, stdout, stderr };
 }
-
-// src/sandbox.ts
-var AGENT_COMPOSE_TAG = process.env.AGENT_COMPOSE_TAG ?? `agent-compose-${process.env.AGENT_COMPOSE_ENV ?? "dev"}`;
-var VERCEL_VM_LIFETIME_WINDOW_MS = 6 * 60 * 60 * 1000;
-var SANDBOX_VCPUS = {
-  "2vcpu-4gb": 2,
-  "4vcpu-8gb": 4,
-  "8vcpu-16gb": 8,
-  "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));
-}
+// src/sandbox/providers/e2b.ts
+import { Sandbox } from "e2b";
+import pRetry from "p-retry";
 function makeSandboxProvider(sb) {
   const commands = sb.commands;
   return {
@@ -3458,31 +4506,22 @@ function makeSandboxProvider(sb) {
     files: {
       async write(path, content) {
         await sb.files.write(path, content);
+      },
+      async read(path) {
+        return await sb.files.read(path);
       }
     },
     async kill() {
       await sb.kill();
+    },
+    getHost(port) {
+      return sb.getHost(port);
     }
   };
 }
 function e2bMaxSandboxMs() {
   return Number(process.env.E2B_MAX_SANDBOX_MS) || 60 * 60 * 1000;
 }
-function isTransientSandboxError(error) {
-  if (error instanceof SandboxNotFoundError || error instanceof RateLimitError)
-    return true;
-  const message = error instanceof Error ? error.message : String(error ?? "");
-  return /paus|stopp|resum|transition|status(?:\s+code)?[:\s]+5\d\d\b|\b5\d\d\s+(?:internal|bad gateway|service|gateway)|\b429\b|ECONNRESET|ECONNREFUSED|ETIMEDOUT|socket hang up|fetch failed/i.test(message);
-}
-function withSandboxRetry(fn, shouldRetry = isTransientSandboxError) {
-  return pRetry(fn, { retries: 4, minTimeout: 400, factor: 2, shouldRetry });
-}
-function withSnapshotRetry(p) {
-  if (!p.snapshot)
-    return p;
-  const snapshot = p.snapshot.bind(p);
-  return { ...p, snapshot: () => withSandboxRetry(snapshot) };
-}
 function wrapE2bBackgroundProcess(handle) {
   return {
     pid: handle.pid,
@@ -3507,6 +4546,22 @@ function wrapE2bBackgroundProcess(handle) {
     }
   };
 }
+function wrapE2bPtyHandle(sb, handle, onExit) {
+  handle.wait().catch(() => {
+    return;
+  }).finally(() => onExit?.());
+  return {
+    pid: handle.pid,
+    sendInput: (data) => sb.pty.sendInput(handle.pid, data),
+    resize: (size) => sb.pty.resize(handle.pid, size),
+    kill: async () => {
+      await sb.pty.kill(handle.pid);
+    },
+    disconnect: async () => {
+      await handle.disconnect();
+    }
+  };
+}
 function makeE2bSandboxProvider(sb) {
   const base = makeSandboxProvider(sb);
   return {
@@ -3533,6 +4588,24 @@ function makeE2bSandboxProvider(sb) {
         return wrapE2bBackgroundProcess(handle);
       }
     },
+    async createPty(opts) {
+      const handle = await sb.pty.create({
+        cols: opts.cols,
+        rows: opts.rows,
+        ...opts.cwd ? { cwd: opts.cwd } : {},
+        envs: { TERM: "xterm-256color", ...opts.envs ?? {} },
+        onData: opts.onData,
+        timeoutMs: 0
+      });
+      return wrapE2bPtyHandle(sb, handle, opts.onExit);
+    },
+    async connectPty(pid, opts) {
+      const handle = await sb.pty.connect(pid, {
+        onData: opts.onData,
+        timeoutMs: 0
+      });
+      return wrapE2bPtyHandle(sb, handle, opts.onExit);
+    },
     async snapshot() {
       const { snapshotId } = await sb.createSnapshot();
       return { snapshotId };
@@ -3541,11 +4614,64 @@ function makeE2bSandboxProvider(sb) {
       await sb.pause();
       return { resumeHandle: sb.sandboxId };
     },
+    async extendLifetime(ms) {
+      await sb.setTimeout(ms);
+    },
     async updateNetworkPolicy(policy) {
       await sb.updateNetwork(toE2bNetwork(policy));
     }
   };
 }
+async function listOwned() {
+  const paginator = Sandbox.list({ query: { metadata: { executor: AGENT_COMPOSE_TAG }, state: ["running"] } });
+  const out = [];
+  while (paginator.hasNext) {
+    const items = await pRetry(() => paginator.nextItems(), { retries: 3, minTimeout: 500, factor: 2 });
+    for (const sb of items) {
+      out.push({
+        sandboxId: sb.sandboxId,
+        createdAt: new Date(sb.startedAt),
+        metadata: sb.metadata ?? {}
+      });
+    }
+  }
+  return out;
+}
+var e2bProviderDef = {
+  requiredEnv: { E2B_API_KEY: "E2B API key — e2b.dev/dashboard" },
+  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),
+      ...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: 60 * 60 * 1000 })),
+  killAll: async () => {
+    const paginator = Sandbox.list({ query: { metadata: { executor: AGENT_COMPOSE_TAG } } });
+    const sandboxes = [];
+    while (paginator.hasNext)
+      sandboxes.push(...await paginator.nextItems());
+    if (sandboxes.length === 0)
+      return;
+    await Promise.all(sandboxes.map((s) => Sandbox.kill(s.sandboxId)));
+    console.info(`[sandbox] killed ${sandboxes.length} stale E2B sandboxes (tag: ${AGENT_COMPOSE_TAG})`);
+  },
+  getActiveCount: async () => (await listOwned()).length,
+  listOwned,
+  deleteSnapshot: async (snapshotId, env) => {
+    await Sandbox.deleteSnapshot(snapshotId, { apiKey: env.E2B_API_KEY });
+  }
+};
+// src/sandbox/providers/desktop.ts
+import { Sandbox as Desktop } from "@e2b/desktop";
 function makeDesktopSandboxProvider(sb) {
   return {
     ...makeSandboxProvider(sb),
@@ -3561,104 +4687,39 @@ function makeDesktopSandboxProvider(sb) {
     drag: (from, to) => sb.drag(from, to)
   };
 }
-async function parseSseExecStream(body, opts) {
-  let stdout = "", stderr = "", exitCode = 0, exited = false;
-  const reader = body.getReader(), decoder = new TextDecoder;
-  let buf = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done)
-      break;
-    buf += decoder.decode(value, { stream: true });
-    const lines = buf.replace(/\r\n/g, `
-`).split(`
-`);
-    buf = lines.pop() ?? "";
-    for (const line of lines) {
-      if (!line.startsWith("data: "))
-        continue;
-      let event;
-      try {
-        event = JSON.parse(line.slice(6));
-      } catch (err) {
-        throw new Error(`Malformed sandbox exec event: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      if (event.type === "stdout") {
-        stdout += event.data ?? "";
-        opts?.onStdout?.(event.data ?? "");
-      } else if (event.type === "stderr") {
-        stderr += event.data ?? "";
-        opts?.onStderr?.(event.data ?? "");
-      } else if (event.type === "exit") {
-        exitCode = event.exitCode ?? 0;
-        exited = true;
-      } else if (event.type === "error") {
-        throw new Error(`Sandbox exec error: ${event.data}`);
-      }
+var e2bDesktopProviderDef = {
+  requiredEnv: { E2B_API_KEY: "E2B API key — e2b.dev/dashboard" },
+  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)");
+    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.");
     }
-    if (exited)
-      break;
-  }
-  if (!exited)
-    throw new Error("Sandbox exec stream ended without an exit event");
-  return { exitCode, stdout, stderr };
-}
-var DOT_SEGMENT_PATH_RE2 = ".*(?:^|/|%2[fF])(?:\\.|%2[eE]){2}(?:/|%2[fF]|$).*";
-var DOT_SEGMENT_RE = /(?:^|\/|%2f)(?:\.|%2e){2}(?:\/|%2f|$)/i;
-function assertSafePathPrefix(domain, prefix) {
-  if (!prefix.startsWith("/") || DOT_SEGMENT_RE.test(prefix)) {
-    throw new Error(`Invalid Tier-2 pathPrefix ${JSON.stringify(prefix)} for "${domain}": prefixes must start with "/" and contain no dot-segments`);
-  }
-}
-function toVercelNetworkPolicy(policy) {
-  if (typeof policy === "string" || !policy.allow || Array.isArray(policy.allow)) {
-    return policy;
-  }
-  const allow = {};
-  for (const [domain, rules] of Object.entries(policy.allow)) {
-    const translated = rules.flatMap((rule) => {
-      const { requestRules, ...rest } = rule;
-      const methods = requestRules?.methods ?? [];
-      const prefixes = requestRules?.pathPrefixes ?? [];
-      if (methods.length === 0 && prefixes.length === 0)
-        return [rest];
-      const methodMatch = methods.length > 0 ? { method: methods } : {};
-      if (prefixes.length === 0)
-        return [{ ...rest, match: methodMatch }];
-      for (const prefix of prefixes)
-        assertSafePathPrefix(domain, prefix);
-      return prefixes.map((prefix) => ({ ...rest, match: { ...methodMatch, path: { startsWith: prefix } } }));
-    });
-    const hasPathGate = rules.some((rule) => (rule.requestRules?.pathPrefixes?.length ?? 0) > 0);
-    allow[domain] = hasPathGate ? [{ match: { path: { regex: DOT_SEGMENT_PATH_RE2 } } }, ...translated] : translated;
+    return makeDesktopSandboxProvider(await Desktop.create(template, {
+      ...rest,
+      timeoutMs: Math.min(timeoutMs, e2bMaxSandboxMs())
+    }));
   }
-  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;
+};
+// src/sandbox/providers/vercel.ts
+import pRetry2 from "p-retry";
+
+// src/sandbox-errors.ts
+var SANDBOX_UNAVAILABLE_PREFIX = "[sandbox-unavailable";
+
+class SandboxUnavailableError extends Error {
+  retryable;
+  sandboxId;
+  constructor(detail, opts) {
+    super(`${SANDBOX_UNAVAILABLE_PREFIX}:${opts.retryable ? "retryable" : "terminal"}] ${detail}`);
+    this.name = "SandboxUnavailableError";
+    this.retryable = opts.retryable;
+    this.sandboxId = opts.sandboxId;
   }
-  return network;
 }
+
+// src/sandbox/providers/vercel.ts
+var VERCEL_VM_LIFETIME_WINDOW_MS = 6 * 60 * 60 * 1000;
 var VERCEL_MAX_TAGS = 5;
 function buildVercelTags(metadata) {
   const tags = { ...metadata, executor: AGENT_COMPOSE_TAG };
@@ -3681,23 +4742,33 @@ function makeVercelSandboxProvider(sb, globalEnvs) {
         let stderr = "";
         const handle = await sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts?.cwd, env: mergeEnvs(opts?.envs), detached: true, signal, ...opts?.sudo ? { sudo: true } : {} }).catch((err) => asUnavailable(err, true));
         const collect = async () => {
-          await pRetry(async (attempt) => {
+          const finished = await pRetry2(async (attempt) => {
             const h = attempt === 1 ? handle : await sb.getCommand(handle.cmdId);
-            if (attempt > 1) {
-              stdout = "";
-              stderr = "";
-            }
+            let seenOut = 0;
+            let seenErr = 0;
+            const fresh = (data, seen, delivered) => {
+              const skip = Math.min(Math.max(delivered - seen, 0), data.length);
+              return skip > 0 ? data.slice(skip) : data;
+            };
             for await (const log of h.logs()) {
               if (log.stream === "stdout") {
-                stdout += log.data;
-                opts?.onStdout?.(log.data);
+                const add = fresh(log.data, seenOut, stdout.length);
+                seenOut += log.data.length;
+                if (add) {
+                  stdout += add;
+                  opts?.onStdout?.(add);
+                }
               } else {
-                stderr += log.data;
-                opts?.onStderr?.(log.data);
+                const add = fresh(log.data, seenErr, stderr.length);
+                seenErr += log.data.length;
+                if (add) {
+                  stderr += add;
+                  opts?.onStderr?.(add);
+                }
               }
             }
+            return await h.wait();
           }, { retries: 3, minTimeout: 1000, factor: 2 });
-          const finished = await handle.wait();
           return { exitCode: finished.exitCode, stdout, stderr };
         };
         let timer;
@@ -3721,6 +4792,12 @@ function makeVercelSandboxProvider(sb, globalEnvs) {
     files: {
       async write(path, content) {
         await sb.writeFiles([{ path, content }]).catch((err) => asUnavailable(err, true));
+      },
+      async read(path) {
+        const buf = await sb.readFileToBuffer({ path });
+        if (buf === null)
+          throw new Error(`file not found: ${path}`);
+        return buf.toString("utf8");
       }
     },
     async kill() {
@@ -3740,6 +4817,84 @@ function makeVercelSandboxProvider(sb, globalEnvs) {
     }
   };
 }
+async function listOwned2(env) {
+  const { Sandbox: VercelSandbox } = await import("@vercel/sandbox");
+  const creds = { token: env.VERCEL_ACCESS_TOKEN, teamId: env.VERCEL_TEAM_ID, projectId: env.VERCEL_PROJECT_ID };
+  const since = Date.now() - VERCEL_VM_LIFETIME_WINDOW_MS;
+  const out = [];
+  let cursor;
+  for (let page = 0;page < 200; page++) {
+    const result = await pRetry2(() => VercelSandbox.list({ ...creds, limit: 50, sortBy: "createdAt", sortOrder: "desc", tags: { executor: AGENT_COMPOSE_TAG }, ...cursor !== undefined ? { cursor } : {} }), { retries: 3, minTimeout: 500, factor: 2 });
+    for (const sb of result.sandboxes) {
+      if (sb.createdAt < since)
+        return out;
+      if (sb.status === "running") {
+        out.push({ sandboxId: sb.name, createdAt: new Date(sb.createdAt), metadata: sb.tags ?? {} });
+      }
+    }
+    if (result.pagination.next === null)
+      return out;
+    cursor = result.pagination.next;
+  }
+  throw new Error("Vercel listSandboxes exceeded 200 pages (10k sandboxes) within the lifetime window — refuse to silently truncate");
+}
+var vercelProviderDef = {
+  requiredEnv: {
+    VERCEL_ACCESS_TOKEN: "Vercel access token — vercel.com/account/tokens",
+    VERCEL_TEAM_ID: "Vercel team ID — vercel.com/account/settings",
+    VERCEL_PROJECT_ID: "Vercel project ID — vercel.com/[team]/[project]/settings"
+  },
+  create: async (opts, env) => {
+    const { Sandbox: VercelSandbox } = await import("@vercel/sandbox");
+    const creds = { token: env.VERCEL_ACCESS_TOKEN, teamId: env.VERCEL_TEAM_ID, projectId: env.VERCEL_PROJECT_ID };
+    const np = opts.networkPolicy ? { networkPolicy: toVercelNetworkPolicy(opts.networkPolicy) } : {};
+    const tags = buildVercelTags(opts.metadata);
+    const tmpl = opts.template ?? process.env.VERCEL_DEFAULT_SNAPSHOT;
+    const resources = { vcpus: SANDBOX_VCPUS[opts.size ?? DEFAULT_SANDBOX_SIZE] };
+    const sb = await VercelSandbox.create(tmpl ? { source: { type: "snapshot", snapshotId: tmpl }, timeout: opts.timeoutMs, env: opts.envs, tags, persistent: false, resources, ...np, ...creds } : { runtime: "node24", timeout: opts.timeoutMs, env: opts.envs, tags, persistent: false, resources, ...np, ...creds });
+    return makeVercelSandboxProvider(sb, opts.envs);
+  },
+  reconnect: async (sandboxId) => {
+    const { Sandbox: VercelSandbox } = await import("@vercel/sandbox");
+    const creds = {
+      token: process.env.VERCEL_ACCESS_TOKEN ?? "",
+      teamId: process.env.VERCEL_TEAM_ID ?? "",
+      projectId: process.env.VERCEL_PROJECT_ID ?? ""
+    };
+    const sb = await VercelSandbox.get({ name: sandboxId, ...creds }).catch((err) => {
+      throw new SandboxUnavailableError(err instanceof Error ? err.message : String(err), { retryable: true, sandboxId });
+    });
+    return makeVercelSandboxProvider(sb);
+  },
+  getActiveCount: async (env) => (await listOwned2(env)).length,
+  listOwned: listOwned2,
+  deleteSnapshot: 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 };
+    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;
+    }
+  }
+};
+
+// src/sandbox/providers/local.ts
+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";
 function makeLocalSandboxProvider() {
   return {
     sandboxId: "local",
@@ -3805,145 +4960,37 @@ function makeLocalSandboxProvider() {
       async write(path, content) {
         await fs2.mkdir(dirname2(path), { recursive: true });
         await fs2.writeFile(path, content);
+      },
+      async read(path) {
+        return await fs2.readFile(path, "utf8");
       }
     },
     async kill() {}
   };
 }
+// src/sandbox/registry.ts
+import { SandboxNotFoundError, RateLimitError } from "e2b";
+import pRetry3 from "p-retry";
 var SANDBOX_PROVIDERS = {
-  vercel: {
-    requiredEnv: {
-      VERCEL_ACCESS_TOKEN: "Vercel access token — vercel.com/account/tokens",
-      VERCEL_TEAM_ID: "Vercel team ID — vercel.com/account/settings",
-      VERCEL_PROJECT_ID: "Vercel project ID — vercel.com/[team]/[project]/settings"
-    },
-    create: async (opts, env) => {
-      const { Sandbox: VercelSandbox } = await import("@vercel/sandbox");
-      const creds = { token: env.VERCEL_ACCESS_TOKEN, teamId: env.VERCEL_TEAM_ID, projectId: env.VERCEL_PROJECT_ID };
-      const np = opts.networkPolicy ? { networkPolicy: toVercelNetworkPolicy(opts.networkPolicy) } : {};
-      const tags = buildVercelTags(opts.metadata);
-      const tmpl = opts.template ?? process.env.VERCEL_DEFAULT_SNAPSHOT;
-      const resources = { vcpus: SANDBOX_VCPUS[opts.size ?? DEFAULT_SANDBOX_SIZE] };
-      const sb = await VercelSandbox.create(tmpl ? { source: { type: "snapshot", snapshotId: tmpl }, timeout: opts.timeoutMs, env: opts.envs, tags, persistent: false, resources, ...np, ...creds } : { runtime: "node24", timeout: opts.timeoutMs, env: opts.envs, tags, persistent: false, resources, ...np, ...creds });
-      return makeVercelSandboxProvider(sb, opts.envs);
-    },
-    reconnect: async (sandboxId) => {
-      const { Sandbox: VercelSandbox } = await import("@vercel/sandbox");
-      const creds = {
-        token: process.env.VERCEL_ACCESS_TOKEN ?? "",
-        teamId: process.env.VERCEL_TEAM_ID ?? "",
-        projectId: process.env.VERCEL_PROJECT_ID ?? ""
-      };
-      const sb = await VercelSandbox.get({ name: sandboxId, ...creds }).catch((err) => {
-        throw new SandboxUnavailableError(err instanceof Error ? err.message : String(err), { retryable: true, sandboxId });
-      });
-      return makeVercelSandboxProvider(sb);
-    },
-    getActiveCount: async (env) => (await SANDBOX_PROVIDERS.vercel.listOwned(env)).length,
-    listOwned: async (env) => {
-      const { Sandbox: VercelSandbox } = await import("@vercel/sandbox");
-      const creds = { token: env.VERCEL_ACCESS_TOKEN, teamId: env.VERCEL_TEAM_ID, projectId: env.VERCEL_PROJECT_ID };
-      const since = Date.now() - VERCEL_VM_LIFETIME_WINDOW_MS;
-      const out = [];
-      let cursor;
-      for (let page = 0;page < 200; page++) {
-        const result = await pRetry(() => VercelSandbox.list({ ...creds, limit: 50, sortBy: "createdAt", sortOrder: "desc", tags: { executor: AGENT_COMPOSE_TAG }, ...cursor !== undefined ? { cursor } : {} }), { retries: 3, minTimeout: 500, factor: 2 });
-        for (const sb of result.sandboxes) {
-          if (sb.createdAt < since)
-            return out;
-          if (sb.status === "running") {
-            out.push({ sandboxId: sb.name, createdAt: new Date(sb.createdAt), metadata: sb.tags ?? {} });
-          }
-        }
-        if (result.pagination.next === null)
-          return out;
-        cursor = result.pagination.next;
-      }
-      throw new Error("Vercel listSandboxes exceeded 200 pages (10k sandboxes) within the lifetime window — refuse to silently truncate");
-    },
-    deleteSnapshot: 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 };
-      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, 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),
-        ...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 })),
-    killAll: async () => {
-      const paginator = Sandbox.list({ query: { metadata: { executor: AGENT_COMPOSE_TAG } } });
-      const sandboxes = [];
-      while (paginator.hasNext)
-        sandboxes.push(...await paginator.nextItems());
-      if (sandboxes.length === 0)
-        return;
-      await Promise.all(sandboxes.map((s) => Sandbox.kill(s.sandboxId)));
-      console.info(`[sandbox] killed ${sandboxes.length} stale E2B sandboxes (tag: ${AGENT_COMPOSE_TAG})`);
-    },
-    getActiveCount: async () => (await SANDBOX_PROVIDERS.e2b.listOwned({})).length,
-    listOwned: async () => {
-      const paginator = Sandbox.list({ query: { metadata: { executor: AGENT_COMPOSE_TAG }, state: ["running"] } });
-      const out = [];
-      while (paginator.hasNext) {
-        const items = await pRetry(() => paginator.nextItems(), { retries: 3, minTimeout: 500, factor: 2 });
-        for (const sb of items) {
-          out.push({
-            sandboxId: sb.sandboxId,
-            createdAt: new Date(sb.startedAt),
-            metadata: sb.metadata ?? {}
-          });
-        }
-      }
-      return out;
-    },
-    deleteSnapshot: async (snapshotId, env) => {
-      await Sandbox.deleteSnapshot(snapshotId, { apiKey: env.E2B_API_KEY });
-    }
-  },
-  "e2b-desktop": {
-    requiredEnv: { E2B_API_KEY: "E2B API key — e2b.dev/dashboard" },
-    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)");
-      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())
-      }));
-    }
-  }
+  vercel: vercelProviderDef,
+  e2b: e2bProviderDef,
+  "e2b-desktop": e2bDesktopProviderDef
 };
+function isTransientSandboxError(error) {
+  if (error instanceof SandboxNotFoundError || error instanceof RateLimitError)
+    return true;
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return /paus|stopp|resum|transition|status(?:\s+code)?[:\s]+5\d\d\b|\b5\d\d\s+(?:internal|bad gateway|service|gateway)|\b429\b|ECONNRESET|ECONNREFUSED|ETIMEDOUT|socket hang up|fetch failed/i.test(message);
+}
+function withSandboxRetry(fn, shouldRetry = isTransientSandboxError) {
+  return pRetry3(fn, { retries: 4, minTimeout: 400, factor: 2, shouldRetry });
+}
+function withSnapshotRetry(p) {
+  if (!p.snapshot)
+    return p;
+  const snapshot = p.snapshot.bind(p);
+  return { ...p, snapshot: () => withSandboxRetry(snapshot) };
+}
 async function createSandbox(provider, opts) {
   const def = SANDBOX_PROVIDERS[provider];
   if (!def)
@@ -4114,7 +5161,7 @@ class StepObservabilityCollector {
     await this.drainInFlight();
     const hasMetadata = Object.keys(this.metadata).length > 0;
     const hasSubSteps = this.subSteps.length > 0;
-    const remainingEvents = this.events.filter((_, idx) => !this.ackedSeqs.has(idx));
+    const remainingEvents = this.events.map((event, seq) => ({ ...event, seq })).filter(({ seq }) => !this.ackedSeqs.has(seq));
     const hasEvents = remainingEvents.length > 0;
     if (!hasMetadata && !hasEvents && !hasSubSteps)
       return;
@@ -4147,6 +5194,8 @@ function scopedMemoize(scope) {
 }
 
 // src/pause/wrappers.ts
+import { z as z11 } from "zod";
+var DecisionResultSchema = z11.object({ decision: z11.string() });
 function buildPauseWrappers(pause) {
   return {
     sleep(durationMs) {
@@ -4164,6 +5213,20 @@ function buildPauseWrappers(pause) {
         ...req.schema !== undefined ? { schema: req.schema } : {},
         ...req.ttlMs !== undefined ? { ttlMs: req.ttlMs } : {}
       }, "event");
+    },
+    requestDecision(req) {
+      return pause({
+        reason: req.prompt,
+        payload: {
+          prompt: req.prompt,
+          ...req.options !== undefined ? { options: req.options } : {},
+          ...req.approvers !== undefined ? { approvers: req.approvers } : {},
+          ...req.draft !== undefined ? { draft: req.draft } : {}
+        },
+        schema: DecisionResultSchema,
+        ...req.ttlMs !== undefined ? { ttlMs: req.ttlMs } : {},
+        ...req.correlationKey !== undefined ? { correlationKey: req.correlationKey } : {}
+      }, "decision");
     }
   };
 }
@@ -4466,14 +5529,35 @@ function buildInvokeChild(runId, opts = {}) {
   });
 }
 // src/workflow-steps/step.ts
+var CONTROL_CHARS = /[\u0000-\u001f\u007f]/;
 function defineStep(opts) {
   if (!opts.name)
     throw new Error("defineStep: 'name' is required");
+  if (opts.summary !== undefined) {
+    if (opts.summary.length === 0 || opts.summary.length > 200 || CONTROL_CHARS.test(opts.summary)) {
+      throw new Error(`defineStep("${opts.name}"): 'summary' must be one plain sentence, 1-200 characters, no control characters`);
+    }
+  }
+  if (opts.deliverables !== undefined) {
+    if (opts.deliverables.length > 8) {
+      throw new Error(`defineStep("${opts.name}"): at most 8 deliverables`);
+    }
+    for (const d of opts.deliverables) {
+      if (!d.path || d.path.length > 200 || CONTROL_CHARS.test(d.path)) {
+        throw new Error(`defineStep("${opts.name}"): each deliverable needs a 'path' of 1-200 characters, no control characters`);
+      }
+      if (d.description !== undefined && (d.description.length === 0 || d.description.length > 200 || CONTROL_CHARS.test(d.description))) {
+        throw new Error(`defineStep("${opts.name}"): deliverable descriptions must be 1-200 characters, no control characters`);
+      }
+    }
+  }
   return {
     name: opts.name,
     input: opts.input,
     output: opts.output,
-    run: opts.run
+    run: opts.run,
+    ...opts.summary !== undefined ? { summary: opts.summary } : {},
+    ...opts.deliverables !== undefined ? { deliverables: Object.freeze(opts.deliverables.map((d) => ({ ...d }))) } : {}
   };
 }
 // src/step-invocation/protocol.ts
@@ -4505,34 +5589,40 @@ function requestContextPath(stepIndex) {
 function stepResultFilePath(token) {
   return `/tmp/wf/step-result-${token}.json`;
 }
+function stepPidFilePath(token) {
+  return `/tmp/wf/step-pid-${token}.pid`;
+}
+function stepLogFilePath(token) {
+  return `/tmp/wf/step-log-${token}.log`;
+}
 // src/step-invocation/invoker.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-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()
+import { z as z12 } from "zod";
+var StepObservabilitySchema = z12.object({
+  metadata: z12.record(z12.string(), z12.unknown()).optional(),
+  events: z12.array(z12.unknown()).optional(),
+  subSteps: z12.array(z12.object({
+    name: z12.string(),
+    startedAt: z12.number(),
+    durationMs: z12.number(),
+    status: z12.enum(["completed", "failed"]),
+    error: z12.string().optional()
   })).optional()
 }).passthrough();
-var StepResultEnvelopeSchema = z11.discriminatedUnion("ok", [
-  z11.object({
-    ok: z11.literal(true),
-    output: z11.unknown().optional(),
+var StepResultEnvelopeSchema = z12.discriminatedUnion("ok", [
+  z12.object({
+    ok: z12.literal(true),
+    output: z12.unknown().optional(),
     observability: StepObservabilitySchema.optional()
   }),
-  z11.object({
-    ok: z11.literal(false),
-    kind: z11.enum(["protocol", "user-step"]),
-    error: z11.string().optional()
+  z12.object({
+    ok: z12.literal(false),
+    kind: z12.enum(["protocol", "user-step"]),
+    error: z12.string().optional()
   })
 ]);
-var StepPauseEnvelopeSchema = z11.object({
-  pauseId: z11.string().min(1),
+var StepPauseEnvelopeSchema = z12.object({
+  pauseId: z12.string().min(1),
   pauseRequest: StepPauseRequestSchema,
   observability: StepObservabilitySchema.optional()
 });
@@ -4617,8 +5707,9 @@ function makeStreamSplitters(opts, resultToken) {
   const isSentinel = (line) => line.startsWith(resultSentinel) || line.startsWith(pauseSentinel);
   const make = (sink, filterSentinel) => {
     if (!sink)
-      return { onChunk: undefined, flush: () => {} };
+      return { onChunk: undefined, flush: () => {}, consumed: () => 0 };
     let buf = "";
+    let consumed = 0;
     return {
       onChunk: (chunk) => {
         buf += chunk;
@@ -4627,6 +5718,7 @@ function makeStreamSplitters(opts, resultToken) {
 `)) !== -1) {
           const line = buf.slice(0, nl);
           buf = buf.slice(nl + 1);
+          consumed += line.length + 1;
           if (filterSentinel && isSentinel(line))
             continue;
           sink(line);
@@ -4637,10 +5729,12 @@ function makeStreamSplitters(opts, resultToken) {
           return;
         const line = buf;
         buf = "";
+        consumed += line.length;
         if (filterSentinel && isSentinel(line))
           return;
         sink(line);
-      }
+      },
+      consumed: () => consumed
     };
   };
   const stdout = make(opts?.onStdout, true);
@@ -4651,7 +5745,8 @@ function makeStreamSplitters(opts, resultToken) {
     flush: () => {
       stdout.flush();
       stderr.flush();
-    }
+    },
+    stdoutConsumedChars: () => stdout.consumed()
   };
 }
 async function classifyRunnerOutcome(sandbox, output, resultToken) {
@@ -4695,6 +5790,100 @@ ${tail}` : ""}`
     }
   };
 }
+async function pollDurableResult(sandbox, runnerPid, resultToken, opts) {
+  const signal = opts?.signal;
+  const resultFile = stepResultFilePath(resultToken);
+  const POLL_MS = 1000;
+  const deadlineMs = opts?.deadlineMs ?? 45 * 60000;
+  const DEADLINE = Date.now() + deadlineMs;
+  const CMD_TIMEOUT_MS = 1e4;
+  const UNREACHABLE_LIMIT = 20;
+  let unreachableStreak = 0;
+  const readResult = async () => {
+    const r = await sandbox.commands.run(`cat ${resultFile} 2>/dev/null || true`, { timeoutMs: CMD_TIMEOUT_MS }).catch(() => "unreachable");
+    if (r === "unreachable")
+      return "unreachable";
+    return r.stdout ? parseStepResult(r.stdout, resultToken) ?? null : null;
+  };
+  for (let attempt = 1;; attempt++) {
+    if (signal?.aborted) {
+      return { ok: false, error: { kind: "runner-exit", message: "reconnectStep aborted (run re-paused)", exitCode: 1 } };
+    }
+    const fromFile = await readResult();
+    if (fromFile !== null && fromFile !== "unreachable")
+      return fromFile;
+    const probe = await sandbox.commands.run(`test -d /proc/${runnerPid} && echo alive || echo dead`, { timeoutMs: CMD_TIMEOUT_MS }).catch(() => null);
+    if (fromFile === "unreachable" && probe === null) {
+      unreachableStreak++;
+      if (unreachableStreak >= UNREACHABLE_LIMIT) {
+        return {
+          ok: false,
+          error: {
+            kind: "runner-exit",
+            message: `sandbox stopped responding while waiting for runner pid ${runnerPid} to emit a result (${UNREACHABLE_LIMIT} consecutive failed polls)`,
+            exitCode: 1
+          }
+        };
+      }
+    } else {
+      unreachableStreak = 0;
+    }
+    const dead = (probe?.stdout ?? "").includes("dead");
+    process.stderr.write(`[recover] poll ${attempt}: result-file=absent runner=${dead ? "dead" : "alive"} pid=${runnerPid}
+`);
+    if (dead) {
+      const finalRead = await readResult();
+      if (finalRead !== null && finalRead !== "unreachable")
+        return finalRead;
+      return {
+        ok: false,
+        error: { kind: "runner-exit", message: `runner pid ${runnerPid} exited without writing a result file`, exitCode: 1 }
+      };
+    }
+    if (Date.now() > DEADLINE) {
+      return {
+        ok: false,
+        error: {
+          kind: "runner-exit",
+          message: `timed out after ${Math.round(deadlineMs / 60000)}m waiting for runner pid ${runnerPid} to emit a result`,
+          exitCode: 1
+        }
+      };
+    }
+    await new Promise((r) => setTimeout(r, POLL_MS));
+  }
+}
+async function recoverLogsAndResult(sandbox, runnerPid, resultToken, liveSplitters, opts, pollOpts) {
+  const result = await pollDurableResult(sandbox, runnerPid, resultToken, pollOpts);
+  if (sandbox.files.read && opts?.onStdout) {
+    const fullLog = await sandbox.files.read(stepLogFilePath(resultToken)).catch(() => null);
+    if (fullLog != null) {
+      const already = liveSplitters.stdoutConsumedChars();
+      const tail = fullLog.length > already ? fullLog.slice(already) : "";
+      if (tail.length > 0) {
+        const backfill = makeStreamSplitters(opts, resultToken);
+        backfill.onStdout?.(tail);
+        backfill.flush();
+      }
+    }
+  }
+  return result;
+}
+async function readRunnerPid(sandbox, resultToken) {
+  const ATTEMPTS = 3;
+  const RETRY_DELAY_MS = 2000;
+  for (let attempt = 1;attempt <= ATTEMPTS; attempt++) {
+    try {
+      const r = await sandbox.commands.run(`cat ${stepPidFilePath(resultToken)} 2>/dev/null || true`, { timeoutMs: 1e4 });
+      const pid = Number.parseInt(r.stdout.trim(), 10);
+      if (Number.isInteger(pid) && pid > 0)
+        return pid;
+    } catch {}
+    if (attempt < ATTEMPTS)
+      await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+  }
+  return null;
+}
 async function prepareStepLaunch(sandbox, request, opts) {
   const resultToken = randomBytes2(16).toString("hex");
   await Promise.all([
@@ -4712,15 +5901,23 @@ async function invokeStep(sandbox, request, opts) {
   const splitters = makeStreamSplitters(opts, resultToken);
   let result;
   try {
-    result = await sandbox.commands.run(RUNNER_COMMAND, {
-      envs,
+    result = await sandbox.commands.run(`set -o pipefail; echo $$ > ${stepPidFilePath(resultToken)}; ${RUNNER_COMMAND} | tee ${stepLogFilePath(resultToken)}`, {
+      envs: { ...envs, HOME: "/root", IS_SANDBOX: "1" },
+      sudo: true,
       timeoutMs: 0,
       ...splitters.onStdout ? { onStdout: splitters.onStdout } : {},
       ...splitters.onStderr ? { onStderr: splitters.onStderr } : {}
     });
   } catch (e) {
-    if (e instanceof SandboxUnavailableError)
-      throw e;
+    if (e instanceof SandboxUnavailableError) {
+      if (e.retryable)
+        throw e;
+      const runnerPid = await readRunnerPid(sandbox, resultToken);
+      if (runnerPid === null)
+        throw e;
+      opts?.onStreamDegraded?.({ error: e, runnerPid, resultToken });
+      return recoverLogsAndResult(sandbox, runnerPid, resultToken, splitters, opts, opts?.recoveryDeadlineMs !== undefined ? { deadlineMs: opts.recoveryDeadlineMs } : undefined);
+    }
     const ce = e;
     result = {
       stdout: ce.stdout ?? ce.result?.stdout ?? "",
@@ -4737,8 +5934,9 @@ async function launchStep(sandbox, request, opts) {
   }
   const { resultToken, envs } = await prepareStepLaunch(sandbox, request, opts);
   const splitters = makeStreamSplitters(opts, resultToken);
-  const proc = await sandbox.commands.runBackground(RUNNER_COMMAND, {
-    envs,
+  const proc = await sandbox.commands.runBackground(`set -o pipefail; ${RUNNER_COMMAND} | tee ${stepLogFilePath(resultToken)}`, {
+    envs: { ...envs, HOME: "/root", IS_SANDBOX: "1" },
+    sudo: true,
     timeoutMs: 0,
     ...splitters.onStdout ? { onStdout: splitters.onStdout } : {},
     ...splitters.onStderr ? { onStderr: splitters.onStderr } : {}
@@ -4747,9 +5945,16 @@ async function launchStep(sandbox, request, opts) {
     runnerPid: proc.pid,
     resultToken,
     async wait() {
-      const result = await proc.wait();
-      splitters.flush();
-      return classifyRunnerOutcome(sandbox, result, resultToken);
+      try {
+        const result = await proc.wait();
+        splitters.flush();
+        return classifyRunnerOutcome(sandbox, result, resultToken);
+      } catch (e) {
+        if (e instanceof SandboxUnavailableError)
+          throw e;
+        opts?.onStreamDegraded?.({ error: e, runnerPid: proc.pid, resultToken });
+        return recoverLogsAndResult(sandbox, proc.pid, resultToken, splitters, opts);
+      }
     }
   };
 }
@@ -4759,9 +5964,11 @@ async function reconnectStep(sandbox, resume, opts) {
   }
   const { runnerPid, resultToken } = resume;
   const splitters = makeStreamSplitters(opts, resultToken);
-  let proc = null;
+  const signal = opts?.signal;
+  const pollDeadlineMs = opts?.pollDeadlineMs;
+  let attached = null;
   try {
-    proc = await sandbox.commands.connectProcess(runnerPid, {
+    attached = await sandbox.commands.connectProcess(runnerPid, {
       ...splitters.onStdout ? { onStdout: splitters.onStdout } : {},
       ...splitters.onStderr ? { onStderr: splitters.onStderr } : {}
     });
@@ -4769,22 +5976,20 @@ async function reconnectStep(sandbox, resume, opts) {
     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;
-        }
+      try {
+        const result = await pollDurableResult(sandbox, runnerPid, resultToken, {
+          ...signal ? { signal } : {},
+          ...pollDeadlineMs !== undefined ? { deadlineMs: pollDeadlineMs } : {}
+        });
+        splitters.flush();
+        return result;
+      } finally {
+        await attached?.kill().catch(() => {});
       }
-      splitters.flush();
-      return classifyRunnerOutcome(sandbox, output, resultToken);
     }
   };
 }
@@ -4895,7 +6100,7 @@ async function serveStep(handler) {
   process.exit(exitCode);
 }
 // src/agent/run-agent.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/agent/agent-context.ts
@@ -4949,29 +6154,36 @@ Names like \`note.created\` / \`brief.posted\` surface in the Workbench;
 
 ## Writing workflow / agent code — the SDK
 
-\`@agent-compose/sdk\` is installed in \`/workspace\` — import it from any script
-you write there:
-
-    import { defineWorkflow, agent, AgentComposeClient } from "@agent-compose/sdk";
+\`@agent-compose/sdk\` is installed in \`/workspace\`. **To author a workflow,
+ALWAYS run \`/ac:generate-workflow\`** (and \`/ac:generate-agent\` for an agent
+step) instead of writing source from memory — the skill scaffolds the correct,
+current shape. Then \`agentc register <file.ts>\` (or \`/ac:register\`).
 
-Use \`/ac:generate-workflow\` / \`/ac:generate-agent\` to scaffold, then
-\`agentc register <file.ts>\` (or \`/ac:register\`).
+The skill writes **step-form** (a builder of discrete, durable \`.step()\`s).
+The legacy run-form (\`defineWorkflow({ run(ctx, sandbox) { … } })\`) has been
+REMOVED from the SDK — registering one fails with an error. Step-form is the
+only shape: durable per-step replay, and pause only works there.
 
-## Pausing to ask the human — \`agentc pause\`
+## Pausing to ask the human
 
-When you can't or shouldn't proceed without a human, run \`agentc pause\`, then
-**END YOUR TURN**:
+To ask a human and get an answer back, use the **\`AskUserQuestion\`** tool if
+you have it; otherwise run **\`agentc pause\`**:
 
     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.
+**Both BLOCK and hand you the answer inline.** While you wait, the run is
+suspended — your sandbox is frozen and compute stops, so a pause is free while
+the human decides. When they answer, the call RETURNS with their decision: the
+\`AskUserQuestion\` tool result, or \`agentc pause\`'s output
+(\`▶ Resumed. The human answered: …\`), carries it.
+
+**Then USE that answer to finish your work — do NOT end your turn.** This is NOT
+fire-and-forget, and the answer does NOT arrive in a later message: it comes
+back right where you called it, on the SAME turn. The shape is: ask → the call
+blocks → it returns the human's answer → you act on it and produce your result.
+Never end your turn before the call returns, never guess an answer, and never
+proceed without one.
 
 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
@@ -4996,13 +6208,174 @@ request **without** an Authorization header and the platform adds it. Don't try
 to read or exfiltrate tokens; they aren't here. The "Connectors & access"
 section below (when present) lists exactly which providers this run can reach.
 
+## Computer Use — you have a real desktop, and it is already running
+
+**This machine has a graphical desktop.** Every session machine does — terminal
+sessions included — and the platform brings it UP AT BOOT, before your first
+turn: an X server on \`DISPLAY=:0\`, the openbox window manager, wallpaper and a
+panel. You do not start it, you do not wait for a human to open it, and you do
+not need a viewer. Go straight to driving it.
+
+(The one exception, and it is rare: an image built without the GUI stack has no
+display at all, and \`DISPLAY=:0 xdotool getdisplaygeometry\` errors outright.
+That single case is the only one where this section does not apply — a
+screenshot showing only wallpaper is NOT it, and neither is an app that failed
+to start.)
+
+**This is how you SEE anything.** Any question of the form "does it render?",
+"is the page actually working?", "did the markers show up?", "what does it look
+like?" is answered by opening it on this desktop and screenshotting it — not by
+reasoning about the code, and not by a headless render (which proves the process
+starts, not that the thing draws). Verify visually before you report visually.
+
+- **Input** — \`xdotool\` against \`DISPLAY=:0\`: \`DISPLAY=:0 xdotool mousemove <x> <y>\`,
+  \`DISPLAY=:0 xdotool click 1\` (1=left, 3=right), \`DISPLAY=:0 xdotool type 'text'\`,
+  \`DISPLAY=:0 xdotool key Return\` (also \`ctrl+c\`, \`Tab\`, \`super\`, …).
+- **Screenshots** — \`scrot\` (or ImageMagick's \`import\`):
+  \`DISPLAY=:0 scrot /tmp/screen.png\`, then READ the PNG to see the screen,
+  before and after you act. A screenshot is your only eyes here.
+- **Apps + windows** — a plain X session. Launch in the background:
+  \`DISPLAY=:0 <app> &\`. Two things that trip agents up, both normal:
+  - a GUI app needs a **beat to map its window** — screenshot, and if you see
+    only wallpaper, wait a couple of seconds and screenshot again before
+    concluding anything;
+  - **Chromium needs \`--no-sandbox\`** in this environment (nested sandbox).
+    The whole recipe for looking at a local page:
+    \`DISPLAY=:0 chromium --no-sandbox --disable-gpu --start-maximized <url> &\`
+    then \`sleep 5\`, then \`DISPLAY=:0 scrot /tmp/screen.png\` and read it.
+  If a window still never appears, read the app's own log (\`/tmp/*.log\`) — the
+  desktop is not the thing that failed. Do NOT abandon it for a headless
+  screenshot: headless cannot tell you what the human will see.
+- **A human can watch** — the session header carries a **Desktop** button in the
+  dashboard, and what a teammate sees there is exactly this display. The desktop
+  runs whether or not anyone is looking; never wait for a viewer.
+
+Nothing here changes the credentials rule above: tokens are injected at the
+network layer, never present on the desktop or in any file you can read — so
+there is nothing to type, paste, or screenshot a credential from.
+
+## Recording a demo — the desktop, captured to a video the human can play
+
+"Record a demo of you using X" is a normal ask, and this machine does it:
+start a screen recording, drive the app with \`xdotool\` exactly as in Computer
+Use, stop the recording, and report the file. (For a LIVE view no recording is
+needed — the session header's **Desktop** button already streams this display
+to any teammate watching; a recording is the durable, replayable artifact.
+Both modes exist; say so when it matters.)
+
+**ffmpeg is NOT pre-installed** — install it first, once per machine:
+
+    sudo apt-get update -q && sudo apt-get install -y -q ffmpeg
+
+(drop \`sudo\` if you are already root). Then the whole recipe:
+
+    DISPLAY=:0 ffmpeg -f x11grab \\
+      -video_size "$(DISPLAY=:0 xdotool getdisplaygeometry | tr ' ' x)" \\
+      -framerate 10 -i :0 -c:v libvpx -b:v 1M -deadline realtime -cpu-used 8 \\
+      demo.webm &
+    FFMPEG_PID=$!
+    # ... drive the app with xdotool, screenshotting as you go ...
+    kill -INT "$FFMPEG_PID" && wait "$FFMPEG_PID"
+
+The gotchas, each one earned:
+- **Stop with SIGINT (\`kill -INT\`), never SIGKILL** — ffmpeg finalizes the
+  file on SIGINT; a hard kill truncates the encode mid-write.
+- **Record WebM (matroska-family), not MP4** — mp4 writes its moov atom at the
+  END, so a killed or crashed encode leaves an UNPLAYABLE file; webm stays
+  playable up to the last written frame and plays natively in the browser.
+  MP4's only edge is compatibility with some external players — transcode
+  afterwards if you truly need it, never record straight to it.
+- **\`-video_size\` must match the real screen** — x11grab does not default to
+  it; read the geometry from \`xdotool getdisplaygeometry\` as above.
+- **10–12 fps is right for a screen demo** — small files, legible UI motion;
+  this is not video production.
+- **Write to the drive, not /tmp** — the recording must land in your working
+  directory to persist and show up in Files; a file in /tmp dies with the
+  sandbox.
+- When you stop, **TELL the human the exact drive path** of the video — a
+  recording they cannot find might as well not exist.
+
+## Previews — register every server you serve (cloud sessions)
+
+In a cloud session, a dev server listening on a port becomes a hosted,
+member-gated URL the human can open — but ONLY if you register it:
+
+    agentc preview open <port> [--name <label>] [--path </landing>]
+                                                 # hosted URL + an "Open preview" card
+    agentc preview list                          # the registry — what is live right now
+    agentc preview close <port>                  # take one down
+
+(\`agentc preview announce\` is the same verb as \`open\` — announce what you
+serve.) \`--name\` is the human-readable label; \`--path\` is where the app
+should open (e.g. \`/dashboard\`) — the card and every chip land the human
+there instead of a bare \`/\`.
+
+Register EVERY server you start for a human, the moment it is listening, and
+tell them the URL the command printed. The registry is the only discoverable
+record of what this machine serves: an unregistered server keeps running, but
+nobody — not the human, not the assistant — can find its URL, and when the
+sandbox recycles it is gone without a trace. Never guess or hand out a raw
+port; the hosted URL from \`agentc preview open\` is the only address that
+works outside this machine. (Outside a cloud session the command errors
+honestly — there is no session sandbox to expose.)
+
+What registration buys you: the human sees each registered preview as a card
+in the conversation and a row in the session's Previews menu — MANY at once,
+one per port — and the assistant resolves "open the preview" from this same
+registry (its \`list_previews\` read), so what you register is exactly what
+gets opened. On deployments with subdomain previews the hosted URL is a real
+origin of its own — absolute asset paths and client-side routing work, the
+whole app is navigable — so serve normally and let the platform address it;
+never rewrite your app to a path prefix.
+
 ## Tools in this environment
 
 - \`agentc\` — Agent Compose CLI (your primary interface; authed from env)
 - \`@agent-compose/sdk\` — installed in /workspace for writing workflows
 - \`/ac:*\` Claude Code skills — slash commands for the above
 - \`archil\` (factory drive), \`rtk\`, \`bun\`
+- \`xdotool\` / \`scrot\` — drive + screenshot the desktop (if this machine has one; see Computer Use)
 - A world-writable \`/workspace\` working directory`;
+function buildAddedSessionBrief(p) {
+  const dashboardSection = p.dashboardUrl === null ? "" : `
+
+## Dashboard
+
+Teammates follow this conversation (and the rest of the factory) in the
+Agent Compose dashboard: ${p.dashboardUrl}`;
+  return `# Connected to Agent Compose
+
+Agent Compose is your team's agent platform: durable conversations,
+workflow runs, and shared factory drives where humans and agents work
+together. THIS terminal's claude-code session is connected to Agent
+Compose conversation \`${p.conversationId}\` on ${p.serverUrl}.
+
+That conversation is a LIVE, READ-ONLY MIRROR of this terminal session:
+teammates read along in the dashboard as the work happens, but they cannot
+message you through it — anything posted there is answered by the server
+with a notice and never reaches this terminal. Everything you do here is
+mirrored automatically; you have an audience, not a channel.
+
+## The \`agentc\` toolbelt
+
+The \`agentc\` CLI works from this shell. It is already authenticated on
+this machine via the bridge credential fallback — no keys to manage,
+commands just work:
+
+    agentc list                          # registered workflows
+    agentc logs <run-id>                 # a run's logs
+    agentc invoke <workflow> -i '<json>' # dispatch a workflow
+    agentc events list                   # read the factory timeline
+
+## Scope — this is your LOCAL machine
+
+The files here are YOURS: no factory drive is mounted in this session,
+and nothing you write locally lands on a shared drive by itself. Cloud
+drive/branch semantics (per-run directories on the factory drive, drive
+branches, persist-by-default outputs) apply only to cloud sessions —
+not here.${dashboardSection}
+`;
+}
 function renderConnectorsSection(connectors) {
   if (connectors.length === 0)
     return "";
@@ -5108,29 +6481,29 @@ function stripFrontmatter(content) {
   return end === -1 ? content : content.slice(end + 4).trimStart();
 }
 function zodTypeName(schema) {
-  if (schema instanceof z12.ZodString)
+  if (schema instanceof z13.ZodString)
     return "string";
-  if (schema instanceof z12.ZodNumber)
+  if (schema instanceof z13.ZodNumber)
     return "number";
-  if (schema instanceof z12.ZodBoolean)
+  if (schema instanceof z13.ZodBoolean)
     return "boolean";
-  if (schema instanceof z12.ZodArray)
+  if (schema instanceof z13.ZodArray)
     return `${zodTypeName(schema.element)}[]`;
-  if (schema instanceof z12.ZodEnum)
+  if (schema instanceof z13.ZodEnum)
     return schema.options.map((o) => `"${o}"`).join(" | ");
-  if (schema instanceof z12.ZodOptional)
+  if (schema instanceof z13.ZodOptional)
     return `${zodTypeName(schema.unwrap())} (optional)`;
-  if (schema instanceof z12.ZodNullable)
+  if (schema instanceof z13.ZodNullable)
     return `${zodTypeName(schema.unwrap())} | null`;
-  if (schema instanceof z12.ZodLiteral)
+  if (schema instanceof z13.ZodLiteral)
     return `"${String(schema.value)}"`;
-  if (schema instanceof z12.ZodObject)
+  if (schema instanceof z13.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 z12.ZodObject ? schema.shape : null;
+  const shape = schema instanceof z13.ZodObject ? schema.shape : null;
   const body = shape ? (() => {
     const entries = Object.entries(shape);
     const example = Object.fromEntries(entries.map(([k, v]) => [k, `<${zodTypeName(v)}>`]));
@@ -5220,6 +6593,7 @@ async function agent(opts) {
     });
   } : undefined;
   const mode = opts.mode ?? "auto";
+  const processors = [createAskHumanProcessor(), ...opts.processors ?? []];
   try {
     return await agentLoop({
       runtime: (runtimeOpts) => opts.runtime.create(opts.sandbox, { ...runtimeOpts, agentManual: buildAgentContextDoc(process.env) }),
@@ -5248,7 +6622,7 @@ async function agent(opts) {
       } } : {},
       ...opts.onAgentEvent ? { onAgentEvent: opts.onAgentEvent } : {},
       ...opts.onIteration ? { onIteration: opts.onIteration } : {},
-      ...opts.processors?.length ? { processors: opts.processors } : {},
+      ...processors.length ? { processors } : {},
       requestContext: opts.requestContext ?? RequestContext.fromReserved({
         teamId: "",
         runId: "",
@@ -5267,6 +6641,692 @@ async function agent(opts) {
     inboxAbort.abort();
   }
 }
+// src/display.ts
+var DISPLAY_MARKER_KEY = "acDisplay";
+var DISPLAY_MARKER_VERSION = "v1";
+var PLAN_MAX_ENTRIES = 64;
+var PLAN_ENTRY_MAX_CHARS = 1000;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var PLAN_STATUSES = new Set(["pending", "in_progress", "completed"]);
+function clampPlanEntries(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  const entries = [];
+  for (const e of raw) {
+    if (typeof e !== "object" || e === null)
+      continue;
+    const { content, status } = e;
+    if (typeof content !== "string" || content.trim().length === 0)
+      continue;
+    if (typeof status !== "string" || !PLAN_STATUSES.has(status))
+      continue;
+    entries.push({ content: content.slice(0, PLAN_ENTRY_MAX_CHARS), status });
+    if (entries.length >= PLAN_MAX_ENTRIES)
+      break;
+  }
+  return entries;
+}
+var TABLE_MAX_COLUMNS = 12;
+var TABLE_MAX_ROWS = 100;
+var TABLE_CELL_MAX_CHARS = 200;
+var IMAGE_PATH_MAX_CHARS = 512;
+function clampCellString(s) {
+  return s.length > TABLE_CELL_MAX_CHARS ? `${s.slice(0, TABLE_CELL_MAX_CHARS - 1)}…` : s;
+}
+function clampCell(value) {
+  if (typeof value === "string")
+    return clampCellString(value);
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : null;
+  if (typeof value === "boolean")
+    return value;
+  return null;
+}
+function clampTableData(raw) {
+  let rawColumns;
+  let rawRows;
+  if (Array.isArray(raw)) {
+    rawRows = raw;
+  } else if (typeof raw === "object" && raw !== null) {
+    rawColumns = raw.columns;
+    rawRows = raw.rows;
+  } else {
+    return null;
+  }
+  if (!Array.isArray(rawRows))
+    return null;
+  let truncated = false;
+  const columns = [];
+  const seenKeys = new Set;
+  const pushColumn = (key, label) => {
+    if (seenKeys.has(key))
+      return;
+    seenKeys.add(key);
+    if (columns.length >= TABLE_MAX_COLUMNS) {
+      truncated = true;
+      return;
+    }
+    columns.push({ sourceKey: key, key: clampCellString(key), label: clampCellString(label) });
+  };
+  if (rawColumns !== undefined) {
+    if (!Array.isArray(rawColumns))
+      return null;
+    for (const c of rawColumns) {
+      if (typeof c !== "object" || c === null)
+        continue;
+      const { key, label } = c;
+      if (typeof key !== "string" || key.length === 0)
+        continue;
+      pushColumn(key, typeof label === "string" && label.length > 0 ? label : key);
+    }
+  } else {
+    for (const row of rawRows) {
+      if (typeof row !== "object" || row === null || Array.isArray(row))
+        continue;
+      for (const key of Object.keys(row))
+        pushColumn(key, key);
+    }
+  }
+  if (columns.length === 0)
+    return null;
+  const rows = [];
+  for (const rawRow of rawRows) {
+    if (typeof rawRow !== "object" || rawRow === null || Array.isArray(rawRow))
+      continue;
+    if (rows.length >= TABLE_MAX_ROWS) {
+      truncated = true;
+      break;
+    }
+    const row = {};
+    for (const c of columns)
+      row[c.key] = clampCell(rawRow[c.sourceKey]);
+    rows.push(row);
+  }
+  if (rows.length === 0)
+    return null;
+  return { columns: columns.map(({ key, label }) => ({ key, label })), rows, truncated };
+}
+var CHART_MAX_SERIES = 4;
+var CHART_MAX_POINTS_PER_SERIES = 60;
+var CHART_LABEL_MAX_CHARS = 40;
+function clampChartSeries(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  const series = [];
+  for (const s of raw) {
+    if (series.length >= CHART_MAX_SERIES)
+      break;
+    if (typeof s !== "object" || s === null)
+      continue;
+    const { label, points } = s;
+    if (typeof label !== "string" || label.trim().length === 0)
+      continue;
+    if (!Array.isArray(points))
+      continue;
+    const clamped = [];
+    for (const p of points) {
+      if (clamped.length >= CHART_MAX_POINTS_PER_SERIES)
+        break;
+      if (typeof p !== "object" || p === null)
+        continue;
+      const { x, y } = p;
+      if (typeof y !== "number" || !Number.isFinite(y))
+        continue;
+      if (typeof x === "number" && Number.isFinite(x))
+        clamped.push({ x, y });
+      else if (typeof x === "string" && x.length > 0)
+        clamped.push({ x: x.slice(0, CHART_LABEL_MAX_CHARS), y });
+    }
+    if (clamped.length === 0)
+      continue;
+    series.push({ label: label.slice(0, CHART_LABEL_MAX_CHARS), points: clamped });
+  }
+  return series;
+}
+function clampChartAxisLabel(raw) {
+  return typeof raw === "string" && raw.trim().length > 0 ? raw.slice(0, CHART_LABEL_MAX_CHARS) : undefined;
+}
+var ASK_PROMPT_MAX_CHARS = 1000;
+var ASK_MAX_OPTIONS = 8;
+var ASK_OPTION_ID_MAX_CHARS = 100;
+var ASK_OPTION_LABEL_MAX_CHARS = 200;
+function clampAskOptions(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  const options = [];
+  const seen = new Set;
+  for (const o of raw) {
+    if (options.length >= ASK_MAX_OPTIONS)
+      break;
+    let id = null;
+    let label = null;
+    if (typeof o === "string" && o.trim().length > 0) {
+      id = o;
+      label = o;
+    } else if (typeof o === "object" && o !== null) {
+      const cand = o;
+      if (typeof cand.id === "string" && cand.id.length > 0 && typeof cand.label === "string" && cand.label.length > 0) {
+        id = cand.id;
+        label = cand.label;
+      }
+    }
+    if (id === null || label === null)
+      continue;
+    const clampedId = id.slice(0, ASK_OPTION_ID_MAX_CHARS);
+    if (seen.has(clampedId))
+      continue;
+    seen.add(clampedId);
+    options.push({ id: clampedId, label: label.slice(0, ASK_OPTION_LABEL_MAX_CHARS) });
+  }
+  return options;
+}
+function serializeDisplayMarker(marker) {
+  return JSON.stringify({ [DISPLAY_MARKER_KEY]: DISPLAY_MARKER_VERSION, ...marker });
+}
+function parseDisplayMarker(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("{") || !trimmed.includes(DISPLAY_MARKER_KEY))
+    return null;
+  let obj;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return null;
+    obj = parsed;
+  } catch {
+    return null;
+  }
+  if (obj[DISPLAY_MARKER_KEY] !== DISPLAY_MARKER_VERSION)
+    return null;
+  const str = (key) => {
+    const v = obj[key];
+    return typeof v === "string" && v.length > 0 ? v : undefined;
+  };
+  switch (obj.kind) {
+    case "run": {
+      const runId = str("runId");
+      return runId && UUID_RE.test(runId) ? { kind: "run", runId } : null;
+    }
+    case "changes": {
+      const runId = str("runId");
+      if (!runId || !UUID_RE.test(runId))
+        return null;
+      return {
+        kind: "changes",
+        runId,
+        ...str("factorySlug") ? { factorySlug: str("factorySlug") } : {},
+        endedAt: str("endedAt") ?? null
+      };
+    }
+    case "document": {
+      const path = str("path");
+      if (!path)
+        return null;
+      return {
+        kind: "document",
+        path,
+        ...str("factorySlug") ? { factorySlug: str("factorySlug") } : {},
+        preview: str("preview") ?? null
+      };
+    }
+    case "plan": {
+      const entries = clampPlanEntries(obj.entries);
+      return entries.length > 0 ? { kind: "plan", entries } : null;
+    }
+    case "image": {
+      const path = str("path");
+      if (!path || path.length > IMAGE_PATH_MAX_CHARS)
+        return null;
+      return {
+        kind: "image",
+        path,
+        ...str("factorySlug") ? { factorySlug: str("factorySlug") } : {}
+      };
+    }
+    case "table": {
+      const data = clampTableData({ columns: obj.columns, rows: obj.rows });
+      if (!data)
+        return null;
+      return { kind: "table", ...data, truncated: data.truncated || obj.truncated === true };
+    }
+    case "chart": {
+      if (obj.chartKind !== "bar" && obj.chartKind !== "line")
+        return null;
+      const series = clampChartSeries(obj.series);
+      if (series.length === 0)
+        return null;
+      const xLabel = clampChartAxisLabel(obj.xLabel);
+      const yLabel = clampChartAxisLabel(obj.yLabel);
+      return {
+        kind: "chart",
+        chartKind: obj.chartKind,
+        series,
+        ...xLabel !== undefined ? { xLabel } : {},
+        ...yLabel !== undefined ? { yLabel } : {}
+      };
+    }
+    case "ask": {
+      const askId = str("askId");
+      const rawPrompt = str("prompt");
+      if (!askId || !UUID_RE.test(askId) || !rawPrompt)
+        return null;
+      const options = clampAskOptions(obj.options);
+      return {
+        kind: "ask",
+        askId,
+        prompt: rawPrompt.slice(0, ASK_PROMPT_MAX_CHARS),
+        ...options.length > 0 ? { options } : {},
+        freeText: true
+      };
+    }
+    default:
+      return null;
+  }
+}
+function findDisplayMarker(text) {
+  for (const line of text.split(`
+`)) {
+    const marker = parseDisplayMarker(line);
+    if (marker)
+      return marker;
+  }
+  return null;
+}
+var SHELL_STOPPERS = new Set(["|", "||", "&&", ";", ">", ">>", "<", "2>", "2>>", "&"]);
+function shellWords(command) {
+  const words = [];
+  let current = "";
+  let started = false;
+  let quote2 = null;
+  for (let i = 0;i < command.length; i += 1) {
+    const ch = command[i];
+    if (quote2) {
+      if (ch === quote2)
+        quote2 = null;
+      else
+        current += ch;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote2 = ch;
+      started = true;
+      continue;
+    }
+    if (ch === " " || ch === "\t" || ch === `
+`) {
+      if (started) {
+        words.push(current);
+        current = "";
+        started = false;
+      }
+      continue;
+    }
+    current += ch;
+    started = true;
+  }
+  if (started)
+    words.push(current);
+  return words;
+}
+var VALUE_FLAGS = new Set([
+  "--factory",
+  "--input",
+  "--entries",
+  "--url",
+  "--api-key",
+  "--limit",
+  "--thread",
+  "--content-type",
+  "--file",
+  "--out",
+  "--revision",
+  "--ended-at",
+  "--data",
+  "--kind",
+  "--from",
+  "--to",
+  "--prompt",
+  "--options",
+  "--approver"
+]);
+function isShellControlWord(w) {
+  if (/^\d*>&\d+$/.test(w))
+    return false;
+  return SHELL_STOPPERS.has(w) || /^\d*>>?(&\d+)?$/.test(w) || w === "<" || w.startsWith("$(") || w.startsWith("`");
+}
+function detectAgentcInvocation(command) {
+  const words = shellWords(command);
+  const start = words.findIndex((w) => w === "agentc" || w.endsWith("/agentc"));
+  if (start < 0)
+    return null;
+  if (words.some(isShellControlWord))
+    return null;
+  for (let i = 0;i < start; i += 1) {
+    const w = words[i];
+    const isEnvAssign = /^[A-Za-z_][A-Za-z0-9_]*=/.test(w);
+    const isShellInvoker = /^(?:[\w./-]*\/)?(?:sh|bash|zsh|dash)$/.test(w);
+    if (!isEnvAssign && !isShellInvoker && !w.startsWith("-"))
+      return null;
+  }
+  const args = [];
+  const flags = new Map;
+  for (let i = start + 1;i < words.length; i += 1) {
+    const w = words[i];
+    if (SHELL_STOPPERS.has(w))
+      break;
+    if (w.startsWith("--")) {
+      if (VALUE_FLAGS.has(w) && i + 1 < words.length && !SHELL_STOPPERS.has(words[i + 1])) {
+        flags.set(w, words[i + 1]);
+        i += 1;
+      }
+      continue;
+    }
+    args.push(w);
+  }
+  const factorySlug = flags.get("--factory");
+  const withSlug = factorySlug ? { factorySlug } : {};
+  const uuid = (v) => v && UUID_RE.test(v) ? v : null;
+  if (args[0] === "display") {
+    switch (args[1]) {
+      case "run": {
+        const runId = uuid(args[2]);
+        return runId ? { verb: "display-run", runId } : null;
+      }
+      case "changes": {
+        const runId = uuid(args[2]);
+        return runId ? { verb: "display-changes", runId, ...withSlug } : null;
+      }
+      case "document":
+        return args[2] ? { verb: "display-document", path: args[2], ...withSlug } : null;
+      case "plan":
+        return { verb: "display-plan" };
+      case "image":
+        return args[2] ? { verb: "display-image", path: args[2], ...withSlug } : null;
+      case "preview":
+        return args[2] ? { verb: "display-preview", path: args[2] } : null;
+      case "table": {
+        const file = flags.get("--file");
+        const hasData = flags.has("--data");
+        if (file && !hasData)
+          return { verb: "display-table", source: "file", path: file };
+        if (hasData && !file)
+          return { verb: "display-table", source: "inline" };
+        return null;
+      }
+      case "chart": {
+        const chartKind = flags.get("--kind");
+        return chartKind === "bar" || chartKind === "line" ? { verb: "display-chart", chartKind } : null;
+      }
+      case "diff": {
+        const from = flags.get("--from");
+        const to = flags.get("--to");
+        if (!args[2] || !from || !to)
+          return null;
+        if (!REVISION_SELECTOR_RE.test(from) || !REVISION_SELECTOR_RE.test(to))
+          return null;
+        return { verb: "display-diff", path: args[2], from, to };
+      }
+      case "ask": {
+        const prompt = flags.get("--prompt");
+        if (!prompt || prompt.trim().length === 0)
+          return null;
+        const approver = flags.get("--approver");
+        return {
+          verb: "display-ask",
+          prompt: prompt.slice(0, ASK_PROMPT_MAX_CHARS),
+          ...approver ? { approver } : {}
+        };
+      }
+      default:
+        return null;
+    }
+  }
+  if (args[0] === "run" && args[1] === "dispatch" && args[2]) {
+    let input;
+    const rawInput = flags.get("--input");
+    if (rawInput !== undefined) {
+      try {
+        input = JSON.parse(rawInput);
+      } catch {}
+    }
+    return { verb: "run-dispatch", templateName: args[2], ...input !== undefined ? { input } : {} };
+  }
+  if (args[0] === "run" && args[1] === "get") {
+    const runId = uuid(args[2]);
+    return runId ? { verb: "run-get", runId } : null;
+  }
+  if (args[0] === "files" && args[1] === "read" && args[2]) {
+    return { verb: "files-read", path: args[2], ...withSlug };
+  }
+  return null;
+}
+var DOCUMENT_PREVIEW_CHARS = 240;
+var DOCUMENT_CONTENT_CHARS = 4000;
+function commandOf(toolInput) {
+  if (typeof toolInput !== "object" || toolInput === null)
+    return null;
+  const cmd = toolInput.command;
+  if (typeof cmd === "string")
+    return cmd;
+  if (Array.isArray(cmd) && cmd.every((c) => typeof c === "string"))
+    return cmd.join(" ");
+  return null;
+}
+function textOf(output) {
+  if (typeof output === "string")
+    return output;
+  if (typeof output !== "object" || output === null)
+    return null;
+  const o = output;
+  if (typeof o.output === "string")
+    return o.output;
+  if (typeof o.text === "string")
+    return o.text;
+  if (typeof o.content === "string")
+    return o.content;
+  return null;
+}
+function runIdIn(text) {
+  for (const line of [...text.split(`
+`)].reverse()) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === "object" && parsed !== null) {
+          const runId = parsed.runId;
+          if (typeof runId === "string" && UUID_RE.test(runId)) {
+            return { runId, parsed };
+          }
+        }
+      } catch {}
+    }
+  }
+  const m = /run ([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i.exec(text);
+  return m ? { runId: m[1], parsed: null } : null;
+}
+function createDisplayPromoter(ctx = {}) {
+  const pending = new Map;
+  const factoryRef = (slug) => {
+    if (slug)
+      return { factorySlug: slug };
+    if (ctx.factoryId)
+      return { factoryId: ctx.factoryId };
+    return {};
+  };
+  return {
+    promoteToolUse(msg) {
+      if (msg.toolName === "TodoWrite") {
+        const todos = msg.toolInput?.todos;
+        const entries = clampPlanEntries(todos);
+        if (entries.length === 0)
+          return null;
+        return [
+          { type: "tool_call", toolName: msg.toolName, input: msg.toolInput, toolCallId: msg.toolUseId },
+          { type: "plan", entries }
+        ];
+      }
+      const command = commandOf(msg.toolInput);
+      if (!command || !command.includes("agentc"))
+        return null;
+      const invocation = detectAgentcInvocation(command);
+      if (!invocation)
+        return null;
+      pending.set(msg.toolUseId, { invocation });
+      const call = (toolName, input) => [
+        { type: "tool_call", toolName, input: { ...input, command }, toolCallId: msg.toolUseId }
+      ];
+      switch (invocation.verb) {
+        case "display-run":
+        case "run-get":
+          return call("display_run", { runId: invocation.runId });
+        case "display-changes":
+          return call("display_changes", { runId: invocation.runId, ...factoryRef(invocation.factorySlug) });
+        case "display-document":
+        case "files-read":
+          return call("display_document", { path: invocation.path, ...factoryRef(invocation.factorySlug) });
+        case "display-plan":
+          return call("display_plan", {});
+        case "display-image":
+          return call("display_image", { path: invocation.path, ...factoryRef(invocation.factorySlug) });
+        case "display-preview":
+          return call("display_preview", { path: invocation.path, ...factoryRef(undefined) });
+        case "display-table":
+          return call("display_table", {
+            source: invocation.source,
+            ...invocation.path !== undefined ? { path: invocation.path } : {},
+            ...invocation.source === "file" ? factoryRef(undefined) : {}
+          });
+        case "display-chart":
+          return call("display_chart", { chartKind: invocation.chartKind });
+        case "display-diff":
+          return call("display_diff", {
+            path: invocation.path,
+            from: invocation.from,
+            to: invocation.to,
+            ...factoryRef(undefined)
+          });
+        case "display-ask":
+          return call("display_ask", { prompt: invocation.prompt });
+        case "run-dispatch":
+          return call("dispatch_workflow", {
+            templateName: invocation.templateName,
+            ...invocation.input !== undefined ? { input: invocation.input } : {}
+          });
+      }
+    },
+    promoteToolResult(msg) {
+      const entry = pending.get(msg.toolUseId);
+      if (!entry)
+        return null;
+      pending.delete(msg.toolUseId);
+      const isError = msg.isError === true;
+      const result = (output) => ({
+        type: "tool_result",
+        toolCallId: msg.toolUseId,
+        output,
+        isError
+      });
+      const text = textOf(msg.output);
+      if (isError || text === null)
+        return [result(msg.output)];
+      const inv = entry.invocation;
+      switch (inv.verb) {
+        case "display-run": {
+          const marker = findDisplayMarker(text);
+          return [result(marker?.kind === "run" ? { runId: marker.runId } : { runId: inv.runId })];
+        }
+        case "run-get": {
+          const found = runIdIn(text);
+          return [result(found?.parsed ?? { runId: found?.runId ?? inv.runId })];
+        }
+        case "display-changes": {
+          const marker = findDisplayMarker(text);
+          const m = marker?.kind === "changes" ? marker : null;
+          return [result({
+            runId: m?.runId ?? inv.runId,
+            ...factoryRef(m?.factorySlug ?? inv.factorySlug),
+            endedAt: m?.endedAt ?? null
+          })];
+        }
+        case "display-document": {
+          const marker = findDisplayMarker(text);
+          const m = marker?.kind === "document" ? marker : null;
+          return [result({
+            path: m?.path ?? inv.path,
+            ...factoryRef(m?.factorySlug ?? inv.factorySlug),
+            preview: m?.preview ?? null
+          })];
+        }
+        case "files-read":
+          return [result({
+            path: inv.path,
+            ...factoryRef(inv.factorySlug),
+            preview: text.slice(0, DOCUMENT_PREVIEW_CHARS) || null,
+            content: text.slice(0, DOCUMENT_CONTENT_CHARS)
+          })];
+        case "display-plan": {
+          const marker = findDisplayMarker(text);
+          if (marker?.kind !== "plan")
+            return [result(msg.output)];
+          return [
+            result({ entries: marker.entries.length }),
+            { type: "plan", entries: marker.entries }
+          ];
+        }
+        case "display-image": {
+          const marker = findDisplayMarker(text);
+          const m = marker?.kind === "image" ? marker : null;
+          return [result({
+            path: m?.path ?? inv.path,
+            ...factoryRef(m?.factorySlug ?? inv.factorySlug)
+          })];
+        }
+        case "display-table": {
+          if (inv.source === "file")
+            return [result(msg.output)];
+          const marker = findDisplayMarker(text);
+          if (marker?.kind !== "table")
+            return [result(msg.output)];
+          return [result({ columns: marker.columns, rows: marker.rows, truncated: marker.truncated })];
+        }
+        case "display-chart": {
+          const marker = findDisplayMarker(text);
+          if (marker?.kind !== "chart")
+            return [result(msg.output)];
+          return [result({
+            chartKind: marker.chartKind,
+            series: marker.series,
+            ...marker.xLabel !== undefined ? { xLabel: marker.xLabel } : {},
+            ...marker.yLabel !== undefined ? { yLabel: marker.yLabel } : {}
+          })];
+        }
+        case "display-ask": {
+          if (inv.approver !== undefined)
+            return [result(msg.output)];
+          const marker = findDisplayMarker(text);
+          if (marker?.kind !== "ask")
+            return [result(msg.output)];
+          return [result({
+            askId: marker.askId,
+            prompt: marker.prompt,
+            ...marker.options !== undefined ? { options: marker.options } : {},
+            freeText: marker.freeText
+          })];
+        }
+        case "display-preview":
+        case "display-diff":
+          return [result(msg.output)];
+        case "run-dispatch": {
+          const found = runIdIn(text);
+          if (!found)
+            return [result(msg.output)];
+          return [result(found.parsed ?? { runId: found.runId })];
+        }
+      }
+    }
+  };
+}
 // src/runtimes/openai-desktop.ts
 import OpenAI from "openai";
 import sharp from "sharp";
@@ -5300,9 +7360,10 @@ class OpenAIDesktopRunner {
         { type: "input_text", text: opts.prompt }
       ]
     }];
+    const responses = this.openai.responses;
     let previousResponseId;
     for (let turn = 0;turn < MAX_TURNS; turn++) {
-      const response = await this.openai.responses.create({
+      const response = await responses.create({
         model: "computer-use-preview",
         tools: [{ type: "computer_use_preview", name: "computer", display_width: DISPLAY_WIDTH, display_height: DISPLAY_HEIGHT, environment: "linux" }],
         input: messages,