acpx 0.1.10 → 0.1.11

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command, CommanderError, InvalidArgumentError } from "commander";
+import { Command, CommanderError, InvalidArgumentError as InvalidArgumentError3 } from "commander";
 import { realpathSync } from "fs";
 import fs6 from "fs/promises";
 import path7 from "path";
@@ -13,7 +13,7 @@ var AGENT_REGISTRY = {
   codex: "npx @zed-industries/codex-acp",
   claude: "npx -y @zed-industries/claude-agent-acp",
   gemini: "gemini",
-  opencode: "npx opencode-ai",
+  opencode: "npx -y opencode-ai acp",
   pi: "npx pi-acp"
 };
 var DEFAULT_AGENT_NAME = "codex";
@@ -43,6 +43,223 @@ function listBuiltInAgents(overrides) {
   return Object.keys(mergeAgentRegistry(overrides));
 }
 
+// src/cli-internal-owner.ts
+import { InvalidArgumentError } from "commander";
+
+// src/types.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  ERROR: 1,
+  USAGE: 2,
+  TIMEOUT: 3,
+  NO_SESSION: 4,
+  PERMISSION_DENIED: 5,
+  INTERRUPTED: 130
+};
+var OUTPUT_FORMATS = ["text", "json", "quiet"];
+var PERMISSION_MODES = ["approve-all", "approve-reads", "deny-all"];
+var AUTH_POLICIES = ["skip", "fail"];
+var NON_INTERACTIVE_PERMISSION_POLICIES = ["deny", "fail"];
+var OUTPUT_ERROR_CODES = [
+  "NO_SESSION",
+  "TIMEOUT",
+  "PERMISSION_DENIED",
+  "PERMISSION_PROMPT_UNAVAILABLE",
+  "RUNTIME",
+  "USAGE"
+];
+var OUTPUT_ERROR_ORIGINS = ["cli", "runtime", "queue", "acp"];
+
+// src/cli-internal-owner.ts
+function parseNonEmptyValue(label, value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new InvalidArgumentError(`${label} must not be empty`);
+  }
+  return trimmed;
+}
+function parseNonNegativeMilliseconds(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new InvalidArgumentError("TTL must be a non-negative number of milliseconds");
+  }
+  return Math.round(parsed);
+}
+function parseTimeoutMilliseconds(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new InvalidArgumentError("Timeout must be a positive number of milliseconds");
+  }
+  return Math.round(parsed);
+}
+function parsePermissionMode(value) {
+  if (!PERMISSION_MODES.includes(value)) {
+    throw new InvalidArgumentError(
+      `Invalid permission mode "${value}". Expected one of: ${PERMISSION_MODES.join(", ")}`
+    );
+  }
+  return value;
+}
+function parseAuthPolicy(value) {
+  if (!AUTH_POLICIES.includes(value)) {
+    throw new InvalidArgumentError(
+      `Invalid auth policy "${value}". Expected one of: ${AUTH_POLICIES.join(", ")}`
+    );
+  }
+  return value;
+}
+function parseNonInteractivePermissionPolicy(value) {
+  if (!NON_INTERACTIVE_PERMISSION_POLICIES.includes(
+    value
+  )) {
+    throw new InvalidArgumentError(
+      `Invalid non-interactive permission policy "${value}". Expected one of: ${NON_INTERACTIVE_PERMISSION_POLICIES.join(", ")}`
+    );
+  }
+  return value;
+}
+function parseQueueOwnerFlags(argv, defaultTtlMs) {
+  if (argv[0] !== "__queue-owner") {
+    return void 0;
+  }
+  const flags = {
+    ttlMs: defaultTtlMs
+  };
+  const consumeValue = (index, token) => {
+    if (token.includes("=")) {
+      return {
+        value: token.slice(token.indexOf("=") + 1),
+        next: index
+      };
+    }
+    const value = argv[index + 1];
+    if (!value || value.startsWith("-")) {
+      throw new InvalidArgumentError(`${token} requires a value`);
+    }
+    return {
+      value,
+      next: index + 1
+    };
+  };
+  for (let index = 1; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--session-id" || token.startsWith("--session-id=")) {
+      const consumed = consumeValue(index, token);
+      flags.sessionId = parseNonEmptyValue("Session id", consumed.value);
+      index = consumed.next;
+      continue;
+    }
+    if (token === "--ttl-ms" || token.startsWith("--ttl-ms=")) {
+      const consumed = consumeValue(index, token);
+      flags.ttlMs = parseNonNegativeMilliseconds(consumed.value);
+      index = consumed.next;
+      continue;
+    }
+    if (token === "--permission-mode" || token.startsWith("--permission-mode=")) {
+      const consumed = consumeValue(index, token);
+      flags.permissionMode = parsePermissionMode(consumed.value);
+      index = consumed.next;
+      continue;
+    }
+    if (token === "--non-interactive-permissions" || token.startsWith("--non-interactive-permissions=")) {
+      const consumed = consumeValue(index, token);
+      flags.nonInteractivePermissions = parseNonInteractivePermissionPolicy(
+        consumed.value
+      );
+      index = consumed.next;
+      continue;
+    }
+    if (token === "--auth-policy" || token.startsWith("--auth-policy=")) {
+      const consumed = consumeValue(index, token);
+      flags.authPolicy = parseAuthPolicy(consumed.value);
+      index = consumed.next;
+      continue;
+    }
+    if (token === "--timeout-ms" || token.startsWith("--timeout-ms=")) {
+      const consumed = consumeValue(index, token);
+      flags.timeoutMs = parseTimeoutMilliseconds(consumed.value);
+      index = consumed.next;
+      continue;
+    }
+    if (token === "--verbose") {
+      flags.verbose = true;
+      continue;
+    }
+    if (token === "--suppress-sdk-console-errors") {
+      flags.suppressSdkConsoleErrors = true;
+      continue;
+    }
+    throw new InvalidArgumentError(`Unknown __queue-owner option: ${token}`);
+  }
+  if (!flags.sessionId) {
+    throw new InvalidArgumentError("__queue-owner requires --session-id");
+  }
+  if (!flags.permissionMode) {
+    throw new InvalidArgumentError("__queue-owner requires --permission-mode");
+  }
+  return {
+    sessionId: flags.sessionId,
+    ttlMs: flags.ttlMs ?? defaultTtlMs,
+    permissionMode: flags.permissionMode,
+    nonInteractivePermissions: flags.nonInteractivePermissions,
+    authPolicy: flags.authPolicy,
+    timeoutMs: flags.timeoutMs,
+    verbose: flags.verbose,
+    suppressSdkConsoleErrors: flags.suppressSdkConsoleErrors
+  };
+}
+
+// src/cli-public.ts
+import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
+function configurePublicCli(options) {
+  const builtInAgents = options.listBuiltInAgents(options.config.agents);
+  for (const agentName of builtInAgents) {
+    options.registerAgentCommand(options.program, agentName, options.config);
+  }
+  options.registerDefaultCommands(options.program, options.config);
+  const scan = options.detectAgentToken(options.argv);
+  if (!scan.hasAgentOverride && scan.token && !options.topLevelVerbs.has(scan.token) && !builtInAgents.includes(scan.token)) {
+    options.registerAgentCommand(options.program, scan.token, options.config);
+  }
+  options.program.argument("[prompt...]", "Prompt text").action(async function(promptParts) {
+    if (promptParts.length === 0 && process.stdin.isTTY) {
+      if (options.requestedJsonStrict) {
+        throw new InvalidArgumentError2(
+          "Prompt is required (pass as argument, --file, or pipe via stdin)"
+        );
+      }
+      this.outputHelp();
+      return;
+    }
+    await options.handlePromptAction(this, promptParts);
+  });
+  options.program.addHelpText(
+    "after",
+    `
+Examples:
+  acpx codex sessions new
+  acpx codex "fix the tests"
+  acpx codex prompt "fix the tests"
+  acpx codex --no-wait "queue follow-up task"
+  acpx codex exec "what does this repo do"
+  acpx codex cancel
+  acpx codex set-mode plan
+  acpx codex set approval_policy conservative
+  acpx codex -s backend "fix the API"
+  acpx codex sessions
+  acpx codex sessions new --name backend
+  acpx codex sessions ensure --name backend
+  acpx codex sessions close backend
+  acpx codex status
+  acpx config show
+  acpx config init
+  acpx --ttl 30 codex "investigate flaky tests"
+  acpx claude "refactor auth"
+  acpx gemini "add logging"
+  acpx --agent ./my-custom-server "do something"`
+  );
+}
+
 // src/config.ts
 import fs from "fs/promises";
 import os from "os";
@@ -92,7 +309,7 @@ function parseTimeoutMs(value, sourcePath) {
   }
   return Math.round(value * 1e3);
 }
-function parsePermissionMode(value, sourcePath) {
+function parsePermissionMode2(value, sourcePath) {
   if (value == null) {
     return void 0;
   }
@@ -103,7 +320,7 @@ function parsePermissionMode(value, sourcePath) {
   }
   return value;
 }
-function parseNonInteractivePermissionPolicy(value, sourcePath) {
+function parseNonInteractivePermissionPolicy2(value, sourcePath) {
   if (value == null) {
     return void 0;
   }
@@ -116,7 +333,7 @@ function parseNonInteractivePermissionPolicy(value, sourcePath) {
   }
   return value;
 }
-function parseAuthPolicy(value, sourcePath) {
+function parseAuthPolicy2(value, sourcePath) {
   if (value == null) {
     return void 0;
   }
@@ -239,15 +456,15 @@ async function loadResolvedConfig(cwd) {
   const globalConfig = globalResult.config;
   const projectConfig = projectResult.config;
   const defaultAgent = parseDefaultAgent(projectConfig?.defaultAgent, projectPath) ?? parseDefaultAgent(globalConfig?.defaultAgent, globalPath) ?? DEFAULT_AGENT_NAME;
-  const defaultPermissions = parsePermissionMode(projectConfig?.defaultPermissions, projectPath) ?? parsePermissionMode(globalConfig?.defaultPermissions, globalPath) ?? DEFAULT_PERMISSION_MODE;
-  const nonInteractivePermissions = parseNonInteractivePermissionPolicy(
+  const defaultPermissions = parsePermissionMode2(projectConfig?.defaultPermissions, projectPath) ?? parsePermissionMode2(globalConfig?.defaultPermissions, globalPath) ?? DEFAULT_PERMISSION_MODE;
+  const nonInteractivePermissions = parseNonInteractivePermissionPolicy2(
     projectConfig?.nonInteractivePermissions,
     projectPath
-  ) ?? parseNonInteractivePermissionPolicy(
+  ) ?? parseNonInteractivePermissionPolicy2(
     globalConfig?.nonInteractivePermissions,
     globalPath
   ) ?? DEFAULT_NON_INTERACTIVE_PERMISSION_POLICY;
-  const authPolicy = parseAuthPolicy(projectConfig?.authPolicy, projectPath) ?? parseAuthPolicy(globalConfig?.authPolicy, globalPath) ?? DEFAULT_AUTH_POLICY;
+  const authPolicy = parseAuthPolicy2(projectConfig?.authPolicy, projectPath) ?? parseAuthPolicy2(globalConfig?.authPolicy, globalPath) ?? DEFAULT_AUTH_POLICY;
   const ttlMs = parseTtlMs(projectConfig?.ttl, projectPath) ?? parseTtlMs(globalConfig?.ttl, globalPath) ?? DEFAULT_TTL_MS;
   const timeoutConfiguredInProject = projectConfig != null && Object.prototype.hasOwnProperty.call(projectConfig, "timeout");
   const timeoutConfiguredInGlobal = globalConfig != null && Object.prototype.hasOwnProperty.call(globalConfig, "timeout");
@@ -499,29 +716,6 @@ function isAcpResourceNotFoundError(error) {
   return isSessionNotFoundText(formatUnknownErrorMessage(error));
 }
 
-// src/types.ts
-var EXIT_CODES = {
-  SUCCESS: 0,
-  ERROR: 1,
-  USAGE: 2,
-  TIMEOUT: 3,
-  NO_SESSION: 4,
-  PERMISSION_DENIED: 5,
-  INTERRUPTED: 130
-};
-var OUTPUT_FORMATS = ["text", "json", "quiet"];
-var AUTH_POLICIES = ["skip", "fail"];
-var NON_INTERACTIVE_PERMISSION_POLICIES = ["deny", "fail"];
-var OUTPUT_ERROR_CODES = [
-  "NO_SESSION",
-  "TIMEOUT",
-  "PERMISSION_DENIED",
-  "PERMISSION_PROMPT_UNAVAILABLE",
-  "RUNTIME",
-  "USAGE"
-];
-var OUTPUT_ERROR_ORIGINS = ["cli", "runtime", "queue", "acp"];
-
 // src/error-normalization.ts
 var AUTH_REQUIRED_ACP_CODES = /* @__PURE__ */ new Set([-32e3]);
 function asRecord2(value) {
@@ -2914,115 +3108,270 @@ var AcpClient = class {
   }
 };
 
-// src/queue-owner-turn-controller.ts
-var QueueOwnerTurnController = class {
-  options;
-  state = "idle";
-  pendingCancel = false;
-  activeController;
-  constructor(options) {
-    this.options = options;
-  }
-  get lifecycleState() {
-    return this.state;
-  }
-  get hasPendingCancel() {
-    return this.pendingCancel;
-  }
-  beginTurn() {
-    this.state = "starting";
-    this.pendingCancel = false;
+// src/queue-lease-store.ts
+import { createHash } from "crypto";
+import fs3 from "fs/promises";
+import os2 from "os";
+import path4 from "path";
+var PROCESS_EXIT_GRACE_MS = 1500;
+var PROCESS_POLL_MS = 50;
+var QUEUE_OWNER_STALE_HEARTBEAT_MS = 15e3;
+function queueBaseDir() {
+  return path4.join(os2.homedir(), ".acpx", "queues");
+}
+function queueKeyForSession(sessionId) {
+  return createHash("sha256").update(sessionId).digest("hex").slice(0, 24);
+}
+function queueLockFilePath(sessionId) {
+  return path4.join(queueBaseDir(), `${queueKeyForSession(sessionId)}.lock`);
+}
+function queueSocketPath(sessionId) {
+  const key = queueKeyForSession(sessionId);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\acpx-${key}`;
   }
-  markPromptActive() {
-    if (this.state === "starting" || this.state === "active") {
-      this.state = "active";
-    }
+  return path4.join(queueBaseDir(), `${key}.sock`);
+}
+function parseQueueOwnerRecord(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return null;
   }
-  endTurn() {
-    this.state = "idle";
-    this.pendingCancel = false;
+  const record = raw;
+  if (!Number.isInteger(record.pid) || record.pid <= 0 || typeof record.sessionId !== "string" || typeof record.socketPath !== "string" || typeof record.createdAt !== "string" || typeof record.heartbeatAt !== "string" || !Number.isInteger(record.ownerGeneration) || record.ownerGeneration <= 0 || !Number.isInteger(record.queueDepth) || record.queueDepth < 0) {
+    return null;
   }
-  beginClosing() {
-    this.state = "closing";
-    this.pendingCancel = false;
-    this.activeController = void 0;
+  return {
+    pid: record.pid,
+    sessionId: record.sessionId,
+    socketPath: record.socketPath,
+    createdAt: record.createdAt,
+    heartbeatAt: record.heartbeatAt,
+    ownerGeneration: record.ownerGeneration,
+    queueDepth: record.queueDepth
+  };
+}
+function createOwnerGeneration() {
+  return Date.now() * 1e3 + Math.floor(Math.random() * 1e3);
+}
+function nowIso4() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isQueueOwnerHeartbeatStale(owner) {
+  const heartbeatMs = Date.parse(owner.heartbeatAt);
+  if (!Number.isFinite(heartbeatMs)) {
+    return true;
   }
-  setActiveController(controller) {
-    this.activeController = controller;
+  return Date.now() - heartbeatMs > QUEUE_OWNER_STALE_HEARTBEAT_MS;
+}
+async function ensureQueueDir() {
+  await fs3.mkdir(queueBaseDir(), { recursive: true });
+}
+async function removeSocketFile(socketPath) {
+  if (process.platform === "win32") {
+    return;
   }
-  clearActiveController() {
-    this.activeController = void 0;
+  try {
+    await fs3.unlink(socketPath);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
   }
-  assertCanHandleControlRequest() {
-    if (this.state === "closing") {
-      throw new QueueConnectionError("Queue owner is closing", {
-        detailCode: "QUEUE_OWNER_SHUTTING_DOWN",
-        origin: "queue",
-        retryable: true
-      });
+}
+async function waitForProcessExit(pid, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (Date.now() <= deadline) {
+    if (!isProcessAlive(pid)) {
+      return true;
     }
+    await waitMs2(PROCESS_POLL_MS);
   }
-  async requestCancel() {
-    const activeController = this.activeController;
-    if (activeController?.hasActivePrompt()) {
-      const cancelled2 = await activeController.requestCancelActivePrompt();
-      if (cancelled2) {
-        this.pendingCancel = false;
-      }
-      return cancelled2;
-    }
-    if (this.state === "starting" || this.state === "active") {
-      this.pendingCancel = true;
-      return true;
+  return !isProcessAlive(pid);
+}
+async function cleanupStaleQueueOwner(sessionId, owner) {
+  const lockPath = queueLockFilePath(sessionId);
+  const socketPath = owner?.socketPath ?? queueSocketPath(sessionId);
+  await removeSocketFile(socketPath).catch(() => {
+  });
+  await fs3.unlink(lockPath).catch((error) => {
+    if (error.code !== "ENOENT") {
+      throw error;
     }
+  });
+}
+async function readQueueOwnerRecord(sessionId) {
+  const lockPath = queueLockFilePath(sessionId);
+  try {
+    const payload = await fs3.readFile(lockPath, "utf8");
+    const parsed = parseQueueOwnerRecord(JSON.parse(payload));
+    return parsed ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isProcessAlive(pid) {
+  if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) {
     return false;
   }
-  async applyPendingCancel() {
-    const activeController = this.activeController;
-    if (!this.pendingCancel || !activeController || !activeController.hasActivePrompt()) {
-      return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function terminateProcess(pid) {
+  if (!isProcessAlive(pid)) {
+    return false;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  if (await waitForProcessExit(pid, PROCESS_EXIT_GRACE_MS)) {
+    return true;
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    return false;
+  }
+  await waitForProcessExit(pid, PROCESS_EXIT_GRACE_MS);
+  return true;
+}
+async function ensureOwnerIsUsable(sessionId, owner) {
+  const alive = isProcessAlive(owner.pid);
+  const stale = isQueueOwnerHeartbeatStale(owner);
+  if (alive && !stale) {
+    return true;
+  }
+  if (alive) {
+    await terminateProcess(owner.pid).catch(() => {
+    });
+  }
+  await cleanupStaleQueueOwner(sessionId, owner);
+  return false;
+}
+async function readQueueOwnerStatus(sessionId) {
+  const owner = await readQueueOwnerRecord(sessionId);
+  if (!owner) {
+    return void 0;
+  }
+  const alive = await ensureOwnerIsUsable(sessionId, owner);
+  if (!alive) {
+    return void 0;
+  }
+  return {
+    pid: owner.pid,
+    socketPath: owner.socketPath,
+    heartbeatAt: owner.heartbeatAt,
+    ownerGeneration: owner.ownerGeneration,
+    queueDepth: owner.queueDepth,
+    alive,
+    stale: isQueueOwnerHeartbeatStale(owner)
+  };
+}
+async function tryAcquireQueueOwnerLease(sessionId, nowIsoFactory = nowIso4) {
+  await ensureQueueDir();
+  const lockPath = queueLockFilePath(sessionId);
+  const socketPath = queueSocketPath(sessionId);
+  const createdAt = nowIsoFactory();
+  const ownerGeneration = createOwnerGeneration();
+  const payload = JSON.stringify(
+    {
+      pid: process.pid,
+      sessionId,
+      socketPath,
+      createdAt,
+      heartbeatAt: createdAt,
+      ownerGeneration,
+      queueDepth: 0
+    },
+    null,
+    2
+  );
+  try {
+    await fs3.writeFile(lockPath, `${payload}
+`, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    await removeSocketFile(socketPath).catch(() => {
+    });
+    return {
+      sessionId,
+      lockPath,
+      socketPath,
+      createdAt,
+      ownerGeneration
+    };
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
     }
-    const cancelled2 = await activeController.requestCancelActivePrompt();
-    if (cancelled2) {
-      this.pendingCancel = false;
+    const owner = await readQueueOwnerRecord(sessionId);
+    if (!owner) {
+      await cleanupStaleQueueOwner(sessionId, owner);
+      return void 0;
     }
-    return cancelled2;
-  }
-  async setSessionMode(modeId, timeoutMs) {
-    this.assertCanHandleControlRequest();
-    const activeController = this.activeController;
-    if (activeController) {
-      await this.options.withTimeout(
-        async () => await activeController.setSessionMode(modeId),
-        timeoutMs
-      );
-      return;
+    if (!isProcessAlive(owner.pid) || isQueueOwnerHeartbeatStale(owner)) {
+      if (isProcessAlive(owner.pid)) {
+        await terminateProcess(owner.pid).catch(() => {
+        });
+      }
+      await cleanupStaleQueueOwner(sessionId, owner);
     }
-    await this.options.setSessionModeFallback(modeId, timeoutMs);
+    return void 0;
   }
-  async setSessionConfigOption(configId, value, timeoutMs) {
-    this.assertCanHandleControlRequest();
-    const activeController = this.activeController;
-    if (activeController) {
-      return await this.options.withTimeout(
-        async () => await activeController.setSessionConfigOption(configId, value),
-        timeoutMs
-      );
+}
+async function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso4) {
+  const payload = JSON.stringify(
+    {
+      pid: process.pid,
+      sessionId: lease.sessionId,
+      socketPath: lease.socketPath,
+      createdAt: lease.createdAt,
+      heartbeatAt: nowIsoFactory(),
+      ownerGeneration: lease.ownerGeneration,
+      queueDepth: Math.max(0, Math.round(options.queueDepth))
+    },
+    null,
+    2
+  );
+  await fs3.writeFile(lease.lockPath, `${payload}
+`, {
+    encoding: "utf8"
+  });
+}
+async function releaseQueueOwnerLease(lease) {
+  await removeSocketFile(lease.socketPath).catch(() => {
+  });
+  await fs3.unlink(lease.lockPath).catch((error) => {
+    if (error.code !== "ENOENT") {
+      throw error;
     }
-    return await this.options.setSessionConfigOptionFallback(
-      configId,
-      value,
-      timeoutMs
-    );
+  });
+}
+async function terminateQueueOwnerForSession(sessionId) {
+  const owner = await readQueueOwnerRecord(sessionId);
+  if (!owner) {
+    return;
   }
-};
+  if (isProcessAlive(owner.pid)) {
+    await terminateProcess(owner.pid);
+  }
+  await cleanupStaleQueueOwner(sessionId, owner);
+}
+async function waitMs2(ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
 
-// src/queue-ipc.ts
-import { createHash, randomUUID as randomUUID2 } from "crypto";
-import fs3 from "fs/promises";
+// src/queue-ipc-client.ts
+import { randomUUID as randomUUID2 } from "crypto";
 import net from "net";
-import os2 from "os";
-import path4 from "path";
 
 // src/queue-messages.ts
 function asRecord4(value) {
@@ -3255,236 +3604,629 @@ function parseQueueOwnerMessage(raw) {
   return null;
 }
 
-// src/queue-ipc.ts
-var PROCESS_EXIT_GRACE_MS = 1500;
-var PROCESS_POLL_MS = 50;
+// src/queue-ipc-client.ts
 var QUEUE_CONNECT_ATTEMPTS = 40;
 var QUEUE_CONNECT_RETRY_MS = 50;
-function queueBaseDir() {
-  return path4.join(os2.homedir(), ".acpx", "queues");
-}
-function makeQueueOwnerError(requestId, message, detailCode, options = {}) {
-  return {
-    type: "error",
-    requestId,
-    code: "RUNTIME",
-    detailCode,
-    origin: "queue",
-    retryable: options.retryable,
-    message
-  };
+function shouldRetryQueueConnect(error) {
+  const code = error.code;
+  return code === "ENOENT" || code === "ECONNREFUSED";
 }
-function makeQueueOwnerErrorFromUnknown(requestId, error, detailCode, options = {}) {
-  const normalized = normalizeOutputError(error, {
-    defaultCode: "RUNTIME",
-    origin: "queue",
-    detailCode,
-    retryable: options.retryable
+async function connectToSocket(socketPath) {
+  return await new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    const onConnect = () => {
+      socket.off("error", onError);
+      resolve(socket);
+    };
+    const onError = (error) => {
+      socket.off("connect", onConnect);
+      reject(error);
+    };
+    socket.once("connect", onConnect);
+    socket.once("error", onError);
   });
-  return {
-    type: "error",
-    requestId,
-    code: normalized.code,
-    detailCode: normalized.detailCode,
-    origin: normalized.origin,
-    message: normalized.message,
-    retryable: normalized.retryable,
-    acp: normalized.acp
-  };
 }
-function isProcessAlive(pid) {
-  if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) {
-    return false;
+async function connectToQueueOwner(owner) {
+  let lastError;
+  for (let attempt = 0; attempt < QUEUE_CONNECT_ATTEMPTS; attempt += 1) {
+    try {
+      return await connectToSocket(owner.socketPath);
+    } catch (error) {
+      lastError = error;
+      if (!shouldRetryQueueConnect(error)) {
+        throw error;
+      }
+      if (!isProcessAlive(owner.pid)) {
+        return void 0;
+      }
+      await waitMs2(QUEUE_CONNECT_RETRY_MS);
+    }
   }
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+  if (lastError && !shouldRetryQueueConnect(lastError)) {
+    throw lastError;
   }
+  return void 0;
 }
-async function waitForProcessExit(pid, timeoutMs) {
-  const deadline = Date.now() + Math.max(0, timeoutMs);
-  while (Date.now() <= deadline) {
-    if (!isProcessAlive(pid)) {
-      return true;
-    }
-    await new Promise((resolve) => {
-      setTimeout(resolve, PROCESS_POLL_MS);
+async function submitToQueueOwner(owner, options) {
+  const socket = await connectToQueueOwner(owner);
+  if (!socket) {
+    return void 0;
+  }
+  socket.setEncoding("utf8");
+  const requestId = randomUUID2();
+  const request = {
+    type: "submit_prompt",
+    requestId,
+    message: options.message,
+    permissionMode: options.permissionMode,
+    nonInteractivePermissions: options.nonInteractivePermissions,
+    timeoutMs: options.timeoutMs,
+    suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+    waitForCompletion: options.waitForCompletion
+  };
+  options.outputFormatter.setContext({
+    sessionId: options.sessionId,
+    requestId,
+    stream: "prompt"
+  });
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    let acknowledged = false;
+    let buffer = "";
+    let sawDone = false;
+    const finishResolve = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.removeAllListeners();
+      if (!socket.destroyed) {
+        socket.end();
+      }
+      resolve(result);
+    };
+    const finishReject = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.removeAllListeners();
+      if (!socket.destroyed) {
+        socket.destroy();
+      }
+      reject(error);
+    };
+    const processLine = (line) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        finishReject(
+          new QueueProtocolError("Queue owner sent invalid JSON payload", {
+            detailCode: "QUEUE_PROTOCOL_INVALID_JSON",
+            origin: "queue",
+            retryable: true
+          })
+        );
+        return;
+      }
+      const message = parseQueueOwnerMessage(parsed);
+      if (!message || message.requestId !== requestId) {
+        finishReject(
+          new QueueProtocolError("Queue owner sent malformed message", {
+            detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+            origin: "queue",
+            retryable: true
+          })
+        );
+        return;
+      }
+      if (message.type === "accepted") {
+        acknowledged = true;
+        options.outputFormatter.setContext({
+          sessionId: options.sessionId,
+          requestId: message.requestId,
+          stream: "prompt"
+        });
+        if (!options.waitForCompletion) {
+          const queued = {
+            queued: true,
+            sessionId: options.sessionId,
+            requestId
+          };
+          finishResolve(queued);
+        }
+        return;
+      }
+      if (message.type === "error") {
+        options.outputFormatter.setContext({
+          sessionId: options.sessionId,
+          requestId: message.requestId,
+          stream: "prompt"
+        });
+        options.outputFormatter.onError({
+          code: message.code ?? "RUNTIME",
+          detailCode: message.detailCode,
+          origin: message.origin ?? "queue",
+          message: message.message,
+          retryable: message.retryable,
+          acp: message.acp
+        });
+        options.outputFormatter.flush();
+        const queueErrorAlreadyEmitted = options.errorEmissionPolicy?.queueErrorAlreadyEmitted ?? true;
+        finishReject(
+          new QueueConnectionError(message.message, {
+            outputCode: message.code,
+            detailCode: message.detailCode,
+            origin: message.origin ?? "queue",
+            retryable: message.retryable,
+            acp: message.acp,
+            ...queueErrorAlreadyEmitted ? { outputAlreadyEmitted: true } : {}
+          })
+        );
+        return;
+      }
+      if (!acknowledged) {
+        finishReject(
+          new QueueConnectionError("Queue owner did not acknowledge request", {
+            detailCode: "QUEUE_ACK_MISSING",
+            origin: "queue",
+            retryable: true
+          })
+        );
+        return;
+      }
+      if (message.type === "session_update") {
+        options.outputFormatter.onSessionUpdate(message.notification);
+        return;
+      }
+      if (message.type === "client_operation") {
+        options.outputFormatter.onClientOperation(message.operation);
+        return;
+      }
+      if (message.type === "done") {
+        options.outputFormatter.onDone(message.stopReason);
+        sawDone = true;
+        return;
+      }
+      if (message.type === "result") {
+        if (!sawDone) {
+          options.outputFormatter.onDone(message.result.stopReason);
+        }
+        options.outputFormatter.flush();
+        finishResolve(message.result);
+        return;
+      }
+      finishReject(
+        new QueueProtocolError("Queue owner returned unexpected response", {
+          detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
+          origin: "queue",
+          retryable: true
+        })
+      );
+    };
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      let index = buffer.indexOf("\n");
+      while (index >= 0) {
+        const line = buffer.slice(0, index).trim();
+        buffer = buffer.slice(index + 1);
+        if (line.length > 0) {
+          processLine(line);
+        }
+        index = buffer.indexOf("\n");
+      }
     });
+    socket.once("error", (error) => {
+      finishReject(error);
+    });
+    socket.once("close", () => {
+      if (settled) {
+        return;
+      }
+      if (!acknowledged) {
+        finishReject(
+          new QueueConnectionError(
+            "Queue owner disconnected before acknowledging request",
+            {
+              detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
+              origin: "queue",
+              retryable: true
+            }
+          )
+        );
+        return;
+      }
+      if (!options.waitForCompletion) {
+        const queued = {
+          queued: true,
+          sessionId: options.sessionId,
+          requestId
+        };
+        finishResolve(queued);
+        return;
+      }
+      finishReject(
+        new QueueConnectionError("Queue owner disconnected before prompt completion", {
+          detailCode: "QUEUE_DISCONNECTED_BEFORE_COMPLETION",
+          origin: "queue",
+          retryable: true
+        })
+      );
+    });
+    socket.write(`${JSON.stringify(request)}
+`);
+  });
+}
+async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
+  const socket = await connectToQueueOwner(owner);
+  if (!socket) {
+    return void 0;
   }
-  return !isProcessAlive(pid);
+  socket.setEncoding("utf8");
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    let acknowledged = false;
+    let buffer = "";
+    const finishResolve = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.removeAllListeners();
+      if (!socket.destroyed) {
+        socket.end();
+      }
+      resolve(result);
+    };
+    const finishReject = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.removeAllListeners();
+      if (!socket.destroyed) {
+        socket.destroy();
+      }
+      reject(error);
+    };
+    const processLine = (line) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        finishReject(
+          new QueueProtocolError("Queue owner sent invalid JSON payload", {
+            detailCode: "QUEUE_PROTOCOL_INVALID_JSON",
+            origin: "queue",
+            retryable: true
+          })
+        );
+        return;
+      }
+      const message = parseQueueOwnerMessage(parsed);
+      if (!message || message.requestId !== request.requestId) {
+        finishReject(
+          new QueueProtocolError("Queue owner sent malformed message", {
+            detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+            origin: "queue",
+            retryable: true
+          })
+        );
+        return;
+      }
+      if (message.type === "accepted") {
+        acknowledged = true;
+        return;
+      }
+      if (message.type === "error") {
+        finishReject(
+          new QueueConnectionError(message.message, {
+            outputCode: message.code,
+            detailCode: message.detailCode,
+            origin: message.origin ?? "queue",
+            retryable: message.retryable,
+            acp: message.acp
+          })
+        );
+        return;
+      }
+      if (!acknowledged) {
+        finishReject(
+          new QueueConnectionError("Queue owner did not acknowledge request", {
+            detailCode: "QUEUE_ACK_MISSING",
+            origin: "queue",
+            retryable: true
+          })
+        );
+        return;
+      }
+      if (!isExpectedResponse(message)) {
+        finishReject(
+          new QueueProtocolError("Queue owner returned unexpected response", {
+            detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
+            origin: "queue",
+            retryable: true
+          })
+        );
+        return;
+      }
+      finishResolve(message);
+    };
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      let index = buffer.indexOf("\n");
+      while (index >= 0) {
+        const line = buffer.slice(0, index).trim();
+        buffer = buffer.slice(index + 1);
+        if (line.length > 0) {
+          processLine(line);
+        }
+        index = buffer.indexOf("\n");
+      }
+    });
+    socket.once("error", (error) => {
+      finishReject(error);
+    });
+    socket.once("close", () => {
+      if (settled) {
+        return;
+      }
+      if (!acknowledged) {
+        finishReject(
+          new QueueConnectionError(
+            "Queue owner disconnected before acknowledging request",
+            {
+              detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
+              origin: "queue",
+              retryable: true
+            }
+          )
+        );
+        return;
+      }
+      finishReject(
+        new QueueConnectionError("Queue owner disconnected before responding", {
+          detailCode: "QUEUE_DISCONNECTED_BEFORE_COMPLETION",
+          origin: "queue",
+          retryable: true
+        })
+      );
+    });
+    socket.write(`${JSON.stringify(request)}
+`);
+  });
 }
-async function terminateProcess(pid) {
-  if (!isProcessAlive(pid)) {
-    return false;
+async function submitCancelToQueueOwner(owner) {
+  const request = {
+    type: "cancel_prompt",
+    requestId: randomUUID2()
+  };
+  const response = await submitControlToQueueOwner(
+    owner,
+    request,
+    (message) => message.type === "cancel_result"
+  );
+  if (!response) {
+    return void 0;
+  }
+  if (response.requestId !== request.requestId) {
+    throw new QueueProtocolError("Queue owner returned mismatched cancel response", {
+      detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+      origin: "queue",
+      retryable: true
+    });
+  }
+  return response.cancelled;
+}
+async function submitSetModeToQueueOwner(owner, modeId, timeoutMs) {
+  const request = {
+    type: "set_mode",
+    requestId: randomUUID2(),
+    modeId,
+    timeoutMs
+  };
+  const response = await submitControlToQueueOwner(
+    owner,
+    request,
+    (message) => message.type === "set_mode_result"
+  );
+  if (!response) {
+    return void 0;
+  }
+  if (response.requestId !== request.requestId) {
+    throw new QueueProtocolError("Queue owner returned mismatched set_mode response", {
+      detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+      origin: "queue",
+      retryable: true
+    });
+  }
+  return true;
+}
+async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs) {
+  const request = {
+    type: "set_config_option",
+    requestId: randomUUID2(),
+    configId,
+    value,
+    timeoutMs
+  };
+  const response = await submitControlToQueueOwner(
+    owner,
+    request,
+    (message) => message.type === "set_config_option_result"
+  );
+  if (!response) {
+    return void 0;
+  }
+  if (response.requestId !== request.requestId) {
+    throw new QueueProtocolError(
+      "Queue owner returned mismatched set_config_option response",
+      {
+        detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+        origin: "queue",
+        retryable: true
+      }
+    );
+  }
+  return response.response;
+}
+async function trySubmitToRunningOwner(options) {
+  const owner = await readQueueOwnerRecord(options.sessionId);
+  if (!owner) {
+    return void 0;
   }
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch {
-    return false;
+  if (!await ensureOwnerIsUsable(options.sessionId, owner)) {
+    return void 0;
   }
-  if (await waitForProcessExit(pid, PROCESS_EXIT_GRACE_MS)) {
-    return true;
+  const submitted = await submitToQueueOwner(owner, options);
+  if (submitted) {
+    if (options.verbose) {
+      process.stderr.write(
+        `[acpx] queued prompt on active owner pid ${owner.pid} for session ${options.sessionId}
+`
+      );
+    }
+    return submitted;
   }
-  try {
-    process.kill(pid, "SIGKILL");
-  } catch {
-    return false;
+  if (!await ensureOwnerIsUsable(options.sessionId, owner)) {
+    return void 0;
   }
-  await waitForProcessExit(pid, PROCESS_EXIT_GRACE_MS);
-  return true;
+  throw new QueueConnectionError(
+    "Session queue owner is running but not accepting queue requests",
+    {
+      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+      origin: "queue",
+      retryable: true
+    }
+  );
 }
-function parseQueueOwnerRecord(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    return null;
+async function tryCancelOnRunningOwner(options) {
+  const owner = await readQueueOwnerRecord(options.sessionId);
+  if (!owner) {
+    return void 0;
   }
-  const record = raw;
-  if (!Number.isInteger(record.pid) || record.pid <= 0 || typeof record.sessionId !== "string" || typeof record.socketPath !== "string") {
-    return null;
+  if (!await ensureOwnerIsUsable(options.sessionId, owner)) {
+    return void 0;
   }
-  return {
-    pid: record.pid,
-    sessionId: record.sessionId,
-    socketPath: record.socketPath
-  };
-}
-function queueKeyForSession(sessionId) {
-  return createHash("sha256").update(sessionId).digest("hex").slice(0, 24);
-}
-function queueLockFilePath(sessionId) {
-  return path4.join(queueBaseDir(), `${queueKeyForSession(sessionId)}.lock`);
-}
-function queueSocketPath(sessionId) {
-  const key = queueKeyForSession(sessionId);
-  if (process.platform === "win32") {
-    return `\\\\.\\pipe\\acpx-${key}`;
+  const cancelled2 = await submitCancelToQueueOwner(owner);
+  if (cancelled2 !== void 0) {
+    if (options.verbose) {
+      process.stderr.write(
+        `[acpx] requested cancel on active owner pid ${owner.pid} for session ${options.sessionId}
+`
+      );
+    }
+    return cancelled2;
   }
-  return path4.join(queueBaseDir(), `${key}.sock`);
-}
-async function ensureQueueDir() {
-  await fs3.mkdir(queueBaseDir(), { recursive: true });
+  if (!await ensureOwnerIsUsable(options.sessionId, owner)) {
+    return void 0;
+  }
+  throw new QueueConnectionError(
+    "Session queue owner is running but not accepting cancel requests",
+    {
+      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+      origin: "queue",
+      retryable: true
+    }
+  );
 }
-async function removeSocketFile(socketPath) {
-  if (process.platform === "win32") {
-    return;
+async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
+  const owner = await readQueueOwnerRecord(sessionId);
+  if (!owner) {
+    return void 0;
   }
-  try {
-    await fs3.unlink(socketPath);
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw error;
+  if (!await ensureOwnerIsUsable(sessionId, owner)) {
+    return void 0;
+  }
+  const submitted = await submitSetModeToQueueOwner(owner, modeId, timeoutMs);
+  if (submitted) {
+    if (verbose) {
+      process.stderr.write(
+        `[acpx] requested session/set_mode on owner pid ${owner.pid} for session ${sessionId}
+`
+      );
     }
+    return true;
   }
-}
-async function readQueueOwnerRecord(sessionId) {
-  const lockPath = queueLockFilePath(sessionId);
-  try {
-    const payload = await fs3.readFile(lockPath, "utf8");
-    const parsed = parseQueueOwnerRecord(JSON.parse(payload));
-    return parsed ?? void 0;
-  } catch {
+  if (!await ensureOwnerIsUsable(sessionId, owner)) {
     return void 0;
   }
-}
-async function cleanupStaleQueueOwner(sessionId, owner) {
-  const lockPath = queueLockFilePath(sessionId);
-  const socketPath = owner?.socketPath ?? queueSocketPath(sessionId);
-  await removeSocketFile(socketPath).catch(() => {
-  });
-  await fs3.unlink(lockPath).catch((error) => {
-    if (error.code !== "ENOENT") {
-      throw error;
+  throw new QueueConnectionError(
+    "Session queue owner is running but not accepting set_mode requests",
+    {
+      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+      origin: "queue",
+      retryable: true
     }
-  });
+  );
 }
-async function tryAcquireQueueOwnerLease(sessionId, nowIso4 = () => (/* @__PURE__ */ new Date()).toISOString()) {
-  await ensureQueueDir();
-  const lockPath = queueLockFilePath(sessionId);
-  const socketPath = queueSocketPath(sessionId);
-  const payload = JSON.stringify(
-    {
-      pid: process.pid,
-      sessionId,
-      socketPath,
-      createdAt: nowIso4()
-    },
-    null,
-    2
+async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, timeoutMs, verbose) {
+  const owner = await readQueueOwnerRecord(sessionId);
+  if (!owner) {
+    return void 0;
+  }
+  if (!await ensureOwnerIsUsable(sessionId, owner)) {
+    return void 0;
+  }
+  const response = await submitSetConfigOptionToQueueOwner(
+    owner,
+    configId,
+    value,
+    timeoutMs
   );
-  try {
-    await fs3.writeFile(lockPath, `${payload}
-`, {
-      encoding: "utf8",
-      flag: "wx"
-    });
-    await removeSocketFile(socketPath).catch(() => {
-    });
-    return { lockPath, socketPath };
-  } catch (error) {
-    if (error.code !== "EEXIST") {
-      throw error;
-    }
-    const owner = await readQueueOwnerRecord(sessionId);
-    if (!owner || !isProcessAlive(owner.pid)) {
-      await cleanupStaleQueueOwner(sessionId, owner);
+  if (response) {
+    if (verbose) {
+      process.stderr.write(
+        `[acpx] requested session/set_config_option on owner pid ${owner.pid} for session ${sessionId}
+`
+      );
     }
+    return response;
+  }
+  if (!await ensureOwnerIsUsable(sessionId, owner)) {
     return void 0;
   }
-}
-async function releaseQueueOwnerLease(lease) {
-  await removeSocketFile(lease.socketPath).catch(() => {
-  });
-  await fs3.unlink(lease.lockPath).catch((error) => {
-    if (error.code !== "ENOENT") {
-      throw error;
+  throw new QueueConnectionError(
+    "Session queue owner is running but not accepting set_config_option requests",
+    {
+      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+      origin: "queue",
+      retryable: true
     }
-  });
-}
-function shouldRetryQueueConnect(error) {
-  const code = error.code;
-  return code === "ENOENT" || code === "ECONNREFUSED";
+  );
 }
-async function waitMs2(ms) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
+
+// src/queue-ipc-server.ts
+import net2 from "net";
+function makeQueueOwnerError(requestId, message, detailCode, options = {}) {
+  return {
+    type: "error",
+    requestId,
+    code: "RUNTIME",
+    detailCode,
+    origin: "queue",
+    retryable: options.retryable,
+    message
+  };
 }
-async function connectToSocket(socketPath) {
-  return await new Promise((resolve, reject) => {
-    const socket = net.createConnection(socketPath);
-    const onConnect = () => {
-      socket.off("error", onError);
-      resolve(socket);
-    };
-    const onError = (error) => {
-      socket.off("connect", onConnect);
-      reject(error);
-    };
-    socket.once("connect", onConnect);
-    socket.once("error", onError);
+function makeQueueOwnerErrorFromUnknown(requestId, error, detailCode, options = {}) {
+  const normalized = normalizeOutputError(error, {
+    defaultCode: "RUNTIME",
+    origin: "queue",
+    detailCode,
+    retryable: options.retryable
   });
-}
-async function connectToQueueOwner(owner) {
-  let lastError;
-  for (let attempt = 0; attempt < QUEUE_CONNECT_ATTEMPTS; attempt += 1) {
-    try {
-      return await connectToSocket(owner.socketPath);
-    } catch (error) {
-      lastError = error;
-      if (!shouldRetryQueueConnect(error)) {
-        throw error;
-      }
-      if (!isProcessAlive(owner.pid)) {
-        return void 0;
-      }
-      await waitMs2(QUEUE_CONNECT_RETRY_MS);
-    }
-  }
-  if (lastError && !shouldRetryQueueConnect(lastError)) {
-    throw lastError;
-  }
-  return void 0;
+  return {
+    type: "error",
+    requestId,
+    code: normalized.code,
+    detailCode: normalized.detailCode,
+    origin: normalized.origin,
+    message: normalized.message,
+    retryable: normalized.retryable,
+    acp: normalized.acp
+  };
 }
 function writeQueueMessage(socket, message) {
   if (socket.destroyed || !socket.writable) {
@@ -3505,7 +4247,7 @@ var SessionQueueOwner = class _SessionQueueOwner {
   }
   static async start(lease, controlHandlers) {
     const ownerRef = { current: void 0 };
-    const server = net.createServer((socket) => {
+    const server = net2.createServer((socket) => {
       ownerRef.current?.handleConnection(socket);
     });
     ownerRef.current = new _SessionQueueOwner(server, controlHandlers);
@@ -3524,557 +4266,238 @@ var SessionQueueOwner = class _SessionQueueOwner {
     });
     return ownerRef.current;
   }
-  async close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    for (const waiter of this.waiters.splice(0)) {
-      waiter(void 0);
-    }
-    for (const task of this.pending.splice(0)) {
-      if (task.waitForCompletion) {
-        task.send(
-          makeQueueOwnerError(
-            task.requestId,
-            "Queue owner shutting down before prompt execution",
-            "QUEUE_OWNER_SHUTTING_DOWN",
-            {
-              retryable: true
-            }
-          )
-        );
-      }
-      task.close();
-    }
-    await new Promise((resolve) => {
-      this.server.close(() => resolve());
-    });
-  }
-  async nextTask(timeoutMs) {
-    if (this.pending.length > 0) {
-      return this.pending.shift();
-    }
-    if (this.closed) {
-      return void 0;
-    }
-    return await new Promise((resolve) => {
-      const shouldTimeout = timeoutMs != null;
-      const timer = shouldTimeout && setTimeout(
-        () => {
-          const index = this.waiters.indexOf(waiter);
-          if (index >= 0) {
-            this.waiters.splice(index, 1);
-          }
-          resolve(void 0);
-        },
-        Math.max(0, timeoutMs)
-      );
-      const waiter = (task) => {
-        if (timer) {
-          clearTimeout(timer);
-        }
-        resolve(task);
-      };
-      this.waiters.push(waiter);
-    });
-  }
-  enqueue(task) {
-    if (this.closed) {
-      if (task.waitForCompletion) {
-        task.send(
-          makeQueueOwnerError(
-            task.requestId,
-            "Queue owner is shutting down",
-            "QUEUE_OWNER_SHUTTING_DOWN",
-            {
-              retryable: true
-            }
-          )
-        );
-      }
-      task.close();
-      return;
-    }
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      waiter(task);
-      return;
-    }
-    this.pending.push(task);
-  }
-  handleConnection(socket) {
-    socket.setEncoding("utf8");
-    if (this.closed) {
-      writeQueueMessage(
-        socket,
-        makeQueueOwnerError("unknown", "Queue owner is closed", "QUEUE_OWNER_CLOSED", {
-          retryable: true
-        })
-      );
-      socket.end();
-      return;
-    }
-    let buffer = "";
-    let handled = false;
-    const fail = (requestId, message, detailCode) => {
-      writeQueueMessage(
-        socket,
-        makeQueueOwnerError(requestId, message, detailCode, {
-          retryable: false
-        })
-      );
-      socket.end();
-    };
-    const processLine = (line) => {
-      if (handled) {
-        return;
-      }
-      handled = true;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        fail(
-          "unknown",
-          "Invalid queue request payload",
-          "QUEUE_REQUEST_PAYLOAD_INVALID_JSON"
-        );
-        return;
-      }
-      const request = parseQueueRequest(parsed);
-      if (!request) {
-        fail("unknown", "Invalid queue request", "QUEUE_REQUEST_INVALID");
-        return;
-      }
-      if (request.type === "cancel_prompt") {
-        writeQueueMessage(socket, {
-          type: "accepted",
-          requestId: request.requestId
-        });
-        void this.controlHandlers.cancelPrompt().then((cancelled2) => {
-          writeQueueMessage(socket, {
-            type: "cancel_result",
-            requestId: request.requestId,
-            cancelled: cancelled2
-          });
-        }).catch((error) => {
-          writeQueueMessage(
-            socket,
-            makeQueueOwnerErrorFromUnknown(
-              request.requestId,
-              error,
-              "QUEUE_CONTROL_REQUEST_FAILED"
-            )
-          );
-        }).finally(() => {
-          if (!socket.destroyed) {
-            socket.end();
-          }
-        });
-        return;
-      }
-      if (request.type === "set_mode") {
-        writeQueueMessage(socket, {
-          type: "accepted",
-          requestId: request.requestId
-        });
-        void this.controlHandlers.setSessionMode(request.modeId, request.timeoutMs).then(() => {
-          writeQueueMessage(socket, {
-            type: "set_mode_result",
-            requestId: request.requestId,
-            modeId: request.modeId
-          });
-        }).catch((error) => {
-          writeQueueMessage(
-            socket,
-            makeQueueOwnerErrorFromUnknown(
-              request.requestId,
-              error,
-              "QUEUE_CONTROL_REQUEST_FAILED"
-            )
-          );
-        }).finally(() => {
-          if (!socket.destroyed) {
-            socket.end();
-          }
-        });
-        return;
-      }
-      if (request.type === "set_config_option") {
-        writeQueueMessage(socket, {
-          type: "accepted",
-          requestId: request.requestId
-        });
-        void this.controlHandlers.setSessionConfigOption(request.configId, request.value, request.timeoutMs).then((response) => {
-          writeQueueMessage(socket, {
-            type: "set_config_option_result",
-            requestId: request.requestId,
-            response
-          });
-        }).catch((error) => {
-          writeQueueMessage(
-            socket,
-            makeQueueOwnerErrorFromUnknown(
-              request.requestId,
-              error,
-              "QUEUE_CONTROL_REQUEST_FAILED"
-            )
-          );
-        }).finally(() => {
-          if (!socket.destroyed) {
-            socket.end();
-          }
-        });
-        return;
-      }
-      const task = {
-        requestId: request.requestId,
-        message: request.message,
-        permissionMode: request.permissionMode,
-        nonInteractivePermissions: request.nonInteractivePermissions,
-        timeoutMs: request.timeoutMs,
-        suppressSdkConsoleErrors: request.suppressSdkConsoleErrors,
-        waitForCompletion: request.waitForCompletion,
-        send: (message) => {
-          writeQueueMessage(socket, message);
-        },
-        close: () => {
-          if (!socket.destroyed) {
-            socket.end();
-          }
-        }
-      };
-      writeQueueMessage(socket, {
-        type: "accepted",
-        requestId: request.requestId
-      });
-      if (!request.waitForCompletion) {
-        task.close();
-      }
-      this.enqueue(task);
-    };
-    socket.on("data", (chunk) => {
-      buffer += chunk;
-      let index = buffer.indexOf("\n");
-      while (index >= 0) {
-        const line = buffer.slice(0, index).trim();
-        buffer = buffer.slice(index + 1);
-        if (line.length > 0) {
-          processLine(line);
-        }
-        index = buffer.indexOf("\n");
-      }
-    });
-    socket.on("error", () => {
-    });
-  }
-};
-async function submitToQueueOwner(owner, options) {
-  const socket = await connectToQueueOwner(owner);
-  if (!socket) {
-    return void 0;
-  }
-  socket.setEncoding("utf8");
-  const requestId = randomUUID2();
-  const request = {
-    type: "submit_prompt",
-    requestId,
-    message: options.message,
-    permissionMode: options.permissionMode,
-    nonInteractivePermissions: options.nonInteractivePermissions,
-    timeoutMs: options.timeoutMs,
-    suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
-    waitForCompletion: options.waitForCompletion
-  };
-  options.outputFormatter.setContext({
-    sessionId: options.sessionId,
-    requestId,
-    stream: "prompt"
-  });
-  return await new Promise((resolve, reject) => {
-    let settled = false;
-    let acknowledged = false;
-    let buffer = "";
-    let sawDone = false;
-    const finishResolve = (result) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      socket.removeAllListeners();
-      if (!socket.destroyed) {
-        socket.end();
-      }
-      resolve(result);
-    };
-    const finishReject = (error) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      socket.removeAllListeners();
-      if (!socket.destroyed) {
-        socket.destroy();
-      }
-      reject(error);
-    };
-    const processLine = (line) => {
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        finishReject(
-          new QueueProtocolError("Queue owner sent invalid JSON payload", {
-            detailCode: "QUEUE_PROTOCOL_INVALID_JSON",
-            origin: "queue",
-            retryable: true
-          })
-        );
-        return;
-      }
-      const message = parseQueueOwnerMessage(parsed);
-      if (!message || message.requestId !== requestId) {
-        finishReject(
-          new QueueProtocolError("Queue owner sent malformed message", {
-            detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
-            origin: "queue",
-            retryable: true
-          })
-        );
-        return;
-      }
-      if (message.type === "accepted") {
-        acknowledged = true;
-        options.outputFormatter.setContext({
-          sessionId: options.sessionId,
-          requestId: message.requestId,
-          stream: "prompt"
-        });
-        if (!options.waitForCompletion) {
-          const queued = {
-            queued: true,
-            sessionId: options.sessionId,
-            requestId
-          };
-          finishResolve(queued);
-        }
-        return;
-      }
-      if (message.type === "error") {
-        options.outputFormatter.setContext({
-          sessionId: options.sessionId,
-          requestId: message.requestId,
-          stream: "prompt"
-        });
-        options.outputFormatter.onError({
-          code: message.code ?? "RUNTIME",
-          detailCode: message.detailCode,
-          origin: message.origin ?? "queue",
-          message: message.message,
-          retryable: message.retryable,
-          acp: message.acp
-        });
-        options.outputFormatter.flush();
-        const queueErrorAlreadyEmitted = options.errorEmissionPolicy?.queueErrorAlreadyEmitted ?? true;
-        finishReject(
-          new QueueConnectionError(message.message, {
-            outputCode: message.code,
-            detailCode: message.detailCode,
-            origin: message.origin ?? "queue",
-            retryable: message.retryable,
-            acp: message.acp,
-            ...queueErrorAlreadyEmitted ? { outputAlreadyEmitted: true } : {}
-          })
-        );
-        return;
-      }
-      if (!acknowledged) {
-        finishReject(
-          new QueueConnectionError("Queue owner did not acknowledge request", {
-            detailCode: "QUEUE_ACK_MISSING",
-            origin: "queue",
-            retryable: true
-          })
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter(void 0);
+    }
+    for (const task of this.pending.splice(0)) {
+      if (task.waitForCompletion) {
+        task.send(
+          makeQueueOwnerError(
+            task.requestId,
+            "Queue owner shutting down before prompt execution",
+            "QUEUE_OWNER_SHUTTING_DOWN",
+            {
+              retryable: true
+            }
+          )
         );
-        return;
-      }
-      if (message.type === "session_update") {
-        options.outputFormatter.onSessionUpdate(message.notification);
-        return;
-      }
-      if (message.type === "client_operation") {
-        options.outputFormatter.onClientOperation(message.operation);
-        return;
-      }
-      if (message.type === "done") {
-        options.outputFormatter.onDone(message.stopReason);
-        sawDone = true;
-        return;
-      }
-      if (message.type === "result") {
-        if (!sawDone) {
-          options.outputFormatter.onDone(message.result.stopReason);
-        }
-        options.outputFormatter.flush();
-        finishResolve(message.result);
-        return;
       }
-      finishReject(
-        new QueueProtocolError("Queue owner returned unexpected response", {
-          detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
-          origin: "queue",
-          retryable: true
-        })
+      task.close();
+    }
+    await new Promise((resolve) => {
+      this.server.close(() => resolve());
+    });
+  }
+  async nextTask(timeoutMs) {
+    if (this.pending.length > 0) {
+      return this.pending.shift();
+    }
+    if (this.closed) {
+      return void 0;
+    }
+    return await new Promise((resolve) => {
+      const shouldTimeout = timeoutMs != null;
+      const timer = shouldTimeout && setTimeout(
+        () => {
+          const index = this.waiters.indexOf(waiter);
+          if (index >= 0) {
+            this.waiters.splice(index, 1);
+          }
+          resolve(void 0);
+        },
+        Math.max(0, timeoutMs)
       );
-    };
-    socket.on("data", (chunk) => {
-      buffer += chunk;
-      let index = buffer.indexOf("\n");
-      while (index >= 0) {
-        const line = buffer.slice(0, index).trim();
-        buffer = buffer.slice(index + 1);
-        if (line.length > 0) {
-          processLine(line);
+      const waiter = (task) => {
+        if (timer) {
+          clearTimeout(timer);
         }
-        index = buffer.indexOf("\n");
-      }
-    });
-    socket.once("error", (error) => {
-      finishReject(error);
+        resolve(task);
+      };
+      this.waiters.push(waiter);
     });
-    socket.once("close", () => {
-      if (settled) {
-        return;
-      }
-      if (!acknowledged) {
-        finishReject(
-          new QueueConnectionError(
-            "Queue owner disconnected before acknowledging request",
+  }
+  queueDepth() {
+    return this.pending.length;
+  }
+  enqueue(task) {
+    if (this.closed) {
+      if (task.waitForCompletion) {
+        task.send(
+          makeQueueOwnerError(
+            task.requestId,
+            "Queue owner is shutting down",
+            "QUEUE_OWNER_SHUTTING_DOWN",
             {
-              detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
-              origin: "queue",
               retryable: true
             }
           )
         );
-        return;
-      }
-      if (!options.waitForCompletion) {
-        const queued = {
-          queued: true,
-          sessionId: options.sessionId,
-          requestId
-        };
-        finishResolve(queued);
-        return;
       }
-      finishReject(
-        new QueueConnectionError("Queue owner disconnected before prompt completion", {
-          detailCode: "QUEUE_DISCONNECTED_BEFORE_COMPLETION",
-          origin: "queue",
+      task.close();
+      return;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter(task);
+      return;
+    }
+    this.pending.push(task);
+  }
+  handleConnection(socket) {
+    socket.setEncoding("utf8");
+    if (this.closed) {
+      writeQueueMessage(
+        socket,
+        makeQueueOwnerError("unknown", "Queue owner is closed", "QUEUE_OWNER_CLOSED", {
           retryable: true
         })
       );
-    });
-    socket.write(`${JSON.stringify(request)}
-`);
-  });
-}
-async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
-  const socket = await connectToQueueOwner(owner);
-  if (!socket) {
-    return void 0;
-  }
-  socket.setEncoding("utf8");
-  return await new Promise((resolve, reject) => {
-    let settled = false;
-    let acknowledged = false;
+      socket.end();
+      return;
+    }
     let buffer = "";
-    const finishResolve = (result) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      socket.removeAllListeners();
-      if (!socket.destroyed) {
-        socket.end();
-      }
-      resolve(result);
+    let handled = false;
+    const fail = (requestId, message, detailCode) => {
+      writeQueueMessage(
+        socket,
+        makeQueueOwnerError(requestId, message, detailCode, {
+          retryable: false
+        })
+      );
+      socket.end();
     };
-    const finishReject = (error) => {
-      if (settled) {
+    const processLine = (line) => {
+      if (handled) {
         return;
       }
-      settled = true;
-      socket.removeAllListeners();
-      if (!socket.destroyed) {
-        socket.destroy();
-      }
-      reject(error);
-    };
-    const processLine = (line) => {
+      handled = true;
       let parsed;
       try {
         parsed = JSON.parse(line);
       } catch {
-        finishReject(
-          new QueueProtocolError("Queue owner sent invalid JSON payload", {
-            detailCode: "QUEUE_PROTOCOL_INVALID_JSON",
-            origin: "queue",
-            retryable: true
-          })
+        fail(
+          "unknown",
+          "Invalid queue request payload",
+          "QUEUE_REQUEST_PAYLOAD_INVALID_JSON"
         );
         return;
       }
-      const message = parseQueueOwnerMessage(parsed);
-      if (!message || message.requestId !== request.requestId) {
-        finishReject(
-          new QueueProtocolError("Queue owner sent malformed message", {
-            detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
-            origin: "queue",
-            retryable: true
-          })
-        );
+      const request = parseQueueRequest(parsed);
+      if (!request) {
+        fail("unknown", "Invalid queue request", "QUEUE_REQUEST_INVALID");
         return;
       }
-      if (message.type === "accepted") {
-        acknowledged = true;
+      if (request.type === "cancel_prompt") {
+        writeQueueMessage(socket, {
+          type: "accepted",
+          requestId: request.requestId
+        });
+        void this.controlHandlers.cancelPrompt().then((cancelled2) => {
+          writeQueueMessage(socket, {
+            type: "cancel_result",
+            requestId: request.requestId,
+            cancelled: cancelled2
+          });
+        }).catch((error) => {
+          writeQueueMessage(
+            socket,
+            makeQueueOwnerErrorFromUnknown(
+              request.requestId,
+              error,
+              "QUEUE_CONTROL_REQUEST_FAILED"
+            )
+          );
+        }).finally(() => {
+          if (!socket.destroyed) {
+            socket.end();
+          }
+        });
         return;
       }
-      if (message.type === "error") {
-        finishReject(
-          new QueueConnectionError(message.message, {
-            outputCode: message.code,
-            detailCode: message.detailCode,
-            origin: message.origin ?? "queue",
-            retryable: message.retryable,
-            acp: message.acp
-          })
-        );
+      if (request.type === "set_mode") {
+        writeQueueMessage(socket, {
+          type: "accepted",
+          requestId: request.requestId
+        });
+        void this.controlHandlers.setSessionMode(request.modeId, request.timeoutMs).then(() => {
+          writeQueueMessage(socket, {
+            type: "set_mode_result",
+            requestId: request.requestId,
+            modeId: request.modeId
+          });
+        }).catch((error) => {
+          writeQueueMessage(
+            socket,
+            makeQueueOwnerErrorFromUnknown(
+              request.requestId,
+              error,
+              "QUEUE_CONTROL_REQUEST_FAILED"
+            )
+          );
+        }).finally(() => {
+          if (!socket.destroyed) {
+            socket.end();
+          }
+        });
         return;
       }
-      if (!acknowledged) {
-        finishReject(
-          new QueueConnectionError("Queue owner did not acknowledge request", {
-            detailCode: "QUEUE_ACK_MISSING",
-            origin: "queue",
-            retryable: true
-          })
-        );
+      if (request.type === "set_config_option") {
+        writeQueueMessage(socket, {
+          type: "accepted",
+          requestId: request.requestId
+        });
+        void this.controlHandlers.setSessionConfigOption(request.configId, request.value, request.timeoutMs).then((response) => {
+          writeQueueMessage(socket, {
+            type: "set_config_option_result",
+            requestId: request.requestId,
+            response
+          });
+        }).catch((error) => {
+          writeQueueMessage(
+            socket,
+            makeQueueOwnerErrorFromUnknown(
+              request.requestId,
+              error,
+              "QUEUE_CONTROL_REQUEST_FAILED"
+            )
+          );
+        }).finally(() => {
+          if (!socket.destroyed) {
+            socket.end();
+          }
+        });
         return;
       }
-      if (!isExpectedResponse(message)) {
-        finishReject(
-          new QueueProtocolError("Queue owner returned unexpected response", {
-            detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
-            origin: "queue",
-            retryable: true
-          })
-        );
-        return;
+      const task = {
+        requestId: request.requestId,
+        message: request.message,
+        permissionMode: request.permissionMode,
+        nonInteractivePermissions: request.nonInteractivePermissions,
+        timeoutMs: request.timeoutMs,
+        suppressSdkConsoleErrors: request.suppressSdkConsoleErrors,
+        waitForCompletion: request.waitForCompletion,
+        send: (message) => {
+          writeQueueMessage(socket, message);
+        },
+        close: () => {
+          if (!socket.destroyed) {
+            socket.end();
+          }
+        }
+      };
+      writeQueueMessage(socket, {
+        type: "accepted",
+        requestId: request.requestId
+      });
+      if (!request.waitForCompletion) {
+        task.close();
       }
-      finishResolve(message);
+      this.enqueue(task);
     };
     socket.on("data", (chunk) => {
       buffer += chunk;
@@ -4088,256 +4511,264 @@ async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
         index = buffer.indexOf("\n");
       }
     });
-    socket.once("error", (error) => {
-      finishReject(error);
-    });
-    socket.once("close", () => {
-      if (settled) {
-        return;
-      }
-      if (!acknowledged) {
-        finishReject(
-          new QueueConnectionError(
-            "Queue owner disconnected before acknowledging request",
-            {
-              detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
-              origin: "queue",
-              retryable: true
-            }
-          )
-        );
-        return;
-      }
-      finishReject(
-        new QueueConnectionError("Queue owner disconnected before responding", {
-          detailCode: "QUEUE_DISCONNECTED_BEFORE_COMPLETION",
-          origin: "queue",
-          retryable: true
-        })
-      );
-    });
-    socket.write(`${JSON.stringify(request)}
-`);
-  });
-}
-async function submitCancelToQueueOwner(owner) {
-  const request = {
-    type: "cancel_prompt",
-    requestId: randomUUID2()
-  };
-  const response = await submitControlToQueueOwner(
-    owner,
-    request,
-    (message) => message.type === "cancel_result"
-  );
-  if (!response) {
-    return void 0;
-  }
-  if (response.requestId !== request.requestId) {
-    throw new QueueProtocolError("Queue owner returned mismatched cancel response", {
-      detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
-      origin: "queue",
-      retryable: true
+    socket.on("error", () => {
     });
   }
-  return response.cancelled;
-}
-async function submitSetModeToQueueOwner(owner, modeId, timeoutMs) {
-  const request = {
-    type: "set_mode",
-    requestId: randomUUID2(),
-    modeId,
-    timeoutMs
-  };
-  const response = await submitControlToQueueOwner(
-    owner,
-    request,
-    (message) => message.type === "set_mode_result"
-  );
-  if (!response) {
-    return void 0;
+};
+
+// src/queue-owner-turn-controller.ts
+var QueueOwnerTurnController = class {
+  options;
+  state = "idle";
+  pendingCancel = false;
+  activeController;
+  constructor(options) {
+    this.options = options;
   }
-  if (response.requestId !== request.requestId) {
-    throw new QueueProtocolError("Queue owner returned mismatched set_mode response", {
-      detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
-      origin: "queue",
-      retryable: true
-    });
+  get lifecycleState() {
+    return this.state;
   }
-  return true;
-}
-async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs) {
-  const request = {
-    type: "set_config_option",
-    requestId: randomUUID2(),
-    configId,
-    value,
-    timeoutMs
-  };
-  const response = await submitControlToQueueOwner(
-    owner,
-    request,
-    (message) => message.type === "set_config_option_result"
-  );
-  if (!response) {
-    return void 0;
+  get hasPendingCancel() {
+    return this.pendingCancel;
   }
-  if (response.requestId !== request.requestId) {
-    throw new QueueProtocolError(
-      "Queue owner returned mismatched set_config_option response",
-      {
-        detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
-        origin: "queue",
-        retryable: true
-      }
-    );
+  beginTurn() {
+    this.state = "starting";
+    this.pendingCancel = false;
   }
-  return response.response;
-}
-async function trySubmitToRunningOwner(options) {
-  const owner = await readQueueOwnerRecord(options.sessionId);
-  if (!owner) {
-    return void 0;
+  markPromptActive() {
+    if (this.state === "starting" || this.state === "active") {
+      this.state = "active";
+    }
   }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(options.sessionId, owner);
-    return void 0;
+  endTurn() {
+    this.state = "idle";
+    this.pendingCancel = false;
   }
-  const submitted = await submitToQueueOwner(owner, options);
-  if (submitted) {
-    if (options.verbose) {
-      process.stderr.write(
-        `[acpx] queued prompt on active owner pid ${owner.pid} for session ${options.sessionId}
-`
-      );
-    }
-    return submitted;
+  beginClosing() {
+    this.state = "closing";
+    this.pendingCancel = false;
+    this.activeController = void 0;
   }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(options.sessionId, owner);
-    return void 0;
+  setActiveController(controller) {
+    this.activeController = controller;
   }
-  throw new QueueConnectionError(
-    "Session queue owner is running but not accepting queue requests",
-    {
-      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
-      origin: "queue",
-      retryable: true
+  clearActiveController() {
+    this.activeController = void 0;
+  }
+  assertCanHandleControlRequest() {
+    if (this.state === "closing") {
+      throw new QueueConnectionError("Queue owner is closing", {
+        detailCode: "QUEUE_OWNER_SHUTTING_DOWN",
+        origin: "queue",
+        retryable: true
+      });
     }
-  );
-}
-async function tryCancelOnRunningOwner(options) {
-  const owner = await readQueueOwnerRecord(options.sessionId);
-  if (!owner) {
-    return void 0;
   }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(options.sessionId, owner);
-    return void 0;
+  async requestCancel() {
+    const activeController = this.activeController;
+    if (activeController?.hasActivePrompt()) {
+      const cancelled2 = await activeController.requestCancelActivePrompt();
+      if (cancelled2) {
+        this.pendingCancel = false;
+      }
+      return cancelled2;
+    }
+    if (this.state === "starting" || this.state === "active") {
+      this.pendingCancel = true;
+      return true;
+    }
+    return false;
   }
-  const cancelled2 = await submitCancelToQueueOwner(owner);
-  if (cancelled2 !== void 0) {
-    if (options.verbose) {
-      process.stderr.write(
-        `[acpx] requested cancel on active owner pid ${owner.pid} for session ${options.sessionId}
-`
-      );
+  async applyPendingCancel() {
+    const activeController = this.activeController;
+    if (!this.pendingCancel || !activeController || !activeController.hasActivePrompt()) {
+      return false;
+    }
+    const cancelled2 = await activeController.requestCancelActivePrompt();
+    if (cancelled2) {
+      this.pendingCancel = false;
     }
     return cancelled2;
   }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(options.sessionId, owner);
-    return void 0;
-  }
-  throw new QueueConnectionError(
-    "Session queue owner is running but not accepting cancel requests",
-    {
-      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
-      origin: "queue",
-      retryable: true
+  async setSessionMode(modeId, timeoutMs) {
+    this.assertCanHandleControlRequest();
+    const activeController = this.activeController;
+    if (activeController) {
+      await this.options.withTimeout(
+        async () => await activeController.setSessionMode(modeId),
+        timeoutMs
+      );
+      return;
     }
-  );
-}
-async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
-  const owner = await readQueueOwnerRecord(sessionId);
-  if (!owner) {
-    return void 0;
-  }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(sessionId, owner);
-    return void 0;
+    await this.options.setSessionModeFallback(modeId, timeoutMs);
   }
-  const submitted = await submitSetModeToQueueOwner(owner, modeId, timeoutMs);
-  if (submitted) {
-    if (verbose) {
-      process.stderr.write(
-        `[acpx] requested session/set_mode on owner pid ${owner.pid} for session ${sessionId}
-`
+  async setSessionConfigOption(configId, value, timeoutMs) {
+    this.assertCanHandleControlRequest();
+    const activeController = this.activeController;
+    if (activeController) {
+      return await this.options.withTimeout(
+        async () => await activeController.setSessionConfigOption(configId, value),
+        timeoutMs
       );
     }
-    return true;
-  }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(sessionId, owner);
-    return void 0;
+    return await this.options.setSessionConfigOptionFallback(
+      configId,
+      value,
+      timeoutMs
+    );
   }
-  throw new QueueConnectionError(
-    "Session queue owner is running but not accepting set_mode requests",
-    {
-      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
-      origin: "queue",
-      retryable: true
-    }
-  );
-}
-async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, timeoutMs, verbose) {
-  const owner = await readQueueOwnerRecord(sessionId);
-  if (!owner) {
-    return void 0;
+};
+
+// src/session-owner-runtime.ts
+var DEFAULT_QUEUE_OWNER_TTL_MS = 3e5;
+var QUEUE_OWNER_HEARTBEAT_INTERVAL_MS = 2e3;
+function normalizeQueueOwnerTtlMs(ttlMs) {
+  if (ttlMs == null) {
+    return DEFAULT_QUEUE_OWNER_TTL_MS;
   }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(sessionId, owner);
-    return void 0;
+  if (!Number.isFinite(ttlMs) || ttlMs < 0) {
+    return DEFAULT_QUEUE_OWNER_TTL_MS;
   }
-  const response = await submitSetConfigOptionToQueueOwner(
-    owner,
-    configId,
-    value,
-    timeoutMs
-  );
-  if (response) {
-    if (verbose) {
+  return Math.round(ttlMs);
+}
+function createQueueOwnerTurnRuntime(options, deps) {
+  const turnController = new QueueOwnerTurnController({
+    withTimeout: async (run, timeoutMs) => await deps.withTimeout(run, timeoutMs),
+    setSessionModeFallback: deps.setSessionModeFallback,
+    setSessionConfigOptionFallback: deps.setSessionConfigOptionFallback
+  });
+  const applyPendingCancel = async () => {
+    return await turnController.applyPendingCancel();
+  };
+  const scheduleApplyPendingCancel = () => {
+    void applyPendingCancel().catch((error) => {
+      if (options.verbose) {
+        process.stderr.write(
+          `[acpx] failed to apply deferred cancel: ${formatErrorMessage(error)}
+`
+        );
+      }
+    });
+  };
+  return {
+    beginClosing: () => {
+      turnController.beginClosing();
+    },
+    onClientAvailable: (controller) => {
+      turnController.setActiveController(controller);
+      scheduleApplyPendingCancel();
+    },
+    onClientClosed: () => {
+      turnController.clearActiveController();
+    },
+    onPromptActive: async () => {
+      turnController.markPromptActive();
+      await applyPendingCancel();
+    },
+    runPromptTurn: async (run) => {
+      turnController.beginTurn();
+      try {
+        return await run();
+      } finally {
+        turnController.endTurn();
+      }
+    },
+    controlHandlers: {
+      cancelPrompt: async () => {
+        const accepted = await turnController.requestCancel();
+        if (!accepted) {
+          return false;
+        }
+        await applyPendingCancel();
+        return true;
+      },
+      setSessionMode: async (modeId, timeoutMs) => {
+        await turnController.setSessionMode(modeId, timeoutMs);
+      },
+      setSessionConfigOption: async (configId, value, timeoutMs) => {
+        return await turnController.setSessionConfigOption(configId, value, timeoutMs);
+      }
+    }
+  };
+}
+async function runQueueOwnerProcess(options, deps) {
+  const queueOwnerTtlMs = normalizeQueueOwnerTtlMs(options.ttlMs);
+  const lease = await tryAcquireQueueOwnerLease(options.sessionId);
+  if (!lease) {
+    if (options.verbose) {
       process.stderr.write(
-        `[acpx] requested session/set_config_option on owner pid ${owner.pid} for session ${sessionId}
+        `[acpx] queue owner already active for session ${options.sessionId}; skipping spawn
 `
       );
     }
-    return response;
-  }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(sessionId, owner);
-    return void 0;
-  }
-  throw new QueueConnectionError(
-    "Session queue owner is running but not accepting set_config_option requests",
-    {
-      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
-      origin: "queue",
-      retryable: true
-    }
-  );
-}
-async function terminateQueueOwnerForSession(sessionId) {
-  const owner = await readQueueOwnerRecord(sessionId);
-  if (!owner) {
     return;
   }
-  if (isProcessAlive(owner.pid)) {
-    await terminateProcess(owner.pid);
+  const runtime = createQueueOwnerTurnRuntime(options, deps);
+  let owner;
+  let heartbeatTimer;
+  const refreshHeartbeat = async () => {
+    if (!owner) {
+      return;
+    }
+    await refreshQueueOwnerLease(lease, {
+      queueDepth: owner.queueDepth()
+    }).catch((error) => {
+      if (options.verbose) {
+        process.stderr.write(
+          `[acpx] queue owner heartbeat update failed: ${formatErrorMessage(error)}
+`
+        );
+      }
+    });
+  };
+  try {
+    owner = await SessionQueueOwner.start(lease, runtime.controlHandlers);
+    await refreshHeartbeat();
+    heartbeatTimer = setInterval(() => {
+      void refreshHeartbeat();
+    }, QUEUE_OWNER_HEARTBEAT_INTERVAL_MS);
+    heartbeatTimer.unref();
+    const idleWaitMs = queueOwnerTtlMs === 0 ? void 0 : Math.max(0, queueOwnerTtlMs);
+    while (true) {
+      const task = await owner.nextTask(idleWaitMs);
+      if (!task) {
+        if (queueOwnerTtlMs > 0 && options.verbose) {
+          process.stderr.write(
+            `[acpx] queue owner TTL expired after ${Math.round(queueOwnerTtlMs / 1e3)}s for session ${options.sessionId}; shutting down
+`
+          );
+        }
+        break;
+      }
+      await runtime.runPromptTurn(async () => {
+        await deps.runQueuedTask(options.sessionId, task, {
+          verbose: options.verbose,
+          nonInteractivePermissions: options.nonInteractivePermissions,
+          authCredentials: options.authCredentials,
+          authPolicy: options.authPolicy,
+          suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+          onClientAvailable: runtime.onClientAvailable,
+          onClientClosed: runtime.onClientClosed,
+          onPromptActive: runtime.onPromptActive
+        });
+      });
+      await refreshHeartbeat();
+    }
+  } finally {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+    }
+    runtime.beginClosing();
+    if (owner) {
+      await owner.close();
+    }
+    await releaseQueueOwnerLease(lease);
   }
-  await cleanupStaleQueueOwner(sessionId, owner);
 }
 
+// src/session-owner-spawn.ts
+import { spawn as spawn3 } from "child_process";
+
 // src/session-persistence.ts
 import { statSync } from "fs";
 import fs4 from "fs/promises";
@@ -4586,6 +5017,124 @@ async function findSessionByDirectoryWalk(options) {
   }
 }
 
+// src/session-owner-spawn.ts
+var QUEUE_OWNER_STARTUP_TIMEOUT_MS = 1e4;
+var QUEUE_OWNER_RESPAWN_BACKOFF_MS = 250;
+function isQueueNotAcceptingError(error) {
+  return error instanceof QueueConnectionError && error.detailCode === "QUEUE_NOT_ACCEPTING_REQUESTS";
+}
+function spawnDetachedQueueOwner(ownerSpawn) {
+  const child = spawn3(ownerSpawn.command, ownerSpawn.args, {
+    cwd: ownerSpawn.cwd,
+    env: ownerSpawn.env,
+    stdio: "ignore",
+    detached: true
+  });
+  child.unref();
+}
+async function buildDefaultQueueOwnerSpawn(options, queueOwnerTtlMs) {
+  const entrypoint = process.argv[1];
+  if (!entrypoint) {
+    throw new Error("Cannot spawn queue owner process: CLI entrypoint is missing");
+  }
+  const record = await resolveSessionRecord(options.sessionId);
+  const args = [
+    entrypoint,
+    "__queue-owner",
+    "--session-id",
+    options.sessionId,
+    "--ttl-ms",
+    String(queueOwnerTtlMs),
+    "--permission-mode",
+    options.permissionMode
+  ];
+  if (options.nonInteractivePermissions) {
+    args.push("--non-interactive-permissions", options.nonInteractivePermissions);
+  }
+  if (options.authPolicy) {
+    args.push("--auth-policy", options.authPolicy);
+  }
+  if (options.timeoutMs != null && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0) {
+    args.push("--timeout-ms", String(Math.round(options.timeoutMs)));
+  }
+  if (options.verbose) {
+    args.push("--verbose");
+  }
+  if (options.suppressSdkConsoleErrors) {
+    args.push("--suppress-sdk-console-errors");
+  }
+  return {
+    command: process.execPath,
+    args,
+    cwd: absolutePath(record.cwd)
+  };
+}
+async function sendViaDetachedQueueOwner(options) {
+  const waitForCompletion = options.waitForCompletion !== false;
+  const queueOwnerTtlMs = normalizeQueueOwnerTtlMs(options.ttlMs);
+  const ownerSpawn = options.queueOwnerSpawn ?? await buildDefaultQueueOwnerSpawn(options, queueOwnerTtlMs);
+  const startupDeadline = Date.now() + QUEUE_OWNER_STARTUP_TIMEOUT_MS;
+  let lastSpawnAttemptAt = 0;
+  for (; ; ) {
+    try {
+      const queuedToOwner = await trySubmitToRunningOwner({
+        sessionId: options.sessionId,
+        message: options.message,
+        permissionMode: options.permissionMode,
+        nonInteractivePermissions: options.nonInteractivePermissions,
+        outputFormatter: options.outputFormatter,
+        errorEmissionPolicy: options.errorEmissionPolicy,
+        timeoutMs: options.timeoutMs,
+        suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+        waitForCompletion,
+        verbose: options.verbose
+      });
+      if (queuedToOwner) {
+        return queuedToOwner;
+      }
+    } catch (error) {
+      if (!isQueueNotAcceptingError(error)) {
+        throw error;
+      }
+      if (Date.now() >= startupDeadline) {
+        throw new QueueConnectionError(
+          "Timed out waiting for detached queue owner to accept prompt requests",
+          {
+            detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+            origin: "queue",
+            retryable: true,
+            cause: error instanceof Error ? error : void 0
+          }
+        );
+      }
+      await waitMs2(QUEUE_CONNECT_RETRY_MS);
+      continue;
+    }
+    const now = Date.now();
+    if (now >= startupDeadline) {
+      throw new QueueConnectionError(
+        "Timed out waiting for detached queue owner to start",
+        {
+          detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+          origin: "queue",
+          retryable: true
+        }
+      );
+    }
+    if (now - lastSpawnAttemptAt >= QUEUE_OWNER_RESPAWN_BACKOFF_MS) {
+      spawnDetachedQueueOwner(ownerSpawn);
+      lastSpawnAttemptAt = now;
+      if (options.verbose) {
+        process.stderr.write(
+          `[acpx] starting detached queue owner for session ${options.sessionId}
+`
+        );
+      }
+    }
+    await waitMs2(QUEUE_CONNECT_RETRY_MS);
+  }
+}
+
 // src/session-runtime-history.ts
 var SESSION_HISTORY_MAX_ENTRIES = 500;
 var SESSION_HISTORY_PREVIEW_CHARS = 220;
@@ -4774,7 +5323,6 @@ async function connectAndLoadSession(options) {
 }
 
 // src/session-runtime.ts
-var DEFAULT_QUEUE_OWNER_TTL_MS = 3e5;
 var INTERRUPT_CANCEL_WAIT_MS = 2500;
 var TimeoutError = class extends Error {
   constructor(timeoutMs) {
@@ -4902,15 +5450,6 @@ var DISCARD_OUTPUT_FORMATTER = {
   flush() {
   }
 };
-function normalizeQueueOwnerTtlMs(ttlMs) {
-  if (ttlMs == null) {
-    return DEFAULT_QUEUE_OWNER_TTL_MS;
-  }
-  if (!Number.isFinite(ttlMs) || ttlMs < 0) {
-    return DEFAULT_QUEUE_OWNER_TTL_MS;
-  }
-  return Math.round(ttlMs);
-}
 function shouldFallbackToNewSession(error) {
   if (error instanceof TimeoutError || error instanceof InterruptedError) {
     return false;
@@ -5376,179 +5915,41 @@ async function ensureSession(options) {
     created: true
   };
 }
-async function sendSession(options) {
-  const waitForCompletion = options.waitForCompletion !== false;
-  const queueOwnerTtlMs = normalizeQueueOwnerTtlMs(options.ttlMs);
-  const queuedToOwner = await trySubmitToRunningOwner({
-    sessionId: options.sessionId,
-    message: options.message,
-    permissionMode: options.permissionMode,
-    nonInteractivePermissions: options.nonInteractivePermissions,
-    outputFormatter: options.outputFormatter,
-    errorEmissionPolicy: options.errorEmissionPolicy,
-    timeoutMs: options.timeoutMs,
-    suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
-    waitForCompletion,
-    verbose: options.verbose
-  });
-  if (queuedToOwner) {
-    return queuedToOwner;
-  }
-  for (; ; ) {
-    const lease = await tryAcquireQueueOwnerLease(options.sessionId);
-    if (!lease) {
-      const retryQueued = await trySubmitToRunningOwner({
-        sessionId: options.sessionId,
-        message: options.message,
-        permissionMode: options.permissionMode,
+async function runQueueOwnerProcess2(options) {
+  await runQueueOwnerProcess(options, {
+    runQueuedTask,
+    withTimeout: async (run, timeoutMs) => await withTimeout(run(), timeoutMs),
+    setSessionModeFallback: async (modeId, timeoutMs) => {
+      await runSessionSetModeDirect({
+        sessionRecordId: options.sessionId,
+        modeId,
         nonInteractivePermissions: options.nonInteractivePermissions,
-        outputFormatter: options.outputFormatter,
-        errorEmissionPolicy: options.errorEmissionPolicy,
-        timeoutMs: options.timeoutMs,
-        suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
-        waitForCompletion,
+        authCredentials: options.authCredentials,
+        authPolicy: options.authPolicy,
+        timeoutMs,
         verbose: options.verbose
       });
-      if (retryQueued) {
-        return retryQueued;
-      }
-      await waitMs2(QUEUE_CONNECT_RETRY_MS);
-      continue;
-    }
-    let owner;
-    const turnController = new QueueOwnerTurnController({
-      withTimeout: async (run, timeoutMs) => await withTimeout(run(), timeoutMs),
-      setSessionModeFallback: async (modeId, timeoutMs) => {
-        await runSessionSetModeDirect({
-          sessionRecordId: options.sessionId,
-          modeId,
-          nonInteractivePermissions: options.nonInteractivePermissions,
-          authCredentials: options.authCredentials,
-          authPolicy: options.authPolicy,
-          timeoutMs,
-          verbose: options.verbose
-        });
-      },
-      setSessionConfigOptionFallback: async (configId, value, timeoutMs) => {
-        const result = await runSessionSetConfigOptionDirect({
-          sessionRecordId: options.sessionId,
-          configId,
-          value,
-          nonInteractivePermissions: options.nonInteractivePermissions,
-          authCredentials: options.authCredentials,
-          authPolicy: options.authPolicy,
-          timeoutMs,
-          verbose: options.verbose
-        });
-        return result.response;
-      }
-    });
-    const applyPendingCancel = async () => {
-      return await turnController.applyPendingCancel();
-    };
-    const scheduleApplyPendingCancel = () => {
-      void applyPendingCancel().catch((error) => {
-        if (options.verbose) {
-          process.stderr.write(
-            `[acpx] failed to apply deferred cancel: ${formatErrorMessage(error)}
-`
-          );
-        }
-      });
-    };
-    const setActiveController = (controller) => {
-      turnController.setActiveController(controller);
-      scheduleApplyPendingCancel();
-    };
-    const clearActiveController = () => {
-      turnController.clearActiveController();
-    };
-    const runPromptTurn = async (run) => {
-      turnController.beginTurn();
-      try {
-        return await run();
-      } finally {
-        turnController.endTurn();
-      }
-    };
-    try {
-      owner = await SessionQueueOwner.start(lease, {
-        cancelPrompt: async () => {
-          const accepted = await turnController.requestCancel();
-          if (!accepted) {
-            return false;
-          }
-          await applyPendingCancel();
-          return true;
-        },
-        setSessionMode: async (modeId, timeoutMs) => {
-          await turnController.setSessionMode(modeId, timeoutMs);
-        },
-        setSessionConfigOption: async (configId, value, timeoutMs) => {
-          return await turnController.setSessionConfigOption(
-            configId,
-            value,
-            timeoutMs
-          );
-        }
-      });
-      const localResult = await runPromptTurn(async () => {
-        return await runSessionPrompt({
-          sessionRecordId: options.sessionId,
-          message: options.message,
-          permissionMode: options.permissionMode,
-          nonInteractivePermissions: options.nonInteractivePermissions,
-          authCredentials: options.authCredentials,
-          authPolicy: options.authPolicy,
-          outputFormatter: options.outputFormatter,
-          timeoutMs: options.timeoutMs,
-          suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
-          verbose: options.verbose,
-          onClientAvailable: setActiveController,
-          onClientClosed: clearActiveController,
-          onPromptActive: async () => {
-            turnController.markPromptActive();
-            await applyPendingCancel();
-          }
-        });
+    },
+    setSessionConfigOptionFallback: async (configId, value, timeoutMs) => {
+      const result = await runSessionSetConfigOptionDirect({
+        sessionRecordId: options.sessionId,
+        configId,
+        value,
+        nonInteractivePermissions: options.nonInteractivePermissions,
+        authCredentials: options.authCredentials,
+        authPolicy: options.authPolicy,
+        timeoutMs,
+        verbose: options.verbose
       });
-      const idleWaitMs = queueOwnerTtlMs === 0 ? void 0 : Math.max(0, queueOwnerTtlMs);
-      while (true) {
-        const task = await owner.nextTask(idleWaitMs);
-        if (!task) {
-          if (queueOwnerTtlMs > 0 && options.verbose) {
-            process.stderr.write(
-              `[acpx] queue owner TTL expired after ${Math.round(queueOwnerTtlMs / 1e3)}s for session ${options.sessionId}; shutting down
-`
-            );
-          }
-          break;
-        }
-        await runPromptTurn(async () => {
-          await runQueuedTask(options.sessionId, task, {
-            verbose: options.verbose,
-            nonInteractivePermissions: options.nonInteractivePermissions,
-            authCredentials: options.authCredentials,
-            authPolicy: options.authPolicy,
-            suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
-            onClientAvailable: setActiveController,
-            onClientClosed: clearActiveController,
-            onPromptActive: async () => {
-              turnController.markPromptActive();
-              await applyPendingCancel();
-            }
-          });
-        });
-      }
-      return localResult;
-    } finally {
-      turnController.beginClosing();
-      if (owner) {
-        await owner.close();
-      }
-      await releaseQueueOwnerLease(lease);
+      return result.response;
     }
-  }
+  });
+}
+async function sendSession(options) {
+  return await sendViaDetachedQueueOwner(options);
+}
+async function readSessionQueueOwnerStatus(sessionId) {
+  return await readQueueOwnerStatus(sessionId);
 }
 async function cancelSessionPrompt(options) {
   const cancelled2 = await tryCancelOnRunningOwner(options);
@@ -5654,6 +6055,7 @@ var NoSessionError = class extends Error {
   }
 };
 var TOP_LEVEL_VERBS = /* @__PURE__ */ new Set([
+  "__queue-owner",
   "prompt",
   "exec",
   "cancel",
@@ -5666,25 +6068,25 @@ var TOP_LEVEL_VERBS = /* @__PURE__ */ new Set([
 ]);
 function parseOutputFormat2(value) {
   if (!OUTPUT_FORMATS.includes(value)) {
-    throw new InvalidArgumentError(
+    throw new InvalidArgumentError3(
       `Invalid format "${value}". Expected one of: ${OUTPUT_FORMATS.join(", ")}`
     );
   }
   return value;
 }
-function parseAuthPolicy2(value) {
+function parseAuthPolicy3(value) {
   if (!AUTH_POLICIES.includes(value)) {
-    throw new InvalidArgumentError(
+    throw new InvalidArgumentError3(
       `Invalid auth policy "${value}". Expected one of: ${AUTH_POLICIES.join(", ")}`
     );
   }
   return value;
 }
-function parseNonInteractivePermissionPolicy2(value) {
+function parseNonInteractivePermissionPolicy3(value) {
   if (!NON_INTERACTIVE_PERMISSION_POLICIES.includes(
     value
   )) {
-    throw new InvalidArgumentError(
+    throw new InvalidArgumentError3(
       `Invalid non-interactive permission policy "${value}". Expected one of: ${NON_INTERACTIVE_PERMISSION_POLICIES.join(", ")}`
     );
   }
@@ -5693,35 +6095,35 @@ function parseNonInteractivePermissionPolicy2(value) {
 function parseTimeoutSeconds(value) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new InvalidArgumentError("Timeout must be a positive number of seconds");
+    throw new InvalidArgumentError3("Timeout must be a positive number of seconds");
   }
   return Math.round(parsed * 1e3);
 }
 function parseTtlSeconds(value) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed) || parsed < 0) {
-    throw new InvalidArgumentError("TTL must be a non-negative number of seconds");
+    throw new InvalidArgumentError3("TTL must be a non-negative number of seconds");
   }
   return Math.round(parsed * 1e3);
 }
 function parseSessionName(value) {
   const trimmed = value.trim();
   if (trimmed.length === 0) {
-    throw new InvalidArgumentError("Session name must not be empty");
+    throw new InvalidArgumentError3("Session name must not be empty");
   }
   return trimmed;
 }
-function parseNonEmptyValue(label, value) {
+function parseNonEmptyValue2(label, value) {
   const trimmed = value.trim();
   if (trimmed.length === 0) {
-    throw new InvalidArgumentError(`${label} must not be empty`);
+    throw new InvalidArgumentError3(`${label} must not be empty`);
   }
   return trimmed;
 }
 function parseHistoryLimit(value) {
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw new InvalidArgumentError("Limit must be a positive integer");
+    throw new InvalidArgumentError3("Limit must be a positive integer");
   }
   return parsed;
 }
@@ -5730,7 +6132,7 @@ function resolvePermissionMode(flags, defaultMode) {
     Boolean
   ).length;
   if (selected2 > 1) {
-    throw new InvalidArgumentError(
+    throw new InvalidArgumentError3(
       "Use only one permission mode: --approve-all, --approve-reads, or --deny-all"
     );
   }
@@ -5757,7 +6159,7 @@ async function readPrompt(promptParts, filePath, cwd) {
     );
     const prompt2 = pieces.join("\n\n").trim();
     if (!prompt2) {
-      throw new InvalidArgumentError("Prompt from --file is empty");
+      throw new InvalidArgumentError3("Prompt from --file is empty");
     }
     return prompt2;
   }
@@ -5766,13 +6168,13 @@ async function readPrompt(promptParts, filePath, cwd) {
     return joined;
   }
   if (process.stdin.isTTY) {
-    throw new InvalidArgumentError(
+    throw new InvalidArgumentError3(
       "Prompt is required (pass as argument, --file, or pipe via stdin)"
     );
   }
   const prompt = (await readPromptInputFromStdin()).trim();
   if (!prompt) {
-    throw new InvalidArgumentError("Prompt from stdin is empty");
+    throw new InvalidArgumentError3("Prompt from stdin is empty");
   }
   return prompt;
 }
@@ -5787,14 +6189,14 @@ function addGlobalFlags(command) {
   return command.option("--agent <command>", "Raw ACP agent command (escape hatch)").option("--cwd <dir>", "Working directory", process.cwd()).option(
     "--auth-policy <policy>",
     "Authentication policy: skip or fail when auth is required",
-    parseAuthPolicy2
+    parseAuthPolicy3
   ).option("--approve-all", "Auto-approve all permission requests").option(
     "--approve-reads",
     "Auto-approve read/search requests and prompt for writes"
   ).option("--deny-all", "Deny all permission requests").option(
     "--non-interactive-permissions <policy>",
     "When prompting is unavailable: deny or fail",
-    parseNonInteractivePermissionPolicy2
+    parseNonInteractivePermissionPolicy3
   ).option("--format <fmt>", "Output format: text, json, quiet", parseOutputFormat2).option(
     "--json-strict",
     "Strict JSON mode: requires --format json and suppresses non-JSON stderr output"
@@ -5851,10 +6253,10 @@ function resolveGlobalFlags(command, config) {
   const jsonStrict = opts.jsonStrict === true;
   const verbose = opts.verbose === true;
   if (jsonStrict && format !== "json") {
-    throw new InvalidArgumentError("--json-strict requires --format json");
+    throw new InvalidArgumentError3("--json-strict requires --format json");
   }
   if (jsonStrict && verbose) {
-    throw new InvalidArgumentError("--json-strict cannot be combined with --verbose");
+    throw new InvalidArgumentError3("--json-strict cannot be combined with --verbose");
   }
   return {
     agent: opts.agent,
@@ -5883,7 +6285,7 @@ function resolveOutputPolicy(format, jsonStrict) {
 function resolveAgentInvocation(explicitAgentName, globalFlags, config) {
   const override = globalFlags.agent?.trim();
   if (override && explicitAgentName) {
-    throw new InvalidArgumentError(
+    throw new InvalidArgumentError3(
       "Do not combine positional agent with --agent override"
     );
   }
@@ -6561,7 +6963,12 @@ async function handleStatus(explicitAgentName, flags, command, config) {
       uptime: null,
       lastPromptTime: null,
       exitCode: null,
-      signal: null
+      signal: null,
+      ownerPid: null,
+      ownerStatus: null,
+      ownerGeneration: null,
+      ownerHeartbeatAt: null,
+      ownerQueueDepth: null
     };
     if (globalFlags.format === "json") {
       process.stdout.write(`${JSON.stringify(payload2)}
@@ -6583,10 +6990,14 @@ async function handleStatus(explicitAgentName, flags, command, config) {
     process.stdout.write(`uptime: -
 `);
     process.stdout.write(`lastPromptTime: -
+`);
+    process.stdout.write(`ownerStatus: -
 `);
     return;
   }
   const running = isProcessAlive(record.pid);
+  const owner = await readSessionQueueOwnerStatus(record.id);
+  const ownerStatus = owner ? owner.stale ? "stale" : "active" : "inactive";
   const payload = {
     ...canonicalSessionIdentity(record),
     agentCommand: record.agentCommand,
@@ -6595,7 +7006,12 @@ async function handleStatus(explicitAgentName, flags, command, config) {
     uptime: running ? formatUptime(record.agentStartedAt) ?? null : null,
     lastPromptTime: record.lastPromptAt ?? null,
     exitCode: running ? null : record.lastAgentExitCode ?? null,
-    signal: running ? null : record.lastAgentExitSignal ?? null
+    signal: running ? null : record.lastAgentExitSignal ?? null,
+    ownerPid: owner?.pid ?? null,
+    ownerStatus,
+    ownerGeneration: owner?.ownerGeneration ?? null,
+    ownerHeartbeatAt: owner?.heartbeatAt ?? null,
+    ownerQueueDepth: owner?.queueDepth ?? null
   };
   if (globalFlags.format === "json") {
     process.stdout.write(`${JSON.stringify(payload)}
@@ -6622,6 +7038,16 @@ async function handleStatus(explicitAgentName, flags, command, config) {
   process.stdout.write(`uptime: ${payload.uptime ?? "-"}
 `);
   process.stdout.write(`lastPromptTime: ${payload.lastPromptTime ?? "-"}
+`);
+  process.stdout.write(`ownerStatus: ${payload.ownerStatus}
+`);
+  process.stdout.write(`ownerPid: ${payload.ownerPid ?? "-"}
+`);
+  process.stdout.write(`ownerGeneration: ${payload.ownerGeneration ?? "-"}
+`);
+  process.stdout.write(`ownerHeartbeatAt: ${payload.ownerHeartbeatAt ?? "-"}
+`);
+  process.stdout.write(`ownerQueueDepth: ${payload.ownerQueueDepth ?? "-"}
 `);
   if (payload.status === "dead") {
     process.stdout.write(`exitCode: ${payload.exitCode ?? "-"}
@@ -6726,7 +7152,7 @@ function registerSharedAgentSubcommands(parent, explicitAgentName, config, descr
   const setModeCommand = parent.command("set-mode").description(descriptions.setMode).argument(
     "<mode>",
     "Mode id",
-    (value) => parseNonEmptyValue("Mode", value)
+    (value) => parseNonEmptyValue2("Mode", value)
   );
   addSessionNameOption(setModeCommand);
   setModeCommand.action(async function(modeId, flags) {
@@ -6735,11 +7161,11 @@ function registerSharedAgentSubcommands(parent, explicitAgentName, config, descr
   const setConfigCommand = parent.command("set").description(descriptions.setConfig).argument(
     "<key>",
     "Config option id",
-    (value) => parseNonEmptyValue("Config option key", value)
+    (value) => parseNonEmptyValue2("Config option key", value)
   ).argument(
     "<value>",
     "Config option value",
-    (value) => parseNonEmptyValue("Config option value", value)
+    (value) => parseNonEmptyValue2("Config option value", value)
   );
   addSessionNameOption(setConfigCommand);
   setConfigCommand.action(async function(key, value, flags) {
@@ -6934,7 +7360,10 @@ async function main(argv = process.argv) {
     requestedOutputFormat,
     requestedJsonStrict
   );
-  const builtInAgents = listBuiltInAgents(config.agents);
+  const internalQueueOwnerFlags = parseQueueOwnerFlags(
+    argv.slice(2),
+    DEFAULT_QUEUE_OWNER_TTL_MS
+  );
   const program = new Command();
   program.name("acpx").description("Headless CLI client for the Agent Client Protocol").enablePositionalOptions().showHelpAfterError();
   if (requestedJsonStrict) {
@@ -6946,56 +7375,39 @@ async function main(argv = process.argv) {
     });
   }
   addGlobalFlags(program);
-  for (const agentName of builtInAgents) {
-    registerAgentCommand(program, agentName, config);
-  }
-  registerDefaultCommands(program, config);
-  const scan = detectAgentToken(argv.slice(2));
-  if (!scan.hasAgentOverride && scan.token && !TOP_LEVEL_VERBS.has(scan.token) && !builtInAgents.includes(scan.token)) {
-    registerAgentCommand(program, scan.token, config);
-  }
-  program.argument("[prompt...]", "Prompt text").action(async function(promptParts) {
-    if (promptParts.length === 0 && process.stdin.isTTY) {
-      if (requestedJsonStrict) {
-        throw new InvalidArgumentError(
-          "Prompt is required (pass as argument, --file, or pipe via stdin)"
-        );
-      }
-      this.outputHelp();
-      return;
+  configurePublicCli({
+    program,
+    argv: argv.slice(2),
+    config,
+    requestedJsonStrict,
+    topLevelVerbs: TOP_LEVEL_VERBS,
+    listBuiltInAgents,
+    detectAgentToken,
+    registerAgentCommand,
+    registerDefaultCommands,
+    handlePromptAction: async (command, promptParts) => {
+      await handlePrompt(void 0, promptParts, {}, command, config);
     }
-    await handlePrompt(void 0, promptParts, {}, this, config);
   });
-  program.addHelpText(
-    "after",
-    `
-Examples:
-  acpx codex sessions new
-  acpx codex "fix the tests"
-  acpx codex prompt "fix the tests"
-  acpx codex --no-wait "queue follow-up task"
-  acpx codex exec "what does this repo do"
-  acpx codex cancel
-  acpx codex set-mode plan
-  acpx codex set approval_policy conservative
-  acpx codex -s backend "fix the API"
-  acpx codex sessions
-  acpx codex sessions new --name backend
-  acpx codex sessions ensure --name backend
-  acpx codex sessions close backend
-  acpx codex status
-  acpx config show
-  acpx config init
-  acpx --ttl 30 codex "investigate flaky tests"
-  acpx claude "refactor auth"
-  acpx gemini "add logging"
-  acpx --agent ./my-custom-server "do something"`
-  );
   program.exitOverride((error) => {
     throw error;
   });
   await runWithOutputPolicy(requestedOutputPolicy, async () => {
     try {
+      if (internalQueueOwnerFlags) {
+        await runQueueOwnerProcess2({
+          sessionId: internalQueueOwnerFlags.sessionId,
+          ttlMs: internalQueueOwnerFlags.ttlMs,
+          permissionMode: internalQueueOwnerFlags.permissionMode,
+          nonInteractivePermissions: internalQueueOwnerFlags.nonInteractivePermissions,
+          authCredentials: config.auth,
+          authPolicy: internalQueueOwnerFlags.authPolicy,
+          timeoutMs: internalQueueOwnerFlags.timeoutMs,
+          suppressSdkConsoleErrors: internalQueueOwnerFlags.suppressSdkConsoleErrors,
+          verbose: internalQueueOwnerFlags.verbose
+        });
+        return;
+      }
       await program.parseAsync(argv);
     } catch (error) {
       if (error instanceof CommanderError) {