happy-imou-cloud 2.1.49 → 2.1.51

package/dist/AcpBackend-CqO3D07V.mjs

@@ -0,0 +1,2619 @@
+import spawn from 'cross-spawn';
+import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
+import { randomUUID } from 'node:crypto';
+import { l as logger, H as HeadTailPreviewBuffer, p as packageJson, e as delay } from './types-B5vtxa38.mjs';
+import { i as isTerminalReferenceOnlyPayload, f as formatDisplayMessage } from './RuntimeShell-BDt42io_.mjs';
+import { D as DefaultTransport, f as resolveAcpSessionPreferences, g as buildAcpSessionConfigPresetPlan, h as resolveAcpPostPromptNoUpdatesTimeoutMs, i as resolveAcpResponseWaitTimeoutMs } from './index-CX-F_fuk.mjs';
+import psList from 'ps-list';
+
+const DEFAULT_IDLE_TIMEOUT_MS = 500;
+const DEFAULT_TOOL_CALL_TIMEOUT_MS = 10 * 6e4;
+const DEFAULT_TOOL_CALL_OUTPUT_PREVIEW_HEAD_BYTES = 4096;
+const DEFAULT_TOOL_CALL_OUTPUT_PREVIEW_TAIL_BYTES = 12288;
+function parseArgsFromContent(content) {
+  if (Array.isArray(content)) {
+    return { items: content };
+  }
+  if (content && typeof content === "object" && content !== null) {
+    return content;
+  }
+  return {};
+}
+function buildToolCallArgs(_toolKind, content, locations) {
+  const args = parseArgsFromContent(content);
+  if (Array.isArray(locations)) {
+    args.locations = locations;
+  }
+  return args;
+}
+const MAX_TOOL_OUTPUT_OVERLAP_CHARS = 4096;
+const MAX_TRACKED_TOOL_OUTPUT_EXACT_CHARS = 16384;
+const MAX_TRACKED_TOOL_OUTPUT_HEAD_CHARS = 2048;
+const MAX_TRACKED_TOOL_OUTPUT_TAIL_CHARS = MAX_TOOL_OUTPUT_OVERLAP_CHARS;
+const MAX_TRACKED_TOOL_OUTPUT_SUFFIX_CHARS = 65536;
+function findTrailingNewlineTrimmedLength(text) {
+  let trimmedLength = text.length;
+  while (trimmedLength > 0) {
+    const charCode = text.charCodeAt(trimmedLength - 1);
+    if (charCode !== 10 && charCode !== 13) {
+      break;
+    }
+    trimmedLength--;
+  }
+  return trimmedLength;
+}
+function sliceSnapshotHead(text, length) {
+  return text.slice(0, Math.min(length, MAX_TRACKED_TOOL_OUTPUT_HEAD_CHARS));
+}
+function sliceSnapshotTail(text, length) {
+  const tailLength = Math.min(length, MAX_TRACKED_TOOL_OUTPUT_TAIL_CHARS);
+  return text.slice(Math.max(0, length - tailLength), length);
+}
+function sliceSnapshotSuffixWindow(text, length) {
+  const suffixLength = Math.min(length, MAX_TRACKED_TOOL_OUTPUT_SUFFIX_CHARS);
+  return text.slice(Math.max(0, length - suffixLength), length);
+}
+function buildToolOutputSnapshot(text) {
+  const length = text.length;
+  const trimmedLength = findTrailingNewlineTrimmedLength(text);
+  return {
+    length,
+    exact: length <= MAX_TRACKED_TOOL_OUTPUT_EXACT_CHARS ? text : void 0,
+    head: sliceSnapshotHead(text, length),
+    tail: sliceSnapshotTail(text, length),
+    suffixWindow: sliceSnapshotSuffixWindow(text, length),
+    trimmedLength,
+    trimmedExact: trimmedLength <= MAX_TRACKED_TOOL_OUTPUT_EXACT_CHARS ? text.slice(0, trimmedLength) : void 0,
+    trimmedHead: sliceSnapshotHead(text, trimmedLength),
+    trimmedTail: sliceSnapshotTail(text, trimmedLength),
+    trimmedSuffixWindow: sliceSnapshotSuffixWindow(text, trimmedLength)
+  };
+}
+function snapshotMatchesEdges(next, snapshotLength, snapshotHead, snapshotTail) {
+  if (next.length < snapshotLength) {
+    return false;
+  }
+  if (snapshotHead.length > 0 && !next.startsWith(snapshotHead)) {
+    return false;
+  }
+  if (snapshotTail.length === 0) {
+    return true;
+  }
+  const tailStart = snapshotLength - snapshotTail.length;
+  return next.slice(tailStart, tailStart + snapshotTail.length) === snapshotTail;
+}
+function snapshotMatchesText(snapshot, next, useTrimmedSnapshot = false) {
+  const snapshotLength = useTrimmedSnapshot ? snapshot.trimmedLength : snapshot.length;
+  if (next.length !== snapshotLength) {
+    return false;
+  }
+  const snapshotExact = useTrimmedSnapshot ? snapshot.trimmedExact : snapshot.exact;
+  if (snapshotExact !== void 0) {
+    return next === snapshotExact;
+  }
+  const snapshotHead = useTrimmedSnapshot ? snapshot.trimmedHead : snapshot.head;
+  const snapshotTail = useTrimmedSnapshot ? snapshot.trimmedTail : snapshot.tail;
+  return snapshotMatchesEdges(next, snapshotLength, snapshotHead, snapshotTail);
+}
+function snapshotIsPrefixOfText(snapshot, next, useTrimmedSnapshot = false) {
+  const snapshotLength = useTrimmedSnapshot ? snapshot.trimmedLength : snapshot.length;
+  if (next.length < snapshotLength) {
+    return false;
+  }
+  const snapshotExact = useTrimmedSnapshot ? snapshot.trimmedExact : snapshot.exact;
+  if (snapshotExact !== void 0) {
+    return next.startsWith(snapshotExact);
+  }
+  const snapshotHead = useTrimmedSnapshot ? snapshot.trimmedHead : snapshot.head;
+  const snapshotTail = useTrimmedSnapshot ? snapshot.trimmedTail : snapshot.tail;
+  return snapshotMatchesEdges(next, snapshotLength, snapshotHead, snapshotTail);
+}
+function snapshotEndsWithText(snapshot, next) {
+  if (next.length === 0) {
+    return true;
+  }
+  if (snapshot.exact !== void 0) {
+    return snapshot.exact.endsWith(next);
+  }
+  return next.length <= snapshot.suffixWindow.length && snapshot.suffixWindow.endsWith(next);
+}
+function findToolOutputOverlap(previous, next) {
+  const maxOverlap = Math.min(previous.length, next.length, MAX_TOOL_OUTPUT_OVERLAP_CHARS);
+  if (maxOverlap === 0) {
+    return 0;
+  }
+  const previousSuffix = previous.slice(-maxOverlap);
+  const nextPrefix = next.slice(0, maxOverlap);
+  for (let overlap = maxOverlap; overlap > 0; overlap--) {
+    if (previousSuffix.endsWith(nextPrefix.slice(0, overlap))) {
+      return overlap;
+    }
+  }
+  return 0;
+}
+function getToolOutputDelta(previous, next) {
+  if (!previous || previous.length === 0) {
+    return next;
+  }
+  if (snapshotMatchesText(previous, next) || snapshotEndsWithText(previous, next)) {
+    return "";
+  }
+  if (snapshotIsPrefixOfText(previous, next)) {
+    return next.slice(previous.length);
+  }
+  const overlapSource = previous.exact ?? previous.tail;
+  const overlap = findToolOutputOverlap(overlapSource, next);
+  return overlap > 0 ? next.slice(overlap) : next;
+}
+function shouldReplaceToolOutput(previous, next) {
+  if (!previous || previous.length === 0) {
+    return false;
+  }
+  if (snapshotIsPrefixOfText(previous, next)) {
+    return false;
+  }
+  if (previous.trimmedLength === previous.length) {
+    return false;
+  }
+  return snapshotIsPrefixOfText(previous, next, true);
+}
+function appendToolOutput(existing, next) {
+  const shouldReplace = shouldReplaceToolOutput(existing?.lastRawText, next);
+  const preview = shouldReplace || !existing?.preview ? new HeadTailPreviewBuffer(
+    DEFAULT_TOOL_CALL_OUTPUT_PREVIEW_HEAD_BYTES,
+    DEFAULT_TOOL_CALL_OUTPUT_PREVIEW_TAIL_BYTES
+  ) : existing.preview;
+  let emittedChunk = null;
+  if (shouldReplace) {
+    preview.append(next);
+  } else {
+    const textToAppend = getToolOutputDelta(existing?.lastRawText, next);
+    if (textToAppend.length > 0) {
+      preview.append(textToAppend);
+      emittedChunk = textToAppend;
+    }
+  }
+  return {
+    accumulator: {
+      preview,
+      // ACP runtimes sometimes resend the entire cumulative stdout snapshot.
+      // Keep only a bounded summary for dedupe so long tool runs cannot retain
+      // every historical snapshot in memory.
+      lastRawText: buildToolOutputSnapshot(next),
+      updateCount: (existing?.updateCount ?? 0) + 1
+    },
+    emittedChunk
+  };
+}
+function renderToolOutput(accumulator) {
+  if (!accumulator) {
+    return void 0;
+  }
+  return accumulator.preview.render("tool output");
+}
+function extractTerminalOutputMeta(update) {
+  if (!isRecord(update._meta)) {
+    return null;
+  }
+  const terminalOutput = update._meta.terminal_output;
+  if (!isRecord(terminalOutput)) {
+    return null;
+  }
+  const data = typeof terminalOutput.data === "string" && terminalOutput.data.length > 0 ? terminalOutput.data : null;
+  if (!data) {
+    return null;
+  }
+  const terminalId = typeof terminalOutput.terminal_id === "string" && terminalOutput.terminal_id.length > 0 ? terminalOutput.terminal_id : null;
+  const toolCallId = typeof update.toolCallId === "string" && update.toolCallId.length > 0 ? update.toolCallId : terminalId;
+  return toolCallId ? { toolCallId, data } : null;
+}
+function isTerminalLikeToolKind(toolKind) {
+  if (typeof toolKind !== "string" || toolKind.length === 0) {
+    return false;
+  }
+  const normalized = toolKind.toLowerCase();
+  return normalized === "execute" || normalized.includes("bash") || normalized.includes("shell") || normalized.includes("terminal") || normalized.includes("command");
+}
+function formatToolCallTimeoutLimit(timeoutMs) {
+  if (timeoutMs < 1e3) {
+    return `${timeoutMs}ms`;
+  }
+  return `${(timeoutMs / 1e3).toFixed(Number.isInteger(timeoutMs / 1e3) ? 0 : 1)}s`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractNestedToolContentText(value) {
+  if (isTerminalReferenceOnlyPayload(value)) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value.length > 0 ? value : null;
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map((item) => extractNestedToolContentText(item)).filter((item) => Boolean(item));
+    return parts.length > 0 ? parts.join("") : null;
+  }
+  if (!isRecord(value)) {
+    return null;
+  }
+  if (typeof value.text === "string" && value.text.length > 0) {
+    return value.text;
+  }
+  if ("content" in value) {
+    return extractNestedToolContentText(value.content);
+  }
+  return null;
+}
+function hasMeaningfulContent(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (isRecord(value)) {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function looksLikeToolMetadata(record) {
+  const metadataKeys = [
+    "command",
+    "cmd",
+    "script",
+    "argv",
+    "cwd",
+    "workingDirectory",
+    "description",
+    "title",
+    "parsed_cmd"
+  ];
+  if (metadataKeys.some((key) => key in record)) {
+    return true;
+  }
+  const nestedKeys = ["input", "toolCall", "arguments", "content"];
+  for (const key of nestedKeys) {
+    const nested = record[key];
+    if (isRecord(nested) && looksLikeToolMetadata(nested)) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractToolOutputChunk(content) {
+  if (typeof content === "string") {
+    return content.length > 0 ? content : null;
+  }
+  if (Array.isArray(content)) {
+    const parts = content.map((item) => extractToolOutputChunk(item)).filter((item) => Boolean(item));
+    return parts.length > 0 ? parts.join("") : null;
+  }
+  if (!isRecord(content)) {
+    return null;
+  }
+  if (isTerminalReferenceOnlyPayload(content)) {
+    return null;
+  }
+  const outputKeys = ["stdout", "stderr", "output", "text", "message", "data", "error", "reason"];
+  const hasOutputKey = outputKeys.some((key) => key in content);
+  if (!hasOutputKey && looksLikeToolMetadata(content)) {
+    return null;
+  }
+  for (const key of outputKeys) {
+    if (!(key in content)) {
+      continue;
+    }
+    const value = content[key];
+    const nestedText2 = extractNestedToolContentText(value);
+    if (nestedText2 && nestedText2.length > 0) {
+      return nestedText2;
+    }
+    const formatted2 = typeof value === "string" ? value : formatDisplayMessage(value);
+    if (formatted2.length > 0) {
+      return formatted2;
+    }
+  }
+  const nestedText = extractNestedToolContentText(content);
+  if (nestedText && nestedText.length > 0) {
+    return nestedText;
+  }
+  const formatted = formatDisplayMessage(content);
+  return formatted.length > 0 ? formatted : null;
+}
+function hasVisibleToolCallProgress(content) {
+  return extractToolOutputChunk(content) !== null;
+}
+function mergeStreamedOutputWithResult(content, streamedOutput) {
+  if (!streamedOutput || streamedOutput.length === 0) {
+    return content;
+  }
+  if (!hasMeaningfulContent(content)) {
+    return streamedOutput;
+  }
+  if (isRecord(content)) {
+    const hasStructuredOutput = ["stdout", "stderr", "output", "text", "message", "data"].some((key) => key in content);
+    if (!hasStructuredOutput) {
+      return {
+        ...content,
+        stdout: streamedOutput
+      };
+    }
+  }
+  return content;
+}
+function buildCompletedToolResult(toolKind, content, streamedOutput) {
+  if (isTerminalLikeToolKind(toolKind) && isTerminalReferenceOnlyPayload(content)) {
+    return void 0;
+  }
+  return mergeStreamedOutputWithResult(content, streamedOutput);
+}
+function extractErrorDetail(content) {
+  if (!content) return void 0;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (typeof content === "object" && content !== null && !Array.isArray(content)) {
+    const obj = content;
+    if (obj.error) {
+      const error = obj.error;
+      if (typeof error === "string") return error;
+      if (error && typeof error === "object" && "message" in error) {
+        const errObj = error;
+        if (typeof errObj.message === "string") return errObj.message;
+      }
+      return JSON.stringify(error);
+    }
+    if (typeof obj.message === "string") return obj.message;
+    const status = typeof obj.status === "string" ? obj.status : void 0;
+    const reason = typeof obj.reason === "string" ? obj.reason : void 0;
+    return status || reason || JSON.stringify(obj).substring(0, 500);
+  }
+  return void 0;
+}
+function formatDuration(startTime) {
+  if (!startTime) return "unknown";
+  const duration = Date.now() - startTime;
+  return `${(duration / 1e3).toFixed(2)}s`;
+}
+function formatDurationMinutes(startTime) {
+  if (!startTime) return "unknown";
+  const duration = Date.now() - startTime;
+  return (duration / 1e3 / 60).toFixed(2);
+}
+function handleAgentMessageChunk(update, ctx) {
+  const content = update.content;
+  if (!content || typeof content !== "object" || !("text" in content)) {
+    return { handled: false };
+  }
+  const text = content.text;
+  if (typeof text !== "string") {
+    return { handled: false };
+  }
+  const isThinking = /^\*\*[^*]+\*\*\n/.test(text);
+  if (isThinking) {
+    ctx.emit({
+      type: "event",
+      name: "thinking",
+      payload: { text }
+    });
+  } else {
+    logger.debug(`[AcpBackend] Received message chunk (length: ${text.length}): ${text.substring(0, 50)}...`);
+    ctx.emit({
+      type: "model-output",
+      textDelta: text
+    });
+    ctx.clearIdleTimeout();
+    const idleTimeoutMs = ctx.transport.getIdleTimeout?.() ?? DEFAULT_IDLE_TIMEOUT_MS;
+    ctx.setIdleTimeout(() => {
+      if (ctx.activeToolCalls.size === 0) {
+        logger.debug("[AcpBackend] No more chunks received, emitting idle status");
+        ctx.emitIdleStatus();
+      } else {
+        logger.debug(`[AcpBackend] Delaying idle status - ${ctx.activeToolCalls.size} active tool calls`);
+      }
+    }, idleTimeoutMs);
+  }
+  return { handled: true };
+}
+function handleAgentThoughtChunk(update, ctx) {
+  const content = update.content;
+  if (!content || typeof content !== "object" || !("text" in content)) {
+    return { handled: false };
+  }
+  const text = content.text;
+  if (typeof text !== "string") {
+    return { handled: false };
+  }
+  if (ctx.activeToolCalls.size > 0) {
+    const activeToolCallsList = Array.from(ctx.activeToolCalls);
+    logger.debug(`[AcpBackend] \u{1F4AD} Thinking chunk received (${text.length} chars) during active tool calls: ${activeToolCallsList.join(", ")}`);
+  }
+  ctx.emit({
+    type: "event",
+    name: "thinking",
+    payload: { text }
+  });
+  return { handled: true };
+}
+function startToolCall(toolCallId, toolKind, update, ctx, source) {
+  const startTime = Date.now();
+  const toolKindStr = typeof toolKind === "string" ? toolKind : void 0;
+  const isInvestigation = ctx.transport.isInvestigationTool?.(toolCallId, toolKindStr) ?? false;
+  const extractedName = ctx.transport.extractToolNameFromId?.(toolCallId);
+  const realToolName = extractedName ?? (toolKindStr || "unknown");
+  ctx.toolCallIdToNameMap.set(toolCallId, realToolName);
+  ctx.activeToolCalls.add(toolCallId);
+  ctx.toolCallStartTimes.set(toolCallId, startTime);
+  logger.debug(`[AcpBackend] \u23F1\uFE0F Set startTime for ${toolCallId} at ${new Date(startTime).toISOString()} (from ${source})`);
+  logger.debug(`[AcpBackend] \u{1F527} Tool call START: ${toolCallId} (${toolKind} -> ${realToolName})${isInvestigation ? " [INVESTIGATION TOOL]" : ""}`);
+  if (isInvestigation) {
+    logger.debug(`[AcpBackend] \u{1F50D} Investigation tool detected - extended timeout (10min) will be used`);
+  }
+  const timeoutMs = ctx.transport.getToolCallTimeout?.(toolCallId, toolKindStr) ?? DEFAULT_TOOL_CALL_TIMEOUT_MS;
+  if (!ctx.toolCallTimeouts.has(toolCallId)) {
+    ctx.armToolCallTimeout({
+      toolCallId,
+      toolKind,
+      toolName: realToolName,
+      timeoutMs,
+      source
+    });
+    logger.debug(`[AcpBackend] \u23F1\uFE0F Set no-progress timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
+  } else {
+    logger.debug(`[AcpBackend] Timeout already set for ${toolCallId}, skipping`);
+  }
+  ctx.clearIdleTimeout();
+  ctx.emit({ type: "status", status: "running" });
+  const args = buildToolCallArgs(toolKind, update.content, update.locations);
+  if (isInvestigation && args.objective) {
+    logger.debug(`[AcpBackend] \u{1F50D} Investigation tool objective: ${String(args.objective).substring(0, 100)}...`);
+  }
+  ctx.emit({
+    type: "tool-call",
+    toolName: toolKindStr || "unknown",
+    args,
+    callId: toolCallId
+  });
+}
+function completeToolCall(toolCallId, toolKind, content, ctx) {
+  const startTime = ctx.toolCallStartTimes.get(toolCallId);
+  const duration = formatDuration(startTime);
+  const toolKindStr = typeof toolKind === "string" && toolKind !== "unknown" ? toolKind : ctx.toolCallIdToNameMap.get(toolCallId) || "unknown";
+  ctx.activeToolCalls.delete(toolCallId);
+  ctx.toolCallStartTimes.delete(toolCallId);
+  ctx.toolCallIdToNameMap.delete(toolCallId);
+  ctx.clearToolCallTimeout(toolCallId);
+  const streamedOutput = renderToolOutput(ctx.toolCallOutputs.get(toolCallId));
+  ctx.toolCallOutputs.delete(toolCallId);
+  logger.debug(`[AcpBackend] \u2705 Tool call COMPLETED: ${toolCallId} (${toolKindStr}) - Duration: ${duration}. Active tool calls: ${ctx.activeToolCalls.size}`);
+  ctx.emit({
+    type: "tool-result",
+    toolName: toolKindStr,
+    result: buildCompletedToolResult(toolKindStr, content, streamedOutput),
+    callId: toolCallId
+  });
+  if (ctx.activeToolCalls.size === 0) {
+    ctx.clearIdleTimeout();
+    logger.debug("[AcpBackend] All tool calls completed, emitting idle status");
+    ctx.emitIdleStatus();
+  }
+}
+function failToolCall(toolCallId, status, toolKind, content, ctx) {
+  const startTime = ctx.toolCallStartTimes.get(toolCallId);
+  const duration = startTime ? Date.now() - startTime : null;
+  const toolKindStr = typeof toolKind === "string" && toolKind !== "unknown" ? toolKind : ctx.toolCallIdToNameMap.get(toolCallId) || "unknown";
+  const isInvestigation = ctx.transport.isInvestigationTool?.(toolCallId, toolKindStr) ?? false;
+  const hadTimeout = ctx.toolCallTimeouts.has(toolCallId);
+  if (isInvestigation) {
+    const durationStr2 = formatDuration(startTime);
+    const durationMinutes = formatDurationMinutes(startTime);
+    logger.debug(`[AcpBackend] \u{1F50D} Investigation tool ${status.toUpperCase()} after ${durationMinutes} minutes (${durationStr2})`);
+    if (duration) {
+      const threeMinutes = 3 * 60 * 1e3;
+      const tolerance = 5e3;
+      if (Math.abs(duration - threeMinutes) < tolerance) {
+        logger.debug(`[AcpBackend] \u{1F50D} \u26A0\uFE0F Investigation tool failed at ~3 minutes - likely Gemini CLI timeout, not our timeout`);
+      }
+    }
+    logger.debug(`[AcpBackend] \u{1F50D} Investigation tool FAILED - full content:`, JSON.stringify(content, null, 2));
+    logger.debug(`[AcpBackend] \u{1F50D} Investigation tool timeout status BEFORE cleanup: ${hadTimeout ? "timeout was set" : "no timeout was set"}`);
+    logger.debug(`[AcpBackend] \u{1F50D} Investigation tool startTime status BEFORE cleanup: ${startTime ? `set at ${new Date(startTime).toISOString()}` : "not set"}`);
+  }
+  ctx.activeToolCalls.delete(toolCallId);
+  ctx.toolCallStartTimes.delete(toolCallId);
+  ctx.toolCallIdToNameMap.delete(toolCallId);
+  const clearedTimeout = ctx.clearToolCallTimeout(toolCallId);
+  if (clearedTimeout) {
+    logger.debug(`[AcpBackend] Cleared timeout for ${toolCallId} (tool call ${status})`);
+  } else {
+    logger.debug(`[AcpBackend] No timeout found for ${toolCallId} (tool call ${status}) - timeout may not have been set`);
+  }
+  const durationStr = formatDuration(startTime);
+  logger.debug(`[AcpBackend] \u274C Tool call ${status.toUpperCase()}: ${toolCallId} (${toolKindStr}) - Duration: ${durationStr}. Active tool calls: ${ctx.activeToolCalls.size}`);
+  const streamedOutput = renderToolOutput(ctx.toolCallOutputs.get(toolCallId));
+  ctx.toolCallOutputs.delete(toolCallId);
+  const errorDetail = extractErrorDetail(content);
+  if (errorDetail) {
+    logger.debug(`[AcpBackend] \u274C Tool call error details: ${errorDetail.substring(0, 500)}`);
+  } else {
+    logger.debug(`[AcpBackend] \u274C Tool call ${status} but no error details in content`);
+  }
+  ctx.emit({
+    type: "tool-result",
+    toolName: toolKindStr,
+    result: streamedOutput ? {
+      stdout: streamedOutput,
+      error: errorDetail || `Tool call ${status}`,
+      status
+    } : errorDetail ? { error: errorDetail, status } : { error: `Tool call ${status}`, status },
+    callId: toolCallId
+  });
+  if (ctx.activeToolCalls.size === 0) {
+    ctx.clearIdleTimeout();
+    logger.debug("[AcpBackend] All tool calls completed/failed, emitting idle status");
+    ctx.emitIdleStatus();
+  }
+}
+function handleToolCallUpdate(update, ctx, options) {
+  const status = update.status;
+  const toolCallId = update.toolCallId;
+  if (!toolCallId) {
+    logger.debug("[AcpBackend] Tool call update without toolCallId:", update);
+    return { handled: false };
+  }
+  const toolKind = update.kind || ctx.toolCallIdToNameMap.get(toolCallId) || "unknown";
+  let toolCallCountSincePrompt = ctx.toolCallCountSincePrompt;
+  const hasSupplementalTerminalOutput = typeof options?.supplementalOutputChunk === "string" && options.supplementalOutputChunk.length > 0;
+  const outputChunk = extractToolOutputChunk(update.content) ?? options?.supplementalOutputChunk ?? null;
+  if (status === "in_progress" || status === "pending") {
+    if (!ctx.activeToolCalls.has(toolCallId)) {
+      toolCallCountSincePrompt++;
+      startToolCall(toolCallId, toolKind, update, ctx, "tool_call_update");
+    } else {
+      logger.debug(`[AcpBackend] Tool call ${toolCallId} already tracked, status: ${status}`);
+    }
+  }
+  if (outputChunk) {
+    const nextOutput = appendToolOutput(ctx.toolCallOutputs.get(toolCallId), outputChunk);
+    ctx.toolCallOutputs.set(toolCallId, nextOutput.accumulator);
+    if (ctx.activeToolCalls.has(toolCallId) && nextOutput.emittedChunk && (hasSupplementalTerminalOutput || isTerminalLikeToolKind(toolKind))) {
+      ctx.emit({
+        type: "terminal-output",
+        data: nextOutput.emittedChunk,
+        callId: toolCallId
+      });
+    }
+  }
+  if (status === "completed") {
+    completeToolCall(toolCallId, toolKind, update.content, ctx);
+  } else if (status === "failed" || status === "cancelled") {
+    failToolCall(toolCallId, status, toolKind, update.content, ctx);
+  }
+  return {
+    handled: true,
+    toolCallCountSincePrompt,
+    hadVisibleProgress: outputChunk !== null
+  };
+}
+function extractSupplementalToolProgress(update) {
+  const terminalOutput = extractTerminalOutputMeta(update);
+  if (!terminalOutput) {
+    return null;
+  }
+  return {
+    toolCallId: terminalOutput.toolCallId,
+    outputChunk: terminalOutput.data
+  };
+}
+function handleToolCall(update, ctx) {
+  const toolCallId = update.toolCallId;
+  const status = update.status;
+  logger.debug(`[AcpBackend] Received tool_call: toolCallId=${toolCallId}, status=${status}, kind=${update.kind}`);
+  const isInProgress = !status || status === "in_progress" || status === "pending";
+  if (!toolCallId || !isInProgress) {
+    logger.debug(`[AcpBackend] Tool call ${toolCallId} not in progress (status: ${status}), skipping`);
+    return { handled: false };
+  }
+  if (ctx.activeToolCalls.has(toolCallId)) {
+    logger.debug(`[AcpBackend] Tool call ${toolCallId} already in active set, skipping`);
+    return { handled: true };
+  }
+  startToolCall(toolCallId, update.kind, update, ctx, "tool_call");
+  return { handled: true };
+}
+function handleLegacyMessageChunk(update, ctx) {
+  if (!update.messageChunk) {
+    return { handled: false };
+  }
+  const chunk = update.messageChunk;
+  if (chunk.textDelta) {
+    ctx.emit({
+      type: "model-output",
+      textDelta: chunk.textDelta
+    });
+    return { handled: true };
+  }
+  return { handled: false };
+}
+function handlePlanUpdate(update, ctx) {
+  if (!update.plan) {
+    return { handled: false };
+  }
+  ctx.emit({
+    type: "event",
+    name: "plan",
+    payload: update.plan
+  });
+  return { handled: true };
+}
+function handleThinkingUpdate(update, ctx) {
+  if (!update.thinking) {
+    return { handled: false };
+  }
+  ctx.emit({
+    type: "event",
+    name: "thinking",
+    payload: update.thinking
+  });
+  return { handled: true };
+}
+
+function buildAcpSpawnSpec(params) {
+  return {
+    command: params.command,
+    args: (params.args ?? []).map((arg) => String(arg)),
+    options: {
+      cwd: params.cwd,
+      env: params.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: process.platform === "win32"
+    }
+  };
+}
+
+const MAX_DROPPED_LINE_PREVIEW_CHARS = 4096;
+const DEFAULT_ACP_MAX_MULTILINE_STDOUT_BYTES = 32 * 1024;
+function formatDroppedLinePreview(line) {
+  if (line.length <= MAX_DROPPED_LINE_PREVIEW_CHARS) {
+    return line;
+  }
+  const headChars = 2048;
+  const tailChars = 1024;
+  const omittedChars = Math.max(0, line.length - headChars - tailChars);
+  return `${line.slice(0, headChars)}
+...[stdout line truncated ${omittedChars} chars]...
+${line.slice(-tailChars)}`;
+}
+function createAcpFilteredStdoutReadable(params) {
+  const maxMultilineBytes = typeof params.maxMultilineBytes === "number" && Number.isFinite(params.maxMultilineBytes) && params.maxMultilineBytes > 0 ? Math.trunc(params.maxMultilineBytes) : DEFAULT_ACP_MAX_MULTILINE_STDOUT_BYTES;
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      const reader = params.readable.getReader();
+      let buffer = Buffer.alloc(0);
+      let multiline = null;
+      let discardingOversizedLine = false;
+      let controllerErrored = false;
+      const drop = (reason, line) => {
+        params.onDroppedLine?.({ reason, line: formatDroppedLinePreview(line) });
+      };
+      const enqueueLine = (line) => {
+        if (!line.trim()) {
+          return;
+        }
+        const filtered = params.transport.filterStdoutLine?.(line);
+        if (filtered === void 0) {
+          controller.enqueue(encoder.encode(`${line}
+`));
+          return;
+        }
+        if (filtered === null) {
+          drop("transport_filter_null", line);
+          return;
+        }
+        controller.enqueue(encoder.encode(`${filtered}
+`));
+      };
+      const tryFlushMultiline = (candidate) => {
+        const trimmed = candidate.trim();
+        if (!trimmed) {
+          return false;
+        }
+        if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+          return false;
+        }
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (typeof parsed !== "object" || parsed === null) {
+            return false;
+          }
+          enqueueLine(JSON.stringify(parsed));
+          return true;
+        } catch {
+          return false;
+        }
+      };
+      const consumeLine = (line, lineBytes) => {
+        if (multiline) {
+          const nextBuf = multiline.buf.length > 0 ? `${multiline.buf}
+${line}` : line;
+          const nextBytes = multiline.bytes + lineBytes + 1;
+          if (nextBytes > maxMultilineBytes) {
+            drop("multiline_overflow", multiline.buf);
+            multiline = null;
+            if (lineBytes > maxMultilineBytes) {
+              drop("multiline_overflow", line);
+              return;
+            }
+            enqueueLine(line);
+            return;
+          }
+          multiline = { buf: nextBuf, bytes: nextBytes };
+          if (tryFlushMultiline(multiline.buf)) {
+            multiline = null;
+          }
+          return;
+        }
+        if (lineBytes > maxMultilineBytes) {
+          drop("multiline_overflow", line);
+          return;
+        }
+        const trimmed = line.trim();
+        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+          try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed === "object" && parsed !== null) {
+              enqueueLine(line);
+              return;
+            }
+          } catch {
+            multiline = { buf: line, bytes: lineBytes };
+            return;
+          }
+        }
+        enqueueLine(line);
+      };
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          if (!value) {
+            continue;
+          }
+          let chunkBuffer = Buffer.from(value);
+          if (discardingOversizedLine) {
+            const newlineIndex2 = chunkBuffer.indexOf(10);
+            if (newlineIndex2 === -1) {
+              continue;
+            }
+            chunkBuffer = chunkBuffer.subarray(newlineIndex2 + 1);
+            discardingOversizedLine = false;
+          }
+          if (chunkBuffer.length === 0) {
+            continue;
+          }
+          buffer = buffer.length === 0 ? chunkBuffer : Buffer.concat([buffer, chunkBuffer]);
+          let newlineIndex = buffer.indexOf(10);
+          while (newlineIndex !== -1) {
+            const rawLine = buffer.subarray(0, newlineIndex);
+            buffer = buffer.subarray(newlineIndex + 1);
+            const lineBuffer = rawLine.at(-1) === 13 ? rawLine.subarray(0, rawLine.length - 1) : rawLine;
+            const line = lineBuffer.toString("utf8");
+            consumeLine(line, lineBuffer.length);
+            newlineIndex = buffer.indexOf(10);
+          }
+          if (buffer.length > maxMultilineBytes) {
+            drop("multiline_overflow", buffer.toString("utf8"));
+            buffer = Buffer.alloc(0);
+            discardingOversizedLine = true;
+          }
+        }
+        if (buffer.length > 0) {
+          const trailingLine = buffer.toString("utf8");
+          const pendingMultiline = multiline;
+          if (pendingMultiline) {
+            const nextBuf = pendingMultiline.buf.length > 0 ? `${pendingMultiline.buf}
+${trailingLine}` : trailingLine;
+            if (!tryFlushMultiline(nextBuf)) {
+              drop("multiline_incomplete", nextBuf);
+            }
+            multiline = null;
+          } else if (trailingLine.trim()) {
+            drop("multiline_incomplete", trailingLine);
+          }
+        }
+        const remainingMultiline = multiline;
+        if (remainingMultiline) {
+          if (!tryFlushMultiline(remainingMultiline.buf)) {
+            drop("multiline_incomplete", remainingMultiline.buf);
+          }
+          multiline = null;
+        }
+      } catch (error) {
+        controllerErrored = true;
+        controller.error(error);
+      } finally {
+        reader.releaseLock();
+        try {
+          params.onDone?.();
+        } catch {
+        }
+        if (!controllerErrored) {
+          controller.close();
+        }
+      }
+    }
+  });
+}
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveDescendantPids(rootPid) {
+  const processes = await psList();
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const proc of processes) {
+    if (typeof proc.pid !== "number" || typeof proc.ppid !== "number") {
+      continue;
+    }
+    const children = childrenByParent.get(proc.ppid) ?? [];
+    children.push(proc.pid);
+    childrenByParent.set(proc.ppid, children);
+  }
+  const descendants = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (pid) => {
+    for (const childPid of childrenByParent.get(pid) ?? []) {
+      if (seen.has(childPid)) {
+        continue;
+      }
+      seen.add(childPid);
+      visit(childPid);
+      descendants.push(childPid);
+    }
+  };
+  visit(rootPid);
+  return descendants;
+}
+function bestEffortKillPid(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch {
+  }
+}
+async function waitForAllGone(pids, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (pids.every((pid) => !isAlive(pid))) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+}
+async function killProcessTree(proc, options) {
+  const pid = proc.pid;
+  if (!pid) {
+    return;
+  }
+  const graceMs = Math.max(1, options?.graceMs ?? 1e3);
+  const descendants = await resolveDescendantPids(pid).catch(() => []);
+  const allPids = [...descendants, pid];
+  for (const targetPid of allPids) {
+    bestEffortKillPid(targetPid, "SIGTERM");
+  }
+  await waitForAllGone(allPids, graceMs);
+  const remaining = allPids.filter((targetPid) => isAlive(targetPid));
+  if (remaining.length === 0) {
+    return;
+  }
+  for (const targetPid of remaining) {
+    bestEffortKillPid(targetPid, "SIGKILL");
+  }
+  await waitForAllGone(remaining, Math.min(250, graceMs));
+}
+
+const RETRY_CONFIG = {
+  /** Maximum number of retry attempts for init/newSession */
+  maxAttempts: 3,
+  /** Base delay between retries in ms */
+  baseDelayMs: 1e3,
+  /** Maximum delay between retries in ms */
+  maxDelayMs: 5e3
+};
+const DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS = 2 * 6e4;
+const MAX_DROPPED_STDOUT_LINE_SAMPLES = 5;
+const HAPPY_ACP_MAX_MULTILINE_STDOUT_BYTES_ENV = "HAPPY_ACP_MAX_MULTILINE_STDOUT_BYTES";
+const HAPPIER_ACP_MAX_MULTILINE_STDOUT_BYTES_ENV = "HAPPIER_ACP_MAX_MULTILINE_STDOUT_BYTES";
+function readPositiveIntegerEnv(name) {
+  const raw = typeof process.env[name] === "string" ? process.env[name].trim() : "";
+  if (!raw) {
+    return null;
+  }
+  const value = Number(raw);
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+    return null;
+  }
+  return value;
+}
+function resolvePostPromptNoUpdatesTimeoutMs(transport) {
+  const envValue = readPositiveIntegerEnv("HAPPY_ACP_POST_PROMPT_NO_UPDATES_TIMEOUT_MS") ?? readPositiveIntegerEnv("HAPPIER_ACP_POST_PROMPT_NO_UPDATES_TIMEOUT_MS");
+  if (envValue != null) {
+    return envValue;
+  }
+  const transportValue = transport.getPostPromptNoUpdatesTimeoutMs?.();
+  if (typeof transportValue === "number" && Number.isFinite(transportValue) && transportValue > 0) {
+    return Math.trunc(transportValue);
+  }
+  return DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS;
+}
+function resolveAcpMaxMultilineStdoutBytes() {
+  const envValue = readPositiveIntegerEnv(HAPPY_ACP_MAX_MULTILINE_STDOUT_BYTES_ENV) ?? readPositiveIntegerEnv(HAPPIER_ACP_MAX_MULTILINE_STDOUT_BYTES_ENV);
+  return envValue ?? DEFAULT_ACP_MAX_MULTILINE_STDOUT_BYTES;
+}
+function formatAcpStdoutByteLimit(bytes) {
+  if (bytes >= 1024 * 1024) {
+    const value = bytes / (1024 * 1024);
+    return `${Number.isInteger(value) ? value : value.toFixed(1)} MiB`;
+  }
+  if (bytes >= 1024) {
+    const value = bytes / 1024;
+    return `${Number.isInteger(value) ? value : value.toFixed(1)} KiB`;
+  }
+  return `${bytes} bytes`;
+}
+function buildMultilineOverflowStatusDetail(maxBytes) {
+  const formattedLimit = formatAcpStdoutByteLimit(maxBytes);
+  return `Suppressed oversized agent output (>${formattedLimit} / ${maxBytes} bytes per ACP stdout record). Full output stays hidden by default. If you need larger payloads, set ${HAPPY_ACP_MAX_MULTILINE_STDOUT_BYTES_ENV}.`;
+}
+function getSessionUpdates(params) {
+  const notification = params;
+  const updates = Array.isArray(notification.updates) ? notification.updates.filter((update) => Boolean(update && typeof update === "object")) : [];
+  if (updates.length > 0) {
+    return updates;
+  }
+  if (notification.update && typeof notification.update === "object") {
+    return [notification.update];
+  }
+  return [];
+}
+function asNonNegativeFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function shouldRefreshProgressForToolCallUpdate(update, wasToolCallActive, isToolCallActive, hadVisibleProgress = false) {
+  if (!wasToolCallActive && isToolCallActive) {
+    return true;
+  }
+  if (update.status === "completed" || update.status === "failed" || update.status === "cancelled") {
+    return true;
+  }
+  return hadVisibleProgress || hasVisibleToolCallProgress(update.content);
+}
+function extractUsageTokens(record) {
+  const used = asNonNegativeFiniteNumber(record.used);
+  const size = asNonNegativeFiniteNumber(record.size);
+  if (used != null || size != null) {
+    const tokens2 = {
+      total: used ?? 0
+    };
+    if (used != null) tokens2.used = used;
+    if (size != null) tokens2.size = size;
+    return tokens2;
+  }
+  const input = asNonNegativeFiniteNumber(record.input_tokens) ?? asNonNegativeFiniteNumber(record.inputTokens) ?? asNonNegativeFiniteNumber(record.prompt_tokens) ?? asNonNegativeFiniteNumber(record.promptTokens);
+  const output = asNonNegativeFiniteNumber(record.output_tokens) ?? asNonNegativeFiniteNumber(record.outputTokens) ?? asNonNegativeFiniteNumber(record.completion_tokens) ?? asNonNegativeFiniteNumber(record.completionTokens);
+  const cacheRead = asNonNegativeFiniteNumber(record.cache_read_input_tokens) ?? asNonNegativeFiniteNumber(record.cacheReadInputTokens) ?? asNonNegativeFiniteNumber(record.cache_read_tokens) ?? asNonNegativeFiniteNumber(record.cacheReadTokens) ?? asNonNegativeFiniteNumber(record.cached_read_tokens) ?? asNonNegativeFiniteNumber(record.cachedReadTokens);
+  const cacheCreation = asNonNegativeFiniteNumber(record.cache_creation_input_tokens) ?? asNonNegativeFiniteNumber(record.cacheCreationInputTokens) ?? asNonNegativeFiniteNumber(record.cache_creation_tokens) ?? asNonNegativeFiniteNumber(record.cacheCreationTokens) ?? asNonNegativeFiniteNumber(record.cached_write_tokens) ?? asNonNegativeFiniteNumber(record.cachedWriteTokens);
+  const thought = asNonNegativeFiniteNumber(record.thought_tokens) ?? asNonNegativeFiniteNumber(record.thoughtTokens);
+  const totalFromPayload = asNonNegativeFiniteNumber(record.total_tokens) ?? asNonNegativeFiniteNumber(record.totalTokens);
+  const anyPresent = totalFromPayload != null || input != null || output != null || cacheRead != null || cacheCreation != null || thought != null;
+  if (!anyPresent) {
+    return null;
+  }
+  const total = totalFromPayload ?? (input ?? 0) + (output ?? 0) + (cacheRead ?? 0) + (cacheCreation ?? 0) + (thought ?? 0);
+  const tokens = { total };
+  if (input != null) tokens.input = input;
+  if (output != null) tokens.output = output;
+  if (cacheRead != null) tokens.cache_read = cacheRead;
+  if (cacheCreation != null) tokens.cache_creation = cacheCreation;
+  if (thought != null) tokens.thought = thought;
+  return tokens;
+}
+function isApprovalOption(option) {
+  if (option.optionId === "proceed_once" || option.optionId === "proceed_always" || option.optionId === "cancel") {
+    return true;
+  }
+  const searchable = `${option.name ?? ""} ${option.label ?? ""}`.toLowerCase();
+  return searchable.includes("once") || searchable.includes("always") || searchable.includes("cancel");
+}
+function isSelectionPermissionRequest(params) {
+  if (Array.isArray(params.codex_command) && params.codex_command.length > 0) {
+    return false;
+  }
+  if (params.requestedSchema?.properties?.optionId) {
+    return true;
+  }
+  const options = Array.isArray(params.options) ? params.options : [];
+  if (options.length === 0) {
+    return false;
+  }
+  return !options.every((option) => isApprovalOption(option));
+}
+function appendDroppedStdoutLineSummary(summary, entry) {
+  summary.count += 1;
+  if (summary.samples.length < MAX_DROPPED_STDOUT_LINE_SAMPLES) {
+    summary.samples.push(entry);
+  }
+}
+function nodeToWebStreams(stdin, stdout) {
+  const isIgnorableStdinPipeError = (error) => {
+    const code = typeof error === "object" && error !== null ? error.code : void 0;
+    return code === "ERR_STREAM_DESTROYED" || code === "EPIPE";
+  };
+  stdin.on("error", (err) => {
+    if (isIgnorableStdinPipeError(err)) {
+      logger.debug("[AcpBackend] Ignoring stdin pipe error:", err);
+      return;
+    }
+    logger.debug("[AcpBackend] Stdin error:", err);
+  });
+  const writable = new WritableStream({
+    write(chunk) {
+      return new Promise((resolve, reject) => {
+        if (stdin.destroyed) {
+          resolve();
+          return;
+        }
+        const ok = stdin.write(chunk, (err) => {
+          if (err) {
+            if (isIgnorableStdinPipeError(err)) {
+              resolve();
+              return;
+            }
+            logger.debug(`[AcpBackend] Error writing to stdin:`, err);
+            reject(err);
+            return;
+          }
+          resolve();
+        });
+        if (!ok) {
+          stdin.once("drain", resolve);
+        }
+      });
+    },
+    close() {
+      return new Promise((resolve) => {
+        if (stdin.destroyed) {
+          resolve();
+          return;
+        }
+        let settled = false;
+        const settle = () => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          stdin.off("close", settle);
+          stdin.off("finish", settle);
+          stdin.off("error", handleError);
+          resolve();
+        };
+        const handleError = (err) => {
+          if (!isIgnorableStdinPipeError(err)) {
+            logger.debug("[AcpBackend] Error ending stdin:", err);
+          }
+          settle();
+        };
+        stdin.once("close", settle);
+        stdin.once("finish", settle);
+        stdin.once("error", handleError);
+        try {
+          stdin.end(() => settle());
+        } catch (error) {
+          if (!isIgnorableStdinPipeError(error)) {
+            logger.debug("[AcpBackend] Error closing stdin:", error);
+          }
+          settle();
+        }
+      });
+    },
+    abort(reason) {
+      stdin.destroy(reason instanceof Error ? reason : new Error(String(reason)));
+    }
+  });
+  const readable = new ReadableStream({
+    start(controller) {
+      stdout.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk));
+      });
+      stdout.on("end", () => {
+        controller.close();
+      });
+      stdout.on("error", (err) => {
+        logger.debug(`[AcpBackend] Stdout error:`, err);
+        controller.error(err);
+      });
+    },
+    cancel() {
+      stdout.destroy();
+    }
+  });
+  return { writable, readable };
+}
+async function withRetry(operation, options) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = normalizeAcpError(error);
+      const retryable = options.shouldRetry?.(lastError) ?? true;
+      if (!retryable || attempt >= options.maxAttempts) {
+        throw lastError;
+      }
+      const delayMs = Math.min(
+        options.baseDelayMs * Math.pow(2, attempt - 1),
+        options.maxDelayMs
+      );
+      logger.debug(`[AcpBackend] ${options.operationName} failed (attempt ${attempt}/${options.maxAttempts}): ${lastError.message}. Retrying in ${delayMs}ms...`);
+      options.onRetry?.(attempt, lastError);
+      await delay(delayMs);
+    }
+  }
+  throw lastError;
+}
+function formatAcpErrorMessage(error) {
+  if (error instanceof Error && error.message && error.message !== "[object Object]") {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null) {
+    const record = error;
+    const message = formatDisplayMessage(error).trim();
+    const code = record.code;
+    const status = record.status;
+    const prefix = [
+      code !== void 0 && code !== null ? `[code=${String(code)}]` : "",
+      status !== void 0 && status !== null ? `[status=${String(status)}]` : ""
+    ].filter(Boolean).join(" ");
+    if (message.length > 0) {
+      return prefix ? `${prefix} ${message}` : message;
+    }
+  }
+  const fallback = formatDisplayMessage(error).trim();
+  return fallback || "Unknown ACP error";
+}
+function normalizeAcpError(error) {
+  if (error instanceof Error && error.message && error.message !== "[object Object]") {
+    return error;
+  }
+  const normalized = new Error(formatAcpErrorMessage(error));
+  normalized.name = error instanceof Error ? error.name : "Error";
+  if (error && typeof error === "object") {
+    const { message: _message, ...rest } = error;
+    Object.assign(normalized, rest);
+  }
+  return normalized;
+}
+function getStatusErrorDetail(message) {
+  if (message.type !== "status" || message.status !== "error") {
+    return null;
+  }
+  const detail = typeof message.detail === "string" ? message.detail.trim() : "";
+  return detail || "Unknown ACP transport error";
+}
+function looksLikeDroppedStdoutError(text) {
+  const lower = text.toLowerCase();
+  return lower.startsWith("error") || lower.includes("error:") || lower.includes("exception") || lower.includes("traceback") || lower.includes("invalid request") || lower.includes("invalid_request") || lower.includes("unauthorized") || lower.includes("forbidden") || lower.includes("permission denied") || /\b(4\d\d|5\d\d)\b/.test(lower) && (lower.includes("http") || lower.includes("status") || lower.includes("request"));
+}
+function createAcpAbortError(message) {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+function enrichAcpError(error, stderrExcerpt) {
+  const normalized = normalizeAcpError(error);
+  if (!stderrExcerpt.trim()) {
+    return normalized;
+  }
+  const existingStderr = normalized.stderr;
+  if (typeof existingStderr !== "string" || existingStderr.trim().length === 0) {
+    Object.assign(normalized, { stderr: stderrExcerpt });
+  }
+  return normalized;
+}
+class AcpProcessStartupError extends Error {
+  constructor(message, exitCode, signal, stderr) {
+    super(message);
+    this.exitCode = exitCode;
+    this.signal = signal;
+    this.stderr = stderr;
+    this.name = "AcpProcessStartupError";
+  }
+}
+function createProcessStartupError(agentName, operationName, code, signal, stderrExcerpt) {
+  const normalizedStderrExcerpt = stderrExcerpt?.trim() || void 0;
+  if (code !== null) {
+    return new AcpProcessStartupError(
+      `${agentName} exited with code ${code} during ${operationName}`,
+      code,
+      signal,
+      normalizedStderrExcerpt
+    );
+  }
+  if (signal) {
+    return new AcpProcessStartupError(
+      `${agentName} exited due to signal ${signal} during ${operationName}`,
+      code,
+      signal,
+      normalizedStderrExcerpt
+    );
+  }
+  return new AcpProcessStartupError(
+    `${agentName} exited unexpectedly during ${operationName}`,
+    code,
+    signal,
+    normalizedStderrExcerpt
+  );
+}
+function isAcpConnectionClosedError(error) {
+  return error.message.trim() === "ACP connection closed";
+}
+function createCurrentProcessExitError(childProcess, options) {
+  if (childProcess.exitCode !== null || childProcess.signalCode !== null) {
+    return createProcessStartupError(
+      options.agentName,
+      options.operationName,
+      childProcess.exitCode,
+      childProcess.signalCode ?? null,
+      options.getStderrExcerpt?.()
+    );
+  }
+  return null;
+}
+async function raceWithProcessExit(childProcess, operationFactory, options) {
+  if (childProcess.exitCode !== null || childProcess.signalCode !== null) {
+    throw createProcessStartupError(
+      options.agentName,
+      options.operationName,
+      childProcess.exitCode,
+      childProcess.signalCode ?? null,
+      options.getStderrExcerpt?.()
+    );
+  }
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    let closedConnectionFallbackTimeout = null;
+    const cleanup = () => {
+      if (closedConnectionFallbackTimeout) {
+        clearTimeout(closedConnectionFallbackTimeout);
+        closedConnectionFallbackTimeout = null;
+      }
+      childProcess.off("error", handleError);
+      childProcess.off("exit", handleExit);
+    };
+    const settleResolve = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const rejectWithNormalizedError = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const settleReject = (error) => {
+      const normalizedError = normalizeAcpError(error);
+      const currentProcessExitError = createCurrentProcessExitError(childProcess, options);
+      if (currentProcessExitError && isAcpConnectionClosedError(normalizedError)) {
+        rejectWithNormalizedError(currentProcessExitError);
+        return;
+      }
+      if (!settled && !currentProcessExitError && !closedConnectionFallbackTimeout && isAcpConnectionClosedError(normalizedError)) {
+        closedConnectionFallbackTimeout = setTimeout(() => {
+          closedConnectionFallbackTimeout = null;
+          rejectWithNormalizedError(normalizedError);
+        }, 50);
+        return;
+      }
+      rejectWithNormalizedError(normalizedError);
+    };
+    const handleError = (error) => {
+      settleReject(error);
+    };
+    const handleExit = (code, signal) => {
+      settleReject(
+        createProcessStartupError(
+          options.agentName,
+          options.operationName,
+          code,
+          signal,
+          options.getStderrExcerpt?.()
+        )
+      );
+    };
+    childProcess.once("error", handleError);
+    childProcess.once("exit", handleExit);
+    let operation;
+    try {
+      operation = operationFactory();
+    } catch (error) {
+      settleReject(error);
+      return;
+    }
+    operation.then(settleResolve, settleReject);
+  });
+}
+class AcpBackend {
+  constructor(options) {
+    this.options = options;
+    this.transport = options.transportHandler ?? new DefaultTransport(options.agentName);
+    this.sessionPreferences = resolveAcpSessionPreferences({
+      agentName: options.agentName,
+      env: options.env
+    });
+    this.acpMaxMultilineStdoutBytes = resolveAcpMaxMultilineStdoutBytes();
+  }
+  listeners = [];
+  process = null;
+  connection = null;
+  acpSessionId = null;
+  disposed = false;
+  /** Track active tool calls to prevent duplicate events */
+  activeToolCalls = /* @__PURE__ */ new Set();
+  toolCallTimeouts = /* @__PURE__ */ new Map();
+  toolCallTimeoutSpecs = /* @__PURE__ */ new Map();
+  /** Track tool call start times for performance monitoring */
+  toolCallStartTimes = /* @__PURE__ */ new Map();
+  /** Track streamed tool output between ACP updates and final completion */
+  toolCallOutputs = /* @__PURE__ */ new Map();
+  /** Pending permission requests that need response */
+  pendingPermissions = /* @__PURE__ */ new Map();
+  /** Map from permission request ID to real tool call ID for tracking */
+  permissionToToolCallMap = /* @__PURE__ */ new Map();
+  /** Map from real tool call ID to tool name for auto-approval */
+  toolCallIdToNameMap = /* @__PURE__ */ new Map();
+  /** Track tool calls count since last prompt (to identify first tool call) */
+  toolCallCountSincePrompt = 0;
+  /** Timeout for emitting 'idle' status after last message chunk */
+  idleTimeout = null;
+  /** Promise resolver for waitForResponseComplete */
+  idleResolver = null;
+  /** Promise rejecter for waitForResponseComplete */
+  idleRejecter = null;
+  /** Completion signal captured before waitForResponseComplete is attached */
+  responseCompletionOutcome = null;
+  /** Whether the current prompt is still waiting for completion */
+  waitingForResponse = false;
+  /** First fatal prompt-level error observed for the current turn */
+  responseCompletionError = null;
+  /** Resettable no-progress timeout while waiting for a turn to finish */
+  responseWaitTimeout = null;
+  /** Current inactivity threshold used by waitForResponseComplete */
+  responseWaitTimeoutMs = null;
+  /** Timestamp of the last meaningful response progress for the current turn */
+  responseLastProgressAt = null;
+  /** Fallback completion when prompt returns but the agent emits no session updates */
+  postPromptCompletionIdleTimeout = null;
+  /** Whether at least one session/update arrived after the current prompt */
+  sawSessionUpdateSincePrompt = false;
+  /** Transport handler for agent-specific behavior */
+  transport;
+  sessionPreferences;
+  sessionConfigOptions = null;
+  agentCapabilities = null;
+  /** Keep a short rolling stderr buffer so startup failures can surface the real cause. */
+  recentStderrLines = [];
+  acpMaxMultilineStdoutBytes;
+  oversizedStdoutNoticeEmittedForCurrentTurn = false;
+  resourceCleanupDone = false;
+  getProviderSessionId() {
+    return this.acpSessionId;
+  }
+  recordRecentStderr(text) {
+    const normalized = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (normalized.length === 0) {
+      return;
+    }
+    this.recentStderrLines.push(...normalized);
+    if (this.recentStderrLines.length > 12) {
+      this.recentStderrLines = this.recentStderrLines.slice(-12);
+    }
+  }
+  getRecentStderrExcerpt() {
+    return this.recentStderrLines.slice(-6).join("\n");
+  }
+  getRecentStderrSummaryLine() {
+    for (const line of this.recentStderrLines.slice(-6).reverse()) {
+      if (/^note:\s+run with\b/i.test(line)) {
+        continue;
+      }
+      return line;
+    }
+    return this.recentStderrLines.at(-1);
+  }
+  async cleanupOwnedResources() {
+    if (this.resourceCleanupDone) {
+      return;
+    }
+    this.resourceCleanupDone = true;
+    try {
+      await this.options.resourceCleanup?.();
+    } catch (error) {
+      logger.debug("[AcpBackend] Failed to clean up backend-owned resources:", error);
+    }
+  }
+  updateSessionConfigOptions(configOptions) {
+    this.sessionConfigOptions = Array.isArray(configOptions) ? configOptions : null;
+  }
+  supportsLoadSession() {
+    const capabilities = this.agentCapabilities;
+    return capabilities?.loadSession === true;
+  }
+  supportsResumeSession() {
+    const capabilities = this.agentCapabilities;
+    return capabilities?.sessionCapabilities?.resume != null;
+  }
+  syncSessionConfigOptionsFromUpdate(update) {
+    const configOptions = update.configOptions;
+    if (!Array.isArray(configOptions)) {
+      return false;
+    }
+    this.updateSessionConfigOptions(configOptions);
+    return true;
+  }
+  async applySessionConfigPresets() {
+    if (!this.connection || !this.acpSessionId) {
+      return;
+    }
+    const presetPlan = buildAcpSessionConfigPresetPlan({
+      sessionId: this.acpSessionId,
+      configOptions: this.sessionConfigOptions,
+      preferences: this.sessionPreferences
+    });
+    if (presetPlan.length === 0) {
+      return;
+    }
+    logger.debug(
+      `[AcpBackend] Applying ${presetPlan.length} ACP session config preset(s) for ${this.sessionPreferences.agentName}`
+    );
+    for (const preset of presetPlan) {
+      try {
+        logger.debug(
+          `[AcpBackend] Setting ACP session config ${preset.optionId} from ${String(preset.currentValue)} to ${String(preset.targetValue)}`
+        );
+        const response = await this.connection.setSessionConfigOption(preset.request);
+        this.updateSessionConfigOptions(response.configOptions);
+      } catch (error) {
+        logger.warn(
+          `[AcpBackend] Failed to apply ACP session config preset ${preset.optionId}:`,
+          error
+        );
+      }
+    }
+  }
+  getPostPromptNoUpdatesTimeoutMs() {
+    const explicitTimeout = readPositiveIntegerEnv("HAPPY_ACP_POST_PROMPT_NO_UPDATES_TIMEOUT_MS") ?? readPositiveIntegerEnv("HAPPIER_ACP_POST_PROMPT_NO_UPDATES_TIMEOUT_MS");
+    if (explicitTimeout != null) {
+      return explicitTimeout;
+    }
+    if (this.sessionPreferences.timeoutSource === "env") {
+      return resolveAcpPostPromptNoUpdatesTimeoutMs(
+        DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS,
+        this.sessionPreferences.timeoutProfile
+      );
+    }
+    return resolvePostPromptNoUpdatesTimeoutMs(this.transport);
+  }
+  getResponseWaitTimeoutMs(timeoutMs) {
+    if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+      return Math.trunc(timeoutMs);
+    }
+    return readPositiveIntegerEnv("HAPPY_ACP_RESPONSE_WAIT_TIMEOUT_MS") ?? readPositiveIntegerEnv("HAPPIER_ACP_RESPONSE_WAIT_TIMEOUT_MS") ?? resolveAcpResponseWaitTimeoutMs(this.sessionPreferences.timeoutProfile);
+  }
+  createPromptCompletionWatchdog(timeoutMs) {
+    let timeoutHandle = null;
+    let cancelled = false;
+    const promise = new Promise((resolve, reject) => {
+      const schedule = () => {
+        if (cancelled) {
+          return;
+        }
+        if (this.responseCompletionError) {
+          reject(this.responseCompletionError);
+          return;
+        }
+        if (!this.waitingForResponse) {
+          resolve();
+          return;
+        }
+        const lastProgressAt = this.responseLastProgressAt ?? Date.now();
+        const elapsedMs = Math.max(0, Date.now() - lastProgressAt);
+        const remainingMs = Math.max(1, timeoutMs - elapsedMs);
+        timeoutHandle = setTimeout(() => {
+          timeoutHandle = null;
+          if (cancelled) {
+            return;
+          }
+          if (this.responseCompletionError) {
+            reject(this.responseCompletionError);
+            return;
+          }
+          if (!this.waitingForResponse) {
+            resolve();
+            return;
+          }
+          const latestProgressAt = this.responseLastProgressAt ?? Date.now();
+          const latestElapsedMs = Math.max(0, Date.now() - latestProgressAt);
+          if (latestElapsedMs < timeoutMs) {
+            schedule();
+            return;
+          }
+          const timeoutLabel = formatToolCallTimeoutLimit(timeoutMs);
+          const error = new Error(`Timeout waiting for Codex ACP prompt to complete after ${timeoutLabel} without response progress`);
+          this.failPendingResponseWait(error);
+          reject(error);
+        }, remainingMs);
+      };
+      schedule();
+    });
+    return {
+      promise,
+      cancel: () => {
+        cancelled = true;
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+          timeoutHandle = null;
+        }
+      }
+    };
+  }
+  clearIdleTimeoutState() {
+    if (this.idleTimeout) {
+      clearTimeout(this.idleTimeout);
+      this.idleTimeout = null;
+    }
+  }
+  clearPostPromptCompletionIdleTimeout() {
+    if (this.postPromptCompletionIdleTimeout) {
+      clearTimeout(this.postPromptCompletionIdleTimeout);
+      this.postPromptCompletionIdleTimeout = null;
+    }
+  }
+  clearResponseWaitTimeout() {
+    if (this.responseWaitTimeout) {
+      clearTimeout(this.responseWaitTimeout);
+      this.responseWaitTimeout = null;
+    }
+  }
+  resetResponseWaitTracking() {
+    this.clearResponseWaitTimeout();
+    this.responseWaitTimeoutMs = null;
+    this.responseLastProgressAt = null;
+  }
+  armResponseWaitTimeout(timeoutMs) {
+    this.responseWaitTimeoutMs = timeoutMs;
+    this.clearResponseWaitTimeout();
+    const lastProgressAt = this.responseLastProgressAt ?? Date.now();
+    const elapsedMs = Math.max(0, Date.now() - lastProgressAt);
+    const remainingMs = Math.max(1, timeoutMs - elapsedMs);
+    this.responseWaitTimeout = setTimeout(() => {
+      this.responseWaitTimeout = null;
+      this.responseWaitTimeoutMs = null;
+      this.failPendingResponseWait(new Error("Timeout waiting for response to complete"));
+    }, remainingMs);
+  }
+  scheduleToolCallTimeout(toolCallId) {
+    const spec = this.toolCallTimeoutSpecs.get(toolCallId);
+    if (!spec) {
+      return;
+    }
+    const existing = this.toolCallTimeouts.get(toolCallId);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const timeout = setTimeout(() => {
+      const duration = formatDuration(this.toolCallStartTimes.get(toolCallId));
+      const timeoutLabel = formatToolCallTimeoutLimit(spec.timeoutMs);
+      const timeoutDetail = `Tool call ${spec.toolName} timed out after ${timeoutLabel}`;
+      logger.debug(`[AcpBackend] \u23F1\uFE0F Tool call TIMEOUT (from ${spec.source}): ${toolCallId} (${spec.toolKind}) after ${timeoutLabel} without progress - Duration: ${duration}, failing current turn`);
+      this.activeToolCalls.delete(toolCallId);
+      this.toolCallStartTimes.delete(toolCallId);
+      this.clearToolCallTimeout(toolCallId);
+      this.clearIdleTimeoutState();
+      const streamedOutput = renderToolOutput(this.toolCallOutputs.get(toolCallId));
+      this.toolCallOutputs.delete(toolCallId);
+      this.emit({
+        type: "tool-result",
+        toolName: spec.toolName,
+        result: streamedOutput ? {
+          stdout: streamedOutput,
+          error: timeoutDetail,
+          status: "failed",
+          timedOut: true
+        } : {
+          error: timeoutDetail,
+          status: "failed",
+          timedOut: true
+        },
+        callId: toolCallId
+      });
+      this.emit({
+        type: "status",
+        status: "error",
+        detail: timeoutDetail
+      });
+      this.failPendingResponseWait(new Error(timeoutDetail));
+    }, spec.timeoutMs);
+    this.toolCallTimeouts.set(toolCallId, timeout);
+  }
+  armToolCallTimeout(spec) {
+    this.toolCallTimeoutSpecs.set(spec.toolCallId, spec);
+    this.scheduleToolCallTimeout(spec.toolCallId);
+  }
+  clearToolCallTimeout(toolCallId) {
+    const timeout = this.toolCallTimeouts.get(toolCallId);
+    const hadTimeout = Boolean(timeout);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.toolCallTimeouts.delete(toolCallId);
+    }
+    this.toolCallTimeoutSpecs.delete(toolCallId);
+    return hadTimeout;
+  }
+  finalizeDanglingToolCallsAfterTaskComplete() {
+    if (this.activeToolCalls.size === 0) {
+      return;
+    }
+    const danglingToolCallIds = Array.from(this.activeToolCalls);
+    logger.debug(
+      `[AcpBackend] task_complete arrived with ${danglingToolCallIds.length} active tool call(s); synthesizing completion from buffered output`,
+      danglingToolCallIds
+    );
+    for (const toolCallId of danglingToolCallIds) {
+      const toolName = this.toolCallIdToNameMap.get(toolCallId) || "unknown";
+      const streamedOutput = renderToolOutput(this.toolCallOutputs.get(toolCallId));
+      this.activeToolCalls.delete(toolCallId);
+      this.toolCallStartTimes.delete(toolCallId);
+      this.toolCallIdToNameMap.delete(toolCallId);
+      this.toolCallOutputs.delete(toolCallId);
+      this.clearToolCallTimeout(toolCallId);
+      this.emit({
+        type: "tool-result",
+        toolName,
+        result: streamedOutput,
+        callId: toolCallId
+      });
+    }
+  }
+  refreshActiveToolCallTimeouts() {
+    for (const toolCallId of this.activeToolCalls) {
+      if (this.toolCallTimeoutSpecs.has(toolCallId)) {
+        this.scheduleToolCallTimeout(toolCallId);
+      }
+    }
+  }
+  markResponseProgress(opts = {}) {
+    this.responseLastProgressAt = Date.now();
+    if (opts.refreshToolTimeouts !== false) {
+      this.refreshActiveToolCallTimeouts();
+    }
+    if (this.waitingForResponse && this.responseWaitTimeoutMs != null) {
+      this.armResponseWaitTimeout(this.responseWaitTimeoutMs);
+    }
+  }
+  clearToolCallTracking() {
+    this.activeToolCalls.clear();
+    for (const timeout of this.toolCallTimeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.toolCallTimeouts.clear();
+    this.toolCallTimeoutSpecs.clear();
+    this.toolCallStartTimes.clear();
+    this.toolCallIdToNameMap.clear();
+    this.toolCallOutputs.clear();
+    this.toolCallCountSincePrompt = 0;
+  }
+  resetResponseTrackingForNewPrompt() {
+    this.responseCompletionOutcome = null;
+    this.responseCompletionError = null;
+    this.sawSessionUpdateSincePrompt = false;
+    this.oversizedStdoutNoticeEmittedForCurrentTurn = false;
+    this.resetResponseWaitTracking();
+    this.clearIdleTimeoutState();
+    this.clearPostPromptCompletionIdleTimeout();
+    this.clearToolCallTracking();
+  }
+  failPendingResponseWait(error) {
+    if (this.responseCompletionError) {
+      return;
+    }
+    this.responseCompletionError = error;
+    this.responseCompletionOutcome = null;
+    this.waitingForResponse = false;
+    this.resetResponseWaitTracking();
+    this.clearPostPromptCompletionIdleTimeout();
+    if (this.idleRejecter) {
+      this.idleRejecter(error);
+    }
+    this.idleResolver = null;
+    this.idleRejecter = null;
+  }
+  settleResponseWaiter(outcome) {
+    const hasActiveWaiter = Boolean(this.idleResolver || this.idleRejecter);
+    this.resetResponseWaitTracking();
+    if (!this.waitingForResponse && !hasActiveWaiter) {
+      return;
+    }
+    if (!hasActiveWaiter) {
+      this.waitingForResponse = false;
+      this.responseCompletionOutcome = outcome;
+      return;
+    }
+    if (outcome.kind === "resolved") {
+      this.idleResolver?.();
+      return;
+    }
+    this.idleRejecter?.(outcome.error);
+  }
+  onMessage(handler) {
+    this.listeners.push(handler);
+  }
+  offMessage(handler) {
+    const index = this.listeners.indexOf(handler);
+    if (index !== -1) {
+      this.listeners.splice(index, 1);
+    }
+  }
+  emit(msg) {
+    if (this.disposed) return;
+    for (const listener of this.listeners) {
+      try {
+        listener(msg);
+      } catch (error) {
+        logger.warn("[AcpBackend] Error in message handler:", error);
+      }
+    }
+  }
+  handleDroppedStdoutLine(entry) {
+    if (entry.reason === "multiline_overflow") {
+      if (!this.waitingForResponse || this.responseCompletionError || this.oversizedStdoutNoticeEmittedForCurrentTurn) {
+        return;
+      }
+      this.oversizedStdoutNoticeEmittedForCurrentTurn = true;
+      this.emit({
+        type: "status",
+        status: "running",
+        detail: buildMultilineOverflowStatusDetail(this.acpMaxMultilineStdoutBytes)
+      });
+      return;
+    }
+    if (entry.reason !== "transport_filter_null" || !this.waitingForResponse || this.responseCompletionError) {
+      return;
+    }
+    const raw = entry.line.trim();
+    if (!raw) {
+      return;
+    }
+    const context = {
+      activeToolCalls: this.activeToolCalls,
+      hasActiveInvestigation: this.transport.isInvestigationTool ? Array.from(this.activeToolCalls).some((id) => this.transport.isInvestigationTool(id)) : false
+    };
+    const transportResult = this.transport.handleStderr?.(entry.line, context);
+    const transportMessage = transportResult?.message ?? null;
+    if (transportMessage) {
+      this.emit(transportMessage);
+      const errorDetail = getStatusErrorDetail(transportMessage);
+      if (errorDetail) {
+        this.failPendingResponseWait(new Error(errorDetail));
+      }
+      return;
+    }
+    if (!looksLikeDroppedStdoutError(raw)) {
+      return;
+    }
+    this.emit({
+      type: "status",
+      status: "error",
+      detail: raw
+    });
+    this.failPendingResponseWait(new Error(raw));
+  }
+  async startSession(initialPrompt) {
+    if (this.disposed) {
+      throw new Error("Backend has been disposed");
+    }
+    const sessionId = randomUUID();
+    this.emit({ type: "status", status: "starting" });
+    try {
+      logger.debug(`[AcpBackend] Starting session: ${sessionId}`);
+      this.recentStderrLines = [];
+      const spawnSpec = buildAcpSpawnSpec({
+        command: this.options.command,
+        args: this.options.args ?? [],
+        cwd: this.options.cwd,
+        env: { ...process.env, ...this.options.env }
+      });
+      this.process = spawn(spawnSpec.command, spawnSpec.args, spawnSpec.options);
+      if (this.process.stderr) {
+      }
+      if (!this.process.stdin || !this.process.stdout || !this.process.stderr) {
+        throw new Error("Failed to create stdio pipes");
+      }
+      this.process.stderr.on("data", (data) => {
+        const text = data.toString();
+        if (!text.trim()) return;
+        this.recordRecentStderr(text);
+        const hasActiveInvestigation = this.transport.isInvestigationTool ? Array.from(this.activeToolCalls).some((id) => this.transport.isInvestigationTool(id)) : false;
+        const context = {
+          activeToolCalls: this.activeToolCalls,
+          hasActiveInvestigation
+        };
+        if (hasActiveInvestigation) {
+          logger.debug(`[AcpBackend] \u{1F50D} Agent stderr (during investigation): ${text.trim()}`);
+        } else {
+          logger.debug(`[AcpBackend] Agent stderr: ${text.trim()}`);
+        }
+        if (this.transport.handleStderr) {
+          const result = this.transport.handleStderr(text, context);
+          if (result.message) {
+            this.emit(result.message);
+            const errorDetail = getStatusErrorDetail(result.message);
+            if (errorDetail && this.waitingForResponse) {
+              this.failPendingResponseWait(new Error(errorDetail));
+            }
+          }
+        }
+      });
+      this.process.on("error", (err) => {
+        logger.debug(`[AcpBackend] Process error:`, err);
+        if (this.waitingForResponse) {
+          this.failPendingResponseWait(err);
+        }
+        this.emit({ type: "status", status: "error", detail: err.message });
+      });
+      this.process.on("exit", (code, signal) => {
+        logger.debug(
+          `[AcpBackend] Process exited with code ${code}, signal ${signal}, disposed=${this.disposed}, waitingForResponse=${this.waitingForResponse}`
+        );
+        const recentStderrExcerpt = this.getRecentStderrExcerpt();
+        const recentStderrSummaryLine = this.getRecentStderrSummaryLine();
+        if (recentStderrExcerpt) {
+          logger.debug(`[AcpBackend] Recent stderr before exit:
+${recentStderrExcerpt}`);
+        }
+        if (this.disposed) {
+          return;
+        }
+        if (this.waitingForResponse) {
+          const detail = code !== null ? `ACP process exited with code ${code}${signal ? ` (${signal})` : ""}` : signal ? `ACP process exited with signal ${signal}` : "ACP process exited unexpectedly";
+          this.failPendingResponseWait(new Error(detail));
+        }
+        if (code !== 0 && code !== null) {
+          const detail = recentStderrSummaryLine ? `Exit code: ${code}
+Recent stderr: ${recentStderrSummaryLine}` : `Exit code: ${code}`;
+          this.emit({ type: "status", status: "stopped", detail });
+          return;
+        }
+        if (signal) {
+          const detail = recentStderrSummaryLine ? `Signal: ${signal}
+Recent stderr: ${recentStderrSummaryLine}` : `Signal: ${signal}`;
+          this.emit({ type: "status", status: "stopped", detail });
+        }
+      });
+      const streams = nodeToWebStreams(
+        this.process.stdin,
+        this.process.stdout
+      );
+      const writable = streams.writable;
+      const readable = streams.readable;
+      const droppedStdoutSummary = {
+        count: 0,
+        samples: []
+      };
+      const filteredReadable = createAcpFilteredStdoutReadable({
+        readable,
+        transport: this.transport,
+        onDroppedLine: (entry) => {
+          appendDroppedStdoutLineSummary(droppedStdoutSummary, entry);
+          this.handleDroppedStdoutLine(entry);
+        },
+        onDone: () => {
+          if (droppedStdoutSummary.count > 0) {
+            logger.debug(
+              `[AcpBackend] Filtered out ${droppedStdoutSummary.count} stdout lines from ${this.transport.agentName}`,
+              droppedStdoutSummary.samples
+            );
+          }
+        },
+        maxMultilineBytes: this.acpMaxMultilineStdoutBytes
+      });
+      const stream = ndJsonStream(writable, filteredReadable);
+      const client = {
+        sessionUpdate: async (params) => {
+          this.handleSessionUpdate(params);
+        },
+        requestPermission: async (params) => {
+          const extendedParams = params;
+          const toolCall = extendedParams.toolCall;
+          let toolName = toolCall?.kind || toolCall?.toolName || extendedParams.kind || "Unknown tool";
+          const toolCallId = toolCall?.id || randomUUID();
+          const permissionId = toolCallId;
+          let input = {};
+          if (toolCall) {
+            input = toolCall.input || toolCall.arguments || toolCall.content || {};
+          } else {
+            input = extendedParams.input || extendedParams.arguments || extendedParams.content || {};
+          }
+          const context = {
+            toolCallCountSincePrompt: this.toolCallCountSincePrompt
+          };
+          toolName = this.transport.determineToolName?.(toolName, toolCallId, input, context) ?? toolName;
+          if (toolName !== (toolCall?.kind || toolCall?.toolName || extendedParams.kind || "Unknown tool")) {
+            logger.debug(`[AcpBackend] Detected tool name: ${toolName} from toolCallId: ${toolCallId}`);
+          }
+          this.toolCallCountSincePrompt++;
+          const options = extendedParams.options || [];
+          const isSelectionRequest = isSelectionPermissionRequest(extendedParams);
+          logger.debug(`[AcpBackend] Permission request: tool=${toolName}, toolCallId=${toolCallId}, input=`, JSON.stringify(input));
+          logger.debug(`[AcpBackend] Permission request params structure:`, JSON.stringify({
+            hasToolCall: !!toolCall,
+            toolCallKind: toolCall?.kind,
+            toolCallId: toolCall?.id,
+            paramsKind: extendedParams.kind,
+            paramsKeys: Object.keys(params)
+          }, null, 2));
+          if (isSelectionRequest) {
+            const selectionOptions = options.reduce((acc, option) => {
+              if (!option.optionId) {
+                return acc;
+              }
+              const displayOption = option;
+              acc.push({
+                optionId: option.optionId,
+                label: displayOption.label || option.name || option.optionId,
+                description: displayOption.description || option.name || option.optionId
+              });
+              return acc;
+            }, []);
+            if (selectionOptions.length === 0) {
+              logger.debug("[AcpBackend] Selection request has no valid options, cancelling");
+              return { outcome: { outcome: "selected", optionId: "cancel" } };
+            }
+            if (!this.options.selectionHandler) {
+              logger.debug("[AcpBackend] No selection handler configured, cancelling selection request");
+              return { outcome: { outcome: "selected", optionId: "cancel" } };
+            }
+            try {
+              const selectionMessage = typeof extendedParams.message === "string" && extendedParams.message.trim().length > 0 ? extendedParams.message : formatDisplayMessage(input).trim() || toolName;
+              const requestId = extendedParams.codex_event_id || extendedParams.codex_elicitation || toolCallId;
+              const response = await this.options.selectionHandler.handleSelection({
+                id: requestId,
+                message: selectionMessage,
+                options: selectionOptions,
+                defaultOptionId: extendedParams.requestedSchema?.properties?.optionId?.default
+              });
+              return { outcome: { outcome: "selected", optionId: response.optionId } };
+            } catch (error) {
+              logger.debug("[AcpBackend] Error in selection handler:", error);
+              return { outcome: { outcome: "selected", optionId: "cancel" } };
+            }
+          }
+          this.emit({
+            type: "permission-request",
+            id: permissionId,
+            reason: toolName,
+            payload: {
+              ...params,
+              permissionId,
+              toolCallId,
+              toolName,
+              input,
+              options: options.map((opt) => ({
+                id: opt.optionId,
+                name: opt.name,
+                kind: opt.kind
+              }))
+            }
+          });
+          if (this.options.permissionHandler) {
+            try {
+              const result = await this.options.permissionHandler.handleToolCall(
+                toolCallId,
+                toolName,
+                input
+              );
+              let optionId = "cancel";
+              if (result.decision === "approved" || result.decision === "approved_for_session") {
+                const proceedOnceOption2 = options.find(
+                  (opt) => opt.optionId === "proceed_once" || opt.name?.toLowerCase().includes("once")
+                );
+                const proceedAlwaysOption = options.find(
+                  (opt) => opt.optionId === "proceed_always" || opt.name?.toLowerCase().includes("always")
+                );
+                if (result.decision === "approved_for_session" && proceedAlwaysOption) {
+                  optionId = proceedAlwaysOption.optionId || "proceed_always";
+                } else if (proceedOnceOption2) {
+                  optionId = proceedOnceOption2.optionId || "proceed_once";
+                } else if (options.length > 0) {
+                  optionId = options[0].optionId || "proceed_once";
+                }
+                this.emit({
+                  type: "tool-result",
+                  toolName,
+                  result: { status: "approved", decision: result.decision },
+                  callId: permissionId
+                });
+              } else {
+                const cancelOption = options.find(
+                  (opt) => opt.optionId === "cancel" || opt.name?.toLowerCase().includes("cancel")
+                );
+                if (cancelOption) {
+                  optionId = cancelOption.optionId || "cancel";
+                }
+                this.emit({
+                  type: "tool-result",
+                  toolName,
+                  result: { status: "denied", decision: result.decision },
+                  callId: permissionId
+                });
+              }
+              return { outcome: { outcome: "selected", optionId } };
+            } catch (error) {
+              logger.debug("[AcpBackend] Error in permission handler:", error);
+              return { outcome: { outcome: "selected", optionId: "cancel" } };
+            }
+          }
+          const proceedOnceOption = options.find(
+            (opt) => opt.optionId === "proceed_once" || typeof opt.name === "string" && opt.name.toLowerCase().includes("once")
+          );
+          const defaultOptionId = proceedOnceOption?.optionId || (options.length > 0 && options[0].optionId ? options[0].optionId : "proceed_once");
+          return { outcome: { outcome: "selected", optionId: defaultOptionId } };
+        }
+      };
+      this.connection = new ClientSideConnection(
+        (agent) => client,
+        stream
+      );
+      const initRequest = {
+        protocolVersion: 1,
+        clientCapabilities: {
+          _meta: {
+            terminal_output: true
+          },
+          fs: {
+            readTextFile: false,
+            writeTextFile: false
+          }
+        },
+        clientInfo: {
+          name: "happy-cli",
+          version: packageJson.version
+        }
+      };
+      const initTimeout = this.transport.getInitTimeout();
+      const initDelayMs = this.transport.getInitDelayMs?.() ?? 0;
+      if (initDelayMs > 0) {
+        logger.debug(`[AcpBackend] Waiting ${initDelayMs}ms before initialize (${this.transport.agentName})...`);
+        await delay(initDelayMs);
+      }
+      logger.debug(`[AcpBackend] Initializing connection (timeout: ${initTimeout}ms)...`);
+      const initializeResponse = await withRetry(
+        async () => {
+          let timeoutHandle = null;
+          try {
+            const result = await raceWithProcessExit(
+              this.process,
+              () => Promise.race([
+                this.connection.initialize(initRequest).then((res) => {
+                  if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                    timeoutHandle = null;
+                  }
+                  return res;
+                }),
+                new Promise((_, reject) => {
+                  timeoutHandle = setTimeout(() => {
+                    reject(new Error(`Initialize timeout after ${initTimeout}ms - ${this.transport.agentName} did not respond`));
+                  }, initTimeout);
+                })
+              ]),
+              {
+                agentName: this.transport.agentName,
+                operationName: "initialize",
+                getStderrExcerpt: () => this.getRecentStderrExcerpt()
+              }
+            );
+            return result;
+          } finally {
+            if (timeoutHandle) {
+              clearTimeout(timeoutHandle);
+            }
+          }
+        },
+        {
+          operationName: "Initialize",
+          maxAttempts: RETRY_CONFIG.maxAttempts,
+          baseDelayMs: RETRY_CONFIG.baseDelayMs,
+          maxDelayMs: RETRY_CONFIG.maxDelayMs,
+          shouldRetry: (error) => !(error instanceof AcpProcessStartupError)
+        }
+      );
+      this.agentCapabilities = initializeResponse.agentCapabilities ?? null;
+      logger.debug(`[AcpBackend] Initialize completed`);
+      const mcpServers = this.options.mcpServers ? Object.entries(this.options.mcpServers).map(([name, config]) => ({
+        name,
+        command: config.command,
+        args: config.args || [],
+        env: config.env ? Object.entries(config.env).map(([envName, envValue]) => ({ name: envName, value: envValue })) : []
+      })) : [];
+      const newSessionRequest = {
+        cwd: this.options.cwd,
+        mcpServers
+      };
+      const requestedResumeSessionId = typeof this.options.resumeSessionId === "string" && this.options.resumeSessionId.trim() ? this.options.resumeSessionId.trim() : null;
+      const sessionOperation = requestedResumeSessionId && this.supportsResumeSession() ? "resume" : requestedResumeSessionId && this.supportsLoadSession() ? "load" : "new";
+      const sessionRequest = sessionOperation === "resume" ? {
+        cwd: this.options.cwd,
+        mcpServers,
+        sessionId: requestedResumeSessionId
+      } : sessionOperation === "load" ? {
+        cwd: this.options.cwd,
+        mcpServers,
+        sessionId: requestedResumeSessionId
+      } : newSessionRequest;
+      if (requestedResumeSessionId && sessionOperation === "new") {
+        throw new Error("ACP agent does not support session resume/load; refusing to fork the Codex conversation");
+      }
+      logger.debug(`[AcpBackend] ${sessionOperation === "new" ? "Creating new" : `${sessionOperation === "resume" ? "Resuming" : "Loading"} existing`} session...`);
+      const sessionResponse = await withRetry(
+        async () => {
+          let timeoutHandle = null;
+          try {
+            const resumeSession = this.connection.resumeSession ?? this.connection.unstable_resumeSession;
+            const result = await raceWithProcessExit(
+              this.process,
+              () => Promise.race([
+                (sessionOperation === "resume" ? resumeSession ? resumeSession(sessionRequest).then((response) => ({
+                  ...response,
+                  sessionId: requestedResumeSessionId
+                })) : Promise.reject(new Error("ACP agent advertised session resume, but this SDK connection does not expose resumeSession.")) : sessionOperation === "load" ? this.connection.loadSession(sessionRequest) : this.connection.newSession(sessionRequest)).then((res) => {
+                  if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                    timeoutHandle = null;
+                  }
+                  return res;
+                }),
+                new Promise((_, reject) => {
+                  timeoutHandle = setTimeout(() => {
+                    reject(new Error(`New session timeout after ${initTimeout}ms - ${this.transport.agentName} did not respond`));
+                  }, initTimeout);
+                })
+              ]),
+              {
+                agentName: this.transport.agentName,
+                operationName: "new session",
+                getStderrExcerpt: () => this.getRecentStderrExcerpt()
+              }
+            );
+            return result;
+          } finally {
+            if (timeoutHandle) {
+              clearTimeout(timeoutHandle);
+            }
+          }
+        },
+        {
+          operationName: sessionOperation === "resume" ? "ResumeSession" : sessionOperation === "load" ? "LoadSession" : "NewSession",
+          maxAttempts: RETRY_CONFIG.maxAttempts,
+          baseDelayMs: RETRY_CONFIG.baseDelayMs,
+          maxDelayMs: RETRY_CONFIG.maxDelayMs,
+          shouldRetry: (error) => !(error instanceof AcpProcessStartupError)
+        }
+      );
+      this.acpSessionId = requestedResumeSessionId ?? sessionResponse.sessionId;
+      this.updateSessionConfigOptions(sessionResponse.configOptions);
+      logger.debug(`[AcpBackend] Session created: ${this.acpSessionId}`);
+      await this.applySessionConfigPresets();
+      this.emitIdleStatus();
+      if (initialPrompt) {
+        this.sendPrompt(sessionId, initialPrompt).catch((error) => {
+          logger.debug("[AcpBackend] Error sending initial prompt:", error);
+          this.emit({ type: "status", status: "error", detail: formatAcpErrorMessage(error) });
+        });
+      }
+      return { sessionId };
+    } catch (error) {
+      const enrichedError = enrichAcpError(error, this.getRecentStderrExcerpt());
+      if (this.process) {
+        try {
+          await killProcessTree(this.process, { graceMs: 250 });
+        } catch {
+        } finally {
+          this.process = null;
+        }
+      }
+      this.connection = null;
+      this.acpSessionId = null;
+      await this.cleanupOwnedResources();
+      logger.debug("[AcpBackend] Error starting session:", enrichedError);
+      this.emit({
+        type: "status",
+        status: "error",
+        detail: formatAcpErrorMessage(enrichedError)
+      });
+      throw enrichedError;
+    }
+  }
+  /**
+   * Create handler context for session update processing
+   */
+  createHandlerContext() {
+    return {
+      transport: this.transport,
+      activeToolCalls: this.activeToolCalls,
+      toolCallStartTimes: this.toolCallStartTimes,
+      toolCallTimeouts: this.toolCallTimeouts,
+      toolCallIdToNameMap: this.toolCallIdToNameMap,
+      toolCallOutputs: this.toolCallOutputs,
+      idleTimeout: this.idleTimeout,
+      toolCallCountSincePrompt: this.toolCallCountSincePrompt,
+      emit: (msg) => this.emit(msg),
+      emitIdleStatus: () => this.emitIdleStatus(),
+      failPendingResponseWait: (error) => this.failPendingResponseWait(error),
+      armToolCallTimeout: (spec) => this.armToolCallTimeout(spec),
+      clearToolCallTimeout: (toolCallId) => this.clearToolCallTimeout(toolCallId),
+      clearIdleTimeout: () => {
+        if (this.idleTimeout) {
+          clearTimeout(this.idleTimeout);
+          this.idleTimeout = null;
+        }
+      },
+      setIdleTimeout: (callback, ms) => {
+        this.idleTimeout = setTimeout(() => {
+          callback();
+          this.idleTimeout = null;
+        }, ms);
+      }
+    };
+  }
+  emitUsageTelemetry(payload, source) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+      return false;
+    }
+    const tokens = extractUsageTokens(payload);
+    if (!tokens) {
+      return false;
+    }
+    this.emit({
+      type: "token-count",
+      key: source,
+      tokens,
+      source
+    });
+    return true;
+  }
+  handleSessionUpdate(params) {
+    const updates = getSessionUpdates(params);
+    if (updates.length === 0) {
+      logger.debug("[AcpBackend] Received session update without update field:", params);
+      return;
+    }
+    this.sawSessionUpdateSincePrompt = true;
+    this.clearPostPromptCompletionIdleTimeout();
+    for (const update of updates) {
+      const sessionUpdateType = update.sessionUpdate;
+      if (sessionUpdateType !== "agent_message_chunk" && sessionUpdateType !== "tool_call_update") {
+        logger.debug(`[AcpBackend] Received session update: ${sessionUpdateType}`, JSON.stringify({
+          sessionUpdate: sessionUpdateType,
+          toolCallId: update.toolCallId,
+          status: update.status,
+          kind: update.kind,
+          hasContent: !!update.content,
+          hasLocations: !!update.locations
+        }, null, 2));
+      }
+      const ctx = this.createHandlerContext();
+      const toolCallId = update.toolCallId;
+      const wasToolCallActive = typeof toolCallId === "string" && this.activeToolCalls.has(toolCallId);
+      const supplementalToolProgress = extractSupplementalToolProgress(update);
+      if (sessionUpdateType === "agent_message_chunk") {
+        if (handleAgentMessageChunk(update, ctx).handled) {
+          this.markResponseProgress();
+        }
+        continue;
+      }
+      if (sessionUpdateType === "tool_call_update") {
+        const result = handleToolCallUpdate(update, ctx, {
+          supplementalOutputChunk: supplementalToolProgress && supplementalToolProgress.toolCallId === toolCallId ? supplementalToolProgress.outputChunk : null
+        });
+        if (result.toolCallCountSincePrompt !== void 0) {
+          this.toolCallCountSincePrompt = result.toolCallCountSincePrompt;
+        }
+        const isToolCallActive = typeof toolCallId === "string" && this.activeToolCalls.has(toolCallId);
+        if (shouldRefreshProgressForToolCallUpdate(
+          update,
+          wasToolCallActive,
+          isToolCallActive,
+          result.hadVisibleProgress
+        )) {
+          this.markResponseProgress();
+        }
+        continue;
+      }
+      if (sessionUpdateType === "agent_thought_chunk") {
+        if (handleAgentThoughtChunk(update, ctx).handled) {
+          this.markResponseProgress();
+        }
+        continue;
+      }
+      if (sessionUpdateType === "tool_call") {
+        const result = handleToolCall(update, ctx);
+        const isToolCallActive = typeof toolCallId === "string" && this.activeToolCalls.has(toolCallId);
+        if (result.handled && !wasToolCallActive && isToolCallActive) {
+          this.markResponseProgress();
+        }
+        continue;
+      }
+      if (sessionUpdateType === "usage_update") {
+        this.emitUsageTelemetry(update, "acp-usage-update");
+        continue;
+      }
+      if (sessionUpdateType === "config_option_update") {
+        if (this.syncSessionConfigOptionsFromUpdate(update)) {
+          this.markResponseProgress({ refreshToolTimeouts: false });
+        }
+        continue;
+      }
+      if (sessionUpdateType === "task_complete") {
+        this.emitUsageTelemetry(update.usage, "acp-session-usage");
+        this.finalizeDanglingToolCallsAfterTaskComplete();
+        ctx.clearIdleTimeout();
+        logger.debug("[AcpBackend] task_complete received, emitting idle status");
+        this.emitIdleStatus();
+        continue;
+      }
+      const handledLegacy = handleLegacyMessageChunk(update, ctx).handled;
+      const handledPlan = handlePlanUpdate(update, ctx).handled;
+      const handledThinking = handleThinkingUpdate(update, ctx).handled;
+      const handledUsage = this.emitUsageTelemetry(update.usage, "acp-session-usage");
+      if (handledLegacy || handledPlan || handledThinking) {
+        this.markResponseProgress();
+      }
+      const updateTypeStr = sessionUpdateType;
+      const handledTypes = [
+        "agent_message_chunk",
+        "tool_call_update",
+        "agent_thought_chunk",
+        "tool_call",
+        "usage_update",
+        "config_option_update",
+        "task_complete"
+      ];
+      if (updateTypeStr && !handledTypes.includes(updateTypeStr) && !handledLegacy && !handledPlan && !handledThinking && !handledUsage) {
+        logger.debug(`[AcpBackend] Unhandled session update type: ${updateTypeStr}`, JSON.stringify(update, null, 2));
+      }
+    }
+  }
+  async sendPrompt(sessionId, prompt) {
+    this.toolCallCountSincePrompt = 0;
+    if (this.disposed) {
+      throw new Error("Backend has been disposed");
+    }
+    if (!this.connection || !this.acpSessionId) {
+      throw new Error("Session not started");
+    }
+    this.resetResponseTrackingForNewPrompt();
+    this.emit({ type: "status", status: "running" });
+    this.waitingForResponse = true;
+    this.markResponseProgress({ refreshToolTimeouts: false });
+    try {
+      logger.debug(`[AcpBackend] Sending prompt (length: ${prompt.length}): ${prompt.substring(0, 100)}...`);
+      logger.debug(`[AcpBackend] Full prompt: ${prompt}`);
+      const contentBlock = {
+        type: "text",
+        text: prompt
+      };
+      const promptRequest = {
+        sessionId: this.acpSessionId,
+        prompt: [contentBlock]
+      };
+      logger.debug(`[AcpBackend] Prompt request:`, JSON.stringify(promptRequest, null, 2));
+      const promptWatchdog = this.createPromptCompletionWatchdog(this.getResponseWaitTimeoutMs());
+      try {
+        await raceWithProcessExit(
+          this.process,
+          () => Promise.race([
+            this.connection.prompt(promptRequest),
+            promptWatchdog.promise
+          ]),
+          {
+            agentName: this.transport.agentName,
+            operationName: "prompt",
+            getStderrExcerpt: () => this.getRecentStderrExcerpt()
+          }
+        );
+      } finally {
+        promptWatchdog.cancel();
+      }
+      logger.debug("[AcpBackend] Prompt request sent to ACP connection");
+      if (this.waitingForResponse && this.activeToolCalls.size === 0 && this.sawSessionUpdateSincePrompt === false) {
+        const noUpdatesTimeoutMs = this.getPostPromptNoUpdatesTimeoutMs();
+        this.postPromptCompletionIdleTimeout = setTimeout(() => {
+          this.postPromptCompletionIdleTimeout = null;
+          if (this.responseCompletionError || !this.waitingForResponse) {
+            return;
+          }
+          if (this.sawSessionUpdateSincePrompt || this.activeToolCalls.size > 0) {
+            return;
+          }
+          const exitCode = this.process?.exitCode;
+          if (typeof exitCode === "number" && Number.isFinite(exitCode) && exitCode !== 0) {
+            this.failPendingResponseWait(new Error(`Exit code: ${exitCode}`));
+            return;
+          }
+          const signalCode = this.process?.signalCode;
+          if (typeof signalCode === "string" && signalCode.trim().length > 0) {
+            this.failPendingResponseWait(new Error(`Signal: ${signalCode}`));
+            return;
+          }
+          this.emitIdleStatus();
+        }, Math.max(100, noUpdatesTimeoutMs));
+      }
+    } catch (error) {
+      logger.debug("[AcpBackend] Error sending prompt:", error);
+      let errorDetail;
+      if (error instanceof Error) {
+        errorDetail = error.message;
+      } else if (typeof error === "object" && error !== null) {
+        errorDetail = formatAcpErrorMessage(error);
+      } else {
+        errorDetail = formatAcpErrorMessage(error);
+      }
+      this.emit({
+        type: "status",
+        status: "error",
+        detail: errorDetail
+      });
+      this.failPendingResponseWait(error instanceof Error ? error : normalizeAcpError(error));
+      throw error;
+    }
+  }
+  /**
+   * Wait for the response to complete (idle status after all chunks received)
+   * Call this after sendPrompt to wait for Gemini to finish responding
+   */
+  async waitForResponseComplete(timeoutMs) {
+    if (this.responseCompletionError) {
+      throw this.responseCompletionError;
+    }
+    const pendingOutcome = this.responseCompletionOutcome;
+    if (pendingOutcome) {
+      this.responseCompletionOutcome = null;
+      if (pendingOutcome.kind === "rejected") {
+        throw pendingOutcome.error;
+      }
+      return;
+    }
+    if (!this.waitingForResponse) {
+      return;
+    }
+    const effectiveTimeoutMs = this.getResponseWaitTimeoutMs(timeoutMs);
+    return new Promise((resolve, reject) => {
+      this.idleResolver = () => {
+        this.idleResolver = null;
+        this.idleRejecter = null;
+        this.waitingForResponse = false;
+        resolve();
+      };
+      this.idleRejecter = (error) => {
+        this.idleResolver = null;
+        this.idleRejecter = null;
+        this.waitingForResponse = false;
+        reject(error);
+      };
+      this.armResponseWaitTimeout(effectiveTimeoutMs);
+    });
+  }
+  /**
+   * Helper to emit idle status and resolve any waiting promises
+   */
+  emitIdleStatus() {
+    this.clearPostPromptCompletionIdleTimeout();
+    this.emit({ type: "status", status: "idle" });
+    this.settleResponseWaiter({ kind: "resolved" });
+  }
+  async cancel(sessionId) {
+    const cancelError = createAcpAbortError("Cancelled by user");
+    this.clearIdleTimeoutState();
+    this.clearPostPromptCompletionIdleTimeout();
+    this.clearToolCallTracking();
+    this.settleResponseWaiter({ kind: "rejected", error: cancelError });
+    this.emit({ type: "status", status: "stopped", detail: "Cancelled by user" });
+    if (!this.connection || !this.acpSessionId) {
+      return;
+    }
+    try {
+      await this.connection.cancel({ sessionId: this.acpSessionId });
+    } catch (error) {
+      logger.debug("[AcpBackend] Error cancelling:", error);
+    }
+  }
+  /**
+   * Emit permission response event for UI/logging purposes.
+   *
+   * **IMPORTANT:** For ACP backends, this method does NOT send the actual permission
+   * response to the agent. The ACP protocol requires synchronous permission handling,
+   * which is done inside the `requestPermission` RPC handler via `this.options.permissionHandler`.
+   *
+   * This method only emits a `permission-response` event for:
+   * - UI updates (e.g., closing permission dialogs)
+   * - Logging and debugging
+   * - Other parts of the CLI that need to react to permission decisions
+   *
+   * @param requestId - The ID of the permission request
+   * @param approved - Whether the permission was granted
+   */
+  async respondToPermission(requestId, approved) {
+    logger.debug(`[AcpBackend] Permission response event (UI only): ${requestId} = ${approved}`);
+    this.emit({ type: "permission-response", id: requestId, approved });
+  }
+  async dispose() {
+    if (this.disposed) return;
+    logger.debug("[AcpBackend] Disposing backend");
+    this.disposed = true;
+    this.settleResponseWaiter({
+      kind: "rejected",
+      error: createAcpAbortError("ACP backend disposed")
+    });
+    const processStillRunning = this.process ? this.process.exitCode === null && this.process.signalCode === null : false;
+    if (this.connection && this.acpSessionId && processStillRunning) {
+      try {
+        await Promise.race([
+          this.connection.cancel({ sessionId: this.acpSessionId }),
+          new Promise((resolve) => setTimeout(resolve, 2e3))
+          // 2s timeout for graceful shutdown
+        ]);
+      } catch (error) {
+        logger.debug("[AcpBackend] Error during graceful shutdown:", error);
+      }
+    } else if (this.connection && this.acpSessionId && this.process && !processStillRunning) {
+      logger.debug("[AcpBackend] Skipping graceful shutdown because ACP process already exited");
+    }
+    if (this.process) {
+      try {
+        await killProcessTree(this.process, { graceMs: 1e3 });
+      } catch (error) {
+        logger.debug("[AcpBackend] Failed to kill ACP process tree:", error);
+      } finally {
+        this.process = null;
+      }
+    }
+    this.clearIdleTimeoutState();
+    this.clearPostPromptCompletionIdleTimeout();
+    this.listeners = [];
+    this.connection = null;
+    this.acpSessionId = null;
+    this.sessionConfigOptions = null;
+    this.clearToolCallTracking();
+    this.pendingPermissions.clear();
+    await this.cleanupOwnedResources();
+  }
+}
+
+export { AcpBackend as A };