@plannotator/ui 0.53.0 → 0.54.0

package/config/settings.ts

@@ -13,8 +13,14 @@ import {
   isAnnotateAgentTerminalSide,
   type AnnotateAgentTerminalSide,
 } from '@plannotator/core/agent-terminal';
-import type { DiffLineBgIntensity } from '@plannotator/core/config-types';
+import type { DiffLineBgIntensity, ReviewDefaults } from '@plannotator/core/config-types';
 import { isFaviconStyle, type FaviconStyle } from '@plannotator/core/favicon';
+import {
+  agentSwitchConfigValue,
+  isAgentSwitchName,
+  parseAgentSwitchConfig,
+  type AgentSwitchChoice,
+} from '@plannotator/core/agent-switch';
 import {
   DEFAULT_TOKEN_HOVER_DELAY_MS,
   isTokenHoverDelay,
@@ -23,7 +29,14 @@ import {
   type TokenHoverTrigger,
 } from '@plannotator/core/token-hover';
 import { DEFAULT_DIAGRAM_SHADOW, isDiagramShadow } from '../utils/diagramShadow';
+import {
+  DEFAULT_DOCUMENT_TEXT_SIZE,
+  isDocumentTextSize,
+  type DocumentTextSize,
+} from '../utils/documentTextSize';
+import { normalizeFontFamilyName } from '../utils/cssFontFamily';
 import { storage } from '../utils/storage';
+import { isLookChoiceResolved } from '../utils/lookAndFeelAnnouncement';
 import { generateIdentity } from '../utils/generateIdentity';
 import {
   getDefaultThemePair,
@@ -89,11 +102,45 @@ export function readThemePairCookies(keys?: ThemePairLegacyKeys): ThemePair | un
   return normalizeThemePair({ mode, light: light ?? seeded.light, dark: dark ?? seeded.dark }, seeded);
 }
 
+/** Pre-registry cookie keys of the agent switch, kept so an upgrade keeps the choice. */
+const AGENT_SWITCH_COOKIE = 'plannotator-agent-switch';
+const AGENT_SWITCH_CUSTOM_COOKIE = 'plannotator-agent-custom';
+
+function readAgentSwitchCookies(): AgentSwitchChoice | undefined {
+  const choice = parseAgentSwitchConfig(storage.getItem(AGENT_SWITCH_COOKIE));
+  if (!choice) return undefined;
+  const customName = storage.getItem(AGENT_SWITCH_CUSTOM_COOKIE);
+  return isAgentSwitchName(customName) ? { switchTo: choice.switchTo, customName } : choice;
+}
+
+function writeAgentSwitchCookies(choice: AgentSwitchChoice | null): void {
+  // null = never chosen: write nothing, so the surface default keeps applying.
+  if (!choice) return;
+  storage.setItem(AGENT_SWITCH_COOKIE, choice.switchTo);
+  if (choice.customName) storage.setItem(AGENT_SWITCH_CUSTOM_COOKIE, choice.customName);
+  // Custom with its name cleared: drop the old name, or the next read would
+  // pair it with "custom" and switch to that old agent again.
+  else if (choice.switchTo === 'custom') storage.removeItem(AGENT_SWITCH_CUSTOM_COOKIE);
+}
+
 const DIFF_LINE_BG_INTENSITY_VALUES = ['subtle', 'normal', 'strong'] as const;
 function isDiffLineBgIntensity(v: unknown): v is DiffLineBgIntensity {
   return typeof v === 'string' && (DIFF_LINE_BG_INTENSITY_VALUES as readonly string[]).includes(v);
 }
 
+function parseReviewDefaults(value: unknown): ReviewDefaults | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  const defaults: ReviewDefaults = {};
+  for (const [providerId, providerValue] of Object.entries(value)) {
+    if (!providerId || !providerValue || typeof providerValue !== 'object' || Array.isArray(providerValue)) continue;
+    const defaultDiffType = (providerValue as Record<string, unknown>).defaultDiffType;
+    if (typeof defaultDiffType === 'string' && defaultDiffType) {
+      defaults[providerId] = { defaultDiffType };
+    }
+  }
+  return defaults;
+}
+
 export interface SettingDef<T> {
   defaultValue: T | (() => T);
   fromCookie: () => T | undefined;
@@ -160,10 +207,18 @@ export const SETTINGS = {
   },
 
   gridEnabled: {
-    // Default ON: plans open in the classic grid / floating-card look. The UI 2.0
-    // flat look is offered as an opt-in via the look-and-feel chooser dialog.
-    defaultValue: true as boolean,
+    // Default OFF: plans open in the Clean look (the document edge to edge).
+    // Grid (the classic floating card on grid paper) is a choice, made in the
+    // first-run chooser or in Settings.
+    defaultValue: false as boolean,
     fromCookie: () => {
+      // ConfigStore writes the default into this cookie on first load, so every
+      // browser that ran an older build stored 'true' (the old default) without
+      // anyone choosing it. The stored value counts only once the person has
+      // resolved the Grid/Clean choice under the Clean default (the v2 marker;
+      // a v1 marker with Grid stored is moved to Clean once, see
+      // utils/lookAndFeelAnnouncement); until then they get Clean.
+      if (!isLookChoiceResolved()) return undefined;
       const v = storage.getItem('plannotator-grid-enabled');
       return v === 'true' ? true : v === 'false' ? false : undefined;
     },
@@ -192,6 +247,54 @@ export const SETTINGS = {
     serverKey: undefined, fromServer: undefined, toServer: undefined,
   },
 
+  /**
+   * The document's body text size in plan review and annotate, in px (#2066;
+   * see `utils/documentTextSize`). Default 15, today's size. Cookie-only, like
+   * the other display knobs; an unknown value reads as the default.
+   */
+  documentTextSize: {
+    defaultValue: DEFAULT_DOCUMENT_TEXT_SIZE as DocumentTextSize,
+    fromCookie: () => {
+      const raw = storage.getItem('plannotator-document-text-size');
+      if (raw === null || raw.trim() === '') return undefined;
+      const parsed = Number(raw);
+      return isDocumentTextSize(parsed) ? parsed : undefined;
+    },
+    toCookie: (value: DocumentTextSize) =>
+      storage.setItem('plannotator-document-text-size', String(value)),
+    serverKey: undefined, fromServer: undefined, toServer: undefined,
+  },
+
+  /**
+   * The document's font in plan review and annotate (#1657; see
+   * `utils/documentFont`): a generic preset or an installed family name.
+   * Empty = the theme's font. Cookie-only, like Text size.
+   */
+  documentFontFamily: {
+    defaultValue: '' as string,
+    fromCookie: () =>
+      normalizeFontFamilyName(storage.getItem('plannotator-document-font-family') ?? '') || undefined,
+    toCookie: (value: string) => storage.setItem('plannotator-document-font-family', value),
+    serverKey: undefined, fromServer: undefined, toServer: undefined,
+  },
+
+  /**
+   * Enter saves a comment and Shift+Enter adds a new line (#1934). Default
+   * OFF: comments save with Cmd/Ctrl+Enter only, as they always have, and
+   * Cmd/Ctrl+Enter keeps saving with it on. Read by every comment composer
+   * through `isCommentSubmitKey` (`utils/commentSubmitKey`). Cookie-only.
+   */
+  enterSavesComment: {
+    defaultValue: false as boolean,
+    fromCookie: () => {
+      const value = storage.getItem('plannotator-enter-saves-comment');
+      return value === 'true' ? true : value === 'false' ? false : undefined;
+    },
+    toCookie: (value: boolean) =>
+      storage.setItem('plannotator-enter-saves-comment', String(value)),
+    serverKey: undefined, fromServer: undefined, toServer: undefined,
+  },
+
   vimModeEnabled: {
     // Vim bindings deliberately default OFF. Unmodified letter keys must remain
     // inert for existing users until they explicitly opt into modal document
@@ -360,6 +463,25 @@ export const SETTINGS = {
     serverKey: undefined, fromServer: undefined, toServer: undefined,
   },
 
+  reviewDefaults: {
+    defaultValue: {} as ReviewDefaults,
+    fromCookie: () => {
+      const value = storage.getItem('plannotator-review-defaults');
+      if (!value) return undefined;
+      try {
+        return parseReviewDefaults(JSON.parse(value));
+      } catch {
+        return undefined;
+      }
+    },
+    toCookie: (value: ReviewDefaults) =>
+      storage.setItem('plannotator-review-defaults', JSON.stringify(value)),
+    serverKey: 'reviewDefaults',
+    fromServer: (serverConfig: Record<string, unknown>) =>
+      parseReviewDefaults(serverConfig.reviewDefaults),
+    toServer: (value: ReviewDefaults) => ({ reviewDefaults: value }),
+  },
+
   defaultDiffType: {
     defaultValue: 'since-base' as 'since-base' | 'local-vs-remote' | 'uncommitted' | 'unstaged' | 'staged' | 'merge-base' | 'all',
     fromCookie: () => {
@@ -655,6 +777,35 @@ export const SETTINGS = {
       }
     },
   },
+  /**
+   * OpenCode's agent switch after plan approval / review feedback (#1390).
+   * null = never chosen: each surface applies its own default (plan approval
+   * switches to "build", review feedback stays), see utils/agentSwitch.
+   *
+   * Server-synced to `agentSwitch` in ~/.plannotator/config.json because some
+   * webviews (Glimpse's WKWebView) keep no cookies between runs, and a lost
+   * choice silently hands the session to the build agent. The cookie keys
+   * are the pre-registry ones, so an upgrade keeps an existing choice.
+   */
+  agentSwitch: {
+    defaultValue: null as AgentSwitchChoice | null,
+    fromCookie: () => readAgentSwitchCookies(),
+    toCookie: (v: AgentSwitchChoice | null) => writeAgentSwitchCookies(v),
+    serverKey: 'agentSwitch',
+    fromServer: (sc: Record<string, unknown>) => {
+      const choice = parseAgentSwitchConfig(sc.agentSwitch);
+      // Custom with no name means no switch: never pair it with an old name.
+      if (!choice || choice.customName || choice.switchTo === 'custom') return choice;
+      // A plain choice keeps the name typed in the Custom field earlier, so
+      // picking Custom again shows it (the cookie is the only place it lives).
+      const customName = storage.getItem(AGENT_SWITCH_CUSTOM_COOKIE);
+      return isAgentSwitchName(customName) ? { ...choice, customName } : choice;
+    },
+    toServer: (v: AgentSwitchChoice | null) => {
+      const value = v ? agentSwitchConfigValue(v) : undefined;
+      return value === undefined ? {} : { agentSwitch: value };
+    },
+  },
   /**
    * Where the annotate-mode Agent TUI docks: 'left' (where it always docked),
    * 'right', or 'hidden' (no slot until the user opens it for the session).

package/configure.ts

@@ -18,6 +18,9 @@ import { configStore } from './config';
 import type { ServerSyncFn } from './config/configStore';
 import type { ExternalAnnotationEvent, VaultNode } from './types';
 import { setComponentTooltips } from './components/HostTitle';
+import { setRichCopyEnabled } from './utils/richCopyPolicy';
+import { setDigitHexIssueRefs } from './components/InlineMarkdown';
+import { setRefCardTransport, type RefCardTransport } from './utils/refCard';
 
 // One-stop type barrel: every seam contract a host implements is importable
 // from this module, next to configurePlannotatorUI itself.
@@ -44,6 +47,7 @@ export type {
   IdentityGenerator,
   AlertIconRenderer,
   FenceThemeResolver,
+  RefCardTransport,
 };
 
 type ExternalAnnotationBase = { id: string; source?: string };
@@ -127,6 +131,27 @@ export interface PlannotatorUIConfig {
    * as before. The Plannotator Inbox passes true.
    */
   componentTooltips?: boolean;
+  /**
+   * Render a digit-only 6/8-digit `#123456` (word boundary, no leading zero)
+   * as an issue ref instead of a hex colour swatch, when a ref link can be
+   * built (a repo on a known forge). Default: false, swatches exactly as
+   * before. The Plannotator Inbox passes true (#1932).
+   */
+  digitHexIssueRefs?: boolean;
+  /**
+   * Make the selection toolbar's Copy button (Viewer and HtmlViewer) copy rich
+   * text: text/html plus text/plain in one clipboard write, and show Copy
+   * where `hideCopyButton` hid it (the Viewer on desktop). Default: false,
+   * Copy exactly as before. Plannotator's plan review, annotate, code review
+   * and Inbox pass true (#1972, `utils/richCopyPolicy`).
+   */
+  richCopy?: boolean;
+  /**
+   * Fetch an issue / PR / MR hover card's data (`components/RefHoverCard`).
+   * Default: none, so no card is drawn and nothing is requested. The
+   * Plannotator Inbox passes one over its `/api/inbox/ref` route.
+   */
+  refCardTransport?: RefCardTransport;
   /** Re-hydrate settings from the installed (SYNCHRONOUS) storageBackend after install. */
   loadSettingsFromBackend?: boolean;
 }
@@ -152,6 +177,9 @@ export function configurePlannotatorUI(config: PlannotatorUIConfig): void {
   if (config.alertIconRenderer) setAlertIconRenderer(config.alertIconRenderer);
   if (config.fenceTheme) setFenceThemeResolver(config.fenceTheme);
   if (config.componentTooltips !== undefined) setComponentTooltips(config.componentTooltips);
+  if (config.digitHexIssueRefs !== undefined) setDigitHexIssueRefs(config.digitHexIssueRefs);
+  if (config.richCopy !== undefined) setRichCopyEnabled(config.richCopy);
+  if (config.refCardTransport) setRefCardTransport(config.refCardTransport);
   // Re-hydrate AFTER storageBackend is installed (load-bearing order — gated last).
   if (config.loadSettingsFromBackend) configStore.loadFromBackend();
 }

package/hooks/pfm/useCodeFilePopout.ts

@@ -1,4 +1,4 @@
-import { useState, useCallback } from "react";
+import { useState, useCallback, useRef } from "react";
 import { parseCodePath } from "@plannotator/core/code-file";
 
 interface CodeFileState {
@@ -9,6 +9,7 @@ interface CodeFileState {
   requestedPath?: string;
   line?: number;
   lineEnd?: number;
+  revealKey?: number;
 }
 
 interface UseCodeFilePopoutOptions {
@@ -29,6 +30,8 @@ export interface UseCodeFilePopoutReturn {
     requestedPath?: string;
     line?: number;
     lineEnd?: number;
+    /** Changes on every open, so reopening the same file:line scrolls to it again. */
+    revealKey?: number;
   } | null;
 }
 
@@ -38,6 +41,7 @@ export function useCodeFilePopout(
   const { buildUrl } = options;
   const [state, setState] = useState<CodeFileState | null>(null);
   const [isLoading, setIsLoading] = useState(false);
+  const revealCount = useRef(0);
 
   const close = useCallback(() => {
     setState(null);
@@ -75,6 +79,7 @@ export function useCodeFilePopout(
           prerenderedHTML: data.prerenderedHTML,
           line: data.line ?? parsed.line,
           lineEnd: data.lineEnd ?? parsed.lineEnd,
+          revealKey: ++revealCount.current,
         });
         setIsLoading(false);
       } catch {
@@ -105,6 +110,7 @@ export function useCodeFilePopout(
           requestedPath: state.requestedPath,
           line: state.line,
           lineEnd: state.lineEnd,
+          revealKey: state.revealKey,
         }
       : null,
   };

package/hooks/useAIChat.ts

@@ -30,6 +30,9 @@ export interface AIChatThread {
 
 export interface AskAIParams {
   prompt: string;
+  /** What the chat shows as the question when it differs from `prompt`, which
+   *  is what the agent gets (e.g. a short "Explain this finding: …"). */
+  displayPrompt?: string;
   filePath?: string;
   lineStart?: number;
   lineEnd?: number;
@@ -52,6 +55,12 @@ export interface AskAIParams {
    *  received, and the server frames it as read-only context, never as
    *  feedback (#1748). Leave unset for every other provider. */
   draftAnnotations?: string;
+  /** Called once, when the stream first shows the question reached the
+   *  session (an answer started, or the session took it over). A busy, gone
+   *  or failed ask never calls it; a retry keeps it, so the retried question
+   *  calls it when it lands. Lets a caller record what the session was told
+   *  (e.g. which document a note named) only once it was received. */
+  onDelivered?: () => void;
 }
 
 /** What to send as `draftAnnotations` for one question: the list when this
@@ -73,6 +82,15 @@ const BRIDGE_DRAFTS_KEY = 'session-bridge';
 /** Stream messages that show the session received the question. */
 const DELIVERED_MESSAGE_TYPES = new Set(['text_delta', 'text', 'tool_use', 'tool_result', 'result']);
 
+/**
+ * A busy "Ask this session" answer still offers its choice ("Ask when it
+ * finishes" / "Interrupt and ask now"): the question has not been asked yet,
+ * and clearing the thread would drop it without a word.
+ */
+export function hasPendingBusyChoice(messages: AIChatEntry[]): boolean {
+  return messages.some(m => m.response.errorCode === SESSION_ASK_ERROR_CODES.agentBusy);
+}
+
 /** Overrides for re-asking a question that ended in a busy/gone/blocked answer. */
 export interface AIRetryOptions {
   busyPolicy?: 'wait' | 'interrupt';
@@ -179,8 +197,9 @@ export interface AITransport {
   session(body: unknown, signal: AbortSignal): Promise<Response>;
   /** POST /api/ai/query — send a message; returns the streaming SSE response. */
   query(body: unknown, signal: AbortSignal): Promise<Response>;
-  /** POST /api/ai/abort — abort a session (supersede + standalone). Resolves once
-      the server acknowledges so a following query can await it (best-effort, never rejects). */
+  /** POST /api/ai/abort. A superseding question sends `reason: 'supersede'`
+   * so session bridges close the answer without stopping the host turn.
+   * Resolves once acknowledged, before the old fetch is disconnected. */
   abort(body: unknown): Promise<unknown>;
   /** POST /api/ai/permission — respond to a permission request. Fire-and-forget. */
   permission(body: unknown): void;
@@ -238,9 +257,9 @@ export const resetAITransport = (): void => {
  * ask() relies on this resolving. Single-sourced so every abort call site stays
  * hardened. Reads `aiTransport` at call time so a late override is honored.
  */
-function safeAbort(sessionId: string): Promise<unknown> {
+function safeAbort(sessionId: string, reason?: 'supersede'): Promise<unknown> {
   return Promise.resolve()
-    .then(() => aiTransport.abort({ sessionId }))
+    .then(() => aiTransport.abort({ sessionId, ...(reason && { reason }) }))
     .catch(() => {});
 }
 
@@ -261,10 +280,15 @@ export function useAIChat({
   // In-flight server abort (from Stop or a superseding question). The next ask()
   // waits on it so a new query can't race the still-active turn into busy.
   const pendingAbortRef = useRef<Promise<unknown> | null>(null);
+  // Answers a newer question replaced. Their fetch stays open until the server
+  // acknowledges the supersede, but nothing more they stream is shown.
+  const supersededRef = useRef(new WeakSet<AbortController>());
   const sessionEpochRef = useRef(0);
   const createRequestRef = useRef(0);
   const sessionIdRef = useRef<string | null>(null);
   sessionIdRef.current = thread.sessionId;
+  const threadRef = useRef(thread);
+  threadRef.current = thread;
 
   const updateMessages = useCallback((updater: (messages: AIChatEntry[]) => AIChatEntry[]) => {
     setThread(prev => ({ ...prev, messages: updater(prev.messages) }));
@@ -316,16 +340,13 @@ export function useAIChat({
     }
   }, [context, model, providerId, reasoningEffort, setSessionId]);
 
-  // Tell the server to stop the current session's in-flight turn, and resolve
-  // once it has. Used by the Stop button and when a new question supersedes a
-  // streaming one — aborting the browser fetch alone leaves the agent's turn
-  // running. The /api/ai/abort handler clears the session's active flag before
-  // it responds, so awaiting this guarantees a following query won't race it
-  // into a session_busy error. Best-effort (never rejects).
-  const postServerAbort = useCallback((): Promise<unknown> => {
+  // Stop cancels the turn. Supersede closes the old answer but lets a session
+  // bridge's host keep working until the reviewer chooses to interrupt it.
+  // Both clear the server's query before the next one. Best-effort (never rejects).
+  const postServerAbort = useCallback((reason?: 'supersede'): Promise<unknown> => {
     const sessionId = sessionIdRef.current; // capture the session being aborted now
     if (!sessionId) return Promise.resolve();
-    return safeAbort(sessionId);
+    return safeAbort(sessionId, reason);
   }, []);
 
   // The params each question was asked with, so a busy answer can be
@@ -341,19 +362,18 @@ export function useAIChat({
   const deliveredDraftsRef = useRef<{ sessionId: string; text: string } | null>(null);
 
   const ask = useCallback(async (params: AskAIParams, askOptions?: { providerId?: string }) => {
-    if (abortRef.current) {
-      abortRef.current.abort();
-      // Supersede: stop the server-side turn (not just the browser fetch).
-      pendingAbortRef.current = postServerAbort();
+    const previous = abortRef.current;
+    if (previous) {
+      supersededRef.current.add(previous);
+      pendingAbortRef.current = postServerAbort('supersede');
     }
-    // Wait for any in-flight server abort — from this supersede OR a prior Stop
-    // click — so the query below doesn't race the still-active turn into a
-    // session_busy error. Stopping still kills the turn; chatting right after
-    // just waits the one round-trip for the stop to land.
+    // Let the server distinguish supersede from Stop before disconnecting:
+    // cancelling the SSE fetch first would still abort the host's turn.
     if (pendingAbortRef.current) {
       await pendingAbortRef.current;
       pendingAbortRef.current = null;
     }
+    previous?.abort();
 
     const controller = new AbortController();
     abortRef.current = controller;
@@ -364,7 +384,7 @@ export function useAIChat({
     paramsByQuestionRef.current.set(questionId, params);
     const question: AIQuestion = {
       id: questionId,
-      prompt: params.prompt,
+      prompt: params.displayPrompt ?? params.prompt,
       scope: params.scope,
       filePath: params.filePath,
       lineStart: params.lineStart,
@@ -392,7 +412,7 @@ export function useAIChat({
         sid = await createSession(controller.signal, epoch);
       }
 
-      if (controller.signal.aborted || epoch !== sessionEpochRef.current) {
+      if (controller.signal.aborted || supersededRef.current.has(controller) || epoch !== sessionEpochRef.current) {
         throw createAbortError('AI question was superseded');
       }
 
@@ -400,11 +420,20 @@ export function useAIChat({
       const drafts = draftAnnotationsToSend(deliveredDraftsRef.current, BRIDGE_DRAFTS_KEY, params.draftAnnotations);
       // Recorded once the session shows it received the question, so a busy,
       // gone or failed ask sends the list again next time.
+      let deliveredCalled = false;
       const markDraftsDelivered = (msg: { type?: unknown; code?: unknown }) => {
-        if (drafts === undefined) return;
         const received = DELIVERED_MESSAGE_TYPES.has(String(msg.type))
           || (msg.type === 'error' && msg.code === SESSION_ASK_ERROR_CODES.takenOver);
-        if (received) deliveredDraftsRef.current = { sessionId: BRIDGE_DRAFTS_KEY, text: drafts };
+        if (!received) return;
+        if (drafts !== undefined) deliveredDraftsRef.current = { sessionId: BRIDGE_DRAFTS_KEY, text: drafts };
+        if (!deliveredCalled) {
+          deliveredCalled = true;
+          try {
+            params.onDelivered?.();
+          } catch {
+            // A caller's bookkeeping must never break the stream.
+          }
+        }
       };
       const res = await aiTransport.query({
         sessionId: sid,
@@ -425,6 +454,7 @@ export function useAIChat({
 
       while (true) {
         const { done, value } = await reader.read();
+        if (supersededRef.current.has(controller)) throw createAbortError('AI question was superseded');
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
 
@@ -566,7 +596,7 @@ export function useAIChat({
         )
       );
     } finally {
-      if (abortRef.current === controller) {
+      if (abortRef.current === controller && !supersededRef.current.has(controller)) {
         setIsStreaming(false);
         abortRef.current = null;
       }
@@ -649,6 +679,22 @@ export function useAIChat({
     setError(null);
   }, [postServerAbort, threadTitle]);
 
+  // The panel's "New chat": clears the thread and forgets the Plannotator AI
+  // session, so the next question starts a fresh one (a separate AI then gets
+  // the full context again). Unlike `resetThread` (a document switch), it never
+  // stops anything: while a question is in flight (streaming, creating its
+  // session, or waiting on a busy "Ask this session") or a busy answer still
+  // offers its choice, it does nothing and answers false, so a running turn is
+  // not aborted and a pending ask is not dropped. What the agent session already received (`deliveredDraftsRef`) is
+  // kept: with "Ask this session" a new chat reaches the SAME host session,
+  // which still remembers it.
+  const newChat = useCallback((): boolean => {
+    if (abortRef.current) return false;
+    if (hasPendingBusyChoice(threadRef.current.messages)) return false;
+    resetThread();
+    return true;
+  }, [resetThread]);
+
   useEffect(() => {
     return () => {
       sessionEpochRef.current += 1;
@@ -672,6 +718,7 @@ export function useAIChat({
     abort,
     resetSession,
     resetThread,
+    newChat,
     sessionId: thread.sessionId,
   };
 }