acpx 0.1.9 → 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";
@@ -11,9 +11,9 @@ import { findSkillsRoot, maybeHandleSkillflag } from "skillflag";
 // src/agent-registry.ts
 var AGENT_REGISTRY = {
   codex: "npx @zed-industries/codex-acp",
-  claude: "npx @zed-industries/claude-agent-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");
@@ -388,96 +605,14 @@ var PermissionPromptUnavailableError = class extends AcpxOperationalError {
   }
 };
 
-// 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
+// src/acp-error-shapes.ts
 var RESOURCE_NOT_FOUND_ACP_CODES = /* @__PURE__ */ new Set([-32001, -32002]);
-var AUTH_REQUIRED_ACP_CODES = /* @__PURE__ */ new Set([-32e3]);
 function asRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
   }
   return value;
 }
-function isAuthRequiredMessage(value) {
-  if (!value) {
-    return false;
-  }
-  const normalized = value.toLowerCase();
-  return normalized.includes("auth required") || normalized.includes("authentication required") || normalized.includes("authorization required") || normalized.includes("credential required") || normalized.includes("credentials required") || normalized.includes("token required") || normalized.includes("login required");
-}
-function isAcpAuthRequiredPayload(acp) {
-  if (!acp) {
-    return false;
-  }
-  if (!AUTH_REQUIRED_ACP_CODES.has(acp.code)) {
-    return false;
-  }
-  if (isAuthRequiredMessage(acp.message)) {
-    return true;
-  }
-  const data = asRecord(acp.data);
-  if (!data) {
-    return false;
-  }
-  if (data.authRequired === true) {
-    return true;
-  }
-  const methodId = data.methodId;
-  if (typeof methodId === "string" && methodId.trim().length > 0) {
-    return true;
-  }
-  const methods = data.methods;
-  if (Array.isArray(methods) && methods.length > 0) {
-    return true;
-  }
-  return false;
-}
-function isOutputErrorCode(value) {
-  return typeof value === "string" && OUTPUT_ERROR_CODES.includes(value);
-}
-function isOutputErrorOrigin(value) {
-  return typeof value === "string" && OUTPUT_ERROR_ORIGINS.includes(value);
-}
-function readOutputErrorMeta(error) {
-  const record = asRecord(error);
-  if (!record) {
-    return {};
-  }
-  const outputCode = isOutputErrorCode(record.outputCode) ? record.outputCode : void 0;
-  const detailCode = typeof record.detailCode === "string" && record.detailCode.trim().length > 0 ? record.detailCode : void 0;
-  const origin = isOutputErrorOrigin(record.origin) ? record.origin : void 0;
-  const retryable = typeof record.retryable === "boolean" ? record.retryable : void 0;
-  const acp = toAcpErrorPayload(record.acp);
-  return {
-    outputCode,
-    detailCode,
-    origin,
-    retryable,
-    acp
-  };
-}
 function toAcpErrorPayload(value) {
   const record = asRecord(value);
   if (!record) {
@@ -521,19 +656,7 @@ function extractAcpErrorInternal(value, depth) {
   }
   return void 0;
 }
-function isTimeoutLike(error) {
-  return error instanceof Error && error.name === "TimeoutError";
-}
-function isNoSessionLike(error) {
-  return error instanceof Error && error.name === "NoSessionError";
-}
-function isUsageLike(error) {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  return error.name === "CommanderError" || error.name === "InvalidArgumentError" || asRecord(error)?.code === "commander.invalidArgument";
-}
-function formatErrorMessage(error) {
+function formatUnknownErrorMessage(error) {
   if (error instanceof Error) {
     return error.message;
   }
@@ -549,6 +672,31 @@ function formatErrorMessage(error) {
   }
   return String(error);
 }
+function isSessionNotFoundText(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const normalized = value.toLowerCase();
+  return normalized.includes("resource_not_found") || normalized.includes("resource not found") || normalized.includes("session not found") || normalized.includes("unknown session");
+}
+function hasSessionNotFoundHint(value, depth = 0) {
+  if (depth > 4) {
+    return false;
+  }
+  if (isSessionNotFoundText(value)) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.some((entry) => hasSessionNotFoundHint(entry, depth + 1));
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return false;
+  }
+  return Object.values(record).some(
+    (entry) => hasSessionNotFoundHint(entry, depth + 1)
+  );
+}
 function extractAcpError(error) {
   return extractAcpErrorInternal(error, 0);
 }
@@ -557,12 +705,131 @@ function isAcpResourceNotFoundError(error) {
   if (acp && RESOURCE_NOT_FOUND_ACP_CODES.has(acp.code)) {
     return true;
   }
-  const message = formatErrorMessage(error).toLowerCase();
-  return message.includes("resource_not_found") || message.includes("resource not found") || message.includes("session not found") || message.includes("unknown session");
+  if (acp) {
+    if (isSessionNotFoundText(acp.message)) {
+      return true;
+    }
+    if (hasSessionNotFoundHint(acp.data)) {
+      return true;
+    }
+  }
+  return isSessionNotFoundText(formatUnknownErrorMessage(error));
 }
-function mapErrorCode(error) {
-  if (error instanceof PermissionPromptUnavailableError) {
-    return "PERMISSION_PROMPT_UNAVAILABLE";
+
+// src/error-normalization.ts
+var AUTH_REQUIRED_ACP_CODES = /* @__PURE__ */ new Set([-32e3]);
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function isAuthRequiredMessage(value) {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.toLowerCase();
+  return normalized.includes("auth required") || normalized.includes("authentication required") || normalized.includes("authorization required") || normalized.includes("credential required") || normalized.includes("credentials required") || normalized.includes("token required") || normalized.includes("login required");
+}
+function isAcpAuthRequiredPayload(acp) {
+  if (!acp) {
+    return false;
+  }
+  if (!AUTH_REQUIRED_ACP_CODES.has(acp.code)) {
+    return false;
+  }
+  if (isAuthRequiredMessage(acp.message)) {
+    return true;
+  }
+  const data = asRecord2(acp.data);
+  if (!data) {
+    return false;
+  }
+  if (data.authRequired === true) {
+    return true;
+  }
+  const methodId = data.methodId;
+  if (typeof methodId === "string" && methodId.trim().length > 0) {
+    return true;
+  }
+  const methods = data.methods;
+  if (Array.isArray(methods) && methods.length > 0) {
+    return true;
+  }
+  return false;
+}
+function isOutputErrorCode(value) {
+  return typeof value === "string" && OUTPUT_ERROR_CODES.includes(value);
+}
+function isOutputErrorOrigin(value) {
+  return typeof value === "string" && OUTPUT_ERROR_ORIGINS.includes(value);
+}
+function readOutputErrorMeta(error) {
+  const record = asRecord2(error);
+  if (!record) {
+    return {};
+  }
+  const outputCode = isOutputErrorCode(record.outputCode) ? record.outputCode : void 0;
+  const detailCode = typeof record.detailCode === "string" && record.detailCode.trim().length > 0 ? record.detailCode : void 0;
+  const origin = isOutputErrorOrigin(record.origin) ? record.origin : void 0;
+  const retryable = typeof record.retryable === "boolean" ? record.retryable : void 0;
+  const acp = toAcpErrorPayload2(record.acp);
+  return {
+    outputCode,
+    detailCode,
+    origin,
+    retryable,
+    acp
+  };
+}
+function toAcpErrorPayload2(value) {
+  const record = asRecord2(value);
+  if (!record) {
+    return void 0;
+  }
+  if (typeof record.code !== "number" || !Number.isFinite(record.code)) {
+    return void 0;
+  }
+  if (typeof record.message !== "string" || record.message.length === 0) {
+    return void 0;
+  }
+  return {
+    code: record.code,
+    message: record.message,
+    data: record.data
+  };
+}
+function isTimeoutLike(error) {
+  return error instanceof Error && error.name === "TimeoutError";
+}
+function isNoSessionLike(error) {
+  return error instanceof Error && error.name === "NoSessionError";
+}
+function isUsageLike(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.name === "CommanderError" || error.name === "InvalidArgumentError" || asRecord2(error)?.code === "commander.invalidArgument";
+}
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error && typeof error === "object") {
+    const maybeMessage = error.message;
+    if (typeof maybeMessage === "string" && maybeMessage.length > 0) {
+      return maybeMessage;
+    }
+    try {
+      return JSON.stringify(error);
+    } catch {
+    }
+  }
+  return String(error);
+}
+function mapErrorCode(error) {
+  if (error instanceof PermissionPromptUnavailableError) {
+    return "PERMISSION_PROMPT_UNAVAILABLE";
   }
   if (error instanceof PermissionDeniedError) {
     return "PERMISSION_DENIED";
@@ -658,7 +925,7 @@ function toStatusLabel(status) {
       return "running";
   }
 }
-function asRecord2(value) {
+function asRecord3(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
   }
@@ -752,7 +1019,7 @@ function summarizeToolInput(rawInput) {
   if (typeof rawInput === "string" || typeof rawInput === "number" || typeof rawInput === "boolean") {
     return toInline(String(rawInput));
   }
-  const record = asRecord2(rawInput);
+  const record = asRecord3(rawInput);
   if (record) {
     const command = readFirstString(record, ["command", "cmd", "program"]);
     const args = readFirstStringArray(record, ["args", "arguments"]);
@@ -886,7 +1153,7 @@ function extractOutputText(value, depth = 0, seen = /* @__PURE__ */ new Set()) {
     }
     return dedupeStrings(parts).join("\n");
   }
-  const record = asRecord2(value);
+  const record = asRecord3(value);
   if (!record) {
     return void 0;
   }
@@ -2086,6 +2353,9 @@ var TerminalManager = class {
 var REPLAY_IDLE_MS = 80;
 var REPLAY_DRAIN_TIMEOUT_MS = 5e3;
 var DRAIN_POLL_INTERVAL_MS = 20;
+var AGENT_CLOSE_AFTER_STDIN_END_MS = 100;
+var AGENT_CLOSE_TERM_GRACE_MS = 1500;
+var AGENT_CLOSE_KILL_GRACE_MS = 1e3;
 function shouldSuppressSdkConsoleError(args) {
   if (args.length === 0) {
     return false;
@@ -2121,6 +2391,38 @@ function waitForSpawn2(child) {
     child.once("error", onError);
   });
 }
+function isChildProcessRunning(child) {
+  return child.exitCode == null && child.signalCode == null;
+}
+function waitForChildExit(child, timeoutMs) {
+  if (!isChildProcessRunning(child)) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    const timer = setTimeout(
+      () => {
+        finish(false);
+      },
+      Math.max(0, timeoutMs)
+    );
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.off("close", onExitLike);
+      child.off("exit", onExitLike);
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const onExitLike = () => {
+      finish(true);
+    };
+    child.once("close", onExitLike);
+    child.once("exit", onExitLike);
+  });
+}
 function splitCommandLine(value) {
   const parts = [];
   let current = "";
@@ -2542,8 +2844,8 @@ var AcpClient = class {
   async close() {
     this.closing = true;
     await this.terminalManager.shutdown();
-    if (this.agent && !this.agent.killed) {
-      this.agent.kill();
+    if (this.agent) {
+      await this.terminateAgentProcess(this.agent);
     }
     this.sessionUpdateChain = Promise.resolve();
     this.observedSessionUpdates = 0;
@@ -2555,6 +2857,44 @@ var AcpClient = class {
     this.connection = void 0;
     this.agent = void 0;
   }
+  async terminateAgentProcess(child) {
+    if (!child.stdin.destroyed) {
+      try {
+        child.stdin.end();
+      } catch {
+      }
+    }
+    let exited = await waitForChildExit(child, AGENT_CLOSE_AFTER_STDIN_END_MS);
+    if (!exited && isChildProcessRunning(child)) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      exited = await waitForChildExit(child, AGENT_CLOSE_TERM_GRACE_MS);
+    }
+    if (!exited && isChildProcessRunning(child)) {
+      this.log(
+        `agent did not exit after ${AGENT_CLOSE_TERM_GRACE_MS}ms; forcing SIGKILL`
+      );
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      exited = await waitForChildExit(child, AGENT_CLOSE_KILL_GRACE_MS);
+    }
+    if (!child.stdin.destroyed) {
+      child.stdin.destroy();
+    }
+    if (!child.stdout.destroyed) {
+      child.stdout.destroy();
+    }
+    if (!child.stderr.destroyed) {
+      child.stderr.destroy();
+    }
+    if (!exited) {
+      child.unref();
+    }
+  }
   getConnection() {
     if (!this.connection) {
       throw new Error("ACP client not started");
@@ -2768,118 +3108,273 @@ 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;
-  }
-  markPromptActive() {
-    if (this.state === "starting" || this.state === "active") {
-      this.state = "active";
-    }
+// 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}`;
   }
-  endTurn() {
-    this.state = "idle";
-    this.pendingCancel = false;
+  return path4.join(queueBaseDir(), `${key}.sock`);
+}
+function parseQueueOwnerRecord(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return null;
   }
-  beginClosing() {
-    this.state = "closing";
-    this.pendingCancel = false;
-    this.activeController = void 0;
+  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;
   }
-  setActiveController(controller) {
-    this.activeController = controller;
+  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;
   }
-  clearActiveController() {
-    this.activeController = void 0;
+  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;
   }
-  assertCanHandleControlRequest() {
-    if (this.state === "closing") {
-      throw new QueueConnectionError("Queue owner is closing", {
-        detailCode: "QUEUE_OWNER_SHUTTING_DOWN",
-        origin: "queue",
-        retryable: true
-      });
+  try {
+    await fs3.unlink(socketPath);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
     }
   }
-  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;
+}
+async function waitForProcessExit(pid, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (Date.now() <= deadline) {
+    if (!isProcessAlive(pid)) {
       return true;
     }
-    return false;
+    await waitMs2(PROCESS_POLL_MS);
   }
-  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 !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;
     }
-    return cancelled2;
+  });
+}
+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;
   }
-  async setSessionMode(modeId, timeoutMs) {
-    this.assertCanHandleControlRequest();
-    const activeController = this.activeController;
-    if (activeController) {
-      await this.options.withTimeout(
-        async () => await activeController.setSessionMode(modeId),
-        timeoutMs
-      );
-      return;
+}
+function isProcessAlive(pid) {
+  if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) {
+    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;
     }
-    await this.options.setSessionModeFallback(modeId, timeoutMs);
+    const owner = await readQueueOwnerRecord(sessionId);
+    if (!owner) {
+      await cleanupStaleQueueOwner(sessionId, owner);
+      return void 0;
+    }
+    if (!isProcessAlive(owner.pid) || isQueueOwnerHeartbeatStale(owner)) {
+      if (isProcessAlive(owner.pid)) {
+        await terminateProcess(owner.pid).catch(() => {
+        });
+      }
+      await cleanupStaleQueueOwner(sessionId, owner);
+    }
+    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 asRecord3(value) {
+function asRecord4(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
   }
@@ -2898,7 +3393,7 @@ function isOutputErrorOrigin2(value) {
   return typeof value === "string" && OUTPUT_ERROR_ORIGINS.includes(value);
 }
 function parseAcpError(value) {
-  const record = asRecord3(value);
+  const record = asRecord4(value);
   if (!record) {
     return void 0;
   }
@@ -2915,7 +3410,7 @@ function parseAcpError(value) {
   };
 }
 function parseQueueRequest(raw) {
-  const request = asRecord3(raw);
+  const request = asRecord4(raw);
   if (!request) {
     return null;
   }
@@ -2973,15 +3468,15 @@ function parseQueueRequest(raw) {
   return null;
 }
 function parseSessionSendResult(raw) {
-  const result = asRecord3(raw);
+  const result = asRecord4(raw);
   if (!result) {
     return null;
   }
   if (typeof result.stopReason !== "string" || typeof result.sessionId !== "string" || typeof result.resumed !== "boolean") {
     return null;
   }
-  const permissionStats = asRecord3(result.permissionStats);
-  const record = asRecord3(result.record);
+  const permissionStats = asRecord4(result.permissionStats);
+  const record = asRecord4(result.record);
   if (!permissionStats || !record) {
     return null;
   }
@@ -2996,7 +3491,7 @@ function parseSessionSendResult(raw) {
   return result;
 }
 function parseQueueOwnerMessage(raw) {
-  const message = asRecord3(raw);
+  const message = asRecord4(raw);
   if (!message || typeof message.type !== "string") {
     return null;
   }
@@ -3021,7 +3516,7 @@ function parseQueueOwnerMessage(raw) {
     };
   }
   if (message.type === "client_operation") {
-    const operation = asRecord3(message.operation);
+    const operation = asRecord4(message.operation);
     if (!operation || typeof operation.method !== "string" || typeof operation.status !== "string" || typeof operation.summary !== "string" || typeof operation.timestamp !== "string") {
       return null;
     }
@@ -3076,7 +3571,7 @@ function parseQueueOwnerMessage(raw) {
     };
   }
   if (message.type === "set_config_option_result") {
-    const response = asRecord3(message.response);
+    const response = asRecord4(message.response);
     if (!response || !Array.isArray(response.configOptions)) {
       return null;
     }
@@ -3109,504 +3604,354 @@ 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;
   }
-  return !isProcessAlive(pid);
-}
-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;
-}
-function parseQueueOwnerRecord(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    return null;
-  }
-  const record = raw;
-  if (!Number.isInteger(record.pid) || record.pid <= 0 || typeof record.sessionId !== "string" || typeof record.socketPath !== "string") {
-    return null;
-  }
-  return {
-    pid: record.pid,
-    sessionId: record.sessionId,
-    socketPath: record.socketPath
+  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
   };
-}
-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}`;
-  }
-  return path4.join(queueBaseDir(), `${key}.sock`);
-}
-async function ensureQueueDir() {
-  await fs3.mkdir(queueBaseDir(), { recursive: true });
-}
-async function removeSocketFile(socketPath) {
-  if (process.platform === "win32") {
-    return;
-  }
-  try {
-    await fs3.unlink(socketPath);
-  } 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;
-  }
-}
-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 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
-  );
-  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);
-    }
-    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;
-    }
-  });
-}
-function shouldRetryQueueConnect(error) {
-  const code = error.code;
-  return code === "ENOENT" || code === "ECONNREFUSED";
-}
-async function waitMs2(ms) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
+  options.outputFormatter.setContext({
+    sessionId: options.sessionId,
+    requestId,
+    stream: "prompt"
   });
-}
-async function connectToSocket(socketPath) {
   return await new Promise((resolve, reject) => {
-    const socket = net.createConnection(socketPath);
-    const onConnect = () => {
-      socket.off("error", onError);
-      resolve(socket);
+    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 onError = (error) => {
-      socket.off("connect", onConnect);
+    const finishReject = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.removeAllListeners();
+      if (!socket.destroyed) {
+        socket.destroy();
+      }
       reject(error);
     };
-    socket.once("connect", onConnect);
-    socket.once("error", onError);
-  });
-}
-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;
+    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;
       }
-      if (!isProcessAlive(owner.pid)) {
-        return void 0;
+      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;
       }
-      await waitMs2(QUEUE_CONNECT_RETRY_MS);
-    }
-  }
-  if (lastError && !shouldRetryQueueConnect(lastError)) {
-    throw lastError;
-  }
-  return void 0;
-}
-function writeQueueMessage(socket, message) {
-  if (socket.destroyed || !socket.writable) {
-    return;
-  }
-  socket.write(`${JSON.stringify(message)}
-`);
-}
-var SessionQueueOwner = class _SessionQueueOwner {
-  server;
-  controlHandlers;
-  pending = [];
-  waiters = [];
-  closed = false;
-  constructor(server, controlHandlers) {
-    this.server = server;
-    this.controlHandlers = controlHandlers;
-  }
-  static async start(lease, controlHandlers) {
-    const ownerRef = { current: void 0 };
-    const server = net.createServer((socket) => {
-      ownerRef.current?.handleConnection(socket);
-    });
-    ownerRef.current = new _SessionQueueOwner(server, controlHandlers);
-    await new Promise((resolve, reject) => {
-      const onListening = () => {
-        server.off("error", onError);
-        resolve();
-      };
-      const onError = (error) => {
-        server.off("listening", onListening);
-        reject(error);
-      };
-      server.once("listening", onListening);
-      server.once("error", onError);
-      server.listen(lease.socketPath);
-    });
-    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
-            }
-          )
+      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;
       }
-      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)
+      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
+        })
       );
-      const waiter = (task) => {
-        if (timer) {
-          clearTimeout(timer);
+    };
+    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);
         }
-        resolve(task);
-      };
-      this.waiters.push(waiter);
+        index = buffer.indexOf("\n");
+      }
     });
-  }
-  enqueue(task) {
-    if (this.closed) {
-      if (task.waitForCompletion) {
-        task.send(
-          makeQueueOwnerError(
-            task.requestId,
-            "Queue owner is shutting down",
-            "QUEUE_OWNER_SHUTTING_DOWN",
+    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;
       }
-      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", {
+      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.end();
-      return;
-    }
+    });
+    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;
     let buffer = "";
-    let handled = false;
-    const fail = (requestId, message, detailCode) => {
-      writeQueueMessage(
-        socket,
-        makeQueueOwnerError(requestId, message, detailCode, {
-          retryable: false
-        })
-      );
-      socket.end();
+    const finishResolve = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.removeAllListeners();
+      if (!socket.destroyed) {
+        socket.end();
+      }
+      resolve(result);
     };
-    const processLine = (line) => {
-      if (handled) {
+    const finishReject = (error) => {
+      if (settled) {
         return;
       }
-      handled = true;
+      settled = true;
+      socket.removeAllListeners();
+      if (!socket.destroyed) {
+        socket.destroy();
+      }
+      reject(error);
+    };
+    const processLine = (line) => {
       let parsed;
       try {
         parsed = JSON.parse(line);
       } catch {
-        fail(
-          "unknown",
-          "Invalid queue request payload",
-          "QUEUE_REQUEST_PAYLOAD_INVALID_JSON"
+        finishReject(
+          new QueueProtocolError("Queue owner sent invalid JSON payload", {
+            detailCode: "QUEUE_PROTOCOL_INVALID_JSON",
+            origin: "queue",
+            retryable: true
+          })
         );
         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();
-          }
-        });
+      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 (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();
-          }
-        });
+      if (message.type === "accepted") {
+        acknowledged = true;
         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();
-          }
-        });
+      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;
       }
-      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();
+      if (!acknowledged) {
+        finishReject(
+          new QueueConnectionError("Queue owner did not acknowledge request", {
+            detailCode: "QUEUE_ACK_MISSING",
+            origin: "queue",
+            retryable: true
+          })
+        );
+        return;
       }
-      this.enqueue(task);
+      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;
@@ -3620,315 +3965,539 @@ var SessionQueueOwner = class _SessionQueueOwner {
         index = buffer.indexOf("\n");
       }
     });
-    socket.on("error", () => {
+    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
+    });
+  }
+  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;
+  }
+  if (!await ensureOwnerIsUsable(options.sessionId, owner)) {
+    return void 0;
+  }
+  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;
+  }
+  if (!await ensureOwnerIsUsable(options.sessionId, owner)) {
+    return void 0;
+  }
+  throw new QueueConnectionError(
+    "Session queue owner is running but not accepting queue requests",
+    {
+      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+      origin: "queue",
+      retryable: true
+    }
+  );
+}
+async function tryCancelOnRunningOwner(options) {
+  const owner = await readQueueOwnerRecord(options.sessionId);
+  if (!owner) {
+    return void 0;
+  }
+  if (!await ensureOwnerIsUsable(options.sessionId, owner)) {
+    return void 0;
+  }
+  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;
+  }
+  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 trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
+  const owner = await readQueueOwnerRecord(sessionId);
+  if (!owner) {
+    return void 0;
+  }
+  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;
+  }
+  if (!await ensureOwnerIsUsable(sessionId, owner)) {
+    return void 0;
+  }
+  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;
+  }
+  if (!await ensureOwnerIsUsable(sessionId, owner)) {
+    return void 0;
+  }
+  const response = await submitSetConfigOptionToQueueOwner(
+    owner,
+    configId,
+    value,
+    timeoutMs
+  );
+  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;
+  }
+  throw new QueueConnectionError(
+    "Session queue owner is running but not accepting set_config_option requests",
+    {
+      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+      origin: "queue",
+      retryable: true
+    }
+  );
+}
+
+// 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
+  };
+}
+function makeQueueOwnerErrorFromUnknown(requestId, error, detailCode, options = {}) {
+  const normalized = normalizeOutputError(error, {
+    defaultCode: "RUNTIME",
+    origin: "queue",
+    detailCode,
+    retryable: options.retryable
+  });
+  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) {
+    return;
+  }
+  socket.write(`${JSON.stringify(message)}
+`);
+}
+var SessionQueueOwner = class _SessionQueueOwner {
+  server;
+  controlHandlers;
+  pending = [];
+  waiters = [];
+  closed = false;
+  constructor(server, controlHandlers) {
+    this.server = server;
+    this.controlHandlers = controlHandlers;
+  }
+  static async start(lease, controlHandlers) {
+    const ownerRef = { current: void 0 };
+    const server = net2.createServer((socket) => {
+      ownerRef.current?.handleConnection(socket);
+    });
+    ownerRef.current = new _SessionQueueOwner(server, controlHandlers);
+    await new Promise((resolve, reject) => {
+      const onListening = () => {
+        server.off("error", onError);
+        resolve();
+      };
+      const onError = (error) => {
+        server.off("listening", onListening);
+        reject(error);
+      };
+      server.once("listening", onListening);
+      server.once("error", onError);
+      server.listen(lease.socketPath);
     });
+    return ownerRef.current;
   }
-};
-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",
-            {
-              detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
-              origin: "queue",
+  }
+  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",
+            {
               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;
@@ -3936,262 +4505,270 @@ async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
       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 (line.length > 0) {
+          processLine(line);
+        }
+        index = buffer.indexOf("\n");
       }
-      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;
+  async setSessionMode(modeId, timeoutMs) {
+    this.assertCanHandleControlRequest();
+    const activeController = this.activeController;
+    if (activeController) {
+      await this.options.withTimeout(
+        async () => await activeController.setSessionMode(modeId),
+        timeoutMs
+      );
+      return;
+    }
+    await this.options.setSessionModeFallback(modeId, timeoutMs);
   }
-  throw new QueueConnectionError(
-    "Session queue owner is running but not accepting cancel requests",
-    {
-      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
-      origin: "queue",
-      retryable: true
+  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 trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
-  const owner = await readQueueOwnerRecord(sessionId);
-  if (!owner) {
-    return void 0;
+    return await this.options.setSessionConfigOptionFallback(
+      configId,
+      value,
+      timeoutMs
+    );
   }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(sessionId, 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;
   }
-  const submitted = await submitSetModeToQueueOwner(owner, modeId, timeoutMs);
-  if (submitted) {
-    if (verbose) {
+  if (!Number.isFinite(ttlMs) || ttlMs < 0) {
+    return DEFAULT_QUEUE_OWNER_TTL_MS;
+  }
+  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_mode on owner pid ${owner.pid} for session ${sessionId}
+        `[acpx] queue owner already active for session ${options.sessionId}; skipping spawn
 `
       );
     }
-    return true;
-  }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(sessionId, owner);
-    return void 0;
+    return;
   }
-  throw new QueueConnectionError(
-    "Session queue owner is running but not accepting set_mode requests",
-    {
-      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
-      origin: "queue",
-      retryable: true
+  const runtime = createQueueOwnerTurnRuntime(options, deps);
+  let owner;
+  let heartbeatTimer;
+  const refreshHeartbeat = async () => {
+    if (!owner) {
+      return;
     }
-  );
-}
-async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, timeoutMs, verbose) {
-  const owner = await readQueueOwnerRecord(sessionId);
-  if (!owner) {
-    return void 0;
-  }
-  if (!isProcessAlive(owner.pid)) {
-    await cleanupStaleQueueOwner(sessionId, owner);
-    return void 0;
-  }
-  const response = await submitSetConfigOptionToQueueOwner(
-    owner,
-    configId,
-    value,
-    timeoutMs
-  );
-  if (response) {
-    if (verbose) {
-      process.stderr.write(
-        `[acpx] requested session/set_config_option on owner pid ${owner.pid} for session ${sessionId}
+    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();
     }
-    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
+  } finally {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
     }
-  );
-}
-async function terminateQueueOwnerForSession(sessionId) {
-  const owner = await readQueueOwnerRecord(sessionId);
-  if (!owner) {
-    return;
-  }
-  if (isProcessAlive(owner.pid)) {
-    await terminateProcess(owner.pid);
+    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";
@@ -4363,88 +4940,390 @@ function normalizeName(value) {
 function isoNow2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-async function listSessions() {
-  await ensureSessionDir();
-  const entries = await fs4.readdir(sessionBaseDir(), { withFileTypes: true });
-  const records = [];
+async function listSessions() {
+  await ensureSessionDir();
+  const entries = await fs4.readdir(sessionBaseDir(), { withFileTypes: true });
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) {
+      continue;
+    }
+    const fullPath = path5.join(sessionBaseDir(), entry.name);
+    try {
+      const payload = await fs4.readFile(fullPath, "utf8");
+      const parsed = parseSessionRecord(JSON.parse(payload));
+      if (parsed) {
+        records.push(parsed);
+      }
+    } catch {
+    }
+  }
+  records.sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
+  return records;
+}
+async function listSessionsForAgent(agentCommand) {
+  const sessions = await listSessions();
+  return sessions.filter((session) => session.agentCommand === agentCommand);
+}
+async function findSession(options) {
+  const normalizedCwd = absolutePath(options.cwd);
+  const normalizedName = normalizeName(options.name);
+  const sessions = await listSessionsForAgent(options.agentCommand);
+  return sessions.find((session) => {
+    if (session.cwd !== normalizedCwd) {
+      return false;
+    }
+    if (!options.includeClosed && session.closed) {
+      return false;
+    }
+    if (normalizedName == null) {
+      return session.name == null;
+    }
+    return session.name === normalizedName;
+  });
+}
+async function findSessionByDirectoryWalk(options) {
+  const normalizedName = normalizeName(options.name);
+  const normalizedStart = absolutePath(options.cwd);
+  const normalizedBoundary = absolutePath(options.boundary ?? normalizedStart);
+  const walkBoundary = isWithinBoundary(normalizedBoundary, normalizedStart) ? normalizedBoundary : normalizedStart;
+  const sessions = await listSessionsForAgent(options.agentCommand);
+  const matchesScope = (session, dir2) => {
+    if (session.cwd !== dir2) {
+      return false;
+    }
+    if (session.closed) {
+      return false;
+    }
+    if (normalizedName == null) {
+      return session.name == null;
+    }
+    return session.name === normalizedName;
+  };
+  let dir = normalizedStart;
+  for (; ; ) {
+    const match = sessions.find((session) => matchesScope(session, dir));
+    if (match) {
+      return match;
+    }
+    if (dir === walkBoundary) {
+      return void 0;
+    }
+    const parent = path5.dirname(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    dir = parent;
+  }
+}
+
+// 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;
+function collapseWhitespace2(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function toPreviewText(value) {
+  const collapsed = collapseWhitespace2(value);
+  if (collapsed.length <= SESSION_HISTORY_PREVIEW_CHARS) {
+    return collapsed;
+  }
+  if (SESSION_HISTORY_PREVIEW_CHARS <= 3) {
+    return collapsed.slice(0, SESSION_HISTORY_PREVIEW_CHARS);
+  }
+  return `${collapsed.slice(0, SESSION_HISTORY_PREVIEW_CHARS - 3)}...`;
+}
+function textFromContent(content) {
+  if (content.type === "text") {
+    return content.text;
+  }
+  if (content.type === "resource_link") {
+    return content.title ?? content.name ?? content.uri;
+  }
+  if (content.type === "resource") {
+    if ("text" in content.resource && typeof content.resource.text === "string") {
+      return content.resource.text;
+    }
+    return content.resource.uri;
+  }
+  return void 0;
+}
+function toHistoryEntryFromUpdate(notification) {
+  const update = notification.update;
+  if (update.sessionUpdate !== "user_message_chunk" && update.sessionUpdate !== "agent_message_chunk") {
+    return void 0;
+  }
+  const text = textFromContent(update.content);
+  if (!text) {
+    return void 0;
+  }
+  const textPreview = toPreviewText(text);
+  if (!textPreview) {
+    return void 0;
+  }
+  return {
+    role: update.sessionUpdate === "user_message_chunk" ? "user" : "assistant",
+    timestamp: isoNow2(),
+    textPreview
+  };
+}
+function appendHistoryEntries(current, entries) {
+  const base = current ? [...current] : [];
   for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".json")) {
+    if (!entry.textPreview.trim()) {
       continue;
     }
-    const fullPath = path5.join(sessionBaseDir(), entry.name);
-    try {
-      const payload = await fs4.readFile(fullPath, "utf8");
-      const parsed = parseSessionRecord(JSON.parse(payload));
-      if (parsed) {
-        records.push(parsed);
-      }
-    } catch {
-    }
+    base.push(entry);
   }
-  records.sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
-  return records;
+  if (base.length <= SESSION_HISTORY_MAX_ENTRIES) {
+    return base;
+  }
+  return base.slice(base.length - SESSION_HISTORY_MAX_ENTRIES);
 }
-async function listSessionsForAgent(agentCommand) {
-  const sessions = await listSessions();
-  return sessions.filter((session) => session.agentCommand === agentCommand);
+
+// src/session-runtime-lifecycle.ts
+function applyLifecycleSnapshotToRecord(record, snapshot) {
+  record.pid = snapshot.pid;
+  record.agentStartedAt = snapshot.startedAt;
+  if (snapshot.lastExit) {
+    record.lastAgentExitCode = snapshot.lastExit.exitCode;
+    record.lastAgentExitSignal = snapshot.lastExit.signal;
+    record.lastAgentExitAt = snapshot.lastExit.exitedAt;
+    record.lastAgentDisconnectReason = snapshot.lastExit.reason;
+    return;
+  }
+  record.lastAgentExitCode = void 0;
+  record.lastAgentExitSignal = void 0;
+  record.lastAgentExitAt = void 0;
+  record.lastAgentDisconnectReason = void 0;
 }
-async function findSession(options) {
-  const normalizedCwd = absolutePath(options.cwd);
-  const normalizedName = normalizeName(options.name);
-  const sessions = await listSessionsForAgent(options.agentCommand);
-  return sessions.find((session) => {
-    if (session.cwd !== normalizedCwd) {
-      return false;
-    }
-    if (!options.includeClosed && session.closed) {
-      return false;
-    }
-    if (normalizedName == null) {
-      return session.name == null;
-    }
-    return session.name === normalizedName;
-  });
+function reconcileAgentSessionId(record, agentSessionId) {
+  const normalized = normalizeAgentSessionId(agentSessionId);
+  if (!normalized) {
+    return;
+  }
+  record.agentSessionId = normalized;
 }
-async function findSessionByDirectoryWalk(options) {
-  const normalizedName = normalizeName(options.name);
-  const normalizedStart = absolutePath(options.cwd);
-  const normalizedBoundary = absolutePath(options.boundary ?? normalizedStart);
-  const walkBoundary = isWithinBoundary(normalizedBoundary, normalizedStart) ? normalizedBoundary : normalizedStart;
-  const sessions = await listSessionsForAgent(options.agentCommand);
-  const matchesScope = (session, dir2) => {
-    if (session.cwd !== dir2) {
-      return false;
-    }
-    if (session.closed) {
-      return false;
-    }
-    if (normalizedName == null) {
-      return session.name == null;
+
+// src/session-runtime-reconnect.ts
+function loadSessionCandidates(record) {
+  const candidates = [normalizeAgentSessionId(record.agentSessionId), record.sessionId];
+  const unique = [];
+  for (const candidate of candidates) {
+    if (!candidate || unique.includes(candidate)) {
+      continue;
     }
-    return session.name === normalizedName;
-  };
-  let dir = normalizedStart;
-  for (; ; ) {
-    const match = sessions.find((session) => matchesScope(session, dir));
-    if (match) {
-      return match;
+    unique.push(candidate);
+  }
+  return unique;
+}
+async function connectAndLoadSession(options) {
+  const record = options.record;
+  const client = options.client;
+  const storedProcessAlive = isProcessAlive(record.pid);
+  const shouldReconnect = Boolean(record.pid) && !storedProcessAlive;
+  if (options.verbose) {
+    if (storedProcessAlive) {
+      process.stderr.write(
+        `[acpx] saved session pid ${record.pid} is running; reconnecting with loadSession
+`
+      );
+    } else if (shouldReconnect) {
+      process.stderr.write(
+        `[acpx] saved session pid ${record.pid} is dead; respawning agent and attempting session/load
+`
+      );
     }
-    if (dir === walkBoundary) {
-      return void 0;
+  }
+  await options.withTimeout(client.start(), options.timeoutMs);
+  options.onClientAvailable?.(options.activeController);
+  applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
+  record.closed = false;
+  record.closedAt = void 0;
+  options.onConnectedRecord?.(record);
+  await writeSessionRecord(record);
+  let resumed = false;
+  let loadError;
+  let sessionId = record.sessionId;
+  if (client.supportsLoadSession()) {
+    const candidates = loadSessionCandidates(record);
+    for (const candidate of candidates) {
+      if (options.verbose && candidates.length > 1) {
+        process.stderr.write(`[acpx] attempting session/load with ${candidate}
+`);
+      }
+      try {
+        const loadResult = await options.withTimeout(
+          client.loadSessionWithOptions(candidate, record.cwd, {
+            suppressReplayUpdates: true
+          }),
+          options.timeoutMs
+        );
+        reconcileAgentSessionId(record, loadResult.agentSessionId);
+        resumed = true;
+        sessionId = candidate;
+        loadError = void 0;
+        break;
+      } catch (error) {
+        loadError = formatErrorMessage(error);
+        if (!options.shouldFallbackToNewSession(error)) {
+          throw error;
+        }
+        if (options.verbose) {
+          process.stderr.write(
+            `[acpx] session/load failed for ${candidate}: ${loadError}
+`
+          );
+        }
+      }
     }
-    const parent = path5.dirname(dir);
-    if (parent === dir) {
-      return void 0;
+    if (!resumed) {
+      const createdSession = await options.withTimeout(
+        client.createSession(record.cwd),
+        options.timeoutMs
+      );
+      sessionId = createdSession.sessionId;
+      record.sessionId = sessionId;
+      reconcileAgentSessionId(record, createdSession.agentSessionId);
     }
-    dir = parent;
+  } else {
+    const createdSession = await options.withTimeout(
+      client.createSession(record.cwd),
+      options.timeoutMs
+    );
+    sessionId = createdSession.sessionId;
+    record.sessionId = sessionId;
+    reconcileAgentSessionId(record, createdSession.agentSessionId);
   }
+  options.onSessionIdResolved?.(sessionId);
+  return {
+    sessionId,
+    agentSessionId: record.agentSessionId,
+    resumed,
+    loadError
+  };
 }
 
 // src/session-runtime.ts
-var DEFAULT_QUEUE_OWNER_TTL_MS = 3e5;
 var INTERRUPT_CANCEL_WAIT_MS = 2500;
-var SESSION_HISTORY_MAX_ENTRIES = 500;
-var SESSION_HISTORY_PREVIEW_CHARS = 220;
 var TimeoutError = class extends Error {
   constructor(timeoutMs) {
     super(`Timed out after ${timeoutMs}ms`);
@@ -4539,203 +5418,44 @@ var QueueTaskOutputFormatter = class {
     this.send({
       type: "done",
       requestId: this.requestId,
-      stopReason
-    });
-  }
-  onError(params) {
-    this.send({
-      type: "error",
-      requestId: this.requestId,
-      code: params.code,
-      detailCode: params.detailCode,
-      origin: params.origin,
-      message: params.message,
-      retryable: params.retryable,
-      acp: params.acp
-    });
-  }
-  flush() {
-  }
-};
-var DISCARD_OUTPUT_FORMATTER = {
-  setContext() {
-  },
-  onSessionUpdate() {
-  },
-  onClientOperation() {
-  },
-  onDone() {
-  },
-  onError() {
-  },
-  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 collapseWhitespace2(value) {
-  return value.replace(/\s+/g, " ").trim();
-}
-function toPreviewText(value) {
-  const collapsed = collapseWhitespace2(value);
-  if (collapsed.length <= SESSION_HISTORY_PREVIEW_CHARS) {
-    return collapsed;
-  }
-  if (SESSION_HISTORY_PREVIEW_CHARS <= 3) {
-    return collapsed.slice(0, SESSION_HISTORY_PREVIEW_CHARS);
-  }
-  return `${collapsed.slice(0, SESSION_HISTORY_PREVIEW_CHARS - 3)}...`;
-}
-function textFromContent(content) {
-  if (content.type === "text") {
-    return content.text;
-  }
-  if (content.type === "resource_link") {
-    return content.title ?? content.name ?? content.uri;
-  }
-  if (content.type === "resource") {
-    if ("text" in content.resource && typeof content.resource.text === "string") {
-      return content.resource.text;
-    }
-    return content.resource.uri;
-  }
-  return void 0;
-}
-function toHistoryEntryFromUpdate(notification) {
-  const update = notification.update;
-  if (update.sessionUpdate !== "user_message_chunk" && update.sessionUpdate !== "agent_message_chunk") {
-    return void 0;
-  }
-  const text = textFromContent(update.content);
-  if (!text) {
-    return void 0;
-  }
-  const textPreview = toPreviewText(text);
-  if (!textPreview) {
-    return void 0;
-  }
-  return {
-    role: update.sessionUpdate === "user_message_chunk" ? "user" : "assistant",
-    timestamp: isoNow2(),
-    textPreview
-  };
-}
-function appendHistoryEntries(current, entries) {
-  const base = current ? [...current] : [];
-  for (const entry of entries) {
-    if (!entry.textPreview.trim()) {
-      continue;
-    }
-    base.push(entry);
+      stopReason
+    });
   }
-  if (base.length <= SESSION_HISTORY_MAX_ENTRIES) {
-    return base;
+  onError(params) {
+    this.send({
+      type: "error",
+      requestId: this.requestId,
+      code: params.code,
+      detailCode: params.detailCode,
+      origin: params.origin,
+      message: params.message,
+      retryable: params.retryable,
+      acp: params.acp
+    });
   }
-  return base.slice(base.length - SESSION_HISTORY_MAX_ENTRIES);
-}
-function applyLifecycleSnapshotToRecord(record, snapshot) {
-  record.pid = snapshot.pid;
-  record.agentStartedAt = snapshot.startedAt;
-  if (snapshot.lastExit) {
-    record.lastAgentExitCode = snapshot.lastExit.exitCode;
-    record.lastAgentExitSignal = snapshot.lastExit.signal;
-    record.lastAgentExitAt = snapshot.lastExit.exitedAt;
-    record.lastAgentDisconnectReason = snapshot.lastExit.reason;
-    return;
+  flush() {
   }
-  record.lastAgentExitCode = void 0;
-  record.lastAgentExitSignal = void 0;
-  record.lastAgentExitAt = void 0;
-  record.lastAgentDisconnectReason = void 0;
-}
-function reconcileAgentSessionId(record, agentSessionId) {
-  const normalized = normalizeAgentSessionId(agentSessionId);
-  if (!normalized) {
-    return;
+};
+var DISCARD_OUTPUT_FORMATTER = {
+  setContext() {
+  },
+  onSessionUpdate() {
+  },
+  onClientOperation() {
+  },
+  onDone() {
+  },
+  onError() {
+  },
+  flush() {
   }
-  record.agentSessionId = normalized;
-}
+};
 function shouldFallbackToNewSession(error) {
   if (error instanceof TimeoutError || error instanceof InterruptedError) {
     return false;
   }
   return isAcpResourceNotFoundError(error);
 }
-async function connectAndLoadSession(options) {
-  const record = options.record;
-  const client = options.client;
-  const storedProcessAlive = isProcessAlive(record.pid);
-  const shouldReconnect = Boolean(record.pid) && !storedProcessAlive;
-  if (options.verbose) {
-    if (storedProcessAlive) {
-      process.stderr.write(
-        `[acpx] saved session pid ${record.pid} is running; reconnecting with loadSession
-`
-      );
-    } else if (shouldReconnect) {
-      process.stderr.write(
-        `[acpx] saved session pid ${record.pid} is dead; respawning agent and attempting session/load
-`
-      );
-    }
-  }
-  await withTimeout(client.start(), options.timeoutMs);
-  options.onClientAvailable?.(options.activeController);
-  applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
-  record.closed = false;
-  record.closedAt = void 0;
-  options.onConnectedRecord?.(record);
-  await writeSessionRecord(record);
-  let resumed = false;
-  let loadError;
-  let sessionId = record.sessionId;
-  if (client.supportsLoadSession()) {
-    try {
-      const loadResult = await withTimeout(
-        client.loadSessionWithOptions(record.sessionId, record.cwd, {
-          suppressReplayUpdates: true
-        }),
-        options.timeoutMs
-      );
-      reconcileAgentSessionId(record, loadResult.agentSessionId);
-      resumed = true;
-    } catch (error) {
-      loadError = formatErrorMessage(error);
-      if (!shouldFallbackToNewSession(error)) {
-        throw error;
-      }
-      const createdSession = await withTimeout(
-        client.createSession(record.cwd),
-        options.timeoutMs
-      );
-      sessionId = createdSession.sessionId;
-      record.sessionId = sessionId;
-      reconcileAgentSessionId(record, createdSession.agentSessionId);
-    }
-  } else {
-    const createdSession = await withTimeout(
-      client.createSession(record.cwd),
-      options.timeoutMs
-    );
-    sessionId = createdSession.sessionId;
-    record.sessionId = sessionId;
-    reconcileAgentSessionId(record, createdSession.agentSessionId);
-  }
-  options.onSessionIdResolved?.(sessionId);
-  return {
-    sessionId,
-    agentSessionId: record.agentSessionId,
-    resumed,
-    loadError
-  };
-}
 async function runQueuedTask(sessionRecordId, task, options) {
   const outputFormatter = task.waitForCompletion ? new QueueTaskOutputFormatter(task) : DISCARD_OUTPUT_FORMATTER;
   try {
@@ -4842,6 +5562,8 @@ async function runSessionPrompt(options) {
           timeoutMs: options.timeoutMs,
           verbose: options.verbose,
           activeController,
+          withTimeout,
+          shouldFallbackToNewSession,
           onClientAvailable: (controller) => {
             options.onClientAvailable?.(controller);
             notifiedClientAvailable = true;
@@ -4976,6 +5698,8 @@ async function withConnectedSession(options) {
           timeoutMs: options.timeoutMs,
           verbose: options.verbose,
           activeController,
+          withTimeout,
+          shouldFallbackToNewSession,
           onClientAvailable: (controller) => {
             options.onClientAvailable?.(controller);
             notifiedClientAvailable = true;
@@ -5191,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);
@@ -5469,6 +6055,7 @@ var NoSessionError = class extends Error {
   }
 };
 var TOP_LEVEL_VERBS = /* @__PURE__ */ new Set([
+  "__queue-owner",
   "prompt",
   "exec",
   "cancel",
@@ -5481,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(", ")}`
     );
   }
@@ -5508,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;
 }
@@ -5545,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"
     );
   }
@@ -5572,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;
   }
@@ -5581,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;
 }
@@ -5602,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"
@@ -5666,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,
@@ -5698,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"
     );
   }
@@ -6376,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)}
@@ -6398,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,
@@ -6410,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)}
@@ -6437,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 ?? "-"}
@@ -6541,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) {
@@ -6550,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) {
@@ -6749,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) {
@@ -6761,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) {