very-happy-cli 0.2.158 → 0.2.160

package/dist/runClaudeDeps-DOt79DjU.mjs

@@ -0,0 +1,3624 @@
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { k as notifyDaemonSessionEvent, m as notifyDaemonClaudeAuthFailed } from './controlClient-BGbDcgWS.mjs';
+export { g as reportSessionEditToDaemon } from './controlClient-BGbDcgWS.mjs';
+import { s as sameBackgroundTasks, c as createBackgroundTaskTracker } from './backgroundTaskActivity-8PdPxrvy.mjs';
+import { randomInt, randomUUID, createHash } from 'node:crypto';
+import { M as MessageBuffer } from './messageBuffer-BWlGgR3A.mjs';
+import { query } from './index-B6UGRQ7h.mjs';
+import { AbortError } from '@anthropic-ai/claude-agent-sdk';
+import { m as mapToClaudeMode, p as parseClaudePermissionMode } from './permissionMode-Cr5JCbB7.mjs';
+import { c as claudeCheckSession, s as systemPrompt } from './systemPrompt-DX521JJz.mjs';
+import { join, resolve, dirname } from 'node:path';
+import { p as parseSpecialCommand } from './specialCommands-BSqhYg5X.mjs';
+import 'axios';
+import 'node:events';
+import 'socket.io-client';
+import { A as AsyncLock } from './attachmentLimits-yba1uHFO.mjs';
+import 'tweetnacl';
+import { c as configuration, e as ensurePrivateDirectory } from './configuration-RfeNjFmd.mjs';
+import './index-qdS1friN.mjs';
+import './registerCommonHandlers-Ccvsz7Ou.mjs';
+import 'os';
+import 'child_process';
+import '@paralleldrive/cuid2';
+import './persistence-HGW_ZVs9.mjs';
+import { c as contentLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
+import 'chalk';
+export { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
+import { g as getProjectPath } from './path-D2wdaNSk.mjs';
+import { access } from 'fs/promises';
+import { d as delay } from './time-D0XyHOid.mjs';
+import { F as Future } from './sessionScanner-CX3onqXh.mjs';
+export { c as createSessionScanner } from './sessionScanner-CX3onqXh.mjs';
+import { execSync } from 'node:child_process';
+import { S as StreamRelay } from './streamRelay-FPVbHpbM.mjs';
+import { C as CLAUDE_ATTACHMENT_KINDS, c as chatAttachmentDirectory, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-_kxRznNf.mjs';
+export { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-GYvHdipX.mjs';
+import { h as hashObject, i as isSelfReportFresh } from './deterministicJson-CzkFJWw1.mjs';
+export { c as createSelfReportState, s as startHappyServer } from './deterministicJson-CzkFJWw1.mjs';
+export { g as getEnvironmentInfo } from './doctor-DOvByjbk.mjs';
+import { createServer } from 'node:http';
+export { E as EditReportThrottle, b as extractClaudeEditPaths } from './editPaths-BVfS_FFL.mjs';
+import { existsSync, unlinkSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { r as resolveClaudeBinary, a as runClaudeOneShot } from './titleGenerator-CQ8CoGhg.mjs';
+export { T as TitleGenerator } from './titleGenerator-CQ8CoGhg.mjs';
+import { B as BOARD_ANALYZER_PROMPT_PREFIX } from './oneShotPrompts-DT4p6RNd.mjs';
+import 'node:util';
+import './smallFastModel-BLNgMrwR.mjs';
+import './trimIdent-BAjmv_TG.mjs';
+import 'node:os';
+import './agentGuidance-CQuNlNx8.mjs';
+import 'zod';
+import './package-BhaKlnxz.mjs';
+import 'node:fs/promises';
+import 'util';
+import 'crypto';
+import 'path';
+import 'cross-spawn';
+import './authRelay-DSAvg1uv.mjs';
+import './sync-C8gyQFMc.mjs';
+import './startFileWatcher-DErVWZE4.mjs';
+import './client-CeGKqqcJ.mjs';
+import './context-H0Bcb9S_.mjs';
+import './sessionOps-SuHW8Dfe.mjs';
+import './resources-BdFBQi8r.mjs';
+import './tools-DkluDcG4.mjs';
+import './tools-BZtHF_qQ.mjs';
+import './client-ClR0K8zX.mjs';
+import './peerTools-BTqw97Gb.mjs';
+import './ids-DU6sLx4C.mjs';
+import './remoteSessionClient-CYnXRynE.mjs';
+import '@modelcontextprotocol/sdk/server/mcp.js';
+import '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import './limits-DIo7rEBR.mjs';
+import './assistantTools-D6tuc6o4.mjs';
+import './terminals-Dlg0x3nY.mjs';
+import './terminalTitleSuggest-CeKsX_V6.mjs';
+import './tmuxSocket-B8Yx20sT.mjs';
+import './bootstrap-hxXPCFMx.mjs';
+import './previewPath-CXN4Vag0.mjs';
+import './doctor-BPkYWSuq.mjs';
+import 'ps-list';
+import './doctorReadiness-C208SMN9.mjs';
+import './detectCLI-CSGMlV51.mjs';
+import 'fs';
+import './cliUpdate-Y34VGe9Y.mjs';
+import 'url';
+import 'node:module';
+
+class Session {
+  path;
+  logPath;
+  api;
+  client;
+  queue;
+  claudeEnvVars;
+  claudeArgs;
+  // Made mutable to allow filtering
+  mcpServers;
+  allowedTools;
+  sandboxConfig;
+  _onModeChange;
+  _onAbort;
+  /** Path to temporary settings file with SessionStart hook (required for session tracking) */
+  hookSettingsPath;
+  /** JavaScript runtime to use for spawning Claude Code (default: 'node') */
+  jsRuntime;
+  sessionId;
+  mode = "local";
+  thinking = false;
+  /** B-507: background tasks still in flight (async sub-agents, backgrounded
+   *  commands, monitors) — published with every keepAlive. Always an array
+   *  for the Claude runner: an empty one says "nothing running", which is a
+   *  different statement from a runner that has no such notion (undefined). */
+  backgroundTasks = [];
+  /**
+   * Window after a user-initiated abort during which stray promise rejections
+   * from tearing down the SDK query (MCP transports, in-flight tool calls,
+   * the aborted streaming generator) are benign teardown noise — NOT a real
+   * crash. The process-level unhandledRejection/uncaughtException handlers
+   * must not treat them as fatal and force-archive the session (the reported
+   * "点终止就 archive" bug). Self-expiring so a genuine later crash still
+   * archives normally.
+   */
+  abortingUntil = 0;
+  markAborting = (windowMs = 8e3) => {
+    this.abortingUntil = Date.now() + windowMs;
+  };
+  isAborting = () => Date.now() < this.abortingUntil;
+  /**
+   * Account-encrypted notification producer. Set lazily once we have a
+   * server session id (notifications are addressed per session). May be
+   * null in offline/degraded paths — all call sites must null-check.
+   */
+  notificationProducer = null;
+  /**
+   * Whether Claude produced assistant text output during the current turn.
+   * Used at turn end to distinguish `reply_done` (Claude replied) from
+   * `input_needed` (turn ended idle without a reply, e.g. after an abort).
+   */
+  hadAssistantOutputThisTurn = false;
+  /** Last assistant text snippet seen this turn, used as the reply_done body. */
+  lastAssistantSnippet;
+  /** Live remote-query input sink. Absent in local mode and between SDK queries. */
+  steerHandler = null;
+  /** B-482: the live remote Query's in-process side-question entry; null between Queries and in local mode. */
+  sideQuestionLive = null;
+  /** Callbacks to be notified when session ID is found/changed */
+  sessionFoundCallbacks = [];
+  /** Keep alive interval reference for cleanup */
+  keepAliveInterval;
+  constructor(opts) {
+    this.path = opts.path;
+    this.api = opts.api;
+    this.client = opts.client;
+    this.logPath = opts.logPath;
+    this.sessionId = opts.sessionId;
+    this.queue = opts.messageQueue;
+    this.claudeEnvVars = opts.claudeEnvVars;
+    this.claudeArgs = opts.claudeArgs;
+    this.mcpServers = opts.mcpServers;
+    this.allowedTools = opts.allowedTools;
+    this.sandboxConfig = opts.sandboxConfig;
+    this._onModeChange = opts.onModeChange;
+    this._onAbort = opts.onAbort;
+    this.hookSettingsPath = opts.hookSettingsPath;
+    this.jsRuntime = opts.jsRuntime ?? "node";
+    try {
+      this.notificationProducer = opts.api.notificationProducer(
+        opts.client.sessionId,
+        () => opts.client.getMetadata()
+      );
+    } catch (err) {
+      logger.debug("[Session] Failed to create notification producer:", err);
+      this.notificationProducer = null;
+    }
+    this.client.keepAlive(this.thinking, this.mode, this.backgroundTasks);
+    this.keepAliveInterval = setInterval(() => {
+      this.client.keepAlive(this.thinking, this.mode, this.backgroundTasks);
+    }, 2e3);
+  }
+  /**
+   * B-507: the tracker's current set (`claude/backgroundTasks.ts`). A change
+   * beats at once so the daemon, agentState and the web see the edge without
+   * waiting for the 2s tick; an unchanged set is left to the interval.
+   */
+  setBackgroundTasks = (tasks) => {
+    if (sameBackgroundTasks(this.backgroundTasks, tasks)) return;
+    this.backgroundTasks = tasks;
+    this.client.keepAlive(this.thinking, this.mode, this.backgroundTasks);
+  };
+  /**
+   * Cleanup resources (call when session is no longer needed)
+   */
+  cleanup = () => {
+    clearInterval(this.keepAliveInterval);
+    this.sessionFoundCallbacks = [];
+    this.steerHandler = null;
+    this.sideQuestionLive = null;
+    logger.debug("[Session] Cleaned up resources");
+  };
+  /** Register the current remote query's in-process side-question entry (B-482); null removes it. */
+  setSideQuestionLive = (live) => {
+    this.sideQuestionLive = live;
+  };
+  getSideQuestionLive = () => this.sideQuestionLive;
+  /** Register the current remote query's Steer sink; null removes it. */
+  setSteerHandler = (handler) => {
+    this.steerHandler = handler;
+  };
+  /**
+   * Attempt same-turn delivery. A stale Web "working" snapshot must never
+   * lose a message: once the turn is no longer thinking, return false and
+   * let runClaude fall back to the ordinary next-turn queue.
+   */
+  trySteer = async (input) => {
+    if (!this.thinking || !this.steerHandler) return false;
+    return this.steerHandler(input);
+  };
+  onThinkingChange = (thinking) => {
+    if (thinking && !this.thinking) {
+      this.hadAssistantOutputThisTurn = false;
+      this.lastAssistantSnippet = void 0;
+    }
+    this.thinking = thinking;
+    this.client.keepAlive(thinking, this.mode, this.backgroundTasks);
+  };
+  /**
+   * Record that Claude emitted an assistant text reply during this turn.
+   * Called from the message stream so turn-end can fire `reply_done` with a
+   * meaningful snippet.
+   */
+  noteAssistantOutput = (snippet) => {
+    this.hadAssistantOutputThisTurn = true;
+    if (snippet) {
+      this.lastAssistantSnippet = snippet;
+    }
+  };
+  /**
+   * A turn has ended (the agent yielded control back, e.g. SDK `result`).
+   * Produces the appropriate notification:
+   *   - `reply_done` when Claude produced output this turn,
+   *   - `input_needed` when the session is now idle awaiting user input
+   *     (not controlled by user, no pending permission requests, not thinking).
+   *
+   * `idle` is true when there are no pending/queued messages — the producer
+   * caller (launcher) knows this. The pending-requests / controlledByUser
+   * checks are made here against the latest agent state.
+   */
+  onTurnEnd = (idle) => {
+    if (idle) {
+      const state2 = this.client.getAgentState();
+      const hasPendingRequests2 = !!state2?.requests && Object.keys(state2.requests).length > 0;
+      if (!hasPendingRequests2 && state2?.controlledByUser !== true && !this.thinking) {
+        this.reportEventToDaemon("completed");
+      }
+    }
+    const producer = this.notificationProducer;
+    if (!producer) return;
+    if (this.hadAssistantOutputThisTurn) {
+      producer.replyDone(this.lastAssistantSnippet);
+      this.hadAssistantOutputThisTurn = false;
+      this.lastAssistantSnippet = void 0;
+      return;
+    }
+    if (!idle) {
+      return;
+    }
+    const state = this.client.getAgentState();
+    const hasPendingRequests = !!state?.requests && Object.keys(state.requests).length > 0;
+    const controlledByUser = state?.controlledByUser === true;
+    if (!hasPendingRequests && !controlledByUser && !this.thinking) {
+      producer.inputNeeded();
+    }
+  };
+  /**
+   * B-069: best-effort state-transition report to the local daemon
+   * (/session-event). Only assistant-dispatched sessions carry
+   * HAPPY_SPAWNED_BY, so ordinary sessions never POST. Fire-and-forget —
+   * a missing/old daemon must never disturb the session loop.
+   */
+  reportEventToDaemon = (event) => {
+    const spawnedBy = process.env.HAPPY_SPAWNED_BY;
+    if (!spawnedBy) return;
+    void notifyDaemonSessionEvent(this.client.sessionId, event, spawnedBy).catch((error) => logger.debug("[Session] Failed to report session event to daemon:", error));
+  };
+  /** Produce an `error` notification for an unexpected session failure. */
+  onSessionError = (message) => {
+    this.notificationProducer?.error(message);
+  };
+  onModeChange = (mode) => {
+    this.mode = mode;
+    this.client.keepAlive(this.thinking, mode, this.backgroundTasks);
+    this._onModeChange(mode);
+  };
+  onAbort = () => {
+    this._onAbort?.();
+  };
+  /**
+   * Called when Claude session ID is discovered or changed.
+   * 
+   * This is triggered by the SessionStart hook when:
+   * - Claude starts a new session (fresh start)
+   * - Claude resumes a session (--continue, --resume flags)
+   * - Claude forks a session (/compact, double-escape fork)
+   * 
+   * Updates internal state, syncs to API metadata, and notifies
+   * all registered callbacks (e.g., SessionScanner) about the change.
+   */
+  onSessionFound = (sessionId) => {
+    this.sessionId = sessionId;
+    this.client.updateMetadata((metadata) => ({
+      ...metadata,
+      claudeSessionId: sessionId
+    }));
+    logger.debug(`[Session] Claude Code session ID ${sessionId} added to metadata`);
+    for (const callback of this.sessionFoundCallbacks) {
+      callback(sessionId);
+    }
+  };
+  /**
+   * Register a callback to be notified when session ID is found/changed
+   */
+  addSessionFoundCallback = (callback) => {
+    this.sessionFoundCallbacks.push(callback);
+  };
+  /**
+   * Remove a session found callback
+   */
+  removeSessionFoundCallback = (callback) => {
+    const index = this.sessionFoundCallbacks.indexOf(callback);
+    if (index !== -1) {
+      this.sessionFoundCallbacks.splice(index, 1);
+    }
+  };
+  /**
+   * Clear the current session ID (used by /clear command)
+   */
+  clearSessionId = () => {
+    this.sessionId = null;
+    logger.debug("[Session] Session ID cleared");
+  };
+  /**
+   * Consume one-time Claude flags from claudeArgs after Claude spawn
+   * Handles: --resume (with or without session ID), --continue
+   */
+  consumeOneTimeFlags = () => {
+    if (!this.claudeArgs) return;
+    const filteredArgs = [];
+    for (let i = 0; i < this.claudeArgs.length; i++) {
+      const arg = this.claudeArgs[i];
+      if (arg === "--continue") {
+        logger.debug("[Session] Consumed --continue flag");
+        continue;
+      }
+      if (arg === "--resume") {
+        if (i + 1 < this.claudeArgs.length) {
+          const nextArg = this.claudeArgs[i + 1];
+          if (!nextArg.startsWith("-") && nextArg.includes("-")) {
+            i++;
+            logger.debug(`[Session] Consumed --resume flag with session ID: ${nextArg}`);
+          } else {
+            logger.debug("[Session] Consumed --resume flag (no session ID)");
+          }
+        } else {
+          logger.debug("[Session] Consumed --resume flag (no session ID)");
+        }
+        continue;
+      }
+      filteredArgs.push(arg);
+    }
+    this.claudeArgs = filteredArgs.length > 0 ? filteredArgs : void 0;
+    logger.debug(`[Session] Consumed one-time flags, remaining args:`, this.claudeArgs);
+  };
+}
+
+const text = (value) => typeof value === "string" && value.length > 0 && value.length <= 1024 && !value.includes("\0") ? value : null;
+const publicMcpStatus = (servers) => servers.map(({ name, status, serverInfo, scope, tools }) => ({ name, status, serverInfo, scope, tools: tools?.map(({ name: name2 }) => ({ name: name2 })) }));
+const fingerprint = (result) => JSON.stringify([result.canRewind, [...result.filesChanged ?? []].sort(), result.insertions, result.deletions]);
+function isRuntimeCheckpointReplay(message) {
+  const m = message;
+  return m.type === "user" && m.isReplay === true && !m.parent_tool_use_id && !(Array.isArray(m.message?.content) && m.message.content.some((block) => block.type === "tool_result"));
+}
+function createRuntimeControls(isThinking) {
+  let query = null, generation = randomInt(0, 2 ** 40), activityRevision = 0;
+  const operations = /* @__PURE__ */ new Map();
+  const confirmations = /* @__PURE__ */ new Map();
+  const tasks = /* @__PURE__ */ new Map();
+  const checkpoints = /* @__PURE__ */ new Map();
+  let pending = false;
+  const setQuery = (next) => {
+    for (const operation of operations.values()) if (operation.status === "running") {
+      operation.status = "failed";
+      operation.error = "Claude query ended before this operation completed";
+    }
+    query = next;
+    generation++;
+    pending = false;
+    confirmations.clear();
+    tasks.clear();
+    checkpoints.clear();
+  };
+  function observe(message) {
+    const m = message;
+    if (m.type === "user" || m.type === "assistant") {
+      activityRevision++;
+      confirmations.clear();
+    }
+    const content = typeof m.message?.content === "string" ? m.message.content : Array.isArray(m.message?.content) ? m.message.content.filter((block) => block.type === "text").map((block) => block.text).join(" ") : "";
+    if (isRuntimeCheckpointReplay(message) && text(m.uuid) && content) {
+      checkpoints.set(m.uuid, { id: m.uuid, title: content.slice(0, 120) });
+      if (checkpoints.size > 100) checkpoints.delete(checkpoints.keys().next().value);
+    }
+    if (m.type === "system" && text(m.task_id) && ["task_started", "task_updated", "task_progress", "task_notification"].includes(m.subtype)) {
+      const previous = tasks.get(m.task_id);
+      if (m.subtype !== "task_notification" && ["completed", "failed", "stopped", "cancelled"].includes(String(previous?.status))) return;
+      tasks.set(m.task_id, {
+        ...previous,
+        id: m.task_id,
+        ...text(m.tool_use_id) ? { toolUseId: m.tool_use_id } : {},
+        ...text(m.description) ? { description: m.description } : {},
+        ...text(m.task_type) ? { type: m.task_type } : {},
+        status: m.subtype === "task_notification" ? m.status ?? "completed" : "running"
+      });
+      if (tasks.size > 100) tasks.delete(tasks.keys().next().value);
+    }
+  }
+  function request(input) {
+    const r = input && typeof input === "object" ? input : {};
+    if (r.action === "status") return { queryGeneration: generation, active: !!query, isRunning: isThinking(), canRewind: !!query && !isThinking() && !pending && query.canControl(), busy: pending || !!query && !query.canControl(), tasks: [...tasks.values()], checkpoints: [...checkpoints.values()], operations: [...operations.values()].filter((op2) => op2.queryGeneration === generation) };
+    if (r.action === "operation") {
+      const op2 = operations.get(String(r.operationId));
+      return op2 ? { ...op2 } : { error: "Operation not found" };
+    }
+    const q = query;
+    if (!q) return { error: "No active Claude SDK query" };
+    if (pending || !q.canControl()) return { error: "Claude is waiting for an interaction or another control operation; retry after it finishes" };
+    const action = String(r.action), server = text(r.serverName), task = text(r.taskId), target = text(r.userMessageId);
+    const runGeneration = generation, runRevision = activityRevision;
+    let execute;
+    switch (action) {
+      case "reload-skills":
+        execute = () => q.reloadSkills();
+        break;
+      case "reload-plugins":
+        execute = async () => {
+          const result = await q.reloadPlugins();
+          return { ...result, mcpServers: publicMcpStatus(result.mcpServers ?? []) };
+        };
+        break;
+      case "mcp-status":
+        execute = async () => publicMcpStatus(await q.mcpServerStatus());
+        break;
+      case "mcp-reconnect":
+        if (!server) return { error: "Invalid server name" };
+        execute = () => q.reconnectMcpServer(server);
+        break;
+      case "mcp-toggle":
+        if (!server || typeof r.enabled !== "boolean") return { error: "Invalid server or enabled flag" };
+        execute = () => q.toggleMcpServer(server, r.enabled);
+        break;
+      case "stop-task":
+        if (!task || !tasks.has(task)) return { error: "Unknown task in this query" };
+        execute = () => q.stopTask(task);
+        break;
+      case "background-tasks":
+        if (r.toolUseId !== void 0 && !text(r.toolUseId)) return { error: "Invalid tool use ID" };
+        execute = async () => ({ backgrounded: await q.backgroundTasks(r.toolUseId) });
+        break;
+      case "rewind-preview":
+        if (isThinking() || !target || !checkpoints.has(target)) return { error: "Rewind requires an idle query and a known user checkpoint" };
+        execute = async () => {
+          const result = await q.rewindFiles(target, { dryRun: true });
+          if (!result.canRewind) return result;
+          if (query !== q || generation !== runGeneration || activityRevision !== runRevision || isThinking() || !q.canControl()) throw Error("Query changed; preview again");
+          const token = randomUUID();
+          confirmations.set(token, { generation, revision: activityRevision, userMessageId: target, fingerprint: fingerprint(result), expires: Date.now() + 3e5 });
+          return { ...result, confirmationToken: token };
+        };
+        break;
+      case "rewind-apply": {
+        const confirmation = confirmations.get(String(r.confirmationToken));
+        if (isThinking() || !confirmation || confirmation.generation !== generation || confirmation.expires < Date.now()) return { error: "Preview expired or query is running; preview again" };
+        confirmations.delete(String(r.confirmationToken));
+        execute = async () => {
+          const fresh = await q.rewindFiles(confirmation.userMessageId, { dryRun: true });
+          if (query !== q || generation !== runGeneration || activityRevision !== confirmation.revision || isThinking() || !q.canControl() || fingerprint(fresh) !== confirmation.fingerprint) throw Error("Files or query changed; preview again");
+          return q.rewindFiles(confirmation.userMessageId, { dryRun: false });
+        };
+        break;
+      }
+      default:
+        return { error: "Unknown Claude control action" };
+    }
+    pending = true;
+    const op = { id: randomUUID(), queryGeneration: runGeneration, action, status: "running" };
+    operations.set(op.id, op);
+    if (operations.size > 50) for (const [id, old] of operations) {
+      if (old.status !== "running") {
+        operations.delete(id);
+        break;
+      }
+    }
+    void Promise.resolve().then(() => {
+      if (query !== q || generation !== runGeneration || !q.canControl()) throw Error("Claude query changed or is waiting for an interaction");
+      return execute();
+    }).then((result) => {
+      if (generation !== runGeneration || op.status !== "running") return;
+      op.status = "completed";
+      op.result = result ?? null;
+    }, (error) => {
+      if (generation !== runGeneration || op.status !== "running") return;
+      op.status = "failed";
+      op.error = error instanceof Error ? error.message : "Claude control failed";
+    }).finally(() => {
+      if (generation === runGeneration) pending = false;
+    });
+    return { operationId: op.id };
+  }
+  async function stopRunningTasks() {
+    const q = query, runGeneration = generation;
+    if (!q || !q.canControl()) return [];
+    const running = [...tasks.values()].filter((task) => task.status === "running" && text(task.id)).map((task) => String(task.id)).slice(0, 20);
+    const stopped = [];
+    await Promise.all(running.map(async (id) => {
+      try {
+        await q.stopTask(id);
+        if (query === q && generation === runGeneration) stopped.push(id);
+      } catch {
+      }
+    }));
+    return stopped;
+  }
+  return { setQuery, observe, request, stopRunningTasks };
+}
+
+const AUTH_FAILURE_RESULT_TEXT = /Failed to authenticate|OAuth session expired/i;
+const QUERY_RECYCLE_NOTICE = {
+  authentication_failed: "\u26A0\uFE0F Claude Code could not refresh its OAuth session. This agent process was ended so your next message starts a fresh one that re-reads the credentials on this machine; if it fails again, run `claude` on the machine to log in again."
+};
+function queryRecycleReason(result, lastAssistantError) {
+  if (lastAssistantError === "authentication_failed") {
+    return "authentication_failed";
+  }
+  if (result.is_error && typeof result.result === "string" && AUTH_FAILURE_RESULT_TEXT.test(result.result)) {
+    return "authentication_failed";
+  }
+  return null;
+}
+
+class PushableAsyncIterable {
+  queue = [];
+  waiters = [];
+  isDone = false;
+  error = null;
+  started = false;
+  constructor() {
+  }
+  /**
+   * Push a value to the iterable
+   */
+  push(value) {
+    if (this.isDone) {
+      throw new Error("Cannot push to completed iterable");
+    }
+    if (this.error) {
+      throw this.error;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  /**
+   * Mark the iterable as complete
+   */
+  end() {
+    if (this.isDone) {
+      return;
+    }
+    this.isDone = true;
+    this.cleanup();
+  }
+  /**
+   * Set an error on the iterable
+   */
+  setError(err) {
+    if (this.isDone) {
+      return;
+    }
+    this.error = err;
+    this.isDone = true;
+    this.cleanup();
+  }
+  /**
+   * Cleanup waiting consumers
+   */
+  cleanup() {
+    while (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      if (this.error) {
+        waiter.reject(this.error);
+      } else {
+        waiter.resolve({ done: true, value: void 0 });
+      }
+    }
+  }
+  /**
+   * AsyncIterableIterator implementation
+   */
+  async next() {
+    if (this.queue.length > 0) {
+      return { done: false, value: this.queue.shift() };
+    }
+    if (this.isDone) {
+      if (this.error) {
+        throw this.error;
+      }
+      return { done: true, value: void 0 };
+    }
+    return new Promise((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+  /**
+   * AsyncIterableIterator return implementation
+   */
+  async return(_value) {
+    this.end();
+    return { done: true, value: void 0 };
+  }
+  /**
+   * AsyncIterableIterator throw implementation
+   */
+  async throw(e) {
+    this.setError(e instanceof Error ? e : new Error(String(e)));
+    throw this.error;
+  }
+  /**
+   * Make this iterable
+   */
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error("PushableAsyncIterable can only be iterated once");
+    }
+    this.started = true;
+    return this;
+  }
+  /**
+   * Check if the iterable is done
+   */
+  get done() {
+    return this.isDone;
+  }
+  /**
+   * Check if the iterable has an error
+   */
+  get hasError() {
+    return this.error !== null;
+  }
+  /**
+   * Get the current queue size
+   */
+  get queueSize() {
+    return this.queue.length;
+  }
+  /**
+   * Get the number of waiting consumers
+   */
+  get waiterCount() {
+    return this.waiters.length;
+  }
+}
+
+async function awaitFileExist(file, timeout = 1e4) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    try {
+      await access(file);
+      return true;
+    } catch (e) {
+      await delay(1e3);
+    }
+  }
+  return false;
+}
+
+function modelTarget(model) {
+  return model == null || model === "" ? void 0 : model;
+}
+function needsModelSwitch(current, next) {
+  return modelTarget(current) !== modelTarget(next);
+}
+function modelSwitchFailureNotice(model, error) {
+  const name = modelTarget(model) ?? "default";
+  const detail = error instanceof Error ? error.message : String(error);
+  return `\u26A0\uFE0F Could not switch to model "${name}" \u2014 continuing with the previous model. ${detail}`;
+}
+
+async function claudeRemote(opts) {
+  let startFrom = opts.sessionId;
+  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
+    startFrom = null;
+  }
+  if (!startFrom && opts.claudeArgs) {
+    for (let i = 0; i < opts.claudeArgs.length; i++) {
+      if (opts.claudeArgs[i] === "--resume") {
+        if (i + 1 < opts.claudeArgs.length) {
+          const nextArg = opts.claudeArgs[i + 1];
+          if (!nextArg.startsWith("-") && nextArg.includes("-")) {
+            startFrom = nextArg;
+            logger.debug(`[claudeRemote] Found --resume with session ID: ${startFrom}`);
+            break;
+          } else {
+            logger.debug("[claudeRemote] Found --resume without session ID - not supported in remote mode");
+            break;
+          }
+        } else {
+          logger.debug("[claudeRemote] Found --resume without session ID - not supported in remote mode");
+          break;
+        }
+      }
+    }
+  }
+  if (opts.claudeEnvVars) {
+    Object.entries(opts.claudeEnvVars).forEach(([key, value]) => {
+      process.env[key] = value;
+    });
+  }
+  const initial = await opts.nextMessage();
+  if (!initial) {
+    return;
+  }
+  const initialText = typeof initial.message === "string" ? initial.message : initial.message.find((b) => b.type === "text")?.text ?? "";
+  const specialCommand = parseSpecialCommand(initialText);
+  if (specialCommand.type === "clear") {
+    if (opts.onCompletionEvent) {
+      opts.onCompletionEvent("Context was reset");
+    }
+    if (opts.onSessionReset) {
+      opts.onSessionReset();
+    }
+    opts.onReady();
+    return;
+  }
+  let isCompactCommand = false;
+  if (specialCommand.type === "compact") {
+    logger.debug("[claudeRemote] /compact command detected - will process as normal but with compaction behavior");
+    isCompactCommand = true;
+    if (opts.onCompletionEvent) {
+      opts.onCompletionEvent("Compaction started");
+    }
+  }
+  let mode = initial.mode;
+  const sdkOptions = {
+    cwd: opts.path,
+    resume: startFrom ?? void 0,
+    mcpServers: opts.mcpServers,
+    permissionMode: mapToClaudeMode(initial.mode.permissionMode),
+    // This is only the SDK safety opt-in; permissionMode/canUseTool still
+    // enforce the selected policy. It must be enabled at Query creation so
+    // a later explicit live switch to bypassPermissions can succeed.
+    allowDangerouslySkipPermissions: true,
+    model: initial.mode.model,
+    fallbackModel: initial.mode.fallbackModel,
+    customSystemPrompt: initial.mode.customSystemPrompt ? initial.mode.customSystemPrompt + "\n\n" + systemPrompt : void 0,
+    appendSystemPrompt: initial.mode.appendSystemPrompt ? initial.mode.appendSystemPrompt + "\n\n" + systemPrompt : systemPrompt,
+    allowedTools: initial.mode.allowedTools ? initial.mode.allowedTools.concat(opts.allowedTools) : opts.allowedTools,
+    additionalDirectories: opts.additionalDirectories,
+    disallowedTools: initial.mode.disallowedTools,
+    effort: initial.mode.effort,
+    canCallTool: (toolName, input, options) => opts.canCallTool(toolName, input, mode, options),
+    onElicitation: opts.onElicitation,
+    onUserDialog: opts.onUserDialog,
+    supportedDialogKinds: opts.onUserDialog ? ["refusal_fallback_prompt"] : void 0,
+    abort: opts.signal,
+    settingsPath: opts.hookSettingsPath,
+    // B-309: token-level partials. Without this the SDK emits nothing
+    // between "turn started" and "entire assistant message", which is
+    // exactly why the web used to show a spinner where the terminal shows
+    // the model thinking out loud. The partials do NOT enter the
+    // transcript; they are split off below and relayed on a side channel.
+    // Only pay for them when someone is listening.
+    includePartialMessages: opts.onStreamFrame ? true : void 0
+  };
+  let thinking = false;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      logger.debug(`[claudeRemote] Thinking state changed to: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
+    }
+  };
+  let messages = new PushableAsyncIterable();
+  messages.push({
+    type: "user",
+    parent_tool_use_id: null,
+    origin: { kind: "human" },
+    message: {
+      role: "user",
+      content: initial.message
+    }
+  });
+  let callbackDepth = 0;
+  const guardCallback = (callback) => (async (...args) => {
+    callbackDepth++;
+    try {
+      return await callback(...args);
+    } finally {
+      setImmediate(() => {
+        callbackDepth--;
+      });
+    }
+  });
+  if (sdkOptions.canCallTool) sdkOptions.canCallTool = guardCallback(sdkOptions.canCallTool);
+  if (sdkOptions.onElicitation) sdkOptions.onElicitation = guardCallback(sdkOptions.onElicitation);
+  if (sdkOptions.onUserDialog) sdkOptions.onUserDialog = guardCallback(sdkOptions.onUserDialog);
+  const response = query({
+    prompt: messages,
+    options: sdkOptions
+  });
+  let models;
+  if (typeof response.supportedModels === "function") {
+    try {
+      models = (await response.supportedModels()).map((model) => ({
+        code: model.value,
+        value: model.displayName,
+        description: model.description,
+        resolvedModel: model.resolvedModel,
+        ...model.supportsEffort === false ? { reasoningEfforts: [] } : model.supportedEffortLevels ? { reasoningEfforts: model.supportedEffortLevels } : {}
+      }));
+    } catch (error) {
+      logger.debug("[claudeRemote] Model capability discovery unavailable");
+    }
+  }
+  if (opts.onQueryReady) {
+    opts.onQueryReady({
+      canControl: () => callbackDepth === 0,
+      reloadSkills: () => response.reloadSkills(),
+      reloadPlugins: () => response.reloadPlugins(),
+      mcpServerStatus: () => response.mcpServerStatus(),
+      reconnectMcpServer: (name) => response.reconnectMcpServer(name),
+      toggleMcpServer: (name, enabled) => response.toggleMcpServer(name, enabled),
+      stopTask: (id) => response.stopTask(id),
+      backgroundTasks: (id) => response.backgroundTasks(id),
+      rewindFiles: (id, options) => response.rewindFiles(id, options),
+      setPermissionMode: (mode2) => response.setPermissionMode(mode2),
+      setModel: (model) => response.setModel(modelTarget(model)),
+      interrupt: async () => {
+        await response.interrupt();
+      },
+      // `request` is the SDK's generic control-request sender (every typed
+      // method wraps it); the public types omit `side_question`, the CLI
+      // handles it. An abort on `signal` becomes control_cancel_request.
+      sideQuestion: async (request, signal) => {
+        const raw = await response.request({ subtype: "side_question", ...request }, { signal });
+        const body = raw?.response;
+        return body && typeof body === "object" ? body : { response: null };
+      },
+      steer: (message, nextMode) => {
+        mode = { ...nextMode, model: mode.model };
+        messages.push({
+          type: "user",
+          parent_tool_use_id: null,
+          priority: "now",
+          origin: { kind: "human" },
+          message: { role: "user", content: message }
+        });
+      }
+    });
+  }
+  let lastAssistantError;
+  updateThinking(true);
+  try {
+    logger.debug(`[claudeRemote] Starting to iterate over response`);
+    for await (const message of response) {
+      if (message.type === "stream_event") {
+        if (opts.onStreamFrame && !message.parent_tool_use_id) {
+          opts.onStreamFrame({ type: "stream_event", event: message.event });
+        }
+        continue;
+      }
+      logger.debug(`[claudeRemote] Message ${message.type}`, contentLogMetadata(message));
+      if (message.type === "assistant" && message.error) {
+        lastAssistantError = message.error;
+      }
+      if (opts.onStreamFrame && message.type === "system") {
+        const subtype = message.subtype;
+        if (subtype === "thinking_tokens") {
+          const tokens = message;
+          opts.onStreamFrame({ type: "system", subtype: "thinking_tokens", estimated_tokens: tokens.estimated_tokens });
+        } else if (subtype === "status") {
+          const status = message;
+          opts.onStreamFrame({ type: "system", subtype: "status", status: status.status });
+        }
+      }
+      const outboundMessage = isCompactCommand && message.type === "assistant" ? { ...message, isCompactSummary: true } : message;
+      opts.onMessage(outboundMessage);
+      if (message.type === "system" && message.subtype === "init") {
+        updateThinking(true);
+        const systemInit = message;
+        if (opts.onSDKMetadata) {
+          opts.onSDKMetadata({
+            models,
+            tools: systemInit.tools,
+            slashCommands: systemInit.slash_commands,
+            mcpServers: systemInit.mcp_servers?.map((s) => ({ name: s.name, status: s.status })),
+            skills: systemInit.skills,
+            model: systemInit.model,
+            // `mode`, not `initial.mode`: the model can move mid-Query
+            // via setModel, and init is re-emitted every turn with the
+            // model actually in force.
+            modelIsDefault: modelTarget(mode.model) === void 0,
+            // The SDK's own verdict on the mode it will enforce —
+            // settings (permissions.deny/ask/defaultMode/
+            // disableBypassPermissionsMode) can override what we
+            // asked for. runClaude publishes THIS, not our intent.
+            permissionMode: systemInit.permissionMode
+          });
+        }
+        if (systemInit.session_id) {
+          logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${systemInit.session_id}`);
+          const projectDir = getProjectPath(opts.path);
+          const found = await awaitFileExist(join(projectDir, `${systemInit.session_id}.jsonl`), 3e4);
+          logger.debug(`[claudeRemote] Session file found: ${systemInit.session_id} ${found}`);
+          if (!found) {
+            logger.debug(`[claudeRemote] WARNING: session transcript ${systemInit.session_id} never appeared after 30s`);
+            opts.onCompletionEvent?.("\u26A0\uFE0F Claude session did not produce a transcript \u2014 the agent may be unresponsive. Try sending your message again.");
+          }
+          opts.onSessionFound(systemInit.session_id);
+        }
+      }
+      if (message.type === "result") {
+        updateThinking(false);
+        logger.debug("[claudeRemote] Result received");
+        const denials = message.permission_denials;
+        if (denials && denials.length > 0) {
+          logger.warn(`[claudeRemote] ${denials.length} tool call(s) auto-denied by Claude Code policy: ${denials.map((d) => d.tool_name ?? "?").join(", ")}`);
+        }
+        if (isCompactCommand) {
+          const compactSucceeded = message.subtype === "success";
+          logger.debug(`[claudeRemote] Compaction ${compactSucceeded ? "completed" : "failed"}`);
+          if (opts.onCompletionEvent) {
+            opts.onCompletionEvent(message.subtype === "success" ? "Compaction completed" : `Compaction failed: ${message.errors?.join("\n") || message.subtype}`);
+          }
+          isCompactCommand = false;
+        }
+        opts.onReady(message);
+        const recycleReason = queryRecycleReason(message, lastAssistantError);
+        lastAssistantError = void 0;
+        if (recycleReason) {
+          logger.warn(`[claudeRemote] Ending SDK query after ${recycleReason}; the next message starts a fresh Claude Code process`);
+          opts.onCompletionEvent?.(QUERY_RECYCLE_NOTICE[recycleReason]);
+          opts.onAuthFailure?.(recycleReason);
+          messages.end();
+          continue;
+        }
+        opts.nextMessage().then(async (next) => {
+          if (!next) {
+            messages.end();
+            return;
+          }
+          if (needsModelSwitch(mode.model, next.mode.model)) {
+            try {
+              await response.setModel(modelTarget(next.mode.model));
+              logger.debug(`[claudeRemote] Model switched to ${modelTarget(next.mode.model) ?? "default"}`);
+            } catch (e) {
+              logger.debug(`[claudeRemote] setModel failed: ${e instanceof Error ? e.message : String(e)}`);
+              opts.onCompletionEvent?.(modelSwitchFailureNotice(next.mode.model, e));
+              next = { ...next, mode: { ...next.mode, model: mode.model } };
+            }
+          }
+          mode = next.mode;
+          updateThinking(true);
+          messages.push({
+            type: "user",
+            parent_tool_use_id: null,
+            origin: { kind: "human" },
+            message: { role: "user", content: next.message }
+          });
+        }).catch(() => {
+          messages.end();
+        });
+      }
+      if (message.type === "user") {
+        const msg = message;
+        if (msg.message.role === "user" && Array.isArray(msg.message.content)) {
+          for (let c of msg.message.content) {
+            if (c.type === "tool_result" && c.tool_use_id && opts.isAborted(c.tool_use_id)) {
+              logger.debug("[claudeRemote] Tool aborted, exiting claudeRemote");
+              return;
+            }
+          }
+        }
+      }
+    }
+  } catch (e) {
+    if (e instanceof AbortError) {
+      logger.debug(`[claudeRemote] Aborted`);
+    } else {
+      throw e;
+    }
+  } finally {
+    updateThinking(false);
+  }
+}
+
+function getToolDescriptor(toolName) {
+  if (toolName === "exit_plan_mode" || toolName === "ExitPlanMode") {
+    return { edit: false, exitPlan: true, dangerous: false };
+  }
+  if (toolName === "Edit" || toolName === "MultiEdit" || toolName === "Write" || toolName === "NotebookEdit") {
+    return { edit: true, exitPlan: false, dangerous: true };
+  }
+  if (toolName === "Bash") {
+    return { edit: false, exitPlan: false, dangerous: true };
+  }
+  return { edit: false, exitPlan: false, dangerous: false };
+}
+
+function elicitationContent(input) {
+  if (!input) return void 0;
+  const content = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === "string" || typeof value === "number" && Number.isFinite(value) || typeof value === "boolean" || Array.isArray(value) && value.every((item) => typeof item === "string")) {
+      content[key] = value;
+    }
+  }
+  return content;
+}
+class PermissionHandler {
+  responses = /* @__PURE__ */ new Map();
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  allowedTools = /* @__PURE__ */ new Set();
+  allowedBashLiterals = /* @__PURE__ */ new Set();
+  allowedBashPrefixes = /* @__PURE__ */ new Set();
+  permissionMode = "default";
+  onPermissionRequestCallback;
+  /** Callback to change permission mode on the active query (set by claudeRemote) */
+  setPermissionModeCallback;
+  modeChangeQueue = Promise.resolve();
+  deferredPermissionMode;
+  /** Fired when an approval response (plan approval / approve-with-mode) moved the mode. */
+  onModeChangedCallback;
+  constructor(session) {
+    this.session = session;
+    this.setupClientHandler();
+  }
+  /**
+   * Set callback to trigger when permission request is made
+   */
+  setOnPermissionRequest(callback) {
+    this.onPermissionRequestCallback = callback;
+  }
+  handleModeChange(mode) {
+    this.permissionMode = mapToClaudeMode(mode);
+  }
+  /** Current locally enforced mode (what canUseTool applies right now). */
+  getPermissionMode() {
+    return this.permissionMode;
+  }
+  /**
+   * Observe mode transitions that originate inside the approval flow
+   * (ExitPlanMode approval, approve-with-mode). Live/idle RPC changes and
+   * queue-driven changes are owned by the launcher and do not fire this.
+   */
+  setOnModeChanged(callback) {
+    this.onModeChangedCallback = callback;
+  }
+  /**
+   * Set callback to dynamically change permission mode on the active query.
+   * Called by claudeRemote after the Query object is created.
+   */
+  setPermissionModeUpdater(callback) {
+    this.setPermissionModeCallback = callback;
+  }
+  /**
+   * Apply a user-requested mode to the active SDK Query. Mode changes are
+   * serialized so rapid menu selections cannot finish out of order.
+   *
+   * A live Query can be blocked inside canUseTool. When the requested mode
+   * would have auto-allowed that ordinary tool, finish the callback first;
+   * interactive prompts and ExitPlanMode deliberately remain pending.
+   */
+  setLivePermissionMode(mode) {
+    const task = this.modeChangeQueue.then(() => this.applyLivePermissionMode(mode));
+    this.modeChangeQueue = task.catch(() => void 0);
+    return task;
+  }
+  async applyLivePermissionMode(mode) {
+    if (!this.setPermissionModeCallback) {
+      throw new Error("active Claude query is not ready");
+    }
+    const previousMode = this.permissionMode;
+    this.permissionMode = mode;
+    this.deferredPermissionMode = void 0;
+    try {
+      const autoApproved = [...this.pendingRequests.entries()].filter(([, pending]) => pending.kind === "tool" && this.modeAutoAllowsTool(mode, pending.toolName));
+      for (const [id, pending] of autoApproved) {
+        if (pending.kind !== "tool" || !this.pendingRequests.delete(id)) continue;
+        const response = {
+          id,
+          approved: true,
+          decision: "approved",
+          reason: `Approved by live permission mode ${mode}`
+        };
+        const effectiveResponse = await this.handlePermissionResponse(response, pending);
+        this.responses.set(id, { ...effectiveResponse, receivedAt: Date.now() });
+        this.recordCompletedRequest(id, effectiveResponse);
+      }
+      if (this.pendingRequests.size > 0) {
+        this.deferredPermissionMode = mode;
+        return;
+      }
+      await new Promise((resolve) => setImmediate(resolve));
+      await this.setPermissionModeCallback(mode);
+    } catch (error) {
+      this.permissionMode = previousMode;
+      if (this.deferredPermissionMode === mode) this.deferredPermissionMode = void 0;
+      throw error;
+    }
+  }
+  scheduleDeferredPermissionModeUpdate() {
+    const mode = this.deferredPermissionMode;
+    if (!mode || this.pendingRequests.size > 0) return;
+    this.deferredPermissionMode = void 0;
+    setImmediate(() => {
+      const task = this.modeChangeQueue.then(async () => {
+        if (!this.setPermissionModeCallback || this.permissionMode !== mode) return;
+        await this.setPermissionModeCallback(mode);
+      });
+      this.modeChangeQueue = task.catch((error) => {
+        logger.debug("[PermissionHandler] Deferred SDK permission mode update failed", error);
+      });
+    });
+  }
+  modeAutoAllowsTool(mode, toolName) {
+    if (toolName === "AskUserQuestion") return false;
+    const descriptor = getToolDescriptor(toolName);
+    if (descriptor.exitPlan) return false;
+    if (mode === "bypassPermissions") return true;
+    if (mode === "acceptEdits") return descriptor.edit;
+    return mode === "plan" && !descriptor.dangerous;
+  }
+  /**
+   * Handler response
+   */
+  async handlePermissionResponse(response, pending) {
+    if (pending.toolName === "exit_plan_mode" || pending.toolName === "ExitPlanMode") {
+      logger.debug("Plan mode result received", {
+        approved: response.approved,
+        mode: response.mode,
+        reason: contentLogMetadata(response.reason),
+        allowToolCount: response.allowTools?.length ?? 0,
+        updatedInput: contentLogMetadata(response.updatedInput)
+      });
+      if (response.approved) {
+        const newMode = response.mode && ["default", "acceptEdits", "bypassPermissions"].includes(response.mode) ? response.mode : "bypassPermissions";
+        logger.debug(`Plan approved - allowing ExitPlanMode with ${newMode} as the local follow-up mode`);
+        this.permissionMode = newMode;
+        this.onModeChangedCallback?.(newMode);
+        pending.resolve({ behavior: "allow", updatedInput: pending.input || {} });
+      } else {
+        pending.resolve({ behavior: "deny", message: response.reason || "Plan rejected" });
+      }
+    } else {
+      if (response.approved && response.mode) {
+        this.permissionMode = response.mode;
+        this.deferredPermissionMode = response.mode;
+        this.onModeChangedCallback?.(response.mode);
+      }
+      if (response.approved && !pending.suggestions?.length && response.allowTools?.length) {
+        response.allowTools.forEach((tool) => {
+          if (tool.startsWith("Bash(") || tool === "Bash") {
+            this.parseBashPermission(tool);
+          } else {
+            this.allowedTools.add(tool);
+          }
+        });
+      }
+      const originalInput = pending.input || {};
+      const updatedInput = response.updatedInput ? { ...originalInput, ...response.updatedInput } : originalInput;
+      const result = response.approved ? {
+        behavior: "allow",
+        updatedInput,
+        ...response.decision === "approved_for_session" && pending.suggestions?.length ? { updatedPermissions: pending.suggestions } : {}
+      } : { behavior: "deny", message: response.reason || `The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.` };
+      pending.resolve(result);
+    }
+    return response;
+  }
+  /**
+   * Creates the canCallTool callback for the SDK.
+   * Uses toolUseID from official SDK callback options directly.
+   */
+  handleToolCall = async (toolName, input, mode, options) => {
+    const toolCallId = options.toolUseID;
+    if (toolName === "AskUserQuestion") {
+      return this.handlePermissionRequest(toolCallId, toolName, input, options.signal, options.suggestions);
+    }
+    if (toolName === "Bash") {
+      const inputObj = input;
+      if (inputObj?.command) {
+        if (this.allowedBashLiterals.has(inputObj.command)) {
+          return { behavior: "allow", updatedInput: input };
+        }
+        for (const prefix of this.allowedBashPrefixes) {
+          if (inputObj.command.startsWith(prefix)) {
+            return { behavior: "allow", updatedInput: input };
+          }
+        }
+      }
+    } else if (this.allowedTools.has(toolName)) {
+      return { behavior: "allow", updatedInput: input };
+    }
+    const descriptor = getToolDescriptor(toolName);
+    if (descriptor.exitPlan) {
+      return this.handlePermissionRequest(toolCallId, toolName, input, options.signal, options.suggestions);
+    }
+    if (this.permissionMode === "bypassPermissions") {
+      return { behavior: "allow", updatedInput: input };
+    }
+    if (this.permissionMode === "acceptEdits" && descriptor.edit) {
+      return { behavior: "allow", updatedInput: input };
+    }
+    if (this.permissionMode === "plan" && !descriptor.dangerous) {
+      return { behavior: "allow", updatedInput: input };
+    }
+    return this.handlePermissionRequest(toolCallId, toolName, input, options.signal, options.suggestions);
+  };
+  /**
+   * Handles individual permission requests
+   */
+  async handlePermissionRequest(id, toolName, input, signal, suggestions) {
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new Error("Permission request aborted", { cause: signal.reason }));
+        return;
+      }
+      const abortHandler = () => {
+        this.pendingRequests.delete(id);
+        this.cancelRequestInAgentState(id, "Permission request aborted");
+        reject(new Error("Permission request aborted"));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      this.pendingRequests.set(id, {
+        kind: "tool",
+        resolve: (result) => {
+          signal.removeEventListener("abort", abortHandler);
+          resolve(result);
+        },
+        reject: (error) => {
+          signal.removeEventListener("abort", abortHandler);
+          reject(error);
+        },
+        toolName,
+        input,
+        suggestions
+      });
+      if (this.onPermissionRequestCallback) {
+        this.onPermissionRequestCallback(id);
+      }
+      this.session.api.push().sendSessionNotification({
+        kind: "permission",
+        metadata: this.session.client.getMetadata(),
+        data: {
+          sessionId: this.session.client.sessionId,
+          requestId: id,
+          tool: toolName,
+          type: "permission_request",
+          provider: "claude"
+        }
+      });
+      this.session.client.updateAgentState((currentState) => ({
+        ...currentState,
+        requests: {
+          ...currentState.requests,
+          [id]: {
+            tool: toolName,
+            arguments: input,
+            createdAt: Date.now(),
+            kind: "tool",
+            ...suggestions?.length ? { permissionSuggestions: suggestions } : {}
+          }
+        }
+      }));
+      this.session.notificationProducer?.permissionRequest(toolName);
+      this.session.reportEventToDaemon("needs_input");
+      logger.debug(`Permission request sent for tool call ${id}: ${toolName}`);
+    });
+  }
+  handleElicitation = async (request, options) => {
+    return this.handleInteractionRequest(options.requestId, "elicitation", request, options.signal);
+  };
+  handleUserDialog = async (request, options) => {
+    if (request.dialogKind !== "refusal_fallback_prompt") {
+      return { behavior: "cancelled" };
+    }
+    return this.handleInteractionRequest(options.requestId, "user_dialog", request, options.signal);
+  };
+  handleInteractionRequest(id, kind, request, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new Error("Interaction request aborted", { cause: signal.reason }));
+        return;
+      }
+      const abortHandler = () => {
+        this.pendingRequests.delete(id);
+        this.cancelRequestInAgentState(id, "Interaction request aborted");
+        reject(new Error("Interaction request aborted", { cause: signal.reason }));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      const finishResolve = (value) => {
+        signal.removeEventListener("abort", abortHandler);
+        resolve(value);
+      };
+      const finishReject = (error) => {
+        signal.removeEventListener("abort", abortHandler);
+        reject(error);
+      };
+      if (kind === "elicitation") {
+        this.pendingRequests.set(id, {
+          kind,
+          request,
+          resolve: finishResolve,
+          reject: finishReject
+        });
+      } else {
+        this.pendingRequests.set(id, {
+          kind,
+          request,
+          resolve: finishResolve,
+          reject: finishReject
+        });
+      }
+      const tool = "AskUserQuestion";
+      this.publishRequest(id, tool, request, kind);
+    });
+  }
+  publishRequest(id, tool, args, kind) {
+    this.session.api.push().sendSessionNotification({
+      kind: "permission",
+      metadata: this.session.client.getMetadata(),
+      data: {
+        sessionId: this.session.client.sessionId,
+        requestId: id,
+        tool,
+        type: "permission_request",
+        provider: "claude"
+      }
+    });
+    this.session.client.updateAgentState((currentState) => ({
+      ...currentState,
+      requests: {
+        ...currentState.requests,
+        [id]: { tool, arguments: args, createdAt: Date.now(), kind }
+      }
+    }));
+    this.session.notificationProducer?.permissionRequest(tool);
+    this.session.reportEventToDaemon("needs_input");
+    logger.debug(`${kind} request sent: ${id}`);
+  }
+  cancelRequestInAgentState(id, reason) {
+    this.session.client.updateAgentState((currentState) => {
+      const request = currentState.requests?.[id];
+      if (!request) return currentState;
+      const requests = { ...currentState.requests };
+      delete requests[id];
+      return {
+        ...currentState,
+        requests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [id]: {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason
+          }
+        }
+      };
+    });
+  }
+  recordCompletedRequest(id, response) {
+    this.session.client.updateAgentState((currentState) => {
+      const request = currentState.requests?.[id];
+      if (!request) return currentState;
+      const requests = { ...currentState.requests };
+      delete requests[id];
+      return {
+        ...currentState,
+        requests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [id]: {
+            ...request,
+            completedAt: Date.now(),
+            status: response.approved ? "approved" : "denied",
+            reason: response.reason,
+            mode: response.mode,
+            decision: response.decision,
+            allowedTools: response.allowTools
+          }
+        }
+      };
+    });
+  }
+  /**
+   * Parses Bash permission strings into literal and prefix sets
+   */
+  parseBashPermission(permission) {
+    if (permission === "Bash") {
+      return;
+    }
+    const bashPattern = /^Bash\((.+?)\)$/;
+    const match = permission.match(bashPattern);
+    if (!match) {
+      return;
+    }
+    const command = match[1];
+    if (command.endsWith(":*")) {
+      const prefix = command.slice(0, -2);
+      this.allowedBashPrefixes.add(prefix);
+    } else {
+      this.allowedBashLiterals.add(command);
+    }
+  }
+  /**
+   * Checks if a tool call is rejected
+   */
+  isAborted(toolCallId) {
+    if (this.responses.get(toolCallId)?.approved === false) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Resets all state for new sessions
+   */
+  reset(reason = "Session switched to local mode") {
+    this.responses.clear();
+    this.allowedTools.clear();
+    this.allowedBashLiterals.clear();
+    this.allowedBashPrefixes.clear();
+    this.permissionMode = "default";
+    this.deferredPermissionMode = void 0;
+    for (const [, pending] of this.pendingRequests.entries()) {
+      pending.reject(new Error("Session reset"));
+    }
+    this.pendingRequests.clear();
+    this.session.client.updateAgentState((currentState) => {
+      const pendingRequests = currentState.requests || {};
+      const completedRequests = { ...currentState.completedRequests };
+      for (const [id, request] of Object.entries(pendingRequests)) {
+        completedRequests[id] = {
+          ...request,
+          completedAt: Date.now(),
+          status: "canceled",
+          reason
+        };
+      }
+      return {
+        ...currentState,
+        requests: {},
+        // Clear all pending requests
+        completedRequests
+      };
+    });
+  }
+  /**
+   * Sets up the client handler for permission responses
+   */
+  setupClientHandler() {
+    this.session.client.rpcHandlerManager.registerHandler("permission", async (message) => {
+      logger.debug("Permission response received:", {
+        id: message.id,
+        approved: message.approved,
+        mode: message.mode,
+        reason: contentLogMetadata(message.reason),
+        allowToolCount: message.allowTools?.length ?? 0,
+        updatedInput: contentLogMetadata(message.updatedInput)
+      });
+      const id = message.id;
+      const pending = this.pendingRequests.get(id);
+      if (!pending) {
+        logger.debug("Permission request not found or already resolved");
+        return;
+      }
+      this.pendingRequests.delete(id);
+      let effectiveResponse = message;
+      if (pending.kind === "tool") {
+        effectiveResponse = await this.handlePermissionResponse(message, pending);
+        this.responses.set(id, { ...effectiveResponse, receivedAt: Date.now() });
+      } else if (pending.kind === "elicitation") {
+        pending.resolve(message.approved ? { action: "accept", content: elicitationContent(message.updatedInput) } : { action: message.decision === "abort" ? "cancel" : "decline" });
+      } else {
+        pending.resolve(message.approved && pending.request.dialogKind === "refusal_fallback_prompt" && (message.updatedInput?.result === void 0 || message.updatedInput.result === "retry_fallback") ? { behavior: "completed", result: "retry_fallback" } : { behavior: "cancelled" });
+      }
+      this.recordCompletedRequest(id, effectiveResponse);
+      this.scheduleDeferredPermissionModeUpdate();
+    });
+  }
+  /**
+   * Gets the responses map (for compatibility with existing code)
+   */
+  getResponses() {
+    return this.responses;
+  }
+}
+
+function rewriteQueuedPermissionMode(queue, hasher, permissionMode) {
+  let rewritten = 0;
+  for (const item of queue) {
+    if (item.mode.permissionMode === permissionMode) continue;
+    item.mode = { ...item.mode, permissionMode };
+    item.modeHash = hasher(item.mode);
+    rewritten += 1;
+  }
+  return rewritten;
+}
+
+function formatClaudeMessageForInk(message, messageBuffer, onAssistantResult) {
+  logger.debugLargeJson("[CLAUDE INK] Message from remote mode:", message);
+  switch (message.type) {
+    case "system": {
+      const sysMsg = message;
+      if (sysMsg.subtype === "init") {
+        messageBuffer.addMessage("\u2500".repeat(40), "status");
+        messageBuffer.addMessage(`\u{1F680} Session initialized: ${sysMsg.session_id}`, "system");
+        messageBuffer.addMessage(`  Model: ${sysMsg.model}`, "status");
+        messageBuffer.addMessage(`  CWD: ${sysMsg.cwd}`, "status");
+        if (sysMsg.tools && sysMsg.tools.length > 0) {
+          messageBuffer.addMessage(`  Tools: ${sysMsg.tools.join(", ")}`, "status");
+        }
+        messageBuffer.addMessage("\u2500".repeat(40), "status");
+      }
+      break;
+    }
+    case "user": {
+      const userMsg = message;
+      if (userMsg.message && typeof userMsg.message === "object" && "content" in userMsg.message) {
+        const content = userMsg.message.content;
+        if (typeof content === "string") {
+          messageBuffer.addMessage(`\u{1F464} User: ${content}`, "user");
+        } else if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "text") {
+              messageBuffer.addMessage(`\u{1F464} User: ${block.text}`, "user");
+            } else if (block.type === "tool_result") {
+              messageBuffer.addMessage(`\u2705 Tool Result (ID: ${block.tool_use_id})`, "result");
+              if (block.content) {
+                const outputStr = typeof block.content === "string" ? block.content : JSON.stringify(block.content, null, 2);
+                const maxLength = 200;
+                if (outputStr.length > maxLength) {
+                  messageBuffer.addMessage(outputStr.substring(0, maxLength) + "... (truncated)", "result");
+                } else {
+                  messageBuffer.addMessage(outputStr, "result");
+                }
+              }
+            }
+          }
+        } else {
+          messageBuffer.addMessage(`\u{1F464} User: ${JSON.stringify(content, null, 2)}`, "user");
+        }
+      }
+      break;
+    }
+    case "assistant": {
+      const assistantMsg = message;
+      if (assistantMsg.message && assistantMsg.message.content) {
+        messageBuffer.addMessage("\u{1F916} Assistant:", "assistant");
+        for (const block of assistantMsg.message.content) {
+          if (block.type === "text") {
+            messageBuffer.addMessage(block.text || "", "assistant");
+          } else if (block.type === "tool_use") {
+            messageBuffer.addMessage(`\u{1F527} Tool: ${block.name}`, "tool");
+            if (block.input) {
+              const inputStr = JSON.stringify(block.input, null, 2);
+              const maxLength = 500;
+              if (inputStr.length > maxLength) {
+                messageBuffer.addMessage(`Input: ${inputStr.substring(0, maxLength)}... (truncated)`, "tool");
+              } else {
+                messageBuffer.addMessage(`Input: ${inputStr}`, "tool");
+              }
+            }
+          }
+        }
+      }
+      break;
+    }
+    case "result": {
+      const resultMsg = message;
+      if (resultMsg.subtype === "success") {
+        if ("result" in resultMsg && resultMsg.result) {
+          messageBuffer.addMessage("\u2728 Summary:", "result");
+          messageBuffer.addMessage(resultMsg.result || "", "result");
+        }
+        if (resultMsg.usage) {
+          messageBuffer.addMessage("\u{1F4CA} Session Stats:", "status");
+          messageBuffer.addMessage(`  \u2022 Turns: ${resultMsg.num_turns}`, "status");
+          messageBuffer.addMessage(`  \u2022 Input tokens: ${resultMsg.usage.input_tokens}`, "status");
+          messageBuffer.addMessage(`  \u2022 Output tokens: ${resultMsg.usage.output_tokens}`, "status");
+          if (resultMsg.usage.cache_read_input_tokens) {
+            messageBuffer.addMessage(`  \u2022 Cache read tokens: ${resultMsg.usage.cache_read_input_tokens}`, "status");
+          }
+          if (resultMsg.usage.cache_creation_input_tokens) {
+            messageBuffer.addMessage(`  \u2022 Cache creation tokens: ${resultMsg.usage.cache_creation_input_tokens}`, "status");
+          }
+          messageBuffer.addMessage(`  \u2022 Cost: $${resultMsg.total_cost_usd.toFixed(4)}`, "status");
+          messageBuffer.addMessage(`  \u2022 Duration: ${resultMsg.duration_ms}ms`, "status");
+        }
+      } else if (resultMsg.subtype === "error_max_turns") {
+        messageBuffer.addMessage("\u274C Error: Maximum turns reached", "result");
+        messageBuffer.addMessage(`Completed ${resultMsg.num_turns} turns`, "status");
+      } else if (resultMsg.subtype === "error_during_execution") {
+        messageBuffer.addMessage("\u274C Error during execution", "result");
+        messageBuffer.addMessage(`Completed ${resultMsg.num_turns} turns before error`, "status");
+        logger.debugLargeJson("[RESULT] Error during execution", resultMsg);
+      }
+      break;
+    }
+    default: {
+      if (process.env.DEBUG) {
+        messageBuffer.addMessage(`[Unknown message type: ${message.type}]`, "status");
+      }
+    }
+  }
+}
+
+const INTERRUPT_SENTINEL = /^\[Request interrupted by user(?: for tool use)?\]$/i;
+const EDE_DIAGNOSTIC_PREFIX = "[ede_diagnostic]";
+const SDK_ERROR_PREFIX = "Claude Code returned an error result:";
+function errorEntries(value) {
+  return value.split(/[;\n]+/).map((entry) => entry.trim()).filter(Boolean);
+}
+function textBlocks(content) {
+  if (!Array.isArray(content) || content.length === 0) return null;
+  const texts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object" || block.type !== "text") {
+      return null;
+    }
+    const text = block.text;
+    if (typeof text !== "string") return null;
+    texts.push(text.trim());
+  }
+  return texts;
+}
+function isClaudeInterruptSentinelContent(content) {
+  if (typeof content === "string") {
+    return INTERRUPT_SENTINEL.test(content.trim());
+  }
+  const texts = textBlocks(content);
+  return texts !== null && texts.length > 0 && texts.every((text) => INTERRUPT_SENTINEL.test(text));
+}
+function resultErrors(value) {
+  if (!value || typeof value !== "object") return [];
+  const errors = value.errors;
+  if (!Array.isArray(errors) || errors.length === 0 || errors.some((error) => typeof error !== "string")) {
+    return [];
+  }
+  return errors.map((error) => error.trim()).filter(Boolean);
+}
+function isClaudeEdeOnlyResult(value) {
+  const errors = resultErrors(value);
+  return errors.length > 0 && errors.every((error) => error.startsWith(EDE_DIAGNOSTIC_PREFIX));
+}
+function stripClaudeEdeDiagnosticText(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (!trimmed.includes(EDE_DIAGNOSTIC_PREFIX)) return trimmed;
+  const visible = errorEntries(trimmed).filter((entry) => !entry.startsWith(EDE_DIAGNOSTIC_PREFIX));
+  return visible.length > 0 ? visible.join("\n") : void 0;
+}
+function stripClaudeEdeDiagnosticErrors(value) {
+  return resultErrors({ errors: value }).filter((error) => !error.startsWith(EDE_DIAGNOSTIC_PREFIX));
+}
+function isClaudeEdeOnlySdkError(error) {
+  if (!(error instanceof Error)) return false;
+  const message = error.message.trim();
+  if (!message.startsWith(SDK_ERROR_PREFIX)) return false;
+  const payload = message.slice(SDK_ERROR_PREFIX.length).trim();
+  const entries = errorEntries(payload);
+  return entries.length > 0 && entries.every((entry) => entry.startsWith(EDE_DIAGNOSTIC_PREFIX));
+}
+
+function getGitBranch(cwd) {
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    }).trim();
+    return branch || void 0;
+  } catch {
+    return void 0;
+  }
+}
+class SDKToLogConverter {
+  lastUuid = null;
+  context;
+  responses;
+  sidechainLastUUID = /* @__PURE__ */ new Map();
+  sawInterruptSentinel = false;
+  sawEdeOnlyAssistantError = false;
+  sawVisibleAssistantError = false;
+  constructor(context, responses) {
+    this.context = {
+      ...context,
+      gitBranch: context.gitBranch ?? getGitBranch(context.cwd),
+      version: context.version ?? process.env.npm_package_version ?? "0.0.0",
+      parentUuid: null
+    };
+    this.responses = responses;
+  }
+  /**
+   * Update session ID (for when session changes during resume)
+   */
+  updateSessionId(sessionId) {
+    this.context.sessionId = sessionId;
+  }
+  /**
+   * Reset parent chain (useful when starting new conversation)
+   */
+  resetParentChain() {
+    this.lastUuid = null;
+    this.context.parentUuid = null;
+  }
+  /** Drop per-query markers that must never leak into the next SDK query. */
+  resetTransientState() {
+    this.sawInterruptSentinel = false;
+    this.sawEdeOnlyAssistantError = false;
+    this.sawVisibleAssistantError = false;
+  }
+  /**
+   * Convert SDK message to log format
+   */
+  convert(sdkMessage) {
+    const uuid = randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    let parentUuid = this.lastUuid;
+    let isSidechain = false;
+    const parentToolUseId = sdkMessage.parent_tool_use_id;
+    if (parentToolUseId) {
+      isSidechain = true;
+      parentUuid = this.sidechainLastUUID.get(parentToolUseId) ?? null;
+      this.sidechainLastUUID.set(parentToolUseId, uuid);
+    }
+    const baseFields = {
+      parentUuid,
+      isSidechain,
+      userType: "external",
+      cwd: this.context.cwd,
+      sessionId: this.context.sessionId,
+      version: this.context.version,
+      gitBranch: this.context.gitBranch,
+      uuid,
+      timestamp
+    };
+    let logMessage = null;
+    switch (sdkMessage.type) {
+      case "user": {
+        const userMsg = sdkMessage;
+        if (isClaudeInterruptSentinelContent(userMsg.message.content)) {
+          this.sawInterruptSentinel = true;
+          return null;
+        }
+        const meta = userMsg.isSynthetic === true || userMsg.isMeta === true;
+        logMessage = {
+          ...baseFields,
+          type: "user",
+          message: userMsg.message,
+          ...userMsg.parent_tool_use_id ? { parent_tool_use_id: userMsg.parent_tool_use_id } : {},
+          ...meta ? { isMeta: true } : {},
+          // B-260-P2: structured tool output (Agent/Task final report +
+          // run totals, or the `async_launched` stub marker) and the
+          // message origin (task-notification). Both are consumed by
+          // sessionProtocolMapper; the raw-line schema is passthrough.
+          ...userMsg.tool_use_result !== void 0 ? { tool_use_result: userMsg.tool_use_result } : {},
+          ...userMsg.origin ? { origin: userMsg.origin } : {}
+        };
+        if (Array.isArray(userMsg.message.content)) {
+          for (const content of userMsg.message.content) {
+            if (content.type === "tool_result" && content.tool_use_id && this.responses?.has(content.tool_use_id)) {
+              const response = this.responses.get(content.tool_use_id);
+              if (response?.mode) {
+                logMessage.mode = response.mode;
+              }
+            }
+          }
+        } else if (typeof userMsg.message.content === "string") ;
+        break;
+      }
+      case "assistant": {
+        const assistantMsg = sdkMessage;
+        const assistantError = stripClaudeEdeDiagnosticText(assistantMsg.error);
+        if (typeof assistantMsg.error === "string" && assistantMsg.error.trim() && !assistantError) {
+          this.sawEdeOnlyAssistantError = true;
+        } else if (assistantError) {
+          this.sawVisibleAssistantError = true;
+        }
+        logMessage = {
+          ...baseFields,
+          type: "assistant",
+          message: assistantMsg.message,
+          // Assistant messages often have additional fields
+          requestId: assistantMsg.requestId,
+          ...assistantMsg.isCompactSummary ? { isCompactSummary: true } : {},
+          ...assistantMsg.parent_tool_use_id ? { parent_tool_use_id: assistantMsg.parent_tool_use_id } : {},
+          ...assistantError ? { error: assistantError } : {}
+        };
+        break;
+      }
+      case "system": {
+        const systemMsg = sdkMessage;
+        if (systemMsg.subtype === "init" && systemMsg.session_id) {
+          this.updateSessionId(systemMsg.session_id);
+        }
+        logMessage = {
+          ...baseFields,
+          type: "system",
+          subtype: systemMsg.subtype,
+          model: systemMsg.model,
+          tools: systemMsg.tools,
+          // Include all other fields
+          ...systemMsg
+        };
+        break;
+      }
+      case "result": {
+        const resultMsg = sdkMessage;
+        const visibleErrors = stripClaudeEdeDiagnosticErrors(
+          "errors" in resultMsg ? resultMsg.errors : void 0
+        );
+        const interruptionSignal = this.sawInterruptSentinel || this.sawEdeOnlyAssistantError || isClaudeEdeOnlyResult(resultMsg);
+        const interrupted = interruptionSignal && !this.sawVisibleAssistantError && visibleErrors.length === 0;
+        this.sawInterruptSentinel = false;
+        this.sawEdeOnlyAssistantError = false;
+        this.sawVisibleAssistantError = false;
+        logMessage = {
+          ...baseFields,
+          type: "result",
+          subtype: resultMsg.subtype,
+          is_error: resultMsg.is_error,
+          ..."result" in resultMsg && typeof resultMsg.result === "string" ? { result: resultMsg.result } : {},
+          total_cost_usd: resultMsg.total_cost_usd,
+          duration_ms: resultMsg.duration_ms,
+          num_turns: resultMsg.num_turns,
+          usage: resultMsg.usage,
+          ...visibleErrors.length > 0 ? { errors: visibleErrors } : {},
+          ..."terminal_reason" in resultMsg && resultMsg.terminal_reason ? { terminal_reason: resultMsg.terminal_reason } : {},
+          ...interrupted ? { interrupted: true } : {}
+        };
+        break;
+      }
+      // These SDK lifecycle/advisory frames are intentionally not part
+      // of the persisted Claude transcript. Enumerating them keeps SDK
+      // upgrades type-visible instead of silently passing new frames
+      // through as conversation messages.
+      case "stream_event":
+      case "tool_progress":
+      case "auth_status":
+      case "tool_use_summary":
+      case "rate_limit_event":
+      case "prompt_suggestion":
+      case "conversation_reset":
+        return null;
+      default: {
+        const exhaustive = sdkMessage;
+        return exhaustive;
+      }
+    }
+    if (logMessage && logMessage.type !== "summary" && logMessage.type !== "result") {
+      this.lastUuid = uuid;
+    }
+    return logMessage;
+  }
+  /**
+   * Convert multiple SDK messages to log format
+   */
+  convertMany(sdkMessages) {
+    return sdkMessages.map((msg) => this.convert(msg)).filter((msg) => msg !== null);
+  }
+  /**
+   * Convert a simple string content to a sidechain user message
+   * Used for Task tool sub-agent prompts
+   */
+  convertSidechainUserMessage(toolUseId, content) {
+    const uuid = randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    this.sidechainLastUUID.set(toolUseId, uuid);
+    return {
+      parentUuid: null,
+      isSidechain: true,
+      parent_tool_use_id: toolUseId,
+      userType: "external",
+      cwd: this.context.cwd,
+      sessionId: this.context.sessionId,
+      version: this.context.version,
+      gitBranch: this.context.gitBranch,
+      type: "user",
+      message: {
+        role: "user",
+        content
+      },
+      uuid,
+      timestamp
+    };
+  }
+  /**
+   * Generate an interrupted tool result message
+   * Used when a tool call is interrupted by the user
+   * @param toolUseId - The ID of the tool that was interrupted
+   * @param parentToolUseId - Optional parent tool ID if this is a sidechain tool
+   */
+  generateInterruptedToolResult(toolUseId, parentToolUseId) {
+    const uuid = randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const errorMessage = "[Request interrupted by user for tool use]";
+    let isSidechain = false;
+    let parentUuid = this.lastUuid;
+    if (parentToolUseId) {
+      isSidechain = true;
+      parentUuid = this.sidechainLastUUID.get(parentToolUseId) ?? null;
+      this.sidechainLastUUID.set(parentToolUseId, uuid);
+    }
+    const logMessage = {
+      type: "user",
+      isSidechain,
+      ...parentToolUseId ? { parent_tool_use_id: parentToolUseId } : {},
+      uuid,
+      message: {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            content: errorMessage,
+            is_error: true,
+            tool_use_id: toolUseId
+          }
+        ]
+      },
+      parentUuid,
+      userType: "external",
+      cwd: this.context.cwd,
+      sessionId: this.context.sessionId,
+      version: this.context.version,
+      gitBranch: this.context.gitBranch,
+      timestamp,
+      toolUseResult: `Error: ${errorMessage}`
+    };
+    this.lastUuid = uuid;
+    return logMessage;
+  }
+}
+
+const transcriptSystemSubtypes = /* @__PURE__ */ new Set(["task_started", "task_updated", "task_progress", "task_notification"]);
+class OutgoingMessageQueue {
+  constructor(sendFunction) {
+    this.sendFunction = sendFunction;
+  }
+  queue = [];
+  nextId = 1;
+  lock = new AsyncLock();
+  processTimer;
+  delayTimers = /* @__PURE__ */ new Map();
+  /**
+   * Add message to queue
+   */
+  enqueue(logMessage, options) {
+    this.lock.inLock(async () => {
+      const item = {
+        id: this.nextId++,
+        logMessage,
+        delayed: !!options?.delay,
+        delayMs: options?.delay || 0,
+        toolCallIds: options?.toolCallIds,
+        released: !options?.delay,
+        // Not delayed = already released
+        sent: false
+      };
+      this.queue.push(item);
+      if (item.delayed) {
+        const timer = setTimeout(() => {
+          this.releaseItem(item.id);
+        }, item.delayMs);
+        this.delayTimers.set(item.id, timer);
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Release specific item by ID
+   */
+  async releaseItem(itemId) {
+    await this.lock.inLock(async () => {
+      const item = this.queue.find((i) => i.id === itemId);
+      if (item && !item.released) {
+        item.released = true;
+        const timer = this.delayTimers.get(itemId);
+        if (timer) {
+          clearTimeout(timer);
+          this.delayTimers.delete(itemId);
+        }
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Release all messages with specific tool call ID
+   */
+  async releaseToolCall(toolCallId) {
+    await this.lock.inLock(async () => {
+      for (const item of this.queue) {
+        if (item.toolCallIds?.includes(toolCallId) && !item.released) {
+          item.released = true;
+          const timer = this.delayTimers.get(item.id);
+          if (timer) {
+            clearTimeout(timer);
+            this.delayTimers.delete(item.id);
+          }
+        }
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Process queue - send messages in ID order that are released
+   * (Internal implementation without lock)
+   */
+  processQueueInternal() {
+    this.queue.sort((a, b) => a.id - b.id);
+    while (this.queue.length > 0) {
+      const item = this.queue[0];
+      if (!item.released) {
+        break;
+      }
+      if (!item.sent) {
+        if (item.logMessage.type !== "system" || transcriptSystemSubtypes.has(item.logMessage.subtype)) {
+          this.sendFunction(item.logMessage);
+        }
+        item.sent = true;
+      }
+      this.queue.shift();
+    }
+  }
+  /**
+   * Process queue - send messages in ID order that are released
+   */
+  async processQueue() {
+    await this.lock.inLock(async () => {
+      this.processQueueInternal();
+    });
+  }
+  /**
+   * Flush all messages immediately (for cleanup)
+   */
+  async flush() {
+    await this.lock.inLock(async () => {
+      for (const timer of this.delayTimers.values()) {
+        clearTimeout(timer);
+      }
+      this.delayTimers.clear();
+      for (const item of this.queue) {
+        item.released = true;
+      }
+      this.processQueueInternal();
+    });
+  }
+  /**
+   * Schedule processing on next tick
+   */
+  scheduleProcessing() {
+    if (this.processTimer) {
+      clearTimeout(this.processTimer);
+    }
+    this.processTimer = setTimeout(() => {
+      this.processQueue();
+    }, 0);
+  }
+  /**
+   * Cleanup timers and resources
+   */
+  destroy() {
+    if (this.processTimer) {
+      clearTimeout(this.processTimer);
+    }
+    for (const timer of this.delayTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.delayTimers.clear();
+  }
+}
+
+function getAskUserQuestionToolCallIds(message) {
+  if (message.type !== "assistant") {
+    return [];
+  }
+  const assistantMessage = message;
+  const content = assistantMessage.message.content;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const ids = [];
+  for (const block of content) {
+    if (block.type === "tool_use" && block.name === "AskUserQuestion" && typeof block.id === "string" && block.id.length > 0) {
+      ids.push(block.id);
+    }
+  }
+  return ids;
+}
+
+async function cleanupStdinAfterInk(opts) {
+  const stdin = opts.stdin;
+  if (!stdin.isTTY) return;
+  const leaveRawMode = opts.leaveRawMode ?? true;
+  try {
+    stdin.setRawMode?.(true);
+  } catch {
+  }
+  const drainMs = Math.max(0, opts.drainMs);
+  if (drainMs === 0) {
+    try {
+      stdin.pause();
+    } catch {
+    }
+    if (!leaveRawMode) {
+      try {
+        stdin.setRawMode?.(false);
+      } catch {
+      }
+    }
+    return;
+  }
+  let bytes = 0;
+  let chunks = 0;
+  const drainListener = (chunk) => {
+    chunks++;
+    if (typeof chunk === "string") {
+      bytes += Buffer.byteLength(chunk);
+    } else if (chunk && typeof chunk.length === "number") {
+      bytes += chunk.length;
+    }
+  };
+  try {
+    stdin.on("data", drainListener);
+    stdin.resume();
+    await new Promise((resolve) => setTimeout(resolve, drainMs));
+  } finally {
+    try {
+      stdin.off("data", drainListener);
+    } catch {
+    }
+    try {
+      stdin.pause();
+    } catch {
+    }
+    if (!leaveRawMode) {
+      try {
+        stdin.setRawMode?.(false);
+      } catch {
+      }
+    }
+    opts.onDebug?.({ kind: "drain-byte-count", bytes, chunks });
+  }
+}
+
+function applyClaudeResultLifecycle(result, callbacks) {
+  if (result && (result.subtype !== "success" || result.is_error === true)) {
+    const frame = result;
+    const error = frame.errors?.filter(Boolean).join("\n").trim() || (typeof frame.result === "string" ? frame.result.trim() : "") || frame.subtype;
+    callbacks.closeFailed(error);
+    callbacks.onFailed(error);
+    return;
+  }
+  callbacks.closeCompleted();
+  callbacks.onCompleted();
+}
+
+function applyClaudeSdkMetadata(current, update) {
+  return {
+    ...current,
+    ...update.models ? { models: update.models } : {},
+    tools: update.tools,
+    slashCommands: update.slashCommands,
+    mcpServers: update.mcpServers,
+    skills: update.skills,
+    attachmentKinds: [...CLAUDE_ATTACHMENT_KINDS],
+    queueCancellation: true,
+    // The model Claude Code reports it is ACTUALLY running. system/init is
+    // re-emitted at every turn boundary (verified against the pinned SDK,
+    // 2026-09-03), including after a live setModel, so this is the web's
+    // only ground truth for "did my switch take effect" — the picker
+    // otherwise renders nothing but the client's own optimistic intent.
+    ...update.model ? { currentModelCode: update.model } : {},
+    ...update.modelIsDefault && update.model ? { defaultModelCode: update.model } : {}
+  };
+}
+
+function createTurnSteeringController() {
+  let interrupt = null;
+  let steering = false;
+  let interrupting = false;
+  return {
+    setInterrupt(next) {
+      interrupt = next;
+    },
+    async steer() {
+      if (!interrupt) return false;
+      steering = true;
+      try {
+        await interrupt();
+        return true;
+      } catch (error) {
+        steering = false;
+        throw error;
+      }
+    },
+    /**
+     * Interrupt the current turn WITHOUT injecting a follow-up message —
+     * used by the stop button. Like steer it keeps the streaming query
+     * alive (same process, same claudeSessionId); unlike steer it does not
+     * set the steering flag, so the turn simply ends and the query waits
+     * for the next user message. Returns false when no query is attached.
+     */
+    async interruptTurn() {
+      if (!interrupt) return false;
+      interrupting = true;
+      try {
+        await interrupt();
+        return true;
+      } catch (error) {
+        interrupting = false;
+        throw error;
+      }
+    },
+    consumeReady() {
+      if (!steering) return false;
+      steering = false;
+      return true;
+    },
+    /** The next `result` belongs to a stop-button interrupt: close the
+     *  turn as cancelled and say "Aborted by user", not "failed". */
+    consumeInterrupted() {
+      if (!interrupting) return false;
+      interrupting = false;
+      return true;
+    },
+    reset() {
+      interrupt = null;
+      steering = false;
+      interrupting = false;
+    }
+  };
+}
+
+class LaunchModeGate {
+  constructor(hasher) {
+    this.hasher = hasher;
+  }
+  currentMode = null;
+  currentHash = null;
+  parked = null;
+  /** The mode this launch is running, or null before the first message. */
+  get mode() {
+    return this.currentMode;
+  }
+  /** Hash of {@link mode}; null means "not armed yet — accept anything". */
+  get hash() {
+    return this.currentHash;
+  }
+  /** Whether a message has been adopted into this launch yet. */
+  get armed() {
+    return this.currentHash !== null;
+  }
+  /** Bind the launch to `mode`. Idempotent; safe to call with the same mode. */
+  adopt(mode) {
+    this.currentMode = mode;
+    this.currentHash = this.hasher(mode);
+  }
+  /**
+   * Re-adopt the current mode with one field replaced. No-op before the first
+   * adopt: there is nothing to derive from, and arming here would make the
+   * first real message look like a mode change.
+   */
+  amend(patch) {
+    if (this.currentMode === null) return null;
+    this.adopt({ ...this.currentMode, ...patch });
+    return this.currentMode;
+  }
+  /**
+   * True when `incomingHash` cannot run on this launch's Query and must be
+   * parked for a fresh one. An un-armed gate accepts anything — that is how a
+   * new launch takes its first message, including a replayed parked one.
+   */
+  requiresRelaunch(incomingHash, isolate) {
+    if (isolate) return true;
+    return this.armed && incomingHash !== this.currentHash;
+  }
+  /** True when `mode` is exactly what this launch adopted (Steer's precondition). */
+  matches(mode) {
+    return this.armed && this.hasher(mode) === this.currentHash;
+  }
+  /**
+   * Hold a message that cannot run on this launch until its successor picks
+   * it up. Survives {@link reset} — the parked message is precisely what the
+   * next launch exists to run.
+   */
+  park(message) {
+    this.parked = message;
+  }
+  /** Whether a parked message is waiting for the next launch. */
+  get hasParked() {
+    return this.parked !== null;
+  }
+  /**
+   * Take the parked message AND adopt its mode in one step.
+   *
+   * This pairing is the whole point of the class. When parking and adopting
+   * were separate — a `pending` variable in the launcher next to a `modeHash`
+   * one — the replay path took the message and forgot to adopt, so the gate
+   * stayed un-armed and swallowed the NEXT mode change into a Query built for
+   * the previous one. Nothing structural tied the two, and no unit test could
+   * reach the wiring. Here they cannot come apart.
+   */
+  takeParked() {
+    const message = this.parked;
+    if (!message) return null;
+    this.parked = null;
+    this.adopt(message.mode);
+    return message;
+  }
+  /**
+   * Re-adopt the parked message with a patched mode. Used when an explicit
+   * mode switch lands while a message is parked: the switch is newer than the
+   * snapshot the message carried when it was queued.
+   */
+  amendParked(patch) {
+    if (!this.parked) return;
+    this.parked = { ...this.parked, mode: { ...this.parked.mode, ...patch } };
+  }
+  /**
+   * Drop back to un-armed. Called when a launch ends. Deliberately does NOT
+   * clear a parked message: parking happens in the launch that is ending, and
+   * the message belongs to the one about to start.
+   */
+  reset() {
+    this.currentMode = null;
+    this.currentHash = null;
+  }
+}
+
+const ABORT_INTERRUPT_GRACE_MS = 4e3;
+async function claudeRemoteLauncher(session, onPermissionModeChange, onEffectivePermissionMode, onPromptFinalized) {
+  logger.debug("[claudeRemoteLauncher] Starting remote launcher");
+  const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
+  logger.debug(`[claudeRemoteLauncher] TTY available: ${hasTTY}`);
+  let messageBuffer = new MessageBuffer();
+  let inkInstance = null;
+  if (hasTTY) {
+    const [{ render }, { default: React }, { RemoteModeDisplay }] = await Promise.all([
+      import('ink'),
+      import('react'),
+      import('./RemoteModeDisplay-D-HewyXg.mjs')
+    ]);
+    console.clear();
+    inkInstance = render(React.createElement(RemoteModeDisplay, {
+      messageBuffer,
+      logPath: process.env.DEBUG ? session.logPath : void 0,
+      onExit: async () => {
+        logger.debug("[remote]: Exiting client via Ctrl-C");
+        if (!exitReason) {
+          exitReason = "exit";
+        }
+        await abort();
+      },
+      onSwitchToLocal: () => {
+        logger.debug("[remote]: Switching to local mode via double space");
+        doSwitch();
+      }
+    }), {
+      exitOnCtrlC: false,
+      patchConsole: false
+    });
+  }
+  if (hasTTY) {
+    process.stdin.resume();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.setEncoding("utf8");
+  }
+  let exitReason = null;
+  let abortController = null;
+  let abortFuture = null;
+  const turnSteering = createTurnSteeringController();
+  const runtimeControls = createRuntimeControls(() => session.thinking);
+  session.client.rpcHandlerManager.registerHandler("claude-runtime-control", async (input) => runtimeControls.request(input));
+  const backgroundTasks = createBackgroundTaskTracker();
+  async function abort() {
+    if (abortController && !abortController.signal.aborted) {
+      abortController.abort();
+    }
+    await abortFuture?.promise;
+  }
+  async function doAbort() {
+    logger.debug("[remote]: doAbort");
+    session.markAborting();
+    session.onAbort();
+    void runtimeControls.stopRunningTasks().then((ids) => {
+      if (ids.length > 0) logger.debug(`[remote]: stopped ${ids.length} background task(s) on abort: ${ids.join(", ")}`);
+    }).catch((error) => logger.debug("[remote]: stopping background tasks on abort failed", error));
+    if (session.thinking) {
+      const interrupted = await turnSteering.interruptTurn().catch((e) => {
+        logger.debug("[remote]: interruptTurn threw, falling back to hard abort", e);
+        return false;
+      });
+      if (interrupted && await waitForThinkingToStop(ABORT_INTERRUPT_GRACE_MS)) {
+        logger.debug("[remote]: interrupt stopped the turn gracefully; query kept alive");
+        return;
+      }
+      logger.debug("[remote]: interrupt did not stop the turn in time; escalating to hard abort");
+      turnSteering.consumeInterrupted();
+    }
+    await abort();
+  }
+  async function waitForThinkingToStop(graceMs) {
+    const deadline = Date.now() + graceMs;
+    while (Date.now() < deadline) {
+      if (!session.thinking) return true;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return !session.thinking;
+  }
+  async function doSwitch() {
+    logger.debug("[remote]: doSwitch");
+    if (!exitReason) {
+      exitReason = "switch";
+    }
+    await abort();
+  }
+  session.client.rpcHandlerManager.registerHandler("abort", doAbort);
+  session.client.rpcHandlerManager.registerHandler("steer", async () => {
+    await turnSteering.steer();
+  });
+  session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
+  let livePermissionModeHandler = null;
+  let idlePermissionModeHandler = null;
+  session.client.rpcHandlerManager.registerHandler(
+    "set-permission-mode",
+    async (request) => {
+      const requestedMode = parseClaudePermissionMode(request?.mode);
+      if (!requestedMode) throw new Error("Invalid Claude permission mode");
+      if (livePermissionModeHandler) return { mode: await livePermissionModeHandler(requestedMode) };
+      if (idlePermissionModeHandler) return { mode: idlePermissionModeHandler(requestedMode) };
+      throw new Error("No active Claude query");
+    }
+  );
+  const permissionHandler = new PermissionHandler(session);
+  idlePermissionModeHandler = (nextMode) => {
+    permissionHandler.handleModeChange(nextMode);
+    onPermissionModeChange?.(nextMode);
+    return nextMode;
+  };
+  permissionHandler.reset("Previous CLI process exited before responding");
+  const streamingEnabled = process.env.HAPPY_SESSION_STREAM_DISABLED !== "1";
+  const streamRelay = new StreamRelay({
+    send: (frame) => session.client.sendStreamFrame(frame)
+  });
+  const messageQueue = new OutgoingMessageQueue(
+    (logMessage) => session.client.sendClaudeSessionMessage(logMessage)
+  );
+  permissionHandler.setOnPermissionRequest((toolCallId) => {
+    messageQueue.releaseToolCall(toolCallId);
+  });
+  const sdkToLogConverter = new SDKToLogConverter({
+    sessionId: session.sessionId || "unknown",
+    cwd: session.path,
+    version: process.env.npm_package_version
+  }, permissionHandler.getResponses());
+  let ongoingToolCalls = /* @__PURE__ */ new Map();
+  let notifiedQuestionToolCalls = /* @__PURE__ */ new Set();
+  function onMessage(message) {
+    runtimeControls.observe(message);
+    backgroundTasks.observe(message);
+    session.setBackgroundTasks(backgroundTasks.list());
+    if (isRuntimeCheckpointReplay(message)) return;
+    if (message.type === "user" && isClaudeInterruptSentinelContent(message.message.content)) {
+      sdkToLogConverter.convert(message);
+      return;
+    }
+    formatClaudeMessageForInk(message, messageBuffer);
+    if (message.type === "assistant") {
+      let umessage = message;
+      if (umessage.message.content && Array.isArray(umessage.message.content)) {
+        for (let c of umessage.message.content) {
+          if (c.type === "tool_use") {
+            logger.debug("[remote]: detected tool use " + c.id + " parent: " + umessage.parent_tool_use_id);
+            ongoingToolCalls.set(c.id, { parentToolCallId: umessage.parent_tool_use_id ?? null });
+          }
+          if (c.type === "text" && (umessage.parent_tool_use_id ?? null) === null) {
+            session.noteAssistantOutput(typeof c.text === "string" ? c.text : void 0);
+          }
+        }
+      }
+    }
+    for (const toolCallId of getAskUserQuestionToolCallIds(message)) {
+      if (notifiedQuestionToolCalls.has(toolCallId)) {
+        continue;
+      }
+      notifiedQuestionToolCalls.add(toolCallId);
+      session.api.push().sendSessionNotification({
+        kind: "question",
+        metadata: session.client.getMetadata(),
+        data: {
+          sessionId: session.client.sessionId,
+          tool: "AskUserQuestion",
+          toolCallId,
+          type: "question_request",
+          provider: "claude"
+        }
+      });
+    }
+    if (message.type === "user") {
+      let umessage = message;
+      if (umessage.message.content && Array.isArray(umessage.message.content)) {
+        for (let c of umessage.message.content) {
+          if (c.type === "tool_result" && c.tool_use_id) {
+            ongoingToolCalls.delete(c.tool_use_id);
+            messageQueue.releaseToolCall(c.tool_use_id);
+          }
+        }
+      }
+    }
+    const logMessage = sdkToLogConverter.convert(message);
+    if (logMessage) {
+      if (logMessage.type === "user" && logMessage.message?.content) {
+        const content = Array.isArray(logMessage.message.content) ? logMessage.message.content : [];
+        for (let i = 0; i < content.length; i++) {
+          const c = content[i];
+          if (c.type === "tool_result" && c.tool_use_id) {
+            const responses = permissionHandler.getResponses();
+            const response = responses.get(c.tool_use_id);
+            if (response) {
+              const permissions = {
+                date: response.receivedAt || Date.now(),
+                result: response.approved ? "approved" : "denied"
+              };
+              if (response.mode) {
+                permissions.mode = response.mode;
+              }
+              if (response.allowTools && response.allowTools.length > 0) {
+                permissions.allowedTools = response.allowTools;
+              }
+              content[i] = {
+                ...c,
+                permissions
+              };
+            }
+          }
+        }
+      }
+      if (logMessage.type === "assistant" && message.type === "assistant") {
+        const assistantMsg = message;
+        const toolCallIds = [];
+        if (assistantMsg.message.content && Array.isArray(assistantMsg.message.content)) {
+          for (const block of assistantMsg.message.content) {
+            if (block.type === "tool_use" && block.id) {
+              toolCallIds.push(block.id);
+            }
+          }
+        }
+        if (toolCallIds.length > 0) {
+          const isSidechain = assistantMsg.parent_tool_use_id !== void 0;
+          if (!isSidechain) {
+            messageQueue.enqueue(logMessage, {
+              delay: 250,
+              toolCallIds
+            });
+            return;
+          }
+        }
+      }
+      messageQueue.enqueue(logMessage);
+    }
+    if (message.type === "assistant") {
+      let umessage = message;
+      if (umessage.message.content && Array.isArray(umessage.message.content)) {
+        for (let c of umessage.message.content) {
+          if (c.type === "tool_use" && c.name === "Task" && c.input && typeof c.input.prompt === "string") {
+            const logMessage2 = sdkToLogConverter.convertSidechainUserMessage(c.id, c.input.prompt);
+            if (logMessage2) {
+              messageQueue.enqueue(logMessage2);
+            }
+          }
+        }
+      }
+    }
+  }
+  try {
+    const modeGate = new LaunchModeGate(session.queue.modeHasher);
+    let previousSessionId = null;
+    while (!exitReason) {
+      logger.debug("[remote]: launch");
+      messageBuffer.addMessage("\u2550".repeat(40), "status");
+      const isNewSession = session.sessionId !== previousSessionId;
+      if (isNewSession) {
+        messageBuffer.addMessage("Starting new Claude session...", "status");
+        permissionHandler.reset();
+        sdkToLogConverter.resetParentChain();
+        logger.debug(`[remote]: New session detected (previous: ${previousSessionId}, current: ${session.sessionId})`);
+      } else {
+        messageBuffer.addMessage("Continuing Claude session...", "status");
+        logger.debug(`[remote]: Continuing existing session: ${session.sessionId}`);
+      }
+      previousSessionId = session.sessionId;
+      const controller = new AbortController();
+      abortController = controller;
+      abortFuture = new Future();
+      const commitPermissionMode = (nextMode) => {
+        permissionHandler.handleModeChange(nextMode);
+        modeGate.amend({ permissionMode: nextMode });
+        rewriteQueuedPermissionMode(session.queue.queue, session.queue.modeHasher, nextMode);
+        modeGate.amendParked({ permissionMode: nextMode });
+        onPermissionModeChange?.(nextMode);
+        return nextMode;
+      };
+      idlePermissionModeHandler = commitPermissionMode;
+      permissionHandler.setOnModeChanged((nextMode) => {
+        commitPermissionMode(nextMode);
+      });
+      try {
+        const attachmentDirectory = chatAttachmentDirectory(configuration.happyHomeDir, session.client.sessionId);
+        await ensurePrivateDirectory(attachmentDirectory);
+        const remoteResult = await claudeRemote({
+          sessionId: session.sessionId,
+          path: session.path,
+          additionalDirectories: [attachmentDirectory],
+          allowedTools: session.allowedTools ?? [],
+          mcpServers: session.mcpServers,
+          hookSettingsPath: session.hookSettingsPath,
+          jsRuntime: session.jsRuntime,
+          canCallTool: permissionHandler.handleToolCall,
+          onElicitation: permissionHandler.handleElicitation,
+          onUserDialog: permissionHandler.handleUserDialog,
+          isAborted: (toolCallId) => {
+            return permissionHandler.isAborted(toolCallId);
+          },
+          nextMessage: async () => {
+            const parked = modeGate.takeParked();
+            if (parked) {
+              permissionHandler.handleModeChange(parked.mode.permissionMode);
+              if (typeof parked.message === "string") onPromptFinalized?.(parked.message);
+              return parked;
+            }
+            let msg = await session.queue.waitForMessagesAndGetAsString(controller.signal);
+            if (msg) {
+              if (modeGate.requiresRelaunch(msg.hash, msg.isolate)) {
+                logger.debug("[remote]: mode has changed, pending message");
+                const parkedAttachments = msg.attachments ?? [];
+                const parkedStaged = parkedAttachments.length > 0 ? await stageClaudeAttachments(parkedAttachments, {
+                  happyHomeDir: configuration.happyHomeDir,
+                  sessionId: session.client.sessionId
+                }) : [];
+                modeGate.park({
+                  message: parkedStaged.length > 0 ? appendStagedAttachmentsToPrompt(msg.message, parkedStaged) : msg.message,
+                  mode: msg.mode
+                });
+                return null;
+              }
+              modeGate.adopt(msg.mode);
+              permissionHandler.handleModeChange(msg.mode.permissionMode);
+              const attachments = msg.attachments ?? [];
+              if (attachments.length > 0) {
+                const staged = await stageClaudeAttachments(attachments, {
+                  happyHomeDir: configuration.happyHomeDir,
+                  sessionId: session.client.sessionId
+                });
+                logger.debug(`[remote] Staged ${staged.length} attachment(s) for the coding agent`);
+                const withAttachments = appendStagedAttachmentsToPrompt(msg.message, staged);
+                onPromptFinalized?.(withAttachments);
+                return {
+                  message: withAttachments,
+                  mode: msg.mode
+                };
+              }
+              onPromptFinalized?.(msg.message);
+              return {
+                message: msg.message,
+                mode: msg.mode
+              };
+            }
+            return null;
+          },
+          onSessionFound: (sessionId) => {
+            sdkToLogConverter.updateSessionId(sessionId);
+            session.onSessionFound(sessionId);
+          },
+          onSDKMetadata: (metadata) => {
+            logger.debug("[remote] SDK metadata received, updating session:", {
+              toolCount: metadata.tools?.length ?? 0,
+              slashCommandCount: metadata.slashCommands?.length ?? 0,
+              mcpServerCount: metadata.mcpServers?.length ?? 0,
+              skillCount: metadata.skills?.length ?? 0
+            });
+            session.client.updateMetadata((currentMetadata) => applyClaudeSdkMetadata(currentMetadata, metadata));
+            if (metadata.permissionMode) onEffectivePermissionMode?.(metadata.permissionMode);
+          },
+          onQueryReady: (q) => {
+            runtimeControls.setQuery(q);
+            backgroundTasks.reset();
+            session.setBackgroundTasks([]);
+            turnSteering.setInterrupt(q.interrupt);
+            session.setSideQuestionLive({ ask: q.sideQuestion, canControl: q.canControl });
+            session.setSteerHandler(async (input) => {
+              if (!modeGate.matches(input.mode)) return false;
+              let message = input.message;
+              if (input.attachments?.length) {
+                const staged = await stageClaudeAttachments(input.attachments, {
+                  happyHomeDir: configuration.happyHomeDir,
+                  sessionId: session.client.sessionId
+                });
+                message = appendStagedAttachmentsToPrompt(input.message, staged);
+              }
+              if (!session.thinking || !modeGate.matches(input.mode)) return false;
+              if (typeof message === "string") onPromptFinalized?.(message);
+              q.steer(message, input.mode);
+              return true;
+            });
+            permissionHandler.setPermissionModeUpdater(async (mode) => {
+              await q.setPermissionMode(mode);
+            });
+            livePermissionModeHandler = async (nextMode) => {
+              await permissionHandler.setLivePermissionMode(nextMode);
+              modeGate.amend({ permissionMode: nextMode });
+              onPermissionModeChange?.(nextMode);
+              return nextMode;
+            };
+          },
+          onThinkingChange: session.onThinkingChange,
+          onStreamFrame: streamingEnabled ? (frame) => streamRelay.ingest(frame) : void 0,
+          claudeEnvVars: session.claudeEnvVars,
+          claudeArgs: session.claudeArgs,
+          onMessage,
+          onCompletionEvent: (message) => {
+            logger.debug("[remote]: Completion event received:", contentLogMetadata(message));
+            session.client.sendSessionEvent({ type: "message", message });
+          },
+          onAuthFailure: (reason) => {
+            session.client.sendSessionEvent({ type: "message", message: `Claude Code auth: ${reason}`, kind: "claude-auth-failed" });
+            void notifyDaemonClaudeAuthFailed(session.client.sessionId).catch((error) => logger.debug("[remote]: auth_failed report to daemon failed:", error));
+          },
+          onSessionReset: () => {
+            logger.debug("[remote]: Session reset");
+            session.clearSessionId();
+          },
+          onReady: (result) => {
+            if (turnSteering.consumeReady()) {
+              session.client.closeClaudeSessionTurn("cancelled");
+              return;
+            }
+            if (turnSteering.consumeInterrupted()) {
+              session.client.closeClaudeSessionTurn("cancelled");
+              session.client.sendSessionEvent({ type: "message", message: "Aborted by user" });
+              return;
+            }
+            applyClaudeResultLifecycle(result, {
+              closeCompleted: () => session.client.closeClaudeSessionTurn("completed"),
+              closeFailed: (error) => session.client.closeClaudeSessionTurn("failed", { error }),
+              onFailed: (error) => session.onSessionError(error),
+              onCompleted: () => {
+                const idle = !modeGate.hasParked && session.queue.size() === 0 && !session.client.promptQueueHasPending();
+                session.onTurnEnd(idle);
+                if (idle) {
+                  session.api.push().sendSessionNotification({
+                    kind: "done",
+                    metadata: session.client.getMetadata(),
+                    data: {
+                      sessionId: session.client.sessionId,
+                      type: "ready",
+                      provider: "claude"
+                    }
+                  });
+                }
+              }
+            });
+          },
+          signal: abortController.signal
+        });
+        session.consumeOneTimeFlags();
+        if (!exitReason && abortController.signal.aborted) {
+          session.client.closeClaudeSessionTurn("cancelled");
+          session.client.sendSessionEvent({ type: "message", message: "Aborted by user" });
+        }
+      } catch (e) {
+        logger.debug("[remote]: launch error", e);
+        if (!exitReason) {
+          if (isClaudeEdeOnlySdkError(e)) {
+            session.client.closeClaudeSessionTurn("cancelled");
+            continue;
+          }
+          session.client.closeClaudeSessionTurn("failed");
+          session.client.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+          session.onSessionError(e instanceof Error ? e.message : "Process exited unexpectedly");
+          continue;
+        }
+      } finally {
+        runtimeControls.setQuery(null);
+        backgroundTasks.reset();
+        session.setBackgroundTasks([]);
+        turnSteering.reset();
+        session.setSteerHandler(null);
+        session.setSideQuestionLive(null);
+        livePermissionModeHandler = null;
+        permissionHandler.setPermissionModeUpdater(void 0);
+        sdkToLogConverter.resetTransientState();
+        logger.debug("[remote]: launch finally");
+        for (let [toolCallId, { parentToolCallId }] of ongoingToolCalls) {
+          const converted = sdkToLogConverter.generateInterruptedToolResult(toolCallId, parentToolCallId);
+          if (converted) {
+            logger.debug("[remote]: terminating tool call " + toolCallId + " parent: " + parentToolCallId);
+            session.client.sendClaudeSessionMessage(converted);
+          }
+        }
+        ongoingToolCalls.clear();
+        logger.debug("[remote]: flushing message queue");
+        await messageQueue.flush();
+        messageQueue.destroy();
+        logger.debug("[remote]: message queue flushed");
+        streamRelay.endTurn();
+        streamRelay.dispose();
+        abortController = null;
+        abortFuture?.resolve(void 0);
+        abortFuture = null;
+        logger.debug("[remote]: launch done");
+        permissionHandler.reset();
+        modeGate.reset();
+      }
+    }
+  } finally {
+    permissionHandler.reset();
+    const t0 = Date.now();
+    logger.debug(`[remote]: cleanup begin exitReason=${exitReason} hasInk=${!!inkInstance} rawMode=${process.stdin.isRaw}`);
+    if (inkInstance) {
+      inkInstance.unmount();
+    }
+    logger.debug(`[remote]: ink.unmount() done +${Date.now() - t0}ms rawMode=${process.stdin.isRaw}`);
+    await cleanupStdinAfterInk({
+      stdin: process.stdin,
+      drainMs: 150,
+      onDebug: (event) => {
+        logger.debug(`[remote]: stdin drain ${event.bytes}B / ${event.chunks} chunk(s) +${Date.now() - t0}ms`);
+      }
+    });
+    logger.debug(`[remote]: cleanup done +${Date.now() - t0}ms rawMode=${process.stdin.isRaw}`);
+    messageBuffer.clear();
+    if (abortFuture) {
+      abortFuture.resolve(void 0);
+    }
+  }
+  return exitReason || "exit";
+}
+
+async function loop(opts) {
+  const logPath = logger.logFilePath;
+  let session = new Session({
+    api: opts.api,
+    client: opts.session,
+    path: opts.path,
+    sessionId: null,
+    claudeEnvVars: opts.claudeEnvVars,
+    claudeArgs: opts.claudeArgs,
+    mcpServers: opts.mcpServers,
+    logPath,
+    messageQueue: opts.messageQueue,
+    allowedTools: opts.allowedTools,
+    sandboxConfig: opts.sandboxConfig,
+    onModeChange: opts.onModeChange,
+    onAbort: opts.onAbort,
+    hookSettingsPath: opts.hookSettingsPath,
+    jsRuntime: opts.jsRuntime
+  });
+  opts.onSessionReady?.(session);
+  let mode = opts.startingMode ?? "local";
+  while (true) {
+    logger.debug(`[loop] Iteration with mode: ${mode}`);
+    switch (mode) {
+      case "local": {
+        const { claudeLocalLauncher } = await import('./claudeLocalLauncher-D4T7MTqd.mjs');
+        const result = await claudeLocalLauncher(session);
+        switch (result.type) {
+          case "switch":
+            mode = "remote";
+            opts.onModeChange?.(mode);
+            break;
+          case "exit":
+            return result.code;
+        }
+        break;
+      }
+      case "remote": {
+        const reason = await claudeRemoteLauncher(session, opts.onPermissionModeChange, opts.onEffectivePermissionMode, opts.onPromptFinalized);
+        switch (reason) {
+          case "exit":
+            return 0;
+          case "switch":
+            mode = "local";
+            opts.onModeChange?.(mode);
+            break;
+        }
+        break;
+      }
+    }
+  }
+}
+
+function claudeModeHash(mode) {
+  return hashObject({
+    isPlan: mode.permissionMode === "plan",
+    fallbackModel: mode.fallbackModel,
+    customSystemPrompt: mode.customSystemPrompt,
+    appendSystemPrompt: mode.appendSystemPrompt,
+    allowedTools: mode.allowedTools,
+    disallowedTools: mode.disallowedTools,
+    effort: mode.effort
+  });
+}
+
+function hookRequestLogMetadata(body, data) {
+  return {
+    bodyBytes: Buffer.byteLength(body, "utf8"),
+    parsed: data !== void 0,
+    hasSessionId: Boolean(data?.session_id || data?.sessionId)
+  };
+}
+function hookErrorLogMetadata(error) {
+  if (!error || typeof error !== "object") return { errorType: typeof error };
+  const value = error;
+  const errorType = typeof value.name === "string" && /^[a-z][a-z0-9_.-]{0,63}$/i.test(value.name) ? value.name : "Error";
+  const safeCode = typeof value.code === "string" && /^[a-z0-9_.-]{1,64}$/i.test(value.code) ? value.code : typeof value.code === "number" ? value.code : void 0;
+  return {
+    errorType,
+    ...safeCode === void 0 ? {} : { code: safeCode }
+  };
+}
+async function startHookServer(options) {
+  const { onSessionHook } = options;
+  return new Promise((resolve, reject) => {
+    const server = createServer(async (req, res) => {
+      if (req.method === "POST" && req.url === "/hook/session-start") {
+        const timeout = setTimeout(() => {
+          if (!res.headersSent) {
+            logger.debug("[hookServer] Request timeout");
+            res.writeHead(408).end("timeout");
+          }
+        }, 5e3);
+        try {
+          const chunks = [];
+          for await (const chunk of req) {
+            chunks.push(chunk);
+          }
+          clearTimeout(timeout);
+          const body = Buffer.concat(chunks).toString("utf-8");
+          let data;
+          try {
+            data = JSON.parse(body);
+            logger.debug("[hookServer] Received session hook metadata", hookRequestLogMetadata(body, data));
+          } catch {
+            logger.debug("[hookServer] Failed to parse session hook", hookRequestLogMetadata(body));
+          }
+          const sessionId = data?.session_id || data?.sessionId;
+          if (sessionId && data) {
+            logger.debug(`[hookServer] Session hook received session ID: ${sessionId}`);
+            onSessionHook(sessionId, data);
+          } else {
+            logger.debug("[hookServer] Session hook received but no session_id found in data");
+          }
+          res.writeHead(200, { "Content-Type": "text/plain" }).end("ok");
+        } catch (error) {
+          clearTimeout(timeout);
+          logger.debug("[hookServer] Error handling session hook", hookErrorLogMetadata(error));
+          if (!res.headersSent) {
+            res.writeHead(500).end("error");
+          }
+        }
+        return;
+      }
+      res.writeHead(404).end("not found");
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Failed to get server address"));
+        return;
+      }
+      const port = address.port;
+      logger.debug(`[hookServer] Started on port ${port}`);
+      resolve({
+        port,
+        stop: () => {
+          server.close();
+          logger.debug("[hookServer] Stopped");
+        }
+      });
+    });
+    server.on("error", (err) => {
+      logger.debug("[hookServer] Server error", hookErrorLogMetadata(err));
+      reject(err);
+    });
+  });
+}
+
+function generateHookSettingsFile(port) {
+  const hooksDir = join(configuration.happyHomeDir, "tmp", "hooks");
+  mkdirSync(hooksDir, { recursive: true });
+  const filename = `session-hook-${process.pid}.json`;
+  const filepath = join(hooksDir, filename);
+  const forwarderScript = resolve(projectPath(), "scripts", "session_hook_forwarder.cjs");
+  const hookCommand = `node "${forwarderScript}" ${port}`;
+  const settings = {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "*",
+          hooks: [
+            {
+              type: "command",
+              command: hookCommand
+            }
+          ]
+        }
+      ]
+    }
+  };
+  writeFileSync(filepath, JSON.stringify(settings, null, 2));
+  logger.debug(`[generateHookSettings] Created hook settings file: ${filepath}`);
+  return filepath;
+}
+function cleanupHookSettingsFile(filepath) {
+  try {
+    if (existsSync(filepath)) {
+      unlinkSync(filepath);
+      logger.debug(`[generateHookSettings] Cleaned up hook settings file: ${filepath}`);
+    }
+  } catch (error) {
+    logger.debug(`[generateHookSettings] Failed to cleanup hook settings file: ${error}`);
+  }
+}
+
+async function settleSessionOnExit(sessionId, intent, deps) {
+  if (intent === "archive") {
+    deps.updateMetadata((currentMetadata) => ({
+      ...currentMetadata,
+      lifecycleState: "archived",
+      lifecycleStateSince: Date.now(),
+      archivedBy: "cli",
+      archiveReason: "User terminated"
+    }));
+  }
+  deps.sendSessionDeath();
+  try {
+    if (intent === "archive") await deps.archiveSession(sessionId);
+    else await deps.deactivateSession(sessionId);
+  } catch (error) {
+    deps.log?.(`[START] ${intent === "archive" ? "archiveSession" : "deactivateSession"} during cleanup failed:`, error);
+  }
+}
+class SessionExitGate {
+  decided = null;
+  /** Returns the intent to act on, or null when cleanup already started. */
+  claim(intent) {
+    if (this.decided !== null) return null;
+    this.decided = intent;
+    return intent;
+  }
+  get current() {
+    return this.decided;
+  }
+}
+function exitIntentFromArchiveFlag(archive) {
+  return archive ?? true ? "archive" : "offline";
+}
+
+function isUnsupportedSideQuestionError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /unknown|unsupported|not supported|unrecognized|invalid.*subtype/i.test(message);
+}
+async function runSideQuestionLive(ask, input) {
+  const history = (input.history ?? []).filter((h) => h.question.trim() && h.answer.trim()).slice(-12).map((h) => ({ question: clip(h.question.trim(), MAX_HISTORY_CHARS), response: clip(h.answer.trim(), MAX_HISTORY_CHARS) }));
+  const result = await ask({ question: input.question.trim(), ...history.length ? { history } : {} }, input.signal);
+  if (input.signal?.aborted) throw new Error("Side question cancelled");
+  const text = typeof result?.response === "string" ? result.response : "";
+  if (!text.trim()) throw new Error("Side question ended without a result");
+  const fallback = result.refusal_fallback?.content;
+  const answer = fallback ? `\u26A0 ${fallback}
+
+${text}` : text;
+  input.onText?.(answer);
+  return { answer, hadContext: true, mode: "live" };
+}
+const SIDE_QUESTION_SYSTEM_PROMPT = [
+  "A user message wrapped in a side-question system-reminder is a SIDE QUESTION: answer it",
+  "directly in one response from the conversation context, with no tools and no action on the main task."
+].join(" ");
+const SIDE_QUESTION_REMINDER = [
+  "<system-reminder>This is a side question from the user. You must answer this question directly in a single response.",
+  "",
+  "IMPORTANT CONTEXT:",
+  "- You are a separate, lightweight agent spawned to answer this one question",
+  "- The main agent is NOT interrupted - it continues working independently in the background",
+  "- You share the conversation context but are a completely separate instance",
+  '- Do NOT reference being interrupted or what you were "previously doing" - that framing is incorrect',
+  "",
+  "CRITICAL CONSTRAINTS:",
+  "- You have NO tools available - you cannot read files, run commands, search, or take any actions",
+  "- This is a one-off response - there will be no follow-up turns",
+  "- You can ONLY provide information based on what you already know from the conversation context",
+  `- NEVER say things like "Let me try...", "I'll now...", "Let me check...", or promise to take any action`,
+  "- If you don't know the answer, say so - do not offer to look it up or investigate",
+  "",
+  "Simply answer the question with the information you have.</system-reminder>"
+].join("\n");
+const MAX_HISTORY_CHARS = 2e3;
+function clip(text, max) {
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+function buildSideQuestionPrompt(question, history = []) {
+  const trimmed = question.trim();
+  const prior = history.filter((h) => h.question.trim() && h.answer.trim()).slice(-12);
+  const body = `${SIDE_QUESTION_REMINDER}
+
+${trimmed}`;
+  if (prior.length === 0) return body;
+  const lines = prior.map((h) => `Q: ${clip(h.question.trim(), MAX_HISTORY_CHARS)}
+A: ${clip(h.answer.trim(), MAX_HISTORY_CHARS)}`);
+  return `<earlier-side-questions>
+${lines.join("\n\n")}
+</earlier-side-questions>
+
+${body}`;
+}
+function sideQuestionQueryOptions(input) {
+  return {
+    cwd: input.cwd,
+    ...input.resumeSessionId ? { resume: input.resumeSessionId, forkSession: true } : {},
+    persistSession: false,
+    tools: [],
+    mcpServers: {},
+    strictMcpConfig: true,
+    maxTurns: 1,
+    includePartialMessages: true,
+    permissionMode: "default",
+    model: input.model,
+    env: input.env,
+    settingsPath: input.settingsPath,
+    appendSystemPrompt: SIDE_QUESTION_SYSTEM_PROMPT,
+    canCallTool: async () => ({ behavior: "deny", message: "Side questions cannot use tools" }),
+    abort: input.signal
+  };
+}
+function assistantBlocks(message) {
+  if (message.type !== "assistant") return [];
+  const content = message.message?.content;
+  return Array.isArray(content) ? content.filter((b) => Boolean(b) && typeof b === "object") : [];
+}
+function textFromAssistant(message) {
+  return assistantBlocks(message).map((block) => block.type === "text" ? String(block.text ?? "") : "").join("");
+}
+function toolUseFromAssistant(message) {
+  const block = assistantBlocks(message).find((b) => b.type === "tool_use");
+  return block ? String(block.name ?? "a tool") : null;
+}
+function toolAttemptNotice(toolName) {
+  return `(The model tried to call ${toolName} instead of answering directly. Try rephrasing or ask in the main conversation.)`;
+}
+function apiErrorFromSystem(message) {
+  if (message.type !== "system") return null;
+  const m = message;
+  if (m.subtype !== "api_error") return null;
+  if (typeof m.error === "string") return m.error;
+  const detail = m.error?.formatted ?? m.error?.message;
+  return typeof detail === "string" && detail ? detail : "API error";
+}
+async function runSideQuestion(query, input) {
+  const options = sideQuestionQueryOptions(input);
+  const stream = query({ prompt: buildSideQuestionPrompt(input.question, input.history), options });
+  let streamed = "";
+  let final = "";
+  let toolAttempt = null;
+  let lastApiError = null;
+  let resultSeen = false;
+  for await (const message of stream) {
+    if (message.type === "stream_event") {
+      const event = message.event;
+      if (event?.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
+        streamed += event.delta.text;
+        input.onText?.(streamed);
+      }
+      continue;
+    }
+    if (message.type === "assistant") {
+      const text = textFromAssistant(message);
+      if (text) {
+        final = final ? `${final}
+
+${text}` : text;
+        input.onText?.(final);
+      }
+      toolAttempt ??= toolUseFromAssistant(message);
+      continue;
+    }
+    if (message.type === "system") {
+      lastApiError = apiErrorFromSystem(message) ?? lastApiError;
+      continue;
+    }
+    if (message.type === "result") {
+      resultSeen = true;
+      const result = message;
+      if (result.subtype !== "success") {
+        if (toolAttempt && result.subtype === "error_max_turns") break;
+        const detail = Array.isArray(result.errors) && result.errors.length > 0 ? String(result.errors[0]) : typeof result.result === "string" && result.result ? result.result : lastApiError ?? result.subtype ?? "unknown";
+        throw new Error(`Side question failed: ${detail}`);
+      }
+      if (!final && typeof result.result === "string") final = result.result;
+    }
+  }
+  if (input.signal?.aborted) throw new Error("Side question cancelled");
+  if (toolAttempt && !final.trim() && !streamed.trim()) {
+    const notice = toolAttemptNotice(toolAttempt);
+    input.onText?.(notice);
+    return { answer: notice, hadContext: Boolean(input.resumeSessionId), mode: "fork" };
+  }
+  if (!resultSeen && !final && !streamed) throw new Error(`Side question ended without a result${lastApiError ? `: ${lastApiError}` : ""}`);
+  return { answer: final || streamed, hadContext: Boolean(input.resumeSessionId), mode: "fork" };
+}
+
+const SIDE_QUESTION_RETAIN_MS = 5 * 6e4;
+const SIDE_QUESTION_MAX_CHARS = 8e3;
+const SIDE_QUESTION_MAX_RUN_MS = 10 * 6e4;
+function writeSideQuestionSettingsFile(homeDir) {
+  const dir = join(homeDir, "tmp", "hooks");
+  mkdirSync(dir, { recursive: true });
+  const file = join(dir, `side-question-${process.pid}.json`);
+  writeFileSync(file, JSON.stringify({ disableAllHooks: true }));
+  return file;
+}
+function parseHistory(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.flatMap((item) => {
+    if (!item || typeof item !== "object") return [];
+    const { question, answer } = item;
+    return typeof question === "string" && typeof answer === "string" ? [{ question, answer }] : [];
+  });
+}
+function registerSideQuestionHandler(rpc, deps) {
+  const now = deps.now ?? (() => Date.now());
+  const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
+  const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
+  const fork = deps.run ?? (async (input) => {
+    const { query } = await import('./index-B6UGRQ7h.mjs');
+    return runSideQuestion(query, input);
+  });
+  const run = async (input, live) => {
+    if (!live) return fork(input);
+    try {
+      return await runSideQuestionLive(live.ask, input);
+    } catch (error) {
+      if (input.signal?.aborted || !isUnsupportedSideQuestionError(error)) throw error;
+      logger.debug(`[btw] live side question unsupported by this CLI, forking instead: ${error instanceof Error ? error.message : String(error)}`);
+      return fork(input);
+    }
+  };
+  const slots = /* @__PURE__ */ new Map();
+  let active = null;
+  const prune = () => {
+    const t = now();
+    for (const [id, slot] of slots) {
+      if (slot.status !== "running" && slot.finishedAt !== void 0 && t - slot.finishedAt > retainMs) slots.delete(id);
+    }
+  };
+  const finish = (slot, status, error) => {
+    if (slot.status !== "running") return;
+    slot.status = status;
+    slot.error = error;
+    slot.finishedAt = now();
+    if (active === slot) active = null;
+  };
+  rpc.registerHandler("btw-ask", async (request) => {
+    const question = typeof request?.question === "string" ? request.question.trim() : "";
+    if (!question) throw new Error("Side question is empty");
+    if (question.length > SIDE_QUESTION_MAX_CHARS) throw new Error("Side question is too long");
+    prune();
+    if (active) {
+      const stale = active;
+      stale.abort.abort("superseded");
+      finish(stale, "cancelled");
+      logger.debug(`[btw] side question ${stale.requestId} superseded by a new ask`);
+    }
+    const candidate = deps.getLiveQuery?.() ?? null;
+    const live = candidate && candidate.canControl() ? candidate : null;
+    const resumeSessionId = deps.getClaudeSessionId() ?? null;
+    const slot = {
+      requestId: randomUUID(),
+      status: "running",
+      text: "",
+      startedAt: now(),
+      abort: new AbortController()
+    };
+    slots.set(slot.requestId, slot);
+    active = slot;
+    logger.debug(`[btw] side question ${slot.requestId} start (${live ? "live" : resumeSessionId ? "fork" : "no-context"})`);
+    const deadline = setTimeout(() => {
+      if (slot.status !== "running") return;
+      slot.abort.abort("timeout");
+      finish(slot, "error", "Side question timed out");
+      logger.debug(`[btw] side question ${slot.requestId} timed out after ${maxRunMs}ms`);
+    }, maxRunMs);
+    deadline.unref?.();
+    void run({
+      question,
+      history: parseHistory(request.history),
+      resumeSessionId,
+      cwd: deps.cwd,
+      model: deps.getModel(),
+      env: deps.getEnv?.(),
+      settingsPath: deps.settingsPath,
+      signal: slot.abort.signal,
+      onText: (text) => {
+        if (slot.status === "running") slot.text = text;
+      }
+    }, live).then((result) => {
+      slot.text = result.answer;
+      finish(slot, "done");
+      logger.debug(`[btw] side question ${slot.requestId} done (${result.mode ?? "fork"}, ${result.answer.length} chars)`);
+    }).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      if (slot.abort.signal.aborted) {
+        finish(slot, "cancelled");
+      } else {
+        finish(slot, "error", message);
+        logger.debug(`[btw] side question ${slot.requestId} failed: ${message}`);
+      }
+    }).finally(() => clearTimeout(deadline));
+    return { requestId: slot.requestId, hadContext: live ? true : Boolean(resumeSessionId), mode: live ? "live" : "fork" };
+  });
+  rpc.registerHandler("btw-poll", async (request) => {
+    prune();
+    const id = typeof request?.requestId === "string" ? request.requestId : "";
+    const slot = slots.get(id);
+    if (!slot) throw new Error("Unknown side question");
+    return {
+      requestId: slot.requestId,
+      status: slot.status,
+      text: slot.text,
+      error: slot.error,
+      startedAt: slot.startedAt,
+      finishedAt: slot.finishedAt
+    };
+  });
+  rpc.registerHandler("btw-cancel", async (request) => {
+    const id = typeof request?.requestId === "string" ? request.requestId : "";
+    const slot = slots.get(id);
+    if (!slot || slot.status !== "running") return { cancelled: false };
+    slot.abort.abort("cancelled by user");
+    finish(slot, "cancelled");
+    return { cancelled: true };
+  });
+  return {
+    /** Test/introspection hook. */
+    _slots: slots
+  };
+}
+
+const ANALYZE_MIN_INTERVAL_MS = 5 * 60 * 1e3;
+const HOURLY_LIMIT = 30;
+const HOURLY_WINDOW_MS = 60 * 60 * 1e3;
+const USER_MESSAGE_MAX_CHARS = 1e3;
+const ASSISTANT_TAIL_MAX_CHARS = 1e3;
+const PROGRESS_MAX_CHARS = 200;
+const MAX_TASKS_IN_PROMPT = 30;
+function computeInputHash(input) {
+  const h = createHash("sha256");
+  h.update(input.lastUserMessage);
+  h.update("\0");
+  h.update(input.assistantTail);
+  h.update("\0");
+  h.update(input.todos.join("\n"));
+  h.update("\0");
+  h.update(input.tasks.map((t) => t.id).join(","));
+  return h.digest("hex");
+}
+function shouldAnalyze(state, hash, now) {
+  if (state.lastHash !== null && state.lastHash === hash) return false;
+  if (now - state.lastRunAt < ANALYZE_MIN_INTERVAL_MS) return false;
+  return true;
+}
+function pruneRateWindow(timestamps, now, limit = HOURLY_LIMIT, windowMs = HOURLY_WINDOW_MS) {
+  const window = timestamps.filter((t) => typeof t === "number" && t > now - windowMs && t <= now);
+  return { window, allowed: window.length < limit };
+}
+function parseBoardAnalysis(raw, knownTaskIds) {
+  let text = raw.trim();
+  if (!text) return null;
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fence) text = fence[1].trim();
+  if (!text.startsWith("{")) {
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start === -1 || end <= start) return null;
+    text = text.slice(start, end + 1);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  const obj = parsed;
+  const attention = obj.attention;
+  if (attention !== "none" && attention !== "review" && attention !== "blocked") return null;
+  if (typeof obj.progress !== "string") return null;
+  const progress = obj.progress.trim().slice(0, PROGRESS_MAX_CHARS);
+  if (!progress) return null;
+  let taskId = null;
+  if (typeof obj.taskId === "string" && knownTaskIds.has(obj.taskId)) {
+    taskId = obj.taskId;
+  }
+  return { taskId, attention, progress };
+}
+function buildBoardPrompt(input) {
+  const tasks = input.tasks.slice(0, MAX_TASKS_IN_PROMPT);
+  const taskLines = tasks.length > 0 ? tasks.map((t) => `- ${t.id}: ${t.title}`).join("\n") : "(no tasks defined)";
+  const todoBlock = input.todos.length > 0 ? input.todos.join("\n") : "(none)";
+  return [
+    `${BOARD_ANALYZER_PROMPT_PREFIX} Analyze this session snapshot and reply with ONLY a strict JSON object, no markdown, no explanations:`,
+    '{"taskId": string|null, "attention": "none"|"review"|"blocked", "progress": string}',
+    "",
+    "Rules:",
+    `- taskId: the id of the ONE task below this session is working on, or null if none clearly matches. Never invent an id.`,
+    '- attention: "blocked" if the agent is stuck/waiting on the user; "review" if it finished something that needs the user to check; otherwise "none".',
+    "- progress: one short sentence in Chinese (\u7B80\u4F53\u4E2D\u6587) describing current progress. No quotes inside.",
+    "",
+    `Task list:
+${taskLines}`,
+    "",
+    `Latest user message:
+${input.lastUserMessage.slice(0, USER_MESSAGE_MAX_CHARS)}`,
+    "",
+    `Latest assistant output (tail):
+${input.assistantTail.slice(-ASSISTANT_TAIL_MAX_CHARS)}`,
+    "",
+    `Current todos:
+${todoBlock}`
+  ].join("\n");
+}
+function extractFromClaudeMessage(body) {
+  if (body.type !== "assistant") return {};
+  const message = body.message;
+  const content = message?.content;
+  if (!Array.isArray(content)) return {};
+  let assistantText;
+  let todos;
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string" && b.text.trim()) {
+      assistantText = b.text;
+    } else if (b.type === "tool_use" && b.name === "TodoWrite" && Array.isArray(b.input?.todos)) {
+      todos = b.input.todos.filter((t) => t && typeof t.content === "string").map((t) => `[${t.status === "completed" ? "x" : t.status === "in_progress" ? "~" : " "}] ${t.content}`);
+    }
+  }
+  return { assistantText, todos };
+}
+class FileRateLimiter {
+  constructor(filePath, limit = HOURLY_LIMIT, windowMs = HOURLY_WINDOW_MS) {
+    this.filePath = filePath;
+    this.limit = limit;
+    this.windowMs = windowMs;
+  }
+  /** Try to record one run right now. False → over the hourly cap. */
+  tryAcquire(now = Date.now()) {
+    let timestamps = [];
+    try {
+      const raw = readFileSync(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed.runs)) timestamps = parsed.runs;
+    } catch {
+    }
+    const { window, allowed } = pruneRateWindow(timestamps, now, this.limit, this.windowMs);
+    if (!allowed) return false;
+    window.push(now);
+    try {
+      mkdirSync(dirname(this.filePath), { recursive: true });
+      writeFileSync(this.filePath, JSON.stringify({ runs: window }));
+    } catch (error) {
+      logger.debug("[boardAnalyzer] rate file write failed", { error: String(error) });
+    }
+    return true;
+  }
+}
+class BoardAnalyzer {
+  constructor(session, options) {
+    this.session = session;
+    this.options = options;
+  }
+  lastUserMessage = "";
+  assistantTail = "";
+  todos = [];
+  throttle = { lastRunAt: 0, lastHash: null };
+  running = false;
+  sawUserMessage = false;
+  /** Feed every observed user prompt (both the app channel and the JSONL
+   *  scanner — same call sites as titleGenerator.maybeGenerate). The FIRST
+   *  one also triggers an immediate analysis attempt. */
+  noteUserMessage(text) {
+    if (!this.options.enabled) return;
+    if (!text || text.trim().length === 0) return;
+    this.lastUserMessage = text.slice(0, USER_MESSAGE_MAX_CHARS * 2);
+    if (!this.sawUserMessage) {
+      this.sawUserMessage = true;
+      this.maybeAnalyze("first-message");
+    }
+  }
+  /** Feed every raw Claude JSONL line flowing to the server (assistant text
+   *  tail + TodoWrite snapshots). Cheap; called from a socket 'claude-session-message' listener. */
+  noteClaudeMessage(body) {
+    if (!this.options.enabled) return;
+    try {
+      const { assistantText, todos } = extractFromClaudeMessage(body);
+      if (assistantText) this.assistantTail = assistantText.slice(-ASSISTANT_TAIL_MAX_CHARS);
+      if (todos) this.todos = todos;
+    } catch {
+    }
+  }
+  /** Turn ended (any status) — throttled analysis attempt. */
+  onTurnEnd() {
+    if (!this.options.enabled) return;
+    this.maybeAnalyze("turn-end");
+  }
+  maybeAnalyze(reason) {
+    if (this.running) return;
+    if (!this.lastUserMessage) return;
+    this.running = true;
+    void this.analyze(reason).catch((error) => {
+      logger.debug("[boardAnalyzer] analysis rejected", { error: String(error) });
+    }).finally(() => {
+      this.running = false;
+    });
+  }
+  async analyze(reason) {
+    let tasks = [];
+    try {
+      tasks = await this.options.fetchTasks() ?? [];
+    } catch {
+      tasks = [];
+    }
+    const input = {
+      lastUserMessage: this.lastUserMessage,
+      assistantTail: this.assistantTail,
+      todos: this.todos,
+      tasks
+    };
+    const hash = computeInputHash(input);
+    const now = Date.now();
+    if (this.options.selfReportState && isSelfReportFresh(this.options.selfReportState, now)) {
+      logger.debug("[boardAnalyzer] recent self-report; skipping LLM analysis");
+      return;
+    }
+    if (!shouldAnalyze(this.throttle, hash, now)) {
+      logger.debug(`[boardAnalyzer] throttled (${reason})`);
+      return;
+    }
+    if (!this.options.rateLimiter.tryAcquire(now)) {
+      logger.debug("[boardAnalyzer] machine hourly cap reached; skipping");
+      return;
+    }
+    this.throttle = { lastRunAt: now, lastHash: hash };
+    const binary = resolveClaudeBinary();
+    if (!binary) {
+      logger.debug("[boardAnalyzer] no claude binary; skipping");
+      return;
+    }
+    const stdout = await runClaudeOneShot(binary, buildBoardPrompt(input));
+    if (stdout == null) return;
+    const verdict = parseBoardAnalysis(stdout, new Set(tasks.map((t) => t.id)));
+    if (!verdict) {
+      logger.debug("[boardAnalyzer] unusable analysis output; dropped");
+      return;
+    }
+    logger.debug(`[boardAnalyzer] verdict: task=${verdict.taskId} attention=${verdict.attention}`);
+    this.session.updateMetadata((metadata) => ({
+      ...metadata,
+      board: {
+        ...verdict.taskId ? { taskId: verdict.taskId } : {},
+        attention: verdict.attention,
+        progress: verdict.progress,
+        analyzedAt: Date.now()
+      }
+    }));
+  }
+}
+
+const ASSISTANT_DISALLOWED_TOOLS = [
+  "Bash",
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "NotebookEdit"
+];
+function withAssistantDenylist(current, isAssistant) {
+  if (!isAssistant) return current;
+  const merged = /* @__PURE__ */ new Set([...current ?? [], ...ASSISTANT_DISALLOWED_TOOLS]);
+  return [...merged];
+}
+
+export { BoardAnalyzer, FileRateLimiter, SessionExitGate, claudeCheckSession, claudeModeHash, cleanupHookSettingsFile, contentLogMetadata, exitIntentFromArchiveFlag, generateHookSettingsFile, getProjectPath, loop, parseSpecialCommand, registerSideQuestionHandler, settleSessionOnExit, startHookServer, withAssistantDenylist, writeSideQuestionSettingsFile };