@quantiya/codevibe-antigravity-plugin 2.0.84 → 2.0.86

package/dist/server.js

@@ -32,6 +32,7 @@ var server_exports = {};
 __export(server_exports, {
   ApprovalDetector: () => ApprovalDetector,
   McpServer: () => McpServer,
+  PromptResponder: () => PromptResponder,
   SessionNotFoundError: () => SessionNotFoundError,
   StoredAuthFailureError: () => StoredAuthFailureError,
   TERMINAL_SHUTDOWN_SIGNALS: () => TERMINAL_SHUTDOWN_SIGNALS,
@@ -88,19 +89,19 @@ var os2 = __toESM(require("os"));
 var path2 = __toESM(require("path"));
 var HOOK_ENTRY_NAME = "codevibe-antigravity";
 var HOOK_ROUTE_PREFIX = "/agy-hook/v1/";
-var HOOK_EVENTS = ["PreInvocation", "PostToolUse"];
+var HOOK_EVENTS = ["PreInvocation", "PostToolUse", "PreToolUse", "Stop"];
 var HOOK_SHELL_BASENAME = "agy-hook.sh";
 var HOOK_SCRIPT_BASENAME = "agy-hook.js";
 function isHookEvent(value) {
   return typeof value === "string" && HOOK_EVENTS.includes(value);
 }
-function codevibeAgyDir(home = os2.homedir()) {
+function codevibeAgyDir(home = process.env.HOME || os2.homedir()) {
   return path2.join(home, ".codevibe", "codevibe-agy");
 }
-function hooksDir(home = os2.homedir()) {
+function hooksDir(home = process.env.HOME || os2.homedir()) {
   return path2.join(codevibeAgyDir(home), "hooks");
 }
-function globalHooksConfigPath(home = os2.homedir()) {
+function globalHooksConfigPath(home = process.env.HOME || os2.homedir()) {
   return path2.join(home, ".gemini", "config", "hooks.json");
 }
 
@@ -1987,7 +1988,7 @@ var ConversationRouter = class {
         dropped: entry.overflowed
       });
     }
-    if (decision) this.options.onRelease(entry.items, decision);
+    if (decision) this.options.onRelease(entry.items, decision, conversationId);
   }
   expire(conversationId) {
     const entry = this.held.get(conversationId);
@@ -2019,7 +2020,7 @@ var ConversationRouter = class {
       entry.items = entry.items.slice(tailStart);
       if (earlier.length > 0) {
         if (this.roles.get(conversationId) === "main" && !this.movedElsewhere(conversationId) && !entry.moved) {
-          this.options.onRelease(earlier, "process");
+          this.options.onRelease(earlier, "process", conversationId);
         } else {
           this.options.onLog?.("Dropping agy events held from an earlier turn of another session", {
             conversationId,
@@ -2224,6 +2225,14 @@ function buildHookEntry(hooksFolder) {
     PreInvocation: [
       { type: "command", command: `${shell} PreInvocation`, timeout: HOOK_TIMEOUT_SECONDS }
     ],
+    PreToolUse: [
+      {
+        matcher: "^(?:ask_question|question|ask)$",
+        hooks: [
+          { type: "command", command: `${shell} PreToolUse`, timeout: HOOK_TIMEOUT_SECONDS }
+        ]
+      }
+    ],
     PostToolUse: [
       {
         matcher: "*",
@@ -2231,6 +2240,9 @@ function buildHookEntry(hooksFolder) {
           { type: "command", command: `${shell} PostToolUse`, timeout: HOOK_TIMEOUT_SECONDS }
         ]
       }
+    ],
+    Stop: [
+      { type: "command", command: `${shell} Stop`, timeout: HOOK_TIMEOUT_SECONDS }
     ]
   };
 }
@@ -2913,6 +2925,7 @@ function isComposerBoxAt(lines, idx) {
   }
   return false;
 }
+var ANSI_ESCAPE_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
 function isPaneInputSafetyBlocked(input) {
   const rawText = Array.isArray(input) ? input.join("\n") : input;
   if (!rawText) return { blocked: false, kind: null };
@@ -3082,9 +3095,10 @@ function isPaneInputSafetyBlocked(input) {
   return { blocked: false, kind: null };
 }
 function looksLikePromptDelta(chunk) {
+  const text = chunk.includes("\x1B") ? chunk.replace(ANSI_ESCAPE_REGEX, "") : chunk;
   return (
     // Approval UI signatures
-    /Requesting permission for:/i.test(chunk) || /Do you want to proceed\?/i.test(chunk) || /\besc to cancel\b/i.test(chunk) || /^\s*[1-9]\. (?:Yes|No)\b/im.test(chunk) || /\[(?:y\/n|Y\/n|y\/N)\]/.test(chunk) || /^\s*(?:[❯>]\s*)?\?\s+(?!for\s+(?:shortcuts|help|commands))\S/im.test(chunk) || /Question\b(?:\s+\d+(?:[\/:of\s]+\d+)?)?:/i.test(chunk) || /\benter\s+(?:to\s+)?select\b/i.test(chunk) || /\b(?:navigate|use\s+arrow\s+keys)\b/i.test(chunk) || /^File access\s*$/im.test(chunk) || /^\s*Allow access to this file\?\s*$/im.test(chunk) || /(?:Yes, allow access|No, deny access)/i.test(chunk) || /(?:↑\/↓\s+Navigate|ctrl\+r\s+Review)/i.test(chunk) || /Our servers are experiencing/i.test(chunk) || /Error ID:\s*[0-9a-fA-F-]*/i.test(chunk) || /(?:⚠️|⚠\uFE0F?)\s+.*(?:high[- ]traffic|try again in a minute|try again later|stream was interrupted|stream interrupted|overloaded|unexpected error|quota\b|upgrade your subscription|increase your limits|resets in\s+\d|credits balance is too low|out of credits|rate[- ]limit|capacity exhausted|exhausted your quota|internal error|currently unreachable|network issue connecting|authentication expired|authentication issue|terminated due to error|invalid output|invalid tool call)/i.test(chunk)
+    /Requesting permission for:/i.test(chunk) || /Do you want to proceed\?/i.test(chunk) || /\besc to cancel\b/i.test(text) || /^\s*[1-9]\. (?:Yes|No)\b/im.test(text) || /\[(?:y\/n|Y\/n|y\/N)\]/.test(chunk) || /^\s*(?:[❯>]\s*)?\?\s+(?!for\s+(?:shortcuts|help|commands))\S/im.test(text) || /Question\b(?:\s+\d+(?:[\/:of\s]+\d+)?)?:/i.test(text) || /\benter\s+(?:to\s+)?(?:select|submit(?:\s+all)?|next)\b/i.test(text) || /\b(?:navigate|use\s+arrow\s+keys)\b/i.test(text) || /\b\d+[\/:of\s]+\d+:\s+\S/i.test(text) || /\bSubmit(?:\s+All)?\b/i.test(text) || /(?:^|[\s·|│])(?:←|<-)\s*Back\b/i.test(text) || /^File access\s*$/im.test(text) || /^\s*Allow access to this file\?\s*$/im.test(text) || /(?:Yes, allow access|No, deny access)/i.test(text) || /(?:↑\/↓\s+Navigate|ctrl\+r\s+Review)/i.test(text) || /Our servers are experiencing/i.test(text) || /Error ID:\s*[0-9a-fA-F-]*/i.test(text) || /(?:⚠️|⚠\uFE0F?)\s+.*(?:high[- ]traffic|try again in a minute|try again later|stream was interrupted|stream interrupted|overloaded|unexpected error|quota\b|upgrade your subscription|increase your limits|resets in\s+\d|credits balance is too low|out of credits|rate[- ]limit|capacity exhausted|exhausted your quota|internal error|currently unreachable|network issue connecting|authentication expired|authentication issue|terminated due to error|invalid output|invalid tool call)/i.test(text)
   );
 }
 function isNonSystemErrorWarningLine(trimmed) {
@@ -3159,7 +3173,7 @@ function isAgyStatusFooterLine(trimmed) {
   if (/^\s*(?:[❯>]\s*)?\?\s+for shortcuts\b/i.test(trimmed)) {
     return true;
   }
-  if (/^\s*esc to cancel\b/i.test(trimmed)) {
+  if (/^\s*esc to cancel/i.test(trimmed)) {
     return true;
   }
   if (/^(?:\(initializing\.\.\.\)|\d+\s+task\(s\)\s+·\s+\/tasks|\d+\s+subagent\s*\(s\)|AI:\s+(?:\d+\s+\(\/credits to add more\)|Out of credits)|AI Credits:\s+\d+|Quota:\s*\d+(?:\.\d+)?%)$/i.test(trimmed)) {
@@ -3258,7 +3272,7 @@ function reconstructFooter(rawLines) {
   }
   const hasMiddleDot = cleaned.some((l) => l.includes("\xB7"));
   const hasFooterKeyword = cleaned.some(
-    (l) => /^\s*(?:\?\s+for shortcuts|esc to cancel)\b/i.test(l) || /\b(?:auto|accept-edits|plan|Gemini|Claude|GPT|Gemma|high|low|subagent|quota|credits)\b/i.test(l)
+    (l) => /^\s*(?:\?\s+for shortcuts|esc to cancel)/i.test(l) || /\b(?:auto|accept-edits|plan|Gemini|Claude|GPT|Gemma|high|low|subagent|quota|credits)\b/i.test(l)
   );
   if (!hasMiddleDot && !hasFooterKeyword) {
     return cleaned.join(" ").replace(/\s*·\s*/g, " \xB7 ").trim();
@@ -3346,7 +3360,7 @@ function isSystemErrorActiveFromIndex(lines, errorIdx) {
           }
           if (remainingRaw.length <= 4) {
             const hasFooterMarkers = remainingRaw.some(
-              (l) => l.includes("\xB7") || /^\s*(?:\?\s+for shortcuts|esc to cancel)\b/i.test(l.trim()) || /\b(?:auto|accept-edits|plan|Gemini|Claude|GPT|Gemma|high|low|subagent|quota|credits)\b/i.test(l)
+              (l) => l.includes("\xB7") || /^\s*(?:\?\s+for shortcuts|esc to cancel)/i.test(l.trim()) || /\b(?:auto|accept-edits|plan|Gemini|Claude|GPT|Gemma|high|low|subagent|quota|credits)\b/i.test(l)
             );
             if (hasFooterMarkers) {
               const reconstructed = reconstructFooter(remainingRaw);
@@ -3382,7 +3396,7 @@ function isLegacyYNActiveInLines(lines) {
     const trimmed = lines[j].trim();
     if (!trimmed) continue;
     if (/^[─━│╭╰╮╯\s_-]*$/.test(trimmed)) continue;
-    if (/^\s*(?:\?\s+for shortcuts|esc to cancel)\b/i.test(trimmed)) continue;
+    if (/^\s*(?:\?\s+for shortcuts|esc to cancel)/i.test(trimmed)) continue;
     return { active: false, lineIdx: -1 };
   }
   return { active: true, lineIdx: ynIdx };
@@ -3513,7 +3527,7 @@ function extractFileAccessPrompt(snapshot) {
       headingIndex = index;
       break;
     }
-    if (/^[─━│╭╰╮╯\s_-]*$/.test(line) || /^[│\s]*[❯>]\s+\S/.test(line) || /^\s*(?:Requesting permission for:|Question \d+\/\d+:|Allow access to this file\?|Do you want to proceed\?)/i.test(line) || /^[▶▸\s]*Thought|^●\s*/i.test(line) || /^\s*(?:\?\s+for shortcuts|esc to cancel)\b/i.test(line) || /^\s*(?:[↑↓/\s]*Navigate\b|ctrl\+r\s+Review\b)/i.test(line)) {
+    if (/^[─━│╭╰╮╯\s_-]*$/.test(line) || /^[│\s]*[❯>]\s+\S/.test(line) || /^\s*(?:Requesting permission for:|Question \d+\/\d+:|Allow access to this file\?|Do you want to proceed\?)/i.test(line) || /^[▶▸\s]*Thought|^●\s*/i.test(line) || /^\s*(?:\?\s+for shortcuts|esc to cancel)/i.test(line) || /^\s*(?:[↑↓/\s]*Navigate\b|ctrl\+r\s+Review\b)/i.test(line)) {
       break;
     }
     break;
@@ -4205,7 +4219,7 @@ function isQuestionFooterLine(line) {
   }
   if (/^[>\s❯]*[1-9][.)]\s+\S/.test(trimmed)) return false;
   if (isQuestionHeaderLine(trimmed)) return false;
-  return /^(?:esc|<esc>)\s+(?:to\s+)?(?:cancel|skip)(?:\s*[·│,]\s*(?:enter|<enter>)\s+(?:to\s+)?select)?(?:\s*[·│,]\s*ctrl\+[a-z0-9]+\s+[a-zA-Z]+)*$/i.test(trimmed) || /^(?:enter|<enter>)\s+(?:to\s+)?select(?:\s*[·│,]\s*(?:esc|<esc>)\s+(?:to\s+)?(?:cancel|skip))?(?:\s*[·│,]\s*ctrl\+[a-z0-9]+\s+[a-zA-Z]+)*$/i.test(trimmed) || /^(?:↑\/↓|↑|↓|\^|v)\s*(?:\/|\s+)?Navigate(?:\s*[·│,]\s*(?:enter|<enter>)?\s*(?:Select|to select))(?:\s*[·│,]\s*(?:esc|<esc>)?\s*(?:Skip|Cancel))?(?:\s*[·│,]\s*ctrl\+[a-z0-9]+\s+[a-zA-Z]+)*$/i.test(trimmed) || /^(?:↑\/↓|↑|↓|\^|v)\s*(?:\/|\s+)?Navigate(?:\s*[·│,]\s*(?:esc|<esc>)?\s*(?:Skip|Cancel))?$/i.test(trimmed) || /^press\s+<?(?:enter|return|space)>?\s+to\s+select$/i.test(trimmed) || /^space\s+to\s+select$/i.test(trimmed) || /^(?:\(?use\s+arrow\s+keys(?:\s+to\s+navigate)?\)?)$/i.test(trimmed) || /^(?:[\u2800-\u28FF]+(?:\s*waiting(?:\.\.\.)?)?|waiting(?:\.\.\.)?)$/i.test(trimmed);
+  return /^(?:esc|<esc>)\s+(?:to\s+)?(?:cancel|skip)(?:\s*[·│,]\s*(?:enter|<enter>)\s+(?:to\s+)?(?:select|submit(?:\s+all)?))?(?:\s*[·│,]\s*ctrl\+[a-z0-9]+\s+[a-zA-Z]+)*$/i.test(trimmed) || /^(?:enter|<enter>)\s+(?:to\s+)?(?:select|submit(?:\s+all)?)(?:\s*[·│,]\s*(?:esc|<esc>)\s+(?:to\s+)?(?:cancel|skip|back))?(?:\s*[·│,]\s*ctrl\+[a-z0-9]+\s+[a-zA-Z]+)*$/i.test(trimmed) || /^(?:space|<space>)\s+(?:to\s+)?(?:select|toggle)(?:\s*[·│,]\s*(?:enter|<enter>)\s+(?:to\s+)?(?:select|submit(?:\s+all)?))?(?:\s*[·│,]\s*(?:esc|<esc>)\s+(?:to\s+)?(?:cancel|skip|back))?$/i.test(trimmed) || /^(?:↑\/↓|↑|↓|\^|v)\s*(?:\/|\s+)?Navigate(?:\s*[·│,]\s*(?:(?:→|->)\s*Next|(?:←|<-)\s*Back))*(?:\s*[·│,]\s*(?:enter|<enter>)?\s*(?:Select|Submit(?:\s+All)?|to select))(?:\s*[·│,]\s*(?:esc|<esc>)?\s*(?:Skip|Cancel|Back))?(?:\s*[·│,]\s*(?:(?:→|->)\s*Next|(?:←|<-)\s*Back))*(?:\s*[·│,]\s*ctrl\+[a-z0-9]+\s+[a-zA-Z]+)*$/i.test(trimmed) || /^(?:↑\/↓|↑|↓|\^|v)\s*(?:\/|\s+)?Navigate(?:\s*[·│,]\s*(?:esc|<esc>)?\s*(?:Skip|Cancel|Back))?$/i.test(trimmed) || /^(?:←|<-)\s*Back\s*[·│,]\s*(?:enter|<enter>)\s+(?:to\s+)?(?:select|submit(?:\s+all)?)(?:\s*[·│,]\s*(?:esc|<esc>)\s+(?:to\s+)?(?:cancel|skip))?$/i.test(trimmed) || /^press\s+<?(?:enter|return|space)>?\s+to\s+select$/i.test(trimmed) || /^space\s+to\s+select$/i.test(trimmed) || /^(?:\(?use\s+arrow\s+keys(?:\s+to\s+navigate)?\)?)$/i.test(trimmed) || /^(?:[\u2800-\u28FF]+(?:\s*waiting(?:\.\.\.)?)?|waiting(?:\.\.\.)?)$/i.test(trimmed);
 }
 function extractQuestionHeader(snapshot) {
   const stripped = snapshot.replace(ANSI_ESCAPE_REGEX, "");
@@ -4231,7 +4245,6 @@ function hashPromptSnapshot(snapshot) {
   }
   return (0, import_crypto.createHash)("sha256").update(normalized).digest("hex");
 }
-var ANSI_ESCAPE_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
 function escapeShellArg(value) {
   return value.replace(/'/g, `'\\''`);
 }
@@ -4247,7 +4260,7 @@ function isQuestionUISnapshot(snapshot) {
 
 // src/approval-detector.ts
 var import_events3 = require("events");
-var import_uuid = require("uuid");
+var import_uuid2 = require("uuid");
 
 // src/prompt-parser.ts
 var import_crypto2 = require("crypto");
@@ -4276,17 +4289,17 @@ function parseApprovalSnapshot(snapshot) {
   return parseApprovalUISnapshot(stripped, snapshot);
 }
 function buildApprovalSemanticKey(candidate) {
-  const normalize = (value) => value.replace(/\s+/g, " ").trim();
+  const normalize = (value) => (value ?? "").replace(/\s+/g, " ").trim();
   const payload = {
     kind: candidate.kind,
     headerText: normalize(candidate.headerText),
     body: normalize(candidate.body),
-    options: candidate.options.map((option) => ({
+    options: (candidate.options ?? []).map((option) => ({
       number: option.number,
       text: normalize(option.text)
     })),
     submitMap: Object.fromEntries(
-      Object.entries(candidate.submitMap).sort(([left], [right]) => Number(left) - Number(right)).map(([number, keys]) => [number, [...keys]])
+      Object.entries(candidate.submitMap ?? {}).sort(([left], [right]) => Number(left) - Number(right)).map(([number, keys]) => [number, [...keys]])
     )
   };
   return (0, import_crypto2.createHash)("sha256").update(JSON.stringify(payload)).digest("hex");
@@ -4376,33 +4389,8 @@ function parseQuestionSnapshot(stripped, originalSnapshot, header) {
   const options = parseOptions(belowHeader);
   if (options.length < 2) return null;
   const normalizedHeader = header.fullLine.replace(/^[❯>\s*•-]+\s*/, "").trim();
-  const headerHasArrowHint = /\((?:Use\s+arrow\s+keys|Use\s+\S+\s+keys)[^)]*\)/i.test(normalizedHeader);
-  let footerHasArrowHint = false;
-  let footerHasCtrlRReview = false;
-  const startLine = headerIdx >= 0 ? headerIdx + 1 : 0;
-  let hasSeenOptions = false;
-  for (let i = startLine; i < lines.length; i++) {
-    if (lineInFence[i]) continue;
-    const trimmed = lines[i].trim();
-    if (!trimmed) continue;
-    if (hasSeenOptions && isResumedTurnSignal(trimmed)) break;
-    if (/^[>\s❯]*[1-9][.)]\s+\S/.test(trimmed)) {
-      hasSeenOptions = true;
-    }
-    const isFooter = isQuestionFooterLine(trimmed) || /^(?:ctrl\+[a-z0-9]+\s+[a-zA-Z]+|\(?use\s+arrow\s+keys(?:\s+to\s+navigate)?\)?)$/i.test(trimmed);
-    if (isFooter) {
-      if (/(?:↑\/↓|↑|↓|\^|v)\s*(?:\/|\s+)?Navigate\b/i.test(trimmed) || /\(?use\s+arrow\s+keys(?:\s+to\s+navigate)?\)?/i.test(trimmed)) {
-        footerHasArrowHint = true;
-      }
-      if (/ctrl\+r\s+Review\b/i.test(trimmed)) {
-        footerHasCtrlRReview = true;
-      }
-    }
-  }
-  const hasArrowKeyHint = headerHasArrowHint || footerHasArrowHint;
-  const hasWriteInOption = options.some((opt) => /^\s*write-?in\b/i.test(opt.text));
-  const hasCtrlRReviewFooter = footerHasCtrlRReview;
-  const isBaseNumberedWizard = /^Question\s+\d+\/\d+:/i.test(normalizedHeader) && !hasArrowKeyHint && !hasWriteInOption && !hasCtrlRReviewFooter;
+  const isMultiSelect = /\bselect\s+(?:all|multiple)\b/i.test(normalizedHeader) || /\bselect\s+(?:all|multiple)\b/i.test(belowHeader) || /(?:<space>|\bspace)\s+(?:to\s+)?(?:select|toggle)\b/i.test(belowHeader) || /\bctrl\+a\s+select\s+all\b/i.test(belowHeader);
+  const isBaseNumberedWizard = /^Question\s+\d+\/\d+:/i.test(normalizedHeader) && !isMultiSelect;
   const submitMap = isBaseNumberedWizard ? buildQuestionSubmitMap(options) : {};
   const body = extractBodyBetweenHeaderAndFirstOption(belowHeader);
   return {
@@ -4465,12 +4453,47 @@ function buildApprovalSubmitMap(options) {
 function buildQuestionSubmitMap(options) {
   const map = {};
   for (const opt of options) {
-    if (!/^\s*write-?in\b/i.test(opt.text)) {
-      map[opt.number] = [opt.number, "Enter"];
-    }
+    map[opt.number] = [opt.number];
   }
   return map;
 }
+function isWriteInInputActive(paneText, expectedHeader, expectedStep) {
+  if (!paneText) return false;
+  if (detectActivePromptKind(paneText) !== "question") return false;
+  const stripped = paneText.replace(ANSI_ESCAPE_REGEX2, "");
+  const lines = stripped.trimEnd().split("\n");
+  const windowStart = Math.max(0, lines.length - 30);
+  let headerIdx = -1;
+  for (let i = lines.length - 1; i >= windowStart; i--) {
+    if (isQuestionHeaderLine(lines[i])) {
+      headerIdx = i;
+      break;
+    }
+  }
+  if (headerIdx < 0) return false;
+  const rawHeader = lines[headerIdx];
+  const extracted = extractQuestionHeader(rawHeader);
+  if (!extracted) return false;
+  if (expectedHeader) {
+    const expectedExtracted = extractQuestionHeader(expectedHeader);
+    const expectedBody = (expectedExtracted ? expectedExtracted.body : expectedHeader).replace(/^[❯>\s*•-]+\s*/, "").trim().toLowerCase();
+    const paneBody = extracted.body.replace(/^[❯>\s*•-]+\s*/, "").trim().toLowerCase();
+    if (paneBody !== expectedBody) {
+      return false;
+    }
+  }
+  const expectedStepVal = expectedStep || (expectedHeader ? expectedHeader.match(/\bQuestion\s+(\d+(?:[\/:of\s]+\d+)?):/i)?.[1] : void 0);
+  if (expectedStepVal) {
+    const stepMatch = extracted.fullLine.match(/\bQuestion\s+(\d+(?:[\/:of\s]+\d+)?):/i);
+    const paneStep = stepMatch ? stepMatch[1] : null;
+    if (!paneStep || paneStep !== expectedStepVal) {
+      return false;
+    }
+  }
+  const searchLines = lines.slice(headerIdx);
+  const text = searchLines.join("\n");
+  return /Your answer:/i.test(text) && /enter\s+Submit(?:\s+All)?\s*[·│,]\s*esc\s+Back/i.test(text);
+}
 function extractIdentity(headerText) {
   if (!headerText) return {};
   const trimmed = headerText.trim();
@@ -4561,1428 +4584,2096 @@ function stripAnsi(s) {
   return s.replace(ANSI_ESCAPE_REGEX2, "");
 }
 
-// src/approval-detector.ts
-var DEFAULT_PROMPT_TTL_MS = 6e4;
-var PENDING_CALL_TTL_MS = 5 * 6e4;
-var SWEEP_INTERVAL_MS = 3e4;
-var PASS3_MIN_IDENTITY_LEN = 4;
-var PENDING_CANDIDATE_BUFFER_MS = 5e3;
-var ApprovalDetector = class extends import_events3.EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.pendingCalls = /* @__PURE__ */ new Map();
-    this.pendingPrompts = /* @__PURE__ */ new Map();
-    /** Track recently-resolved promptIds so a duplicate candidate-emit
-     *  doesn't re-fire INTERACTIVE_PROMPT. Maps promptId → ms-epoch when
-     *  resolved. Pruned by sweep. */
-    this.resolvedPrompts = /* @__PURE__ */ new Map();
-    /** Pre-transcript candidate buffer keyed by `${conversationId}|${paneHash}`
-     *  (composite key prevents collision when two conversations on the same
-     *  tmux pane produce identical paneHashes — agy R2 Stage 2 round-3 MED).
-     *  When a candidate arrives with no matching pending call, we park it
-     *  here for pendingCandidateBufferMs and re-try the match each time
-     *  registerPendingCall fires. */
-    this.pendingCandidates = /* @__PURE__ */ new Map();
-    this.sweepTimer = null;
-    // ─── Pane-only prompt emission (v9.1 — bypasses pending-call match) ─────
-    /** Set of pane-snapshot hashes we've already emitted INTERACTIVE_PROMPT
-     *  for. Belt-and-suspenders dedupe against the case where paneObserver
-     *  somehow re-fires `prompt-candidate` with the same snapshot bytes
-     *  for the same prompt. The primary dedupe for cosmetic redraws of a
-     *  single approval (spinner ticks, cursor blink, partial repaints)
-     *  lives in tmux-pane-observer's debounce window — by the time a
-     *  candidate reaches this layer, the pane has settled. */
-    this.paneOnlyEmittedHashes = /* @__PURE__ */ new Set();
-    this.promptTtlMs = options.promptTtlMs ?? DEFAULT_PROMPT_TTL_MS;
-    this.pendingCallTtlMs = options.pendingCallTtlMs ?? PENDING_CALL_TTL_MS;
-    this.sweepIntervalMs = options.sweepIntervalMs ?? SWEEP_INTERVAL_MS;
-    this.pendingCandidateBufferMs = options.pendingCandidateBufferMs ?? PENDING_CANDIDATE_BUFFER_MS;
-  }
-  start() {
-    if (this.sweepTimer) return;
-    this.sweepTimer = setInterval(() => this.sweep(), this.sweepIntervalMs);
-    if (this.sweepTimer.unref) this.sweepTimer.unref();
-    logger.info("Approval detector started", {
-      promptTtlMs: this.promptTtlMs,
-      pendingCallTtlMs: this.pendingCallTtlMs
-    });
-  }
-  async stop() {
-    if (this.sweepTimer) {
-      clearInterval(this.sweepTimer);
-      this.sweepTimer = null;
-    }
-    this.pendingCalls.clear();
-    this.pendingPrompts.clear();
-    this.resolvedPrompts.clear();
-    this.pendingCandidates.clear();
-    this.paneOnlyEmittedHashes.clear();
-    logger.info("Approval detector stopped");
-  }
-  /**
-   * Emit INTERACTIVE_PROMPT directly from a pane snapshot, WITHOUT
-   * requiring a matching PendingToolCall from a transcript PLANNER_RESPONSE.
-   *
-   * Background (v9.1, 2026-05-21): agy does NOT write tool_call entries
-   * to the transcript BEFORE rendering the approval UI for shell
-   * commands. It only writes them AFTER the user approves. So the
-   * transcript-based pending-call matching path deadlocks for shell
-   * commands: paneObserver sees the UI, but no pending call exists →
-   * candidate buffered → user can't approve from mobile (no prompt
-   * shown) → no transcript write → buffer expires.
-   *
-   * Solution: pane is authoritative for "approval UI is showing right
-   * now." Skip the pending-call requirement and emit directly. The
-   * parsed candidate has everything needed (command, options, submitMap).
-   *
-   * Synthesizes a minimal PendingToolCall from the candidate so the
-   * existing handlePendingPrompt code path doesn't need to branch on
-   * `pendingCall: null`.
-   *
-   * Returns the emitted state, or null if dedupe (already emitted for
-   * this paneHash) or disabled.
-   */
-  emitPaneOnlyPrompt(candidate, conversationId, forcedPromptId) {
-    if (this.paneOnlyEmittedHashes.has(candidate.paneHash)) {
-      logger.debug("Skipping pane-only re-emit for duplicate paneHash", {
-        paneHash: candidate.paneHash.substring(0, 16)
+// src/event-mapper.ts
+var import_uuid = require("uuid");
+var import_codevibe_core5 = require("@quantiya/codevibe-core");
+var CONTENT_MAX = 150 * 1024;
+var TOOL_OUTPUT_MAX = 50 * 1024;
+var TOOL_DIFF_MAX = 100 * 1024;
+function mapTranscriptEvent(emit, sessionId, notBeforeMs) {
+  const { event } = emit;
+  const base = {
+    sessionId,
+    source: import_codevibe_core5.EventSource.DESKTOP
+  };
+  const orderingKey = `${sessionId}:${emit.conversationId}`;
+  const nextTimestamp = () => (0, import_codevibe_core5.prepareEventTimestamp)({ orderingKey, agentClock: event.created_at, notBeforeMs });
+  const baseMetadata = {
+    step_index: event.step_index,
+    agy_source: event.source,
+    agy_status: event.status,
+    agy_created_at: event.created_at,
+    agy_type: event.type,
+    agy_conversation_id: emit.conversationId
+  };
+  if (event.source === "SYSTEM") {
+    if (event.type === "CONVERSATION_HISTORY" || event.type === "SYSTEM_MESSAGE") {
+      logger.debug("Dropping internal transcript event", {
+        type: event.type,
+        stepIndex: event.step_index
       });
-      return null;
+      return { events: [], pendingCallRegistrations: [] };
     }
-    const promptId = forcedPromptId ?? (0, import_uuid.v4)();
-    const matchingCall = candidate.kind === "question" ? this.findMatchingPendingCall(candidate, conversationId) : null;
-    if (matchingCall) {
-      matchingCall.matchedPromptId = promptId;
+    if (event.type !== "ERROR_MESSAGE") {
+      logger.warn("Dropping unknown SYSTEM-source transcript event (safety)", {
+        type: event.type,
+        stepIndex: event.step_index
+      });
+      return { events: [], pendingCallRegistrations: [] };
     }
-    const syntheticCall = {
-      conversationId,
-      intentStepIndex: matchingCall?.intentStepIndex ?? -1,
-      // sentinel: "no transcript origin"
-      toolCallIndex: matchingCall?.toolCallIndex ?? 0,
-      intentByteOffset: matchingCall?.intentByteOffset ?? 0,
-      // Best-effort tool-type inference from the candidate. For shell
-      // commands → RUN_COMMAND. For edit-style headers with a file
-      // path → CODE_ACTION. For questions → ASK_QUESTION. Default: GENERIC.
-      toolType: matchingCall?.toolType ?? guessToolTypeFromIdentity(candidate),
-      command: matchingCall?.command ?? candidate.command,
-      filePath: matchingCall?.filePath ?? candidate.filePath,
-      rawToolName: matchingCall?.rawToolName ?? (candidate.kind === "question" ? "ask_question" : candidate.command ?? candidate.filePath ?? "unknown"),
-      questionText: candidate.kind === "question" && candidate.headerText ? candidate.headerText : matchingCall?.questionText,
-      // NOTE (Codex R3-F1 / Claude R3-F2): Pane options are authoritative ground truth
-      // that directly correspond to desktop keystrokes (submitMap). Transcript options
-      // serve solely as fallback when pane options cannot be parsed.
-      questionOptions: candidate.kind === "question" && candidate.options && candidate.options.length > 0 ? candidate.options : matchingCall?.questionOptions,
-      promptId,
-      startedAt: matchingCall?.startedAt ?? Date.now(),
-      intentCreatedAt: matchingCall?.intentCreatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const state = {
-      promptId,
-      conversationId,
-      pendingCall: syntheticCall,
-      submitMap: candidate.submitMap,
-      matchedPaneHeader: candidate.headerText,
-      paneDisplayHeader: candidate.fullHeaderLine,
-      body: candidate.body,
-      paneOptions: candidate.options,
-      paneSemanticKey: buildApprovalSemanticKey(candidate),
-      kind: candidate.kind,
-      emittedAt: Date.now(),
-      ttlMs: this.promptTtlMs,
-      // E1 (§6a-2b / F5) — carry the consumed pane hash so an emit-failure
-      // rollback can reset the observer's lastPromptHash and let the unchanged
-      // live pane re-emit.
-      paneHash: candidate.paneHash
-    };
-    this.pendingPrompts.set(promptId, state);
-    this.paneOnlyEmittedHashes.add(candidate.paneHash);
-    logger.info("Emitting pane-only INTERACTIVE_PROMPT", {
-      promptId,
-      command: candidate.command,
-      filePath: candidate.filePath,
-      optionsCount: candidate.options.length
+  }
+  if (event.type === "CONVERSATION_HISTORY" || event.type === "SYSTEM_MESSAGE") {
+    logger.debug("Dropping internal transcript event (non-SYSTEM source)", {
+      type: event.type,
+      source: event.source,
+      stepIndex: event.step_index
     });
-    this.emit("pending-prompt", state);
-    return state;
+    return { events: [], pendingCallRegistrations: [] };
   }
-  // ─── Pending-call registration (called from event-mapper hook) ──────────
-  /**
-   * Register a tool-call intent from a PLANNER_RESPONSE.tool_calls[].
-   * Indexed by composite key so agy rollback (which can replay
-   * step_index values) doesn't cause collisions.
-   */
-  registerPendingCall(call) {
-    const key = this.callKey(call);
-    if (this.pendingCalls.has(key)) {
-      logger.debug("Pending call already registered, skipping", {
-        key,
-        intentStepIndex: call.intentStepIndex,
-        toolType: call.toolType
+  if (event.type === "USER_INPUT") {
+    const cleaned = stripUserRequestWrapper(event.content || "");
+    return {
+      events: [
+        {
+          ...base,
+          timestamp: nextTimestamp(),
+          type: import_codevibe_core5.EventType.USER_PROMPT,
+          content: truncate(cleaned, CONTENT_MAX),
+          metadata: { ...baseMetadata }
+        }
+      ],
+      pendingCallRegistrations: []
+    };
+  }
+  if (event.type === "PLANNER_RESPONSE") {
+    const events = [];
+    const pendingCallRegistrations = [];
+    if (typeof event.thinking === "string" && event.thinking.trim().length > 0) {
+      events.push({
+        ...base,
+        timestamp: nextTimestamp(),
+        type: import_codevibe_core5.EventType.REASONING,
+        content: truncate(event.thinking, CONTENT_MAX),
+        metadata: { ...baseMetadata }
       });
-      return;
     }
-    this.pendingCalls.set(key, call);
-    logger.debug("Pending tool call registered", {
-      key,
-      toolType: call.toolType,
-      command: call.command,
-      filePath: call.filePath
-    });
-    this.drainBufferedCandidates(call.conversationId);
-  }
-  drainBufferedCandidates(conversationId) {
-    if (this.pendingCandidates.size === 0) return;
-    const now = Date.now();
-    for (const [key, buffered] of this.pendingCandidates.entries()) {
-      if (buffered.conversationId !== conversationId) continue;
-      if (now - buffered.queuedAt > this.pendingCandidateBufferMs) {
-        this.pendingCandidates.delete(key);
-        continue;
-      }
-      const state = this.matchCandidateInternal(buffered.candidate, buffered.conversationId);
-      if (state) {
-        this.pendingCandidates.delete(key);
-        logger.info("Drained buffered candidate after pending-call arrived", {
-          key,
-          ageMs: now - buffered.queuedAt
+    if (typeof event.content === "string" && event.content.trim().length > 0) {
+      events.push({
+        ...base,
+        timestamp: nextTimestamp(),
+        type: import_codevibe_core5.EventType.ASSISTANT_RESPONSE,
+        content: truncate(event.content, CONTENT_MAX),
+        metadata: { ...baseMetadata }
+      });
+    }
+    const toolCalls = event.tool_calls;
+    if (Array.isArray(toolCalls)) {
+      for (let i = 0; i < toolCalls.length; i++) {
+        const tc = toolCalls[i];
+        if (!tc || typeof tc !== "object") continue;
+        const name = tc.name;
+        if (typeof name !== "string") continue;
+        const args = tc.args;
+        pendingCallRegistrations.push({
+          intentStepIndex: event.step_index,
+          toolCallIndex: i,
+          intentByteOffset: emit.byteOffset,
+          toolType: hookToolNameToTranscriptType(name),
+          conversationId: emit.conversationId,
+          command: extractCommandFromArgs(name, args),
+          filePath: extractFilePathFromArgs(name, args),
+          questionText: extractQuestionFromArgs(name, args),
+          questionOptions: extractQuestionOptionsFromArgs(name, args),
+          cwd: extractCwdFromArgs(args),
+          rawToolName: name,
+          startedAt: Date.now(),
+          intentCreatedAt: event.created_at
         });
       }
     }
+    return { events, pendingCallRegistrations };
   }
-  /** Composite key for the pre-transcript buffer. Scoping by
-   *  conversationId prevents the collision case where two simultaneous
-   *  conversations on the same tmux pane (contract-discouraged but not
-   *  contract-impossible) produce identical paneHashes — without
-   *  conversation scoping, conv-B's candidate would be silently dropped
-   *  at the same-key dedupe check. (agy R2 Stage 2 round-3 MED finding
-   *  2026-05-20.) */
-  candidateKey(conversationId, paneHash) {
-    return `${conversationId}|${paneHash}`;
+  if (event.type === "ERROR_MESSAGE") {
+    const content = stripTimestampPrefix(event.content || "Agy error");
+    return {
+      events: [
+        {
+          ...base,
+          timestamp: nextTimestamp(),
+          type: import_codevibe_core5.EventType.NOTIFICATION,
+          content: truncate(content, CONTENT_MAX),
+          metadata: {
+            ...baseMetadata,
+            severity: "error"
+          }
+        }
+      ],
+      pendingCallRegistrations: []
+    };
   }
-  /**
-   * Clear a pending call when its matching RESULT event arrives in the
-   * transcript. event-mapper.ts calls this from its tool-result handlers.
-   *
-   * The result event's step_index = intentStepIndex + toolCallIndex + 1
-   * per agy R2 v2 (the deterministic correlation formula). We try to
-   * match by (conversationId, expected step_index, toolType) — when one
-   * matches, clear it. If multiple pending calls match (rollback edge),
-   * clear the earliest by intentStepIndex.
-   */
-  clearOnResultEvent(args) {
-    let matched = null;
-    let matchedKey = null;
-    for (const [key, call] of this.pendingCalls.entries()) {
-      if (call.conversationId !== args.conversationId) continue;
-      if (args.toolType !== "GENERIC" && call.toolType !== args.toolType) continue;
-      const expected = call.intentStepIndex + call.toolCallIndex + 1;
-      if (expected !== args.resultStepIndex) continue;
-      if (typeof args.resultByteOffset === "number") {
-        if (call.intentByteOffset >= args.resultByteOffset) continue;
-        if (!matched || call.intentByteOffset > matched.intentByteOffset) {
-          matched = call;
-          matchedKey = key;
+  const toolName = transcriptTypeToFriendlyToolName(event.type);
+  const isErrorStatus = event.status === "ERROR";
+  const rawContent = stripTimestampPrefix(event.content || "");
+  const truncatedContent = truncate(rawContent, TOOL_OUTPUT_MAX);
+  return {
+    events: [
+      {
+        ...base,
+        timestamp: nextTimestamp(),
+        type: import_codevibe_core5.EventType.TOOL_USE,
+        content: formatToolResultContent(event.type, toolName, truncatedContent, isErrorStatus),
+        metadata: {
+          ...baseMetadata,
+          tool_name: toolName,
+          tool_output: truncatedContent,
+          success: !isErrorStatus
         }
-      } else if (!matched || call.intentStepIndex < matched.intentStepIndex) {
-        matched = call;
-        matchedKey = key;
       }
+    ],
+    pendingCallRegistrations: []
+  };
+}
+function stripUserRequestWrapper(content) {
+  const match = content.match(/<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/);
+  if (match && match[1] !== void 0) {
+    return match[1].trim();
+  }
+  return content.trim();
+}
+function stripTimestampPrefix(content) {
+  return content.replace(
+    /^Created At:[^\n]*\nCompleted At:[^\n]*\n+(?:\s*\n)?/,
+    ""
+  ).trim();
+}
+function transcriptTypeToFriendlyToolName(type) {
+  switch (type) {
+    case "RUN_COMMAND":
+      return "Bash";
+    case "LIST_DIRECTORY":
+      return "LS";
+    case "GREP_SEARCH":
+      return "Grep";
+    case "VIEW_FILE":
+      return "Read";
+    case "CODE_ACTION":
+      return "Edit";
+    case "SEARCH_WEB":
+      return "WebSearch";
+    case "GENERIC":
+      return "Other";
+    default:
+      return "Other";
+  }
+}
+function hookToolNameToTranscriptType(hookName) {
+  const upper = hookName.toUpperCase();
+  switch (upper) {
+    case "LIST_DIR":
+      return "LIST_DIRECTORY";
+    case "REPLACE_FILE_CONTENT":
+    case "MULTI_REPLACE_FILE_CONTENT":
+    case "WRITE_TO_FILE":
+      return "CODE_ACTION";
+    case "GENERATE_IMAGE":
+    case "READ_URL_CONTENT":
+    case "INVOKE_SUBAGENT":
+    case "DEFINE_SUBAGENT":
+    case "MANAGE_SUBAGENTS":
+    case "SEND_MESSAGE":
+    case "LIST_PERMISSIONS":
+    case "MANAGE_TASK":
+    case "SCHEDULE":
+    case "ASK_PERMISSION":
+      return "GENERIC";
+    case "ASK_QUESTION":
+      return "ASK_QUESTION";
+    default:
+      return upper;
+  }
+}
+function extractCommandFromArgs(toolName, args) {
+  if (!args || typeof args !== "object") return void 0;
+  const a = args;
+  for (const key of ["CommandLine", "Command", "command", "cmd", "exec"]) {
+    const v = a[key];
+    if (typeof v === "string" && v.trim().length > 0) {
+      return stripWrappingQuotes2(v.trim());
     }
-    if (matched && matchedKey) {
-      matched.resultStepIndex = args.resultStepIndex;
-      this.pendingCalls.delete(matchedKey);
-      if (matched.promptId) {
-        this.resolvedPrompts.set(matched.promptId, Date.now());
-        this.pendingPrompts.delete(matched.promptId);
+  }
+  return void 0;
+}
+function extractFilePathFromArgs(toolName, args) {
+  if (!args || typeof args !== "object") return void 0;
+  const a = args;
+  for (const key of [
+    "TargetFile",
+    "FilePath",
+    "file_path",
+    "filePath",
+    "path",
+    "DirectoryPath",
+    "directory",
+    "Directory"
+  ]) {
+    const v = a[key];
+    if (typeof v === "string" && v.trim().length > 0) {
+      return stripWrappingQuotes2(v.trim());
+    }
+  }
+  return void 0;
+}
+function extractQuestionFromArgs(toolName, args) {
+  if (!args || typeof args !== "object") return void 0;
+  const tn = (toolName || "").toLowerCase().trim();
+  const isQuestionTool = tn === "ask_question" || tn === "question" || tn === "ask";
+  if (!isQuestionTool) return void 0;
+  const a = args;
+  if (typeof a.question === "string" && a.question.trim().length > 0) {
+    return stripWrappingQuotes2(a.question.trim());
+  }
+  if (typeof a.prompt === "string" && a.prompt.trim().length > 0) {
+    return stripWrappingQuotes2(a.prompt.trim());
+  }
+  let questions = a.questions;
+  if (typeof questions === "string") {
+    try {
+      questions = JSON.parse(questions.trim());
+    } catch {
+    }
+  }
+  if (Array.isArray(questions) && questions.length > 0) {
+    const first = questions[0];
+    if (typeof first === "string" && first.trim().length > 0) {
+      return stripWrappingQuotes2(first.trim());
+    }
+    if (first && typeof first === "object") {
+      const q = first.question;
+      if (typeof q === "string" && q.trim().length > 0) {
+        return stripWrappingQuotes2(q.trim());
       }
-      logger.debug("Pending tool call cleared on result event", {
-        intentStepIndex: matched.intentStepIndex,
-        toolCallIndex: matched.toolCallIndex,
-        resultStepIndex: args.resultStepIndex,
-        toolType: args.toolType
-      });
     }
-    return matched;
   }
-  // ─── Candidate matching (called from tmux-pane-observer's prompt-candidate) ─
-  /**
-   * Cross-reference a parsed ApprovalCandidate against the pending-call
-   * list. Returns the matched PendingPromptState (which the MCP server
-   * uses to create the INTERACTIVE_PROMPT event), or null if no match
-   * (stale scrollback).
-   *
-   * Match algorithm:
-   *   1. Filter pendingCalls by candidate.command (if set) — exact match
-   *      against PendingToolCall.command.
-   *   2. Fallback: filter by candidate.filePath (if set) — exact match
-   *      against PendingToolCall.filePath.
-   *   3. If multiple candidates match (rare), prefer the earliest
-   *      intentStepIndex.
-   *   4. If a match exists AND it already has a promptId AND that
-   *      promptId is in resolvedPrompts → null (don't re-emit).
-   *   5. If a match exists AND has a promptId BUT NOT resolved → return
-   *      the existing PendingPromptState (idempotent re-emit on the same
-   *      promptId for a duplicate candidate hash).
-   *   6. Otherwise: create a fresh promptId + PendingPromptState, attach
-   *      to the matched call, store in pendingPrompts, return it.
-   */
-  matchCandidate(candidate, conversationId) {
-    const state = this.matchCandidateInternal(candidate, conversationId);
-    if (state) return state;
-    const existing = this.pendingCandidates.get(this.candidateKey(conversationId, candidate.paneHash));
-    if (existing) {
-      logger.debug("Candidate already buffered (same paneHash)", { paneHash: this.candidateKey(conversationId, candidate.paneHash) });
-    } else {
-      this.pendingCandidates.set(this.candidateKey(conversationId, candidate.paneHash), {
-        candidate,
-        conversationId,
-        queuedAt: Date.now()
-      });
-      logger.debug("No pending tool-call matched \u2014 buffering candidate for pre-transcript window", {
-        candidateCommand: candidate.command,
-        candidateFilePath: candidate.filePath,
-        pendingCount: this.pendingCalls.size,
-        bufferSize: this.pendingCandidates.size
-      });
+  return void 0;
+}
+function extractQuestionOptionsFromArgs(toolName, args) {
+  if (!args || typeof args !== "object") return void 0;
+  const tn = (toolName || "").toLowerCase().trim();
+  const isQuestionTool = tn === "ask_question" || tn === "question" || tn === "ask";
+  if (!isQuestionTool) return void 0;
+  const a = args;
+  let questions = a.questions;
+  if (typeof questions === "string") {
+    try {
+      questions = JSON.parse(questions.trim());
+    } catch {
     }
-    return null;
   }
-  /** Internal match logic — does NOT buffer on miss. Used both by the
-   *  public matchCandidate (which buffers on miss) and by
-   *  drainBufferedCandidates (which doesn't re-buffer; misses just stay
-   *  in the buffer until their TTL expires). */
-  matchCandidateInternal(candidate, conversationId) {
-    const matched = this.findMatchingPendingCall(candidate, conversationId);
-    if (!matched) {
-      return null;
-    }
-    if (matched.promptId && this.resolvedPrompts.has(matched.promptId)) {
-      logger.debug("Skipping re-emit for already-resolved prompt", {
-        promptId: matched.promptId
-      });
-      return null;
-    }
-    if (matched.promptId && this.pendingPrompts.has(matched.promptId)) {
-      return this.pendingPrompts.get(matched.promptId) ?? null;
+  if (Array.isArray(questions) && questions.length > 0) {
+    const first = questions[0];
+    if (first && typeof first === "object" && Array.isArray(first.options)) {
+      const rawOptions = first.options;
+      const result = [];
+      for (let i = 0; i < rawOptions.length; i++) {
+        const opt = rawOptions[i];
+        if (typeof opt === "string" && opt.trim().length > 0) {
+          result.push({ number: String(i + 1), text: stripWrappingQuotes2(opt.trim()) });
+        } else if (opt && typeof opt === "object" && typeof opt.text === "string") {
+          result.push({
+            number: String(opt.number ?? i + 1),
+            text: stripWrappingQuotes2(String(opt.text).trim())
+          });
+        }
+      }
+      if (result.length > 0) return result;
     }
-    const promptId = (0, import_uuid.v4)();
-    matched.promptId = promptId;
-    const state = {
-      promptId,
-      conversationId,
-      pendingCall: matched,
-      submitMap: candidate.submitMap,
-      matchedPaneHeader: candidate.headerText,
-      paneDisplayHeader: candidate.fullHeaderLine,
-      body: candidate.body,
-      paneOptions: candidate.options,
-      paneSemanticKey: buildApprovalSemanticKey(candidate),
-      kind: candidate.kind,
-      emittedAt: Date.now(),
-      ttlMs: this.promptTtlMs
-    };
-    this.pendingPrompts.set(promptId, state);
-    logger.info("Emitting INTERACTIVE_PROMPT for matched candidate", {
-      promptId,
-      command: matched.command,
-      filePath: matched.filePath,
-      intentStepIndex: matched.intentStepIndex,
-      toolCallIndex: matched.toolCallIndex
-    });
-    this.emit("pending-prompt", state);
-    return state;
   }
-  /** Resolve a pending prompt — called from MCP server when mobile sends
-   *  the option-number reply with metadata.promptId. */
-  /**
-   * Called from the MCP server when paneObserver emits 'prompt-cleared'
-   * — i.e. the approval UI disappeared from the pane (desktop user
-   * picked an option, agy timed out the prompt, or the dispatcher
-   * answered). Resolves ALL outstanding pane-only pending prompts and
-   * releases the paneOnly dedup hashes so a subsequent approval can
-   * fresh-emit. Without this, mobile prompt state dangles until TTL
-   * AND the next identical approval is forever-suppressed by stale
-   * dedup. (Stage 2 R1 MED finding 2026-05-21.)
-   *
-   * `emittedBeforeMs` (F1, Stage 2 R1-F2): a desktop input that waited in the
-   * routing hold proves only that prompts raised BEFORE it was typed are gone.
-   * A prompt emitted after that moment stays pending, and so does its dedup
-   * hash (clearing it would re-emit the still-visible chooser).
-   */
-  onPanePromptCleared(emittedBeforeMs) {
-    if (this.pendingPrompts.size === 0 && this.paneOnlyEmittedHashes.size === 0) {
-      return [];
-    }
-    const now = Date.now();
-    const cleared = [];
-    let retained = false;
-    for (const [promptId, state] of this.pendingPrompts.entries()) {
-      if (emittedBeforeMs !== void 0 && state.emittedAt >= emittedBeforeMs) {
-        retained = true;
-        continue;
+  if (Array.isArray(a.options) || typeof a.options === "string") {
+    let topOptions = a.options;
+    if (typeof topOptions === "string") {
+      try {
+        topOptions = JSON.parse(topOptions.trim());
+      } catch {
       }
-      this.resolvedPrompts.set(promptId, now);
-      cleared.push(promptId);
     }
-    if (!retained) {
-      this.pendingPrompts.clear();
-      this.paneOnlyEmittedHashes.clear();
-    } else {
-      for (const promptId of cleared) {
-        const state = this.pendingPrompts.get(promptId);
-        if (state?.paneHash) this.paneOnlyEmittedHashes.delete(state.paneHash);
-        this.pendingPrompts.delete(promptId);
+    if (Array.isArray(topOptions)) {
+      const result = [];
+      for (let i = 0; i < topOptions.length; i++) {
+        const opt = topOptions[i];
+        if (typeof opt === "string" && opt.trim().length > 0) {
+          result.push({ number: String(i + 1), text: stripWrappingQuotes2(opt.trim()) });
+        } else if (opt && typeof opt === "object" && typeof opt.text === "string") {
+          result.push({
+            number: String(opt.number ?? i + 1),
+            text: stripWrappingQuotes2(String(opt.text).trim())
+          });
+        }
       }
+      if (result.length > 0) return result;
     }
-    if (cleared.length > 0) {
-      logger.info("Pane prompt cleared \u2014 resolved pending prompts", {
-        count: cleared.length
-      });
-    }
-    return cleared;
   }
-  resolvePrompt(promptId) {
-    const state = this.pendingPrompts.get(promptId);
-    if (!state) return null;
-    this.resolvedPrompts.set(promptId, Date.now());
-    this.pendingPrompts.delete(promptId);
-    this.paneOnlyEmittedHashes.clear();
-    return state;
+  return void 0;
+}
+function decodeBoolean(val) {
+  if (typeof val === "boolean") return val;
+  if (typeof val === "string") {
+    const s = val.trim().toLowerCase();
+    return s === "true" || s === "1" || s === "yes";
   }
-  /**
-   * Roll back a pending prompt WITHOUT marking it as resolved. Used by
-   * the MCP server when the INTERACTIVE_PROMPT createEvent fails — the
-   * prompt was never delivered to mobile, so a future tmux pane
-   * candidate for the same pending tool-call should be eligible to
-   * re-emit. `resolvePrompt` is the WRONG call there because it adds
-   * the promptId to `resolvedPrompts`, which the stale-scrollback guard
-   * uses to suppress re-emit forever. This method instead detaches the
-   * promptId from the pending call + removes from pendingPrompts +
-   * leaves resolvedPrompts UNTOUCHED so the fresh-emit path runs on
-   * the next match. (agy R2 Stage 2 round-2 MED finding 2026-05-20.)
-   */
-  rollbackPrompt(promptId) {
-    const state = this.pendingPrompts.get(promptId);
-    if (!state) return null;
-    this.pendingPrompts.delete(promptId);
-    if (state.pendingCall.promptId === promptId) {
-      state.pendingCall.promptId = void 0;
+  if (typeof val === "number") return val !== 0;
+  return false;
+}
+function extractAllQuestionsFromArgs(toolName, args) {
+  if (!args || typeof args !== "object") return void 0;
+  const tn = (toolName || "").toLowerCase().trim();
+  const isQuestionTool = tn === "ask_question" || tn === "question" || tn === "ask";
+  if (!isQuestionTool) return void 0;
+  const a = args;
+  let questions = a.questions;
+  if (typeof questions === "string") {
+    try {
+      questions = JSON.parse(questions.trim());
+    } catch {
     }
-    for (const call of this.pendingCalls.values()) {
-      if (call.matchedPromptId === promptId) {
-        call.matchedPromptId = void 0;
+  }
+  const items = [];
+  if (Array.isArray(questions) && questions.length > 0) {
+    for (const qItem of questions) {
+      if (typeof qItem === "string" && qItem.trim().length > 0) {
+        items.push({ question: stripWrappingQuotes2(qItem.trim()), options: [] });
+      } else if (qItem && typeof qItem === "object") {
+        const qObj = qItem;
+        const qText = typeof qObj.question === "string" ? stripWrappingQuotes2(qObj.question.trim()) : "Question";
+        const opts = [];
+        if (Array.isArray(qObj.options)) {
+          for (let i = 0; i < qObj.options.length; i++) {
+            const opt = qObj.options[i];
+            if (typeof opt === "string" && opt.trim().length > 0) {
+              opts.push({ number: String(i + 1), text: stripWrappingQuotes2(opt.trim()) });
+            } else if (opt && typeof opt === "object" && typeof opt.text === "string") {
+              opts.push({
+                number: String(opt.number ?? i + 1),
+                text: stripWrappingQuotes2(String(opt.text).trim())
+              });
+            }
+          }
+        }
+        const isMulti = decodeBoolean(qObj.is_multi_select ?? qObj.isMultiSelect);
+        items.push({ question: qText, options: opts, isMultiSelect: isMulti });
       }
     }
-    this.paneOnlyEmittedHashes.clear();
-    return state;
-  }
-  /** Returns the current pending-prompt state by id, or null if expired /
-   *  unknown. Used by prompt-responder for the active-prompt-identity
-   *  guard right before send-keys. */
-  getPendingPrompt(promptId) {
-    return this.pendingPrompts.get(promptId) ?? null;
-  }
-  getPendingPromptsForConversation(conversationId) {
-    const pending = Array.from(this.pendingPrompts.values());
-    return conversationId ? pending.filter((state) => state.conversationId === conversationId) : pending;
-  }
-  // ─── Read-only accessors ────────────────────────────────────────────────
-  getPendingCalls() {
-    return Array.from(this.pendingCalls.values());
+  } else if (typeof a.question === "string" || typeof a.prompt === "string") {
+    const qText = stripWrappingQuotes2(String(a.question ?? a.prompt).trim());
+    const opts = extractQuestionOptionsFromArgs(toolName, args) ?? [];
+    const isMulti = decodeBoolean(a.is_multi_select ?? a.isMultiSelect);
+    items.push({ question: qText, options: opts, isMultiSelect: isMulti });
   }
-  getActivePromptCount() {
-    return this.pendingPrompts.size;
+  return items.length > 0 ? items : void 0;
+}
+function extractCwdFromArgs(args) {
+  if (!args || typeof args !== "object") return void 0;
+  const a = args;
+  for (const key of ["Cwd", "cwd", "workingDirectory", "WorkingDirectory"]) {
+    const v = a[key];
+    if (typeof v === "string" && v.trim().length > 0) {
+      return stripWrappingQuotes2(v.trim());
+    }
   }
-  // ─── Internals ──────────────────────────────────────────────────────────
-  callKey(call) {
-    return `${call.conversationId}|${call.intentStepIndex}|${call.toolCallIndex}|${call.intentByteOffset}`;
+  return void 0;
+}
+function stripWrappingQuotes2(s) {
+  if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+    return s.slice(1, -1);
   }
-  findMatchingPendingCall(candidate, conversationId) {
-    if (candidate.kind === "question") {
-      const questionCalls = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => c.resultStepIndex === void 0).filter((c) => {
-        const associatedPromptId = c.matchedPromptId || c.promptId;
-        if (!associatedPromptId) return true;
-        return !this.resolvedPrompts.has(associatedPromptId) && !this.pendingPrompts.has(associatedPromptId);
-      }).filter(
-        (c) => c.toolType === "ASK_QUESTION" || c.rawToolName?.toLowerCase() === "ask_question"
-      ).sort((a, b) => a.intentStepIndex - b.intentStepIndex);
-      if (questionCalls.length > 0 && candidate.headerText) {
-        const normHeader = candidate.headerText.toLowerCase().trim();
-        const textMatch = questionCalls.find((c) => {
-          if (!c.questionText) return false;
-          const normQ = c.questionText.toLowerCase().trim();
-          return normHeader === normQ || normHeader.includes(normQ) || normQ.includes(normHeader);
-        });
-        if (textMatch) return textMatch;
-      }
-      return null;
-    }
-    if (candidate.command) {
-      const matches = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => c.command && c.command === candidate.command).sort((a, b) => a.intentStepIndex - b.intentStepIndex);
-      if (matches.length > 0) return matches[0];
-    }
-    if (candidate.filePath) {
-      const matches = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => c.filePath && c.filePath === candidate.filePath).sort((a, b) => a.intentStepIndex - b.intentStepIndex);
-      if (matches.length > 0) return matches[0];
-    }
-    const allFields = (candidate.command ?? "") + " " + (candidate.filePath ?? "");
-    if (allFields.trim()) {
-      const matches = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => {
-        const cmd = (c.command ?? "").trim();
-        const fp = (c.filePath ?? "").trim();
-        if (!cmd && !fp) return false;
-        const cmdOk = cmd.length >= PASS3_MIN_IDENTITY_LEN && containsAsWord(allFields, cmd);
-        const fpOk = fp.length >= PASS3_MIN_IDENTITY_LEN && containsAsWord(allFields, fp);
-        return cmdOk || fpOk;
-      }).sort((a, b) => a.intentStepIndex - b.intentStepIndex);
-      if (matches.length > 0) return matches[0];
-    }
-    return null;
+  return s;
+}
+function formatToolResultContent(agyType, toolName, output, isError) {
+  const prefix = isError ? "\u26A0 " : "";
+  const firstLine = output.split("\n", 1)[0]?.trim();
+  switch (agyType) {
+    case "RUN_COMMAND":
+      return `${prefix}Bash: ${firstLine || "command executed"}`;
+    case "LIST_DIRECTORY":
+      return `${prefix}LS: ${firstLine || "directory listed"}`;
+    case "GREP_SEARCH":
+      return `${prefix}Grep: ${firstLine || "search executed"}`;
+    case "VIEW_FILE":
+      return `${prefix}Read: ${firstLine || "file read"}`;
+    case "CODE_ACTION":
+      return `${prefix}Edit: ${firstLine || "file edited"}`;
+    case "SEARCH_WEB":
+      return `${prefix}WebSearch: ${firstLine || "search executed"}`;
+    case "GENERIC":
+      return `${prefix}${toolName}: ${firstLine || "tool executed"}`;
+    default:
+      return `${prefix}${toolName} (${agyType}): ${firstLine || "unknown event"}`;
   }
-  sweep() {
-    const now = Date.now();
-    for (const [key, call] of this.pendingCalls.entries()) {
-      if (now - call.startedAt > this.pendingCallTtlMs) {
-        this.pendingCalls.delete(key);
-        if (call.promptId) {
-          this.pendingPrompts.delete(call.promptId);
-          this.resolvedPrompts.set(call.promptId, now);
-        }
-        logger.warn("Pending tool call expired (no matching result event)", {
-          intentStepIndex: call.intentStepIndex,
-          toolCallIndex: call.toolCallIndex,
-          command: call.command,
-          filePath: call.filePath,
-          ageMs: now - call.startedAt
-        });
-        this.emit("pending-call-expired", call);
-      }
-    }
-    for (const [promptId, resolvedAt] of this.resolvedPrompts.entries()) {
-      if (now - resolvedAt > 5 * 6e4) {
-        this.resolvedPrompts.delete(promptId);
-      }
+}
+function truncate(s, maxBytes) {
+  if (!s) return "";
+  if (Buffer.byteLength(s, "utf-8") <= maxBytes) return s;
+  let lo = 0;
+  let hi = s.length;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >>> 1;
+    if (Buffer.byteLength(s.slice(0, mid), "utf-8") <= maxBytes - 32) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
     }
-    for (const [key, buffered] of this.pendingCandidates.entries()) {
-      if (now - buffered.queuedAt > this.pendingCandidateBufferMs) {
-        this.pendingCandidates.delete(key);
-        logger.debug("Buffered candidate expired without ever matching a pending call", {
-          key,
-          candidateCommand: buffered.candidate.command,
-          ageMs: now - buffered.queuedAt
-        });
+  }
+  return s.slice(0, lo) + ` [...truncated ${s.length - lo} chars]`;
+}
+
+// src/approval-detector.ts
+var DEFAULT_PROMPT_TTL_MS = 6e4;
+var PENDING_CALL_TTL_MS = 5 * 6e4;
+var SWEEP_INTERVAL_MS = 3e4;
+var PASS3_MIN_IDENTITY_LEN = 4;
+var PENDING_CANDIDATE_BUFFER_MS = 5e3;
+function normalizeQuestionText(q) {
+  if (!q) return "";
+  return q.normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+function questionsMatch(hookText, paneText) {
+  const h = normalizeQuestionText(hookText);
+  const p = normalizeQuestionText(paneText);
+  if (!h || !p) return false;
+  return h === p;
+}
+function correlatesQuestionInvocation(call, delivery) {
+  if (!call) return false;
+  const tn = (delivery.toolName ?? "").toLowerCase().trim();
+  if (!["ask_question", "question", "ask"].includes(tn)) {
+    return false;
+  }
+  const hasPromptStep = call.intentStepIndex !== void 0 && call.intentStepIndex >= 0;
+  const hasDeliveryStep = delivery.stepIdx !== void 0 && delivery.stepIdx >= 0;
+  if (hasPromptStep && !hasDeliveryStep) {
+    return false;
+  }
+  if (hasPromptStep && hasDeliveryStep) {
+    const stepDiff = delivery.stepIdx - call.intentStepIndex;
+    if (stepDiff < 0 || stepDiff > 1) return false;
+  } else {
+    if (!delivery.toolArgs) return false;
+  }
+  if (delivery.toolArgs) {
+    const completedQ = extractQuestionFromArgs(delivery.toolName ?? "", delivery.toolArgs);
+    const allCompleted = extractAllQuestionsFromArgs(delivery.toolName ?? "", delivery.toolArgs);
+    if (completedQ || allCompleted && allCompleted.length > 0) {
+      const matchesCurrent = completedQ ? questionsMatch(call.questionText, completedQ) : false;
+      const matchesStructured = call.structuredQuestions?.some(
+        (sq) => completedQ && questionsMatch(sq.question, completedQ) || allCompleted?.some((ac) => questionsMatch(sq.question, ac.question))
+      ) ?? false;
+      const matchesAllCompleted = allCompleted?.some(
+        (ac) => questionsMatch(call.questionText, ac.question)
+      ) ?? false;
+      if (!matchesCurrent && !matchesStructured && !matchesAllCompleted) {
+        return false;
       }
+    } else if (!hasPromptStep || !hasDeliveryStep) {
+      return false;
     }
   }
-};
-function containsAsWord(haystack, needle) {
-  const escaped = needle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`(^|[\\s"'\`])${escaped}([\\s"'\`]|$)`).test(haystack);
+  return true;
 }
-
-// src/prompt-responder.ts
-var import_child_process2 = require("child_process");
-var import_util2 = require("util");
-var execAsync2 = (0, import_util2.promisify)(import_child_process2.exec);
-var ENTER_DELAY_MS = 100;
-var CODEVIBE_AGY_ESCAPE_INPUT = "__CODEVIBE_AGY_KEY_ESCAPE__";
-var PromptResponder = class {
+var ApprovalDetector = class extends import_events3.EventEmitter {
   constructor(options = {}) {
-    this.tmuxTargetOverride = options.tmuxTarget;
-    this.execFn = options.execFn ?? (async (cmd) => execAsync2(cmd));
-    this.paneObserver = options.paneObserver ?? null;
-    this.detector = options.detector ?? null;
-    if (this.detector && !this.paneObserver) {
-      throw new Error(
-        "PromptResponder misconfigured: detector wired without paneObserver. Approval-reply identity guard requires the observer to re-probe the pane before send. Either wire both, or wire neither."
-      );
-    }
+    super();
+    this.pendingCalls = /* @__PURE__ */ new Map();
+    this.pendingPrompts = /* @__PURE__ */ new Map();
+    /** Track recently-resolved promptIds so a duplicate candidate-emit
+     *  doesn't re-fire INTERACTIVE_PROMPT. Maps promptId → ms-epoch when
+     *  resolved. Pruned by sweep. */
+    this.resolvedPrompts = /* @__PURE__ */ new Map();
+    /** Pre-transcript candidate buffer keyed by `${conversationId}|${paneHash}`
+     *  (composite key prevents collision when two conversations on the same
+     *  tmux pane produce identical paneHashes — agy R2 Stage 2 round-3 MED).
+     *  When a candidate arrives with no matching pending call, we park it
+     *  here for pendingCandidateBufferMs and re-try the match each time
+     *  registerPendingCall fires. */
+    this.pendingCandidates = /* @__PURE__ */ new Map();
+    /** Authoritative live wizard invocations keyed by conversationId (Codex S2-Codex-R6-F15).
+     *  Retains invocation identity and structured questions independently of transcript TTL sweeps. */
+    this.liveWizardInvocations = /* @__PURE__ */ new Map();
+    this.sweepTimer = null;
+    // ─── Pane-only prompt emission (v9.1 — bypasses pending-call match) ─────
+    /** Set of pane-snapshot hashes we've already emitted INTERACTIVE_PROMPT
+     *  for. Belt-and-suspenders dedupe against the case where paneObserver
+     *  somehow re-fires `prompt-candidate` with the same snapshot bytes
+     *  for the same prompt. The primary dedupe for cosmetic redraws of a
+     *  single approval (spinner ticks, cursor blink, partial repaints)
+     *  lives in tmux-pane-observer's debounce window — by the time a
+     *  candidate reaches this layer, the pane has settled. */
+    this.paneOnlyEmittedHashes = /* @__PURE__ */ new Set();
+    this.promptTtlMs = options.promptTtlMs ?? DEFAULT_PROMPT_TTL_MS;
+    this.pendingCallTtlMs = options.pendingCallTtlMs ?? PENDING_CALL_TTL_MS;
+    this.sweepIntervalMs = options.sweepIntervalMs ?? SWEEP_INTERVAL_MS;
+    this.pendingCandidateBufferMs = options.pendingCandidateBufferMs ?? PENDING_CANDIDATE_BUFFER_MS;
   }
-  /**
-   * Send free-form text to the agy session. The text is typed (via
-   * `send-keys -l`) then Enter is sent after a short delay so agy's
-   * input handler has time to process the buffer.
-   */
-  async sendFreeForm(text) {
-    const target = this.resolveTmuxTarget();
-    if (!target) {
-      return { ok: false, reason: "no-tmux-target" };
+  start() {
+    if (this.sweepTimer) return;
+    this.sweepTimer = setInterval(() => this.sweep(), this.sweepIntervalMs);
+    if (this.sweepTimer.unref) this.sweepTimer.unref();
+    logger.info("Approval detector started", {
+      promptTtlMs: this.promptTtlMs,
+      pendingCallTtlMs: this.pendingCallTtlMs
+    });
+  }
+  async stop() {
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
     }
-    try {
-      if (text === CODEVIBE_AGY_ESCAPE_INPUT) {
-        await this.sendKey(target, "Escape");
-      } else {
-        await this.typeLiteral(target, text);
-        await delay(ENTER_DELAY_MS);
-        await this.sendKey(target, "Enter");
+    this.pendingCalls.clear();
+    this.pendingPrompts.clear();
+    this.resolvedPrompts.clear();
+    this.pendingCandidates.clear();
+    this.paneOnlyEmittedHashes.clear();
+    this.liveWizardInvocations.clear();
+    logger.info("Approval detector stopped");
+  }
+  /** Explicitly retire a live wizard invocation upon completion (PostToolUse / Stop). (Codex S2-Codex-R6-F15) */
+  retireLiveWizard(conversationId) {
+    const live = this.liveWizardInvocations.get(conversationId);
+    if (live) {
+      if (live.promptId) {
+        this.resolvedPrompts.set(live.promptId, Date.now());
       }
-      logger.info("Sent free-form input to agy", {
-        target,
-        textLength: text.length
-      });
-      return { ok: true };
-    } catch (error) {
-      logger.error("tmux send-keys failed for free-form input", { target, error });
-      return {
-        ok: false,
-        reason: "tmux-failed",
-        details: error instanceof Error ? error.message : String(error)
-      };
+      const callKey = this.callKey(live.call);
+      const call = this.pendingCalls.get(callKey);
+      if (call) {
+        call.resultStepIndex = call.intentStepIndex;
+      }
+      this.liveWizardInvocations.delete(conversationId);
+    }
+  }
+  /** Explicitly retire a live wizard invocation matching a completed tool delivery (PostToolUse) (Codex S2-Codex-R6-F15, Claude R8-F6).
+   *  Runs synchronously before any async backend awaits, using the shared invocation correlation predicate. */
+  retireLiveWizardMatching(conversationId, delivery) {
+    const live = this.liveWizardInvocations.get(conversationId);
+    if (!live) return false;
+    if (!correlatesQuestionInvocation(live.call, delivery)) {
+      return false;
+    }
+    if (live.promptId) {
+      this.resolvedPrompts.set(live.promptId, Date.now());
+    }
+    const callKey = this.callKey(live.call);
+    const call = this.pendingCalls.get(callKey);
+    if (call) {
+      call.resultStepIndex = call.intentStepIndex;
     }
+    this.liveWizardInvocations.delete(conversationId);
+    logger.info("Retired live wizard invocation matching completed tool", {
+      conversationId,
+      toolName: delivery.toolName,
+      stepIdx: delivery.stepIdx,
+      intentStepIndex: live.call.intentStepIndex
+    });
+    return true;
   }
   /**
-   * Resolve a pending approval prompt with the mobile-user's chosen
-   * option number. Uses the submitMap from the PendingPromptState to
-   * translate option-number → terminal keystrokes (digit alone for agy's
-   * 4-numbered UI; future Y/N prompts would use 'y'/'n'/'Escape').
+   * Emit INTERACTIVE_PROMPT directly from a pane snapshot, WITHOUT
+   * requiring a matching PendingToolCall from a transcript PLANNER_RESPONSE.
    *
-   * Active-prompt-identity guard (DESIGN.md §3.4):
-   *   1. Detector check: is `promptId` still in pendingPrompts? If not
-   *      (expired or already-resolved), drop with `prompt-expired`.
-   *   2. Pane-observer check: probeApprovalUIActive() — does the pane
-   *      STILL show an approval UI whose header matches our pending
-   *      call's identity? If active-UI is gone OR header differs,
-   *      drop with `prompt-superseded`.
-   *   3. submitMap lookup: is `optionNumber` a valid key? If not (e.g.
-   *      mobile sent "5" for a 4-option prompt), drop with
-   *      `invalid-option`.
-   *   4. Send the keystrokes via tmux send-keys.
+   * Background (v9.1, 2026-05-21): agy does NOT write tool_call entries
+   * to the transcript BEFORE rendering the approval UI for shell
+   * commands. It only writes them AFTER the user approves. So the
+   * transcript-based pending-call matching path deadlocks for shell
+   * commands: paneObserver sees the UI, but no pending call exists →
+   * candidate buffered → user can't approve from mobile (no prompt
+   * shown) → no transcript write → buffer expires.
+   *
+   * Solution: pane is authoritative for "approval UI is showing right
+   * now." Skip the pending-call requirement and emit directly. The
+   * parsed candidate has everything needed (command, options, submitMap).
+   *
+   * Synthesizes a minimal PendingToolCall from the candidate so the
+   * existing handlePendingPrompt code path doesn't need to branch on
+   * `pendingCall: null`.
+   *
+   * Returns the emitted state, or null if dedupe (already emitted for
+   * this paneHash) or disabled.
    */
-  async sendApprovalReply(promptId, optionNumber) {
-    const target = this.resolveTmuxTarget();
-    if (!target) {
-      return { ok: false, reason: "no-tmux-target" };
+  emitPaneOnlyPrompt(candidate, conversationId, forcedPromptId) {
+    if (this.paneOnlyEmittedHashes.has(candidate.paneHash)) {
+      logger.debug("Skipping pane-only re-emit for duplicate paneHash", {
+        paneHash: candidate.paneHash.substring(0, 16)
+      });
+      return null;
     }
-    if (this.detector) {
-      const state = this.detector.getPendingPrompt(promptId);
-      if (!state) {
-        logger.warn("Mobile reply for unknown / expired promptId", { promptId, optionNumber });
-        return {
-          ok: false,
-          reason: "prompt-expired",
-          details: `promptId ${promptId} is not in pendingPrompts`
+    if (candidate.kind === "question") {
+      const paneQuestionText = candidate.headerText || candidate.fullHeaderLine;
+      const candidateSemanticKey = buildApprovalSemanticKey(candidate);
+      const liveWizard2 = this.liveWizardInvocations.get(conversationId);
+      if (liveWizard2 && liveWizard2.call.structuredQuestions && liveWizard2.call.structuredQuestions.length > 0) {
+        const sqs = liveWizard2.call.structuredQuestions;
+        const currentActiveIdx = liveWizard2.activeStepIndex ?? 0;
+        const scoreStep = (stepIdx) => {
+          if (stepIdx < 0 || stepIdx >= sqs.length) return { score: -1, textMatch: false };
+          const targetQ = sqs[stepIdx];
+          const textMatch = questionsMatch(targetQ.question, paneQuestionText);
+          if (!textMatch) return { score: -1, textMatch: false };
+          const qOptTexts = (targetQ.options || []).map((o) => (typeof o === "string" ? o : o.text).toLowerCase().trim());
+          const cOptTexts = (candidate.options || []).map((o) => (typeof o === "string" ? o : o.text).toLowerCase().trim());
+          if (cOptTexts.length > 0 && qOptTexts.length > 0) {
+            const hasTrailingWriteIn = cOptTexts.length === qOptTexts.length + 1 && /^\s*write-?in\b/i.test(cOptTexts[cOptTexts.length - 1]);
+            const cEffectiveTexts = hasTrailingWriteIn ? cOptTexts.slice(0, -1) : cOptTexts;
+            const matchedQCount = qOptTexts.filter((q) => cEffectiveTexts.includes(q)).length;
+            const matchedCCount = cEffectiveTexts.filter((c) => qOptTexts.includes(c)).length;
+            const qRatio = matchedQCount / qOptTexts.length;
+            if (cEffectiveTexts.length !== qOptTexts.length || matchedQCount !== qOptTexts.length || matchedCCount !== cEffectiveTexts.length) {
+              return { score: -1, textMatch: true };
+            }
+            const posMatches = qOptTexts.filter((q, idx) => idx < cEffectiveTexts.length && cEffectiveTexts[idx] === q).length;
+            const posRatio = posMatches / qOptTexts.length;
+            const score = qRatio * 0.5 + posRatio * 0.5;
+            return { score, textMatch: true };
+          }
+          if (cOptTexts.length === 0 && qOptTexts.length === 0) {
+            return { score: 1, textMatch: true };
+          }
+          return { score: -1, textMatch: true };
         };
-      }
-      if (this.paneObserver) {
-        if (!state.paneSemanticKey) {
-          return {
-            ok: false,
-            reason: "prompt-probe-failed",
-            details: "pending prompt has no exact semantic identity"
-          };
+        const allScores = sqs.map((_, idx) => ({ stepIdx: idx, ...scoreStep(idx) })).filter((res) => res.score > 0);
+        let bestStepIdx = -1;
+        if (allScores.length > 0) {
+          const maxScore = Math.max(...allScores.map((s) => s.score));
+          const topSteps = allScores.filter((s) => Math.abs(s.score - maxScore) < 1e-3);
+          if (topSteps.length > 1) {
+            logger.warn("Ambiguous pane options match: multiple wizard steps tied with score", {
+              maxScore,
+              tiedSteps: topSteps.map((s) => s.stepIdx)
+            });
+            bestStepIdx = -1;
+          } else {
+            bestStepIdx = topSteps[0].stepIdx;
+          }
         }
-      }
-      const keys = state.submitMap[optionNumber];
-      if (!keys || keys.length === 0) {
-        return {
-          ok: false,
-          reason: "invalid-option",
-          details: `option '${optionNumber}' not in submitMap (valid: ${Object.keys(state.submitMap).join(",")})`
-        };
-      }
-      try {
-        for (const key of keys) {
-          if (!this.detector || !this.paneObserver) {
-            return {
-              ok: false,
-              reason: "prompt-probe-failed",
-              details: "approval responder is missing its detector or pane observer"
+        if (bestStepIdx === -1) {
+          logger.debug("Pane candidate did not match any step of active live wizard", {
+            paneQuestionText,
+            currentActiveIdx,
+            totalSteps: sqs.length
+          });
+          return null;
+        }
+        const targetStepQ = sqs[bestStepIdx];
+        if (targetStepQ?.isMultiSelect) {
+          candidate.submitMap = {};
+        }
+        const isAdvancement = bestStepIdx !== currentActiveIdx;
+        if (!isAdvancement) {
+          const existing = [...this.pendingPrompts.values()].find(
+            (p) => p.conversationId === conversationId && p.kind === "question"
+          );
+          if (existing) {
+            const targetQ = existing.pendingCall?.structuredQuestions?.[existing.wizardStepIndex ?? 0];
+            const isAuthoritativeMultiSelect = Boolean(targetQ?.isMultiSelect);
+            const isInitialUpgrade = existing.isHookPrompt && !isAuthoritativeMultiSelect && Object.keys(existing.submitMap || {}).length === 0 && Object.keys(candidate.submitMap || {}).length > 0;
+            if (isInitialUpgrade) {
+              existing.submitMap = candidate.submitMap;
+              if (candidate.options && candidate.options.length > 0) {
+                existing.paneOptions = candidate.options;
+              }
+              existing.paneSemanticKey = candidateSemanticKey;
+              existing.paneHash = candidate.paneHash;
+              if (candidate.headerText) existing.matchedPaneHeader = candidate.headerText;
+              if (candidate.fullHeaderLine) existing.paneDisplayHeader = candidate.fullHeaderLine;
+              if (candidate.body) existing.body = candidate.body;
+              if (candidate.paneHash) this.paneOnlyEmittedHashes.add(candidate.paneHash);
+              logger.info("Upgraded hook-driven question prompt to actionable from pane observer", {
+                promptId: existing.promptId,
+                optionsCount: existing.paneOptions?.length ?? 0
+              });
+              this.emit("prompt-upgraded", existing);
+              return existing;
+            }
+            const areControlsMutated = (existingOpts, candidateOpts) => {
+              if (!existingOpts || !candidateOpts) return false;
+              if (existingOpts.length !== candidateOpts.length) return true;
+              return !existingOpts.every((o, idx) => o.number === candidateOpts[idx].number && (o.text || "").trim() === (candidateOpts[idx].text || "").trim());
             };
+            const isControlDelta = Boolean(
+              existing.paneOptions && existing.paneOptions.length > 0 && candidate.options && candidate.options.length > 0 && areControlsMutated(existing.paneOptions, candidate.options)
+            );
+            if (isControlDelta) {
+              logger.info("Control delta observed on active question step; resolving old prompt and re-emitting", {
+                oldPromptId: existing.promptId,
+                oldSemanticKey: existing.paneSemanticKey,
+                newSemanticKey: candidateSemanticKey
+              });
+              this.resolvePrompt(existing.promptId, { advanceWizard: false });
+              this.emit("prompt-resolved", existing.promptId);
+            } else {
+              if (!existing.paneSemanticKey) {
+                existing.paneSemanticKey = candidateSemanticKey;
+              }
+              if (candidate.body) existing.body = candidate.body;
+              if (candidate.paneHash) this.paneOnlyEmittedHashes.add(candidate.paneHash);
+              return null;
+            }
           }
-          if (this.detector.getPendingPrompt(promptId) !== state) {
-            return { ok: false, reason: "prompt-expired" };
+        } else {
+          liveWizard2.activeStepIndex = bestStepIdx;
+          for (const p of [...this.pendingPrompts.values()]) {
+            if (p.conversationId === conversationId && p.kind === "question") {
+              logger.info("Resolving older question prompt on wizard step progression", {
+                oldPromptId: p.promptId,
+                fromStep: currentActiveIdx,
+                toStep: bestStepIdx
+              });
+              this.resolvePrompt(p.promptId, { advanceWizard: false });
+              this.emit("prompt-resolved", p.promptId);
+            }
           }
-          let liveSemanticKey = null;
-          try {
-            const snapshot = await this.paneObserver.captureSnapshot();
-            const live = parseApprovalSnapshot(snapshot);
-            if (!live) {
-              if (detectActivePromptKind(snapshot) === null) {
-                this.detector.resolvePrompt(promptId);
-                return {
-                  ok: false,
-                  reason: "prompt-superseded",
-                  details: "the approval chooser is no longer active"
-                };
+        }
+      } else {
+        for (const p of [...this.pendingPrompts.values()]) {
+          if (p.conversationId === conversationId && p.kind === "question") {
+            const hookQuestionText = p.pendingCall?.questionText || p.matchedPaneHeader || p.paneDisplayHeader;
+            const isSameQuestion = questionsMatch(hookQuestionText, paneQuestionText);
+            if (isSameQuestion) {
+              const targetQ = p.pendingCall?.structuredQuestions?.[p.wizardStepIndex ?? 0];
+              const isAuthoritativeMultiSelect = Boolean(targetQ?.isMultiSelect);
+              const isInitialUpgrade = p.isHookPrompt && !isAuthoritativeMultiSelect && Object.keys(p.submitMap || {}).length === 0 && Object.keys(candidate.submitMap || {}).length > 0;
+              const isControlDelta = !isInitialUpgrade && Boolean(
+                p.paneSemanticKey && candidateSemanticKey !== p.paneSemanticKey
+              );
+              if (!isControlDelta) {
+                if (isInitialUpgrade) {
+                  p.submitMap = candidate.submitMap;
+                  if (candidate.options && candidate.options.length > 0) {
+                    p.paneOptions = candidate.options;
+                  }
+                  p.paneSemanticKey = candidateSemanticKey;
+                  p.paneHash = candidate.paneHash;
+                  if (candidate.headerText) p.matchedPaneHeader = candidate.headerText;
+                  if (candidate.fullHeaderLine) p.paneDisplayHeader = candidate.fullHeaderLine;
+                  if (candidate.body) p.body = candidate.body;
+                  if (candidate.paneHash) this.paneOnlyEmittedHashes.add(candidate.paneHash);
+                  logger.info("Upgraded hook-driven question prompt to actionable from pane observer", {
+                    promptId: p.promptId,
+                    optionsCount: p.paneOptions?.length ?? 0
+                  });
+                  this.emit("prompt-upgraded", p);
+                  return p;
+                }
+                if (!p.paneSemanticKey) {
+                  p.paneSemanticKey = candidateSemanticKey;
+                }
+                if (candidate.paneHash) this.paneOnlyEmittedHashes.add(candidate.paneHash);
+                return null;
               }
-              return {
-                ok: false,
-                reason: "prompt-probe-failed",
-                details: "the active chooser could not be parsed exactly"
-              };
             }
-            liveSemanticKey = live ? buildApprovalSemanticKey(live) : null;
-          } catch (error) {
-            return {
-              ok: false,
-              reason: "prompt-probe-failed",
-              details: error instanceof Error ? error.message : String(error)
-            };
-          }
-          if (liveSemanticKey !== state.paneSemanticKey) {
-            this.detector.resolvePrompt(promptId);
-            return {
-              ok: false,
-              reason: "prompt-superseded",
-              details: "active chooser semantics differ from the mobile prompt"
-            };
+            this.resolvePrompt(p.promptId);
+            this.emit("prompt-resolved", p.promptId);
           }
-          if (isNamedKey(key)) {
-            await this.sendKey(target, key);
+        }
+      }
+    }
+    const promptId = forcedPromptId ?? (0, import_uuid2.v4)();
+    const liveWizard = candidate.kind === "question" ? this.liveWizardInvocations.get(conversationId) : void 0;
+    const matchingCall = liveWizard ? liveWizard.call : candidate.kind === "question" ? this.findMatchingPendingCall(candidate, conversationId) : null;
+    if (liveWizard) {
+      liveWizard.promptId = promptId;
+    } else if (matchingCall) {
+      matchingCall.matchedPromptId = promptId;
+    }
+    const syntheticCall = {
+      conversationId,
+      intentStepIndex: matchingCall?.intentStepIndex ?? -1,
+      // sentinel: "no transcript origin"
+      toolCallIndex: matchingCall?.toolCallIndex ?? 0,
+      intentByteOffset: matchingCall?.intentByteOffset ?? 0,
+      // Best-effort tool-type inference from the candidate. For shell
+      // commands → RUN_COMMAND. For edit-style headers with a file
+      // path → CODE_ACTION. For questions → ASK_QUESTION. Default: GENERIC.
+      toolType: matchingCall?.toolType ?? guessToolTypeFromIdentity(candidate),
+      command: matchingCall?.command ?? candidate.command,
+      filePath: matchingCall?.filePath ?? candidate.filePath,
+      rawToolName: matchingCall?.rawToolName ?? (candidate.kind === "question" ? "ask_question" : candidate.command ?? candidate.filePath ?? "unknown"),
+      questionText: candidate.kind === "question" && candidate.headerText ? candidate.headerText : matchingCall?.questionText,
+      // NOTE (Codex R3-F1 / Claude R3-F2): Pane options are authoritative ground truth
+      // that directly correspond to desktop keystrokes (submitMap). Transcript options
+      // serve solely as fallback when pane options cannot be parsed.
+      questionOptions: candidate.kind === "question" && candidate.options && candidate.options.length > 0 ? candidate.options : matchingCall?.questionOptions,
+      structuredQuestions: matchingCall?.structuredQuestions,
+      promptId,
+      startedAt: matchingCall?.startedAt ?? Date.now(),
+      intentCreatedAt: matchingCall?.intentCreatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const isHookCall = Boolean(
+      matchingCall?.structuredQuestions && matchingCall.structuredQuestions.length > 0
+    );
+    const state = {
+      promptId,
+      conversationId,
+      pendingCall: syntheticCall,
+      submitMap: candidate.submitMap,
+      matchedPaneHeader: candidate.headerText,
+      paneDisplayHeader: candidate.fullHeaderLine,
+      body: candidate.body,
+      paneOptions: candidate.options,
+      paneSemanticKey: buildApprovalSemanticKey(candidate),
+      kind: candidate.kind,
+      isHookPrompt: isHookCall,
+      // Carry hook ownership forward so pane redraws do not drop it! (Codex S2-Codex-R6-F15)
+      wizardStepIndex: liveWizard ? liveWizard.activeStepIndex : void 0,
+      emittedAt: Date.now(),
+      ttlMs: this.promptTtlMs,
+      // E1 (§6a-2b / F5) — carry the consumed pane hash so an emit-failure
+      // rollback can reset the observer's lastPromptHash and let the unchanged
+      // live pane re-emit.
+      paneHash: candidate.paneHash
+    };
+    this.pendingPrompts.set(promptId, state);
+    this.paneOnlyEmittedHashes.add(candidate.paneHash);
+    logger.info("Emitting pane-only INTERACTIVE_PROMPT", {
+      promptId,
+      command: candidate.command,
+      filePath: candidate.filePath,
+      optionsCount: candidate.options.length
+    });
+    this.emit("pending-prompt", state);
+    return state;
+  }
+  /**
+   * Emit an INTERACTIVE_PROMPT for a question tool call directly from the PreToolUse hook.
+   * This guarantees prompt delivery to mobile without relying on fragile TUI terminal screen-scraping.
+   */
+  emitHookQuestionPrompt(call, forcedPromptId) {
+    const questionText = call.questionText ?? "Question";
+    if (!call.questionOptions && call.structuredQuestions && call.structuredQuestions[0]?.options) {
+      call.questionOptions = call.structuredQuestions[0].options;
+    }
+    for (const [id, p] of this.pendingPrompts.entries()) {
+      if (p.conversationId === call.conversationId && p.kind === "question") {
+        const existingText = p.pendingCall?.questionText || p.matchedPaneHeader || p.paneDisplayHeader;
+        const isSameInvocation = !p.pendingCall || p.pendingCall.intentStepIndex === -1 || call.intentStepIndex === -1 || p.pendingCall.intentStepIndex === call.intentStepIndex;
+        if (isSameInvocation && questionsMatch(existingText, questionText)) {
+          if (p.pendingCall) {
+            p.pendingCall.structuredQuestions = call.structuredQuestions;
+            if (call.intentStepIndex !== -1) {
+              p.pendingCall.intentStepIndex = call.intentStepIndex;
+            }
+            p.pendingCall.rawToolName = call.rawToolName;
+            p.pendingCall.toolType = call.toolType;
           } else {
-            await this.typeLiteral(target, key);
+            p.pendingCall = call;
+          }
+          const isHookMultiSelect = Boolean(
+            call.isMultiSelect || call.structuredQuestions && call.structuredQuestions[0]?.isMultiSelect
+          );
+          if (isHookMultiSelect && Object.keys(p.submitMap || {}).length > 0) {
+            p.submitMap = {};
+            logger.info("emitHookQuestionPrompt: revoked actionable submitMap because incoming hook is multi-select", {
+              promptId: p.promptId
+            });
+            this.emit("prompt-upgraded", p);
+          }
+          p.isHookPrompt = true;
+          call.matchedPromptId = p.promptId;
+          if (call.structuredQuestions && call.structuredQuestions.length > 0) {
+            this.liveWizardInvocations.set(call.conversationId, {
+              call,
+              activeStepIndex: 0,
+              promptId: p.promptId,
+              registeredAt: Date.now()
+            });
           }
+          logger.info("emitHookQuestionPrompt: reusing existing matching prompt", {
+            promptId: p.promptId,
+            isActionable: Object.keys(p.submitMap || {}).length > 0
+          });
+          return p;
         }
-        this.detector.resolvePrompt(promptId);
-        logger.info("Sent approval reply via tmux", {
-          promptId,
-          optionNumber,
-          keysSent: keys
+        logger.info("Replacing older question prompt with new hook question", {
+          oldPromptId: id,
+          oldStep: p.pendingCall?.intentStepIndex,
+          newStep: call.intentStepIndex,
+          conversationId: call.conversationId
         });
-        return { ok: true };
-      } catch (error) {
-        return {
-          ok: false,
-          reason: "tmux-failed",
-          details: error instanceof Error ? error.message : String(error)
-        };
+        this.resolvePrompt(id);
+        this.emit("prompt-resolved", id);
       }
     }
-    try {
-      await this.typeLiteral(target, optionNumber);
-      return { ok: true };
-    } catch (error) {
-      return {
-        ok: false,
-        reason: "tmux-failed",
-        details: error instanceof Error ? error.message : String(error)
-      };
+    const promptId = forcedPromptId ?? (0, import_uuid2.v4)();
+    this.registerPendingCall(call);
+    call.matchedPromptId = promptId;
+    const state = {
+      promptId,
+      conversationId: call.conversationId,
+      pendingCall: call,
+      submitMap: {},
+      matchedPaneHeader: call.questionText ?? "Question",
+      paneDisplayHeader: call.questionText ?? "Question",
+      body: void 0,
+      paneOptions: call.questionOptions,
+      paneSemanticKey: buildApprovalSemanticKey({
+        kind: "question",
+        headerText: call.questionText ?? "Question",
+        fullHeaderLine: call.questionText ?? "Question",
+        options: call.questionOptions ?? [],
+        submitMap: {},
+        body: "",
+        paneHash: ""
+      }),
+      kind: "question",
+      isHookPrompt: true,
+      wizardStepIndex: 0,
+      emittedAt: Date.now(),
+      ttlMs: this.promptTtlMs
+    };
+    if (call.structuredQuestions && call.structuredQuestions.length > 0) {
+      this.liveWizardInvocations.set(call.conversationId, {
+        call,
+        activeStepIndex: 0,
+        promptId,
+        registeredAt: Date.now()
+      });
     }
+    this.pendingPrompts.set(promptId, state);
+    logger.info("Emitting hook-driven INTERACTIVE_PROMPT for question", {
+      promptId,
+      conversationId: call.conversationId,
+      questionText: call.questionText,
+      optionsCount: call.questionOptions?.length ?? 0
+    });
+    this.emit("pending-prompt", state);
+    return state;
   }
-  async sendFreeFormWhenNoApprovalActive(text, beforeType) {
-    const target = this.resolveTmuxTarget();
-    if (!target) return { ok: false, reason: "no-tmux-target" };
-    if (!this.paneObserver) {
-      return {
-        ok: false,
-        reason: "prompt-probe-failed",
-        details: "pane observer is required for safe free-form input"
-      };
+  // ─── Pending-call registration (called from event-mapper hook) ──────────
+  /**
+   * Register a tool-call intent from a PLANNER_RESPONSE.tool_calls[].
+   * Indexed by composite key so agy rollback (which can replay
+   * step_index values) doesn't cause collisions.
+   */
+  registerPendingCall(call) {
+    const key = this.callKey(call);
+    if (this.pendingCalls.has(key)) {
+      logger.debug("Pending call already registered, skipping", {
+        key,
+        intentStepIndex: call.intentStepIndex,
+        toolType: call.toolType
+      });
+      return;
     }
-    const chooserIsAbsent = async () => {
-      const probe = await this.paneObserver.probeApprovalUIActive();
-      if (!probe.probeSucceeded) {
-        return { ok: false, reason: "prompt-probe-failed" };
-      }
-      if (probe.active) {
-        return { ok: false, reason: "prompt-superseded" };
+    this.pendingCalls.set(key, call);
+    logger.debug("Pending tool call registered", {
+      key,
+      toolType: call.toolType,
+      command: call.command,
+      filePath: call.filePath
+    });
+    this.drainBufferedCandidates(call.conversationId);
+  }
+  drainBufferedCandidates(conversationId) {
+    if (this.pendingCandidates.size === 0) return;
+    const now = Date.now();
+    for (const [key, buffered] of this.pendingCandidates.entries()) {
+      if (buffered.conversationId !== conversationId) continue;
+      if (now - buffered.queuedAt > this.pendingCandidateBufferMs) {
+        this.pendingCandidates.delete(key);
+        continue;
       }
-      return null;
-    };
-    let preparationFailed = false;
-    try {
-      const beforeText = await chooserIsAbsent();
-      if (beforeText) return beforeText;
-      if (beforeType) {
-        try {
-          await beforeType();
-        } catch (error) {
-          preparationFailed = true;
-          throw error;
-        }
-        const afterPreparation = await chooserIsAbsent();
-        if (afterPreparation) return afterPreparation;
+      const state = this.matchCandidateInternal(buffered.candidate, buffered.conversationId);
+      if (state) {
+        this.pendingCandidates.delete(key);
+        logger.info("Drained buffered candidate after pending-call arrived", {
+          key,
+          ageMs: now - buffered.queuedAt
+        });
       }
-      await this.typeLiteral(target, text);
-      await delay(ENTER_DELAY_MS);
-      const beforeEnter = await chooserIsAbsent();
-      if (beforeEnter) return beforeEnter;
-      await this.sendKey(target, "Enter");
-      return { ok: true };
-    } catch (error) {
-      if (preparationFailed) throw error;
-      return {
-        ok: false,
-        reason: "tmux-failed",
-        details: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  /** Dismiss whichever approval UI is active without binding to a stale promptId. */
-  async dismissActivePrompt() {
-    const target = this.resolveTmuxTarget();
-    if (!target) return { ok: false, reason: "no-tmux-target" };
-    if (!this.paneObserver) {
-      return { ok: false, reason: "prompt-probe-failed" };
-    }
-    try {
-      const before = await this.paneObserver.probeApprovalUIActive();
-      if (!before.probeSucceeded) return { ok: false, reason: "prompt-probe-failed" };
-      if (!before.active) return { ok: true };
-      if (before.ambiguous) {
-        return {
-          ok: false,
-          reason: "ambiguous-prompt-active",
-          details: "masked/ambiguous prompt cannot be dismissed via Escape from mobile"
-        };
-      }
-      if (before.kind === "question") {
-        let isActionableWizard = false;
-        try {
-          const snapshot = await this.paneObserver.captureSnapshot();
-          if (snapshot) {
-            const parsed = parseApprovalSnapshot(snapshot);
-            if (parsed && parsed.kind === "question" && Object.keys(parsed.submitMap || {}).length > 0) {
-              isActionableWizard = true;
-            }
-          }
-        } catch {
-        }
-        if (!isActionableWizard) {
-          return {
-            ok: false,
-            reason: "display-only-question-active",
-            details: "active question prompt cannot be dismissed via Escape from mobile"
-          };
-        }
-      }
-      await this.sendKey(target, "Escape");
-      await delay(250);
-      const after = await this.paneObserver.probeApprovalUIActive();
-      if (!after.probeSucceeded) return { ok: false, reason: "prompt-probe-failed" };
-      if (after.active) {
-        return {
-          ok: false,
-          reason: "prompt-superseded",
-          details: "approval chooser remained active after Escape"
-        };
-      }
-      return { ok: true };
-    } catch (error) {
-      return {
-        ok: false,
-        reason: "tmux-failed",
-        details: error instanceof Error ? error.message : String(error)
-      };
     }
   }
-  // ─── Tmux primitives ────────────────────────────────────────────────────
-  async typeLiteral(target, text) {
-    const escaped = text.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
-    const safeTarget = escapeShellArg2(target);
-    const cmd = `tmux send-keys -t '${safeTarget}' -l "${escaped}"`;
-    await this.execFn(cmd);
-  }
-  async sendKey(target, key) {
-    const safeTarget = escapeShellArg2(target);
-    const cmd = `tmux send-keys -t '${safeTarget}' ${key}`;
-    await this.execFn(cmd);
-  }
-  resolveTmuxTarget() {
-    return this.tmuxTargetOverride ?? process.env.CODEVIBE_AGY_TMUX_TARGET ?? null;
-  }
-};
-function escapeShellArg2(value) {
-  return value.replace(/'/g, `'\\''`);
-}
-function isNamedKey(key) {
-  return /^[A-Z][A-Za-z0-9]+$/.test(key);
-}
-function delay(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-// src/mobile-prompt-dedupe.ts
-var DEFAULT_EXPIRY_MS = 15e3;
-var DEFAULT_MIN_FUZZY_ECHO_LENGTH = 16;
-var DEFAULT_MIN_FUZZY_ECHO_RATIO = 0.35;
-var MobilePromptDeduper = class {
-  constructor(options = {}) {
-    this.pendingBySession = /* @__PURE__ */ new Map();
-    this.expiryMs = options.expiryMs ?? DEFAULT_EXPIRY_MS;
-    this.minFuzzyEchoLength = options.minFuzzyEchoLength ?? DEFAULT_MIN_FUZZY_ECHO_LENGTH;
-    this.minFuzzyEchoRatio = options.minFuzzyEchoRatio ?? DEFAULT_MIN_FUZZY_ECHO_RATIO;
-    this.now = options.now ?? Date.now;
-  }
-  /** Called by the MCP server immediately BEFORE prompt-responder
-   *  performs the tmux send-keys. Records the normalized text + timestamp
-   *  for future echo-suppression. */
-  track(sessionId, prompt) {
-    this.sweep();
-    const normalized = this.normalize(prompt);
-    if (!normalized) return;
-    const entries = this.validEntries(sessionId);
-    entries.push({ normalized, timestamp: this.now() });
-    this.pendingBySession.set(sessionId, entries);
-  }
-  /** Symmetric helper for callers that want to retract a tracked entry
-   *  WITHOUT consuming it via dedupe (e.g. responder bailed before send). */
-  forget(sessionId, prompt) {
-    this.sweep();
-    const normalized = this.normalize(prompt);
-    if (!normalized) return;
-    let removed = false;
-    const entries = this.validEntries(sessionId).filter((entry) => {
-      if (!removed && entry.normalized === normalized) {
-        removed = true;
-        return false;
-      }
-      return true;
-    });
-    this.replaceEntries(sessionId, entries);
+  /** Composite key for the pre-transcript buffer. Scoping by
+   *  conversationId prevents the collision case where two simultaneous
+   *  conversations on the same tmux pane (contract-discouraged but not
+   *  contract-impossible) produce identical paneHashes — without
+   *  conversation scoping, conv-B's candidate would be silently dropped
+   *  at the same-key dedupe check. (agy R2 Stage 2 round-3 MED finding
+   *  2026-05-20.) */
+  candidateKey(conversationId, paneHash) {
+    return `${conversationId}|${paneHash}`;
   }
   /**
-   * Called by event-mapper / MCP server immediately BEFORE forwarding a
-   * USER_PROMPT to AppSync. If the echo matches a recently-tracked mobile
-   * prompt, returns the match metadata + CONSUMES the tracked entry (so a
-   * second similar echo doesn't suppress an actual second mobile prompt).
-   * Returns null when no match → caller proceeds with the AppSync emit.
+   * Clear a pending call when its matching RESULT event arrives in the
+   * transcript. event-mapper.ts calls this from its tool-result handlers.
+   *
+   * The result event's step_index = intentStepIndex + toolCallIndex + 1
+   * per agy R2 v2 (the deterministic correlation formula). We try to
+   * match by (conversationId, expected step_index, toolType) — when one
+   * matches, clear it. If multiple pending calls match (rollback edge),
+   * clear the earliest by intentStepIndex.
    */
-  consumeIfDuplicate(sessionId, echo) {
-    this.sweep();
-    const normalizedEcho = this.normalize(echo);
-    if (!normalizedEcho) return null;
-    let match = null;
-    const entries = this.validEntries(sessionId).filter((entry) => {
-      if (!match) {
-        const matchType = this.matchType(entry.normalized, normalizedEcho);
-        if (matchType) {
-          match = {
-            matchType,
-            originalLength: entry.normalized.length,
-            echoLength: normalizedEcho.length
-          };
-          return false;
+  clearOnResultEvent(args) {
+    let matched = null;
+    let matchedKey = null;
+    for (const [key, call] of this.pendingCalls.entries()) {
+      if (call.conversationId !== args.conversationId) continue;
+      if (args.toolType !== "GENERIC" && call.toolType !== args.toolType) continue;
+      const expected = call.intentStepIndex + call.toolCallIndex + 1;
+      if (expected !== args.resultStepIndex) continue;
+      if (typeof args.resultByteOffset === "number") {
+        if (call.intentByteOffset >= args.resultByteOffset) continue;
+        if (!matched || call.intentByteOffset > matched.intentByteOffset) {
+          matched = call;
+          matchedKey = key;
         }
+      } else if (!matched || call.intentStepIndex < matched.intentStepIndex) {
+        matched = call;
+        matchedKey = key;
       }
-      return true;
-    });
-    this.replaceEntries(sessionId, entries);
-    return match;
-  }
-  /** Inspect without spending the token before durable native admission. */
-  peekIfDuplicate(sessionId, echo) {
-    const normalized = this.normalize(echo);
-    if (!normalized) return null;
-    for (const entry of this.validEntries(sessionId)) {
-      const matchType = this.matchType(entry.normalized, normalized);
-      if (matchType) return { matchType, originalLength: entry.normalized.length, echoLength: normalized.length };
     }
-    return null;
-  }
-  // ─── Internals ──────────────────────────────────────────────────────────
-  sweep() {
-    const cutoff = this.now() - this.expiryMs;
-    for (const [sessId, entries] of this.pendingBySession.entries()) {
-      const valid = entries.filter((entry) => entry.timestamp >= cutoff);
-      if (valid.length > 0) {
-        this.pendingBySession.set(sessId, valid);
-      } else {
-        this.pendingBySession.delete(sessId);
+    if (matched && matchedKey) {
+      matched.resultStepIndex = args.resultStepIndex;
+      this.pendingCalls.delete(matchedKey);
+      if (matched.promptId) {
+        this.resolvedPrompts.set(matched.promptId, Date.now());
+        this.pendingPrompts.delete(matched.promptId);
       }
+      logger.debug("Pending tool call cleared on result event", {
+        intentStepIndex: matched.intentStepIndex,
+        toolCallIndex: matched.toolCallIndex,
+        resultStepIndex: args.resultStepIndex,
+        toolType: args.toolType
+      });
     }
+    return matched;
   }
-  validEntries(sessionId) {
-    const cutoff = this.now() - this.expiryMs;
-    return (this.pendingBySession.get(sessionId) || []).filter((entry) => entry.timestamp >= cutoff);
-  }
-  replaceEntries(sessionId, entries) {
-    if (entries.length > 0) {
-      this.pendingBySession.set(sessionId, entries);
+  // ─── Candidate matching (called from tmux-pane-observer's prompt-candidate) ─
+  /**
+   * Cross-reference a parsed ApprovalCandidate against the pending-call
+   * list. Returns the matched PendingPromptState (which the MCP server
+   * uses to create the INTERACTIVE_PROMPT event), or null if no match
+   * (stale scrollback).
+   *
+   * Match algorithm:
+   *   1. Filter pendingCalls by candidate.command (if set) — exact match
+   *      against PendingToolCall.command.
+   *   2. Fallback: filter by candidate.filePath (if set) — exact match
+   *      against PendingToolCall.filePath.
+   *   3. If multiple candidates match (rare), prefer the earliest
+   *      intentStepIndex.
+   *   4. If a match exists AND it already has a promptId AND that
+   *      promptId is in resolvedPrompts → null (don't re-emit).
+   *   5. If a match exists AND has a promptId BUT NOT resolved → return
+   *      the existing PendingPromptState (idempotent re-emit on the same
+   *      promptId for a duplicate candidate hash).
+   *   6. Otherwise: create a fresh promptId + PendingPromptState, attach
+   *      to the matched call, store in pendingPrompts, return it.
+   */
+  matchCandidate(candidate, conversationId) {
+    const state = this.matchCandidateInternal(candidate, conversationId);
+    if (state) return state;
+    const existing = this.pendingCandidates.get(this.candidateKey(conversationId, candidate.paneHash));
+    if (existing) {
+      logger.debug("Candidate already buffered (same paneHash)", { paneHash: this.candidateKey(conversationId, candidate.paneHash) });
     } else {
-      this.pendingBySession.delete(sessionId);
-    }
-  }
-  matchType(original, echo) {
-    if (original === echo) {
-      return "exact";
-    }
-    const longEnough = echo.length >= this.minFuzzyEchoLength;
-    const enoughOfOriginal = echo.length / original.length >= this.minFuzzyEchoRatio;
-    if (longEnough && enoughOfOriginal && original.endsWith(echo)) {
-      return "suffix";
+      this.pendingCandidates.set(this.candidateKey(conversationId, candidate.paneHash), {
+        candidate,
+        conversationId,
+        queuedAt: Date.now()
+      });
+      logger.debug("No pending tool-call matched \u2014 buffering candidate for pre-transcript window", {
+        candidateCommand: candidate.command,
+        candidateFilePath: candidate.filePath,
+        pendingCount: this.pendingCalls.size,
+        bufferSize: this.pendingCandidates.size
+      });
     }
     return null;
   }
-  normalize(text) {
-    return text.replace(/\s+/g, " ").trim();
-  }
-};
-
-// src/daemon-telemetry.ts
-var crypto2 = __toESM(require("crypto"));
-var fs6 = __toESM(require("fs"));
-var https = __toESM(require("https"));
-var os6 = __toESM(require("os"));
-var path7 = __toESM(require("path"));
-var MEASUREMENT_ID = "G-GS74YEQTB8";
-var API_SECRET = "lAfOF6OxRzSQ-NsLBRjhAg";
-var GA4_HOSTNAME = "www.google-analytics.com";
-var GA4_PATH = `/mp/collect?measurement_id=${MEASUREMENT_ID}&api_secret=${API_SECRET}`;
-var BEACON_TOTAL_TIMEOUT_MS = 800;
-function readPluginVersion() {
-  try {
-    const pkgPath = path7.resolve(__dirname, "..", "package.json");
-    const raw = fs6.readFileSync(pkgPath, "utf-8");
-    const pkg = JSON.parse(raw);
-    if (typeof pkg.version === "string" && pkg.version.length > 0 && pkg.version.length < 30) {
-      return pkg.version;
+  /** Internal match logic — does NOT buffer on miss. Used both by the
+   *  public matchCandidate (which buffers on miss) and by
+   *  drainBufferedCandidates (which doesn't re-buffer; misses just stay
+   *  in the buffer until their TTL expires). */
+  matchCandidateInternal(candidate, conversationId) {
+    const matched = this.findMatchingPendingCall(candidate, conversationId);
+    if (!matched) {
+      return null;
     }
-  } catch {
-  }
-  return "unknown";
-}
-var PLUGIN_VERSION = readPluginVersion();
-function getClientId() {
-  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-  return crypto2.createHash("sha256").update(`${os6.hostname()}-${uid}`).digest("hex").substring(0, 36);
-}
-function sanitizeErrorMessage(msg) {
-  if (!msg) return "";
-  const homedir5 = os6.homedir();
-  let out = msg.replace(/[\n\r\t]/g, " ");
-  if (homedir5 && homedir5.length > 0) {
-    const safeHome = homedir5.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    out = out.replace(new RegExp(safeHome, "g"), "~");
-  }
-  out = out.replace(/\/Users\/[^/\s"'`]+/g, "/Users/<user>").replace(/\/home\/[^/\s"'`]+/g, "/home/<user>").replace(/[A-Za-z]:\\Users\\[^\\\s"'`]+/gi, "C:\\Users\\<user>").replace(/[^\x20-\x7E]/g, "");
-  return out.trim().substring(0, 100);
-}
-function fireDaemonBeacon(name, params) {
-  return new Promise((resolve2) => {
-    let req;
-    let settled = false;
-    const settle = () => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(overall);
-      resolve2();
+    if (matched.promptId && this.resolvedPrompts.has(matched.promptId)) {
+      logger.debug("Skipping re-emit for already-resolved prompt", {
+        promptId: matched.promptId
+      });
+      return null;
+    }
+    if (matched.promptId && this.pendingPrompts.has(matched.promptId)) {
+      return this.pendingPrompts.get(matched.promptId) ?? null;
+    }
+    const promptId = (0, import_uuid2.v4)();
+    matched.promptId = promptId;
+    const state = {
+      promptId,
+      conversationId,
+      pendingCall: matched,
+      submitMap: candidate.submitMap,
+      matchedPaneHeader: candidate.headerText,
+      paneDisplayHeader: candidate.fullHeaderLine,
+      body: candidate.body,
+      paneOptions: candidate.options,
+      paneSemanticKey: buildApprovalSemanticKey(candidate),
+      kind: candidate.kind,
+      emittedAt: Date.now(),
+      ttlMs: this.promptTtlMs
     };
-    const overall = setTimeout(() => {
-      try {
-        req?.destroy();
-      } catch {
-      }
-      settle();
-    }, BEACON_TOTAL_TIMEOUT_MS);
-    if (typeof overall.unref === "function") {
-      overall.unref();
+    this.pendingPrompts.set(promptId, state);
+    logger.info("Emitting INTERACTIVE_PROMPT for matched candidate", {
+      promptId,
+      command: matched.command,
+      filePath: matched.filePath,
+      intentStepIndex: matched.intentStepIndex,
+      toolCallIndex: matched.toolCallIndex
+    });
+    this.emit("pending-prompt", state);
+    return state;
+  }
+  /** Resolve a pending prompt — called from MCP server when mobile sends
+   *  the option-number reply with metadata.promptId. */
+  /**
+   * Called from the MCP server when paneObserver emits 'prompt-cleared'
+   * — i.e. the approval UI disappeared from the pane (desktop user
+   * picked an option, agy timed out the prompt, or the dispatcher
+   * answered). Resolves ALL outstanding pane-only pending prompts and
+   * releases the paneOnly dedup hashes so a subsequent approval can
+   * fresh-emit. Without this, mobile prompt state dangles until TTL
+   * AND the next identical approval is forever-suppressed by stale
+   * dedup. (Stage 2 R1 MED finding 2026-05-21.)
+   *
+   * `emittedBeforeMs` (F1, Stage 2 R1-F2): a desktop input that waited in the
+   * routing hold proves only that prompts raised BEFORE it was typed are gone.
+   * A prompt emitted after that moment stays pending, and so does its dedup
+   * hash (clearing it would re-emit the still-visible chooser).
+   */
+  onPanePromptCleared(emittedBeforeMs) {
+    if (this.pendingPrompts.size === 0 && this.paneOnlyEmittedHashes.size === 0) {
+      return [];
     }
-    try {
-      const sanitizedParams = {};
-      for (const [key, value] of Object.entries(params)) {
-        if (typeof value === "string") {
-          sanitizedParams[key] = sanitizeErrorMessage(value);
-        } else {
-          sanitizedParams[key] = value;
-        }
+    const now = Date.now();
+    const cleared = [];
+    let retained = false;
+    for (const [promptId, state] of this.pendingPrompts.entries()) {
+      if (emittedBeforeMs !== void 0 && state.emittedAt >= emittedBeforeMs) {
+        retained = true;
+        continue;
       }
-      const payload = JSON.stringify({
-        client_id: getClientId(),
-        events: [
-          {
-            name,
-            params: {
-              agent: "antigravity",
-              plugin_version: PLUGIN_VERSION,
-              platform: process.platform,
-              source: process.env.CODEVIBE_TELEMETRY_SOURCE || "production",
-              ...sanitizedParams
-            }
-          }
-        ]
-      });
-      req = https.request(
-        {
-          hostname: GA4_HOSTNAME,
-          path: GA4_PATH,
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          timeout: BEACON_TOTAL_TIMEOUT_MS
-        },
-        (res) => {
-          res.resume();
-          res.on("end", settle);
-          res.on("close", settle);
-          res.on("error", settle);
-        }
-      );
-      req.on("error", settle);
-      req.on("timeout", () => {
-        try {
-          req?.destroy();
-        } catch {
-        }
-        settle();
-      });
-      req.on("close", settle);
-      req.write(payload);
-      req.end();
-    } catch {
-      settle();
+      if (state.isHookPrompt) {
+        retained = true;
+        continue;
+      }
+      this.resolvedPrompts.set(promptId, now);
+      cleared.push(promptId);
     }
-  });
-}
-
-// src/event-mapper.ts
-var import_uuid2 = require("uuid");
-var import_codevibe_core5 = require("@quantiya/codevibe-core");
-var CONTENT_MAX = 150 * 1024;
-var TOOL_OUTPUT_MAX = 50 * 1024;
-var TOOL_DIFF_MAX = 100 * 1024;
-function mapTranscriptEvent(emit, sessionId, notBeforeMs) {
-  const { event } = emit;
-  const base = {
-    sessionId,
-    source: import_codevibe_core5.EventSource.DESKTOP
-  };
-  const orderingKey = `${sessionId}:${emit.conversationId}`;
-  const nextTimestamp = () => (0, import_codevibe_core5.prepareEventTimestamp)({ orderingKey, agentClock: event.created_at, notBeforeMs });
-  const baseMetadata = {
-    step_index: event.step_index,
-    agy_source: event.source,
-    agy_status: event.status,
-    agy_created_at: event.created_at,
-    agy_type: event.type,
-    agy_conversation_id: emit.conversationId
-  };
-  if (event.source === "SYSTEM") {
-    if (event.type === "CONVERSATION_HISTORY" || event.type === "SYSTEM_MESSAGE") {
-      logger.debug("Dropping internal transcript event", {
-        type: event.type,
-        stepIndex: event.step_index
-      });
-      return { events: [], pendingCallRegistrations: [] };
+    if (!retained) {
+      this.pendingPrompts.clear();
+      this.paneOnlyEmittedHashes.clear();
+    } else {
+      for (const promptId of cleared) {
+        const state = this.pendingPrompts.get(promptId);
+        if (state?.paneHash) this.paneOnlyEmittedHashes.delete(state.paneHash);
+        this.pendingPrompts.delete(promptId);
+      }
     }
-    if (event.type !== "ERROR_MESSAGE") {
-      logger.warn("Dropping unknown SYSTEM-source transcript event (safety)", {
-        type: event.type,
-        stepIndex: event.step_index
+    if (cleared.length > 0) {
+      logger.info("Pane prompt cleared \u2014 resolved pending prompts", {
+        count: cleared.length
       });
-      return { events: [], pendingCallRegistrations: [] };
     }
+    return cleared;
   }
-  if (event.type === "CONVERSATION_HISTORY" || event.type === "SYSTEM_MESSAGE") {
-    logger.debug("Dropping internal transcript event (non-SYSTEM source)", {
-      type: event.type,
-      source: event.source,
-      stepIndex: event.step_index
-    });
-    return { events: [], pendingCallRegistrations: [] };
+  resolvePrompt(promptId, options) {
+    const state = this.pendingPrompts.get(promptId);
+    if (!state) return null;
+    this.resolvedPrompts.set(promptId, Date.now());
+    this.pendingPrompts.delete(promptId);
+    const advanceWizard = options?.advanceWizard !== false;
+    const liveWizard = this.liveWizardInvocations.get(state.conversationId);
+    if (liveWizard && liveWizard.promptId === promptId) {
+      if (advanceWizard) {
+        const maxStep = (liveWizard.call.structuredQuestions?.length ?? 1) - 1;
+        liveWizard.activeStepIndex = Math.min(liveWizard.activeStepIndex + 1, maxStep);
+      }
+      liveWizard.promptId = "";
+    }
+    this.paneOnlyEmittedHashes.clear();
+    return state;
   }
-  if (event.type === "USER_INPUT") {
-    const cleaned = stripUserRequestWrapper(event.content || "");
-    return {
-      events: [
-        {
-          ...base,
-          timestamp: nextTimestamp(),
-          type: import_codevibe_core5.EventType.USER_PROMPT,
-          content: truncate(cleaned, CONTENT_MAX),
-          metadata: { ...baseMetadata }
-        }
-      ],
-      pendingCallRegistrations: []
-    };
+  /**
+   * Roll back a pending prompt WITHOUT marking it as resolved. Used by
+   * the MCP server when the INTERACTIVE_PROMPT createEvent fails — the
+   * prompt was never delivered to mobile, so a future tmux pane
+   * candidate for the same pending tool-call should be eligible to
+   * re-emit. `resolvePrompt` is the WRONG call there because it adds
+   * the promptId to `resolvedPrompts`, which the stale-scrollback guard
+   * uses to suppress re-emit forever. This method instead detaches the
+   * promptId from the pending call + removes from pendingPrompts +
+   * leaves resolvedPrompts UNTOUCHED so the fresh-emit path runs on
+   * the next match. (agy R2 Stage 2 round-2 MED finding 2026-05-20.)
+   */
+  rollbackPrompt(promptId) {
+    const state = this.pendingPrompts.get(promptId);
+    if (!state) return null;
+    this.pendingPrompts.delete(promptId);
+    if (state.pendingCall.promptId === promptId) {
+      state.pendingCall.promptId = void 0;
+    }
+    for (const call of this.pendingCalls.values()) {
+      if (call.matchedPromptId === promptId) {
+        call.matchedPromptId = void 0;
+      }
+    }
+    this.paneOnlyEmittedHashes.clear();
+    return state;
   }
-  if (event.type === "PLANNER_RESPONSE") {
-    const events = [];
-    const pendingCallRegistrations = [];
-    if (typeof event.thinking === "string" && event.thinking.trim().length > 0) {
-      events.push({
-        ...base,
-        timestamp: nextTimestamp(),
-        type: import_codevibe_core5.EventType.REASONING,
-        content: truncate(event.thinking, CONTENT_MAX),
-        metadata: { ...baseMetadata }
-      });
+  /**
+   * Rekey a pending prompt in the detector's internal map and associated pending calls.
+   * Keeps map keys and state.promptId synchronized when a server layer adopts an admission identity.
+   */
+  rekeyPrompt(oldPromptId, newPromptId) {
+    if (oldPromptId === newPromptId) return;
+    const state = this.pendingPrompts.get(oldPromptId);
+    if (!state) return;
+    this.pendingPrompts.delete(oldPromptId);
+    state.promptId = newPromptId;
+    if (state.pendingCall) {
+      if (state.pendingCall.promptId === oldPromptId) state.pendingCall.promptId = newPromptId;
+      if (state.pendingCall.matchedPromptId === oldPromptId) state.pendingCall.matchedPromptId = newPromptId;
     }
-    if (typeof event.content === "string" && event.content.trim().length > 0) {
-      events.push({
-        ...base,
-        timestamp: nextTimestamp(),
-        type: import_codevibe_core5.EventType.ASSISTANT_RESPONSE,
-        content: truncate(event.content, CONTENT_MAX),
-        metadata: { ...baseMetadata }
-      });
+    for (const call of this.pendingCalls.values()) {
+      if (call.promptId === oldPromptId) call.promptId = newPromptId;
+      if (call.matchedPromptId === oldPromptId) call.matchedPromptId = newPromptId;
     }
-    const toolCalls = event.tool_calls;
-    if (Array.isArray(toolCalls)) {
-      for (let i = 0; i < toolCalls.length; i++) {
-        const tc = toolCalls[i];
-        if (!tc || typeof tc !== "object") continue;
-        const name = tc.name;
-        if (typeof name !== "string") continue;
-        const args = tc.args;
-        pendingCallRegistrations.push({
-          intentStepIndex: event.step_index,
-          toolCallIndex: i,
-          intentByteOffset: emit.byteOffset,
-          toolType: hookToolNameToTranscriptType(name),
-          conversationId: emit.conversationId,
-          command: extractCommandFromArgs(name, args),
-          filePath: extractFilePathFromArgs(name, args),
-          questionText: extractQuestionFromArgs(name, args),
-          questionOptions: extractQuestionOptionsFromArgs(name, args),
-          cwd: extractCwdFromArgs(args),
-          rawToolName: name,
-          startedAt: Date.now(),
-          intentCreatedAt: event.created_at
+    this.pendingPrompts.set(newPromptId, state);
+  }
+  /** Returns the current pending-prompt state by id, or null if expired /
+   *  unknown. Used by prompt-responder for the active-prompt-identity
+   *  guard right before send-keys. */
+  getPendingPrompt(promptId) {
+    return this.pendingPrompts.get(promptId) ?? null;
+  }
+  getPendingPromptsForConversation(conversationId) {
+    const pending = Array.from(this.pendingPrompts.values());
+    return conversationId ? pending.filter((state) => state.conversationId === conversationId) : pending;
+  }
+  // ─── Read-only accessors ────────────────────────────────────────────────
+  getPendingCalls() {
+    return Array.from(this.pendingCalls.values());
+  }
+  getActivePromptCount() {
+    return this.pendingPrompts.size;
+  }
+  // ─── Internals ──────────────────────────────────────────────────────────
+  callKey(call) {
+    return `${call.conversationId}|${call.intentStepIndex}|${call.toolCallIndex}|${call.intentByteOffset}`;
+  }
+  findMatchingPendingCall(candidate, conversationId) {
+    if (candidate.kind === "question") {
+      const questionCalls = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => c.resultStepIndex === void 0).filter((c) => {
+        if (c.structuredQuestions && candidate.headerText) {
+          const matchesStructured = c.structuredQuestions.some((sq) => questionsMatch(sq.question, candidate.headerText));
+          if (matchesStructured) return true;
+        }
+        const associatedPromptId = c.matchedPromptId || c.promptId;
+        if (!associatedPromptId) return true;
+        return !this.resolvedPrompts.has(associatedPromptId) && !this.pendingPrompts.has(associatedPromptId);
+      }).filter(
+        (c) => c.toolType === "ASK_QUESTION" || ["ask_question", "question", "ask"].includes(c.rawToolName?.toLowerCase() ?? "")
+      ).sort((a, b) => (b.intentStepIndex ?? 0) - (a.intentStepIndex ?? 0));
+      if (questionCalls.length > 0 && candidate.headerText) {
+        const textMatch = questionCalls.find((c) => {
+          if (!c.questionText) return false;
+          if (questionsMatch(c.questionText, candidate.headerText)) return true;
+          if (c.structuredQuestions) {
+            return c.structuredQuestions.some((sq) => questionsMatch(sq.question, candidate.headerText));
+          }
+          return false;
         });
+        if (textMatch) return textMatch;
       }
+      return null;
     }
-    return { events, pendingCallRegistrations };
-  }
-  if (event.type === "ERROR_MESSAGE") {
-    const content = stripTimestampPrefix(event.content || "Agy error");
-    return {
-      events: [
-        {
-          ...base,
-          timestamp: nextTimestamp(),
-          type: import_codevibe_core5.EventType.NOTIFICATION,
-          content: truncate(content, CONTENT_MAX),
-          metadata: {
-            ...baseMetadata,
-            severity: "error"
-          }
-        }
-      ],
-      pendingCallRegistrations: []
-    };
+    if (candidate.command) {
+      const matches = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => c.command && c.command === candidate.command).sort((a, b) => a.intentStepIndex - b.intentStepIndex);
+      if (matches.length > 0) return matches[0];
+    }
+    if (candidate.filePath) {
+      const matches = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => c.filePath && c.filePath === candidate.filePath).sort((a, b) => a.intentStepIndex - b.intentStepIndex);
+      if (matches.length > 0) return matches[0];
+    }
+    const allFields = (candidate.command ?? "") + " " + (candidate.filePath ?? "");
+    if (allFields.trim()) {
+      const matches = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => {
+        const cmd = (c.command ?? "").trim();
+        const fp = (c.filePath ?? "").trim();
+        if (!cmd && !fp) return false;
+        const cmdOk = cmd.length >= PASS3_MIN_IDENTITY_LEN && containsAsWord(allFields, cmd);
+        const fpOk = fp.length >= PASS3_MIN_IDENTITY_LEN && containsAsWord(allFields, fp);
+        return cmdOk || fpOk;
+      }).sort((a, b) => a.intentStepIndex - b.intentStepIndex);
+      if (matches.length > 0) return matches[0];
+    }
+    return null;
   }
-  const toolName = transcriptTypeToFriendlyToolName(event.type);
-  const isErrorStatus = event.status === "ERROR";
-  const rawContent = stripTimestampPrefix(event.content || "");
-  const truncatedContent = truncate(rawContent, TOOL_OUTPUT_MAX);
-  return {
-    events: [
-      {
-        ...base,
-        timestamp: nextTimestamp(),
-        type: import_codevibe_core5.EventType.TOOL_USE,
-        content: formatToolResultContent(event.type, toolName, truncatedContent, isErrorStatus),
-        metadata: {
-          ...baseMetadata,
-          tool_name: toolName,
-          tool_output: truncatedContent,
-          success: !isErrorStatus
+  sweep() {
+    const now = Date.now();
+    for (const [key, call] of this.pendingCalls.entries()) {
+      if (now - call.startedAt > this.pendingCallTtlMs) {
+        this.pendingCalls.delete(key);
+        if (call.promptId) {
+          this.pendingPrompts.delete(call.promptId);
+          this.resolvedPrompts.set(call.promptId, now);
         }
+        logger.warn("Pending tool call expired (no matching result event)", {
+          intentStepIndex: call.intentStepIndex,
+          toolCallIndex: call.toolCallIndex,
+          command: call.command,
+          filePath: call.filePath,
+          ageMs: now - call.startedAt
+        });
+        this.emit("pending-call-expired", call);
       }
-    ],
-    pendingCallRegistrations: []
-  };
-}
-function stripUserRequestWrapper(content) {
-  const match = content.match(/<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/);
-  if (match && match[1] !== void 0) {
-    return match[1].trim();
+    }
+    for (const [promptId, resolvedAt] of this.resolvedPrompts.entries()) {
+      if (now - resolvedAt > 5 * 6e4) {
+        this.resolvedPrompts.delete(promptId);
+      }
+    }
+    for (const [key, buffered] of this.pendingCandidates.entries()) {
+      if (now - buffered.queuedAt > this.pendingCandidateBufferMs) {
+        this.pendingCandidates.delete(key);
+        logger.debug("Buffered candidate expired without ever matching a pending call", {
+          key,
+          candidateCommand: buffered.candidate.command,
+          ageMs: now - buffered.queuedAt
+        });
+      }
+    }
   }
-  return content.trim();
-}
-function stripTimestampPrefix(content) {
-  return content.replace(
-    /^Created At:[^\n]*\nCompleted At:[^\n]*\n+(?:\s*\n)?/,
-    ""
-  ).trim();
+};
+function containsAsWord(haystack, needle) {
+  const escaped = needle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(^|[\\s"'\`])${escaped}([\\s"'\`]|$)`).test(haystack);
 }
-function transcriptTypeToFriendlyToolName(type) {
-  switch (type) {
-    case "RUN_COMMAND":
-      return "Bash";
-    case "LIST_DIRECTORY":
-      return "LS";
-    case "GREP_SEARCH":
-      return "Grep";
-    case "VIEW_FILE":
-      return "Read";
-    case "CODE_ACTION":
-      return "Edit";
-    case "SEARCH_WEB":
-      return "WebSearch";
-    case "GENERIC":
-      return "Other";
-    default:
-      return "Other";
+
+// src/prompt-responder.ts
+var import_child_process2 = require("child_process");
+var import_util2 = require("util");
+var execAsync2 = (0, import_util2.promisify)(import_child_process2.exec);
+var ENTER_DELAY_MS = 100;
+var CODEVIBE_AGY_ESCAPE_INPUT = "__CODEVIBE_AGY_KEY_ESCAPE__";
+var PromptResponder = class {
+  constructor(options = {}) {
+    this.tmuxTargetOverride = options.tmuxTarget;
+    this.execFn = options.execFn ?? (async (cmd) => execAsync2(cmd));
+    this.paneObserver = options.paneObserver ?? null;
+    this.detector = options.detector ?? null;
+    if (this.detector && !this.paneObserver) {
+      throw new Error(
+        "PromptResponder misconfigured: detector wired without paneObserver. Approval-reply identity guard requires the observer to re-probe the pane before send. Either wire both, or wire neither."
+      );
+    }
   }
-}
-function hookToolNameToTranscriptType(hookName) {
-  const upper = hookName.toUpperCase();
-  switch (upper) {
-    case "LIST_DIR":
-      return "LIST_DIRECTORY";
-    case "REPLACE_FILE_CONTENT":
-    case "MULTI_REPLACE_FILE_CONTENT":
-    case "WRITE_TO_FILE":
-      return "CODE_ACTION";
-    case "GENERATE_IMAGE":
-    case "READ_URL_CONTENT":
-    case "INVOKE_SUBAGENT":
-    case "DEFINE_SUBAGENT":
-    case "MANAGE_SUBAGENTS":
-    case "SEND_MESSAGE":
-    case "LIST_PERMISSIONS":
-    case "MANAGE_TASK":
-    case "SCHEDULE":
-    case "ASK_PERMISSION":
-      return "GENERIC";
-    case "ASK_QUESTION":
-      return "ASK_QUESTION";
-    default:
-      return upper;
+  /**
+   * Send free-form text to the agy session. The text is typed (via
+   * `send-keys -l`) then Enter is sent after a short delay so agy's
+   * input handler has time to process the buffer.
+   */
+  async sendFreeForm(text) {
+    const target = this.resolveTmuxTarget();
+    if (!target) {
+      return { ok: false, reason: "no-tmux-target" };
+    }
+    try {
+      if (text === CODEVIBE_AGY_ESCAPE_INPUT) {
+        await this.sendKey(target, "Escape");
+      } else {
+        await this.typeLiteral(target, text);
+        await delay(ENTER_DELAY_MS);
+        await this.sendKey(target, "Enter");
+      }
+      logger.info("Sent free-form input to agy", {
+        target,
+        textLength: text.length
+      });
+      return { ok: true };
+    } catch (error) {
+      logger.error("tmux send-keys failed for free-form input", { target, error });
+      return {
+        ok: false,
+        reason: "tmux-failed",
+        details: error instanceof Error ? error.message : String(error)
+      };
+    }
   }
-}
-function extractCommandFromArgs(toolName, args) {
-  if (!args || typeof args !== "object") return void 0;
-  const a = args;
-  for (const key of ["CommandLine", "Command", "command", "cmd", "exec"]) {
-    const v = a[key];
-    if (typeof v === "string" && v.trim().length > 0) {
-      return stripWrappingQuotes2(v.trim());
+  /**
+   * Resolve a pending approval prompt with the mobile-user's chosen
+   * option number and optional follow-up text for write-in questions.
+   * Uses the submitMap from the PendingPromptState to translate
+   * option-number → terminal keystrokes.
+   *
+   * Active-prompt-identity guard (DESIGN.md §3.4):
+   *   1. Detector check: is `promptId` still in pendingPrompts? If not
+   *      (expired or already-resolved), drop with `prompt-expired`.
+   *   2. submitMap lookup: is `optionNumber` a valid key? If not, drop with `invalid-option`.
+   *      If `followUpText` is provided, verify option is Write-in; otherwise drop with `follow-up-not-allowed`.
+   *      If bare Write-in option has no text, drop with `write-in-text-required`.
+   *   3. Pane-observer check: captureSnapshot() — does the pane STILL show
+   *      an approval UI matching our pending prompt's semantic key?
+   *   4. Send option keystrokes via tmux send-keys.
+   *   5. If write-in followUpText is present: wait 250ms, verify pane state, type literal text, send Enter.
+   */
+  async sendApprovalReply(promptId, optionNumber, followUpText, beforeTypeText) {
+    const target = this.resolveTmuxTarget();
+    if (!target) {
+      return { ok: false, reason: "no-tmux-target" };
+    }
+    if (this.detector) {
+      const state = this.detector.getPendingPrompt(promptId);
+      if (!state) {
+        logger.warn("Mobile reply for unknown / expired promptId", { promptId, optionNumber });
+        return {
+          ok: false,
+          reason: "prompt-expired",
+          details: `promptId ${promptId} is not in pendingPrompts`
+        };
+      }
+      const keys = state.submitMap[optionNumber];
+      if (!keys || keys.length === 0) {
+        return {
+          ok: false,
+          reason: "invalid-option",
+          details: `option '${optionNumber}' not in submitMap (valid: ${Object.keys(state.submitMap).join(",")})`
+        };
+      }
+      const isQuestionPrompt = state.kind === "question";
+      const expectedStep = (state.paneDisplayHeader || "").match(/\bQuestion\s+(\d+(?:[\/:of\s]+\d+)?):/i)?.[1];
+      const matchingOpt = state.paneOptions?.find((o) => String(o.number) === String(optionNumber));
+      const isWriteInOption = matchingOpt ? /^\s*write-?in\b/i.test(matchingOpt.text) : false;
+      if (isQuestionPrompt) {
+        if (state.paneOptions && state.paneOptions.length > 0 && !matchingOpt) {
+          return {
+            ok: false,
+            reason: "invalid-option",
+            details: `option '${optionNumber}' not found in advertised options`,
+            deliveryPhase: "none"
+          };
+        }
+        if (isWriteInOption && (!followUpText || followUpText.trim().length === 0)) {
+          return {
+            ok: false,
+            reason: "write-in-text-required",
+            details: 'Please provide your write-in text along with the option number (e.g. "4, your response")',
+            deliveryPhase: "none"
+          };
+        }
+        if (followUpText && followUpText.trim().length > 0 && !isWriteInOption) {
+          return {
+            ok: false,
+            reason: "follow-up-not-allowed",
+            details: `Option '${optionNumber}' does not accept follow-up text`,
+            deliveryPhase: "none"
+          };
+        }
+      }
+      if (this.paneObserver) {
+        if (!state.paneSemanticKey) {
+          return {
+            ok: false,
+            reason: "prompt-probe-failed",
+            details: "pending prompt has no exact semantic identity",
+            deliveryPhase: "none"
+          };
+        }
+      }
+      let deliveryPhase = "none";
+      try {
+        for (const key of keys) {
+          if (!this.detector || !this.paneObserver) {
+            return {
+              ok: false,
+              reason: "prompt-probe-failed",
+              details: "approval responder is missing its detector or pane observer",
+              deliveryPhase
+            };
+          }
+          const currentPrompt = this.detector.getPendingPrompt(promptId);
+          if (currentPrompt !== state || !currentPrompt.submitMap || !currentPrompt.submitMap[optionNumber]) {
+            return {
+              ok: false,
+              reason: "prompt-expired",
+              details: "option is no longer actionable on active prompt (controls revoked or updated)",
+              deliveryPhase
+            };
+          }
+          let liveSemanticKey = null;
+          try {
+            const snapshot = await this.paneObserver.captureSnapshot();
+            const postCapturePrompt = this.detector.getPendingPrompt(promptId);
+            if (postCapturePrompt !== state || !postCapturePrompt.submitMap || !postCapturePrompt.submitMap[optionNumber]) {
+              return {
+                ok: false,
+                reason: "prompt-expired",
+                details: "option is no longer actionable on active prompt (controls revoked or updated)",
+                deliveryPhase
+              };
+            }
+            if (isQuestionPrompt && isWriteInInputActive(snapshot, state.matchedPaneHeader, expectedStep)) {
+              return {
+                ok: false,
+                reason: "write-in-already-active",
+                details: "write-in input field is already open on desktop; finish or cancel on desktop before selecting an option",
+                deliveryPhase: "none"
+              };
+            }
+            const live = parseApprovalSnapshot(snapshot);
+            if (!live) {
+              if (detectActivePromptKind(snapshot) === null) {
+                this.detector.resolvePrompt(promptId);
+                return {
+                  ok: false,
+                  reason: "prompt-superseded",
+                  details: "the approval chooser is no longer active",
+                  deliveryPhase
+                };
+              }
+              return {
+                ok: false,
+                reason: "prompt-probe-failed",
+                details: "the active chooser could not be parsed exactly",
+                deliveryPhase
+              };
+            }
+            liveSemanticKey = live ? buildApprovalSemanticKey(live) : null;
+          } catch (error) {
+            return {
+              ok: false,
+              reason: "prompt-probe-failed",
+              details: error instanceof Error ? error.message : String(error),
+              deliveryPhase
+            };
+          }
+          if (liveSemanticKey !== state.paneSemanticKey) {
+            this.detector.resolvePrompt(promptId);
+            return {
+              ok: false,
+              reason: "prompt-superseded",
+              details: "active chooser semantics differ from the mobile prompt",
+              deliveryPhase
+            };
+          }
+          deliveryPhase = "option_attempted";
+          if (isNamedKey(key)) {
+            await this.sendKey(target, key);
+          } else {
+            await this.typeLiteral(target, key);
+          }
+          deliveryPhase = "option_sent";
+          await delay(50);
+        }
+        if (isQuestionPrompt && isWriteInOption && followUpText && followUpText.trim().length > 0) {
+          let writeInReady = false;
+          if (this.paneObserver) {
+            for (let probeAttempt = 0; probeAttempt < 10; probeAttempt++) {
+              await delay(100);
+              try {
+                const liveSnap = await this.paneObserver.captureSnapshot();
+                if (liveSnap && isWriteInInputActive(liveSnap, state.matchedPaneHeader, expectedStep)) {
+                  writeInReady = true;
+                  break;
+                }
+              } catch {
+              }
+            }
+            if (!writeInReady) {
+              return {
+                ok: false,
+                reason: "prompt-probe-failed",
+                details: "terminal pane failed to transition to write-in input line",
+                deliveryPhase
+              };
+            }
+          } else {
+            await delay(250);
+          }
+          if (beforeTypeText) {
+            try {
+              await beforeTypeText();
+            } catch (err) {
+              return {
+                ok: false,
+                reason: "tmux-failed",
+                details: err instanceof Error ? err.message : String(err),
+                deliveryPhase: "option_sent"
+                // Do not advance phase if hook throws (Claude R4-N2)
+              };
+            }
+          }
+          const postHookPrompt = this.detector.getPendingPrompt(promptId);
+          if (postHookPrompt !== state || !postHookPrompt.submitMap || !postHookPrompt.submitMap[optionNumber]) {
+            return { ok: false, reason: "prompt-expired", deliveryPhase: "option_sent" };
+          }
+          if (this.paneObserver) {
+            try {
+              const postHookSnap = await this.paneObserver.captureSnapshot();
+              if (!postHookSnap || !isWriteInInputActive(postHookSnap, state.matchedPaneHeader, expectedStep)) {
+                return {
+                  ok: false,
+                  reason: "prompt-probe-failed",
+                  details: "write-in input field disappeared during callback before typing",
+                  deliveryPhase: "option_sent"
+                };
+              }
+            } catch (err) {
+              return {
+                ok: false,
+                reason: "prompt-probe-failed",
+                details: err instanceof Error ? err.message : String(err),
+                deliveryPhase: "option_sent"
+              };
+            }
+            const postSnapPrompt1 = this.detector.getPendingPrompt(promptId);
+            if (postSnapPrompt1 !== state || !postSnapPrompt1.submitMap || !postSnapPrompt1.submitMap[optionNumber]) {
+              return { ok: false, reason: "prompt-expired", deliveryPhase: "option_sent" };
+            }
+          }
+          deliveryPhase = "text_attempted";
+          const cleanText = followUpText.replace(/[\r\n]+/g, " ").trim();
+          await this.typeLiteral(target, cleanText);
+          deliveryPhase = "text_typed";
+          await delay(50);
+          if (this.paneObserver) {
+            try {
+              const preEnterSnap = await this.paneObserver.captureSnapshot();
+              if (!preEnterSnap || !isWriteInInputActive(preEnterSnap, state.matchedPaneHeader, expectedStep)) {
+                return {
+                  ok: false,
+                  reason: "prompt-probe-failed",
+                  details: "write-in input field disappeared before confirmation",
+                  deliveryPhase: "text_typed"
+                };
+              }
+            } catch (err) {
+              return {
+                ok: false,
+                reason: "prompt-probe-failed",
+                details: err instanceof Error ? err.message : String(err),
+                deliveryPhase: "text_typed"
+              };
+            }
+          }
+          const postSnapPrompt = this.detector.getPendingPrompt(promptId);
+          if (postSnapPrompt !== state || !postSnapPrompt.submitMap || !postSnapPrompt.submitMap[optionNumber]) {
+            return { ok: false, reason: "prompt-expired", deliveryPhase: "text_typed" };
+          }
+          deliveryPhase = "enter_attempted";
+          await this.sendKey(target, "Enter");
+          deliveryPhase = "completed";
+        }
+        this.detector.resolvePrompt(promptId);
+        logger.info("Sent approval reply via tmux", {
+          promptId,
+          optionNumber,
+          keysSent: keys,
+          hasFollowUpText: Boolean(followUpText),
+          deliveryPhase
+        });
+        return { ok: true, deliveryPhase: "completed" };
+      } catch (error) {
+        return {
+          ok: false,
+          reason: "tmux-failed",
+          details: error instanceof Error ? error.message : String(error),
+          deliveryPhase
+        };
+      }
+    }
+    try {
+      await this.typeLiteral(target, optionNumber);
+      await delay(50);
+      await this.sendKey(target, "Enter");
+      if (followUpText && followUpText.trim().length > 0) {
+        await delay(250);
+        const cleanText = followUpText.replace(/[\r\n]+/g, " ").trim();
+        await this.typeLiteral(target, cleanText);
+        await delay(50);
+        await this.sendKey(target, "Enter");
+      }
+      return { ok: true };
+    } catch (error) {
+      return {
+        ok: false,
+        reason: "tmux-failed",
+        details: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async sendFreeFormWhenNoApprovalActive(text, beforeType) {
+    const target = this.resolveTmuxTarget();
+    if (!target) return { ok: false, reason: "no-tmux-target" };
+    if (!this.paneObserver) {
+      return {
+        ok: false,
+        reason: "prompt-probe-failed",
+        details: "pane observer is required for safe free-form input"
+      };
+    }
+    const chooserIsAbsent = async () => {
+      const probe = await this.paneObserver.probeApprovalUIActive();
+      if (!probe.probeSucceeded) {
+        return { ok: false, reason: "prompt-probe-failed" };
+      }
+      if (probe.active) {
+        return { ok: false, reason: "prompt-superseded" };
+      }
+      return null;
+    };
+    let preparationFailed = false;
+    try {
+      const beforeText = await chooserIsAbsent();
+      if (beforeText) return beforeText;
+      if (beforeType) {
+        try {
+          await beforeType();
+        } catch (error) {
+          preparationFailed = true;
+          throw error;
+        }
+        const afterPreparation = await chooserIsAbsent();
+        if (afterPreparation) return afterPreparation;
+      }
+      await this.typeLiteral(target, text);
+      await delay(ENTER_DELAY_MS);
+      const beforeEnter = await chooserIsAbsent();
+      if (beforeEnter) return beforeEnter;
+      await this.sendKey(target, "Enter");
+      return { ok: true };
+    } catch (error) {
+      if (preparationFailed) throw error;
+      return {
+        ok: false,
+        reason: "tmux-failed",
+        details: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /** Dismiss whichever approval UI is active without binding to a stale promptId. */
+  async dismissActivePrompt() {
+    const target = this.resolveTmuxTarget();
+    if (!target) return { ok: false, reason: "no-tmux-target" };
+    if (!this.paneObserver) {
+      return { ok: false, reason: "prompt-probe-failed" };
+    }
+    try {
+      const before = await this.paneObserver.probeApprovalUIActive();
+      if (!before.probeSucceeded) return { ok: false, reason: "prompt-probe-failed" };
+      if (!before.active) return { ok: true };
+      if (before.ambiguous) {
+        return {
+          ok: false,
+          reason: "ambiguous-prompt-active",
+          details: "masked/ambiguous prompt cannot be dismissed via Escape from mobile"
+        };
+      }
+      if (before.kind === "question") {
+        let isActionableWizard = false;
+        try {
+          const snapshot = await this.paneObserver.captureSnapshot();
+          if (snapshot) {
+            const parsed = parseApprovalSnapshot(snapshot);
+            if (parsed && parsed.kind === "question" && Object.keys(parsed.submitMap || {}).length > 0) {
+              isActionableWizard = true;
+            }
+          }
+        } catch {
+        }
+        if (!isActionableWizard) {
+          return {
+            ok: false,
+            reason: "display-only-question-active",
+            details: "active question prompt cannot be dismissed via Escape from mobile"
+          };
+        }
+      }
+      await this.sendKey(target, "Escape");
+      await delay(250);
+      const after = await this.paneObserver.probeApprovalUIActive();
+      if (!after.probeSucceeded) return { ok: false, reason: "prompt-probe-failed" };
+      if (after.active) {
+        return {
+          ok: false,
+          reason: "prompt-superseded",
+          details: "approval chooser remained active after Escape"
+        };
+      }
+      return { ok: true };
+    } catch (error) {
+      return {
+        ok: false,
+        reason: "tmux-failed",
+        details: error instanceof Error ? error.message : String(error)
+      };
     }
   }
-  return void 0;
-}
-function extractFilePathFromArgs(toolName, args) {
-  if (!args || typeof args !== "object") return void 0;
-  const a = args;
-  for (const key of [
-    "TargetFile",
-    "FilePath",
-    "file_path",
-    "filePath",
-    "path",
-    "DirectoryPath",
-    "directory",
-    "Directory"
-  ]) {
-    const v = a[key];
-    if (typeof v === "string" && v.trim().length > 0) {
-      return stripWrappingQuotes2(v.trim());
-    }
+  // ─── Tmux primitives ────────────────────────────────────────────────────
+  async typeLiteral(target, text) {
+    const escaped = text.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
+    const safeTarget = escapeShellArg2(target);
+    const cmd = `tmux send-keys -t '${safeTarget}' -l "${escaped}"`;
+    await this.execFn(cmd);
   }
-  return void 0;
+  async sendKey(target, key) {
+    const safeTarget = escapeShellArg2(target);
+    const cmd = `tmux send-keys -t '${safeTarget}' ${key}`;
+    await this.execFn(cmd);
+  }
+  resolveTmuxTarget() {
+    return this.tmuxTargetOverride ?? process.env.CODEVIBE_AGY_TMUX_TARGET ?? null;
+  }
+};
+function escapeShellArg2(value) {
+  return value.replace(/'/g, `'\\''`);
 }
-function extractQuestionFromArgs(toolName, args) {
-  if (!args || typeof args !== "object") return void 0;
-  const tn = (toolName || "").toLowerCase().trim();
-  const isQuestionTool = tn === "ask_question" || tn === "question" || tn === "ask";
-  if (!isQuestionTool) return void 0;
-  const a = args;
-  if (typeof a.question === "string" && a.question.trim().length > 0) {
-    return stripWrappingQuotes2(a.question.trim());
+function isNamedKey(key) {
+  return /^[A-Z][A-Za-z0-9]+$/.test(key);
+}
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/mobile-prompt-dedupe.ts
+var DEFAULT_EXPIRY_MS = 15e3;
+var DEFAULT_MIN_FUZZY_ECHO_LENGTH = 16;
+var DEFAULT_MIN_FUZZY_ECHO_RATIO = 0.35;
+var MobilePromptDeduper = class {
+  constructor(options = {}) {
+    this.pendingBySession = /* @__PURE__ */ new Map();
+    this.expiryMs = options.expiryMs ?? DEFAULT_EXPIRY_MS;
+    this.minFuzzyEchoLength = options.minFuzzyEchoLength ?? DEFAULT_MIN_FUZZY_ECHO_LENGTH;
+    this.minFuzzyEchoRatio = options.minFuzzyEchoRatio ?? DEFAULT_MIN_FUZZY_ECHO_RATIO;
+    this.now = options.now ?? Date.now;
   }
-  if (typeof a.prompt === "string" && a.prompt.trim().length > 0) {
-    return stripWrappingQuotes2(a.prompt.trim());
+  /** Called by the MCP server immediately BEFORE prompt-responder
+   *  performs the tmux send-keys. Records the normalized text + timestamp
+   *  for future echo-suppression. */
+  track(sessionId, prompt) {
+    this.sweep();
+    const normalized = this.normalize(prompt);
+    if (!normalized) return;
+    const entries = this.validEntries(sessionId);
+    entries.push({ normalized, timestamp: this.now() });
+    this.pendingBySession.set(sessionId, entries);
   }
-  let questions = a.questions;
-  if (typeof questions === "string") {
-    try {
-      questions = JSON.parse(questions.trim());
-    } catch {
-    }
+  /** Symmetric helper for callers that want to retract a tracked entry
+   *  WITHOUT consuming it via dedupe (e.g. responder bailed before send). */
+  forget(sessionId, prompt) {
+    this.sweep();
+    const normalized = this.normalize(prompt);
+    if (!normalized) return;
+    let removed = false;
+    const entries = this.validEntries(sessionId).filter((entry) => {
+      if (!removed && entry.normalized === normalized) {
+        removed = true;
+        return false;
+      }
+      return true;
+    });
+    this.replaceEntries(sessionId, entries);
   }
-  if (Array.isArray(questions) && questions.length > 0) {
-    const first = questions[0];
-    if (typeof first === "string" && first.trim().length > 0) {
-      return stripWrappingQuotes2(first.trim());
+  /**
+   * Called by event-mapper / MCP server immediately BEFORE forwarding a
+   * USER_PROMPT to AppSync. If the echo matches a recently-tracked mobile
+   * prompt, returns the match metadata + CONSUMES the tracked entry (so a
+   * second similar echo doesn't suppress an actual second mobile prompt).
+   * Returns null when no match → caller proceeds with the AppSync emit.
+   */
+  consumeIfDuplicate(sessionId, echo) {
+    this.sweep();
+    const normalizedEcho = this.normalize(echo);
+    if (!normalizedEcho) return null;
+    let match = null;
+    const entries = this.validEntries(sessionId).filter((entry) => {
+      if (!match) {
+        const matchType = this.matchType(entry.normalized, normalizedEcho);
+        if (matchType) {
+          match = {
+            matchType,
+            originalLength: entry.normalized.length,
+            echoLength: normalizedEcho.length
+          };
+          return false;
+        }
+      }
+      return true;
+    });
+    this.replaceEntries(sessionId, entries);
+    return match;
+  }
+  /** Inspect without spending the token before durable native admission. */
+  peekIfDuplicate(sessionId, echo) {
+    const normalized = this.normalize(echo);
+    if (!normalized) return null;
+    for (const entry of this.validEntries(sessionId)) {
+      const matchType = this.matchType(entry.normalized, normalized);
+      if (matchType) return { matchType, originalLength: entry.normalized.length, echoLength: normalized.length };
     }
-    if (first && typeof first === "object") {
-      const q = first.question;
-      if (typeof q === "string" && q.trim().length > 0) {
-        return stripWrappingQuotes2(q.trim());
+    return null;
+  }
+  // ─── Internals ──────────────────────────────────────────────────────────
+  sweep() {
+    const cutoff = this.now() - this.expiryMs;
+    for (const [sessId, entries] of this.pendingBySession.entries()) {
+      const valid = entries.filter((entry) => entry.timestamp >= cutoff);
+      if (valid.length > 0) {
+        this.pendingBySession.set(sessId, valid);
+      } else {
+        this.pendingBySession.delete(sessId);
       }
     }
   }
-  return void 0;
-}
-function extractQuestionOptionsFromArgs(toolName, args) {
-  if (!args || typeof args !== "object") return void 0;
-  const tn = (toolName || "").toLowerCase().trim();
-  const isQuestionTool = tn === "ask_question" || tn === "question" || tn === "ask";
-  if (!isQuestionTool) return void 0;
-  const a = args;
-  let questions = a.questions;
-  if (typeof questions === "string") {
-    try {
-      questions = JSON.parse(questions.trim());
-    } catch {
+  validEntries(sessionId) {
+    const cutoff = this.now() - this.expiryMs;
+    return (this.pendingBySession.get(sessionId) || []).filter((entry) => entry.timestamp >= cutoff);
+  }
+  replaceEntries(sessionId, entries) {
+    if (entries.length > 0) {
+      this.pendingBySession.set(sessionId, entries);
+    } else {
+      this.pendingBySession.delete(sessionId);
     }
   }
-  if (Array.isArray(questions) && questions.length > 0) {
-    const first = questions[0];
-    if (first && typeof first === "object" && Array.isArray(first.options)) {
-      const rawOptions = first.options;
-      const result = [];
-      for (let i = 0; i < rawOptions.length; i++) {
-        const opt = rawOptions[i];
-        if (typeof opt === "string" && opt.trim().length > 0) {
-          result.push({ number: String(i + 1), text: stripWrappingQuotes2(opt.trim()) });
-        } else if (opt && typeof opt === "object" && typeof opt.text === "string") {
-          result.push({
-            number: String(opt.number ?? i + 1),
-            text: stripWrappingQuotes2(String(opt.text).trim())
-          });
-        }
-      }
-      if (result.length > 0) return result;
+  matchType(original, echo) {
+    if (original === echo) {
+      return "exact";
     }
+    const longEnough = echo.length >= this.minFuzzyEchoLength;
+    const enoughOfOriginal = echo.length / original.length >= this.minFuzzyEchoRatio;
+    if (longEnough && enoughOfOriginal && original.endsWith(echo)) {
+      return "suffix";
+    }
+    return null;
   }
-  return void 0;
-}
-function extractCwdFromArgs(args) {
-  if (!args || typeof args !== "object") return void 0;
-  const a = args;
-  for (const key of ["Cwd", "cwd", "workingDirectory", "WorkingDirectory"]) {
-    const v = a[key];
-    if (typeof v === "string" && v.trim().length > 0) {
-      return stripWrappingQuotes2(v.trim());
+  normalize(text) {
+    return text.replace(/\s+/g, " ").trim();
+  }
+};
+
+// src/daemon-telemetry.ts
+var crypto2 = __toESM(require("crypto"));
+var fs6 = __toESM(require("fs"));
+var https = __toESM(require("https"));
+var os6 = __toESM(require("os"));
+var path7 = __toESM(require("path"));
+var MEASUREMENT_ID = "G-GS74YEQTB8";
+var API_SECRET = "lAfOF6OxRzSQ-NsLBRjhAg";
+var GA4_HOSTNAME = "www.google-analytics.com";
+var GA4_PATH = `/mp/collect?measurement_id=${MEASUREMENT_ID}&api_secret=${API_SECRET}`;
+var BEACON_TOTAL_TIMEOUT_MS = 800;
+function readPluginVersion() {
+  try {
+    const pkgPath = path7.resolve(__dirname, "..", "package.json");
+    const raw = fs6.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    if (typeof pkg.version === "string" && pkg.version.length > 0 && pkg.version.length < 30) {
+      return pkg.version;
     }
+  } catch {
   }
-  return void 0;
+  return "unknown";
 }
-function stripWrappingQuotes2(s) {
-  if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
-    return s.slice(1, -1);
-  }
-  return s;
+var PLUGIN_VERSION = readPluginVersion();
+function getClientId() {
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  return crypto2.createHash("sha256").update(`${os6.hostname()}-${uid}`).digest("hex").substring(0, 36);
 }
-function formatToolResultContent(agyType, toolName, output, isError) {
-  const prefix = isError ? "\u26A0 " : "";
-  const firstLine = output.split("\n", 1)[0]?.trim();
-  switch (agyType) {
-    case "RUN_COMMAND":
-      return `${prefix}Bash: ${firstLine || "command executed"}`;
-    case "LIST_DIRECTORY":
-      return `${prefix}LS: ${firstLine || "directory listed"}`;
-    case "GREP_SEARCH":
-      return `${prefix}Grep: ${firstLine || "search executed"}`;
-    case "VIEW_FILE":
-      return `${prefix}Read: ${firstLine || "file read"}`;
-    case "CODE_ACTION":
-      return `${prefix}Edit: ${firstLine || "file edited"}`;
-    case "SEARCH_WEB":
-      return `${prefix}WebSearch: ${firstLine || "search executed"}`;
-    case "GENERIC":
-      return `${prefix}${toolName}: ${firstLine || "tool executed"}`;
-    default:
-      return `${prefix}${toolName} (${agyType}): ${firstLine || "unknown event"}`;
+function sanitizeErrorMessage(msg) {
+  if (!msg) return "";
+  const homedir5 = os6.homedir();
+  let out = msg.replace(/[\n\r\t]/g, " ");
+  if (homedir5 && homedir5.length > 0) {
+    const safeHome = homedir5.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    out = out.replace(new RegExp(safeHome, "g"), "~");
   }
+  out = out.replace(/\/Users\/[^/\s"'`]+/g, "/Users/<user>").replace(/\/home\/[^/\s"'`]+/g, "/home/<user>").replace(/[A-Za-z]:\\Users\\[^\\\s"'`]+/gi, "C:\\Users\\<user>").replace(/[^\x20-\x7E]/g, "");
+  return out.trim().substring(0, 100);
 }
-function truncate(s, maxBytes) {
-  if (!s) return "";
-  if (Buffer.byteLength(s, "utf-8") <= maxBytes) return s;
-  let lo = 0;
-  let hi = s.length;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >>> 1;
-    if (Buffer.byteLength(s.slice(0, mid), "utf-8") <= maxBytes - 32) {
-      lo = mid;
-    } else {
-      hi = mid - 1;
+function fireDaemonBeacon(name, params) {
+  return new Promise((resolve2) => {
+    let req;
+    let settled = false;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(overall);
+      resolve2();
+    };
+    const overall = setTimeout(() => {
+      try {
+        req?.destroy();
+      } catch {
+      }
+      settle();
+    }, BEACON_TOTAL_TIMEOUT_MS);
+    if (typeof overall.unref === "function") {
+      overall.unref();
     }
-  }
-  return s.slice(0, lo) + ` [...truncated ${s.length - lo} chars]`;
+    try {
+      const sanitizedParams = {};
+      for (const [key, value] of Object.entries(params)) {
+        if (typeof value === "string") {
+          sanitizedParams[key] = sanitizeErrorMessage(value);
+        } else {
+          sanitizedParams[key] = value;
+        }
+      }
+      const payload = JSON.stringify({
+        client_id: getClientId(),
+        events: [
+          {
+            name,
+            params: {
+              agent: "antigravity",
+              plugin_version: PLUGIN_VERSION,
+              platform: process.platform,
+              source: process.env.CODEVIBE_TELEMETRY_SOURCE || "production",
+              ...sanitizedParams
+            }
+          }
+        ]
+      });
+      req = https.request(
+        {
+          hostname: GA4_HOSTNAME,
+          path: GA4_PATH,
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          timeout: BEACON_TOTAL_TIMEOUT_MS
+        },
+        (res) => {
+          res.resume();
+          res.on("end", settle);
+          res.on("close", settle);
+          res.on("error", settle);
+        }
+      );
+      req.on("error", settle);
+      req.on("timeout", () => {
+        try {
+          req?.destroy();
+        } catch {
+        }
+        settle();
+      });
+      req.on("close", settle);
+      req.write(payload);
+      req.end();
+    } catch {
+      settle();
+    }
+  });
 }
 
 // src/tool-activity-integration.ts
@@ -6437,6 +7128,20 @@ var McpServer = class _McpServer {
      *  bounded by TTL. (Codex Stage 2 R1 v12 HIGH.) */
     this.observedMainConversationIds = /* @__PURE__ */ new Set();
     this.hookRegistrationCache = null;
+    /** Tracks generation numbers per conversation to invalidate in-flight async PreToolUse callbacks upon turn transition, Stop, or PostToolUse. (Codex S2-Codex-F6) */
+    this.conversationGenerations = /* @__PURE__ */ new Map();
+    /** Tracks turn transition and Stop generations per conversation to distinguish turn boundaries from tool completions. (Codex S2-Codex-F6, S2-Codex-R12-F2) */
+    this.conversationTurnGenerations = /* @__PURE__ */ new Map();
+    /** Monotonic sequence counter for hook lifecycle events (PreToolUse arrival, PostToolUse completion, Stop). (Claude R13-F2, Codex S2-Codex-R13-F1) */
+    this.hookEventSeq = 0;
+    /** Tracks Stop sequence per conversation to invalidate in-flight async bootstrap across stop events. (Codex S2-Codex-F6, Claude R13-N1) */
+    this.conversationStopSeq = /* @__PURE__ */ new Map();
+    /** Tracks completed PostToolUse deliveries per conversation with monotonic sequence watermarks to affirmatively correlate concurrent in-flight bootstrap work. (Codex S2-Codex-F6, S2-Codex-R13-F1, Claude R13-F2) */
+    this.conversationCompletedPostDeliveries = /* @__PURE__ */ new Map();
+    /** Tracks the latest turn initialNumSteps to filter stale in-flight or held deliveries from earlier turns. (Codex S2-Codex-F6) */
+    this.conversationInitialNumSteps = /* @__PURE__ */ new Map();
+    /** Bounded buffer for PreToolUse deliveries arriving while conversation routing is in 'hold'. (Codex S2-Codex-F6) */
+    this.heldHookDeliveries = /* @__PURE__ */ new Map();
     this.started = false;
     /** Monotonically-increasing counter incremented on every start(). Captured
      *  by async callbacks at entry; mismatch after an await means stop()→start()
@@ -6563,8 +7268,16 @@ var McpServer = class _McpServer {
       isClaimedElsewhere: (conversationId) => this.claims.isClaimedElsewhere(conversationId),
       otherInvokedAt: (conversationId) => this.claims.otherInvokedAt(conversationId),
       readTranscriptFirstType: (conversationId) => this.readConversationFirstType(conversationId),
-      onRelease: (emits, decision) => {
+      onRelease: (emits, decision, convId) => {
         for (const emit of emits) this.dispatchTranscriptEmit(emit, decision);
+        const targetConvId = convId ?? (emits.length > 0 ? emits[0].conversationId : void 0);
+        if (targetConvId) {
+          const turnStep = emits.find((e) => e.event?.type === "USER_INPUT")?.event?.step_index;
+          const minStep = this.conversationInitialNumSteps.get(targetConvId) ?? (typeof turnStep === "number" ? turnStep : void 0);
+          void this.drainHeldHookDeliveries(targetConvId, decision, minStep).catch((err) => {
+            logger.warn("Failed draining held hook deliveries onRelease", { error: String(err) });
+          });
+        }
       },
       isModelOutput: (emit) => emit.event?.source === "MODEL",
       turnStep: (emit) => emit.event?.type === "USER_INPUT" ? typeof emit.event.step_index === "number" ? emit.event.step_index : -1 : null,
@@ -6572,6 +7285,7 @@ var McpServer = class _McpServer {
       onLog: (message, data) => logger.info(message, data),
       holdMs: options.conversationHoldMs
     });
+    this.conversationHoldMs = options.conversationHoldMs;
     this.httpApi.setHandlers({
       pushEvent: (p) => this.handleHttpPushEvent(p),
       getActiveSession: () => this.getAnySession(),
@@ -6581,6 +7295,9 @@ var McpServer = class _McpServer {
   static {
     this.E1_TTL_REFRESH_MS = 5 * 60 * 1e3;
   }
+  static {
+    this.MAX_HELD_CONVERSATIONS = 50;
+  }
   // ─── Lifecycle ──────────────────────────────────────────────────────────
   async start() {
     if (this.started) throw new Error("McpServer.start() called twice");
@@ -6668,6 +7385,18 @@ var McpServer = class _McpServer {
         logger.error("handlePendingPrompt failed", { error: String(err) });
       });
     });
+    this.addListener(this.approvalDetector, "prompt-upgraded", (state) => {
+      void this.handlePendingPrompt(state).catch((err) => {
+        logger.error("handlePendingPrompt failed on prompt-upgraded", { error: String(err) });
+      });
+    });
+    this.addListener(this.approvalDetector, "prompt-resolved", (promptId) => {
+      const session = this.session;
+      if (!session) return;
+      void this.resolveE1PluginApproval(session.sessionId, promptId).catch((err) => {
+        logger.warn("resolveE1PluginApproval failed on prompt-resolved", { promptId, error: String(err) });
+      });
+    });
     this.launchSessionPromise = this.createLaunchSession();
     await this.launchSessionPromise;
     if (!this.started) {
@@ -6812,6 +7541,12 @@ var McpServer = class _McpServer {
     await this.boundedTeardownStep("paneObserver.stop", () => this.paneObserver.stop());
     await this.boundedTeardownStep("approvalDetector.stop", () => this.approvalDetector.stop());
     await this.boundedTeardownStep("httpApi.stop", () => this.httpApi.stop());
+    for (const [, list] of this.heldHookDeliveries) {
+      for (const entry of list) {
+        clearTimeout(entry.timer);
+      }
+    }
+    this.heldHookDeliveries.clear();
     this.removeOrphanedRuntimeDir();
     try {
       this.appSyncClient.cleanupSubscriptions();
@@ -7163,16 +7898,38 @@ var McpServer = class _McpServer {
     ));
   }
   // ─── agy hooks (F1) ─────────────────────────────────────────────────────
+  dropHeldHookDeliveries(conversationId, reason) {
+    const list = this.heldHookDeliveries.get(conversationId);
+    if (!list) return;
+    for (const entry of list) {
+      clearTimeout(entry.timer);
+    }
+    this.heldHookDeliveries.delete(conversationId);
+    logger.info("Dropped held hook deliveries", { conversationId, reason, count: list.length });
+  }
   /**
    * One hook delivery from OUR agy (agy-hook.js only posts here when the
    * launcher's inline CODEVIBE_AGY_HOOK_OWNER names this daemon's runtime
    * dir). Updates routing state synchronously; network work runs afterwards so
    * the HTTP reply — which agy is waiting for — goes out at once.
    */
-  handleAgyHook(delivery) {
+  async handleAgyHook(delivery) {
     if (!this.started) return;
     const { conversationId } = delivery;
     if (delivery.event === "PreInvocation") {
+      const isTurnStart = delivery.invocationNum === void 0 || delivery.invocationNum === 0;
+      const wasAlreadyAdmitted = this.router.roleOf(conversationId) === "main" || this.observedMainConversationIds.has(conversationId);
+      if (isTurnStart && wasAlreadyAdmitted) {
+        this.conversationGenerations.set(conversationId, (this.conversationGenerations.get(conversationId) ?? 0) + 1);
+        this.conversationTurnGenerations.set(conversationId, (this.conversationTurnGenerations.get(conversationId) ?? 0) + 1);
+        this.approvalDetector.retireLiveWizard(conversationId);
+        this.resolveLingeringQuestionPrompts(conversationId);
+        this.dropHeldHookDeliveries(conversationId, "turn-transition");
+        this.conversationCompletedPostDeliveries.delete(conversationId);
+      }
+      if (delivery.initialNumSteps !== void 0) {
+        this.conversationInitialNumSteps.set(conversationId, delivery.initialNumSteps);
+      }
       const previousBound = this.router.getBound();
       const { role, bound } = this.router.onPreInvocation({
         conversationId,
@@ -7181,6 +7938,9 @@ var McpServer = class _McpServer {
       });
       if (role === "main") {
         this.observedMainConversationIds.add(conversationId);
+        if (!wasAlreadyAdmitted) {
+          await this.drainHeldHookDeliveries(conversationId, "process", delivery.initialNumSteps);
+        }
       } else {
         this.observedMainConversationIds.delete(conversationId);
       }
@@ -7193,10 +7953,264 @@ var McpServer = class _McpServer {
       }
       return;
     }
-    this.router.onPostToolUse(conversationId);
+    if (delivery.event === "Stop") {
+      this.conversationGenerations.set(conversationId, (this.conversationGenerations.get(conversationId) ?? 0) + 1);
+      this.conversationTurnGenerations.set(conversationId, (this.conversationTurnGenerations.get(conversationId) ?? 0) + 1);
+      this.conversationStopSeq.set(conversationId, ++this.hookEventSeq);
+      this.dropHeldHookDeliveries(conversationId, "stop-hook");
+      this.conversationCompletedPostDeliveries.delete(conversationId);
+      this.approvalDetector.retireLiveWizard(conversationId);
+      this.resolveLingeringQuestionPrompts(conversationId);
+      return;
+    }
+    if (delivery.event === "PreToolUse") {
+      void this.handlePreToolUse(delivery).catch((error) => {
+        logger.warn("PreToolUse hook handling failed", { error: String(error) });
+      });
+      return;
+    }
+    const tn = (delivery.toolName ?? "").toLowerCase().trim();
+    const isQuestionTool = ["ask_question", "question", "ask"].includes(tn);
+    if (isQuestionTool) {
+      this.conversationGenerations.set(delivery.conversationId, (this.conversationGenerations.get(delivery.conversationId) ?? 0) + 1);
+      let list = this.conversationCompletedPostDeliveries.get(delivery.conversationId);
+      if (!list) {
+        list = [];
+        this.conversationCompletedPostDeliveries.set(delivery.conversationId, list);
+      }
+      list.push({ toolName: delivery.toolName, stepIdx: delivery.stepIdx, toolArgs: delivery.toolArgs, seq: ++this.hookEventSeq });
+      this.dropHeldHookDeliveries(delivery.conversationId, "post-tool-use-completion");
+      this.approvalDetector.retireLiveWizardMatching(delivery.conversationId, delivery);
+    }
     void this.resolvePromptsForCompletedTool(delivery).catch((error) => {
       logger.warn("PostToolUse prompt resolution failed", { error: String(error) });
     });
+    this.router.onPostToolUse(conversationId);
+  }
+  resolveLingeringQuestionPrompts(conversationId) {
+    const lingeringPrompts = this.approvalDetector.getPendingPromptsForConversation(conversationId).filter((p) => p.kind === "question");
+    for (const p of lingeringPrompts) {
+      this.approvalDetector.resolvePrompt(p.promptId);
+      if (this.session) {
+        void this.resolveE1PluginApproval(this.session.sessionId, p.promptId).catch(() => {
+        });
+      }
+    }
+  }
+  async drainHeldHookDeliveries(conversationId, decision, initialNumSteps) {
+    const list = this.heldHookDeliveries.get(conversationId);
+    if (!list || list.length === 0) return;
+    for (const entry of list) {
+      clearTimeout(entry.timer);
+    }
+    this.heldHookDeliveries.delete(conversationId);
+    if (decision === "drop") {
+      logger.info("Disposing held hook deliveries for foreign conversation", {
+        conversationId,
+        count: list.length
+      });
+      return;
+    }
+    logger.info("Replaying held hook deliveries after affirmative admission", {
+      conversationId,
+      count: list.length,
+      decision
+    });
+    const now = Date.now();
+    const HELD_TTL_MS = 3e4;
+    const capturedGen = this.conversationGenerations.get(conversationId) ?? 0;
+    for (const entry of list) {
+      if (now - entry.receivedAt > HELD_TTL_MS) {
+        logger.info("Discarding expired held hook delivery", {
+          conversationId,
+          toolName: entry.delivery.toolName,
+          ageMs: now - entry.receivedAt
+        });
+        continue;
+      }
+      if (initialNumSteps !== void 0 && entry.delivery.stepIdx !== void 0 && entry.delivery.stepIdx < initialNumSteps - 1) {
+        logger.info("Discarding held delivery from prior step before initialNumSteps", {
+          conversationId,
+          stepIdx: entry.delivery.stepIdx,
+          initialNumSteps
+        });
+        continue;
+      }
+      if (capturedGen !== (this.conversationGenerations.get(conversationId) ?? 0)) {
+        logger.info("Aborting drain of held hook delivery due to generation advance", {
+          conversationId
+        });
+        break;
+      }
+      try {
+        await this.handlePreToolUse(entry.delivery);
+      } catch (err) {
+        logger.warn("Failed replaying held hook delivery", { error: String(err) });
+      }
+    }
+  }
+  async handlePreToolUse(delivery) {
+    if (!this.started || !delivery.toolName) return;
+    logger.info("PreToolUse hook delivery received", {
+      conversationId: delivery.conversationId,
+      toolName: delivery.toolName,
+      stepIdx: delivery.stepIdx
+    });
+    const tn = delivery.toolName.toLowerCase().trim();
+    if (tn === "ask_question" || tn === "question" || tn === "ask") {
+      const capturedTurnGen = this.conversationTurnGenerations.get(delivery.conversationId) ?? 0;
+      const startedSeq = ++this.hookEventSeq;
+      await this.ensureLaunchSession();
+      if (!this.session && !this.sessionDisabled && !this.launchKeyUnavailable) {
+        for (let attempt = 0; attempt < 2 && !this.session; attempt++) {
+          await this.ensureLaunchSession();
+          if (this.sessionDisabled || this.launchKeyUnavailable) break;
+          if (!this.session) await new Promise((r) => setTimeout(r, 150));
+        }
+      }
+      if (this.sessionDisabled || this.launchKeyUnavailable) {
+        logger.warn("PreToolUse dropped due to terminal session state", {
+          conversationId: delivery.conversationId
+        });
+        return;
+      }
+      const completedPosts = this.conversationCompletedPostDeliveries.get(delivery.conversationId) ?? [];
+      const qText = extractQuestionFromArgs(delivery.toolName ?? "ask_question", delivery.toolArgs ?? {});
+      const structQuestions = extractAllQuestionsFromArgs(delivery.toolName ?? "ask_question", delivery.toolArgs ?? {});
+      const candidateCall = {
+        intentStepIndex: delivery.stepIdx,
+        questionText: qText,
+        structuredQuestions: structQuestions,
+        rawToolName: delivery.toolName ?? "ask_question"
+      };
+      const isAlreadyCompleted = completedPosts.some(
+        (post) => post.seq > startedSeq && correlatesQuestionInvocation(candidateCall, post)
+      );
+      if (isAlreadyCompleted) {
+        logger.info("PreToolUse already completed during async bootstrap await", {
+          conversationId: delivery.conversationId,
+          stepIdx: delivery.stepIdx
+        });
+        return;
+      }
+      const stoppedSeq = this.conversationStopSeq.get(delivery.conversationId) ?? 0;
+      if (stoppedSeq > startedSeq) {
+        logger.info("PreToolUse invalidated by Stop during async bootstrap await", {
+          conversationId: delivery.conversationId,
+          stepIdx: delivery.stepIdx
+        });
+        return;
+      }
+      const currentTurnGen = this.conversationTurnGenerations.get(delivery.conversationId) ?? 0;
+      if (capturedTurnGen !== currentTurnGen) {
+        const minStep2 = this.conversationInitialNumSteps.get(delivery.conversationId);
+        const isCurrentTurn = minStep2 !== void 0 && delivery.stepIdx !== void 0 && delivery.stepIdx >= minStep2 - 1;
+        if (!isCurrentTurn) {
+          logger.info("PreToolUse invalidated by turn transition during async bootstrap await", {
+            conversationId: delivery.conversationId,
+            capturedTurnGen,
+            currentTurnGen,
+            stepIdx: delivery.stepIdx,
+            minStep: minStep2
+          });
+          return;
+        }
+        logger.info("PreToolUse correlated with admitted current turn across bootstrap await", {
+          conversationId: delivery.conversationId,
+          stepIdx: delivery.stepIdx,
+          minStep: minStep2
+        });
+      }
+      const minStep = this.conversationInitialNumSteps.get(delivery.conversationId);
+      if (minStep !== void 0 && delivery.stepIdx !== void 0 && delivery.stepIdx < minStep - 1) {
+        logger.info("PreToolUse dropped as stale prior step before initialNumSteps", {
+          conversationId: delivery.conversationId,
+          stepIdx: delivery.stepIdx,
+          minStep
+        });
+        return;
+      }
+      const decision = this.router.route(delivery.conversationId);
+      if (decision === "drop") {
+        logger.debug("PreToolUse dropped for conversation outside session", {
+          conversationId: delivery.conversationId
+        });
+        return;
+      }
+      if (decision === "hold") {
+        if (!this.heldHookDeliveries.has(delivery.conversationId) && this.heldHookDeliveries.size >= _McpServer.MAX_HELD_CONVERSATIONS) {
+          const oldestConv = this.heldHookDeliveries.keys().next().value;
+          if (oldestConv) {
+            this.dropHeldHookDeliveries(oldestConv, "global-capacity-exceeded");
+          }
+        }
+        let held = this.heldHookDeliveries.get(delivery.conversationId);
+        if (!held) {
+          held = [];
+          this.heldHookDeliveries.set(delivery.conversationId, held);
+        }
+        if (held.length < 10) {
+          const timer = setTimeout(() => {
+            this.dropHeldHookDeliveries(delivery.conversationId, "hold-timeout");
+          }, this.conversationHoldMs ?? 3e4);
+          held.push({ delivery, receivedAt: Date.now(), timer });
+        }
+        this.registerHeldConversationBeforeFirstHook(delivery.conversationId);
+        return;
+      }
+      const structuredQuestions = extractAllQuestionsFromArgs(delivery.toolName, delivery.toolArgs);
+      const questionText = extractQuestionFromArgs(delivery.toolName, delivery.toolArgs);
+      const questionOptions = extractQuestionOptionsFromArgs(delivery.toolName, delivery.toolArgs);
+      logger.info("PreToolUse received ask_question hook", {
+        conversationId: delivery.conversationId,
+        questionText: questionText ? questionText.slice(0, 100) : null,
+        optionCount: questionOptions ? questionOptions.length : 0,
+        structuredQuestionsCount: structuredQuestions ? structuredQuestions.length : 0
+      });
+      const pendingCall = {
+        intentStepIndex: delivery.stepIdx ?? -1,
+        toolCallIndex: 0,
+        intentByteOffset: 0,
+        toolType: "ASK_QUESTION",
+        conversationId: delivery.conversationId,
+        rawToolName: delivery.toolName,
+        questionText,
+        questionOptions,
+        structuredQuestions,
+        startedAt: Date.now(),
+        intentCreatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.approvalDetector.registerPendingCall(pendingCall);
+      this.emitQuestionPromptFromHook(delivery.conversationId, pendingCall);
+    }
+  }
+  emitQuestionPromptFromHook(conversationId, pendingCall) {
+    const decision = this.router.route(conversationId);
+    if (decision !== "process" && decision !== "legacy") {
+      logger.debug("emitQuestionPromptFromHook skipped for non-admitted conversation", { conversationId, decision });
+      return;
+    }
+    let session = this.getSessionByConversation(conversationId);
+    if (!session && this.session) {
+      if (decision === "process" || decision === "legacy" && this.legacyAcceptsConversation(conversationId)) {
+        this.observedMainConversationIds.add(conversationId);
+        session = this.session;
+      }
+    }
+    if (!session) {
+      logger.warn("PreToolUse ask_question hook fired but conversation not owned or no session known", {
+        conversationId,
+        decision
+      });
+      return;
+    }
+    const e1rec = this.newE1Raise(session.sessionId, false);
+    const emitted = this.approvalDetector.emitHookQuestionPrompt(pendingCall, e1rec.promptId);
+    if (!emitted) {
+      this.e1PromptRaises.delete(e1rec.promptId);
+    } else if (emitted.promptId !== e1rec.promptId) {
+      this.e1PromptRaises.delete(e1rec.promptId);
+    }
   }
   /**
    * A tool our agy just ran was blocked on its approval prompt, so a pending
@@ -7206,8 +8220,14 @@ var McpServer = class _McpServer {
   async resolvePromptsForCompletedTool(delivery) {
     const session = this.session;
     if (!session) return;
-    const pending = this.approvalDetector.getPendingPromptsForConversation();
-    const matched = pending.filter((state) => promptMatchesCompletedTool(state, delivery.toolName, delivery.toolArgs));
+    const pending = this.approvalDetector.getPendingPromptsForConversation(delivery.conversationId);
+    const matched = pending.filter((state) => {
+      if (state.conversationId !== delivery.conversationId) return false;
+      if (state.kind === "question") {
+        return correlatesQuestionInvocation(state.pendingCall, delivery);
+      }
+      return promptMatchesCompletedTool(state, delivery.toolName, delivery.toolArgs);
+    });
     logger.info("PostToolUse checked pending prompts", {
       conversationId: delivery.conversationId,
       toolName: delivery.toolName ?? null,
@@ -8235,11 +9255,14 @@ var McpServer = class _McpServer {
     const e1rec = this.newE1Raise(session.sessionId, isActionable);
     const emitted = this.approvalDetector.emitPaneOnlyPrompt(parsed, activeConvId, e1rec.promptId);
     if (emitted) {
+      if (emitted.promptId !== e1rec.promptId) {
+        this.e1PromptRaises.delete(e1rec.promptId);
+      }
       if (cand.snapshotHash) {
-        this.e1ContentKeyIndex.set(`${session.sessionId}::${cand.snapshotHash}`, e1rec.promptId);
+        this.e1ContentKeyIndex.set(`${session.sessionId}::${cand.snapshotHash}`, emitted.promptId);
       }
       logger.info("Pane prompt identity", {
-        promptId: e1rec.promptId,
+        promptId: emitted.promptId,
         conversationId: activeConvId,
         commandDigest: commandDigest(parsed.command)
       });
@@ -8283,8 +9306,16 @@ var McpServer = class _McpServer {
     }
     const isDisplayOnly = Object.keys(state.submitMap || {}).length === 0;
     const e1existing = this.e1PromptRaises.get(state.promptId);
-    const e1rec = e1existing ? e1existing.record : this.newE1Raise(session.sessionId, !isDisplayOnly);
-    if (!e1existing) state.promptId = e1rec.promptId;
+    let e1rec;
+    if (e1existing) {
+      e1rec = e1existing.record;
+      e1rec.mobileActionable = !isDisplayOnly;
+    } else {
+      e1rec = this.newE1Raise(session.sessionId, !isDisplayOnly);
+      const oldPromptId = state.promptId;
+      state.promptId = e1rec.promptId;
+      this.approvalDetector.rekeyPrompt(oldPromptId, e1rec.promptId);
+    }
     const resolvedOptions = state.paneOptions && state.paneOptions.length > 0 ? state.paneOptions : state.pendingCall?.questionOptions && state.pendingCall.questionOptions.length > 0 ? state.pendingCall.questionOptions : void 0;
     const optionsArr = isDisplayOnly ? [] : resolvedOptions ? resolvedOptions.map((o) => ({ number: o.number, text: o.text })) : Object.keys(state.submitMap).map((n) => ({ number: n }));
     const diffParsed = parseFencedDiffFromBody(
@@ -8317,12 +9348,29 @@ var McpServer = class _McpServer {
       file_path: filePath,
       options: optionsArr,
       ...toolInput ? { tool_input: toolInput } : {},
-      ...state.kind === "question" && resolvedOptions && resolvedOptions.length > 0 ? {
-        questions: [{
-          question: state.pendingCall?.questionText || state.matchedPaneHeader || state.paneDisplayHeader || "Question",
-          options: resolvedOptions,
-          ...isDisplayOnly ? { instructions: "Answer this question in your desktop terminal" } : {}
-        }]
+      ...state.kind === "question" ? {
+        questions: (() => {
+          if (!state.pendingCall?.structuredQuestions || state.pendingCall.structuredQuestions.length === 0) {
+            return resolvedOptions && resolvedOptions.length > 0 ? [{
+              question: state.pendingCall?.questionText || state.matchedPaneHeader || state.paneDisplayHeader || "Question",
+              options: resolvedOptions,
+              ...isDisplayOnly ? { instructions: "Answer this question in your desktop terminal" } : {}
+            }] : void 0;
+          }
+          const activeQuestionText = state.matchedPaneHeader || state.paneDisplayHeader || state.pendingCall?.questionText || "";
+          let activeIdx = state.wizardStepIndex !== void 0 ? state.wizardStepIndex : state.pendingCall.structuredQuestions.findIndex((sq) => questionsMatch(sq.question, activeQuestionText));
+          if (activeIdx < 0 || activeIdx >= state.pendingCall.structuredQuestions.length) activeIdx = 0;
+          const activeQ = state.pendingCall.structuredQuestions[activeIdx] ?? {
+            question: activeQuestionText || "Question",
+            options: resolvedOptions || []
+          };
+          return [{
+            question: activeQ.question,
+            options: resolvedOptions && resolvedOptions.length > 0 ? resolvedOptions : activeQ.options,
+            ...activeQ.isMultiSelect !== void 0 ? { is_multi_select: activeQ.isMultiSelect } : {},
+            ...isDisplayOnly ? { instructions: "Answer this question in your desktop terminal" } : {}
+          }];
+        })()
       } : {}
     } : { promptId: state.promptId };
     const content = state.paneDisplayHeader || state.matchedPaneHeader || state.pendingCall?.command || state.pendingCall?.filePath || "approval requested";
@@ -8545,22 +9593,119 @@ var McpServer = class _McpServer {
           }
         }
         await this.trackDurableMobileEcho(session, evt, intent.option, "primary");
-        const optionResult = await this.promptResponder.sendApprovalReply(
-          activePrompt.promptId,
-          intent.option
-        );
-        if (!optionResult.ok) {
-          if (!(0, import_codevibe_core7.requiresSyncInputDeliveryReceipt)(evt)) this.mobileDeduper.forget(session.sessionId, intent.option);
+        const isQuestionPrompt = activePrompt.kind === "question";
+        if (isQuestionPrompt) {
+          let armedWriteInEcho = false;
+          const optionResult = intent.followUpText ? await this.promptResponder.sendApprovalReply(
+            activePrompt.promptId,
+            intent.option,
+            intent.followUpText,
+            async () => {
+              armedWriteInEcho = true;
+              await this.trackDurableMobileEcho(session, evt, intent.followUpText, "free_form");
+            }
+          ) : await this.promptResponder.sendApprovalReply(
+            activePrompt.promptId,
+            intent.option
+          );
+          if (!optionResult.ok) {
+            if (optionResult.reason === "write-in-text-required") {
+              await this.emitPromptSafetyNotification(
+                session,
+                optionResult.details || 'Please provide your write-in text along with the option number (e.g. "4, your response").'
+              );
+            } else if (optionResult.reason === "write-in-already-active") {
+              await this.emitPromptSafetyNotification(
+                session,
+                optionResult.details || "Write-in input field is already open on desktop; finish or cancel on desktop before selecting an option."
+              );
+            } else if (optionResult.reason === "follow-up-not-allowed") {
+              await this.emitPromptSafetyNotification(
+                session,
+                optionResult.details || `Option ${intent.option} does not accept follow-up text.`
+              );
+            } else {
+              const phase = optionResult.deliveryPhase ?? "none";
+              let message;
+              if (phase !== "none") {
+                message = "Your answer was partially entered on desktop. Please complete or cancel the prompt directly on desktop.";
+              } else if (optionResult.reason === "prompt-expired" || optionResult.reason === "prompt-superseded") {
+                message = "The question prompt on desktop has expired or changed. Please review on desktop.";
+              } else if (optionResult.reason === "prompt-probe-failed") {
+                message = "Write-in input field was not ready on desktop. Please try again or respond on desktop.";
+              } else if (optionResult.reason === "no-tmux-target" || optionResult.reason === "tmux-failed") {
+                message = optionResult.details || "Desktop terminal session is unreachable. Please respond directly on desktop.";
+              } else if (optionResult.reason === "display-only-question-active") {
+                message = "This question requires desktop input. Please respond directly on desktop.";
+              } else if (optionResult.reason === "invalid-option") {
+                message = optionResult.details || `Option '${intent.option}' is not valid for the current question.`;
+              } else {
+                message = optionResult.details || `Failed to submit response to question prompt (${optionResult.reason}).`;
+              }
+              await this.emitPromptSafetyNotification(session, message);
+            }
+            if (!(0, import_codevibe_core7.requiresSyncInputDeliveryReceipt)(evt)) {
+              const phase = optionResult.deliveryPhase ?? "none";
+              if (phase === "none") {
+                this.mobileDeduper.forget(session.sessionId, intent.option);
+                if (armedWriteInEcho && intent.followUpText) {
+                  this.mobileDeduper.forget(session.sessionId, intent.followUpText);
+                }
+              } else if (phase === "option_sent" && armedWriteInEcho && intent.followUpText) {
+                this.mobileDeduper.forget(session.sessionId, intent.followUpText);
+              }
+            }
+            return;
+          }
+          await this.resolveE1PluginApproval(session.sessionId, activePrompt.promptId);
+          await this.markExecuted(evt);
           return;
-        }
-        await this.resolveE1PluginApproval(session.sessionId, activePrompt.promptId);
-        if (!intent.followUpText) {
+        } else {
+          const optionResult = await this.promptResponder.sendApprovalReply(
+            activePrompt.promptId,
+            intent.option
+          );
+          if (!optionResult.ok) {
+            if (!(0, import_codevibe_core7.requiresSyncInputDeliveryReceipt)(evt)) {
+              const phase = optionResult.deliveryPhase ?? "none";
+              if (phase === "none") {
+                this.mobileDeduper.forget(session.sessionId, intent.option);
+              }
+            }
+            return;
+          }
+          await this.resolveE1PluginApproval(session.sessionId, activePrompt.promptId);
+          if (intent.followUpText) {
+            await new Promise((r) => setTimeout(r, 250));
+            const freeFormResult = await this.promptResponder.sendFreeFormWhenNoApprovalActive(
+              intent.followUpText,
+              () => this.trackDurableMobileEcho(session, evt, intent.followUpText, "free_form")
+            );
+            if (!freeFormResult.ok) {
+              if (!(0, import_codevibe_core7.requiresSyncInputDeliveryReceipt)(evt)) {
+                this.mobileDeduper.forget(session.sessionId, intent.followUpText);
+              }
+              logger.warn("Follow-up text send failed for approval", { reason: freeFormResult.reason });
+              return;
+            }
+          }
           await this.markExecuted(evt);
           return;
         }
-        promptContent = intent.followUpText;
-        await new Promise((resolve2) => setTimeout(resolve2, 250));
       } else {
+        const activeQuestionPrompt = pendingPrompts.find((p) => p.kind === "question");
+        if (activeQuestionPrompt) {
+          const isDisplayOnly = Object.keys(activeQuestionPrompt.submitMap || {}).length === 0;
+          logger.warn("Non-option input received while an interactive question prompt is active; rejecting dismissal", {
+            sessionId: session.sessionId,
+            promptId: activeQuestionPrompt.promptId,
+            isDisplayOnly,
+            content: promptContent.slice(0, 64)
+          });
+          const message = isDisplayOnly ? "The active terminal question prompt is display-only on mobile. Please select an option directly in your terminal." : "An interactive question prompt is active in your terminal. Please select one of the advertised options or answer directly in your terminal.";
+          await this.emitPromptSafetyNotification(session, message);
+          return;
+        }
         const hasDisplayOnlyPrompt = pendingPrompts.some(
           (p) => Object.keys(p.submitMap || {}).length === 0
         );
@@ -9230,6 +10375,7 @@ var __testing = {
 0 && (module.exports = {
   ApprovalDetector,
   McpServer,
+  PromptResponder,
   SessionNotFoundError,
   StoredAuthFailureError,
   TERMINAL_SHUTDOWN_SIGNALS,