@zhivex-ai/harness 1.2.0 → 1.3.0-rc.7

package/dist/{cli-entry-b1mfvmxe.js → index-2jrdcj6b.js}

@@ -1,4 +1,58 @@
-// src/cli/cli-options.ts
+import {
+  DEFAULT_PROVIDER_REGISTRY,
+  HARNESS_SUBAGENT_PROFILES
+} from "./index-gq9xagx2.js";
+
+// src/providers/routing.ts
+var routeError = (value) => new Error(`Invalid route: ${value}. Use <profile>=<provider>[:<model>].`);
+var parseHarnessModelRoute = (value, registry = DEFAULT_PROVIDER_REGISTRY) => {
+  const separator = value.indexOf("=");
+  if (separator <= 0 || separator === value.length - 1) {
+    throw routeError(value);
+  }
+  const profile = value.slice(0, separator).trim().toLowerCase();
+  if (!HARNESS_SUBAGENT_PROFILES.includes(profile)) {
+    throw routeError(value);
+  }
+  const target = value.slice(separator + 1).trim();
+  const modelSeparator = target.indexOf(":");
+  const providerInput = (modelSeparator === -1 ? target : target.slice(0, modelSeparator)).trim();
+  const provider = registry.parse(providerInput);
+  const configuredModel = modelSeparator === -1 ? "" : target.slice(modelSeparator + 1).trim();
+  if (modelSeparator !== -1 && !configuredModel) {
+    throw routeError(value);
+  }
+  const model = configuredModel || registry.descriptor(provider).defaultModel;
+  if (/[\u0000-\u001f\u007f]/.test(model) || model.length > 256) {
+    throw routeError(value);
+  }
+  return Object.freeze({
+    profile,
+    provider,
+    model
+  });
+};
+var resolveHarnessModelRoutes = (values = [], registry = DEFAULT_PROVIDER_REGISTRY) => {
+  const routes = new Map;
+  for (const value of values) {
+    const route = parseHarnessModelRoute(value, registry);
+    if (routes.has(route.profile)) {
+      throw new Error(`Duplicate model route for ${route.profile}.`);
+    }
+    routes.set(route.profile, route);
+  }
+  return routes;
+};
+var createHarnessRouteModels = (routes, env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => Object.fromEntries([...routes].map(([profile, route]) => [
+  profile,
+  registry.createModel(route, env)
+]));
+var serializeHarnessModelRoutes = (routes) => Object.fromEntries([...routes].map(([profile, route]) => [
+  profile,
+  { provider: route.provider, model: route.model }
+]));
+
+// src/compat/cli-options.ts
 var repeatableOptions = new Set([
   "--route",
   "--oci-allow-command",
@@ -105,6 +159,7 @@ var CLI_OPTION_NAMES = [
   "--help",
   "--version",
   "--search",
+  "--tool-policy",
   "--pricing-file",
   "--usage-limit-usd"
 ];
@@ -167,6 +222,7 @@ var childBudgets = [
 var agent = [
   "--compaction-model",
   "--compaction-provider",
+  "--tool-policy",
   "--pricing-file",
   "--usage-limit-usd",
   ...provider,
@@ -196,6 +252,7 @@ var CLI_COMMAND_OPTION_CONTRACTS = {
   init: contract([...provider, ...profile, "--update", "--json"]),
   run: contract(["--service", "--session", ...agent, "--idempotency-key", "--approval-mode", "--yes", "--json", "--jsonl"]),
   review: contract([
+    "--tool-policy",
     "--pricing-file",
     "--usage-limit-usd",
     ...provider,
@@ -212,18 +269,30 @@ var CLI_COMMAND_OPTION_CONTRACTS = {
   ]),
   chat: contract(["--service", ...agent, "--approval-mode", "--yes", "--session", "--continue"]),
   providers: contract(["--json"]),
+  policy: contract(["--service", ...agent, "--json"]),
   doctor: contract([...provider, ...profile, ...locator, ...project, ...execution, ...budgets, "--allow-check", "--require-capability", "--subagent", "--json"]),
-  resume: contract(["--service", "--session", ...locator, "--approve", "--deny", "--json", "--jsonl"], [["--approve", "--deny"]]),
+  resume: contract(["--tool-policy", "--service", "--session", ...locator, "--approve", "--deny", "--json", "--jsonl"], [["--approve", "--deny"]]),
   "runs:list": contract([...locator, "--status", "--limit", "--cursor", "--json"]),
   "runs:inspect": contract([...locator, "--json"]),
   "runs:cancel": contract([...locator, "--reason", "--cascade", "--final", "--json"]),
   "runs:cleanup": contract([...locator, "--before", "--status", "--limit", "--json"], ["--before"]),
   "runs:export": contract([...locator, "--json"]),
+  "runs:report": contract([...locator, "--json", "--session"]),
   "sessions:list": contract(["--service", ...locator, "--limit", "--json", "--search"]),
   "sessions:inspect": contract(["--service", ...locator, "--json"]),
   "sessions:rename": contract(["--service", ...locator, "--json"]),
   "sessions:fork": contract([...locator, "--json"]),
   "sessions:archive": contract([...locator, "--json"]),
+  "checkpoints:storage": contract([...locator, "--json"]),
+  "checkpoints:prune-review": contract([...locator, "--json"]),
+  "checkpoints:prune-apply": contract([...locator, "--json"]),
+  "checkpoints:list": contract([...locator, "--json"]),
+  "checkpoints:capture": contract([...locator, "--json"]),
+  "checkpoints:inspect": contract([...locator, "--json"]),
+  "checkpoints:prepare": contract([...locator, "--json"]),
+  "checkpoints:review": contract([...locator, "--json"]),
+  "checkpoints:apply": contract([...locator, "--json"]),
+  "checkpoints:recover": contract([...locator, "--json"]),
   "changes:create": contract(["--patch"], ["--patch"]),
   "changes:verify": contract(["--patch", "--preconditions", "--now"], ["--patch"]),
   "state:status": contract([...locator, "--json"]),
@@ -261,116 +330,4 @@ var validateCliCommandOptions = (commandKey, counts) => {
   }
 };
 
-// src/cli/cli-help.ts
-var usage = {
-  init: "zhx init [--provider <id>] [--model <id>] [--profile <name>] [--update]",
-  run: 'zhx run [options] "task" | zhx run [options] -',
-  review: 'zhx review [options] "review task" | zhx review [options] -',
-  chat: "zhx [--continue | --session <id>]",
-  providers: "zhx providers [--json]",
-  doctor: "zhx doctor [options]",
-  resume: "zhx resume <runId> --approve|--deny",
-  "runs:list": "zhx runs list [options]",
-  "runs:inspect": "zhx runs inspect <runId>",
-  "runs:cancel": "zhx runs cancel <runId> [options]",
-  "runs:cleanup": "zhx runs cleanup --before <date> [options]",
-  "runs:export": "zhx runs export <runId>",
-  "sessions:list": "zhx sessions list [--search <text>]",
-  "sessions:inspect": "zhx sessions inspect <sessionId>",
-  "sessions:rename": 'zhx sessions rename <sessionId> "title"',
-  "sessions:fork": "zhx sessions fork <sessionId>",
-  "sessions:archive": "zhx sessions archive <sessionId>",
-  "changes:create": "zhx changes create <input.json> --patch <artifact>",
-  "changes:verify": "zhx changes verify <envelope.json> --patch <artifact> [options]",
-  "state:status": "zhx state status",
-  "state:export": "zhx state export <backup.json>",
-  "state:import": "zhx state import <backup.json> [--apply]",
-  version: "zhx --version"
-};
-var shortCliHelp = (version) => `Zhivex Harness v${version}
-
-Start in your project:
-  zhx                         Open the conversation (first-use setup if needed)
-  zhx --continue              Reopen the latest conversation
-  zhx run "task"              Run one task for a script or automation
-  zhx doctor                  Check local configuration
-
-Inside the console, type / for common actions or /help for guidance.
-  zhx init                    Configure a provider/model profile explicitly
-  zhx <command> --help        Show help for one command
-  zhx help all                Show every command and advanced option
-  zhx --version               Show the installed version
-
-Requires Node >=22.13. The console guides API key setup; automation uses environment keys.
-zhx chat and zhivex-harness remain supported aliases.`;
-function resolveHelpTopic(parts, explicit) {
-  if (!explicit || !parts.length)
-    return;
-  const topic = parts.join(":");
-  if (topic === "all" || Object.hasOwn(usage, topic) || Object.keys(usage).some((key) => key.startsWith(`${topic}:`)))
-    return topic;
-  throw new Error(`Unknown help topic: ${parts.join(" ")}. Use zhx help all.`);
-}
-function formatCliHelp(topic, version, full) {
-  if (!topic)
-    return shortCliHelp(version);
-  if (topic === "all")
-    return full;
-  const contract2 = CLI_COMMAND_OPTION_CONTRACTS[topic];
-  if (!contract2) {
-    return `Zhivex Harness — ${topic}
-
-` + Object.entries(usage).filter(([key]) => key.startsWith(`${topic}:`)).map(([, command]) => `  ${command}`).join(`
-`) + `
-
-Use zhx ${topic} <subcommand> --help for its options.`;
-  }
-  const descriptions = new Map;
-  for (const line of full.split(`
-`)) {
-    const match = line.match(/^  (--[\w-]+)(?:\s|$)/);
-    if (match)
-      descriptions.set(match[1], line);
-  }
-  const extra = {
-    "--approve": "  --approve                     Approve the pending batch",
-    "--deny": "  --deny                        Deny the pending batch",
-    "--status": "  --status <status>             Filter by run status; repeatable",
-    "--limit": "  --limit <n>                   Maximum number of results",
-    "--search": "  --search <text>               Literal conversation title or ID filter",
-    "--pricing-file": "  --pricing-file <file.json>    Operator-supplied price estimates",
-    "--usage-limit-usd": "  --usage-limit-usd <amount>    Per-run monetary limit; requires pricing",
-    "--version": "  --version                     Show the installed version"
-  };
-  const examples = {
-    run: ['zhx run "Explain this repository"', 'zhx run --profile daily --json "Review the parser"', "git diff | zhx run -"],
-    review: ['zhx review "Review error handling"', "zhx review - < review-task.txt"],
-    init: ["zhx init --profile daily", "zhx init --profile daily --update --model <id>"],
-    doctor: ["zhx doctor --profile daily", "zhx doctor --workspace /path/to/project"]
-  };
-  const groups = new Map;
-  for (const name of contract2.allowed) {
-    const group = name.startsWith("--oci-") || ["--execution", "--require-verified-delivery", "--allow-check", "--yes"].includes(name) ? "Execution and approvals" : /subagent|reviewer|parallel-reviews|^--route$/.test(name) ? "Specialist agents" : /cost|pricing|usage-limit|^--max-|^--timeout/.test(name) ? "Budgets and limits" : ["--state-dir", "--store", "--tenant", "--user", "--namespace", "--idempotency-key"].includes(name) ? "State and scope" : ["--mcp-config", "--context-config", "--no-project-context", "--require-capability"].includes(name) ? "Context and capabilities" : "Common options";
-    const lines = groups.get(group) ?? [];
-    lines.push(descriptions.get(name) ?? extra[name] ?? `  ${name}`);
-    groups.set(group, lines);
-  }
-  const sections = ["Common options", "Execution and approvals", "Budgets and limits", "Specialist agents", "Context and capabilities", "State and scope"].filter((group) => groups.has(group)).map((group) => `${group}:
-${groups.get(group).join(`
-`)}`);
-  return `Zhivex Harness — ${topic.replace(":", " ")}
-
-Usage: ${usage[topic]}
-` + (examples[topic] ? `
-Examples:
-${examples[topic].map((example) => `  ${example}`).join(`
-`)}
-` : "") + `
-${sections.join(`
-
-`)}
-
-Use zhx help all for the full reference and exit codes.`;
-}
-
-export { CLI_OPTION_DEFINITIONS, validateCliCommandOptions, shortCliHelp, resolveHelpTopic, formatCliHelp };
+export { parseHarnessModelRoute, resolveHarnessModelRoutes, createHarnessRouteModels, serializeHarnessModelRoutes, CLI_OPTION_NAMES, CLI_OPTION_DEFINITIONS, CLI_COMMAND_OPTION_CONTRACTS, validateCliCommandOptions };

package/dist/index-3ah1f369.js

@@ -0,0 +1,356 @@
+// src/client/acp-mcp-session.ts
+var providers = new WeakMap;
+function issueAcpMcpSessionProvider(provider) {
+  const token = Object.freeze({});
+  providers.set(token, provider);
+  return token;
+}
+function resolveAcpMcpSessionProvider(token, adapter) {
+  const provider = providers.get(token);
+  if (!provider || provider.adapter !== adapter)
+    throw new Error("ACP MCP requires its host-owned adapter capability.");
+  return provider;
+}
+
+// src/client/acp.ts
+import { randomUUID } from "node:crypto";
+import { isAbsolute, resolve } from "node:path";
+import { z } from "zod";
+var envelope = z.object({ jsonrpc: z.literal("2.0"), id: z.union([z.string(), z.number().int()]).optional(), method: z.string(), params: z.unknown().optional() }).strict();
+var sessionParams = z.object({ sessionId: z.string().min(1) }).strict();
+var permissionResult = z.object({ outcome: z.union([
+  z.object({ outcome: z.literal("cancelled") }).strict(),
+  z.object({ outcome: z.literal("selected"), optionId: z.enum(["allow_once", "reject_once"]) }).strict()
+]) });
+
+class AcpFault extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+var createAcpConnection = (adapter, options) => {
+  if (!isAbsolute(options.workspace))
+    throw new Error("ACP workspace must be absolute");
+  const negotiated = adapter.negotiate([1]);
+  if (!negotiated.ok)
+    throw new Error(negotiated.error.code);
+  const mcp = options.mcpSessionProvider ? resolveAcpMcpSessionProvider(options.mcpSessionProvider, adapter) : undefined;
+  let initialized = false;
+  let creating = false;
+  const sessions = new Set;
+  let active;
+  const command = async (value) => {
+    const response = await adapter.dispatch({
+      protocolVersion: 1,
+      requestId: randomUUID(),
+      connectionId: negotiated.connectionId,
+      command: { ...value, projectId: negotiated.projectId }
+    });
+    if (!response.ok)
+      throw new AcpFault(-32000, response.error.code);
+    return response.data;
+  };
+  const requireSession = (id) => {
+    if (!sessions.has(id))
+      throw new AcpFault(-32602, "Unknown session");
+  };
+  const execute = async (method, params) => {
+    if (method === "initialize") {
+      const input2 = z.object({ protocolVersion: z.literal(1), clientCapabilities: z.record(z.string(), z.unknown()).optional(), clientInfo: z.unknown().optional(), _meta: z.unknown().optional() }).parse(params);
+      initialized = true;
+      return {
+        protocolVersion: 1,
+        agentCapabilities: { loadSession: false, promptCapabilities: { image: false, audio: false, embeddedContext: false }, mcpCapabilities: { http: false, sse: false } },
+        authMethods: [],
+        agentInfo: { name: "zhivex-harness", title: "Zhivex Harness (text-session subset)", version: "1" },
+        _meta: { zhivex: { subset: true, fixedWorkspace: true, clientMcp: !!mcp } }
+      };
+    }
+    if (!initialized)
+      throw new AcpFault(-32002, "Initialize first");
+    if (method === "session/new") {
+      if (sessions.size >= 256)
+        throw new AcpFault(-32000, "Session capacity exceeded");
+      if (active || creating)
+        throw new AcpFault(-32000, "BUSY");
+      const input2 = z.object({ cwd: z.string(), mcpServers: z.array(z.unknown()).max(mcp ? 8 : 0) }).strict().parse(params);
+      if (!isAbsolute(input2.cwd) || resolve(input2.cwd) !== resolve(options.workspace))
+        throw new AcpFault(-32602, "Workspace is host-owned");
+      let servers;
+      try {
+        servers = mcp?.parse(input2.mcpServers);
+      } catch {
+        throw new AcpFault(-32602, "MCP configuration was not accepted by the host");
+      }
+      creating = true;
+      try {
+        const data = await command({ method: "session.create", idempotencyKey: randomUUID() });
+        if (data.kind !== "session")
+          throw new AcpFault(-32603, "Invalid adapter response");
+        if (mcp && servers)
+          mcp.bind(data.session.sessionId, servers);
+        sessions.add(data.session.sessionId);
+        return { sessionId: data.session.sessionId };
+      } finally {
+        creating = false;
+      }
+    }
+    if (method === "session/cancel") {
+      const input2 = sessionParams.parse(params);
+      requireSession(input2.sessionId);
+      if (active?.sessionId === input2.sessionId) {
+        active.cancelled = true;
+        active.cancel();
+        await adapter.cancelActive();
+      }
+      return {};
+    }
+    if (method !== "session/prompt")
+      throw new AcpFault(-32601, "Method not supported");
+    const input = sessionParams.extend({ prompt: z.array(z.object({ type: z.literal("text"), text: z.string().max(64 * 1024) }).strict()).min(1).max(64) }).parse(params);
+    requireSession(input.sessionId);
+    const prompt = input.prompt.map((block) => block.text).join(`
+`);
+    if (!prompt.trim() || prompt.length > 64 * 1024)
+      throw new AcpFault(-32602, "Invalid prompt size");
+    if (active || creating)
+      throw new AcpFault(-32000, "BUSY");
+    const permissionController = new AbortController;
+    let cancel;
+    const current = { sessionId: input.sessionId, cancelled: false, cancellation: new Promise((resolve2) => {
+      cancel = resolve2;
+    }), cancel: () => {
+      permissionController.abort();
+      cancel();
+    } };
+    active = current;
+    try {
+      const session = await command({ method: "session.get", sessionId: input.sessionId });
+      if (session.kind !== "session")
+        throw new AcpFault(-32603, "Invalid adapter response");
+      if (current.cancelled)
+        return { stopReason: "cancelled" };
+      let data = await command({
+        method: "run.start",
+        sessionId: input.sessionId,
+        expectedRevision: session.session.revision,
+        prompt,
+        idempotencyKey: randomUUID()
+      });
+      while (data.kind === "run" && data.run.status === "waiting_approval" && !current.cancelled) {
+        const decisions = [];
+        for (const approval of data.run.approvals) {
+          const answer = await Promise.race([
+            options.requestPermission({
+              sessionId: input.sessionId,
+              toolCall: { toolCallId: approval.approvalId, title: "Review pending action", kind: "other", status: "pending", rawInput: approval.action },
+              options: [{ optionId: "allow_once", name: "Allow once", kind: "allow_once" }, { optionId: "reject_once", name: "Reject once", kind: "reject_once" }]
+            }, permissionController.signal),
+            current.cancellation.then(() => ({ outcome: { outcome: "cancelled" } }))
+          ]);
+          const result = permissionResult.parse(answer);
+          if (result.outcome.outcome === "cancelled" || current.cancelled) {
+            current.cancelled = true;
+            break;
+          }
+          decisions.push({ approvalId: approval.approvalId, digest: approval.digest, approve: result.outcome.optionId === "allow_once" });
+        }
+        if (current.cancelled)
+          break;
+        if (!decisions.length)
+          throw new AcpFault(-32603, "Missing pending approval");
+        data = await command({
+          method: "approval.resolve",
+          sessionId: input.sessionId,
+          runId: data.run.runId,
+          expectedRevision: data.run.revision,
+          decisions,
+          idempotencyKey: randomUUID()
+        });
+      }
+      if (data.kind !== "run")
+        throw new AcpFault(-32603, "Invalid adapter response");
+      if (current.cancelled && !["completed", "failed", "cancelled", "timed_out"].includes(data.run.status)) {
+        await command({
+          method: "run.cancel",
+          sessionId: input.sessionId,
+          runId: data.run.runId,
+          expectedRevision: data.run.revision,
+          idempotencyKey: randomUUID()
+        });
+      }
+      if (data.run.output)
+        await options.notify({ jsonrpc: "2.0", method: "session/update", params: {
+          sessionId: input.sessionId,
+          update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: data.run.output } }
+        } });
+      return { stopReason: current.cancelled || data.run.status === "cancelled" ? "cancelled" : data.run.status === "completed" ? "end_turn" : "refusal" };
+    } catch (error) {
+      if (current.cancelled)
+        return { stopReason: "cancelled" };
+      throw error;
+    } finally {
+      permissionController.abort();
+      active = undefined;
+    }
+  };
+  return {
+    async cancelActive() {
+      if (active) {
+        active.cancelled = true;
+        active.cancel();
+      }
+      await adapter.cancelActive();
+    },
+    async handle(value) {
+      const parsed = envelope.safeParse(value);
+      if (!parsed.success)
+        return { jsonrpc: "2.0", id: null, error: { code: -32600, message: "Invalid request" } };
+      const request = parsed.data;
+      if (request.id === undefined && request.method !== "session/cancel")
+        return;
+      try {
+        const result = await execute(request.method, request.params);
+        return request.id === undefined ? undefined : { jsonrpc: "2.0", id: request.id, result };
+      } catch (error) {
+        if (request.id === undefined)
+          return;
+        return { jsonrpc: "2.0", id: request.id, error: {
+          code: error instanceof AcpFault ? error.code : error instanceof z.ZodError ? -32602 : -32603,
+          message: error instanceof AcpFault ? error.message : error instanceof z.ZodError ? "Invalid params" : "Internal error"
+        } };
+      }
+    }
+  };
+};
+
+// src/client/acp-stdio.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var serveAcpStdio = async (adapter, options) => {
+  const timeoutMs = options.permissionTimeoutMs ?? 15 * 60000;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 15 * 60000)
+    throw new Error("Invalid ACP permission timeout");
+  const pending = new Map;
+  const jobs = new Set;
+  const inflight = new Set;
+  const write = (value) => new Promise((resolve2, reject) => {
+    options.output.write(JSON.stringify(value) + `
+`, (error) => error ? reject(error) : resolve2());
+  });
+  let transportFailure;
+  const connection = createAcpConnection(adapter, {
+    workspace: options.workspace,
+    ...options.mcpSessionProvider ? { mcpSessionProvider: options.mcpSessionProvider } : {},
+    notify: write,
+    requestPermission: async (params, signal) => {
+      const id = `permission_${randomUUID2()}`;
+      const cancel = () => {
+        const request = pending.get(id);
+        if (request) {
+          clearTimeout(request.timer);
+          pending.delete(id);
+          request.resolve({ outcome: { outcome: "cancelled" } });
+        }
+      };
+      const response = new Promise((resolve2) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          resolve2({ outcome: { outcome: "cancelled" } });
+        }, timeoutMs);
+        timer.unref();
+        pending.set(id, { resolve: resolve2, timer });
+      });
+      signal?.addEventListener("abort", cancel, { once: true });
+      if (signal?.aborted)
+        cancel();
+      try {
+        if (!signal?.aborted)
+          await write({ jsonrpc: "2.0", id, method: "session/request_permission", params });
+        return await response;
+      } finally {
+        signal?.removeEventListener("abort", cancel);
+        const request = pending.get(id);
+        if (request)
+          clearTimeout(request.timer);
+        pending.delete(id);
+      }
+    }
+  });
+  const dispatch = async (line) => {
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      await write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+      return;
+    }
+    if (value?.jsonrpc === "2.0" && typeof value.id === "string" && value.method === undefined) {
+      const request = pending.get(value.id);
+      if (request) {
+        clearTimeout(request.timer);
+        pending.delete(value.id);
+        request.resolve("result" in value && !("error" in value) ? value.result : { outcome: { outcome: "cancelled" } });
+      }
+      return;
+    }
+    const key = value?.id === undefined ? undefined : JSON.stringify(value.id);
+    if (key && inflight.has(key)) {
+      await write({ jsonrpc: "2.0", id: value.id, error: { code: -32600, message: "Request ID already active" } });
+      return;
+    }
+    if (key)
+      inflight.add(key);
+    try {
+      const response = await connection.handle(value);
+      if (response !== undefined)
+        await write(response);
+    } finally {
+      if (key)
+        inflight.delete(key);
+    }
+  };
+  const launch = (line) => {
+    if (!line.trim())
+      return;
+    if (jobs.size >= 64)
+      throw new Error("ACP request capacity exceeded");
+    const job = dispatch(line).catch((error) => {
+      transportFailure = error;
+      options.input.destroy();
+    });
+    jobs.add(job);
+    job.finally(() => jobs.delete(job));
+  };
+  let buffer = Buffer.alloc(0);
+  try {
+    for await (const chunk of options.input) {
+      buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+      let newline;
+      while ((newline = buffer.indexOf(10)) !== -1) {
+        if (newline > 1024 * 1024)
+          throw new Error("ACP frame exceeds 1 MiB");
+        const line = buffer.subarray(0, newline).toString("utf8");
+        buffer = buffer.subarray(newline + 1);
+        launch(line);
+      }
+      if (buffer.length > 1024 * 1024)
+        throw new Error("ACP frame exceeds 1 MiB");
+    }
+    if (buffer.length)
+      launch(buffer.toString("utf8"));
+  } finally {
+    for (const request of pending.values()) {
+      clearTimeout(request.timer);
+      request.resolve({ outcome: { outcome: "cancelled" } });
+    }
+    pending.clear();
+    await connection.cancelActive();
+    await Promise.allSettled(jobs);
+  }
+  if (transportFailure)
+    throw transportFailure;
+};
+
+export { issueAcpMcpSessionProvider, createAcpConnection, serveAcpStdio };