@threadbase-sh/streamer 1.16.0 → 1.17.0

package/dist/index.js

@@ -702,6 +702,162 @@ function getLogger(component) {
 }
 var logger = build(baseLogger);
 
+// src/services/questions/detectPermissionGate.ts
+var OSC_777_RE = /\x1b\]777;notify;Claude Code;[^\x07\x1b]*/;
+function hasPermissionOsc(rawData) {
+  return OSC_777_RE.test(rawData);
+}
+var OPTION_RE = /^\s*(❯)?\s*(\d+)\.\s+(.+?)\s*$/;
+var FOOTER_RE = /Enter to select|Esc to cancel|↑|↓|to navigate|to cancel/i;
+var BOX_ONLY_RE = /^[\s│─┌┐└┘├┤┬┴┼╭╮╰╯╱╲=_-]+$/;
+var PROMPT_ARROW_RE = /^[\s]*[❯›>]\s*$/;
+function stripGutter(line) {
+  return line.replace(/^\s*[│|]\s?/, "").replace(/\s*[│|]\s*$/, "");
+}
+function scrapePermissionGate(lines) {
+  const options = [];
+  let cursor;
+  let firstOptionLine = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const m = OPTION_RE.exec(stripGutter(lines[i]));
+    if (!m) continue;
+    const index = Number.parseInt(m[2], 10);
+    if (!Number.isFinite(index)) continue;
+    if (firstOptionLine === -1) firstOptionLine = i;
+    if (m[1]) cursor = index;
+    options.push({ index, label: m[3] });
+  }
+  if (options.length === 0) return null;
+  let prompt;
+  for (let i = firstOptionLine - 1; i >= 0; i--) {
+    const t = stripGutter(lines[i]).trim();
+    if (t.length === 0) continue;
+    if (BOX_ONLY_RE.test(lines[i].trim()) || FOOTER_RE.test(t) || PROMPT_ARROW_RE.test(t)) continue;
+    prompt = t || void 0;
+    break;
+  }
+  return { ...prompt ? { prompt } : {}, options, ...cursor !== void 0 ? { cursor } : {} };
+}
+
+// src/services/questions/detectQuestionFromScreen.ts
+var ASK_FOOTER_RE = /Enter to select/i;
+var ESC_FOOTER_RE = /Esc to cancel|to navigate/i;
+var OPTION_RE2 = /^\s*(?:❯)?\s*(\d+)\.\s+(.+?)\s*$/;
+var QUESTION_RE = /\?\s*$/;
+var BOX_ONLY_RE2 = /^[\s│─┌┐└┘├┤┬┴┼╭╮╰╯╱╲=_-]+$/;
+var PERMISSION_LABEL_RE = /^(Yes|No)\b/i;
+function stripBoxGutter(line) {
+  return line.replace(/^\s*[│|]\s?/, "").replace(/\s*[│|]\s*$/, "");
+}
+function detectQuestionFromScreen(lines) {
+  let footerIdx = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (ASK_FOOTER_RE.test(lines[i])) {
+      footerIdx = i;
+      break;
+    }
+  }
+  if (footerIdx === -1) return null;
+  const options = [];
+  let firstOptionIdx = -1;
+  for (let i = footerIdx - 1; i >= 0; i--) {
+    const line = lines[i];
+    const inner = stripBoxGutter(line);
+    const trimmed = inner.trim();
+    if (trimmed.length === 0) {
+      if (options.length === 0) continue;
+      break;
+    }
+    if (BOX_ONLY_RE2.test(line.trim())) continue;
+    if (ESC_FOOTER_RE.test(line) && options.length === 0) continue;
+    if (options.length > 0 && QUESTION_RE.test(trimmed) && !OPTION_RE2.test(inner)) break;
+    const m = OPTION_RE2.exec(inner);
+    if (m) {
+      const label = m[2].trim();
+      if (PERMISSION_LABEL_RE.test(label)) return null;
+      options.unshift({ label, description: "" });
+      firstOptionIdx = i;
+    }
+  }
+  if (options.length < 2 || firstOptionIdx === -1) return null;
+  let question;
+  for (let i = firstOptionIdx - 1; i >= 0; i--) {
+    const raw = stripBoxGutter(lines[i]);
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) continue;
+    if (BOX_ONLY_RE2.test(lines[i].trim())) continue;
+    if (QUESTION_RE.test(trimmed)) {
+      question = trimmed;
+    }
+    break;
+  }
+  if (!question) return null;
+  return {
+    questions: [{ question, header: "", multiSelect: false, options }]
+  };
+}
+function questionContentKey(questions) {
+  return questions.map((q) => `${q.question} ${q.options.map((o) => o.label).join(",")}`).join("::");
+}
+
+// src/services/questions/detectShellPrompt.ts
+var ENTER = "\r";
+var YN_RE = /[[(]\s*y\s*\/\s*n\s*[\])]/i;
+var PRESS_ENTER_RE = /press\s+(enter|return|any key)/i;
+var CONTINUE_RE = /\bcontinue\b\s*\??\s*$/i;
+var NUMBERED_RE = /^\s*(?:❯|>)?\s*(\d+)[.)]\s+(.+?)\s*$/;
+var CLAUDE_CHROME_RE = /Enter to select|Esc to cancel|╭|╰|│.*│/;
+var BOX_ONLY_RE3 = /^[\s│─┌┐└┘├┤┬┴┼╭╮╰╯╱╲=_-]+$/;
+function lastNonBlank(lines) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const t = lines[i].trim();
+    if (t.length > 0) return { text: t, idx: i };
+  }
+  return null;
+}
+function detectShellPrompt(lines) {
+  if (lines.some((l) => CLAUDE_CHROME_RE.test(l))) return null;
+  const last = lastNonBlank(lines);
+  if (!last) return null;
+  if (YN_RE.test(last.text)) {
+    return {
+      prompt: last.text,
+      options: [
+        { index: 1, label: "Yes", answerKeys: `y${ENTER}` },
+        { index: 2, label: "No", answerKeys: `n${ENTER}` }
+      ]
+    };
+  }
+  if (NUMBERED_RE.test(last.text)) {
+    const options = [];
+    for (let i = 0; i <= last.idx; i++) {
+      const m = NUMBERED_RE.exec(lines[i]);
+      if (!m) continue;
+      const num = Number.parseInt(m[1], 10);
+      if (!Number.isFinite(num)) continue;
+      options.push({ index: num, label: m[2].trim(), answerKeys: `${num}${ENTER}` });
+    }
+    if (options.length >= 2) {
+      const firstRow = lines.findIndex((l) => NUMBERED_RE.test(l));
+      let prompt = "";
+      for (let i = firstRow - 1; i >= 0; i--) {
+        const t = lines[i].trim();
+        if (t.length === 0 || BOX_ONLY_RE3.test(t)) continue;
+        prompt = t;
+        break;
+      }
+      return { prompt: prompt || "Select an option", options };
+    }
+  }
+  if (PRESS_ENTER_RE.test(last.text) || CONTINUE_RE.test(last.text)) {
+    return {
+      prompt: last.text,
+      options: [{ index: 1, label: "Continue", answerKeys: ENTER }]
+    };
+  }
+  return null;
+}
+
 // src/pty-manager.ts
 var OUTPUT_BUFFER_MAX = 65536;
 var PTY_COLS = 120;
@@ -752,6 +908,21 @@ var PTYManager = class {
   onOutput;
   onStatusChange;
   onReady;
+  onPermissionChange;
+  onLiveQuestion;
+  onLiveQuestionGone;
+  // Per-session permission-gate state. True between an OSC 777 (gate open) and
+  // the next prompt-ready without a fresh 777 (gate closed). Prevents
+  // re-broadcasting open/close on every chunk.
+  permissionOpen = /* @__PURE__ */ new Set();
+  // Content key of the last AskUserQuestion broadcast from the rendered screen,
+  // per session — de-dupes the same menu firing on consecutive repaints.
+  lastScreenQuestionKey = /* @__PURE__ */ new Map();
+  // Content key of the last unstructured shell prompt (detectShellPrompt)
+  // broadcast per session — present between open and resolve so we can clear it
+  // on a prompt-ready/marker return and de-dupe consecutive repaints. Modelled
+  // on permissionOpen but keyed by content (a shell prompt has no OSC trigger).
+  shellPromptOpen = /* @__PURE__ */ new Map();
   // Tracks sessions (both fresh and resume) whose PTY has spawned but Claude
   // hasn't yet reached an interactive prompt — i.e. onReady hasn't fired.
   pendingReady = /* @__PURE__ */ new Set();
@@ -774,6 +945,9 @@ var PTYManager = class {
     this.onOutput = options.onOutput;
     this.onStatusChange = options.onStatusChange;
     this.onReady = options.onReady;
+    this.onPermissionChange = options.onPermissionChange;
+    this.onLiveQuestion = options.onLiveQuestion;
+    this.onLiveQuestionGone = options.onLiveQuestionGone;
     this.log = options.logger ?? getLogger("pty");
   }
   // Resume an existing Claude conversation. sessionId is the JSONL UUID.
@@ -1016,6 +1190,9 @@ var PTYManager = class {
     this.pendingReady.delete(sessionId);
     this.queuedInputs.delete(sessionId);
     this.firstChunkAt.delete(sessionId);
+    this.permissionOpen.delete(sessionId);
+    this.lastScreenQuestionKey.delete(sessionId);
+    this.shellPromptOpen.delete(sessionId);
     try {
       session.process.kill("SIGINT");
     } catch {
@@ -1075,6 +1252,9 @@ var PTYManager = class {
     this.firstChunkAt.clear();
     this.chunkIndex.clear();
     this.lastChunkAt.clear();
+    this.permissionOpen.clear();
+    this.lastScreenQuestionKey.clear();
+    this.shellPromptOpen.clear();
   }
   handleOutput(sessionId, data) {
     const session = this.sessions.get(sessionId);
@@ -1118,6 +1298,87 @@ var PTYManager = class {
       this.markReady(sessionId, session, "fallback:timeout");
     }
     this.onOutput?.(sessionId, data);
+    this.detectLivePrompts(sessionId, data, stripped).catch((err) => {
+      this.log.warn("[pty.prompt_detect] failed", {
+        event: "pty.prompt_detect_failed",
+        sessionId,
+        err
+      });
+    });
+  }
+  // Detect permission gates (OSC 777 + scraped options) and AskUserQuestion
+  // menus from the rendered screen, firing the additive callbacks. Async because
+  // reading the rendered buffer needs the xterm write queue flushed. Pure
+  // detection lives in services/questions/*; this only orchestrates triggers,
+  // per-session debounce, and the callbacks.
+  async detectLivePrompts(sessionId, rawData, stripped) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    const oscPermission = hasPermissionOsc(rawData);
+    const hasAskFooter = /Enter to select/i.test(stripped);
+    const hasPromptMarker = CLAUDE_PROMPT_MARKERS.some((m) => stripped.includes(m));
+    const hasShellPromptHint = /[[(]\s*y\s*\/\s*n\s*[\])]|press\s+(enter|return|any key)|\bcontinue\b\s*\?|^\s*(?:❯|>)?\s*\d+[.)]\s+\S/im.test(
+      stripped
+    );
+    if (!oscPermission && !hasAskFooter && !hasShellPromptHint && !this.permissionOpen.has(sessionId) && !this.shellPromptOpen.has(sessionId) && !this.lastScreenQuestionKey.has(sessionId)) {
+      return;
+    }
+    const lines = await this.getOutputLines(sessionId, 60);
+    const askFooterOnScreen = lines.some((l) => /Enter to select/i.test(l));
+    if (oscPermission || hasAskFooter || askFooterOnScreen) {
+      this.log.debug?.(`[pty.prompt_detect] ${sessionId.slice(0, 8)} trigger`, {
+        event: "pty.prompt_detect",
+        sessionId,
+        oscPermission,
+        hasAskFooter,
+        askFooterOnScreen,
+        permGate: oscPermission && !askFooterOnScreen ? scrapePermissionGate(lines) : void 0,
+        askQuestion: askFooterOnScreen ? detectQuestionFromScreen(lines) : void 0,
+        renderedTail: lines.slice(-25)
+      });
+    }
+    if (oscPermission && !askFooterOnScreen) {
+      const gate = scrapePermissionGate(lines);
+      this.permissionOpen.add(sessionId);
+      this.onPermissionChange?.(sessionId, gate ?? { options: [] });
+    } else if (this.permissionOpen.has(sessionId) && !askFooterOnScreen) {
+      const gate = scrapePermissionGate(lines);
+      if (gate) {
+        this.onPermissionChange?.(sessionId, gate);
+      } else if (hasPromptMarker) {
+        this.permissionOpen.delete(sessionId);
+        this.onPermissionChange?.(sessionId, null);
+      }
+    }
+    if (askFooterOnScreen) {
+      const detected = detectQuestionFromScreen(lines);
+      if (detected) {
+        const key = questionContentKey(detected.questions);
+        if (this.lastScreenQuestionKey.get(sessionId) !== key) {
+          this.lastScreenQuestionKey.set(sessionId, key);
+          this.onLiveQuestion?.(sessionId, detected.questions);
+        }
+      }
+    } else if (this.lastScreenQuestionKey.has(sessionId) && hasPromptMarker) {
+      this.lastScreenQuestionKey.delete(sessionId);
+      this.onLiveQuestionGone?.(sessionId);
+    }
+    if (!oscPermission && !askFooterOnScreen && !this.permissionOpen.has(sessionId)) {
+      const shell = detectShellPrompt(lines);
+      if (shell) {
+        const key = `${shell.prompt}\0${shell.options.map((o) => o.label).join("\0")}`;
+        if (this.shellPromptOpen.get(sessionId) !== key) {
+          this.shellPromptOpen.set(sessionId, key);
+          this.onPermissionChange?.(sessionId, {
+            prompt: shell.prompt,
+            options: shell.options
+          });
+        }
+      } else if (this.shellPromptOpen.has(sessionId) && hasPromptMarker) {
+        this.shellPromptOpen.delete(sessionId);
+        this.onPermissionChange?.(sessionId, null);
+      }
+    }
   }
   // Transition a session from "running" to "waiting_input", clear pendingReady,
   // and flush any queued input. Idempotent: callers can invoke at any chunk.
@@ -1156,6 +1417,9 @@ var PTYManager = class {
     this.sessions.delete(sessionId);
     this.queuedInputs.delete(sessionId);
     this.firstChunkAt.delete(sessionId);
+    this.permissionOpen.delete(sessionId);
+    this.lastScreenQuestionKey.delete(sessionId);
+    this.shellPromptOpen.delete(sessionId);
   }
 };
 function toPublicSession(s) {
@@ -1830,6 +2094,10 @@ var createSessionRoutes = (deps) => {
     await deps.handleSendInput(c.req.param("id"), c.env.incoming, c.env.outgoing);
     return alreadyHandled6();
   });
+  app.post("/:id/answer", async (c) => {
+    await deps.handleSendAnswer(c.req.param("id"), c.env.incoming, c.env.outgoing);
+    return alreadyHandled6();
+  });
   app.post("/:id/files", async (c) => {
     await deps.handleUploadFile(c.req.param("id"), c.env.incoming, c.env.outgoing);
     return alreadyHandled6();
@@ -3452,6 +3720,129 @@ function pruneAgentConversations(cache) {
   return { scanned: rows.length, pruned, missing };
 }
 
+// src/services/questions/detectAskUserQuestion.ts
+function normalizeContent2(raw) {
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw === "string") return [{ type: "text", text: raw }];
+  return [];
+}
+function coerceOptions(raw) {
+  if (!Array.isArray(raw)) return null;
+  const out = [];
+  for (const o of raw) {
+    if (o && typeof o === "object" && typeof o.label === "string") {
+      const opt = o;
+      out.push({
+        label: opt.label,
+        description: typeof opt.description === "string" ? opt.description : "",
+        ...typeof opt.preview === "string" ? { preview: opt.preview } : {}
+      });
+    }
+  }
+  return out.length > 0 ? out : null;
+}
+function coerceQuestions(raw) {
+  if (!Array.isArray(raw)) return null;
+  const out = [];
+  for (const q of raw) {
+    if (!q || typeof q !== "object") continue;
+    const qq = q;
+    const options = coerceOptions(qq.options);
+    if (typeof qq.question !== "string" || !options) continue;
+    out.push({
+      question: qq.question,
+      header: typeof qq.header === "string" ? qq.header : "",
+      multiSelect: qq.multiSelect === true,
+      options
+    });
+  }
+  return out.length > 0 ? out : null;
+}
+function detectAskUserQuestion(rawLine) {
+  let parsed;
+  try {
+    parsed = JSON.parse(rawLine);
+  } catch {
+    return null;
+  }
+  const blocks = normalizeContent2(parsed.message?.content ?? parsed.content);
+  for (const b of blocks) {
+    if (b.type === "tool_use" && b.name === "AskUserQuestion" && typeof b.id === "string") {
+      const input = b.input;
+      const questions = coerceQuestions(input?.questions);
+      if (questions) return { toolUseId: b.id, questions };
+    }
+  }
+  return null;
+}
+
+// src/services/questions/questionBroadcast.ts
+function questionsFromLines(sessionId, lines) {
+  const messages = [];
+  const pending = [];
+  for (const line of lines) {
+    const detected = detectAskUserQuestion(line);
+    if (detected) {
+      messages.push({
+        type: "question",
+        sessionId,
+        toolUseId: detected.toolUseId,
+        questions: detected.questions
+      });
+      pending.push(detected);
+    }
+  }
+  return { messages, pending };
+}
+function shouldBroadcastQuestion(args) {
+  const alreadyShown = args.lastContentKey === args.newContentKey;
+  if (!alreadyShown) return true;
+  return args.priorToolUseId !== args.newToolUseId;
+}
+
+// src/services/questions/answersToKeystrokes.ts
+var DOWN = "\x1B[B";
+var ENTER2 = "\r";
+var UnknownOptionError = class extends Error {
+  constructor(question, value) {
+    super(`No option labelled "${value}" for question "${question}"`);
+    this.question = question;
+    this.value = value;
+    this.name = "UnknownOptionError";
+  }
+  question;
+  value;
+};
+function answersToKeystrokes(questions, answers) {
+  let out = "";
+  for (const q of questions) {
+    const raw = answers[q.question];
+    if (raw === void 0) {
+      throw new Error(`Missing answer for question "${q.question}"`);
+    }
+    const label = Array.isArray(raw) ? raw[0] : raw;
+    const target = q.options.findIndex((o) => o.label === label);
+    if (target < 0) throw new UnknownOptionError(q.question, label);
+    out += DOWN.repeat(target) + ENTER2;
+  }
+  return out;
+}
+
+// src/services/questions/resolveAnswer.ts
+function resolveAnswer(pending, body) {
+  if (!pending) return { ok: false, reason: "no_pending_question" };
+  if (typeof body.toolUseId !== "string" || body.toolUseId !== pending.toolUseId) {
+    return { ok: false, reason: "tool_use_mismatch" };
+  }
+  const answers = body.answers ?? {};
+  try {
+    return { ok: true, keys: answersToKeystrokes(pending.questions, answers) };
+  } catch (e) {
+    if (e instanceof UnknownOptionError) return { ok: false, reason: "unknown_option" };
+    throw e;
+  }
+}
+
 // src/session-store.ts
 var SessionStore = class {
   managed = /* @__PURE__ */ new Map();
@@ -3882,6 +4273,16 @@ var StreamerServer = class {
   fileWatcher;
   sessionFileMap = /* @__PURE__ */ new Map();
   // sessionId → JSONL filePath
+  pendingQuestions = /* @__PURE__ */ new Map();
+  // Content key of the AskUserQuestion currently broadcast for a session (from
+  // either the rendered screen or JSONL), used to de-dupe the two paths: when
+  // the screen detection fires first, the later JSONL flush of the same question
+  // is suppressed. Cleared alongside pendingQuestions.
+  pendingQuestionKey = /* @__PURE__ */ new Map();
+  // Per-session permission gate currently open (scraped via OSC 777). Parallel
+  // to pendingQuestions; mobile answers it by sending the option index via
+  // /input { keys }. Cleared when the gate closes.
+  pendingPermission = /* @__PURE__ */ new Map();
   scanner = null;
   scannerReady = null;
   // Set by onConversationChanged while a scan is in-flight; getScanner() does
@@ -3977,6 +4378,28 @@ var StreamerServer = class {
         this.cache?.updateFromLines(filePath, lines);
         for (const [sessionId, watchedPath] of this.sessionFileMap) {
           if (watchedPath === filePath) {
+            const priorToolUseId = this.pendingQuestions.get(sessionId)?.toolUseId;
+            const { messages, pending } = questionsFromLines(sessionId, lines);
+            for (const p of pending) {
+              this.pendingQuestions.set(sessionId, p);
+              const t = setTimeout(() => {
+                if (this.pendingQuestions.get(sessionId)?.toolUseId === p.toolUseId) {
+                  this.cancelPendingQuestion(sessionId);
+                }
+              }, 6e4);
+              t.unref();
+            }
+            for (const m of messages) {
+              const key = questionContentKey(m.questions);
+              const broadcast = shouldBroadcastQuestion({
+                newContentKey: key,
+                lastContentKey: this.pendingQuestionKey.get(sessionId),
+                newToolUseId: m.toolUseId,
+                priorToolUseId
+              });
+              this.pendingQuestionKey.set(sessionId, key);
+              if (broadcast) this.wsHub.broadcast(m);
+            }
             this.wsHub.broadcast({ type: "conversation_events", sessionId, lines });
             for (const line of lines) {
               this.wsHub.broadcast({ type: "conversation_event", sessionId, line });
@@ -4008,6 +4431,19 @@ var StreamerServer = class {
       onOutput: (sessionId, data) => {
         this.wsHub.broadcast({ type: "terminal_output", sessionId, data });
       },
+      onPermissionChange: (sessionId, gate) => {
+        this.handlePermissionChange(sessionId, gate);
+      },
+      onLiveQuestion: (sessionId, questions) => {
+        this.handleLiveQuestion(sessionId, questions);
+      },
+      onLiveQuestionGone: (sessionId) => {
+        this.pendingQuestionKey.delete(sessionId);
+        const pq = this.pendingQuestions.get(sessionId);
+        if (pq?.toolUseId.startsWith("screen:")) {
+          this.cancelPendingQuestion(sessionId);
+        }
+      },
       onReady: (session) => {
         const resp = this.sessionStore.get(session.id, this.ptyAttachedIds());
         if (resp) this.wsHub.broadcast({ type: "session_ready", session: resp });
@@ -4045,7 +4481,9 @@ var StreamerServer = class {
           if (filePath) {
             this.fileWatcher.unwatch(filePath);
             this.sessionFileMap.delete(session.id);
+            this.cancelPendingQuestion(session.id);
           }
+          this.pendingPermission.delete(session.id);
         }
         const resp = this.sessionStore.get(session.id, this.ptyAttachedIds());
         if (resp) {
@@ -4096,6 +4534,7 @@ var StreamerServer = class {
       handleGetSession: (id, res) => this.handleGetSession(id, res),
       handleGetOutput: (id, res) => this.handleGetOutput(id, res),
       handleSendInput: (id, req, res) => this.handleSendInput(id, req, res),
+      handleSendAnswer: (id, req, res) => this.handleSendAnswer(id, req, res),
       handleCancel: (id, res) => this.handleCancel(id, res),
       handleStopSession: (id, res) => this.handleStopSession(id, res),
       handleSetSessionName: (id, req, res) => this.handleSetSessionName(id, req, res),
@@ -4231,16 +4670,28 @@ var StreamerServer = class {
     if (existing) clearTimeout(existing);
     const timer = setTimeout(() => {
       this.ptyGraceTimers.delete(sessionId);
-      this.sessionSubscribers.delete(sessionId);
       if (this.ptyManager.hasSession(sessionId)) {
+        const resp = this.sessionStore.get(sessionId, this.ptyAttachedIds());
+        if (resp?.status === "running") {
+          this.log.info(
+            `[grace] session ${sessionId} still running, deferring hold`,
+            { sessionId, event: "pty.grace_defer" },
+            "pino"
+          );
+          this.startGraceTimer(sessionId, delayMs);
+          return;
+        }
+        this.sessionSubscribers.delete(sessionId);
         this.log.info(
           `[grace] killing idle PTY for ${sessionId}`,
           { sessionId, event: "pty.grace_kill" },
           "pino"
         );
         this.ptyManager.putOnHold(sessionId);
-        const resp = this.sessionStore.get(sessionId, this.ptyAttachedIds());
-        if (resp) this.wsHub.broadcast({ type: "session_update", session: resp });
+        const held = this.sessionStore.get(sessionId, this.ptyAttachedIds());
+        if (held) this.wsHub.broadcast({ type: "session_update", session: held });
+      } else {
+        this.sessionSubscribers.delete(sessionId);
       }
     }, delayMs);
     this.ptyGraceTimers.set(sessionId, timer);
@@ -4606,22 +5057,36 @@ var StreamerServer = class {
   async handleConversationsCount(url, res) {
     const project = url.searchParams.get("project") ?? void 0;
     const bustCache = url.searchParams.get("refresh") === "1";
-    if (bustCache) {
-      this.cache?.invalidate();
-      this.scanner = null;
-      this.scannerReady = null;
-    }
-    if (this.cache && !bustCache) {
+    if (this.cache) {
       const { total } = this.cache.listConversations({ project, limit: 0, offset: 0 });
       json(res, 200, { total });
+      if (bustCache) this.refreshCountInBackground();
       return;
     }
-    const scanner = await this.getScanner();
+    const scanner = await this.getScanner(true);
     let metas = [...scanner.getMetadataCache().values()];
     metas = applyIncludeFilter(metas, "conversations");
     if (project) metas = applyProjectFilter(metas, project);
     json(res, 200, { total: metas.length });
   }
+  // Fire-and-forget full rescan that reconciles the SQLite cache from disk so a
+  // later count reflects new/removed conversations. Never awaited by the request
+  // path — refresh=1 returns the cached total synchronously and this catches up.
+  refreshCountInBackground() {
+    void (async () => {
+      try {
+        const scanner = await this.getFreshScanner();
+        if (this.cache) {
+          this.cache.upsertFromScannerMeta([...scanner.getMetadataCache().values()]);
+        }
+      } catch (err) {
+        this.log.warn(
+          `Background count refresh failed: ${err instanceof Error ? err.message : String(err)}`,
+          { event: "count.refresh_failed" }
+        );
+      }
+    })();
+  }
   handleSessionsCount(res) {
     json(res, 200, { total: this.sessionStore.list(this.ptyAttachedIds()).length });
   }
@@ -5205,6 +5670,65 @@ var StreamerServer = class {
       json(res, 400, { error: message });
     }
   }
+  cancelPendingQuestion(sessionId) {
+    const pq = this.pendingQuestions.get(sessionId);
+    if (!pq) return;
+    this.pendingQuestions.delete(sessionId);
+    this.pendingQuestionKey.delete(sessionId);
+    this.wsHub.broadcast({ type: "question_cancelled", sessionId, toolUseId: pq.toolUseId });
+  }
+  // Live AskUserQuestion detected from the rendered screen (ahead of JSONL).
+  // Broadcasts the `question` event immediately and records the content key so
+  // the later JSONL flush of the same question is de-duped. We synthesize a
+  // screen-scoped toolUseId; the JSONL path overwrites pendingQuestions with the
+  // real toolUseId when it lands, so answering works once JSONL catches up.
+  handleLiveQuestion(sessionId, questions) {
+    const key = questionContentKey(questions);
+    if (this.pendingQuestionKey.get(sessionId) === key) return;
+    const toolUseId = `screen:${sessionId}:${key.length}`;
+    this.pendingQuestions.set(sessionId, { toolUseId, questions });
+    this.pendingQuestionKey.set(sessionId, key);
+    this.wsHub.broadcast({ type: "question", sessionId, toolUseId, questions });
+  }
+  // Permission gate opened/closed (OSC 777 + scraped options). Broadcasts the
+  // additive `permission` / `permission_cancelled` events. Mobile answers by
+  // sending the chosen option index via /input { keys } (e.g. "2\r").
+  handlePermissionChange(sessionId, gate) {
+    if (gate === null) {
+      if (!this.pendingPermission.has(sessionId)) return;
+      this.pendingPermission.delete(sessionId);
+      this.wsHub.broadcast({ type: "permission_cancelled", sessionId });
+      return;
+    }
+    this.pendingPermission.set(sessionId, gate);
+    this.wsHub.broadcast({
+      type: "permission",
+      sessionId,
+      ...gate.prompt ? { prompt: gate.prompt } : {},
+      options: gate.options,
+      ...gate.cursor !== void 0 ? { cursor: gate.cursor } : {}
+    });
+  }
+  async handleSendAnswer(sessionId, req, res) {
+    const body = await readBody(req);
+    const pending = this.pendingQuestions.get(sessionId);
+    const resolution = resolveAnswer(pending, body);
+    if (!resolution.ok) {
+      json(res, 400, { ok: false, reason: resolution.reason });
+      return;
+    }
+    const toolUseId = pending?.toolUseId ?? "";
+    try {
+      this.ptyManager.sendKeys(sessionId, resolution.keys);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to send answer";
+      json(res, 400, { ok: false, reason: message });
+      return;
+    }
+    this.pendingQuestions.delete(sessionId);
+    this.wsHub.broadcast({ type: "question_cancelled", sessionId, toolUseId });
+    json(res, 200, { ok: true });
+  }
   async handleUploadFile(sessionId, req, res) {
     const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
     if (!session) {