@hachej/boring-ask-user 0.1.54 → 0.1.56

package/README.md

@@ -23,7 +23,7 @@ cancels.
 | Panel | `ask-user.questions` ("Questions"), `placement: "center"`, chromeless |
 | Surface resolver | kind `questions` (`ASK_USER_SURFACE_KIND`) → opens the panel |
 | Agent tool | `ask_user` (blocking; resolves `answered` / `cancelled`) |
-| HTTP route | `POST /api/v1/questions/commands` (submit + cancel commands) |
+| WorkspaceBridge ops | `ask-user.v1.request`, `ask-user.v1.answer`, `ask-user.v1.cancel`, `ask-user.v1.pending`, `ask-user.v1.transcript` |
 | Pi prompt | `pi.systemPrompt` nudges the agent to use `ask_user` over chat roleplay |
 
 ## How it's wired
@@ -74,6 +74,11 @@ The agent then calls `ask_user` with a `{ title, context?, schema }` payload:
 The pane opens, the user submits, and the tool resolves with
 `{ status: "answered", answer: { values: { env: "production" } } }`.
 
+Submit/cancel/pending/transcript traffic goes through WorkspaceBridge
+`ask-user.v1.*` operations. The old `questionsRoutes` helper for
+`POST /api/v1/questions/commands` remains exported only for manual legacy
+wiring; `createAskUserServerPlugin` does not register that route.
+
 ## Field types
 
 `text`, `textarea`, `select`, `multiselect`, `checkbox`, `radio`, `number`.

package/dist/front/index.js

@@ -3,26 +3,20 @@
 // src/front/index.tsx
 import { Button, EmptyState, Notice, Pane, PaneBody, PaneFooter, PaneHeader, PaneTitle } from "@hachej/boring-ui-kit";
 import {
-  UI_COMMAND_EVENT,
-  events,
-  useWorkspaceAttention,
-  workspaceEvents
+  WORKSPACE_COMPOSER_STOP_EVENT as WORKSPACE_COMPOSER_STOP_EVENT2,
+  workspaceComposerStopAppliesToSession as workspaceComposerStopAppliesToSession2
 } from "@hachej/boring-workspace";
 import {
   definePlugin
 } from "@hachej/boring-workspace/plugin";
 import { HelpCircle, XCircle } from "lucide-react";
-import { createContext as createContext2, useContext as useContext2, useEffect as useEffect2, useMemo as useMemo2, useSyncExternalStore, useState as useState2 } from "react";
+import { useEffect as useEffect3, useMemo as useMemo2, useRef as useRef3, useSyncExternalStore, useState as useState2 } from "react";
 
 // src/shared/constants.ts
 var ASK_USER_PLUGIN_ID = "ask-user";
 var ASK_USER_PANEL_ID = "ask-user.questions";
 var ASK_USER_PANEL_TITLE = "Questions";
 var ASK_USER_SURFACE_KIND = "questions";
-var ASK_USER_COMMAND_KINDS = {
-  SUBMIT: "questions.submit",
-  CANCEL: "questions.cancel"
-};
 var ASK_USER_UI_STATE_SLOTS = {
   PENDING: "questions.pending"
 };
@@ -41,6 +35,15 @@ var ASK_USER_SCHEMA_LIMITS = {
   defaultTimeoutMs: 10 * 6e4
 };
 
+// src/shared/bridge.ts
+var ASK_USER_BRIDGE_OPS = {
+  request: "ask-user.v1.request",
+  answer: "ask-user.v1.answer",
+  cancel: "ask-user.v1.cancel",
+  pending: "ask-user.v1.pending",
+  transcript: "ask-user.v1.transcript"
+};
+
 // src/shared/error-codes.ts
 var ASK_USER_ERROR_CODES = {
   PENDING_EXISTS: "ASK_USER_PENDING_EXISTS",
@@ -303,50 +306,219 @@ var QuestionsClientError = class extends Error {
   code;
   statusCode;
 };
-function readPendingQuestionFromState(state) {
+function readPendingQuestionHintsFromState(state) {
   const slot = state?.[ASK_USER_UI_STATE_SLOTS.PENDING];
-  if (!slot || typeof slot !== "object") return null;
-  const question = slot.question;
-  return question && typeof question === "object" ? question : null;
+  if (!slot || typeof slot !== "object") return [];
+  const hints = /* @__PURE__ */ new Map();
+  const rawSlot = slot;
+  const current = readHint(rawSlot.hint) ?? readHint(rawSlot.question);
+  if (current) hints.set(current.sessionId, current);
+  if (rawSlot.hintsBySession && typeof rawSlot.hintsBySession === "object" && !Array.isArray(rawSlot.hintsBySession)) {
+    for (const [sessionId, candidate] of Object.entries(rawSlot.hintsBySession)) {
+      const hint = readHint(candidate);
+      if (hint && hint.sessionId === sessionId) hints.set(sessionId, hint);
+    }
+  }
+  return [...hints.values()];
+}
+function readHint(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  if (typeof raw.questionId !== "string" || typeof raw.sessionId !== "string") return null;
+  const status = normalizeQuestionStatus(raw.status);
+  return { questionId: raw.questionId, sessionId: raw.sessionId, ...status === "abandoned" && raw.status === void 0 ? {} : { status } };
 }
 function createQuestionsClient(options = {}) {
-  async function dispatch(command) {
-    const response = await fetch(`${options.apiBaseUrl ?? ""}/api/v1/questions/commands`, {
+  async function callBridge(op, input, sessionId, idempotencyKey) {
+    const response = await fetch(`${options.apiBaseUrl ?? ""}/api/v1/workspace-bridge/call`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", ...options.headers ?? {} },
-      body: JSON.stringify(command)
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers ?? {},
+        ...sessionId ? { "x-boring-session-id": sessionId } : {}
+      },
+      body: JSON.stringify({ op, input, ...idempotencyKey ? { idempotencyKey } : {} })
     });
     const payload = await response.json().catch(() => ({}));
-    if (!response.ok) throw new QuestionsClientError(payload.error ?? ASK_USER_ERROR_CODES.UI_UNAVAILABLE, payload.message ?? "Question command failed", response.status);
-    return payload;
+    if (!response.ok) {
+      const error = "error" in payload ? payload.error : void 0;
+      throw new QuestionsClientError(
+        error?.code ?? ASK_USER_ERROR_CODES.UI_UNAVAILABLE,
+        error?.message ?? "Question bridge call failed",
+        response.status
+      );
+    }
+    if (!payload.ok) {
+      throw new QuestionsClientError(
+        payload.error?.code ?? ASK_USER_ERROR_CODES.UI_UNAVAILABLE,
+        payload.error?.message ?? "Question bridge call failed",
+        response.status
+      );
+    }
+    return payload.output;
   }
   return {
-    dispatch,
-    cancel(question) {
-      return dispatch({ kind: ASK_USER_COMMAND_KINDS.CANCEL, params: { questionId: question.questionId, sessionId: question.sessionId, answerToken: question.answerToken } });
+    async pending(sessionId) {
+      const output = await callBridge(
+        ASK_USER_BRIDGE_OPS.pending,
+        { sessionId },
+        sessionId
+      );
+      return normalizeQuestion(output.pending);
+    },
+    async cancel(question) {
+      ensureAnswerToken(question);
+      return await callBridge(
+        ASK_USER_BRIDGE_OPS.cancel,
+        {
+          questionId: question.questionId,
+          sessionId: question.sessionId,
+          answerToken: question.answerToken
+        },
+        question.sessionId,
+        await deriveIdempotencyKey(ASK_USER_BRIDGE_OPS.cancel, {
+          questionId: question.questionId,
+          sessionId: question.sessionId,
+          answerToken: question.answerToken
+        })
+      );
     },
-    submit(question, values) {
+    async submit(question, values) {
+      ensureAnswerToken(question);
       if (!question.schema) throw new QuestionsClientError(ASK_USER_ERROR_CODES.QUESTION_NOT_READY, "Question is not ready");
       const validation = validateQuestionValues(question.schema, values);
       if (!validation.valid) throw new QuestionsClientError(ASK_USER_ERROR_CODES.ANSWER_INVALID, firstValidationMessage(validation));
-      return dispatch({ kind: ASK_USER_COMMAND_KINDS.SUBMIT, params: { questionId: question.questionId, sessionId: question.sessionId, answerToken: question.answerToken, values } });
+      return await callBridge(
+        ASK_USER_BRIDGE_OPS.answer,
+        {
+          questionId: question.questionId,
+          sessionId: question.sessionId,
+          answerToken: question.answerToken,
+          values
+        },
+        question.sessionId,
+        await deriveIdempotencyKey(ASK_USER_BRIDGE_OPS.answer, {
+          questionId: question.questionId,
+          sessionId: question.sessionId,
+          answerToken: question.answerToken,
+          values
+        })
+      );
     }
   };
 }
+function normalizeQuestion(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  if (typeof raw.questionId !== "string" || typeof raw.sessionId !== "string") return null;
+  const schema = isAskUserFormSchema(raw.schema) ? raw.schema : void 0;
+  return {
+    questionId: raw.questionId,
+    sessionId: raw.sessionId,
+    ownerPrincipalId: typeof raw.ownerPrincipalId === "string" ? raw.ownerPrincipalId : "anonymous",
+    status: normalizeQuestionStatus(raw.status),
+    title: typeof raw.title === "string" ? raw.title : void 0,
+    context: typeof raw.context === "string" ? raw.context : void 0,
+    schema,
+    answerToken: typeof raw.answerToken === "string" ? raw.answerToken : "",
+    createdAt: typeof raw.createdAt === "string" ? raw.createdAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+    updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : (/* @__PURE__ */ new Date(0)).toISOString()
+  };
+}
+async function deriveIdempotencyKey(op, inputValue) {
+  const canonical = `${op}:${stableStringify(inputValue)}`;
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle && typeof subtle.digest === "function") {
+    const input = new TextEncoder().encode(canonical);
+    const digest = await subtle.digest("SHA-256", input);
+    return `ask-user-idem:${Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join("")}`;
+  }
+  return `ask-user-idem:${deterministicHashHex(canonical)}`;
+}
+function deterministicHashHex(value) {
+  let h1 = 3735928559 ^ value.length;
+  let h2 = 1103547991 ^ value.length;
+  let h3 = 3235826430 ^ value.length;
+  let h4 = 2654435769 ^ value.length;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    h1 = Math.imul(h1 ^ code, 2654435761);
+    h2 = Math.imul(h2 ^ code, 1597334677);
+    h3 = Math.imul(h3 ^ code, 2246822507);
+    h4 = Math.imul(h4 ^ code, 3266489909);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h3 ^ h3 >>> 13, 3266489909);
+  h3 = Math.imul(h3 ^ h3 >>> 16, 2246822507) ^ Math.imul(h4 ^ h4 >>> 13, 3266489909);
+  h4 = Math.imul(h4 ^ h4 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return [h1, h2, h3, h4].map((part) => (part >>> 0).toString(16).padStart(8, "0")).join("");
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+}
+function normalizeQuestionStatus(status) {
+  if (status === "pending" || status === "ready") return "ready";
+  if (status === "answered" || status === "cancelled" || status === "abandoned") return status;
+  return "abandoned";
+}
+function ensureAnswerToken(question) {
+  if (!question.answerToken) throw new QuestionsClientError(ASK_USER_ERROR_CODES.QUESTION_NOT_READY, "Question answer token is missing");
+}
 function firstValidationMessage(validation) {
   return Object.values(validation.errors)[0] ?? "Invalid answer";
 }
+function isAskUserFormSchema(value) {
+  return !!value && typeof value === "object" && value.wireVersion === 1 && Array.isArray(value.fields);
+}
 
-// src/front/index.tsx
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+// src/front/runtime.ts
+import { createContext as createContext2, useContext as useContext2 } from "react";
 function createQuestionsStore() {
   const listeners = /* @__PURE__ */ new Set();
-  let pending = null;
+  const pendingBySession = /* @__PURE__ */ new Map();
+  const hintsBySession = /* @__PURE__ */ new Map();
+  const emit = () => {
+    for (const listener of [...listeners]) listener();
+  };
   return {
-    getPending: () => pending,
-    setPending(question) {
-      pending = question;
-      for (const listener of [...listeners]) listener();
+    getPending(sessionId) {
+      return sessionId ? pendingBySession.get(sessionId) ?? null : null;
+    },
+    setPending(question, sessionId) {
+      if (question) {
+        pendingBySession.set(question.sessionId, question);
+        hintsBySession.set(question.sessionId, { questionId: question.questionId, sessionId: question.sessionId, status: question.status });
+      } else if (sessionId) {
+        pendingBySession.delete(sessionId);
+        hintsBySession.delete(sessionId);
+      } else {
+        pendingBySession.clear();
+        hintsBySession.clear();
+      }
+      emit();
+    },
+    getPendingHints() {
+      return [...hintsBySession.values()];
+    },
+    getHydratedPendingKeys() {
+      return [...pendingBySession.values()].map((question) => `${question.sessionId}:${question.questionId}:${question.status}`);
+    },
+    setPendingHints(hints) {
+      hintsBySession.clear();
+      const authoritativeHints = /* @__PURE__ */ new Map();
+      for (const hint of hints) {
+        hintsBySession.set(hint.sessionId, hint);
+        authoritativeHints.set(hint.sessionId, hint);
+      }
+      for (const [sessionId, question] of [...pendingBySession.entries()]) {
+        const hint = authoritativeHints.get(sessionId);
+        if (!hint || hint.questionId !== question.questionId || hint.status && hint.status !== question.status) {
+          pendingBySession.delete(sessionId);
+        }
+      }
+      emit();
     },
     subscribe(listener) {
       listeners.add(listener);
@@ -356,60 +528,143 @@ function createQuestionsStore() {
 }
 var sharedQuestionsStore = createQuestionsStore();
 var QuestionsRuntimeContext = createContext2(null);
-function sessionScopedBlockerId(sessionId) {
-  return sessionId === "default" || sessionId === "anonymous" ? void 0 : sessionId;
-}
-function pendingQuestionSnapshot(store) {
-  const pending = store.getPending();
-  return pending ? `${pending.sessionId}:${pending.questionId}:${pending.status}` : "none";
-}
 function useQuestionsRuntime() {
   const ctx = useContext2(QuestionsRuntimeContext);
   if (!ctx) throw new Error("askUserPlugin QuestionsPane must be rendered under AskUserProvider");
   return ctx;
 }
-function AskUserProvider({ apiBaseUrl, authHeaders, children }) {
+function pendingQuestionSnapshot(store) {
+  const hints = store.getPendingHints().map((hint) => `${hint.sessionId}:${hint.questionId}:${hint.status ?? "ready"}`).sort();
+  const hydrated = store.getHydratedPendingKeys().sort();
+  return `${hints.length ? hints.join("|") : "none"}#hydrated=${hydrated.join("|")}`;
+}
+function isSessionOpen(runtime, sessionId) {
+  if (runtime.openSessionIds) return runtime.openSessionIds.includes(sessionId);
+  return runtime.activeSessionId === sessionId;
+}
+
+// src/front/providerHooks.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import {
+  UI_COMMAND_EVENT,
+  WORKSPACE_ATTENTION_ACTION_EVENT,
+  WORKSPACE_COMPOSER_STOP_EVENT,
+  WORKSPACE_SURFACE_OPEN_SKIPPED_EVENT,
+  events,
+  postUiCommand,
+  useWorkspaceAttention,
+  workspaceComposerStopAppliesToSession,
+  workspaceComposerStopTargetSessionId,
+  workspaceEvents
+} from "@hachej/boring-workspace";
+function useAskUserAttentionBlockers(runtime, pendingSnapshot) {
   const { addBlocker, removeBlocker } = useWorkspaceAttention();
-  const runtime = useMemo2(() => ({ ...sharedQuestionsStore, apiBaseUrl, authHeaders }), [apiBaseUrl, authHeaders]);
-  const pendingSnapshot = useSyncExternalStore(runtime.subscribe, () => pendingQuestionSnapshot(runtime), () => "none");
   useEffect2(() => {
-    const pending = runtime.getPending();
-    const blockerId = pending ? `${ASK_USER_PLUGIN_ID}:${pending.sessionId}:${pending.questionId}` : null;
-    if (pending?.status === "ready" && blockerId) {
+    const blockerIds = [];
+    for (const hint of runtime.getPendingHints()) {
+      if (hint.status && hint.status !== "ready") continue;
+      const blockerId = `${ASK_USER_PLUGIN_ID}:${hint.sessionId}:${hint.questionId}`;
+      blockerIds.push(blockerId);
+      const hydrated = runtime.getPending(hint.sessionId);
+      const isActiveHint = runtime.activeSessionId === hint.sessionId && isSessionOpen(runtime, hint.sessionId);
+      const actions = hydrated ? [{ id: "open", label: "Open Questions" }, { id: "cancel", label: "Cancel question" }] : isActiveHint ? [{ id: "open", label: "Open Questions" }] : void 0;
       addBlocker({
         id: blockerId,
-        reason: "waiting_for_user_input",
+        reason: "ask-user.question",
         surfaceKind: ASK_USER_SURFACE_KIND,
-        target: pending.questionId,
+        target: hint.questionId,
         label: "Answer the question in Questions to continue",
-        sessionId: sessionScopedBlockerId(pending.sessionId),
-        actions: [{ id: "open", label: "Open Questions" }, { id: "cancel", label: "Cancel question" }]
+        sessionId: hint.sessionId,
+        sessionBadge: { kind: "question", label: "question", tone: "attention", priority: 10 },
+        actions
       });
     }
     return () => {
-      if (blockerId) removeBlocker(blockerId);
+      for (const blockerId of blockerIds) removeBlocker(blockerId);
     };
   }, [addBlocker, removeBlocker, runtime, pendingSnapshot]);
+}
+function useAskUserAutoOpen(runtime, activeSessionId, pendingSnapshot) {
+  const autoOpenedQuestionsRef = useRef2(/* @__PURE__ */ new Set());
+  useEffect2(() => {
+    for (const hint2 of runtime.getPendingHints()) {
+      if (!isSessionOpen(runtime, hint2.sessionId)) autoOpenedQuestionsRef.current.delete(`${hint2.sessionId}:${hint2.questionId}`);
+    }
+    if (!activeSessionId || !isSessionOpen(runtime, activeSessionId)) return;
+    const hint = runtime.getPendingHints().find((candidate) => candidate.sessionId === activeSessionId);
+    if (!hint || hint.status && hint.status !== "ready") return;
+    const hydrated = runtime.getPending(activeSessionId);
+    if (!hydrated || hydrated.questionId !== hint.questionId || hydrated.status !== "ready") return;
+    const key = `${hint.sessionId}:${hint.questionId}`;
+    if (autoOpenedQuestionsRef.current.has(key)) return;
+    autoOpenedQuestionsRef.current.add(key);
+    postUiCommand({
+      kind: "openSurface",
+      params: {
+        kind: ASK_USER_SURFACE_KIND,
+        target: hint.questionId,
+        meta: { sessionId: hint.sessionId, openOnlyWhenSessionOpen: true }
+      }
+    });
+  }, [activeSessionId, runtime, pendingSnapshot]);
+}
+function useAskUserAttentionActions(runtime) {
+  useEffect2(() => {
+    const onAction = (event) => {
+      const detail = event.detail;
+      if (!detail || detail.actionId !== "cancel" || detail.blocker.reason !== "ask-user.question") return;
+      const sessionId = detail.blocker.sessionId ?? detail.sessionId ?? runtime.activeSessionId;
+      const pending = runtime.getPending(sessionId);
+      if (!pending || detail.blocker.target && pending.questionId !== detail.blocker.target) return;
+      runtime.setPending(null, pending.sessionId);
+      void createQuestionsClient({ apiBaseUrl: runtime.apiBaseUrl, headers: runtime.authHeaders }).cancel(pending).catch(() => void 0);
+    };
+    window.addEventListener(WORKSPACE_ATTENTION_ACTION_EVENT, onAction);
+    return () => window.removeEventListener(WORKSPACE_ATTENTION_ACTION_EVENT, onAction);
+  }, [runtime]);
+}
+function useAskUserComposerStopCancel(runtime) {
   useEffect2(() => {
     const onStop = (event) => {
-      const sessionId = event.detail?.sessionId;
-      const pending = runtime.getPending();
-      if (!pending || sessionId && sessionScopedBlockerId(pending.sessionId) && sessionId !== pending.sessionId) return;
-      runtime.setPending(null);
+      const detail = event.detail;
+      const sessionId = workspaceComposerStopTargetSessionId(detail, runtime.activeSessionId);
+      const pending = runtime.getPending(sessionId);
+      if (!pending || !workspaceComposerStopAppliesToSession(detail, pending.sessionId, {
+        fallbackSessionId: runtime.activeSessionId
+      })) return;
+      runtime.setPending(null, pending.sessionId);
       void createQuestionsClient({ apiBaseUrl: runtime.apiBaseUrl, headers: runtime.authHeaders }).cancel(pending).catch(() => void 0);
     };
-    window.addEventListener("boring:workspace-composer-stop", onStop);
-    return () => window.removeEventListener("boring:workspace-composer-stop", onStop);
+    window.addEventListener(WORKSPACE_COMPOSER_STOP_EVENT, onStop);
+    return () => window.removeEventListener(WORKSPACE_COMPOSER_STOP_EVENT, onStop);
   }, [runtime]);
+}
+function useAskUserPendingRefresh(runtime, options) {
+  const { activeSessionId, apiBaseUrl, authHeaders } = options;
   useEffect2(() => {
     let stopped = false;
     async function refreshPending() {
+      let hints = [];
       try {
         const response = await fetch(`${apiBaseUrl}/api/v1/ui/state`, { headers: authHeaders });
         const state = await response.json().catch(() => null);
-        if (!stopped) runtime.setPending(readPendingQuestionFromState(state));
+        hints = readPendingQuestionHintsFromState(state);
+        if (!stopped && hasPendingStateSlot(state)) runtime.setPendingHints(hints);
       } catch {
       }
+      const sessionsToHydrate = /* @__PURE__ */ new Set();
+      if (activeSessionId) sessionsToHydrate.add(activeSessionId);
+      for (const hint of hints) {
+        if (isSessionOpen(runtime, hint.sessionId)) sessionsToHydrate.add(hint.sessionId);
+      }
+      if (sessionsToHydrate.size === 0 && hints[0]) sessionsToHydrate.add(hints[0].sessionId);
+      await Promise.all([...sessionsToHydrate].map(async (sessionId) => {
+        try {
+          await runtime.refreshPending(sessionId);
+        } catch {
+          if (!stopped) runtime.setPending(null, sessionId);
+        }
+      }));
     }
     const onVisibility = () => {
       if (document.visibilityState === "visible") void refreshPending();
@@ -417,6 +672,10 @@ function AskUserProvider({ apiBaseUrl, authHeaders, children }) {
     const onUiCommand = () => {
       void refreshPending();
     };
+    const onSurfaceOpenSkipped = (event) => {
+      const detail = event.detail;
+      if (detail?.kind === ASK_USER_SURFACE_KIND) void refreshPending();
+    };
     let agentDataTimer = null;
     const onAgentData = () => {
       if (agentDataTimer) return;
@@ -426,44 +685,112 @@ function AskUserProvider({ apiBaseUrl, authHeaders, children }) {
       }, 1200);
     };
     const offAgentData = events.on(workspaceEvents.agentData, onAgentData);
+    const offUiCommand = events.on(workspaceEvents.uiCommand, onUiCommand);
     void refreshPending();
     window.addEventListener("focus", refreshPending);
     document.addEventListener("visibilitychange", onVisibility);
     window.addEventListener(UI_COMMAND_EVENT, onUiCommand);
+    window.addEventListener(WORKSPACE_SURFACE_OPEN_SKIPPED_EVENT, onSurfaceOpenSkipped);
     return () => {
       stopped = true;
       if (agentDataTimer) clearTimeout(agentDataTimer);
       offAgentData();
+      offUiCommand();
       window.removeEventListener("focus", refreshPending);
       document.removeEventListener("visibilitychange", onVisibility);
       window.removeEventListener(UI_COMMAND_EVENT, onUiCommand);
+      window.removeEventListener(WORKSPACE_SURFACE_OPEN_SKIPPED_EVENT, onSurfaceOpenSkipped);
     };
-  }, [apiBaseUrl, authHeaders, runtime]);
+  }, [activeSessionId, apiBaseUrl, authHeaders, runtime]);
+}
+function hasPendingStateSlot(state) {
+  return !!state && Object.prototype.hasOwnProperty.call(state, ASK_USER_UI_STATE_SLOTS.PENDING);
+}
+
+// src/front/index.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function AskUserProvider({ apiBaseUrl, authHeaders, activeSessionId, openSessionIds, children }) {
+  const runtime = useMemo2(() => ({
+    ...sharedQuestionsStore,
+    apiBaseUrl,
+    authHeaders,
+    activeSessionId,
+    openSessionIds,
+    async refreshPending(sessionId) {
+      const pending = await createQuestionsClient({ apiBaseUrl, headers: authHeaders }).pending(sessionId);
+      sharedQuestionsStore.setPending(pending, sessionId);
+      return pending;
+    }
+  }), [activeSessionId, apiBaseUrl, authHeaders, openSessionIds]);
+  const pendingSnapshot = useSyncExternalStore(runtime.subscribe, () => pendingQuestionSnapshot(runtime), () => "none");
+  useAskUserAttentionBlockers(runtime, pendingSnapshot);
+  useAskUserAutoOpen(runtime, activeSessionId, pendingSnapshot);
+  useAskUserAttentionActions(runtime);
+  useAskUserComposerStopCancel(runtime);
+  useAskUserPendingRefresh(runtime, { activeSessionId, apiBaseUrl, authHeaders });
   return /* @__PURE__ */ jsx2(QuestionsRuntimeContext.Provider, { value: runtime, children });
 }
+function paneQuestionSessionId(runtime, params) {
+  const activeSessionId = runtime.activeSessionId ?? null;
+  if (activeSessionId && isPaneSessionVisible(runtime, activeSessionId) && hasReadyQuestion(runtime, activeSessionId)) return activeSessionId;
+  if (params?.sessionId && isPaneSessionVisible(runtime, params.sessionId)) return params.sessionId;
+  return activeSessionId && isPaneSessionVisible(runtime, activeSessionId) ? activeSessionId : null;
+}
+function isPaneSessionVisible(runtime, sessionId) {
+  return !runtime.openSessionIds || isSessionOpen(runtime, sessionId);
+}
+function isPaneSessionKnownHidden(runtime, sessionId) {
+  return !!runtime.openSessionIds && !isSessionOpen(runtime, sessionId);
+}
+function hasReadyQuestion(runtime, sessionId) {
+  const pending = runtime.getPending(sessionId);
+  if (pending?.status === "ready") return true;
+  return runtime.getPendingHints().some((hint) => hint.sessionId === sessionId && (!hint.status || hint.status === "ready"));
+}
 function QuestionsPane({ api, params, className }) {
   const runtime = useQuestionsRuntime();
-  const pending = useSyncExternalStore(runtime.subscribe, runtime.getPending, runtime.getPending);
+  const paneSessionId = paneQuestionSessionId(runtime, params);
+  const pending = useSyncExternalStore(runtime.subscribe, () => runtime.getPending(paneSessionId), () => runtime.getPending(paneSessionId));
   const [closedQuestionId, setClosedQuestionId] = useState2(null);
+  const retargetRefreshRef = useRef3(null);
   const [error, setError] = useState2(null);
   const [submitting, setSubmitting] = useState2(false);
-  const paramQuestion = params?.question;
-  const question = pending ?? (paramQuestion?.questionId === closedQuestionId ? null : paramQuestion) ?? null;
+  const question = pending?.questionId === closedQuestionId ? null : pending;
   const client = useMemo2(() => createQuestionsClient({ apiBaseUrl: runtime.apiBaseUrl, headers: runtime.authHeaders }), [runtime.apiBaseUrl, runtime.authHeaders]);
-  useEffect2(() => {
+  useEffect3(() => {
+    if (!params?.sessionId || !isPaneSessionKnownHidden(runtime, params.sessionId)) return;
+    const activeSessionId = runtime.activeSessionId ?? null;
+    const canShowActiveQuestion = activeSessionId && isPaneSessionVisible(runtime, activeSessionId) && hasReadyQuestion(runtime, activeSessionId);
+    if (!canShowActiveQuestion) api.close();
+  }, [api, params?.sessionId, runtime]);
+  useEffect3(() => {
     const onStop = (event) => {
-      const sessionId = event.detail?.sessionId;
-      if (!question || sessionId && sessionScopedBlockerId(question.sessionId) && sessionId !== question.sessionId) return;
+      const detail = event.detail;
+      if (!question || !workspaceComposerStopAppliesToSession2(detail, question.sessionId)) return;
       setClosedQuestionId(question.questionId);
-      runtime.setPending(null);
+      runtime.setPending(null, question.sessionId);
       api.close();
     };
-    window.addEventListener("boring:workspace-composer-stop", onStop);
-    return () => window.removeEventListener("boring:workspace-composer-stop", onStop);
+    window.addEventListener(WORKSPACE_COMPOSER_STOP_EVENT2, onStop);
+    return () => window.removeEventListener(WORKSPACE_COMPOSER_STOP_EVENT2, onStop);
   }, [api, question, runtime]);
-  useEffect2(() => {
-    if (question && pending === null && !paramQuestion) api.close();
-  }, [api, pending, paramQuestion, question]);
+  useEffect3(() => {
+    if (!paneSessionId) return;
+    const targetQuestionId = params?.questionId;
+    if (!pending) {
+      retargetRefreshRef.current = null;
+      void runtime.refreshPending(paneSessionId).catch(() => void 0);
+      return;
+    }
+    if (!targetQuestionId || pending.questionId === targetQuestionId) {
+      retargetRefreshRef.current = null;
+      return;
+    }
+    const refreshKey = `${paneSessionId}:${targetQuestionId}`;
+    if (retargetRefreshRef.current === refreshKey) return;
+    retargetRefreshRef.current = refreshKey;
+    void runtime.refreshPending(paneSessionId).catch(() => void 0);
+  }, [paneSessionId, params?.questionId, pending, runtime]);
   return /* @__PURE__ */ jsx2("div", { className: className ? `${className} min-h-0 overflow-hidden` : "h-full min-h-0 overflow-hidden", children: /* @__PURE__ */ jsxs2(Pane, { className: "h-full min-h-0 overflow-hidden border-0 bg-background text-sm", children: [
     /* @__PURE__ */ jsx2(PaneHeader, { className: "border-b bg-background/95", children: /* @__PURE__ */ jsx2("div", { children: /* @__PURE__ */ jsxs2(PaneTitle, { className: "flex items-center gap-2", children: [
       /* @__PURE__ */ jsx2(HelpCircle, { className: "h-4 w-4 text-muted-foreground" }),
@@ -476,7 +803,7 @@ function QuestionsPane({ api, params, className }) {
       try {
         await client.submit(question, values);
         setClosedQuestionId(question.questionId);
-        runtime.setPending(null);
+        runtime.setPending(null, question.sessionId);
         api.close();
         params?.__closeWorkbenchOnDone?.();
       } catch (err) {
@@ -490,7 +817,7 @@ function QuestionsPane({ api, params, className }) {
       try {
         await client.cancel(question);
         setClosedQuestionId(question.questionId);
-        runtime.setPending(null);
+        runtime.setPending(null, question.sessionId);
         api.close();
         params?.__closeWorkbenchOnDone?.();
       } catch (err) {
@@ -515,7 +842,7 @@ function QuestionsPane({ api, params, className }) {
           /* @__PURE__ */ jsx2(Button, { asChild: true, size: "sm", children: /* @__PURE__ */ jsx2(QuestionSubmitButton, { children: question.schema.submitLabel ?? "Send answers" }) })
         ] })
       ] })
-    ] }) }) : null,
+    ] }) }, question.questionId) : null,
     question && question.status !== "ready" ? /* @__PURE__ */ jsx2(PaneBody, { className: "p-5", children: /* @__PURE__ */ jsx2(Notice, { children: /* @__PURE__ */ jsxs2("span", { className: "flex items-center gap-2", children: [
       /* @__PURE__ */ jsx2(XCircle, { className: "h-4 w-4 text-muted-foreground" }),
       "Question ",
@@ -551,12 +878,12 @@ var askUserPlugin = definePlugin({
       // No inner kind guard — the workspace's surface registry already
       // pre-filters by the top-level `kind` field before calling resolve.
       resolve(request) {
-        const metaQuestion = typeof request.meta === "object" && request.meta && "question" in request.meta ? request.meta.question : void 0;
+        const sessionId = typeof request.meta === "object" && request.meta && typeof request.meta.sessionId === "string" ? request.meta.sessionId : void 0;
         return {
           component: ASK_USER_PANEL_ID,
           id: ASK_USER_PANEL_ID,
           title: ASK_USER_PANEL_TITLE,
-          params: { questionId: request.target, question: metaQuestion }
+          params: { questionId: request.target, sessionId }
         };
       }
     }