@threadbase-sh/streamer 1.69.6 → 1.70.1

package/dist/index.cjs

@@ -34,7 +34,13 @@ __export(index_exports, {
   CODEX_CLI_PROVIDER: () => CODEX_CLI_PROVIDER,
   ConversationWatcher: () => ConversationWatcher,
   LiveSessionManager: () => LiveSessionManager,
+  PROMPT_SCHEMA_VERSION: () => PROMPT_SCHEMA_VERSION,
   PTYManager: () => PTYManager,
+  PromptAnswerSchema: () => PromptAnswerSchema,
+  PromptOptionSchema: () => PromptOptionSchema,
+  PromptQuestionSchema: () => PromptQuestionSchema,
+  PromptResponseSchema: () => PromptResponseSchema,
+  PromptSchema: () => PromptSchema,
   SessionStore: () => SessionStore,
   StreamerServer: () => StreamerServer,
   WSHub: () => WSHub,
@@ -2222,7 +2228,7 @@ function toPublicSession(s) {
 }
 
 // src/pty-host/protocol.ts
-var PTY_HOST_PROTOCOL_VERSION = 3;
+var PTY_HOST_PROTOCOL_VERSION = 4;
 function isHostEvent(message) {
   return "type" in message && message.type === "event";
 }
@@ -2310,8 +2316,12 @@ var RemoteSessionRunner = class _RemoteSessionRunner {
       }
       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) {
@@ -2404,6 +2414,19 @@ var RemoteSessionRunner = class _RemoteSessionRunner {
       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);
   }
@@ -2458,13 +2481,13 @@ var RemoteSessionRunner = class _RemoteSessionRunner {
         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);
@@ -4139,6 +4162,130 @@ async function readGitBranch(dir) {
   }
 }
 
+// src/schemas/prompt.schema.ts
+var import_zod = require("zod");
+var PROMPT_SCHEMA_VERSION = 1;
+var OpaqueIdSchema = import_zod.z.string().trim().min(1).max(200);
+var MeaningfulStringSchema = import_zod.z.string().trim().min(1);
+var PromptOptionSchema = import_zod.z.object({
+  optionId: OpaqueIdSchema,
+  label: MeaningfulStringSchema,
+  description: import_zod.z.string().optional(),
+  preview: import_zod.z.string().optional()
+});
+var PromptQuestionSchema = import_zod.z.object({
+  questionId: OpaqueIdSchema,
+  text: MeaningfulStringSchema,
+  header: import_zod.z.string().optional(),
+  inputMode: import_zod.z.enum(["single", "multi", "text"]),
+  options: import_zod.z.array(PromptOptionSchema),
+  allowOther: import_zod.z.boolean(),
+  secret: import_zod.z.union([import_zod.z.boolean(), import_zod.z.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 = import_zod.z.object({
+  schemaVersion: import_zod.z.literal(PROMPT_SCHEMA_VERSION),
+  sessionId: OpaqueIdSchema,
+  promptId: OpaqueIdSchema,
+  revision: import_zod.z.number().int().positive(),
+  state: import_zod.z.enum(["open", "updated", "resolved", "cancelled", "expired", "unavailable"]),
+  terminalReason: MeaningfulStringSchema.optional(),
+  intent: import_zod.z.enum(["approval", "question"]),
+  title: import_zod.z.string().optional(),
+  message: import_zod.z.string().optional(),
+  detail: import_zod.z.string().optional(),
+  questions: import_zod.z.array(PromptQuestionSchema).min(1),
+  answerRequirement: import_zod.z.enum(["blocking", "non_blocking", "unknown"]),
+  expiresAt: import_zod.z.string().datetime({ offset: true }).nullable(),
+  provenance: import_zod.z.object({
+    source: import_zod.z.enum(["provider", "screen", "transcript", "synthetic"]),
+    confidence: import_zod.z.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 = import_zod.z.object({
+  questionId: OpaqueIdSchema,
+  optionIds: import_zod.z.array(OpaqueIdSchema).min(1).refine((ids) => new Set(ids).size === ids.length, "optionIds must be unique"),
+  text: import_zod.z.never().optional()
+});
+var TextResponseSchema = import_zod.z.object({
+  questionId: OpaqueIdSchema,
+  text: import_zod.z.string(),
+  optionIds: import_zod.z.never().optional()
+});
+var PromptResponseSchema = import_zod.z.union([OptionResponseSchema, TextResponseSchema]);
+var PromptAnswerSchema = import_zod.z.object({
+  promptId: OpaqueIdSchema,
+  revision: import_zod.z.number().int().positive(),
+  responses: import_zod.z.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/server.ts
 var import_node_ws = require("@hono/node-ws");
 var import_client = require("@temporalio/client");
@@ -4778,11 +4925,11 @@ var createBrowseRoutes = (deps) => {
 var import_hono4 = require("hono");
 
 // src/schemas/cacheAlert.schema.ts
-var import_zod = require("zod");
-var ResolveCacheAlertSchema = import_zod.z.object({
-  fingerprint: import_zod.z.string(),
-  action: import_zod.z.enum(["prune_all", "prune_selected", "ignore", "reset_rescan"]),
-  ids: import_zod.z.array(import_zod.z.string()).optional()
+var import_zod2 = require("zod");
+var ResolveCacheAlertSchema = import_zod2.z.object({
+  fingerprint: import_zod2.z.string(),
+  action: import_zod2.z.enum(["prune_all", "prune_selected", "ignore", "reset_rescan"]),
+  ids: import_zod2.z.array(import_zod2.z.string()).optional()
 }).refine((v) => v.action !== "prune_selected" || v.ids !== void 0 && v.ids.length > 0, {
   message: "prune_selected requires a non-empty ids array",
   path: ["ids"]
@@ -4838,12 +4985,12 @@ var createCacheAlertRoutes = (deps) => {
 var import_hono5 = require("hono");
 
 // src/schemas/claudeFlags.schema.ts
-var import_zod2 = require("zod");
-var ClaudeFlagsBodySchema = import_zod2.z.object({
-  values: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.union([import_zod2.z.string(), import_zod2.z.boolean(), import_zod2.z.array(import_zod2.z.string())])).default({}),
+var import_zod3 = require("zod");
+var ClaudeFlagsBodySchema = import_zod3.z.object({
+  values: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.union([import_zod3.z.string(), import_zod3.z.boolean(), import_zod3.z.array(import_zod3.z.string())])).default({}),
   // A newline would corrupt the flat one-line-per-key server.yaml, so reject
   // it here with a field error instead of silently stripping it.
-  extraArgs: import_zod2.z.string().refine((v) => !/[\r\n]/.test(v), "extraArgs must not contain newlines").optional()
+  extraArgs: import_zod3.z.string().refine((v) => !/[\r\n]/.test(v), "extraArgs must not contain newlines").optional()
 }).strict();
 
 // src/api/routes/config.routes.ts
@@ -5377,15 +5524,15 @@ var import_node_path5 = require("path");
 var import_yaml = require("yaml");
 
 // src/schemas/updateConfig.schema.ts
-var import_zod3 = require("zod");
-var UpdateConfigSchema = import_zod3.z.object({
-  auto_update: import_zod3.z.boolean().default(false),
-  channel: import_zod3.z.enum(["stable", "next"]).default("stable"),
-  allow: import_zod3.z.array(import_zod3.z.enum(["patch", "minor", "major"])).default(["patch", "minor"]),
-  poll_interval_minutes: import_zod3.z.number().int().min(0).default(1440),
-  defer_if_active_sessions: import_zod3.z.boolean().default(true),
-  github_repo: import_zod3.z.string().regex(/^[^/]+\/[^/]+$/, "github_repo must be 'owner/name'"),
-  webhook_secret: import_zod3.z.string().min(1).nullable().default(null)
+var import_zod4 = require("zod");
+var UpdateConfigSchema = import_zod4.z.object({
+  auto_update: import_zod4.z.boolean().default(false),
+  channel: import_zod4.z.enum(["stable", "next"]).default("stable"),
+  allow: import_zod4.z.array(import_zod4.z.enum(["patch", "minor", "major"])).default(["patch", "minor"]),
+  poll_interval_minutes: import_zod4.z.number().int().min(0).default(1440),
+  defer_if_active_sessions: import_zod4.z.boolean().default(true),
+  github_repo: import_zod4.z.string().regex(/^[^/]+\/[^/]+$/, "github_repo must be 'owner/name'"),
+  webhook_secret: import_zod4.z.string().min(1).nullable().default(null)
 }).strict();
 
 // src/config/update-config.ts
@@ -6010,7 +6157,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([]));
@@ -6379,6 +6532,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();
@@ -9584,6 +9741,396 @@ async function recordUpload(pool2, instanceId, row) {
   );
 }
 
+// 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.sweepExpired(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.sweepExpired(entry.prompt.sessionId);
+    return this.byId.has(promptId) ? copyPrompt(entry.prompt) : null;
+  }
+  hasActionable(sessionId) {
+    this.sweepExpired(sessionId);
+    return [...this.bySession.get(sessionId)?.values() ?? []].some(
+      (entry) => entry.prompt.state === "open" || entry.prompt.state === "updated"
+    );
+  }
+  snapshot(sessionId) {
+    this.sweepExpired(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.sweepExpired(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;
+  }
+  sweepExpired(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, b) => (a[1].terminalAt ?? 0) - (b[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/services/questions/parseStatusLine.ts
 var MODEL_RE = /(Opus|Sonnet|Haiku|Fable)\s+[\d.]+(?:\s*\([^)]*\))?/;
 var EFFORT_RE = /●\s*([A-Za-z]+)\s*·\s*\/effort/;
@@ -9946,6 +10493,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;
@@ -9984,6 +10546,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;
   }
@@ -10502,18 +11068,26 @@ var SessionHandlers = class {
       json(res, 400, { error: "Missing input field" });
       return;
     }
+    this.promptRegistry.sweepExpired(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}`, {
-        event: "input.prompt_pending",
-        sessionId,
-        promptKind: openPrompt
-      });
+      const pendingGate = openPrompt === "permission" ? this.pendingPermission.get(sessionId) : void 0;
+      const promptState = pendingGate?.promptId !== void 0 && this.promptRegistry.get(pendingGate.promptId)?.state === "resolved" ? "answered" : "open";
+      this.log.info(
+        `[input.prompt_pending] ${sessionId.slice(0, 8)} kind=${openPrompt} state=${promptState}`,
+        {
+          event: "input.prompt_pending",
+          sessionId,
+          promptKind: openPrompt,
+          promptState
+        }
+      );
       json(res, 409, {
         ok: false,
         reason: "prompt_pending",
         promptKind: openPrompt,
-        error: "A prompt is waiting for an answer; answer or dismiss it before sending text"
+        promptState,
+        error: promptState === "answered" ? "Your answer was sent; wait for the prompt to close before sending text" : "A prompt is waiting for an answer; answer or dismiss it before sending text"
       });
       return;
     }
@@ -10557,30 +11131,99 @@ 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.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.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(
@@ -10598,6 +11241,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.
    *
@@ -10633,6 +11377,11 @@ 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.broadcastToSession(sessionId, { type: "permission_cancelled", sessionId });
@@ -10674,6 +11423,10 @@ var SessionHandlers = class {
       json(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");
+    }
     json(res, 200, { ok: true });
   }
   /**
@@ -10719,6 +11472,10 @@ 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.broadcastToSession(sessionId, { type: "question_cancelled", sessionId, toolUseId });
@@ -10732,10 +11489,41 @@ var SessionHandlers = class {
       json(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.broadcastToSession(sessionId, { type: "question_cancelled", sessionId, toolUseId });
     json(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) {
+      json(res, 400, { ok: false, code: "invalid_prompt_answer" });
+      return;
+    }
+    const outcome = await this.promptRegistry.answer(sessionId, parsed.data);
+    if (outcome.ok) {
+      json(res, 200, outcome);
+      return;
+    }
+    json(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) {
@@ -12879,6 +13667,27 @@ function handleListProjects(url, res) {
 function wsAllows(principal, required) {
   return principal === null || hasCapability(principal, required);
 }
+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) => {
@@ -13001,11 +13810,11 @@ function createLiveSessionOptions(deps) {
         ts
       });
     },
-    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);
@@ -13086,10 +13895,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);
       }
@@ -13144,6 +13954,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),
@@ -13202,6 +14013,9 @@ function createApiDeps(deps) {
             return;
           }
           deps.addSessionSubscriber(msg.sessionId, ws);
+          if (deps.promptRegistry) {
+            ws.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);
@@ -15972,6 +16786,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.
@@ -16224,6 +17039,20 @@ var StreamerServer = class {
     this.browserCors = config.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,
@@ -16267,6 +17096,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
@@ -16357,6 +17187,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,
@@ -16457,6 +17288,7 @@ var StreamerServer = class {
       terminalSeq: this.terminalSeq,
       pendingPermission: this.pendingPermission,
       pendingQuestions: this.pendingQuestions,
+      promptRegistry: this.promptRegistry,
       agentClient,
       conversationWriter,
       agentConfig
@@ -17237,6 +18069,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();
@@ -17825,7 +18658,7 @@ var StreamerServer = class {
     for (const p of pending) {
       if (contended || foreignVsPty(p.questions)) continue;
       const origin = priorPtyKey !== null && questionContentKey(p.questions) === priorPtyKey ? "pty" : "jsonl";
-      this.pendingQuestions.set(sessionId, { ...p, origin });
+      this.sessionHandlers.handleJsonlQuestion(sessionId, p.toolUseId, p.questions, origin);
       const t = setTimeout(() => {
         if (this.pendingQuestions.get(sessionId)?.toolUseId === p.toolUseId) {
           this.cancelPendingQuestion(sessionId);
@@ -17851,6 +18684,10 @@ var StreamerServer = class {
     if (!pq) return;
     this.pendingQuestions.delete(sessionId);
     this.pendingQuestionKey.delete(sessionId);
+    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,
@@ -18006,7 +18843,13 @@ function parseDirScanDebounceEnv(raw) {
   CODEX_CLI_PROVIDER,
   ConversationWatcher,
   LiveSessionManager,
+  PROMPT_SCHEMA_VERSION,
   PTYManager,
+  PromptAnswerSchema,
+  PromptOptionSchema,
+  PromptQuestionSchema,
+  PromptResponseSchema,
+  PromptSchema,
   SessionStore,
   StreamerServer,
   WSHub,