acpx 0.1.6 → 0.1.8

package/dist/cli.js

@@ -50,6 +50,7 @@ import path from "path";
 var DEFAULT_TIMEOUT_MS = void 0;
 var DEFAULT_TTL_MS = 3e5;
 var DEFAULT_PERMISSION_MODE = "approve-reads";
+var DEFAULT_NON_INTERACTIVE_PERMISSION_POLICY = "deny";
 var DEFAULT_AUTH_POLICY = "skip";
 var DEFAULT_OUTPUT_FORMAT = "text";
 var VALID_PERMISSION_MODES = /* @__PURE__ */ new Set([
@@ -57,6 +58,7 @@ var VALID_PERMISSION_MODES = /* @__PURE__ */ new Set([
   "approve-reads",
   "deny-all"
 ]);
+var VALID_NON_INTERACTIVE_PERMISSION_POLICIES = /* @__PURE__ */ new Set(["deny", "fail"]);
 var VALID_AUTH_POLICIES = /* @__PURE__ */ new Set(["skip", "fail"]);
 var VALID_OUTPUT_FORMATS = /* @__PURE__ */ new Set(["text", "json", "quiet"]);
 function defaultGlobalConfigPath() {
@@ -101,6 +103,19 @@ function parsePermissionMode(value, sourcePath) {
   }
   return value;
 }
+function parseNonInteractivePermissionPolicy(value, sourcePath) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string" || !VALID_NON_INTERACTIVE_PERMISSION_POLICIES.has(
+    value
+  )) {
+    throw new Error(
+      `Invalid config nonInteractivePermissions in ${sourcePath}: expected deny or fail`
+    );
+  }
+  return value;
+}
 function parseAuthPolicy(value, sourcePath) {
   if (value == null) {
     return void 0;
@@ -225,6 +240,13 @@ async function loadResolvedConfig(cwd) {
   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(
+    projectConfig?.nonInteractivePermissions,
+    projectPath
+  ) ?? parseNonInteractivePermissionPolicy(
+    globalConfig?.nonInteractivePermissions,
+    globalPath
+  ) ?? DEFAULT_NON_INTERACTIVE_PERMISSION_POLICY;
   const authPolicy = parseAuthPolicy(projectConfig?.authPolicy, projectPath) ?? parseAuthPolicy(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");
@@ -247,6 +269,7 @@ async function loadResolvedConfig(cwd) {
   return {
     defaultAgent,
     defaultPermissions,
+    nonInteractivePermissions,
     authPolicy,
     ttlMs,
     timeoutMs,
@@ -267,6 +290,7 @@ function toConfigDisplay(config) {
   return {
     defaultAgent: config.defaultAgent,
     defaultPermissions: config.defaultPermissions,
+    nonInteractivePermissions: config.nonInteractivePermissions,
     authPolicy: config.authPolicy,
     ttl: Math.round(config.ttlMs / 1e3),
     timeout: config.timeoutMs == null ? null : config.timeoutMs / 1e3,
@@ -289,6 +313,7 @@ async function initGlobalConfigFile() {
   const payload = {
     defaultAgent: DEFAULT_AGENT_NAME,
     defaultPermissions: "approve-all",
+    nonInteractivePermissions: "deny",
     authPolicy: "skip",
     ttl: 300,
     timeout: null,
@@ -304,6 +329,293 @@ async function initGlobalConfigFile() {
   };
 }
 
+// src/errors.ts
+var AcpxOperationalError = class extends Error {
+  outputCode;
+  detailCode;
+  origin;
+  retryable;
+  acp;
+  outputAlreadyEmitted;
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    this.outputCode = options?.outputCode;
+    this.detailCode = options?.detailCode;
+    this.origin = options?.origin;
+    this.retryable = options?.retryable;
+    this.acp = options?.acp;
+    this.outputAlreadyEmitted = options?.outputAlreadyEmitted;
+  }
+};
+var SessionNotFoundError = class extends AcpxOperationalError {
+  sessionId;
+  constructor(sessionId) {
+    super(`Session not found: ${sessionId}`);
+    this.sessionId = sessionId;
+  }
+};
+var SessionResolutionError = class extends AcpxOperationalError {
+};
+var AgentSpawnError = class extends AcpxOperationalError {
+  agentCommand;
+  constructor(agentCommand, cause) {
+    super(`Failed to spawn agent command: ${agentCommand}`, {
+      cause: cause instanceof Error ? cause : void 0
+    });
+    this.agentCommand = agentCommand;
+  }
+};
+var AuthPolicyError = class extends AcpxOperationalError {
+  constructor(message, options) {
+    super(message, {
+      outputCode: "RUNTIME",
+      detailCode: "AUTH_REQUIRED",
+      origin: "acp",
+      ...options
+    });
+  }
+};
+var QueueConnectionError = class extends AcpxOperationalError {
+};
+var QueueProtocolError = class extends AcpxOperationalError {
+};
+var PermissionDeniedError = class extends AcpxOperationalError {
+};
+var PermissionPromptUnavailableError = class extends AcpxOperationalError {
+  constructor() {
+    super("Permission prompt unavailable in non-interactive mode");
+  }
+};
+
+// src/types.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  ERROR: 1,
+  USAGE: 2,
+  TIMEOUT: 3,
+  NO_SESSION: 4,
+  PERMISSION_DENIED: 5,
+  INTERRUPTED: 130
+};
+var OUTPUT_FORMATS = ["text", "json", "quiet"];
+var AUTH_POLICIES = ["skip", "fail"];
+var NON_INTERACTIVE_PERMISSION_POLICIES = ["deny", "fail"];
+var OUTPUT_ERROR_CODES = [
+  "NO_SESSION",
+  "TIMEOUT",
+  "PERMISSION_DENIED",
+  "PERMISSION_PROMPT_UNAVAILABLE",
+  "RUNTIME",
+  "USAGE"
+];
+var OUTPUT_ERROR_ORIGINS = ["cli", "runtime", "queue", "acp"];
+
+// src/error-normalization.ts
+var 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) {
+    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 extractAcpErrorInternal(value, depth) {
+  if (depth > 5) {
+    return void 0;
+  }
+  const direct = toAcpErrorPayload(value);
+  if (direct) {
+    return direct;
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  if ("error" in record) {
+    const nested = extractAcpErrorInternal(record.error, depth + 1);
+    if (nested) {
+      return nested;
+    }
+  }
+  if ("cause" in record) {
+    const nested = extractAcpErrorInternal(record.cause, depth + 1);
+    if (nested) {
+      return nested;
+    }
+  }
+  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) {
+  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 extractAcpError(error) {
+  return extractAcpErrorInternal(error, 0);
+}
+function isAcpResourceNotFoundError(error) {
+  const acp = extractAcpError(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");
+}
+function mapErrorCode(error) {
+  if (error instanceof PermissionPromptUnavailableError) {
+    return "PERMISSION_PROMPT_UNAVAILABLE";
+  }
+  if (error instanceof PermissionDeniedError) {
+    return "PERMISSION_DENIED";
+  }
+  if (isTimeoutLike(error)) {
+    return "TIMEOUT";
+  }
+  if (isNoSessionLike(error) || isAcpResourceNotFoundError(error)) {
+    return "NO_SESSION";
+  }
+  if (isUsageLike(error)) {
+    return "USAGE";
+  }
+  return void 0;
+}
+function normalizeOutputError(error, options = {}) {
+  const meta = readOutputErrorMeta(error);
+  const mapped = mapErrorCode(error);
+  let code = mapped ?? options.defaultCode ?? "RUNTIME";
+  if (meta.outputCode) {
+    code = meta.outputCode;
+  }
+  if (code === "RUNTIME" && isAcpResourceNotFoundError(error)) {
+    code = "NO_SESSION";
+  }
+  const acp = options.acp ?? meta.acp ?? extractAcpError(error);
+  const detailCode = meta.detailCode ?? options.detailCode ?? (error instanceof AuthPolicyError || isAcpAuthRequiredPayload(acp) ? "AUTH_REQUIRED" : void 0);
+  return {
+    code,
+    message: formatErrorMessage(error),
+    detailCode,
+    origin: meta.origin ?? options.origin,
+    retryable: meta.retryable ?? options.retryable,
+    acp
+  };
+}
+function exitCodeForOutputErrorCode(code) {
+  switch (code) {
+    case "USAGE":
+      return EXIT_CODES.USAGE;
+    case "TIMEOUT":
+      return EXIT_CODES.TIMEOUT;
+    case "NO_SESSION":
+      return EXIT_CODES.NO_SESSION;
+    case "PERMISSION_DENIED":
+    case "PERMISSION_PROMPT_UNAVAILABLE":
+      return EXIT_CODES.PERMISSION_DENIED;
+    case "RUNTIME":
+    default:
+      return EXIT_CODES.ERROR;
+  }
+}
+
 // src/output.ts
 var MAX_THOUGHT_CHARS = 900;
 var MAX_INLINE_CHARS = 220;
@@ -324,6 +636,8 @@ var OUTPUT_PRIORITY_KEYS = [
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
+var DEFAULT_JSON_SESSION_ID = "unknown";
+var DEFAULT_JSON_STREAM = "prompt";
 function asStatus(status) {
   return status ?? "unknown";
 }
@@ -344,7 +658,7 @@ function toStatusLabel(status) {
       return "running";
   }
 }
-function asRecord(value) {
+function asRecord2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
   }
@@ -438,7 +752,7 @@ function summarizeToolInput(rawInput) {
   if (typeof rawInput === "string" || typeof rawInput === "number" || typeof rawInput === "boolean") {
     return toInline(String(rawInput));
   }
-  const record = asRecord(rawInput);
+  const record = asRecord2(rawInput);
   if (record) {
     const command = readFirstString(record, ["command", "cmd", "program"]);
     const args = readFirstStringArray(record, ["args", "arguments"]);
@@ -572,7 +886,7 @@ function extractOutputText(value, depth = 0, seen = /* @__PURE__ */ new Set()) {
     }
     return dedupeStrings(parts).join("\n");
   }
-  const record = asRecord(value);
+  const record = asRecord2(value);
   if (!record) {
     return void 0;
   }
@@ -641,6 +955,8 @@ var TextOutputFormatter = class {
     this.stdout = stdout;
     this.useColor = Boolean(stdout.isTTY);
   }
+  setContext(_context) {
+  }
   onSessionUpdate(notification) {
     const update = notification.update;
     if (update.sessionUpdate !== "agent_thought_chunk") {
@@ -684,6 +1000,11 @@ var TextOutputFormatter = class {
     this.beginSection("done");
     this.writeLine(this.dim(`[done] ${stopReason}`));
   }
+  onError(params) {
+    this.flushThoughtBuffer();
+    this.beginSection("done");
+    this.writeLine(this.formatAnsi(`[error] ${params.code}: ${params.message}`, "31"));
+  }
   onClientOperation(operation) {
     this.flushThoughtBuffer();
     this.beginSection("client");
@@ -870,8 +1191,29 @@ var TextOutputFormatter = class {
 };
 var JsonOutputFormatter = class {
   stdout;
-  constructor(stdout) {
+  sessionId;
+  requestId;
+  stream;
+  sequence = 0;
+  constructor(stdout, context) {
     this.stdout = stdout;
+    this.sessionId = context?.sessionId?.trim() || DEFAULT_JSON_SESSION_ID;
+    this.requestId = context?.requestId?.trim() || void 0;
+    this.stream = context?.stream ?? DEFAULT_JSON_STREAM;
+  }
+  setContext(context) {
+    const nextSessionId = context.sessionId?.trim() || this.sessionId || DEFAULT_JSON_SESSION_ID;
+    const nextRequestId = context.requestId?.trim() || void 0;
+    const nextStream = context.stream ?? this.stream ?? DEFAULT_JSON_STREAM;
+    const sessionChanged = nextSessionId !== this.sessionId;
+    const requestChanged = nextRequestId !== this.requestId;
+    const streamChanged = nextStream !== this.stream;
+    this.sessionId = nextSessionId;
+    this.requestId = nextRequestId;
+    this.stream = nextStream;
+    if (sessionChanged || requestChanged || streamChanged) {
+      this.sequence = 0;
+    }
   }
   onSessionUpdate(notification) {
     const update = notification.update;
@@ -945,6 +1287,18 @@ var JsonOutputFormatter = class {
       timestamp: nowIso()
     });
   }
+  onError(params) {
+    this.emit({
+      type: "error",
+      code: params.code,
+      detailCode: params.detailCode,
+      origin: params.origin,
+      message: params.message,
+      retryable: params.retryable,
+      acp: params.acp,
+      timestamp: params.timestamp ?? nowIso()
+    });
+  }
   onClientOperation(operation) {
     this.emit({
       type: "client_operation",
@@ -958,7 +1312,15 @@ var JsonOutputFormatter = class {
   flush() {
   }
   emit(event) {
-    this.stdout.write(`${JSON.stringify(event)}
+    const payload = {
+      eventVersion: 1,
+      sessionId: this.sessionId || DEFAULT_JSON_SESSION_ID,
+      requestId: this.requestId,
+      seq: this.sequence++,
+      stream: this.stream ?? DEFAULT_JSON_STREAM,
+      ...event
+    };
+    this.stdout.write(`${JSON.stringify(payload)}
 `);
   }
 };
@@ -968,6 +1330,8 @@ var QuietOutputFormatter = class {
   constructor(stdout) {
     this.stdout = stdout;
   }
+  setContext(_context) {
+  }
   onSessionUpdate(notification) {
     const update = notification.update;
     if (update.sessionUpdate !== "agent_message_chunk") {
@@ -982,6 +1346,8 @@ var QuietOutputFormatter = class {
     const text = this.chunks.join("");
     this.stdout.write(text.endsWith("\n") ? text : `${text}
 `);
+  }
+  onError(_params) {
   }
   onClientOperation(_operation) {
   }
@@ -994,7 +1360,7 @@ function createOutputFormatter(format, options = {}) {
     case "text":
       return new TextOutputFormatter(stdout);
     case "json":
-      return new JsonOutputFormatter(stdout);
+      return new JsonOutputFormatter(stdout, options.jsonContext);
     case "quiet":
       return new QuietOutputFormatter(stdout);
     default: {
@@ -1018,40 +1384,6 @@ import { spawn as spawn2 } from "child_process";
 import path3 from "path";
 import { Readable, Writable } from "stream";
 
-// src/errors.ts
-var AcpxOperationalError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = new.target.name;
-  }
-};
-var SessionNotFoundError = class extends AcpxOperationalError {
-  sessionId;
-  constructor(sessionId) {
-    super(`Session not found: ${sessionId}`);
-    this.sessionId = sessionId;
-  }
-};
-var SessionResolutionError = class extends AcpxOperationalError {
-};
-var AgentSpawnError = class extends AcpxOperationalError {
-  agentCommand;
-  constructor(agentCommand, cause) {
-    super(`Failed to spawn agent command: ${agentCommand}`, {
-      cause: cause instanceof Error ? cause : void 0
-    });
-    this.agentCommand = agentCommand;
-  }
-};
-var AuthPolicyError = class extends AcpxOperationalError {
-};
-var QueueConnectionError = class extends AcpxOperationalError {
-};
-var QueueProtocolError = class extends AcpxOperationalError {
-};
-var PermissionDeniedError = class extends AcpxOperationalError {
-};
-
 // src/filesystem.ts
 import fs2 from "fs/promises";
 import path2 from "path";
@@ -1115,15 +1447,22 @@ async function defaultConfirmWrite(filePath, preview) {
     prompt: "Allow write? (y/N) "
   });
 }
+function canPromptForPermission() {
+  return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+}
 var FileSystemHandlers = class {
   rootDir;
   permissionMode;
+  nonInteractivePermissions;
   onOperation;
+  usesDefaultConfirmWrite;
   confirmWrite;
   constructor(options) {
     this.rootDir = path2.resolve(options.cwd);
     this.permissionMode = options.permissionMode;
+    this.nonInteractivePermissions = options.nonInteractivePermissions ?? "deny";
     this.onOperation = options.onOperation;
+    this.usesDefaultConfirmWrite = options.confirmWrite == null;
     this.confirmWrite = options.confirmWrite ?? defaultConfirmWrite;
   }
   async readTextFile(params) {
@@ -1208,6 +1547,9 @@ var FileSystemHandlers = class {
     if (this.permissionMode === "deny-all") {
       return false;
     }
+    if (this.usesDefaultConfirmWrite && this.nonInteractivePermissions === "fail" && !canPromptForPermission()) {
+      throw new PermissionPromptUnavailableError();
+    }
     return await this.confirmWrite(filePath, preview);
   }
   resolvePathWithinRoot(rawPath) {
@@ -1312,7 +1654,10 @@ async function promptForToolPermission(params) {
 [permission] Allow ${toolName} [${toolKind}]? (y/N) `
   });
 }
-async function resolvePermissionRequest(params, mode) {
+function canPromptForPermission2() {
+  return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+}
+async function resolvePermissionRequest(params, mode, nonInteractivePolicy = "deny") {
   const options = params.options ?? [];
   if (options.length === 0) {
     return cancelled();
@@ -1335,6 +1680,15 @@ async function resolvePermissionRequest(params, mode) {
   if (isAutoApprovedReadKind(kind) && allowOption) {
     return selected(allowOption.optionId);
   }
+  if (!canPromptForPermission2()) {
+    if (nonInteractivePolicy === "fail") {
+      throw new PermissionPromptUnavailableError();
+    }
+    if (rejectOption) {
+      return selected(rejectOption.optionId);
+    }
+    return cancelled();
+  }
   const approved = await promptForToolPermission(params);
   if (approved && allowOption) {
     return selected(allowOption.optionId);
@@ -1361,6 +1715,40 @@ function classifyPermissionDecision(params, response) {
   return "denied";
 }
 
+// src/runtime-session-id.ts
+var RUNTIME_SESSION_ID_META_KEYS = [
+  "runtimeSessionId",
+  "providerSessionId",
+  "codexSessionId",
+  "claudeSessionId"
+];
+function normalizeRuntimeSessionId(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function asMetaRecord(meta) {
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+    return void 0;
+  }
+  return meta;
+}
+function extractRuntimeSessionId(meta) {
+  const record = asMetaRecord(meta);
+  if (!record) {
+    return void 0;
+  }
+  for (const key of RUNTIME_SESSION_ID_META_KEYS) {
+    const normalized = normalizeRuntimeSessionId(record[key]);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return void 0;
+}
+
 // src/terminal.ts
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
@@ -1419,6 +1807,9 @@ async function defaultConfirmExecute(commandLine) {
 [permission] Allow terminal command "${commandLine}"? (y/N) `
   });
 }
+function canPromptForPermission3() {
+  return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+}
 function waitMs(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, Math.max(0, ms));
@@ -1427,14 +1818,18 @@ function waitMs(ms) {
 var TerminalManager = class {
   cwd;
   permissionMode;
+  nonInteractivePermissions;
   onOperation;
+  usesDefaultConfirmExecute;
   confirmExecute;
   killGraceMs;
   terminals = /* @__PURE__ */ new Map();
   constructor(options) {
     this.cwd = options.cwd;
     this.permissionMode = options.permissionMode;
+    this.nonInteractivePermissions = options.nonInteractivePermissions ?? "deny";
     this.onOperation = options.onOperation;
+    this.usesDefaultConfirmExecute = options.confirmExecute == null;
     this.confirmExecute = options.confirmExecute ?? defaultConfirmExecute;
     this.killGraceMs = Math.max(
       0,
@@ -1656,6 +2051,9 @@ var TerminalManager = class {
     if (this.permissionMode === "deny-all") {
       return false;
     }
+    if (this.usesDefaultConfirmExecute && this.nonInteractivePermissions === "fail" && !canPromptForPermission3()) {
+      throw new PermissionPromptUnavailableError();
+    }
     return await this.confirmExecute(commandLine);
   }
   isRunning(terminal) {
@@ -1693,6 +2091,24 @@ var TerminalManager = class {
 var REPLAY_IDLE_MS = 80;
 var REPLAY_DRAIN_TIMEOUT_MS = 5e3;
 var DRAIN_POLL_INTERVAL_MS = 20;
+function shouldSuppressSdkConsoleError(args) {
+  if (args.length === 0) {
+    return false;
+  }
+  return typeof args[0] === "string" && args[0] === "Error handling request";
+}
+function installSdkConsoleErrorSuppression() {
+  const originalConsoleError = console.error;
+  console.error = (...args) => {
+    if (shouldSuppressSdkConsoleError(args)) {
+      return;
+    }
+    originalConsoleError(...args);
+  };
+  return () => {
+    console.error = originalConsoleError;
+  };
+}
 function isoNow() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -1835,6 +2251,7 @@ var AcpClient = class {
   agentStartedAt;
   lastAgentExit;
   lastKnownPid;
+  promptPermissionFailures = /* @__PURE__ */ new Map();
   constructor(options) {
     this.options = {
       ...options,
@@ -1845,11 +2262,13 @@ var AcpClient = class {
     this.filesystem = new FileSystemHandlers({
       cwd: this.options.cwd,
       permissionMode: this.options.permissionMode,
+      nonInteractivePermissions: this.options.nonInteractivePermissions,
       onOperation: emitOperation
     });
     this.terminalManager = new TerminalManager({
       cwd: this.options.cwd,
       permissionMode: this.options.permissionMode,
+      nonInteractivePermissions: this.options.nonInteractivePermissions,
       onOperation: emitOperation
     });
   }
@@ -1988,18 +2407,22 @@ var AcpClient = class {
       cwd: asAbsoluteCwd(cwd),
       mcpServers: []
     });
-    return result.sessionId;
+    return {
+      sessionId: result.sessionId,
+      runtimeSessionId: extractRuntimeSessionId(result._meta)
+    };
   }
   async loadSession(sessionId, cwd = this.options.cwd) {
     this.getConnection();
-    await this.loadSessionWithOptions(sessionId, cwd, {});
+    return await this.loadSessionWithOptions(sessionId, cwd, {});
   }
   async loadSessionWithOptions(sessionId, cwd = this.options.cwd, options = {}) {
     const connection = this.getConnection();
     const previousSuppression = this.suppressSessionUpdates;
     this.suppressSessionUpdates = previousSuppression || Boolean(options.suppressReplayUpdates);
+    let response;
     try {
-      await connection.loadSession({
+      response = await connection.loadSession({
         sessionId,
         cwd: asAbsoluteCwd(cwd),
         mcpServers: []
@@ -2011,29 +2434,52 @@ var AcpClient = class {
     } finally {
       this.suppressSessionUpdates = previousSuppression;
     }
+    return {
+      runtimeSessionId: extractRuntimeSessionId(response?._meta)
+    };
   }
   async prompt(sessionId, text) {
     const connection = this.getConnection();
-    const promptPromise = connection.prompt({
-      sessionId,
-      prompt: [
-        {
-          type: "text",
-          text
-        }
-      ]
-    });
+    const restoreConsoleError = this.options.suppressSdkConsoleErrors ? installSdkConsoleErrorSuppression() : void 0;
+    let promptPromise;
+    try {
+      promptPromise = connection.prompt({
+        sessionId,
+        prompt: [
+          {
+            type: "text",
+            text
+          }
+        ]
+      });
+    } catch (error) {
+      restoreConsoleError?.();
+      throw error;
+    }
     this.activePrompt = {
       sessionId,
       promise: promptPromise
     };
     try {
-      return await promptPromise;
+      const response = await promptPromise;
+      const permissionFailure = this.consumePromptPermissionFailure(sessionId);
+      if (permissionFailure) {
+        throw permissionFailure;
+      }
+      return response;
+    } catch (error) {
+      const permissionFailure = this.consumePromptPermissionFailure(sessionId);
+      if (permissionFailure) {
+        throw permissionFailure;
+      }
+      throw error;
     } finally {
+      restoreConsoleError?.();
       if (this.activePrompt?.promise === promptPromise) {
         this.activePrompt = void 0;
       }
       this.cancellingSessionIds.delete(sessionId);
+      this.promptPermissionFailures.delete(sessionId);
     }
   }
   async setSessionMode(sessionId, modeId) {
@@ -2110,6 +2556,7 @@ var AcpClient = class {
     this.suppressSessionUpdates = false;
     this.activePrompt = void 0;
     this.cancellingSessionIds.clear();
+    this.promptPermissionFailures.clear();
     this.connection = void 0;
     this.agent = void 0;
   }
@@ -2177,10 +2624,26 @@ var AcpClient = class {
         }
       };
     }
-    const response = await resolvePermissionRequest(
-      params,
-      this.options.permissionMode
-    );
+    let response;
+    try {
+      response = await resolvePermissionRequest(
+        params,
+        this.options.permissionMode,
+        this.options.nonInteractivePermissions ?? "deny"
+      );
+    } catch (error) {
+      if (error instanceof PermissionPromptUnavailableError) {
+        this.notePromptPermissionFailure(params.sessionId, error);
+        this.permissionStats.requested += 1;
+        this.permissionStats.cancelled += 1;
+        return {
+          outcome: {
+            outcome: "cancelled"
+          }
+        };
+      }
+      throw error;
+    }
     const decision = classifyPermissionDecision(params, response);
     this.permissionStats.requested += 1;
     if (decision === "approved") {
@@ -2219,14 +2682,40 @@ var AcpClient = class {
       unexpectedDuringPrompt: !this.closing && Boolean(this.activePrompt)
     };
   }
+  notePromptPermissionFailure(sessionId, error) {
+    if (!this.promptPermissionFailures.has(sessionId)) {
+      this.promptPermissionFailures.set(sessionId, error);
+    }
+  }
+  consumePromptPermissionFailure(sessionId) {
+    const error = this.promptPermissionFailures.get(sessionId);
+    if (error) {
+      this.promptPermissionFailures.delete(sessionId);
+    }
+    return error;
+  }
   async handleReadTextFile(params) {
     return await this.filesystem.readTextFile(params);
   }
   async handleWriteTextFile(params) {
-    return await this.filesystem.writeTextFile(params);
+    try {
+      return await this.filesystem.writeTextFile(params);
+    } catch (error) {
+      if (error instanceof PermissionPromptUnavailableError) {
+        this.notePromptPermissionFailure(params.sessionId, error);
+      }
+      throw error;
+    }
   }
   async handleCreateTerminal(params) {
-    return await this.terminalManager.createTerminal(params);
+    try {
+      return await this.terminalManager.createTerminal(params);
+    } catch (error) {
+      if (error instanceof PermissionPromptUnavailableError) {
+        this.notePromptPermissionFailure(params.sessionId, error);
+      }
+      throw error;
+    }
   }
   async handleTerminalOutput(params) {
     return await this.terminalManager.terminalOutput(params);
@@ -2325,7 +2814,11 @@ var QueueOwnerTurnController = class {
   }
   assertCanHandleControlRequest() {
     if (this.state === "closing") {
-      throw new QueueConnectionError("Queue owner is closing");
+      throw new QueueConnectionError("Queue owner is closing", {
+        detailCode: "QUEUE_OWNER_SHUTTING_DOWN",
+        origin: "queue",
+        retryable: true
+      });
     }
   }
   async requestCancel() {
@@ -2391,7 +2884,7 @@ import os2 from "os";
 import path4 from "path";
 
 // src/queue-messages.ts
-function asRecord2(value) {
+function asRecord3(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
   }
@@ -2400,8 +2893,34 @@ function asRecord2(value) {
 function isPermissionMode(value) {
   return value === "approve-all" || value === "approve-reads" || value === "deny-all";
 }
+function isNonInteractivePermissionPolicy(value) {
+  return value === "deny" || value === "fail";
+}
+function isOutputErrorCode2(value) {
+  return typeof value === "string" && OUTPUT_ERROR_CODES.includes(value);
+}
+function isOutputErrorOrigin2(value) {
+  return typeof value === "string" && OUTPUT_ERROR_ORIGINS.includes(value);
+}
+function parseAcpError(value) {
+  const record = asRecord3(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 parseQueueRequest(raw) {
-  const request = asRecord2(raw);
+  const request = asRecord3(raw);
   if (!request) {
     return null;
   }
@@ -2411,7 +2930,9 @@ function parseQueueRequest(raw) {
   const timeoutRaw = request.timeoutMs;
   const timeoutMs = typeof timeoutRaw === "number" && Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? Math.round(timeoutRaw) : void 0;
   if (request.type === "submit_prompt") {
-    if (typeof request.message !== "string" || !isPermissionMode(request.permissionMode) || typeof request.waitForCompletion !== "boolean") {
+    const nonInteractivePermissions = request.nonInteractivePermissions == null ? void 0 : isNonInteractivePermissionPolicy(request.nonInteractivePermissions) ? request.nonInteractivePermissions : null;
+    const suppressSdkConsoleErrors = request.suppressSdkConsoleErrors == null ? void 0 : typeof request.suppressSdkConsoleErrors === "boolean" ? request.suppressSdkConsoleErrors : null;
+    if (typeof request.message !== "string" || !isPermissionMode(request.permissionMode) || nonInteractivePermissions === null || suppressSdkConsoleErrors === null || typeof request.waitForCompletion !== "boolean") {
       return null;
     }
     return {
@@ -2419,7 +2940,9 @@ function parseQueueRequest(raw) {
       requestId: request.requestId,
       message: request.message,
       permissionMode: request.permissionMode,
+      nonInteractivePermissions,
       timeoutMs,
+      ...suppressSdkConsoleErrors !== void 0 ? { suppressSdkConsoleErrors } : {},
       waitForCompletion: request.waitForCompletion
     };
   }
@@ -2455,15 +2978,15 @@ function parseQueueRequest(raw) {
   return null;
 }
 function parseSessionSendResult(raw) {
-  const result = asRecord2(raw);
+  const result = asRecord3(raw);
   if (!result) {
     return null;
   }
   if (typeof result.stopReason !== "string" || typeof result.sessionId !== "string" || typeof result.resumed !== "boolean") {
     return null;
   }
-  const permissionStats = asRecord2(result.permissionStats);
-  const record = asRecord2(result.record);
+  const permissionStats = asRecord3(result.permissionStats);
+  const record = asRecord3(result.record);
   if (!permissionStats || !record) {
     return null;
   }
@@ -2478,7 +3001,7 @@ function parseSessionSendResult(raw) {
   return result;
 }
 function parseQueueOwnerMessage(raw) {
-  const message = asRecord2(raw);
+  const message = asRecord3(raw);
   if (!message || typeof message.type !== "string") {
     return null;
   }
@@ -2503,7 +3026,7 @@ function parseQueueOwnerMessage(raw) {
     };
   }
   if (message.type === "client_operation") {
-    const operation = asRecord2(message.operation);
+    const operation = asRecord3(message.operation);
     if (!operation || typeof operation.method !== "string" || typeof operation.status !== "string" || typeof operation.summary !== "string" || typeof operation.timestamp !== "string") {
       return null;
     }
@@ -2558,7 +3081,7 @@ function parseQueueOwnerMessage(raw) {
     };
   }
   if (message.type === "set_config_option_result") {
-    const response = asRecord2(message.response);
+    const response = asRecord3(message.response);
     if (!response || !Array.isArray(response.configOptions)) {
       return null;
     }
@@ -2572,10 +3095,20 @@ function parseQueueOwnerMessage(raw) {
     if (typeof message.message !== "string") {
       return null;
     }
+    const code = isOutputErrorCode2(message.code) ? message.code : void 0;
+    const detailCode = typeof message.detailCode === "string" && message.detailCode.trim().length > 0 ? message.detailCode : void 0;
+    const origin = isOutputErrorOrigin2(message.origin) ? message.origin : void 0;
+    const retryable = typeof message.retryable === "boolean" ? message.retryable : void 0;
+    const acp = parseAcpError(message.acp);
     return {
       type: "error",
       requestId: message.requestId,
-      message: message.message
+      code,
+      detailCode,
+      origin,
+      message: message.message,
+      retryable,
+      acp
     };
   }
   return null;
@@ -2589,21 +3122,34 @@ var QUEUE_CONNECT_RETRY_MS = 50;
 function queueBaseDir() {
   return path4.join(os2.homedir(), ".acpx", "queues");
 }
-function formatError(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 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 isProcessAlive(pid) {
   if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) {
@@ -2847,11 +3393,16 @@ var SessionQueueOwner = class _SessionQueueOwner {
     }
     for (const task of this.pending.splice(0)) {
       if (task.waitForCompletion) {
-        task.send({
-          type: "error",
-          requestId: task.requestId,
-          message: "Queue owner shutting down before prompt execution"
-        });
+        task.send(
+          makeQueueOwnerError(
+            task.requestId,
+            "Queue owner shutting down before prompt execution",
+            "QUEUE_OWNER_SHUTTING_DOWN",
+            {
+              retryable: true
+            }
+          )
+        );
       }
       task.close();
     }
@@ -2890,11 +3441,16 @@ var SessionQueueOwner = class _SessionQueueOwner {
   enqueue(task) {
     if (this.closed) {
       if (task.waitForCompletion) {
-        task.send({
-          type: "error",
-          requestId: task.requestId,
-          message: "Queue owner is shutting down"
-        });
+        task.send(
+          makeQueueOwnerError(
+            task.requestId,
+            "Queue owner is shutting down",
+            "QUEUE_OWNER_SHUTTING_DOWN",
+            {
+              retryable: true
+            }
+          )
+        );
       }
       task.close();
       return;
@@ -2909,22 +3465,24 @@ var SessionQueueOwner = class _SessionQueueOwner {
   handleConnection(socket) {
     socket.setEncoding("utf8");
     if (this.closed) {
-      writeQueueMessage(socket, {
-        type: "error",
-        requestId: "unknown",
-        message: "Queue owner is closed"
-      });
+      writeQueueMessage(
+        socket,
+        makeQueueOwnerError("unknown", "Queue owner is closed", "QUEUE_OWNER_CLOSED", {
+          retryable: true
+        })
+      );
       socket.end();
       return;
     }
     let buffer = "";
     let handled = false;
-    const fail = (requestId, message) => {
-      writeQueueMessage(socket, {
-        type: "error",
-        requestId,
-        message
-      });
+    const fail = (requestId, message, detailCode) => {
+      writeQueueMessage(
+        socket,
+        makeQueueOwnerError(requestId, message, detailCode, {
+          retryable: false
+        })
+      );
       socket.end();
     };
     const processLine = (line) => {
@@ -2936,12 +3494,16 @@ var SessionQueueOwner = class _SessionQueueOwner {
       try {
         parsed = JSON.parse(line);
       } catch {
-        fail("unknown", "Invalid queue request payload");
+        fail(
+          "unknown",
+          "Invalid queue request payload",
+          "QUEUE_REQUEST_PAYLOAD_INVALID_JSON"
+        );
         return;
       }
       const request = parseQueueRequest(parsed);
       if (!request) {
-        fail("unknown", "Invalid queue request");
+        fail("unknown", "Invalid queue request", "QUEUE_REQUEST_INVALID");
         return;
       }
       if (request.type === "cancel_prompt") {
@@ -2956,12 +3518,14 @@ var SessionQueueOwner = class _SessionQueueOwner {
             cancelled: cancelled2
           });
         }).catch((error) => {
-          const message = formatError(error);
-          writeQueueMessage(socket, {
-            type: "error",
-            requestId: request.requestId,
-            message
-          });
+          writeQueueMessage(
+            socket,
+            makeQueueOwnerErrorFromUnknown(
+              request.requestId,
+              error,
+              "QUEUE_CONTROL_REQUEST_FAILED"
+            )
+          );
         }).finally(() => {
           if (!socket.destroyed) {
             socket.end();
@@ -2981,12 +3545,14 @@ var SessionQueueOwner = class _SessionQueueOwner {
             modeId: request.modeId
           });
         }).catch((error) => {
-          const message = formatError(error);
-          writeQueueMessage(socket, {
-            type: "error",
-            requestId: request.requestId,
-            message
-          });
+          writeQueueMessage(
+            socket,
+            makeQueueOwnerErrorFromUnknown(
+              request.requestId,
+              error,
+              "QUEUE_CONTROL_REQUEST_FAILED"
+            )
+          );
         }).finally(() => {
           if (!socket.destroyed) {
             socket.end();
@@ -3006,12 +3572,14 @@ var SessionQueueOwner = class _SessionQueueOwner {
             response
           });
         }).catch((error) => {
-          const message = formatError(error);
-          writeQueueMessage(socket, {
-            type: "error",
-            requestId: request.requestId,
-            message
-          });
+          writeQueueMessage(
+            socket,
+            makeQueueOwnerErrorFromUnknown(
+              request.requestId,
+              error,
+              "QUEUE_CONTROL_REQUEST_FAILED"
+            )
+          );
         }).finally(() => {
           if (!socket.destroyed) {
             socket.end();
@@ -3023,7 +3591,9 @@ var SessionQueueOwner = class _SessionQueueOwner {
         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);
@@ -3071,9 +3641,16 @@ async function submitToQueueOwner(owner, options) {
     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;
@@ -3106,16 +3683,33 @@ async function submitToQueueOwner(owner, options) {
       try {
         parsed = JSON.parse(line);
       } catch {
-        finishReject(new QueueProtocolError("Queue owner sent invalid JSON payload"));
+        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"));
+        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,
@@ -3126,9 +3720,41 @@ async function submitToQueueOwner(owner, options) {
         }
         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")
+          new QueueConnectionError("Queue owner did not acknowledge request", {
+            detailCode: "QUEUE_ACK_MISSING",
+            origin: "queue",
+            retryable: true
+          })
         );
         return;
       }
@@ -3153,11 +3779,13 @@ async function submitToQueueOwner(owner, options) {
         finishResolve(message.result);
         return;
       }
-      if (message.type === "error") {
-        finishReject(new QueueConnectionError(message.message));
-        return;
-      }
-      finishReject(new QueueProtocolError("Queue owner returned unexpected response"));
+      finishReject(
+        new QueueProtocolError("Queue owner returned unexpected response", {
+          detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
+          origin: "queue",
+          retryable: true
+        })
+      );
     };
     socket.on("data", (chunk) => {
       buffer += chunk;
@@ -3181,7 +3809,12 @@ async function submitToQueueOwner(owner, options) {
       if (!acknowledged) {
         finishReject(
           new QueueConnectionError(
-            "Queue owner disconnected before acknowledging request"
+            "Queue owner disconnected before acknowledging request",
+            {
+              detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
+              origin: "queue",
+              retryable: true
+            }
           )
         );
         return;
@@ -3196,7 +3829,11 @@ async function submitToQueueOwner(owner, options) {
         return;
       }
       finishReject(
-        new QueueConnectionError("Queue owner disconnected before prompt completion")
+        new QueueConnectionError("Queue owner disconnected before prompt completion", {
+          detailCode: "QUEUE_DISCONNECTED_BEFORE_COMPLETION",
+          origin: "queue",
+          retryable: true
+        })
       );
     });
     socket.write(`${JSON.stringify(request)}
@@ -3240,31 +3877,59 @@ async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
       try {
         parsed = JSON.parse(line);
       } catch {
-        finishReject(new QueueProtocolError("Queue owner sent invalid JSON payload"));
+        finishReject(
+          new QueueProtocolError("Queue owner sent invalid JSON payload", {
+            detailCode: "QUEUE_PROTOCOL_INVALID_JSON",
+            origin: "queue",
+            retryable: true
+          })
+        );
         return;
       }
       const message = parseQueueOwnerMessage(parsed);
       if (!message || message.requestId !== request.requestId) {
-        finishReject(new QueueProtocolError("Queue owner sent malformed message"));
+        finishReject(
+          new QueueProtocolError("Queue owner sent malformed message", {
+            detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+            origin: "queue",
+            retryable: true
+          })
+        );
         return;
       }
       if (message.type === "accepted") {
         acknowledged = true;
         return;
       }
-      if (!acknowledged) {
+      if (message.type === "error") {
         finishReject(
-          new QueueConnectionError("Queue owner did not acknowledge request")
+          new QueueConnectionError(message.message, {
+            outputCode: message.code,
+            detailCode: message.detailCode,
+            origin: message.origin ?? "queue",
+            retryable: message.retryable,
+            acp: message.acp
+          })
         );
         return;
       }
-      if (message.type === "error") {
-        finishReject(new QueueConnectionError(message.message));
+      if (!acknowledged) {
+        finishReject(
+          new QueueConnectionError("Queue owner did not acknowledge request", {
+            detailCode: "QUEUE_ACK_MISSING",
+            origin: "queue",
+            retryable: true
+          })
+        );
         return;
       }
       if (!isExpectedResponse(message)) {
         finishReject(
-          new QueueProtocolError("Queue owner returned unexpected response")
+          new QueueProtocolError("Queue owner returned unexpected response", {
+            detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
+            origin: "queue",
+            retryable: true
+          })
         );
         return;
       }
@@ -3292,13 +3957,22 @@ async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
       if (!acknowledged) {
         finishReject(
           new QueueConnectionError(
-            "Queue owner disconnected before acknowledging request"
+            "Queue owner disconnected before acknowledging request",
+            {
+              detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
+              origin: "queue",
+              retryable: true
+            }
           )
         );
         return;
       }
       finishReject(
-        new QueueConnectionError("Queue owner disconnected before responding")
+        new QueueConnectionError("Queue owner disconnected before responding", {
+          detailCode: "QUEUE_DISCONNECTED_BEFORE_COMPLETION",
+          origin: "queue",
+          retryable: true
+        })
       );
     });
     socket.write(`${JSON.stringify(request)}
@@ -3319,7 +3993,11 @@ async function submitCancelToQueueOwner(owner) {
     return void 0;
   }
   if (response.requestId !== request.requestId) {
-    throw new QueueProtocolError("Queue owner returned mismatched cancel response");
+    throw new QueueProtocolError("Queue owner returned mismatched cancel response", {
+      detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+      origin: "queue",
+      retryable: true
+    });
   }
   return response.cancelled;
 }
@@ -3339,7 +4017,11 @@ async function submitSetModeToQueueOwner(owner, modeId, timeoutMs) {
     return void 0;
   }
   if (response.requestId !== request.requestId) {
-    throw new QueueProtocolError("Queue owner returned mismatched set_mode response");
+    throw new QueueProtocolError("Queue owner returned mismatched set_mode response", {
+      detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+      origin: "queue",
+      retryable: true
+    });
   }
   return true;
 }
@@ -3361,7 +4043,12 @@ async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeout
   }
   if (response.requestId !== request.requestId) {
     throw new QueueProtocolError(
-      "Queue owner returned mismatched set_config_option response"
+      "Queue owner returned mismatched set_config_option response",
+      {
+        detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+        origin: "queue",
+        retryable: true
+      }
     );
   }
   return response.response;
@@ -3390,7 +4077,12 @@ async function trySubmitToRunningOwner(options) {
     return void 0;
   }
   throw new QueueConnectionError(
-    "Session queue owner is running but not accepting queue requests"
+    "Session queue owner is running but not accepting queue requests",
+    {
+      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+      origin: "queue",
+      retryable: true
+    }
   );
 }
 async function tryCancelOnRunningOwner(options) {
@@ -3417,7 +4109,12 @@ async function tryCancelOnRunningOwner(options) {
     return void 0;
   }
   throw new QueueConnectionError(
-    "Session queue owner is running but not accepting cancel requests"
+    "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) {
@@ -3444,7 +4141,12 @@ async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
     return void 0;
   }
   throw new QueueConnectionError(
-    "Session queue owner is running but not accepting set_mode requests"
+    "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) {
@@ -3476,7 +4178,12 @@ async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, time
     return void 0;
   }
   throw new QueueConnectionError(
-    "Session queue owner is running but not accepting set_config_option requests"
+    "Session queue owner is running but not accepting set_config_option requests",
+    {
+      detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+      origin: "queue",
+      retryable: true
+    }
   );
 }
 async function terminateQueueOwnerForSession(sessionId) {
@@ -3537,6 +4244,7 @@ function parseSessionRecord(raw) {
     return null;
   }
   const record = raw;
+  const runtimeSessionId = normalizeRuntimeSessionId(record.runtimeSessionId);
   const name = record.name == null ? void 0 : typeof record.name === "string" && record.name.trim().length > 0 ? record.name.trim() : null;
   const pid = record.pid == null ? void 0 : Number.isInteger(record.pid) && record.pid > 0 ? record.pid : null;
   const closed = record.closed == null ? false : typeof record.closed === "boolean" ? record.closed : null;
@@ -3559,6 +4267,7 @@ function parseSessionRecord(raw) {
     ...record,
     id: record.id,
     sessionId: record.sessionId,
+    runtimeSessionId,
     agentCommand: record.agentCommand,
     cwd: record.cwd,
     name,
@@ -3815,6 +4524,8 @@ var QueueTaskOutputFormatter = class {
     this.requestId = task.requestId;
     this.send = task.send;
   }
+  setContext() {
+  }
   onSessionUpdate(notification) {
     this.send({
       type: "session_update",
@@ -3836,16 +4547,32 @@ var QueueTaskOutputFormatter = class {
       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() {
   }
 };
@@ -3858,22 +4585,6 @@ function normalizeQueueOwnerTtlMs(ttlMs) {
   }
   return Math.round(ttlMs);
 }
-function formatError2(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 collapseWhitespace2(value) {
   return value.replace(/\s+/g, " ").trim();
 }
@@ -3949,16 +4660,18 @@ function applyLifecycleSnapshotToRecord(record, snapshot) {
   record.lastAgentExitAt = void 0;
   record.lastAgentDisconnectReason = void 0;
 }
+function reconcileRuntimeSessionId(record, runtimeSessionId) {
+  const normalized = normalizeRuntimeSessionId(runtimeSessionId);
+  if (!normalized) {
+    return;
+  }
+  record.runtimeSessionId = normalized;
+}
 function shouldFallbackToNewSession(error) {
   if (error instanceof TimeoutError || error instanceof InterruptedError) {
     return false;
   }
-  const message = formatError2(error).toLowerCase();
-  if (message.includes("resource_not_found") || message.includes("resource not found") || message.includes("session not found") || message.includes("unknown session") || message.includes("invalid session")) {
-    return true;
-  }
-  const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
-  return code === -32001 || code === -32002;
+  return isAcpResourceNotFoundError(error);
 }
 async function connectAndLoadSession(options) {
   const record = options.record;
@@ -3990,31 +4703,40 @@ async function connectAndLoadSession(options) {
   let sessionId = record.sessionId;
   if (client.supportsLoadSession()) {
     try {
-      await withTimeout(
+      const loadResult = await withTimeout(
         client.loadSessionWithOptions(record.sessionId, record.cwd, {
           suppressReplayUpdates: true
         }),
         options.timeoutMs
       );
+      reconcileRuntimeSessionId(record, loadResult.runtimeSessionId);
       resumed = true;
     } catch (error) {
-      loadError = formatError2(error);
+      loadError = formatErrorMessage(error);
       if (!shouldFallbackToNewSession(error)) {
         throw error;
       }
-      sessionId = await withTimeout(
+      const createdSession = await withTimeout(
         client.createSession(record.cwd),
         options.timeoutMs
       );
+      sessionId = createdSession.sessionId;
       record.sessionId = sessionId;
+      reconcileRuntimeSessionId(record, createdSession.runtimeSessionId);
     }
   } else {
-    sessionId = await withTimeout(client.createSession(record.cwd), options.timeoutMs);
+    const createdSession = await withTimeout(
+      client.createSession(record.cwd),
+      options.timeoutMs
+    );
+    sessionId = createdSession.sessionId;
     record.sessionId = sessionId;
+    reconcileRuntimeSessionId(record, createdSession.runtimeSessionId);
   }
   options.onSessionIdResolved?.(sessionId);
   return {
     sessionId,
+    runtimeSessionId: record.runtimeSessionId,
     resumed,
     loadError
   };
@@ -4026,10 +4748,12 @@ async function runQueuedTask(sessionRecordId, task, options) {
       sessionRecordId,
       message: task.message,
       permissionMode: task.permissionMode,
+      nonInteractivePermissions: task.nonInteractivePermissions ?? options.nonInteractivePermissions,
       authCredentials: options.authCredentials,
       authPolicy: options.authPolicy,
       outputFormatter,
       timeoutMs: task.timeoutMs,
+      suppressSdkConsoleErrors: task.suppressSdkConsoleErrors ?? options.suppressSdkConsoleErrors,
       verbose: options.verbose,
       onClientAvailable: options.onClientAvailable,
       onClientClosed: options.onClientClosed,
@@ -4043,12 +4767,20 @@ async function runQueuedTask(sessionRecordId, task, options) {
       });
     }
   } catch (error) {
-    const message = formatError2(error);
+    const normalizedError = normalizeOutputError(error, {
+      origin: "runtime",
+      detailCode: "QUEUE_RUNTIME_PROMPT_FAILED"
+    });
     if (task.waitForCompletion) {
       task.send({
         type: "error",
         requestId: task.requestId,
-        message
+        code: normalizedError.code,
+        detailCode: normalizedError.detailCode,
+        origin: normalizedError.origin,
+        message: normalizedError.message,
+        retryable: normalizedError.retryable,
+        acp: normalizedError.acp
       });
     }
     if (error instanceof InterruptedError) {
@@ -4061,13 +4793,19 @@ async function runQueuedTask(sessionRecordId, task, options) {
 async function runSessionPrompt(options) {
   const output = options.outputFormatter;
   const record = await resolveSessionRecord(options.sessionRecordId);
+  output.setContext({
+    sessionId: record.id,
+    stream: "prompt"
+  });
   const assistantSnippets = [];
   const client = new AcpClient({
     agentCommand: record.agentCommand,
     cwd: absolutePath(record.cwd),
     permissionMode: options.permissionMode,
+    nonInteractivePermissions: options.nonInteractivePermissions,
     authCredentials: options.authCredentials,
     authPolicy: options.authPolicy,
+    suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
     verbose: options.verbose,
     onSessionUpdate: (notification) => {
       output.onSessionUpdate(notification);
@@ -4129,7 +4867,7 @@ async function runSessionPrompt(options) {
             } catch (error) {
               if (options.verbose) {
                 process.stderr.write(
-                  `[acpx] onPromptActive hook failed: ${formatError2(error)}
+                  `[acpx] onPromptActive hook failed: ${formatErrorMessage(error)}
 `
                 );
               }
@@ -4209,6 +4947,7 @@ async function withConnectedSession(options) {
     agentCommand: record.agentCommand,
     cwd: absolutePath(record.cwd),
     permissionMode: options.permissionMode ?? "approve-reads",
+    nonInteractivePermissions: options.nonInteractivePermissions,
     authCredentials: options.authCredentials,
     authPolicy: options.authPolicy,
     verbose: options.verbose
@@ -4288,6 +5027,7 @@ async function withConnectedSession(options) {
 async function runSessionSetModeDirect(options) {
   const result = await withConnectedSession({
     sessionRecordId: options.sessionRecordId,
+    nonInteractivePermissions: options.nonInteractivePermissions,
     authCredentials: options.authCredentials,
     authPolicy: options.authPolicy,
     timeoutMs: options.timeoutMs,
@@ -4310,6 +5050,7 @@ async function runSessionSetModeDirect(options) {
 async function runSessionSetConfigOptionDirect(options) {
   const result = await withConnectedSession({
     sessionRecordId: options.sessionRecordId,
+    nonInteractivePermissions: options.nonInteractivePermissions,
     authCredentials: options.authCredentials,
     authPolicy: options.authPolicy,
     timeoutMs: options.timeoutMs,
@@ -4336,8 +5077,10 @@ async function runOnce(options) {
     agentCommand: options.agentCommand,
     cwd: absolutePath(options.cwd),
     permissionMode: options.permissionMode,
+    nonInteractivePermissions: options.nonInteractivePermissions,
     authCredentials: options.authCredentials,
     authPolicy: options.authPolicy,
+    suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
     verbose: options.verbose,
     onSessionUpdate: (notification) => output.onSessionUpdate(notification),
     onClientOperation: (operation) => output.onClientOperation(operation)
@@ -4346,10 +5089,15 @@ async function runOnce(options) {
     return await withInterrupt(
       async () => {
         await withTimeout(client.start(), options.timeoutMs);
-        const sessionId = await withTimeout(
+        const createdSession = await withTimeout(
           client.createSession(absolutePath(options.cwd)),
           options.timeoutMs
         );
+        const sessionId = createdSession.sessionId;
+        output.setContext({
+          sessionId,
+          stream: "prompt"
+        });
         const response = await withTimeout(
           client.prompt(sessionId, options.message),
           options.timeoutMs
@@ -4372,6 +5120,7 @@ async function createSession(options) {
     agentCommand: options.agentCommand,
     cwd: absolutePath(options.cwd),
     permissionMode: options.permissionMode,
+    nonInteractivePermissions: options.nonInteractivePermissions,
     authCredentials: options.authCredentials,
     authPolicy: options.authPolicy,
     verbose: options.verbose
@@ -4380,15 +5129,17 @@ async function createSession(options) {
     return await withInterrupt(
       async () => {
         await withTimeout(client.start(), options.timeoutMs);
-        const sessionId = await withTimeout(
+        const createdSession = await withTimeout(
           client.createSession(absolutePath(options.cwd)),
           options.timeoutMs
         );
+        const sessionId = createdSession.sessionId;
         const lifecycle = client.getAgentLifecycleSnapshot();
         const now = isoNow2();
         const record = {
           id: sessionId,
           sessionId,
+          runtimeSessionId: createdSession.runtimeSessionId,
           agentCommand: options.agentCommand,
           cwd: absolutePath(options.cwd),
           name: normalizeName(options.name),
@@ -4413,6 +5164,38 @@ async function createSession(options) {
     await client.close();
   }
 }
+async function ensureSession(options) {
+  const cwd = absolutePath(options.cwd);
+  const gitRoot = findGitRepositoryRoot(cwd);
+  const walkBoundary = options.walkBoundary ?? gitRoot ?? cwd;
+  const existing = await findSessionByDirectoryWalk({
+    agentCommand: options.agentCommand,
+    cwd,
+    name: options.name,
+    boundary: walkBoundary
+  });
+  if (existing) {
+    return {
+      record: existing,
+      created: false
+    };
+  }
+  const record = await createSession({
+    agentCommand: options.agentCommand,
+    cwd,
+    name: options.name,
+    permissionMode: options.permissionMode,
+    nonInteractivePermissions: options.nonInteractivePermissions,
+    authCredentials: options.authCredentials,
+    authPolicy: options.authPolicy,
+    timeoutMs: options.timeoutMs,
+    verbose: options.verbose
+  });
+  return {
+    record,
+    created: true
+  };
+}
 async function sendSession(options) {
   const waitForCompletion = options.waitForCompletion !== false;
   const queueOwnerTtlMs = normalizeQueueOwnerTtlMs(options.ttlMs);
@@ -4420,8 +5203,11 @@ async function sendSession(options) {
     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
   });
@@ -4435,8 +5221,11 @@ async function sendSession(options) {
         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
       });
@@ -4453,6 +5242,7 @@ async function sendSession(options) {
         await runSessionSetModeDirect({
           sessionRecordId: options.sessionId,
           modeId,
+          nonInteractivePermissions: options.nonInteractivePermissions,
           authCredentials: options.authCredentials,
           authPolicy: options.authPolicy,
           timeoutMs,
@@ -4464,6 +5254,7 @@ async function sendSession(options) {
           sessionRecordId: options.sessionId,
           configId,
           value,
+          nonInteractivePermissions: options.nonInteractivePermissions,
           authCredentials: options.authCredentials,
           authPolicy: options.authPolicy,
           timeoutMs,
@@ -4479,7 +5270,7 @@ async function sendSession(options) {
       void applyPendingCancel().catch((error) => {
         if (options.verbose) {
           process.stderr.write(
-            `[acpx] failed to apply deferred cancel: ${formatError2(error)}
+            `[acpx] failed to apply deferred cancel: ${formatErrorMessage(error)}
 `
           );
         }
@@ -4526,10 +5317,12 @@ async function sendSession(options) {
           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,
@@ -4554,8 +5347,10 @@ async function sendSession(options) {
         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 () => {
@@ -4598,6 +5393,7 @@ async function setSessionMode(options) {
   return await runSessionSetModeDirect({
     sessionRecordId: options.sessionId,
     modeId: options.modeId,
+    nonInteractivePermissions: options.nonInteractivePermissions,
     authCredentials: options.authCredentials,
     authPolicy: options.authPolicy,
     timeoutMs: options.timeoutMs,
@@ -4623,6 +5419,7 @@ async function setSessionConfigOption(options) {
     sessionRecordId: options.sessionId,
     configId: options.configId,
     value: options.value,
+    nonInteractivePermissions: options.nonInteractivePermissions,
     authCredentials: options.authCredentials,
     authPolicy: options.authPolicy,
     timeoutMs: options.timeoutMs,
@@ -4669,19 +5466,6 @@ async function closeSession(sessionId) {
   return record;
 }
 
-// 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"];
-
 // src/cli.ts
 var NoSessionError = class extends Error {
   constructor(message) {
@@ -4716,6 +5500,16 @@ function parseAuthPolicy2(value) {
   }
   return value;
 }
+function parseNonInteractivePermissionPolicy2(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 parseTimeoutSeconds(value) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed) || parsed <= 0) {
@@ -4817,7 +5611,14 @@ function addGlobalFlags(command) {
   ).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("--format <fmt>", "Output format: text, json, quiet", parseOutputFormat2).option(
+  ).option("--deny-all", "Deny all permission requests").option(
+    "--non-interactive-permissions <policy>",
+    "When prompting is unavailable: deny or fail",
+    parseNonInteractivePermissionPolicy2
+  ).option("--format <fmt>", "Output format: text, json, quiet", parseOutputFormat2).option(
+    "--json-strict",
+    "Strict JSON mode: requires --format json and suppresses non-JSON stderr output"
+  ).option(
     "--timeout <seconds>",
     "Maximum time to wait for agent response",
     parseTimeoutSeconds
@@ -4866,19 +5667,39 @@ function addPromptInputOption(command) {
 }
 function resolveGlobalFlags(command, config) {
   const opts = command.optsWithGlobals();
+  const format = opts.format ?? config.format ?? "text";
+  const jsonStrict = opts.jsonStrict === true;
+  const verbose = opts.verbose === true;
+  if (jsonStrict && format !== "json") {
+    throw new InvalidArgumentError("--json-strict requires --format json");
+  }
+  if (jsonStrict && verbose) {
+    throw new InvalidArgumentError("--json-strict cannot be combined with --verbose");
+  }
   return {
     agent: opts.agent,
     cwd: opts.cwd ?? process.cwd(),
     authPolicy: opts.authPolicy ?? config.authPolicy,
+    nonInteractivePermissions: opts.nonInteractivePermissions ?? config.nonInteractivePermissions,
+    jsonStrict,
     timeout: opts.timeout ?? config.timeoutMs,
     ttl: opts.ttl ?? config.ttlMs ?? DEFAULT_QUEUE_OWNER_TTL_MS,
-    verbose: opts.verbose === true,
-    format: opts.format ?? config.format ?? "text",
+    verbose,
+    format,
     approveAll: opts.approveAll ? true : void 0,
     approveReads: opts.approveReads ? true : void 0,
     denyAll: opts.denyAll ? true : void 0
   };
 }
+function resolveOutputPolicy(format, jsonStrict) {
+  return {
+    format,
+    jsonStrict,
+    suppressNonJsonStderr: jsonStrict,
+    queueErrorAlreadyEmitted: format !== "quiet",
+    suppressSdkConsoleErrors: jsonStrict
+  };
+}
 function resolveAgentInvocation(explicitAgentName, globalFlags, config) {
   const override = globalFlags.agent?.trim();
   if (override && explicitAgentName) {
@@ -4939,6 +5760,13 @@ function printClosedSessionByFormat(record, format) {
   process.stdout.write(`${record.id}
 `);
 }
+function runtimeSessionIdPayload(runtimeSessionId) {
+  const normalized = normalizeRuntimeSessionId(runtimeSessionId);
+  if (!normalized) {
+    return {};
+  }
+  return { runtimeSessionId: normalized };
+}
 function printNewSessionByFormat(record, replaced, format) {
   if (format === "json") {
     process.stdout.write(
@@ -4947,7 +5775,8 @@ function printNewSessionByFormat(record, replaced, format) {
         id: record.id,
         sessionId: record.sessionId,
         name: record.name,
-        replacedSessionId: replaced?.id
+        replacedSessionId: replaced?.id,
+        ...runtimeSessionIdPayload(record.runtimeSessionId)
       })}
 `
     );
@@ -4966,6 +5795,30 @@ function printNewSessionByFormat(record, replaced, format) {
   process.stdout.write(`${record.id}
 `);
 }
+function printEnsuredSessionByFormat(record, created, format) {
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({
+        type: "session_ensured",
+        id: record.id,
+        sessionId: record.sessionId,
+        name: record.name,
+        created,
+        ...runtimeSessionIdPayload(record.runtimeSessionId)
+      })}
+`
+    );
+    return;
+  }
+  if (format === "quiet") {
+    process.stdout.write(`${record.id}
+`);
+    return;
+  }
+  const action = created ? "created" : "existing";
+  process.stdout.write(`${record.id}	(${action})
+`);
+}
 function printQueuedPromptByFormat(result, format) {
   if (format === "json") {
     process.stdout.write(
@@ -5008,15 +5861,15 @@ function formatPromptSessionBannerLine(record, currentCwd) {
   }
   return `[acpx] session ${label} (${record.id}) \xB7 ${normalizedSessionCwd} \xB7 agent ${status}`;
 }
-function printPromptSessionBanner(record, currentCwd, format) {
-  if (format === "quiet") {
+function printPromptSessionBanner(record, currentCwd, format, jsonStrict = false) {
+  if (format === "quiet" || jsonStrict && format === "json") {
     return;
   }
   process.stderr.write(`${formatPromptSessionBannerLine(record, currentCwd)}
 `);
 }
-function printCreatedSessionBanner(record, agentName, format) {
-  if (format === "quiet") {
+function printCreatedSessionBanner(record, agentName, format, jsonStrict = false) {
+  if (format === "quiet" || jsonStrict && format === "json") {
     return;
   }
   const label = formatSessionLabel(record);
@@ -5047,9 +5900,12 @@ Create one: ${createCmd}`
 }
 async function handlePrompt(explicitAgentName, promptParts, flags, command, config) {
   const globalFlags = resolveGlobalFlags(command, config);
+  const outputPolicy = resolveOutputPolicy(
+    globalFlags.format,
+    globalFlags.jsonStrict === true
+  );
   const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
   const prompt = await readPrompt(promptParts, flags.file, globalFlags.cwd);
-  const outputFormatter = createOutputFormatter(globalFlags.format);
   const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
   const record = await findRoutedSessionOrThrow(
     agent.agentCommand,
@@ -5057,21 +5913,37 @@ async function handlePrompt(explicitAgentName, promptParts, flags, command, conf
     agent.cwd,
     flags.session
   );
-  printPromptSessionBanner(record, agent.cwd, globalFlags.format);
+  const outputFormatter = createOutputFormatter(outputPolicy.format, {
+    jsonContext: {
+      sessionId: record.id,
+      stream: "prompt"
+    }
+  });
+  printPromptSessionBanner(
+    record,
+    agent.cwd,
+    outputPolicy.format,
+    outputPolicy.jsonStrict
+  );
   const result = await sendSession({
     sessionId: record.id,
     message: prompt,
     permissionMode,
+    nonInteractivePermissions: globalFlags.nonInteractivePermissions,
     authCredentials: config.auth,
     authPolicy: globalFlags.authPolicy,
     outputFormatter,
+    errorEmissionPolicy: {
+      queueErrorAlreadyEmitted: outputPolicy.queueErrorAlreadyEmitted
+    },
+    suppressSdkConsoleErrors: outputPolicy.suppressSdkConsoleErrors,
     timeoutMs: globalFlags.timeout,
     ttlMs: globalFlags.ttl,
     verbose: globalFlags.verbose,
     waitForCompletion: flags.wait !== false
   });
   if ("queued" in result) {
-    printQueuedPromptByFormat(result, globalFlags.format);
+    printQueuedPromptByFormat(result, outputPolicy.format);
     return;
   }
   applyPermissionExitCode(result);
@@ -5084,18 +5956,24 @@ async function handlePrompt(explicitAgentName, promptParts, flags, command, conf
 }
 async function handleExec(explicitAgentName, promptParts, flags, command, config) {
   const globalFlags = resolveGlobalFlags(command, config);
+  const outputPolicy = resolveOutputPolicy(
+    globalFlags.format,
+    globalFlags.jsonStrict === true
+  );
   const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
   const prompt = await readPrompt(promptParts, flags.file, globalFlags.cwd);
-  const outputFormatter = createOutputFormatter(globalFlags.format);
+  const outputFormatter = createOutputFormatter(outputPolicy.format);
   const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
   const result = await runOnce({
     agentCommand: agent.agentCommand,
     cwd: agent.cwd,
     message: prompt,
     permissionMode,
+    nonInteractivePermissions: globalFlags.nonInteractivePermissions,
     authCredentials: config.auth,
     authPolicy: globalFlags.authPolicy,
     outputFormatter,
+    suppressSdkConsoleErrors: outputPolicy.suppressSdkConsoleErrors,
     timeoutMs: globalFlags.timeout,
     verbose: globalFlags.verbose
   });
@@ -5196,6 +6074,7 @@ async function handleSetMode(explicitAgentName, modeId, flags, command, config)
   const result = await setSessionMode({
     sessionId: record.id,
     modeId,
+    nonInteractivePermissions: globalFlags.nonInteractivePermissions,
     authCredentials: config.auth,
     authPolicy: globalFlags.authPolicy,
     timeoutMs: globalFlags.timeout,
@@ -5222,6 +6101,7 @@ async function handleSetConfigOption(explicitAgentName, configId, value, flags,
     sessionId: record.id,
     configId,
     value,
+    nonInteractivePermissions: globalFlags.nonInteractivePermissions,
     authCredentials: config.auth,
     authPolicy: globalFlags.authPolicy,
     timeoutMs: globalFlags.timeout,
@@ -5281,12 +6161,18 @@ async function handleSessionsNew(explicitAgentName, flags, command, config) {
     cwd: agent.cwd,
     name: flags.name,
     permissionMode,
+    nonInteractivePermissions: globalFlags.nonInteractivePermissions,
     authCredentials: config.auth,
     authPolicy: globalFlags.authPolicy,
     timeoutMs: globalFlags.timeout,
     verbose: globalFlags.verbose
   });
-  printCreatedSessionBanner(created, agent.agentName, globalFlags.format);
+  printCreatedSessionBanner(
+    created,
+    agent.agentName,
+    globalFlags.format,
+    globalFlags.jsonStrict
+  );
   if (globalFlags.verbose) {
     const scope = flags.name ? `named session "${flags.name}"` : "cwd session";
     process.stderr.write(`[acpx] created ${scope}: ${created.id}
@@ -5294,6 +6180,31 @@ async function handleSessionsNew(explicitAgentName, flags, command, config) {
   }
   printNewSessionByFormat(created, replaced, globalFlags.format);
 }
+async function handleSessionsEnsure(explicitAgentName, flags, command, config) {
+  const globalFlags = resolveGlobalFlags(command, config);
+  const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
+  const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
+  const result = await ensureSession({
+    agentCommand: agent.agentCommand,
+    cwd: agent.cwd,
+    name: flags.name,
+    permissionMode,
+    nonInteractivePermissions: globalFlags.nonInteractivePermissions,
+    authCredentials: config.auth,
+    authPolicy: globalFlags.authPolicy,
+    timeoutMs: globalFlags.timeout,
+    verbose: globalFlags.verbose
+  });
+  if (result.created) {
+    printCreatedSessionBanner(
+      result.record,
+      agent.agentName,
+      globalFlags.format,
+      globalFlags.jsonStrict
+    );
+  }
+  printEnsuredSessionByFormat(result.record, result.created, globalFlags.format);
+}
 function printSessionDetailsByFormat(record, format) {
   if (format === "json") {
     process.stdout.write(`${JSON.stringify(record)}
@@ -5308,6 +6219,8 @@ function printSessionDetailsByFormat(record, format) {
   process.stdout.write(`id: ${record.id}
 `);
   process.stdout.write(`sessionId: ${record.sessionId}
+`);
+  process.stdout.write(`runtimeSessionId: ${record.runtimeSessionId ?? "-"}
 `);
   process.stdout.write(`agent: ${record.agentCommand}
 `);
@@ -5476,7 +6389,8 @@ 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,
+    ...runtimeSessionIdPayload(record.runtimeSessionId)
   };
   if (globalFlags.format === "json") {
     process.stdout.write(`${JSON.stringify(payload)}
@@ -5490,6 +6404,10 @@ async function handleStatus(explicitAgentName, flags, command, config) {
   }
   process.stdout.write(`session: ${payload.sessionId}
 `);
+  if ("runtimeSessionId" in payload) {
+    process.stdout.write(`runtimeSessionId: ${payload.runtimeSessionId}
+`);
+  }
   process.stdout.write(`agent: ${payload.agentCommand}
 `);
   process.stdout.write(`pid: ${payload.pid ?? "-"}
@@ -5555,7 +6473,7 @@ async function handleConfigInit(command, config) {
 `);
 }
 function registerSessionsCommand(parent, explicitAgentName, config) {
-  const sessionsCommand = parent.command("sessions").description("List, create, or close sessions for this agent");
+  const sessionsCommand = parent.command("sessions").description("List, ensure, create, or close sessions for this agent");
   sessionsCommand.action(async function() {
     await handleSessionsList(explicitAgentName, this, config);
   });
@@ -5565,6 +6483,9 @@ function registerSessionsCommand(parent, explicitAgentName, config) {
   sessionsCommand.command("new").description("Create a fresh session for current cwd").option("--name <name>", "Session name", parseSessionName).action(async function(flags) {
     await handleSessionsNew(explicitAgentName, flags, this, config);
   });
+  sessionsCommand.command("ensure").description("Ensure a session exists for current cwd or ancestor").option("--name <name>", "Session name", parseSessionName).action(async function(flags) {
+    await handleSessionsEnsure(explicitAgentName, flags, this, config);
+  });
   sessionsCommand.command("close").description("Close session for current cwd").argument("[name]", "Session name", parseSessionName).action(async function(name) {
     await handleSessionsClose(explicitAgentName, name, this, config);
   });
@@ -5685,14 +6606,14 @@ function detectAgentToken(argv) {
       hasAgentOverride = true;
       continue;
     }
-    if (token === "--cwd" || token === "--auth-policy" || token === "--format" || token === "--timeout" || token === "--ttl" || token === "--file") {
+    if (token === "--cwd" || token === "--auth-policy" || token === "--non-interactive-permissions" || token === "--format" || token === "--timeout" || token === "--ttl" || token === "--file") {
       index += 1;
       continue;
     }
-    if (token.startsWith("--cwd=") || token.startsWith("--auth-policy=") || token.startsWith("--format=") || token.startsWith("--timeout=") || token.startsWith("--ttl=") || token.startsWith("--file=")) {
+    if (token.startsWith("--cwd=") || token.startsWith("--auth-policy=") || token.startsWith("--non-interactive-permissions=") || token.startsWith("--format=") || token.startsWith("--json-strict=") || token.startsWith("--timeout=") || token.startsWith("--ttl=") || token.startsWith("--file=")) {
       continue;
     }
-    if (token === "--approve-all" || token === "--approve-reads" || token === "--deny-all" || token === "--verbose") {
+    if (token === "--approve-all" || token === "--approve-reads" || token === "--deny-all" || token === "--json-strict" || token === "--verbose") {
       continue;
     }
     return { hasAgentOverride };
@@ -5722,15 +6643,103 @@ function detectInitialCwd(argv) {
   }
   return process.cwd();
 }
+function detectRequestedOutputFormat(argv, fallback) {
+  let detectedFormat = fallback;
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--") {
+      break;
+    }
+    if (token === "--json-strict" || token.startsWith("--json-strict=")) {
+      return "json";
+    }
+    if (token === "--format") {
+      const raw = argv[index + 1];
+      if (raw && OUTPUT_FORMATS.includes(raw)) {
+        detectedFormat = raw;
+      }
+      continue;
+    }
+    if (token.startsWith("--format=")) {
+      const raw = token.slice("--format=".length).trim();
+      if (OUTPUT_FORMATS.includes(raw)) {
+        detectedFormat = raw;
+      }
+    }
+  }
+  return detectedFormat;
+}
+function detectJsonStrict(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--") {
+      break;
+    }
+    if (token === "--json-strict") {
+      return true;
+    }
+    if (token.startsWith("--json-strict=")) {
+      return true;
+    }
+  }
+  return false;
+}
+function emitJsonErrorEvent(error) {
+  const formatter = createOutputFormatter("json", {
+    jsonContext: {
+      sessionId: "unknown",
+      stream: "control"
+    }
+  });
+  formatter.onError(error);
+  formatter.flush();
+}
+function isOutputAlreadyEmitted(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  return error.outputAlreadyEmitted === true;
+}
+function emitRequestedError(error, normalized, outputPolicy) {
+  if (isOutputAlreadyEmitted(error)) {
+    return;
+  }
+  if (outputPolicy.format === "json") {
+    emitJsonErrorEvent(normalized);
+  } else if (!outputPolicy.suppressNonJsonStderr) {
+    process.stderr.write(`${normalized.message}
+`);
+  }
+}
+async function runWithOutputPolicy(_outputPolicy, run) {
+  return await run();
+}
 async function main(argv = process.argv) {
   await maybeHandleSkillflag(argv, {
     skillsRoot: findSkillsRoot(import.meta.url),
     includeBundledSkill: false
   });
   const config = await loadResolvedConfig(detectInitialCwd(argv.slice(2)));
+  const requestedJsonStrict = detectJsonStrict(argv.slice(2));
+  const requestedOutputFormat = detectRequestedOutputFormat(
+    argv.slice(2),
+    config.format
+  );
+  const requestedOutputPolicy = resolveOutputPolicy(
+    requestedOutputFormat,
+    requestedJsonStrict
+  );
   const builtInAgents = listBuiltInAgents(config.agents);
   const program = new Command();
   program.name("acpx").description("Headless CLI client for the Agent Client Protocol").enablePositionalOptions().showHelpAfterError();
+  if (requestedJsonStrict) {
+    program.configureOutput({
+      writeOut: () => {
+      },
+      writeErr: () => {
+      }
+    });
+  }
   addGlobalFlags(program);
   for (const agentName of builtInAgents) {
     registerAgentCommand(program, agentName, config);
@@ -5742,6 +6751,11 @@ async function main(argv = process.argv) {
   }
   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;
     }
@@ -5762,6 +6776,7 @@ Examples:
   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
@@ -5774,33 +6789,33 @@ Examples:
   program.exitOverride((error) => {
     throw error;
   });
-  try {
-    await program.parseAsync(argv);
-  } catch (error) {
-    if (error instanceof CommanderError) {
-      if (error.code === "commander.helpDisplayed" || error.code === "commander.version") {
-        process.exit(EXIT_CODES.SUCCESS);
+  await runWithOutputPolicy(requestedOutputPolicy, async () => {
+    try {
+      await program.parseAsync(argv);
+    } catch (error) {
+      if (error instanceof CommanderError) {
+        if (error.code === "commander.helpDisplayed" || error.code === "commander.version") {
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        const normalized2 = normalizeOutputError(error, {
+          defaultCode: "USAGE",
+          origin: "cli"
+        });
+        if (requestedOutputPolicy.format === "json") {
+          emitRequestedError(error, normalized2, requestedOutputPolicy);
+        }
+        process.exit(exitCodeForOutputErrorCode(normalized2.code));
       }
-      process.exit(EXIT_CODES.USAGE);
-    }
-    if (error instanceof InterruptedError) {
-      process.exit(EXIT_CODES.INTERRUPTED);
-    }
-    if (error instanceof TimeoutError) {
-      process.stderr.write(`${error.message}
-`);
-      process.exit(EXIT_CODES.TIMEOUT);
-    }
-    if (error instanceof NoSessionError) {
-      process.stderr.write(`${error.message}
-`);
-      process.exit(EXIT_CODES.NO_SESSION);
+      if (error instanceof InterruptedError) {
+        process.exit(EXIT_CODES.INTERRUPTED);
+      }
+      const normalized = normalizeOutputError(error, {
+        origin: "cli"
+      });
+      emitRequestedError(error, normalized, requestedOutputPolicy);
+      process.exit(exitCodeForOutputErrorCode(normalized.code));
     }
-    const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`${message}
-`);
-    process.exit(EXIT_CODES.ERROR);
-  }
+  });
 }
 function isCliEntrypoint(argv) {
   const entry = argv[1];