@threadbase-sh/streamer 1.69.5 → 1.70.0

package/dist/cli.cjs

@@ -116376,7 +116376,7 @@ var require_query = __commonJS({
         if (typeof this.text !== "string" && typeof this.name !== "string") {
           return new Error("A query must have either text or a name. Supplying neither is unsupported.");
         }
-        const previous = connection.parsedStatements[this.name];
+        const previous = connection.parsedStatements[this.name] || connection.submittedNamedStatements[this.name];
         if (this.text && previous && this.text !== previous) {
           return new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
         }
@@ -116396,7 +116396,7 @@ var require_query = __commonJS({
         return null;
       }
       hasBeenParsed(connection) {
-        return this.name && connection.parsedStatements[this.name];
+        return this.name && (connection.parsedStatements[this.name] || connection.submittedNamedStatements[this.name]);
       }
       handlePortalSuspended(connection) {
         this._getRows(connection, this.rows);
@@ -116420,6 +116420,9 @@ var require_query = __commonJS({
             name: this.name,
             types: this.types
           });
+          if (this.name) {
+            connection.submittedNamedStatements[this.name] = this.text;
+          }
         }
         try {
           connection.bind({
@@ -117208,7 +117211,7 @@ var require_parser3 = __commonJS({
       const parameterCount = reader.int16();
       const message = new messages_1.ParameterDescriptionMessage(LATEINIT_LENGTH, parameterCount);
       for (let i = 0; i < parameterCount; i++) {
-        message.dataTypeIDs[i] = reader.int32();
+        message.dataTypeIDs[i] = reader.uint32();
       }
       return message;
     };
@@ -117430,6 +117433,7 @@ var require_connection2 = __commonJS({
         this._keepAlive = config2.keepAlive;
         this._keepAliveInitialDelayMillis = config2.keepAliveInitialDelayMillis;
         this.parsedStatements = {};
+        this.submittedNamedStatements = {};
         this.ssl = config2.ssl || false;
         this.sslNegotiation = config2.sslNegotiation || "postgres";
         this._ending = false;
@@ -117987,6 +117991,8 @@ var require_client3 = __commonJS({
           encoding: this.connectionParameters.client_encoding || "utf8"
         });
         this._queryQueue = [];
+        this._sentQueryQueue = [];
+        this.pipeline = Boolean(c.pipeline);
         this.binary = c.binary || defaults2.binary;
         this.processID = null;
         this.secretKey = null;
@@ -118021,6 +118027,8 @@ var require_client3 = __commonJS({
           enqueueError(activeQuery);
           this._activeQuery = null;
         }
+        this._sentQueryQueue.forEach(enqueueError);
+        this._sentQueryQueue.length = 0;
         this._queryQueue.forEach(enqueueError);
         this._queryQueue.length = 0;
       }
@@ -118263,6 +118271,9 @@ var require_client3 = __commonJS({
           return;
         }
         this._activeQuery = null;
+        if (activeQuery.name) {
+          delete this.connection.submittedNamedStatements[activeQuery.name];
+        }
         activeQuery.handleError(msg, this.connection);
       }
       _handleRowDescription(msg) {
@@ -118319,6 +118330,7 @@ var require_client3 = __commonJS({
         }
         if (activeQuery.name) {
           this.connection.parsedStatements[activeQuery.name] = activeQuery.text;
+          delete this.connection.submittedNamedStatements[activeQuery.name];
         }
       }
       _handleCopyInResponse(msg) {
@@ -118385,6 +118397,9 @@ var require_client3 = __commonJS({
           });
         } else if (client._queryQueue.indexOf(query) !== -1) {
           client._queryQueue.splice(client._queryQueue.indexOf(query), 1);
+        } else if (client._sentQueryQueue.indexOf(query) !== -1) {
+          query.callback = () => {
+          };
         }
       }
       setTypeParser(oid, format, parseFn) {
@@ -118403,6 +118418,10 @@ var require_client3 = __commonJS({
         return utils.escapeLiteral(str);
       }
       _pulseQueryQueue() {
+        if (this.pipeline) {
+          this._pulsePipelinedQueryQueue();
+          return;
+        }
         if (this.readyForQuery === true) {
           this._activeQuery = this._queryQueue.shift();
           const activeQuery = this._getActiveQuery();
@@ -118423,6 +118442,30 @@ var require_client3 = __commonJS({
           }
         }
       }
+      _pulsePipelinedQueryQueue() {
+        if (!this._connected || !this._queryable) {
+          return;
+        }
+        while (this._queryQueue.length > 0) {
+          const query = this._queryQueue.shift();
+          this.hasExecuted = true;
+          const queryError = query.submit(this.connection);
+          if (queryError) {
+            process.nextTick(() => {
+              query.handleError(queryError, this.connection);
+            });
+            continue;
+          }
+          this._sentQueryQueue.push(query);
+        }
+        if (this.readyForQuery && !this._activeQuery && this._sentQueryQueue.length > 0) {
+          this._activeQuery = this._sentQueryQueue.shift();
+          this.readyForQuery = false;
+        }
+        if (!this._activeQuery && this._sentQueryQueue.length === 0 && this._queryQueue.length === 0 && this.hasExecuted) {
+          this.emit("drain");
+        }
+      }
       query(config2, values, callback) {
         let query;
         let result;
@@ -118466,6 +118509,9 @@ var require_client3 = __commonJS({
             const index = this._queryQueue.indexOf(query);
             if (index > -1) {
               this._queryQueue.splice(index, 1);
+            } else if (this.pipeline) {
+              this.connection.stream.destroy();
+              return;
             }
             this._pulseQueryQueue();
           }, readTimeout);
@@ -118492,7 +118538,7 @@ var require_client3 = __commonJS({
           });
           return result;
         }
-        if (this._queryQueue.length > 0) {
+        if (this._queryQueue.length > 0 && !this.pipeline) {
           queryQueueLengthDeprecationNotice();
         }
         this._queryQueue.push(query);
@@ -118518,7 +118564,11 @@ var require_client3 = __commonJS({
             return this._Promise.resolve();
           }
         }
-        if (this._getActiveQuery() || !this._queryable) {
+        if (!this._queryable) {
+          this.connection.stream.destroy();
+        } else if (this.pipeline && (this._getActiveQuery() || this._sentQueryQueue.length > 0 || this._queryQueue.length > 0)) {
+          this.once("drain", () => this.connection.end());
+        } else if (this._getActiveQuery()) {
           this.connection.stream.destroy();
         } else {
           this.connection.end();
@@ -119008,7 +119058,7 @@ var require_query2 = __commonJS({
       sourceFunction: "routine"
     };
     NativeQuery.prototype.handleError = function(err) {
-      const fields = this.native.pq.resultErrorFields();
+      const fields = this.native && this.native.pq.resultErrorFields();
       if (fields) {
         for (const key in fields) {
           const normalizedFieldName = errorFieldMap[key] || key;
@@ -119142,6 +119192,8 @@ var require_client4 = __commonJS({
       this._connecting = false;
       this._connected = false;
       this._queryable = true;
+      this.pipeline = Boolean(config2.pipeline);
+      this._pipelineInFlight = false;
       const cp = this.connectionParameters = new ConnectionParameters(config2);
       if (config2.nativeConnectionString) cp.nativeConnectionString = config2.nativeConnectionString;
       this.user = cp.user;
@@ -119285,7 +119337,7 @@ var require_client4 = __commonJS({
         });
         return result;
       }
-      if (this._queryQueue.length > 0) {
+      if (this._queryQueue.length > 0 && !this.pipeline) {
         queryQueueLengthDeprecationNotice();
       }
       this._queryQueue.push(query);
@@ -119307,14 +119359,21 @@ var require_client4 = __commonJS({
           cb2 = (err) => err ? reject(err) : resolve4();
         });
       }
-      this.native.end(function() {
-        self2._connected = false;
-        self2._errorAllQueries(new Error("Connection terminated"));
-        process.nextTick(() => {
-          self2.emit("end");
-          if (cb2) cb2();
+      const doEnd = function() {
+        self2.native.end(function() {
+          self2._connected = false;
+          self2._errorAllQueries(new Error("Connection terminated"));
+          process.nextTick(() => {
+            self2.emit("end");
+            if (cb2) cb2();
+          });
         });
-      });
+      };
+      if (this.pipeline && (this._pipelineInFlight || this._queryQueue.length > 0)) {
+        this.once("drain", doEnd);
+      } else {
+        doEnd();
+      }
       return result;
     };
     Client2.prototype._hasActiveQuery = function() {
@@ -119324,6 +119383,9 @@ var require_client4 = __commonJS({
       if (!this._connected) {
         return;
       }
+      if (this.pipeline && !initialConnection) {
+        return this._pulsePipelinedQueryQueue();
+      }
       if (this._hasActiveQuery()) {
         return;
       }
@@ -119341,6 +119403,69 @@ var require_client4 = __commonJS({
         self2._pulseQueryQueue();
       });
     };
+    Client2.prototype._pulsePipelinedQueryQueue = function() {
+      if (!this._connected || this._pipelineInFlight) {
+        return;
+      }
+      if (this._queryQueue.length === 0) {
+        if (this.hasExecuted) {
+          this.emit("drain");
+        }
+        return;
+      }
+      this._pipelineInFlight = true;
+      const self2 = this;
+      const queries = [];
+      const nativeQueries = [];
+      const utils = require_utils5();
+      while (this._queryQueue.length > 0) {
+        const query = this._queryQueue.shift();
+        this.hasExecuted = true;
+        nativeQueries.push(query);
+        const values = query.values ? query.values.map(utils.prepareValue) : null;
+        const pipelineEntry = { text: query.text, name: query.name };
+        if (values) {
+          pipelineEntry.values = values;
+        }
+        if (query.name && this.namedQueries[query.name]) {
+          pipelineEntry._alreadyPrepared = true;
+        }
+        queries.push(pipelineEntry);
+      }
+      this.native.pipeline(queries, function(err, results) {
+        self2._pipelineInFlight = false;
+        if (err) {
+          for (let i = 0; i < nativeQueries.length; i++) {
+            const q2 = nativeQueries[i];
+            q2.native = self2.native;
+            q2.handleError(err);
+          }
+          self2._pulsePipelinedQueryQueue();
+          return;
+        }
+        for (let i = 0; i < nativeQueries.length; i++) {
+          const q2 = nativeQueries[i];
+          const r = results[i];
+          q2.native = self2.native;
+          if (r.err) {
+            q2.handleError(r.err);
+          } else {
+            if (q2.name) {
+              self2.namedQueries[q2.name] = q2.text;
+            }
+            q2.state = "end";
+            q2.emit("end", r.result);
+            if (q2.callback) {
+              q2.callback(null, r.result);
+            }
+          }
+          setImmediate(function() {
+            q2.emit("_done");
+          });
+        }
+        self2._pulsePipelinedQueryQueue();
+      });
+    };
     Client2.prototype.cancel = function(query) {
       if (this._activeQuery === query) {
         this.native.cancel(function() {
@@ -120610,7 +120735,7 @@ var PTY_HOST_PROTOCOL_VERSION, SESSION_DATE_FIELDS, LineDecoder;
 var init_protocol = __esm({
   "src/pty-host/protocol.ts"() {
     "use strict";
-    PTY_HOST_PROTOCOL_VERSION = 3;
+    PTY_HOST_PROTOCOL_VERSION = 4;
     SESSION_DATE_FIELDS = [
       "startedAt",
       "completedAt",
@@ -120690,8 +120815,12 @@ var init_remote_session_runner = __esm({
           }
           throw new PtyHostProtocolMismatchError(status.protocolVersion, PTY_HOST_PROTOCOL_VERSION);
         }
-        await runner.request({ type: "subscribe" });
+        const subscribed = await runner.request({ type: "subscribe" });
         runner.refreshMirror(status);
+        runner.restorePromptSnapshots({
+          ...status,
+          promptSnapshots: subscribed.promptSnapshots ?? status.promptSnapshots
+        });
         return runner;
       }
       constructor(transport, options) {
@@ -120784,6 +120913,19 @@ var init_remote_session_runner = __esm({
           this.pids.set(session.id, entry.pid);
         }
       }
+      restorePromptSnapshots(status) {
+        for (const snapshot of status.promptSnapshots ?? []) {
+          if (snapshot.kind === "permission") {
+            this.options.onPermissionChange?.(snapshot.sessionId, snapshot.gate, snapshot.occurrenceId);
+          } else {
+            this.options.onLiveQuestion?.(
+              snapshot.sessionId,
+              snapshot.questions,
+              snapshot.occurrenceId
+            );
+          }
+        }
+      }
       async heartbeat(state, timeoutMs = HOST_HEARTBEAT_REQUEST_TIMEOUT_MS) {
         await this.request({ type: "heartbeat", ...state }, timeoutMs);
       }
@@ -120838,13 +120980,13 @@ var init_remote_session_runner = __esm({
             break;
           }
           case "permission-change":
-            this.options.onPermissionChange?.(event.sessionId, event.gate);
+            this.options.onPermissionChange?.(event.sessionId, event.gate, event.occurrenceId);
             break;
           case "phase-change":
             this.options.onPhaseChange?.(event.sessionId, event.phase);
             break;
           case "live-question":
-            this.options.onLiveQuestion?.(event.sessionId, event.questions);
+            this.options.onLiveQuestion?.(event.sessionId, event.questions, event.occurrenceId);
             break;
           case "live-question-gone":
             this.options.onLiveQuestionGone?.(event.sessionId);
@@ -128466,12 +128608,15 @@ __export(host_exports, {
   HOST_ORPHAN_SWEEP_MS: () => HOST_ORPHAN_SWEEP_MS,
   SessionHost: () => SessionHost
 });
-var HOST_IDLE_SWEEP_MS, HOST_IDLE_AFTER_MS, HOST_HEARTBEAT_TIMEOUT_MS, HOST_ORPHAN_SWEEP_MS, SessionHost;
+var import_node_crypto8, HOST_IDLE_SWEEP_MS, HOST_IDLE_AFTER_MS, HOST_HEARTBEAT_TIMEOUT_MS, HOST_ORPHAN_SWEEP_MS, SessionHost;
 var init_host = __esm({
   "src/pty-host/host.ts"() {
     "use strict";
+    import_node_crypto8 = require("crypto");
     init_live_session_manager();
     init_logger();
+    init_detectPermissionGate();
+    init_detectQuestionFromScreen();
     init_protocol();
     HOST_IDLE_SWEEP_MS = 5 * 60 * 1e3;
     HOST_IDLE_AFTER_MS = 6 * 60 * 60 * 1e3;
@@ -128493,6 +128638,7 @@ var init_host = __esm({
       orphanTimer = null;
       onOrphaned;
       orphaned = false;
+      promptSnapshots = /* @__PURE__ */ new Map();
       constructor(options = {}) {
         this.log = options.logger ?? getLogger("pty-host");
         this.idleAfterMs = options.idleAfterMs ?? HOST_IDLE_AFTER_MS;
@@ -128505,12 +128651,55 @@ var init_host = __esm({
             this.lastAgentChunkAt.set(sessionId, Date.now());
             this.emit({ type: "event", event: "output", sessionId, data });
           },
-          onStatusChange: (session) => this.emit({ type: "event", event: "status-change", session }),
+          onStatusChange: (session) => {
+            if (session.status === "idle") this.promptSnapshots.delete(session.id);
+            this.emit({ type: "event", event: "status-change", session });
+          },
           onReady: (session) => this.emit({ type: "event", event: "ready", session }),
-          onPermissionChange: (sessionId, gate) => this.emit({ type: "event", event: "permission-change", sessionId, gate }),
+          onPermissionChange: (sessionId, gate) => {
+            const prior = this.promptSnapshots.get(sessionId);
+            if (gate === null) {
+              this.promptSnapshots.delete(sessionId);
+              this.emit({
+                type: "event",
+                event: "permission-change",
+                sessionId,
+                gate,
+                ...prior ? { occurrenceId: prior.occurrenceId } : {}
+              });
+              return;
+            }
+            const occurrenceId = prior?.kind === "permission" && permissionGateKey(prior.gate) === permissionGateKey(gate) ? prior.occurrenceId : (0, import_node_crypto8.randomUUID)();
+            this.promptSnapshots.set(sessionId, {
+              kind: "permission",
+              sessionId,
+              occurrenceId,
+              gate
+            });
+            this.emit({
+              type: "event",
+              event: "permission-change",
+              sessionId,
+              gate,
+              occurrenceId
+            });
+          },
           onPhaseChange: (sessionId, phase) => this.emit({ type: "event", event: "phase-change", sessionId, phase }),
-          onLiveQuestion: (sessionId, questions) => this.emit({ type: "event", event: "live-question", sessionId, questions }),
-          onLiveQuestionGone: (sessionId) => this.emit({ type: "event", event: "live-question-gone", sessionId }),
+          onLiveQuestion: (sessionId, questions) => {
+            const prior = this.promptSnapshots.get(sessionId);
+            const occurrenceId = prior?.kind === "question" && questionContentKey(prior.questions) === questionContentKey(questions) ? prior.occurrenceId : (0, import_node_crypto8.randomUUID)();
+            this.promptSnapshots.set(sessionId, {
+              kind: "question",
+              sessionId,
+              occurrenceId,
+              questions
+            });
+            this.emit({ type: "event", event: "live-question", sessionId, questions, occurrenceId });
+          },
+          onLiveQuestionGone: (sessionId) => {
+            this.promptSnapshots.delete(sessionId);
+            this.emit({ type: "event", event: "live-question-gone", sessionId });
+          },
           onUserMessage: (sessionId, text, ts2) => this.emit({ type: "event", event: "user-message", sessionId, text, ts: ts2 })
         });
         this.idleTimer = setInterval(() => this.reapIdle(), options.idleSweepMs ?? HOST_IDLE_SWEEP_MS);
@@ -128579,11 +128768,12 @@ var init_host = __esm({
               event: "pty_host.streamer_subscribed",
               subscribers: this.subscribers.size
             });
-            return {};
+            return { promptSnapshots: [...this.promptSnapshots.values()] };
           case "status":
             return {
               protocolVersion: PTY_HOST_PROTOCOL_VERSION,
-              sessions: this.runner.listSessions().map((session) => this.toHostSession(session))
+              sessions: this.runner.listSessions().map((session) => this.toHostSession(session)),
+              promptSnapshots: [...this.promptSnapshots.values()]
             };
           case "heartbeat":
             this.heartbeatLeases.set(transport, Date.now());
@@ -128641,6 +128831,7 @@ var init_host = __esm({
       }
       forget(sessionId) {
         this.lastAgentChunkAt.delete(sessionId);
+        this.promptSnapshots.delete(sessionId);
       }
       /**
        * Release PTYs whose agent has been silent past the threshold.
@@ -132718,13 +132909,13 @@ var checkOptionalParameter = (path2) => {
     if (segment !== "" && !/\:/.test(segment)) {
       basePath += "/" + segment;
     } else if (/\:/.test(segment)) {
-      if (/\?/.test(segment)) {
+      if (segment.charCodeAt(segment.length - 1) === 63) {
         if (results.length === 0 && basePath === "") {
           results.push("/");
         } else {
           results.push(basePath);
         }
-        const optionalSegment = segment.replace("?", "");
+        const optionalSegment = segment.slice(0, -1);
         basePath += "/" + optionalSegment;
         results.push(basePath);
       } else {
@@ -132734,18 +132925,16 @@ var checkOptionalParameter = (path2) => {
   });
   return results.filter((v2, i, a) => a.indexOf(v2) === i);
 };
+var tryDecodeURIComponent = (str) => str.indexOf("%") !== -1 ? tryDecode(str, decodeURIComponent_) : str;
 var _decodeURI = (value) => {
-  if (!/[%+]/.test(value)) {
-    return value;
-  }
   if (value.indexOf("+") !== -1) {
     value = value.replace(/\+/g, " ");
   }
-  return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
+  return tryDecodeURIComponent(value);
 };
 var _getQueryParam = (url2, key, multiple) => {
   let encoded;
-  if (!multiple && key && !/[%+]/.test(key)) {
+  if (!multiple && key && key.indexOf("%") === -1 && key.indexOf("+") === -1) {
     let keyIndex2 = url2.indexOf("?", 8);
     if (keyIndex2 === -1) {
       return void 0;
@@ -132817,7 +133006,6 @@ var getQueryParams = (url2, key) => {
 var decodeURIComponent_ = decodeURIComponent;
 
 // node_modules/hono/dist/request.js
-var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
 var HonoRequest = class {
   /**
    * `.raw` can get the raw Request object.
@@ -132856,7 +133044,6 @@ var HonoRequest = class {
     this.raw = request;
     this.path = path2;
     this.#matchResult = matchResult;
-    this.#validatedData = {};
   }
   param(key) {
     return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
@@ -132864,7 +133051,7 @@ var HonoRequest = class {
   #getDecodedParam(key) {
     const paramKey = this.#matchResult[0][this.routeIndex][1][key];
     const param = this.#getParamValue(paramKey);
-    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
+    return param && tryDecodeURIComponent(param);
   }
   #getAllDecodedParams() {
     const decoded = {};
@@ -132872,7 +133059,7 @@ var HonoRequest = class {
     for (const key of keys) {
       const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
       if (value !== void 0) {
-        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
+        decoded[key] = tryDecodeURIComponent(value);
       }
     }
     return decoded;
@@ -132905,8 +133092,7 @@ var HonoRequest = class {
     if (cachedBody) {
       return cachedBody;
     }
-    const anyCachedKey = Object.keys(bodyCache)[0];
-    if (anyCachedKey) {
+    for (const anyCachedKey in bodyCache) {
       return bodyCache[anyCachedKey].then((body) => {
         if (anyCachedKey === "json") {
           body = JSON.stringify(body);
@@ -133009,10 +133195,11 @@ var HonoRequest = class {
    * @param data - The validated data to add.
    */
   addValidatedData(target, data) {
-    this.#validatedData[target] = data;
+    ;
+    (this.#validatedData ??= {})[target] = data;
   }
   valid(target) {
-    return this.#validatedData[target];
+    return this.#validatedData?.[target];
   }
   /**
    * `.url()` can get the request url strings.
@@ -133343,6 +133530,10 @@ var Context = class {
    *   c.header('X-Message', 'Hello!')
    *   c.header('Content-Type', 'text/plain')
    *
+   *   // Append multiple headers using the append option (e.g. Vary)
+   *   c.header('Vary', 'Accept-Encoding', { append: true })
+   *   c.header('Vary', 'User-Agent', { append: true })
+   *
    *   return c.body('Thank you for coming')
    * })
    * ```
@@ -133414,11 +133605,11 @@ var Context = class {
     return Object.fromEntries(this.#var);
   }
   #newResponse(data, arg, headers) {
-    const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers();
-    if (typeof arg === "object" && "headers" in arg) {
-      const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
-      for (const [key, value] of argHeaders) {
-        if (key.toLowerCase() === "set-cookie") {
+    let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+    if (typeof arg === "object" && arg.headers) {
+      responseHeaders ??= new Headers();
+      for (const [key, value] of new Headers(arg.headers)) {
+        if (key === "set-cookie") {
           responseHeaders.append(key, value);
         } else {
           responseHeaders.set(key, value);
@@ -133426,19 +133617,34 @@ var Context = class {
       }
     }
     if (headers) {
-      for (const [k2, v2] of Object.entries(headers)) {
-        if (typeof v2 === "string") {
-          responseHeaders.set(k2, v2);
-        } else {
-          responseHeaders.delete(k2);
-          for (const v22 of v2) {
-            responseHeaders.append(k2, v22);
+      if (!responseHeaders) {
+        let count = 0;
+        for (const k2 in headers) {
+          if (++count > 1 || typeof headers[k2] !== "string") {
+            responseHeaders = new Headers();
+            break;
+          }
+        }
+      }
+      if (responseHeaders) {
+        for (const k2 in headers) {
+          const v2 = headers[k2];
+          if (typeof v2 === "string") {
+            responseHeaders.set(k2, v2);
+          } else {
+            responseHeaders.delete(k2);
+            for (const v22 of v2) {
+              responseHeaders.append(k2, v22);
+            }
           }
         }
       }
     }
     const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
-    return createResponseInstance(data, { status, headers: responseHeaders });
+    return createResponseInstance(data, {
+      status,
+      headers: responseHeaders ?? headers
+    });
   }
   newResponse = (...args) => this.#newResponse(...args);
   /**
@@ -133551,7 +133757,7 @@ var Context = class {
 // node_modules/hono/dist/router.js
 var METHOD_NAME_ALL = "ALL";
 var METHOD_NAME_ALL_LOWERCASE = "all";
-var METHODS = ["get", "post", "put", "delete", "options", "patch"];
+var METHODS = ["get", "post", "put", "delete", "options", "patch", "query"];
 var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
 var UnsupportedPathError = class extends Error {
 };
@@ -133578,6 +133784,7 @@ var Hono = class _Hono {
   delete;
   options;
   patch;
+  query;
   all;
   on;
   use;
@@ -133877,8 +134084,8 @@ var Hono = class _Hono {
    * @see {@link https://hono.dev/docs/api/hono#fetch}
    *
    * @param {Request} request - request Object of request
-   * @param {Env} Env - env Object
-   * @param {ExecutionContext} - context of execution
+   * @param {Env} env - env Object
+   * @param {ExecutionContext} executionCtx - context of execution
    * @returns {Response | Promise<Response>} response of request
    *
    */
@@ -133970,7 +134177,7 @@ function compareKey(a, b2) {
     return 1;
   }
   if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
-    return 1;
+    return b2 === TAIL_WILDCARD_REG_EXP_STR ? -1 : 1;
   } else if (b2 === ONLY_WILDCARD_REG_EXP_STR || b2 === TAIL_WILDCARD_REG_EXP_STR) {
     return -1;
   }
@@ -133982,76 +134189,75 @@ function compareKey(a, b2) {
   return a.length === b2.length ? a < b2 ? -1 : 1 : b2.length - a.length;
 }
 var Node = class _Node {
+  // handler index of a dynamic path, or -1 for a static path terminal
   #index;
   #varIndex;
   #children = /* @__PURE__ */ Object.create(null);
-  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
-    if (tokens.length === 0) {
-      if (this.#index !== void 0) {
-        throw PATH_ERROR;
-      }
-      if (pathErrorCheckOnly) {
-        return;
-      }
-      this.#index = index;
-      return;
-    }
-    const [token, ...restTokens] = tokens;
-    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-    let node;
-    if (pattern) {
-      const name = pattern[1];
-      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-      if (name && pattern[2]) {
-        if (regexpStr === ".*") {
-          throw PATH_ERROR;
-        }
-        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
-        if (/\((?!\?:)/.test(regexpStr)) {
-          throw PATH_ERROR;
-        }
-      }
-      node = this.#children[regexpStr];
-      if (!node) {
-        if (Object.keys(this.#children).some(
-          (k2) => k2 !== ONLY_WILDCARD_REG_EXP_STR && k2 !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
+  insert(tokens, index, paramMap, context, isStatic) {
+    let node = this;
+    for (let i = 0, len = tokens.length; i < len; i++) {
+      const token = tokens[i];
+      const pattern = token.length === 1 ? token === "*" ? i === len - 1 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : null : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+      let nextNode;
+      if (pattern) {
+        const name = pattern[1];
+        let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+        if (name && pattern[2]) {
+          if (regexpStr === ".*") {
+            throw PATH_ERROR;
+          }
+          regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+          if (/\((?!\?:)/.test(regexpStr)) {
+            throw PATH_ERROR;
+          }
+          if (regexpStr.length === 1 && regExpMetaChars.has(regexpStr)) {
+            throw PATH_ERROR;
+          }
+        }
+        nextNode = node.#children[regexpStr];
+        if (!nextNode) {
+          if (regexpStr !== ONLY_WILDCARD_REG_EXP_STR && regexpStr !== TAIL_WILDCARD_REG_EXP_STR) {
+            for (const k2 in node.#children) {
+              if (
+                // a single-char pattern coexists with single-char literals as a literal does
+                (regexpStr.length > 1 || k2.length > 1) && k2 !== ONLY_WILDCARD_REG_EXP_STR && k2 !== TAIL_WILDCARD_REG_EXP_STR
+              ) {
+                throw PATH_ERROR;
+              }
+            }
+          }
+          nextNode = node.#children[regexpStr] = new _Node();
         }
-        node = this.#children[regexpStr] = new _Node();
         if (name !== "") {
-          node.#varIndex = context.varIndex++;
+          nextNode.#varIndex ??= context.varIndex++;
+          paramMap.push([name, nextNode.#varIndex]);
         }
-      }
-      if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.#varIndex]);
-      }
-    } else {
-      node = this.#children[token];
-      if (!node) {
-        if (Object.keys(this.#children).some(
-          (k2) => k2.length > 1 && k2 !== ONLY_WILDCARD_REG_EXP_STR && k2 !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
+      } else {
+        nextNode = node.#children[token];
+        if (!nextNode) {
+          for (const k2 in node.#children) {
+            if (k2.length > 1 && k2 !== ONLY_WILDCARD_REG_EXP_STR && k2 !== TAIL_WILDCARD_REG_EXP_STR) {
+              throw PATH_ERROR;
+            }
+          }
+          nextNode = node.#children[token] = new _Node();
         }
-        node = this.#children[token] = new _Node();
       }
+      node = nextNode;
+    }
+    if (node.#index !== void 0) {
+      throw PATH_ERROR;
     }
-    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+    node.#index = isStatic ? -1 : index;
   }
   buildRegExpStr() {
     const childKeys = Object.keys(this.#children).sort(compareKey);
     const strList = childKeys.map((k2) => {
       const c = this.#children[k2];
-      return (typeof c.#varIndex === "number" ? `(${k2})@${c.#varIndex}` : regExpMetaChars.has(k2) ? `\\${k2}` : k2) + c.buildRegExpStr();
-    });
-    if (typeof this.#index === "number") {
+      const childStr = c.buildRegExpStr();
+      return childStr === "" ? "" : (typeof c.#varIndex === "number" ? `(${k2})@${c.#varIndex}` : regExpMetaChars.has(k2) ? `\\${k2}` : k2) + childStr;
+    }).filter(Boolean);
+    if (typeof this.#index === "number" && this.#index !== -1) {
       strList.unshift(`#${this.#index}`);
     }
     if (strList.length === 0) {
@@ -134068,12 +134274,20 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path2, index, pathErrorCheckOnly) {
+  #index = 0;
+  // dynamic path -> [handler index, param assoc]; static paths are not registered
+  paths = /* @__PURE__ */ Object.create(null);
+  insert(path2, isStatic) {
+    if (isStatic) {
+      this.#root.insert(path2.split(""), 0, [], this.#context, true);
+      return;
+    }
     const paramAssoc = [];
     const groups = [];
+    let markedPath = path2;
     for (let i = 0; ; ) {
       let replaced = false;
-      path2 = path2.replace(/\{[^}]+\}/g, (m2) => {
+      markedPath = markedPath.replace(/\{[^}]+\}/g, (m2) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m2];
         i++;
@@ -134084,7 +134298,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path2.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j2 = tokens.length - 1; j2 >= 0; j2--) {
@@ -134094,8 +134308,8 @@ var Trie = class {
         }
       }
     }
-    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
-    return paramAssoc;
+    this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
+    this.paths[path2] = [this.#index++, paramAssoc];
   }
   buildRegExp() {
     let regexp = this.#root.buildRegExpStr();
@@ -134121,7 +134335,6 @@ var Trie = class {
 };
 
 // node_modules/hono/dist/router/reg-exp-router/router.js
-var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 function buildWildcardRegExp(path2) {
   return wildcardRegExpCache[path2] ??= new RegExp(
@@ -134134,63 +134347,6 @@ function buildWildcardRegExp(path2) {
 function clearWildcardRegExpCache() {
   wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 }
-function buildMatcherFromPreprocessedRoutes(routes) {
-  const trie = new Trie();
-  const handlerData = [];
-  if (routes.length === 0) {
-    return nullMatcher;
-  }
-  const routesWithStaticPathFlag = routes.map(
-    (route) => [!/\*|\/:/.test(route[0]), ...route]
-  ).sort(
-    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
-  );
-  const staticMap = /* @__PURE__ */ Object.create(null);
-  for (let i = 0, j2 = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path2, handlers] = routesWithStaticPathFlag[i];
-    if (pathErrorCheckOnly) {
-      staticMap[path2] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
-    } else {
-      j2++;
-    }
-    let paramAssoc;
-    try {
-      paramAssoc = trie.insert(path2, j2, pathErrorCheckOnly);
-    } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path2) : e;
-    }
-    if (pathErrorCheckOnly) {
-      continue;
-    }
-    handlerData[j2] = handlers.map(([h, paramCount]) => {
-      const paramIndexMap = /* @__PURE__ */ Object.create(null);
-      paramCount -= 1;
-      for (; paramCount >= 0; paramCount--) {
-        const [key, value] = paramAssoc[paramCount];
-        paramIndexMap[key] = value;
-      }
-      return [h, paramIndexMap];
-    });
-  }
-  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-  for (let i = 0, len = handlerData.length; i < len; i++) {
-    for (let j2 = 0, len2 = handlerData[i].length; j2 < len2; j2++) {
-      const map2 = handlerData[i][j2]?.[1];
-      if (!map2) {
-        continue;
-      }
-      const keys = Object.keys(map2);
-      for (let k2 = 0, len3 = keys.length; k2 < len3; k2++) {
-        map2[keys[k2]] = paramReplacementMap[map2[keys[k2]]];
-      }
-    }
-  }
-  const handlerMap = [];
-  for (const i in indexReplacementMap) {
-    handlerMap[i] = handlerData[indexReplacementMap[i]];
-  }
-  return [regexp, handlerMap, staticMap];
-}
 function findMiddleware(middleware, path2) {
   if (!middleware) {
     return void 0;
@@ -134206,9 +134362,18 @@ var RegExpRouter = class {
   name = "RegExpRouter";
   #middleware;
   #routes;
+  #tries;
   constructor() {
     this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
     this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#tries = { [METHOD_NAME_ALL]: new Trie() };
+  }
+  #insertPath(method, path2) {
+    try {
+      this.#tries[method].insert(path2, !/\*|\/:/.test(path2));
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path2) : e;
+    }
   }
   add(method, path2, handler) {
     const middleware = this.#middleware;
@@ -134217,11 +134382,12 @@ var RegExpRouter = class {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
     if (!middleware[method]) {
-      ;
+      this.#tries[method] = new Trie();
       [middleware, routes].forEach((handlerMap) => {
         handlerMap[method] = /* @__PURE__ */ Object.create(null);
         Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p2) => {
           handlerMap[method][p2] = [...handlerMap[METHOD_NAME_ALL][p2]];
+          this.#insertPath(method, p2);
         });
       });
     }
@@ -134231,13 +134397,12 @@ var RegExpRouter = class {
     const paramCount = (path2.match(/\/:/g) || []).length;
     if (/\*$/.test(path2)) {
       const re2 = buildWildcardRegExp(path2);
-      if (method === METHOD_NAME_ALL) {
-        Object.keys(middleware).forEach((m2) => {
-          middleware[m2][path2] ||= findMiddleware(middleware[m2], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || [];
-        });
-      } else {
-        middleware[method][path2] ||= findMiddleware(middleware[method], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || [];
-      }
+      Object.keys(middleware).forEach((m2) => {
+        if ((method === METHOD_NAME_ALL || method === m2) && !middleware[m2][path2]) {
+          this.#insertPath(m2, path2);
+          middleware[m2][path2] = findMiddleware(middleware[m2], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || [];
+        }
+      });
       Object.keys(middleware).forEach((m2) => {
         if (method === METHOD_NAME_ALL || method === m2) {
           Object.keys(middleware[m2]).forEach((p2) => {
@@ -134259,9 +134424,12 @@ var RegExpRouter = class {
       const path22 = paths[i];
       Object.keys(routes).forEach((m2) => {
         if (method === METHOD_NAME_ALL || method === m2) {
-          routes[m2][path22] ||= [
-            ...findMiddleware(middleware[m2], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || []
-          ];
+          if (!routes[m2][path22]) {
+            this.#insertPath(m2, path22);
+            routes[m2][path22] = [
+              ...findMiddleware(middleware[m2], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || []
+            ];
+          }
           routes[m2][path22].push([handler, paramCount - len + i + 1]);
         }
       });
@@ -134273,29 +134441,54 @@ var RegExpRouter = class {
     Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
       matchers[method] ||= this.#buildMatcher(method);
     });
-    this.#middleware = this.#routes = void 0;
+    this.#middleware = this.#routes = this.#tries = void 0;
     clearWildcardRegExpCache();
     return matchers;
   }
   #buildMatcher(method) {
-    const routes = [];
-    let hasOwnRoute = method === METHOD_NAME_ALL;
-    [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path2) => [path2, r[method][path2]]) : [];
-      if (ownRoute.length !== 0) {
-        hasOwnRoute ||= true;
-        routes.push(...ownRoute);
-      } else if (method !== METHOD_NAME_ALL) {
-        routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path2) => [path2, r[METHOD_NAME_ALL][path2]])
-        );
+    const middleware = this.#middleware[method];
+    const routes = this.#routes[method];
+    const trie = this.#tries[method];
+    const staticMap = /* @__PURE__ */ Object.create(null);
+    const handlerData = [];
+    [middleware, routes].forEach((r) => {
+      for (const path2 in r) {
+        const handlers = r[path2];
+        const pathData = trie.paths[path2];
+        if (!pathData) {
+          staticMap[path2] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+          continue;
+        }
+        const paramAssoc = pathData[1];
+        handlerData[pathData[0]] = handlers.map(([h, paramCount]) => {
+          const paramIndexMap = /* @__PURE__ */ Object.create(null);
+          paramCount -= 1;
+          for (; paramCount >= 0; paramCount--) {
+            const [key, value] = paramAssoc[paramCount];
+            paramIndexMap[key] = value;
+          }
+          return [h, paramIndexMap];
+        });
       }
     });
-    if (!hasOwnRoute) {
-      return null;
-    } else {
-      return buildMatcherFromPreprocessedRoutes(routes);
+    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+    for (let i = 0, len = handlerData.length; i < len; i++) {
+      for (let j2 = 0, len2 = handlerData[i].length; j2 < len2; j2++) {
+        const map2 = handlerData[i][j2]?.[1];
+        if (!map2) {
+          continue;
+        }
+        const keys = Object.keys(map2);
+        for (let k2 = 0, len3 = keys.length; k2 < len3; k2++) {
+          map2[keys[k2]] = paramReplacementMap[map2[keys[k2]]];
+        }
+      }
+    }
+    const handlerMap = [];
+    for (const i in indexReplacementMap) {
+      handlerMap[i] = handlerData[indexReplacementMap[i]];
     }
+    return [regexp, handlerMap, staticMap];
   }
 };
 
@@ -134356,76 +134549,51 @@ var SmartRouter = class {
 
 // node_modules/hono/dist/router/trie-router/node.js
 var emptyParams = /* @__PURE__ */ Object.create(null);
-var hasChildren = (children) => {
-  for (const _2 in children) {
-    return true;
-  }
-  return false;
-};
+var order = 0;
 var Node2 = class _Node2 {
-  #methods;
-  #children;
-  #patterns;
-  #order = 0;
+  #methods = [];
+  #children = /* @__PURE__ */ Object.create(null);
+  #patterns = [];
+  #pattern;
   #params = emptyParams;
-  constructor(method, handler, children) {
-    this.#children = children || /* @__PURE__ */ Object.create(null);
-    this.#methods = [];
-    if (method && handler) {
-      const m2 = /* @__PURE__ */ Object.create(null);
-      m2[method] = { handler, possibleKeys: [], score: 0 };
-      this.#methods = [m2];
-    }
-    this.#patterns = [];
-  }
   insert(method, path2, handler) {
-    this.#order = ++this.#order;
     let curNode = this;
     const parts = splitRoutingPath(path2);
-    const possibleKeys = [];
-    for (let i = 0, len = parts.length; i < len; i++) {
-      const p2 = parts[i];
-      const nextP = parts[i + 1];
-      const pattern = getPattern(p2, nextP);
-      const key = Array.isArray(pattern) ? pattern[0] : p2;
-      if (key in curNode.#children) {
-        curNode = curNode.#children[key];
-        if (pattern) {
-          possibleKeys.push(pattern[1]);
-        }
-        continue;
+    const possibleKeys = /* @__PURE__ */ new Set();
+    let i = 0;
+    for (const p2 of parts) {
+      const nextP = parts[++i];
+      const pattern = getPattern(p2, nextP) || (nextP === void 0 && p2 && p2.indexOf("*") === p2.length - 1 ? p2 : null);
+      const isParam = Array.isArray(pattern);
+      const key = isParam ? pattern[0] : pattern || p2;
+      const child = curNode.#children[key] ||= new _Node2();
+      if (pattern && !child.#pattern) {
+        child.#pattern = pattern;
+        curNode.#patterns.push(child);
       }
-      curNode.#children[key] = new _Node2();
-      if (pattern) {
-        curNode.#patterns.push(pattern);
-        possibleKeys.push(pattern[1]);
+      curNode = child;
+      if (isParam) {
+        possibleKeys.add(pattern[1]);
       }
-      curNode = curNode.#children[key];
     }
     curNode.#methods.push({
       [method]: {
         handler,
-        possibleKeys: possibleKeys.filter((v2, i, a) => a.indexOf(v2) === i),
-        score: this.#order
+        possibleKeys: [...possibleKeys],
+        score: ++order
       }
     });
-    return curNode;
   }
   #pushHandlerSets(handlerSets, node, method, nodeParams, params) {
     for (let i = 0, len = node.#methods.length; i < len; i++) {
       const m2 = node.#methods[i];
       const handlerSet = m2[method] || m2[METHOD_NAME_ALL];
-      const processedSet = {};
-      if (handlerSet !== void 0) {
+      if (handlerSet) {
         handlerSet.params = /* @__PURE__ */ Object.create(null);
         handlerSets.push(handlerSet);
-        if (nodeParams !== emptyParams || params && params !== emptyParams) {
-          for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
-            const key = handlerSet.possibleKeys[i2];
-            const processed = processedSet[handlerSet.score];
-            handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
-            processedSet[handlerSet.score] = true;
-          }
+        for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+          const key = handlerSet.possibleKeys[i2];
+          handlerSet.params[key] = params?.[key] && !i2 ? params[key] : nodeParams[key] ?? params?.[key];
         }
       }
     }
@@ -134457,33 +134625,33 @@ var Node2 = class _Node2 {
             tempNodes.push(nextNode);
           }
         }
-        for (let k2 = 0, len3 = node.#patterns.length; k2 < len3; k2++) {
-          const pattern = node.#patterns[k2];
+        for (const child of node.#patterns) {
+          const pattern = child.#pattern;
           const params = node.#params === emptyParams ? {} : { ...node.#params };
-          if (pattern === "*") {
-            const astNode = node.#children["*"];
-            if (astNode) {
-              this.#pushHandlerSets(handlerSets, astNode, method, node.#params);
-              astNode.#params = params;
-              tempNodes.push(astNode);
+          if (typeof pattern === "string") {
+            if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
+              this.#pushHandlerSets(handlerSets, child, method, node.#params);
+              if (pattern === "*") {
+                child.#params = params;
+                tempNodes.push(child);
+              }
             }
             continue;
           }
-          const [key, name, matcher] = pattern;
-          if (!part && !(matcher instanceof RegExp)) {
+          const [, name, matcher] = pattern;
+          if (!part && matcher === true) {
             continue;
           }
-          const child = node.#children[key];
-          if (matcher instanceof RegExp) {
-            if (partOffsets === null) {
-              partOffsets = new Array(len);
+          if (matcher !== true) {
+            if (!partOffsets) {
+              partOffsets = [];
               let offset = path2[0] === "/" ? 1 : 0;
               for (let p2 = 0; p2 < len; p2++) {
                 partOffsets[p2] = offset;
                 offset += parts[p2].length + 1;
               }
             }
-            const restPathString = path2.substring(partOffsets[i]);
+            const restPathString = path2.slice(partOffsets[i]);
             const m2 = matcher.exec(restPathString);
             if (m2) {
               params[name] = m2[0];
@@ -134497,11 +134665,12 @@ var Node2 = class _Node2 {
                   params
                 );
               }
-              if (hasChildren(child.#children)) {
+              for (const _2 in child.#children) {
                 child.#params = params;
-                const componentCount = m2[0].match(/\//)?.length ?? 0;
+                const componentCount = m2[0].match(/\//g)?.length ?? 0;
                 const targetCurNodes = curNodesQueue[componentCount] ||= [];
                 targetCurNodes.push(child);
+                break;
               }
               continue;
             }
@@ -134529,7 +134698,7 @@ var Node2 = class _Node2 {
       const shifted = curNodesQueue.shift();
       curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
     }
-    if (handlerSets.length > 1) {
+    if (handlerSets[1]) {
       handlerSets.sort((a, b2) => {
         return a.score - b2.score;
       });
@@ -134541,19 +134710,11 @@ var Node2 = class _Node2 {
 // node_modules/hono/dist/router/trie-router/router.js
 var TrieRouter = class {
   name = "TrieRouter";
-  #node;
-  constructor() {
-    this.#node = new Node2();
-  }
+  #node = new Node2();
   add(method, path2, handler) {
-    const results = checkOptionalParameter(path2);
-    if (results) {
-      for (let i = 0, len = results.length; i < len; i++) {
-        this.#node.insert(method, results[i], handler);
-      }
-      return;
+    for (const result of checkOptionalParameter(path2) || [path2]) {
+      this.#node.insert(method, result, handler);
     }
-    this.#node.insert(method, path2, handler);
   }
   match(method, path2) {
     return this.#node.search(method, path2);
@@ -136057,7 +136218,13 @@ var createMiscRoutes = (deps) => {
       // the box is starved. Additive capability flag only — live readings stay
       // off this polled endpoint. Absent means an older server that never
       // samples. Informational: pressure never holds, kills, or refuses sessions.
-      hostPressure: true
+      hostPressure: true,
+      // Provider-neutral prompt contract: normalized prompt events, opaque ids
+      // and the atomic /prompt/answer route. A prompt_snapshot on subscribe
+      // carries RETAINED prompts, terminal ones included — render on `state`,
+      // not on presence — and an answer retry after that retention window is
+      // answered 404 prompt_not_found rather than the recorded outcome.
+      promptContract: { schemaVersion: 1, atomicAnswer: true }
     });
   });
   app.get("/api/profiles", (c) => c.json([]));
@@ -136555,6 +136722,10 @@ var createSessionRoutes = (deps) => {
     await deps.handleSendAnswer(c.req.param("id"), c.env.incoming, c.env.outgoing);
     return alreadyHandled6();
   });
+  app.post("/:id/prompt/answer", async (c) => {
+    await deps.handlePromptAnswer(c.req.param("id"), c.env.incoming, c.env.outgoing);
+    return alreadyHandled6();
+  });
   app.post("/:id/permission/answer", async (c) => {
     await deps.handlePermissionAnswer(c.req.param("id"), c.env.incoming, c.env.outgoing);
     return alreadyHandled6();
@@ -140738,10 +140909,10 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // node_modules/@threadbase-sh/scanner/dist/index.js
-function applySort(metas, order) {
+function applySort(metas, order2) {
   const out = [...metas];
   const tie = (a, b2) => a.id.localeCompare(b2.id);
-  switch (order) {
+  switch (order2) {
     case "recent":
       out.sort((a, b2) => b2.timestamp.localeCompare(a.timestamp) || tie(a, b2));
       break;
@@ -146251,7 +146422,7 @@ function parseSessionListQuery(url2) {
   if (!VALID_ORDERS.includes(orderRaw)) {
     return { error: `order must be asc or desc` };
   }
-  const order = orderRaw;
+  const order2 = orderRaw;
   const statusRaw = url2.searchParams.get("status");
   let status;
   if (statusRaw) {
@@ -146264,7 +146435,7 @@ function parseSessionListQuery(url2) {
     status = parts;
   }
   const cursor = url2.searchParams.get("cursor") ?? void 0;
-  return { query: { limit, sortBy, order, status, cursor } };
+  return { query: { limit, sortBy, order: order2, status, cursor } };
 }
 function readBody2(req) {
   return new Promise((resolve4, reject) => {
@@ -147672,6 +147843,522 @@ async function readGitBranch2(dir) {
 // src/api/handlers/sessions.handlers.ts
 init_providers();
 init_pty_shared();
+
+// src/schemas/prompt.schema.ts
+init_zod();
+var PROMPT_SCHEMA_VERSION = 1;
+var OpaqueIdSchema = external_exports.string().trim().min(1).max(200);
+var MeaningfulStringSchema = external_exports.string().trim().min(1);
+var PromptOptionSchema = external_exports.object({
+  optionId: OpaqueIdSchema,
+  label: MeaningfulStringSchema,
+  description: external_exports.string().optional(),
+  preview: external_exports.string().optional()
+});
+var PromptQuestionSchema = external_exports.object({
+  questionId: OpaqueIdSchema,
+  text: MeaningfulStringSchema,
+  header: external_exports.string().optional(),
+  inputMode: external_exports.enum(["single", "multi", "text"]),
+  options: external_exports.array(PromptOptionSchema),
+  allowOther: external_exports.boolean(),
+  secret: external_exports.union([external_exports.boolean(), external_exports.literal("unknown")])
+}).superRefine((question, ctx) => {
+  const optionIds = question.options.map((option) => option.optionId);
+  if (new Set(optionIds).size !== optionIds.length) {
+    ctx.addIssue({
+      code: "custom",
+      message: "optionId values must be unique",
+      path: ["options"]
+    });
+  }
+  if (question.inputMode === "text" && question.options.length !== 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "text questions cannot carry options",
+      path: ["options"]
+    });
+  }
+  if (question.inputMode !== "text" && question.options.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "select questions require options",
+      path: ["options"]
+    });
+  }
+});
+var TERMINAL_PROMPT_STATES = /* @__PURE__ */ new Set(["resolved", "cancelled", "expired", "unavailable"]);
+var PromptSchema = external_exports.object({
+  schemaVersion: external_exports.literal(PROMPT_SCHEMA_VERSION),
+  sessionId: OpaqueIdSchema,
+  promptId: OpaqueIdSchema,
+  revision: external_exports.number().int().positive(),
+  state: external_exports.enum(["open", "updated", "resolved", "cancelled", "expired", "unavailable"]),
+  terminalReason: MeaningfulStringSchema.optional(),
+  intent: external_exports.enum(["approval", "question"]),
+  title: external_exports.string().optional(),
+  message: external_exports.string().optional(),
+  detail: external_exports.string().optional(),
+  questions: external_exports.array(PromptQuestionSchema).min(1),
+  answerRequirement: external_exports.enum(["blocking", "non_blocking", "unknown"]),
+  expiresAt: external_exports.string().datetime({ offset: true }).nullable(),
+  provenance: external_exports.object({
+    source: external_exports.enum(["provider", "screen", "transcript", "synthetic"]),
+    confidence: external_exports.enum(["authoritative", "inferred"])
+  })
+}).superRefine((prompt, ctx) => {
+  if (![prompt.title, prompt.message, prompt.detail].some((value) => value?.trim())) {
+    ctx.addIssue({
+      code: "custom",
+      message: "prompt requires a meaningful title, message, or detail",
+      path: ["message"]
+    });
+  }
+  const questionIds = prompt.questions.map((question) => question.questionId);
+  if (new Set(questionIds).size !== questionIds.length) {
+    ctx.addIssue({
+      code: "custom",
+      message: "questionId values must be unique",
+      path: ["questions"]
+    });
+  }
+  const optionIds = prompt.questions.flatMap(
+    (question) => question.options.map((option) => option.optionId)
+  );
+  if (new Set(optionIds).size !== optionIds.length) {
+    ctx.addIssue({
+      code: "custom",
+      message: "optionId values must be unique within a prompt",
+      path: ["questions"]
+    });
+  }
+  const terminal = TERMINAL_PROMPT_STATES.has(prompt.state);
+  if (terminal !== (prompt.terminalReason !== void 0)) {
+    ctx.addIssue({
+      code: "custom",
+      message: terminal ? "terminal prompts require terminalReason" : "actionable prompts cannot carry terminalReason",
+      path: ["terminalReason"]
+    });
+  }
+});
+var OptionResponseSchema = external_exports.object({
+  questionId: OpaqueIdSchema,
+  optionIds: external_exports.array(OpaqueIdSchema).min(1).refine((ids) => new Set(ids).size === ids.length, "optionIds must be unique"),
+  text: external_exports.never().optional()
+});
+var TextResponseSchema = external_exports.object({
+  questionId: OpaqueIdSchema,
+  text: external_exports.string(),
+  optionIds: external_exports.never().optional()
+});
+var PromptResponseSchema = external_exports.union([OptionResponseSchema, TextResponseSchema]);
+var PromptAnswerSchema = external_exports.object({
+  promptId: OpaqueIdSchema,
+  revision: external_exports.number().int().positive(),
+  responses: external_exports.array(PromptResponseSchema).min(1),
+  idempotencyKey: OpaqueIdSchema
+}).superRefine((answer, ctx) => {
+  const questionIds = answer.responses.map((response) => response.questionId);
+  if (new Set(questionIds).size !== questionIds.length) {
+    ctx.addIssue({
+      code: "custom",
+      message: "each questionId can be answered only once",
+      path: ["responses"]
+    });
+  }
+});
+
+// src/services/prompts/promptRegistry.ts
+var import_node_crypto5 = require("crypto");
+var PROMPT_TERMINAL_RETENTION_MS = 10 * 60 * 1e3;
+var PROMPT_MAX_RECORDS_PER_SESSION = 200;
+var MAX_TIMEOUT_MS = 2147483647;
+function copyPrompt(prompt) {
+  return {
+    ...prompt,
+    questions: prompt.questions.map((question) => ({
+      ...question,
+      options: question.options.map((option) => ({ ...option }))
+    })),
+    provenance: { ...prompt.provenance }
+  };
+}
+function terminalError(state) {
+  switch (state) {
+    case "resolved":
+      return "already_resolved";
+    case "expired":
+      return "prompt_expired";
+    case "cancelled":
+      return "prompt_cancelled";
+    case "unavailable":
+      return "prompt_unavailable";
+  }
+}
+var PromptRegistry = class {
+  bySession = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
+  sequences = /* @__PURE__ */ new Map();
+  createId;
+  emit;
+  onExpire;
+  now;
+  terminalRetentionMs;
+  maxRecordsPerSession;
+  constructor(options = {}) {
+    this.createId = options.createId ?? import_node_crypto5.randomUUID;
+    this.emit = options.emit;
+    this.onExpire = options.onExpire;
+    this.now = options.now ?? Date.now;
+    this.terminalRetentionMs = options.terminalRetentionMs ?? PROMPT_TERMINAL_RETENTION_MS;
+    this.maxRecordsPerSession = options.maxRecordsPerSession ?? PROMPT_MAX_RECORDS_PER_SESSION;
+  }
+  open(draft, adapter, promptId = this.createId()) {
+    this.prune(draft.sessionId);
+    const held = this.byId.get(promptId);
+    if (held && (held.prompt.state === "open" || held.prompt.state === "updated")) {
+      throw new Error(`Prompt id already exists: ${promptId}`);
+    }
+    const id = held ? this.createId() : promptId;
+    const prompt = PromptSchema.parse({
+      ...draft,
+      schemaVersion: PROMPT_SCHEMA_VERSION,
+      promptId: id,
+      revision: 1,
+      state: "open",
+      questions: draft.questions.map((question) => ({
+        ...question,
+        questionId: this.createId(),
+        options: question.options.map((option) => ({ ...option, optionId: this.createId() }))
+      })),
+      provenance: { ...draft.provenance }
+    });
+    const entry = {
+      prompt,
+      adapter,
+      queue: Promise.resolve(),
+      inFlight: /* @__PURE__ */ new Map(),
+      outcomes: /* @__PURE__ */ new Map()
+    };
+    const session = this.bySession.get(prompt.sessionId) ?? /* @__PURE__ */ new Map();
+    session.set(prompt.promptId, entry);
+    this.bySession.set(prompt.sessionId, session);
+    this.byId.set(prompt.promptId, entry);
+    this.publish(entry);
+    this.scheduleExpiration(entry);
+    this.enforceCap(prompt.sessionId);
+    return copyPrompt(prompt);
+  }
+  update(promptId, draft, adapter) {
+    const entry = this.requireEntry(promptId);
+    this.expireIfDue(entry, this.now());
+    if (entry.prompt.sessionId !== draft.sessionId) throw new Error("Prompt session cannot change");
+    if (entry.prompt.state !== "open" && entry.prompt.state !== "updated") {
+      throw new Error(`Cannot update terminal prompt ${promptId}`);
+    }
+    if (entry.prompt.questions.length !== draft.questions.length) {
+      throw new Error("Prompt question cardinality cannot change during an update");
+    }
+    const questions = draft.questions.map((question, questionIndex) => {
+      const prior = entry.prompt.questions[questionIndex];
+      if (prior.options.length !== question.options.length) {
+        throw new Error("Prompt option cardinality cannot change during an update");
+      }
+      return {
+        ...question,
+        questionId: prior.questionId,
+        options: question.options.map((option, optionIndex) => ({
+          ...option,
+          optionId: prior.options[optionIndex].optionId
+        }))
+      };
+    });
+    const prompt = PromptSchema.parse({
+      ...draft,
+      schemaVersion: PROMPT_SCHEMA_VERSION,
+      promptId,
+      revision: entry.prompt.revision + 1,
+      state: "updated",
+      questions,
+      provenance: { ...draft.provenance }
+    });
+    entry.prompt = prompt;
+    if (adapter) entry.adapter = adapter;
+    this.publish(entry);
+    this.scheduleExpiration(entry);
+    return copyPrompt(entry.prompt);
+  }
+  transition(promptId, state, reason) {
+    const entry = this.requireEntry(promptId);
+    if (entry.prompt.state !== "open" && entry.prompt.state !== "updated") {
+      throw new Error(`Cannot transition terminal prompt ${promptId}`);
+    }
+    entry.prompt = {
+      ...entry.prompt,
+      revision: entry.prompt.revision + 1,
+      state,
+      terminalReason: reason
+    };
+    entry.terminalAt = this.now();
+    this.clearExpiration(entry);
+    this.publish(entry);
+    return copyPrompt(entry.prompt);
+  }
+  invalidateSession(sessionId, reason = "session_ended") {
+    const transitioned = [];
+    for (const entry of this.bySession.get(sessionId)?.values() ?? []) {
+      if (entry.prompt.state === "open" || entry.prompt.state === "updated") {
+        transitioned.push(this.transition(entry.prompt.promptId, "unavailable", reason));
+      }
+    }
+    return transitioned;
+  }
+  get(promptId) {
+    const entry = this.byId.get(promptId);
+    if (!entry) return null;
+    this.prune(entry.prompt.sessionId);
+    return this.byId.has(promptId) ? copyPrompt(entry.prompt) : null;
+  }
+  hasActionable(sessionId) {
+    this.prune(sessionId);
+    return [...this.bySession.get(sessionId)?.values() ?? []].some(
+      (entry) => entry.prompt.state === "open" || entry.prompt.state === "updated"
+    );
+  }
+  snapshot(sessionId) {
+    this.prune(sessionId);
+    return {
+      type: "prompt_snapshot",
+      schemaVersion: PROMPT_SCHEMA_VERSION,
+      sessionId,
+      sequence: this.sequences.get(sessionId) ?? 0,
+      prompts: [...this.bySession.get(sessionId)?.values() ?? []].map(
+        (entry) => copyPrompt(entry.prompt)
+      )
+    };
+  }
+  dispose() {
+    for (const entry of this.byId.values()) this.clearExpiration(entry);
+  }
+  answer(sessionId, answer) {
+    this.prune(sessionId);
+    const entry = this.byId.get(answer.promptId);
+    if (!entry || entry.prompt.sessionId !== sessionId) {
+      return Promise.resolve({ ok: false, code: "prompt_not_found" });
+    }
+    this.pruneOutcomes(entry);
+    const recorded = entry.outcomes.get(answer.idempotencyKey);
+    if (recorded) return Promise.resolve(recorded.outcome);
+    const pending = entry.inFlight.get(answer.idempotencyKey);
+    if (pending) return pending;
+    const task = entry.queue.then(() => this.performAnswer(entry, answer));
+    entry.queue = task.then(
+      () => void 0,
+      () => void 0
+    );
+    entry.inFlight.set(answer.idempotencyKey, task);
+    void task.then((outcome) => {
+      entry.inFlight.delete(answer.idempotencyKey);
+      entry.outcomes.set(answer.idempotencyKey, { at: this.now(), outcome });
+    });
+    return task;
+  }
+  async performAnswer(entry, answer) {
+    const prompt = entry.prompt;
+    if (prompt.state !== "open" && prompt.state !== "updated") {
+      return { ok: false, code: terminalError(prompt.state) };
+    }
+    if (this.expireIfDue(entry, this.now())) {
+      return { ok: false, code: "prompt_expired" };
+    }
+    if (prompt.revision !== answer.revision) {
+      return {
+        ok: false,
+        code: "prompt_revision_mismatch",
+        currentRevision: prompt.revision
+      };
+    }
+    const responseError = this.validateResponses(prompt, answer);
+    if (responseError) return { ok: false, code: responseError };
+    if (!entry.adapter) return { ok: false, code: "prompt_unavailable" };
+    let adapterResult;
+    try {
+      adapterResult = await entry.adapter({ prompt: copyPrompt(prompt), answer });
+    } catch {
+      return { ok: false, code: "provider_error" };
+    }
+    if (entry.prompt.state !== "open" && entry.prompt.state !== "updated") {
+      return { ok: false, code: terminalError(entry.prompt.state) };
+    }
+    if (entry.prompt.revision !== answer.revision) {
+      return {
+        ok: false,
+        code: "prompt_revision_mismatch",
+        currentRevision: entry.prompt.revision
+      };
+    }
+    if (!adapterResult.ok) {
+      if (adapterResult.terminal) {
+        this.transition(
+          prompt.promptId,
+          adapterResult.terminal.state,
+          adapterResult.terminal.reason
+        );
+      }
+      return { ok: false, code: adapterResult.code };
+    }
+    return { ok: true, prompt: this.transition(prompt.promptId, "resolved", "answered") };
+  }
+  validateResponses(prompt, answer) {
+    const questions = new Map(prompt.questions.map((question) => [question.questionId, question]));
+    for (const response of answer.responses) {
+      if (!questions.has(response.questionId)) return "unknown_question";
+    }
+    if (answer.responses.length !== prompt.questions.length) return "incomplete_answer";
+    const responses = new Map(answer.responses.map((response) => [response.questionId, response]));
+    for (const question of prompt.questions) {
+      const response = responses.get(question.questionId);
+      if (!response) return "incomplete_answer";
+      if (question.inputMode === "text") {
+        if (typeof response.text !== "string") return "incomplete_answer";
+        continue;
+      }
+      const optionIds = response.optionIds;
+      if (!optionIds) return "incomplete_answer";
+      if (question.inputMode === "single" && optionIds.length !== 1) {
+        return "unsupported_prompt_shape";
+      }
+      const known = new Set(question.options.map((option) => option.optionId));
+      if (optionIds.some((optionId) => !known.has(optionId))) return "unknown_option";
+    }
+    return null;
+  }
+  publish(entry) {
+    const sessionId = entry.prompt.sessionId;
+    const sequence = (this.sequences.get(sessionId) ?? 0) + 1;
+    this.sequences.set(sessionId, sequence);
+    this.emit?.({
+      type: "prompt_event",
+      sessionId,
+      sequence,
+      prompt: copyPrompt(entry.prompt)
+    });
+  }
+  scheduleExpiration(entry) {
+    this.clearExpiration(entry);
+    const expiresAt = entry.prompt.expiresAt;
+    if (expiresAt === null) return;
+    const delay = Math.min(MAX_TIMEOUT_MS, Math.max(0, Date.parse(expiresAt) - this.now()));
+    entry.expiryTimer = setTimeout(() => {
+      entry.expiryTimer = void 0;
+      if (!this.expireIfDue(entry, this.now())) this.scheduleExpiration(entry);
+    }, delay);
+    entry.expiryTimer.unref?.();
+  }
+  clearExpiration(entry) {
+    if (entry.expiryTimer) clearTimeout(entry.expiryTimer);
+    entry.expiryTimer = void 0;
+  }
+  expireIfDue(entry, now) {
+    if (entry.prompt.state !== "open" && entry.prompt.state !== "updated") return false;
+    if (entry.prompt.expiresAt === null || now < Date.parse(entry.prompt.expiresAt)) return false;
+    const expired = this.transition(entry.prompt.promptId, "expired", "deadline_elapsed");
+    this.onExpire?.(expired);
+    return true;
+  }
+  requireEntry(promptId) {
+    const entry = this.byId.get(promptId);
+    if (!entry) throw new Error(`Unknown prompt: ${promptId}`);
+    return entry;
+  }
+  prune(sessionId) {
+    const now = this.now();
+    const session = this.bySession.get(sessionId);
+    if (!session) return;
+    for (const [promptId, entry] of session) {
+      this.expireIfDue(entry, now);
+      if (entry.terminalAt !== void 0 && now - entry.terminalAt > this.terminalRetentionMs) {
+        this.clearExpiration(entry);
+        session.delete(promptId);
+        this.byId.delete(promptId);
+      }
+    }
+    if (session.size === 0) this.bySession.delete(sessionId);
+  }
+  enforceCap(sessionId) {
+    const session = this.bySession.get(sessionId);
+    if (!session || session.size <= this.maxRecordsPerSession) return;
+    const terminal = [...session.entries()].filter(([, entry]) => entry.terminalAt !== void 0).sort((a, b2) => (a[1].terminalAt ?? 0) - (b2[1].terminalAt ?? 0));
+    while (session.size > this.maxRecordsPerSession && terminal.length > 0) {
+      const [promptId, entry] = terminal.shift();
+      this.clearExpiration(entry);
+      session.delete(promptId);
+      this.byId.delete(promptId);
+    }
+  }
+  pruneOutcomes(entry) {
+    const now = this.now();
+    for (const [key, recorded] of entry.outcomes) {
+      if (now - recorded.at > this.terminalRetentionMs) entry.outcomes.delete(key);
+    }
+  }
+};
+
+// src/services/prompts/ptyPromptAdapter.ts
+function permissionPromptDraft(sessionId, gate) {
+  if (!gate) throw new Error("Cannot normalize an absent permission gate");
+  const message = gate.prompt?.trim() || "Approval required";
+  return {
+    sessionId,
+    intent: "approval",
+    title: "Approval",
+    message,
+    ...gate.detail?.trim() ? { detail: gate.detail } : {},
+    questions: [
+      {
+        text: message,
+        header: "Approval",
+        inputMode: "single",
+        options: gate.options.map((option) => ({ label: option.label })),
+        allowOther: false,
+        secret: "unknown"
+      }
+    ],
+    answerRequirement: "unknown",
+    expiresAt: null,
+    provenance: { source: "screen", confidence: "inferred" }
+  };
+}
+function questionPromptDraft(sessionId, questions, source) {
+  const first = questions[0];
+  if (!first) throw new Error("Cannot normalize an empty question list");
+  return {
+    sessionId,
+    intent: "question",
+    ...first.header.trim() ? { title: first.header } : {},
+    message: first.question,
+    questions: questions.map((question) => ({
+      text: question.question,
+      ...question.header.trim() ? { header: question.header } : {},
+      inputMode: question.multiSelect ? "multi" : "single",
+      options: question.options.map((option) => ({
+        label: option.label,
+        ...option.description ? { description: option.description } : {},
+        ...option.preview ? { preview: option.preview } : {}
+      })),
+      allowOther: false,
+      secret: "unknown"
+    })),
+    answerRequirement: "unknown",
+    expiresAt: null,
+    provenance: {
+      source,
+      confidence: source === "transcript" ? "authoritative" : "inferred"
+    }
+  };
+}
+
+// src/api/handlers/sessions.handlers.ts
 init_codexScreen();
 init_detectPermissionGate();
 init_detectQuestionFromScreen();
@@ -148041,6 +148728,21 @@ function codexSessionActiveBody(outcome) {
     ...outcome.ownerSource != null && { ownerSource: outcome.ownerSource }
   };
 }
+function promptAnswerStatus(code) {
+  switch (code) {
+    case "prompt_not_found":
+      return 404;
+    case "provider_error":
+      return 502;
+    case "unknown_question":
+    case "unknown_option":
+    case "incomplete_answer":
+    case "unsupported_prompt_shape":
+      return 400;
+    default:
+      return 409;
+  }
+}
 var SessionHandlers = class {
   constructor(deps) {
     this.deps = deps;
@@ -148079,6 +148781,10 @@ var SessionHandlers = class {
   get pendingQuestions() {
     return this.deps.pendingQuestions;
   }
+  get promptRegistry() {
+    if (!this.deps.promptRegistry) this.deps.promptRegistry = new PromptRegistry();
+    return this.deps.promptRegistry;
+  }
   get pendingQuestionKey() {
     return this.deps.pendingQuestionKey;
   }
@@ -148097,6 +148803,13 @@ var SessionHandlers = class {
   get sessionSubscribers() {
     return this.deps.sessionSubscribers;
   }
+  // Prompt lifecycle events (question / permission and their cancellations)
+  // carry prompt content and go ONLY to the session's subscribers — never to
+  // every connected socket. A client that subscribes after a prompt opened
+  // gets it from the subscribe replay (server-wiring), not from a broadcast.
+  broadcastToSession(sessionId, message) {
+    this.wsHub.broadcastToClients(this.sessionSubscribers.get(sessionId) ?? [], message);
+  }
   get agentConfig() {
     return this.deps.agentConfig;
   }
@@ -148590,6 +149303,7 @@ var SessionHandlers = class {
       json2(res, 400, { error: "Missing input field" });
       return;
     }
+    this.promptRegistry.hasActionable(sessionId);
     const openPrompt = this.pendingPermission.has(sessionId) ? "permission" : this.pendingQuestions.has(sessionId) ? "question" : null;
     if (openPrompt) {
       this.log.info(`[input.prompt_pending] ${sessionId.slice(0, 8)} kind=${openPrompt}`, {
@@ -148645,37 +149359,106 @@ var SessionHandlers = class {
   // the later JSONL flush of the same question is de-duped. We synthesize a
   // screen-scoped toolUseId; the JSONL path overwrites pendingQuestions with the
   // real toolUseId when it lands, so answering works once JSONL catches up.
-  handleLiveQuestion(sessionId, questions) {
+  handleLiveQuestion(sessionId, questions, occurrenceId) {
     const key = questionContentKey(questions);
     if (this.pendingQuestionKey.get(sessionId) === key) return;
     const toolUseId = `screen:${sessionId}:${key.length}`;
-    this.pendingQuestions.set(sessionId, { toolUseId, questions, origin: "pty" });
+    const prior = this.pendingQuestions.get(sessionId);
+    const priorPrompt = prior ? this.promptRegistry.get(prior.promptId) : null;
+    if (priorPrompt?.state === "open" || priorPrompt?.state === "updated") {
+      this.promptRegistry.transition(priorPrompt.promptId, "cancelled", "replaced");
+    }
+    const prompt = this.promptRegistry.open(
+      questionPromptDraft(sessionId, questions, "screen"),
+      this.questionAnswerAdapter(sessionId),
+      occurrenceId
+    );
+    this.pendingQuestions.set(sessionId, {
+      toolUseId,
+      questions,
+      origin: "pty",
+      promptId: prompt.promptId
+    });
     this.pendingQuestionKey.set(sessionId, key);
-    this.wsHub.broadcast({ type: "question", sessionId, toolUseId, questions });
+    this.broadcastToSession(sessionId, { type: "question", sessionId, toolUseId, questions });
+  }
+  handleJsonlQuestion(sessionId, toolUseId, questions, origin) {
+    const prior = this.pendingQuestions.get(sessionId);
+    const sameQuestion = prior !== void 0 && questionContentKey(prior.questions) === questionContentKey(questions);
+    let prompt;
+    if (sameQuestion) {
+      const current = this.promptRegistry.get(prior.promptId);
+      prompt = current?.provenance.source === "transcript" ? current : this.promptRegistry.update(
+        prior.promptId,
+        questionPromptDraft(sessionId, questions, "transcript"),
+        this.questionAnswerAdapter(sessionId)
+      );
+    } else {
+      const priorPrompt = prior ? this.promptRegistry.get(prior.promptId) : null;
+      if (priorPrompt?.state === "open" || priorPrompt?.state === "updated") {
+        this.promptRegistry.transition(priorPrompt.promptId, "cancelled", "replaced");
+      }
+      prompt = this.promptRegistry.open(
+        questionPromptDraft(sessionId, questions, "transcript"),
+        this.questionAnswerAdapter(sessionId)
+      );
+    }
+    this.pendingQuestions.set(sessionId, {
+      toolUseId,
+      questions,
+      origin,
+      promptId: prompt.promptId
+    });
   }
   // Permission gate opened/closed (OSC 777 + scraped options). Broadcasts the
   // additive `permission` / `permission_cancelled` events. Mobile answers by
   // sending the chosen option index via /input { keys } (e.g. "2\r").
-  handlePermissionChange(sessionId, gate) {
+  handlePermissionChange(sessionId, gate, occurrenceId) {
     if (gate === null) {
-      if (!this.pendingPermission.has(sessionId)) return;
+      const prior2 = this.pendingPermission.get(sessionId);
+      if (!prior2) return;
+      const prompt2 = prior2.promptId ? this.promptRegistry.get(prior2.promptId) : null;
+      if (prompt2?.state === "open" || prompt2?.state === "updated") {
+        this.promptRegistry.transition(prompt2.promptId, "cancelled", "provider_closed");
+      }
       this.pendingPermission.delete(sessionId);
       this.pendingPermissionKey.delete(sessionId);
-      this.wsHub.broadcast({ type: "permission_cancelled", sessionId });
+      this.broadcastToSession(sessionId, { type: "permission_cancelled", sessionId });
       return;
     }
     const key = permissionContentKey(gate);
-    if (this.pendingPermissionKey.get(sessionId) === key) return;
     const prior = this.pendingPermission.get(sessionId);
-    const gateId = prior && permissionGateKey(prior) === permissionGateKey(gate) ? prior.gateId : (0, import_crypto9.randomUUID)();
-    this.pendingPermission.set(sessionId, { ...gate, gateId });
+    const priorPromptId = prior?.promptId;
+    if (this.pendingPermissionKey.get(sessionId) === key && (occurrenceId === void 0 || prior?.occurrenceId === occurrenceId)) {
+      return;
+    }
+    const samePrompt = prior && priorPromptId !== void 0 && permissionGateKey(prior) === permissionGateKey(gate) && (occurrenceId === void 0 || prior.occurrenceId === occurrenceId);
+    if (prior && !samePrompt) {
+      const priorPrompt = prior.promptId ? this.promptRegistry.get(prior.promptId) : null;
+      if (priorPrompt?.state === "open" || priorPrompt?.state === "updated") {
+        this.promptRegistry.transition(priorPrompt.promptId, "cancelled", "replaced");
+      }
+    }
+    const prompt = gate.options.length === 0 ? null : samePrompt ? this.promptRegistry.get(priorPromptId) : this.promptRegistry.open(
+      permissionPromptDraft(sessionId, gate),
+      this.permissionAnswerAdapter(sessionId),
+      occurrenceId
+    );
+    if (samePrompt && !prompt) throw new Error("Pending permission prompt disappeared");
+    const gateId = prompt?.promptId ?? occurrenceId ?? prior?.gateId ?? (0, import_crypto9.randomUUID)();
+    this.pendingPermission.set(sessionId, {
+      ...gate,
+      gateId,
+      ...prompt ? { promptId: prompt.promptId } : {},
+      ...occurrenceId !== void 0 ? { occurrenceId } : {}
+    });
     this.pendingPermissionKey.set(sessionId, key);
     const subscriberCount = this.sessionSubscribers.get(sessionId)?.size ?? 0;
     this.log.info(
       `[ws.broadcast_permission] ${sessionId.slice(0, 8)} subscribers=${subscriberCount}`,
       { event: "ws.broadcast_permission", sessionId, subscriberCount }
     );
-    this.wsHub.broadcast({
+    this.broadcastToSession(sessionId, {
       type: "permission",
       sessionId,
       ...gate.prompt ? { prompt: gate.prompt } : {},
@@ -148686,6 +149469,107 @@ var SessionHandlers = class {
       gateId
     });
   }
+  permissionAnswerAdapter(sessionId) {
+    return async ({ prompt, answer }) => {
+      const gate = this.pendingPermission.get(sessionId);
+      if (!gate || gate.promptId !== prompt.promptId) {
+        return {
+          ok: false,
+          code: "prompt_unavailable",
+          terminal: { state: "unavailable", reason: "provider_prompt_missing" }
+        };
+      }
+      const response = answer.responses[0];
+      const selectedId = response?.optionIds?.[0];
+      const selectedIndex = prompt.questions[0]?.options.findIndex(
+        (option2) => option2.optionId === selectedId
+      );
+      if (selectedIndex === void 0 || selectedIndex < 0) {
+        return { ok: false, code: "unknown_option" };
+      }
+      const option = gate.options[selectedIndex];
+      if (!option) return { ok: false, code: "unknown_option" };
+      const provider = this.sessionStore.getManaged(sessionId)?.provider;
+      if (provider !== CODEX_CLI_PROVIDER && !await this.permissionGateStillOpen(sessionId, permissionGateKey(gate))) {
+        return {
+          ok: false,
+          code: "prompt_cancelled",
+          terminal: { state: "cancelled", reason: "provider_closed" }
+        };
+      }
+      if (this.pendingPermission.get(sessionId)?.promptId !== prompt.promptId) {
+        return { ok: false, code: "prompt_cancelled" };
+      }
+      try {
+        this.ptyManager.sendKeys(
+          sessionId,
+          option.answerKeys ?? permissionAnswerKeys(option.index)
+        );
+      } catch {
+        return { ok: false, code: "provider_error" };
+      }
+      return { ok: true };
+    };
+  }
+  questionAnswerAdapter(sessionId) {
+    return async ({ prompt, answer }) => {
+      const pending = this.pendingQuestions.get(sessionId);
+      if (!pending || pending.promptId !== prompt.promptId) {
+        return {
+          ok: false,
+          code: "prompt_unavailable",
+          terminal: { state: "unavailable", reason: "provider_prompt_missing" }
+        };
+      }
+      const answers = {};
+      for (const question of prompt.questions) {
+        const response = answer.responses.find((item) => item.questionId === question.questionId);
+        if (!response?.optionIds) return { ok: false, code: "unsupported_prompt_shape" };
+        answers[question.text] = response.optionIds.map((optionId) => {
+          const option = question.options.find((item) => item.optionId === optionId);
+          return option?.label ?? "";
+        });
+      }
+      const resolution = resolveAnswer(pending, {
+        toolUseId: pending.toolUseId,
+        answers
+      });
+      if (!resolution.ok) {
+        const code = resolution.reason === "unknown_option" || resolution.reason === "incomplete_answer" || resolution.reason === "unsupported_prompt_shape" ? resolution.reason : "prompt_unavailable";
+        return { ok: false, code };
+      }
+      if (!await this.questionMenuStillOpen(sessionId)) {
+        this.pendingQuestions.delete(sessionId);
+        this.pendingQuestionKey.delete(sessionId);
+        this.broadcastToSession(sessionId, {
+          type: "question_cancelled",
+          sessionId,
+          toolUseId: pending.toolUseId
+        });
+        return {
+          ok: false,
+          code: "prompt_cancelled",
+          terminal: { state: "cancelled", reason: "provider_closed" }
+        };
+      }
+      if (this.pendingQuestions.get(sessionId)?.promptId !== prompt.promptId) {
+        return { ok: false, code: "prompt_cancelled" };
+      }
+      try {
+        this.ptyManager.sendKeys(sessionId, resolution.keys);
+      } catch {
+        return { ok: false, code: "provider_error" };
+      }
+      this.pendingQuestions.delete(sessionId);
+      this.pendingQuestionKey.delete(sessionId);
+      this.broadcastToSession(sessionId, {
+        type: "question_cancelled",
+        sessionId,
+        toolUseId: pending.toolUseId
+      });
+      return { ok: true };
+    };
+  }
   /**
    * Answer a permission gate — the validated counterpart of POST /:id/input.
    *
@@ -148721,9 +149605,14 @@ var SessionHandlers = class {
       return;
     }
     const gateClosed = () => {
+      const pending = this.pendingPermission.get(sessionId);
+      const prompt = pending?.promptId ? this.promptRegistry.get(pending.promptId) : null;
+      if (prompt?.state === "open" || prompt?.state === "updated") {
+        this.promptRegistry.transition(prompt.promptId, "cancelled", "provider_closed");
+      }
       this.pendingPermission.delete(sessionId);
       this.pendingPermissionKey.delete(sessionId);
-      this.wsHub.broadcast({ type: "permission_cancelled", sessionId });
+      this.broadcastToSession(sessionId, { type: "permission_cancelled", sessionId });
       json2(res, 409, { ok: false, reason: "gate_closed" });
     };
     const gate = this.pendingPermission.get(sessionId);
@@ -148762,6 +149651,10 @@ var SessionHandlers = class {
       json2(res, 400, { ok: false, reason: message });
       return;
     }
+    const normalized = gate.promptId ? this.promptRegistry.get(gate.promptId) : null;
+    if (normalized?.state === "open" || normalized?.state === "updated") {
+      this.promptRegistry.transition(normalized.promptId, "resolved", "answered_legacy");
+    }
     json2(res, 200, { ok: true });
   }
   /**
@@ -148807,9 +149700,13 @@ var SessionHandlers = class {
     }
     const toolUseId = pending?.toolUseId ?? "";
     if (!await this.questionMenuStillOpen(sessionId)) {
+      const prompt = this.promptRegistry.get(pending?.promptId ?? "");
+      if (prompt?.state === "open" || prompt?.state === "updated") {
+        this.promptRegistry.transition(prompt.promptId, "cancelled", "provider_closed");
+      }
       this.pendingQuestions.delete(sessionId);
       this.pendingQuestionKey.delete(sessionId);
-      this.wsHub.broadcast({ type: "question_cancelled", sessionId, toolUseId });
+      this.broadcastToSession(sessionId, { type: "question_cancelled", sessionId, toolUseId });
       json2(res, 409, { ok: false, reason: "question_gone" });
       return;
     }
@@ -148820,10 +149717,41 @@ var SessionHandlers = class {
       json2(res, 400, { ok: false, reason: message });
       return;
     }
+    const normalized = this.promptRegistry.get(pending?.promptId ?? "");
+    if (normalized?.state === "open" || normalized?.state === "updated") {
+      this.promptRegistry.transition(normalized.promptId, "resolved", "answered_legacy");
+    }
     this.pendingQuestions.delete(sessionId);
-    this.wsHub.broadcast({ type: "question_cancelled", sessionId, toolUseId });
+    this.broadcastToSession(sessionId, { type: "question_cancelled", sessionId, toolUseId });
     json2(res, 200, { ok: true });
   }
+  /**
+   * Answer a normalized prompt by its opaque ids.
+   *
+   * Refusals are keyed by `code` — the stable machine taxonomy of the prompt
+   * contract. The released legacy routes (`/answer`, `/permission/answer`) key
+   * theirs by `reason` and keep doing so; a client reads whichever key belongs
+   * to the route it called, and the two vocabularies are not merged.
+   *
+   * Status follows the same split as the legacy routes: a malformed or
+   * unanswerable *request* is 400, a prompt whose *state* refuses the answer is
+   * 409. A retry after PROMPT_TERMINAL_RETENTION_MS answers 404
+   * `prompt_not_found`, not the recorded outcome — the record it would replay
+   * is gone by then.
+   */
+  async handlePromptAnswer(sessionId, req, res) {
+    const parsed = PromptAnswerSchema.safeParse(await readBody2(req));
+    if (!parsed.success) {
+      json2(res, 400, { ok: false, code: "invalid_prompt_answer" });
+      return;
+    }
+    const outcome = await this.promptRegistry.answer(sessionId, parsed.data);
+    if (outcome.ok) {
+      json2(res, 200, outcome);
+      return;
+    }
+    json2(res, promptAnswerStatus(outcome.code), outcome);
+  }
   // Best-effort: a session we don't own a PTY for, or one that raced away
   // mid-read, is not ours to veto — say yes and let the write decide.
   async questionMenuStillOpen(sessionId) {
@@ -151168,6 +152096,27 @@ init_capabilities();
 function wsAllows(principal, required2) {
   return principal === null || hasCapability(principal, required2);
 }
+function clearExpiredPendingPrompt(deps, prompt) {
+  const permission = deps.pendingPermission.get(prompt.sessionId);
+  if (permission?.promptId === prompt.promptId) {
+    deps.pendingPermission.delete(prompt.sessionId);
+    deps.pendingPermissionKey.delete(prompt.sessionId);
+    deps.wsHub.broadcastToClients(deps.sessionSubscribers.get(prompt.sessionId) ?? [], {
+      type: "permission_cancelled",
+      sessionId: prompt.sessionId
+    });
+  }
+  const question = deps.pendingQuestions.get(prompt.sessionId);
+  if (question?.promptId === prompt.promptId) {
+    deps.pendingQuestions.delete(prompt.sessionId);
+    deps.pendingQuestionKey.delete(prompt.sessionId);
+    deps.wsHub.broadcastToClients(deps.sessionSubscribers.get(prompt.sessionId) ?? [], {
+      type: "question_cancelled",
+      sessionId: prompt.sessionId,
+      toolUseId: question.toolUseId
+    });
+  }
+}
 function createConversationWatcherEvents(deps) {
   return {
     onNewLineSpans: (filePath, spans, readFrom, endOffset) => {
@@ -151290,11 +152239,11 @@ function createLiveSessionOptions(deps) {
         ts: ts2
       });
     },
-    onPermissionChange: (sessionId, gate) => {
-      deps.sessionHandlers().handlePermissionChange(sessionId, gate);
+    onPermissionChange: (sessionId, gate, occurrenceId) => {
+      deps.sessionHandlers().handlePermissionChange(sessionId, gate, occurrenceId);
     },
-    onLiveQuestion: (sessionId, questions) => {
-      deps.sessionHandlers().handleLiveQuestion(sessionId, questions);
+    onLiveQuestion: (sessionId, questions, occurrenceId) => {
+      deps.sessionHandlers().handleLiveQuestion(sessionId, questions, occurrenceId);
     },
     onLiveQuestionGone: (sessionId) => {
       deps.pendingQuestionKey.delete(sessionId);
@@ -151375,10 +152324,11 @@ function createLiveSessionOptions(deps) {
         if (filePath) {
           deps.fileWatcher.unwatch(filePath);
           deps.sessionFileMap.delete(session.id);
-          deps.cancelPendingQuestion(session.id);
         }
+        deps.cancelPendingQuestion(session.id);
         deps.pendingPermission.delete(session.id);
         deps.pendingPermissionKey.delete(session.id);
+        deps.promptRegistry.invalidateSession(session.id, "session_ended");
         deps.contendedSessions.delete(session.id);
         deps.rememberSelfPtyEnded(session.id);
       }
@@ -151433,6 +152383,7 @@ function createApiDeps(deps) {
     handleGetOutput: (id, res) => deps.sessionHandlers.handleGetOutput(id, res),
     handleSendInput: (id, req, res) => deps.sessionHandlers.handleSendInput(id, req, res),
     handleSendAnswer: (id, req, res) => deps.sessionHandlers.handleSendAnswer(id, req, res),
+    handlePromptAnswer: (id, req, res) => deps.sessionHandlers.handlePromptAnswer(id, req, res),
     handlePermissionAnswer: (id, req, res) => deps.sessionHandlers.handlePermissionAnswer(id, req, res),
     handleCancel: (id, res) => deps.sessionHandlers.handleCancel(id, res),
     handleStopSession: (id, res) => deps.sessionHandlers.handleStopSession(id, res),
@@ -151491,6 +152442,9 @@ function createApiDeps(deps) {
             return;
           }
           deps.addSessionSubscriber(msg.sessionId, ws2);
+          if (deps.promptRegistry) {
+            ws2.send(JSON.stringify(deps.promptRegistry.snapshot(msg.sessionId)));
+          }
           if (deps.ptyManager.hasSession(msg.sessionId)) {
             const lines = await deps.ptyManager.getOutputLines(msg.sessionId, REPLAY_MAX_LINES);
             const userMessages = deps.ptyManager.getInputHistory(msg.sessionId);
@@ -153720,16 +154674,16 @@ function compareValues(a, b2) {
   if (typeof a === "number" && typeof b2 === "number") return a - b2;
   return String(a).localeCompare(String(b2));
 }
-function makeComparator(key, order) {
-  const dir = order === "asc" ? 1 : -1;
+function makeComparator(key, order2) {
+  const dir = order2 === "asc" ? 1 : -1;
   return (a, b2) => {
     const cmp = compareValues(getSortValue(a, key), getSortValue(b2, key)) * dir;
     if (cmp !== 0) return cmp;
     return a.id.localeCompare(b2.id);
   };
 }
-function findCursorBoundary(sorted, cursor, key, order) {
-  const dir = order === "asc" ? 1 : -1;
+function findCursorBoundary(sorted, cursor, key, order2) {
+  const dir = order2 === "asc" ? 1 : -1;
   for (let i = 0; i < sorted.length; i++) {
     const item = sorted[i];
     const cmp = compareValues(getSortValue(item, key), cursor.k) * dir;
@@ -154305,6 +155259,7 @@ var StreamerServer = class {
   // repaint of the same gate doesn't re-broadcast on every tick. Cleared
   // alongside pendingPermission.
   pendingPermissionKey = /* @__PURE__ */ new Map();
+  promptRegistry;
   // Scanner lifecycle, freshness state and the cache↔disk reconcile.
   scannerManager;
   // Binds a live session to the JSONL/rollout its provider writes.
@@ -154557,6 +155512,20 @@ var StreamerServer = class {
     this.browserCors = config2.browserCors ?? loadBrowserCors();
     this.sessionStore = new SessionStore();
     this.wsHub = new WSHub();
+    this.promptRegistry = new PromptRegistry({
+      emit: (event) => this.wsHub.broadcastToClients(this.sessionSubscribers.get(event.sessionId) ?? [], event),
+      onExpire: (prompt) => clearExpiredPendingPrompt(
+        {
+          pendingPermission: this.pendingPermission,
+          pendingPermissionKey: this.pendingPermissionKey,
+          pendingQuestions: this.pendingQuestions,
+          pendingQuestionKey: this.pendingQuestionKey,
+          sessionSubscribers: this.sessionSubscribers,
+          wsHub: this.wsHub
+        },
+        prompt
+      )
+    });
     this.fileWatcher = new ConversationWatcher(
       createConversationWatcherEvents({
         sessionFileMap: this.sessionFileMap,
@@ -154600,6 +155569,7 @@ var StreamerServer = class {
         pendingQuestionKey: this.pendingQuestionKey,
         pendingPermission: this.pendingPermission,
         pendingPermissionKey: this.pendingPermissionKey,
+        promptRegistry: this.promptRegistry,
         contendedSessions: this.contendedSessions,
         // Thunks, not values: sessionHandlers is constructed below, the
         // registry repo and the push notifiers are bound during listen(), and
@@ -154690,6 +155660,7 @@ var StreamerServer = class {
       sessionStatusBus: this.sessionStatusBus,
       sessionFileMap: this.sessionFileMap,
       pendingQuestions: this.pendingQuestions,
+      promptRegistry: this.promptRegistry,
       pendingQuestionKey: this.pendingQuestionKey,
       pendingPermission: this.pendingPermission,
       pendingPermissionKey: this.pendingPermissionKey,
@@ -154790,6 +155761,7 @@ var StreamerServer = class {
       terminalSeq: this.terminalSeq,
       pendingPermission: this.pendingPermission,
       pendingQuestions: this.pendingQuestions,
+      promptRegistry: this.promptRegistry,
       agentClient,
       conversationWriter,
       agentConfig
@@ -155570,6 +156542,7 @@ var StreamerServer = class {
     if (!this.ptyManager.isRemote()) this.ptyManager.dispose();
     this.fileWatcher.dispose();
     this.externalTails.clear();
+    this.promptRegistry.dispose();
     this.wsHub.dispose();
     this.pairTokens.dispose();
     this.liveActivityRenewal?.stop();
@@ -156158,7 +157131,7 @@ var StreamerServer = class {
     for (const p2 of pending) {
       if (contended || foreignVsPty(p2.questions)) continue;
       const origin = priorPtyKey !== null && questionContentKey(p2.questions) === priorPtyKey ? "pty" : "jsonl";
-      this.pendingQuestions.set(sessionId, { ...p2, origin });
+      this.sessionHandlers.handleJsonlQuestion(sessionId, p2.toolUseId, p2.questions, origin);
       const t = setTimeout(() => {
         if (this.pendingQuestions.get(sessionId)?.toolUseId === p2.toolUseId) {
           this.cancelPendingQuestion(sessionId);
@@ -156176,7 +157149,7 @@ var StreamerServer = class {
         priorToolUseId
       });
       this.pendingQuestionKey.set(sessionId, key);
-      if (broadcast2) this.wsHub.broadcast(m2);
+      if (broadcast2) this.wsHub.broadcastToClients(this.sessionSubscribers.get(sessionId) ?? [], m2);
     }
   }
   cancelPendingQuestion(sessionId) {
@@ -156184,7 +157157,15 @@ var StreamerServer = class {
     if (!pq) return;
     this.pendingQuestions.delete(sessionId);
     this.pendingQuestionKey.delete(sessionId);
-    this.wsHub.broadcast({ type: "question_cancelled", sessionId, toolUseId: pq.toolUseId });
+    const prompt = this.promptRegistry.get(pq.promptId);
+    if (prompt?.state === "open" || prompt?.state === "updated") {
+      this.promptRegistry.transition(pq.promptId, "cancelled", "provider_closed");
+    }
+    this.wsHub.broadcastToClients(this.sessionSubscribers.get(sessionId) ?? [], {
+      type: "question_cancelled",
+      sessionId,
+      toolUseId: pq.toolUseId
+    });
   }
   async handleBrowse(url2, res) {
     if (!this.browseRoot) {
@@ -156515,7 +157496,7 @@ function isBrewInstall(scriptPath = process.argv[1] ?? "") {
 }
 
 // src/updater/download.ts
-var import_node_crypto5 = require("crypto");
+var import_node_crypto6 = require("crypto");
 var import_node_fs10 = require("fs");
 var import_node_path11 = require("path");
 var import_promises17 = require("stream/promises");
@@ -156582,7 +157563,7 @@ async function downloadAndVerify(opts) {
   if (!res.ok || !res.body) {
     throw new Error(`Failed to download ${artifact.filename}: ${res.status} ${res.statusText}`);
   }
-  const hash2 = (0, import_node_crypto5.createHash)("sha256");
+  const hash2 = (0, import_node_crypto6.createHash)("sha256");
   const out = (0, import_node_fs10.createWriteStream)(targetPath);
   let bytes = 0;
   const measured = new TransformStream({
@@ -156887,7 +157868,7 @@ var import_node_path18 = require("path");
 var import_path38 = __toESM(require("path"), 1);
 var import_node_fs14 = __toESM(require("fs"), 1);
 var import_node_assert = __toESM(require("assert"), 1);
-var import_node_crypto6 = require("crypto");
+var import_node_crypto7 = require("crypto");
 var import_node_fs15 = __toESM(require("fs"), 1);
 var import_node_path19 = __toESM(require("path"), 1);
 var import_fs43 = __toESM(require("fs"), 1);
@@ -159302,7 +160283,7 @@ var Te = fo === "win32";
 var uo = 1024;
 var mo = (s3, t) => {
   if (!Te) return import_node_fs15.default.unlink(s3, t);
-  let e = s3 + ".DELETE." + (0, import_node_crypto6.randomBytes)(16).toString("hex");
+  let e = s3 + ".DELETE." + (0, import_node_crypto7.randomBytes)(16).toString("hex");
   import_node_fs15.default.rename(s3, e, (i) => {
     if (i) return t(i);
     import_node_fs15.default.unlink(e, t);
@@ -159310,7 +160291,7 @@ var mo = (s3, t) => {
 };
 var po = (s3) => {
   if (!Te) return import_node_fs15.default.unlinkSync(s3);
-  let t = s3 + ".DELETE." + (0, import_node_crypto6.randomBytes)(16).toString("hex");
+  let t = s3 + ".DELETE." + (0, import_node_crypto7.randomBytes)(16).toString("hex");
   import_node_fs15.default.renameSync(s3, t), import_node_fs15.default.unlinkSync(t);
 };
 var vr = (s3, t, e) => s3 !== void 0 && s3 === s3 >>> 0 ? s3 : t !== void 0 && t === t >>> 0 ? t : e;