@plannotator/ui 0.49.0 → 0.51.0

package/hooks/useAnnotationHighlighter.ts

@@ -11,6 +11,7 @@ import type { Annotation, EditorMode, ImageAttachment } from '../types';
 import { AnnotationType } from '../types';
 import type { QuickLabel } from '../utils/quickLabels';
 import { getIdentity } from '../utils/identity';
+import { annotationOwnsHighlight } from '../utils/annotationOwnsHighlight';
 import { transformPlainText } from '../utils/inlineTransforms';
 
 // --- Exported state types ---
@@ -283,6 +284,37 @@ const paintedTextOf = (doms: readonly HTMLElement[]): string => {
   return painted;
 };
 
+/** The block element a painted highlight sits in, found the way an
+ *  annotation's `blockId` is found when it is created (walk up from the
+ *  parent of the first highlighted node to the nearest `data-block-id`), so an
+ *  unchanged document resolves every restore to the block it was made in. */
+const blockElementOf = (dom: Node | null | undefined): HTMLElement | null => {
+  let parent = dom?.parentElement ?? null;
+  while (parent && !parent.dataset.blockId) parent = parent.parentElement;
+  return parent;
+};
+
+/** Where `quote` starts in `text`, matching whitespace-insensitively (the
+ *  same comparison the restore verification uses: a quote that crossed a
+ *  block boundary or a soft wrap carries different whitespace than the
+ *  block's text). 0 when it is not there, as at creation. */
+const quoteOffsetIn = (text: string, quote: string): number => {
+  const exact = text.indexOf(quote);
+  if (exact !== -1) return exact;
+  const needle = compactText(quote);
+  if (!needle) return 0;
+  // Compact the text while remembering each kept character's original index.
+  const positions: number[] = [];
+  let compact = '';
+  for (let i = 0; i < text.length; i++) {
+    if (/\s/.test(text[i])) continue;
+    compact += text[i];
+    positions.push(i);
+  }
+  const at = compact.indexOf(needle);
+  return at === -1 ? 0 : positions[at];
+};
+
 /**
  * Tags whose boxes a browser separates with a line break in a selection string.
  *
@@ -661,9 +693,34 @@ export interface AnnotationRestoreReport {
   /** Ids the pass considered — including ones already painted, which are
    *  anchored by definition. A host clears their unanchored marks. */
   attempted: string[];
-  /** Of those, the ones left with no highlight because the stored positions
-   *  resolved onto the wrong text AND the quote was nowhere in the document. */
+  /** Of those, the ones left with no highlight: neither the stored positions
+   *  (absent, unresolvable, or resolved onto the wrong text) nor a search for
+   *  the quote found it in the document. */
   unanchored: string[];
+  /** Annotations whose stored `blockId` no longer names where their text is,
+   *  because the document changed since they were made (a draft restored
+   *  after an edit, a plan revision). Each entry says where the text is NOW:
+   *  `blockId` is the block the highlight landed in, or `''` when the text is
+   *  gone (every unanchored id is listed here too). Annotations whose stored
+   *  block still holds their text are never listed, so an unchanged document
+   *  reports nothing here. A host that exports line numbers from `blockId`
+   *  should write these back. Optional so older reporters (the diagram
+   *  overlay) need not produce it. */
+  moved?: RestoredAnchor[];
+}
+
+/** Where a restored annotation's text sits now (see `moved`). */
+export interface RestoredAnchor {
+  id: string;
+  /** The block the highlight landed in; `''` when the text is gone. */
+  blockId: string;
+  /** Offset of the quote in that block's text (same rule as creation);
+   *  absent when the text is gone. */
+  startOffset?: number;
+  /** The stored `startMeta`/`endMeta` did not lead to the text (unresolvable,
+   *  or onto other text) and should be dropped so later restores search by
+   *  text instead. False when the stored positions themselves were verified. */
+  positionsStale: boolean;
 }
 
 /** Annotation UI state and mutation commands owned by one rendered document. */
@@ -1097,9 +1154,36 @@ export function useAnnotationHighlighter({
 
     const attempted: string[] = [];
     const unanchored: string[] = [];
+    const moved: RestoredAnchor[] = [];
+
+    // Record where a restored annotation's text sits when its stored blockId
+    // no longer names that place. Block ids are positional (`block-N`), so
+    // after the document changed the stored id can name a different block,
+    // and a line label read from it would point at the wrong line. Nothing is
+    // recorded while the stored block still holds the quote — an unchanged
+    // document, or a quote that also appears in the stored block — so the
+    // stored id (and the export built from it) stays exactly as it was.
+    const noteAnchor = (ann: Annotation, firstDom: Node | null | undefined, positionsStale: boolean) => {
+      if (!ann.blockId) return;
+      const blockEl = blockElementOf(firstDom);
+      const blockId = blockEl?.dataset.blockId;
+      if (!blockEl || !blockId || blockId === ann.blockId) return;
+      const stored = containerRef.current?.querySelector(
+        `[data-block-id="${escapeAttrValue(ann.blockId)}"]`,
+      );
+      const quote = compactText(ann.originalText);
+      if (stored && quote && compactText(stored.textContent ?? '').includes(quote)) return;
+      moved.push({ id: ann.id, blockId, startOffset: quoteOffsetIn(blockEl.textContent ?? '', ann.originalText), positionsStale });
+    };
 
     anns.forEach(ann => {
       if (ann.type === AnnotationType.GLOBAL_COMMENT) return;
+      // Diff-view comments (`diff-block-N`, drawn by the diff view) and
+      // checkbox toggles (raw-markdown quotes keyed by their block) are never
+      // text highlights. Callers filter them out; skipping them here as well
+      // keeps a stray one from being reported unanchored or moved, which would
+      // rewrite its blockId.
+      if (!annotationOwnsHighlight(ann)) return;
       // A comment on a rendered diagram part has no text anchor: the
       // diagram overlay restores it against its render and reports its own
       // verdict, so it is neither attempted nor unanchored here (the same
@@ -1128,7 +1212,8 @@ export function useAnnotationHighlighter({
       if (existingManual) return;
 
       const mathTargets = findMathElementsForAnnotation(ann);
-      if (mathTargets.length > 0) {
+      const paintedMath = mathTargets.length > 0;
+      if (paintedMath) {
         applyMathTargets(mathTargets, ann.id, ann.type);
         if (!ann.startMeta && !ann.endMeta && !ann.mathTargets?.length) {
           return;
@@ -1160,6 +1245,7 @@ export function useAnnotationHighlighter({
               } else if (ann.type === AnnotationType.COMMENT) {
                 highlighter.addClass('comment', ann.id);
               }
+              if (!paintedMath) noteAnchor(ann, restoredDoms[0] as Node, false);
               return;
             }
           }
@@ -1169,9 +1255,15 @@ export function useAnnotationHighlighter({
       const range = findTextInDOM(ann.originalText);
       if (!range) {
         if (rejectedRestoreText !== null) {
-          unanchored.push(ann.id);
           onRestoreMismatchRef.current?.(ann, rejectedRestoreText);
         }
+        // Nothing painted it: not the stored positions (absent, unresolvable,
+        // or onto other text) and not the search. A formula the math path
+        // painted above is anchored, whatever its quote search says.
+        if (!paintedMath) {
+          unanchored.push(ann.id);
+          moved.push({ id: ann.id, blockId: '', positionsStale: true });
+        }
         console.warn(`Could not find text for annotation ${ann.id}: "${ann.originalText.slice(0, 50)}..."`);
         return;
       }
@@ -1229,6 +1321,8 @@ export function useAnnotationHighlighter({
           return;
         }
 
+        if (!paintedMath) noteAnchor(ann, textNodes[0].node, true);
+
         textNodes.reverse().forEach(({ node, start, end }) => {
           try {
             const nodeRange = document.createRange();
@@ -1259,7 +1353,9 @@ export function useAnnotationHighlighter({
       }
     });
 
-    if (attempted.length > 0) onRestoreReportRef.current?.({ attempted, unanchored });
+    if (attempted.length > 0) {
+      onRestoreReportRef.current?.({ attempted, unanchored, ...(moved.length > 0 ? { moved } : {}) });
+    }
   }, [findMathElementsForAnnotation, findTextInDOM, verifyRestoredContent]);
 
   const removeHighlight = useCallback((id: string) => {

package/hooks/useDiffFileTreeExpansion.ts

@@ -0,0 +1,92 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+  getAllFolderPaths,
+  getAncestorPaths,
+  type DiffFileTreeFile,
+  type DiffFileTreeNode,
+} from '../utils/diffFileTree';
+
+/** Which folders start open: every folder (the review's behavior), none, or
+ * an explicit list of folder paths (`DiffFileTreeNode.path`). */
+export type DiffFileTreeDefaultExpanded = 'all' | 'none' | readonly string[];
+
+function initialSet(allFolderPaths: string[], defaultExpanded: DiffFileTreeDefaultExpanded): Set<string> {
+  if (defaultExpanded === 'all') return new Set(allFolderPaths);
+  if (defaultExpanded === 'none') return new Set();
+  return new Set(defaultExpanded);
+}
+
+/**
+ * Folder open/closed state for a diff file tree, shared by the review's
+ * FileTree and the embeddable DiffFileTree:
+ * - starts from `defaultExpanded` and resets to it whenever `tree` changes
+ *   identity (a new diff), so pass a memoized tree;
+ * - keeps every ancestor of `activePath` open, so moving the selection always
+ *   reveals the selected file.
+ */
+export function useDiffFileTreeExpansion<F extends DiffFileTreeFile>(
+  tree: DiffFileTreeNode<F>[],
+  activePath: string | null | undefined,
+  defaultExpanded: DiffFileTreeDefaultExpanded = 'all',
+) {
+  const allFolderPaths = useMemo(() => getAllFolderPaths(tree), [tree]);
+  const [expandedFolders, setExpandedFolders] = useState<Set<string>>(() => initialSet(allFolderPaths, defaultExpanded));
+  const [prevTree, setPrevTree] = useState(tree);
+
+  // Reset when the tree changes (initial render + diff switch).
+  if (tree !== prevTree) {
+    setPrevTree(tree);
+    setExpandedFolders(initialSet(allFolderPaths, defaultExpanded));
+  }
+
+  // Auto-expand ancestors of the active file so keyboard nav always reveals the target.
+  useEffect(() => {
+    if (activePath) {
+      const ancestors = getAncestorPaths(activePath);
+      setExpandedFolders((prev) => {
+        const missing = ancestors.filter((p) => !prev.has(p));
+        if (missing.length === 0) return prev;
+        const next = new Set(prev);
+        for (const p of missing) next.add(p);
+        return next;
+      });
+    }
+  }, [activePath, tree]);
+
+  const toggleFolder = useCallback((path: string) => {
+    setExpandedFolders((prev) => {
+      const next = new Set(prev);
+      if (next.has(path)) {
+        next.delete(path);
+      } else {
+        next.add(path);
+      }
+      return next;
+    });
+  }, []);
+
+  const setFolderExpanded = useCallback((path: string, expanded: boolean) => {
+    setExpandedFolders((prev) => {
+      if (prev.has(path) === expanded) return prev;
+      const next = new Set(prev);
+      if (expanded) next.add(path);
+      else next.delete(path);
+      return next;
+    });
+  }, []);
+
+  const areAllFoldersExpanded = allFolderPaths.length > 0 && allFolderPaths.every((path) => expandedFolders.has(path));
+
+  const toggleAllFolders = useCallback(() => {
+    setExpandedFolders(areAllFoldersExpanded ? new Set() : new Set(allFolderPaths));
+  }, [allFolderPaths, areAllFoldersExpanded]);
+
+  return {
+    expandedFolders,
+    allFolderPaths,
+    areAllFoldersExpanded,
+    toggleFolder,
+    setFolderExpanded,
+    toggleAllFolders,
+  };
+}

package/hooks/useExternalAnnotations.ts

@@ -120,10 +120,25 @@ interface UseExternalAnnotationsReturn<T> {
   clearExternalAnnotations: (source?: string) => void;
 }
 
+/** The agent session that opened this review closed it (`session-closed` on the stream). */
+export interface ExternalSessionClosed {
+  unsentAnnotations: number;
+}
+
 export function useExternalAnnotations<T extends { id: string; source?: string }>(
-  options?: { enabled?: boolean },
+  options?: {
+    enabled?: boolean;
+    /**
+     * The stream reported that the agent closed this review
+     * (`POST /api/host/close`). Only the SSE stream carries it; the polling
+     * fallback does not.
+     */
+    onSessionClosed?: (event: ExternalSessionClosed) => void;
+  },
 ): UseExternalAnnotationsReturn<T> {
   const enabled = options?.enabled ?? true;
+  const onSessionClosedRef = useRef(options?.onSessionClosed);
+  onSessionClosedRef.current = options?.onSessionClosed;
   const [annotations, setAnnotations] = useState<T[]>([]);
   const versionRef = useRef(0);
   const fallbackRef = useRef(false);
@@ -175,6 +190,11 @@ export function useExternalAnnotations<T extends { id: string; source?: string }
             prev.map((a) => a.id === parsed.id ? (parsed.annotation as T) : a),
           );
           break;
+        case 'session-closed':
+          onSessionClosedRef.current?.({
+            unsentAnnotations: typeof parsed.unsentAnnotations === 'number' ? parsed.unsentAnnotations : 0,
+          });
+          break;
       }
     }
 

package/hooks/useFirstRunAnnouncementWindow.ts

@@ -0,0 +1,114 @@
+import { useEffect, useState } from 'react';
+
+/** How long after the initial load an announcement may still open. */
+export const FIRST_RUN_ANNOUNCEMENT_WINDOW_MS = 4000;
+
+/**
+ * How long after the initial load a window blur is still taken for the app's
+ * own startup (a viewer focusing its iframe) rather than the reader.
+ */
+export const FIRST_RUN_ANNOUNCEMENT_BLUR_GRACE_MS = 1000;
+
+type Phase = 'waiting' | 'shown' | 'missed';
+
+function isEditable(element: Element | null): boolean {
+  if (!(element instanceof HTMLElement)) return false;
+  if (element.isContentEditable) return true;
+  const tag = element.tagName;
+  if (tag === 'TEXTAREA' || tag === 'SELECT') return true;
+  if (tag !== 'INPUT') return false;
+  const type = (element as HTMLInputElement).type;
+  return !['button', 'checkbox', 'radio', 'submit', 'reset', 'range', 'color', 'file', 'image'].includes(type);
+}
+
+/**
+ * The reader is in something the parent cannot see into: a text field, or an
+ * iframe (the raw-HTML and live-app annotate surfaces), where their typing
+ * never reaches this document's listeners.
+ */
+function isWorkingIn(element: Element | null): boolean {
+  return isEditable(element) || element instanceof HTMLIFrameElement;
+}
+
+interface Options {
+  /** The announcement has not been seen (latched at mount). */
+  readonly pending: boolean;
+  /** Every other condition for opening holds right now. */
+  readonly eligible: boolean;
+  /** The initial payload has loaded; the window's clock starts here. */
+  readonly armed: boolean;
+  readonly windowMs?: number;
+  readonly blurGraceMs?: number;
+}
+
+/**
+ * Lets a non-blocking announcement open only before the reader has started
+ * working: before their first pointer press, key press or focus into an
+ * editable field, and within `windowMs` of the initial load. An announcement
+ * whose conditions arrive later (a slow capabilities answer, say) would take
+ * focus mid-sentence, and the Space or Enter that follows would dismiss it
+ * unread and spend its cookie. Instead it misses this load and waits for the
+ * next one; nothing is written. Once open, it stays until dismissed.
+ */
+export function useFirstRunAnnouncementWindow({
+  pending,
+  eligible,
+  armed,
+  windowMs = FIRST_RUN_ANNOUNCEMENT_WINDOW_MS,
+  blurGraceMs = FIRST_RUN_ANNOUNCEMENT_BLUR_GRACE_MS,
+}: Options): boolean {
+  const [phase, setPhase] = useState<Phase>('waiting');
+
+  // The reader's first move closes the window.
+  useEffect(() => {
+    if (phase !== 'waiting' || !pending) return;
+    const miss = () => setPhase((current) => (current === 'waiting' ? 'missed' : current));
+    const onFocusIn = (event: FocusEvent) => {
+      if (isEditable(event.target as Element | null)) miss();
+    };
+    document.addEventListener('pointerdown', miss, true);
+    document.addEventListener('keydown', miss, true);
+    document.addEventListener('focusin', onFocusIn, true);
+    return () => {
+      document.removeEventListener('pointerdown', miss, true);
+      document.removeEventListener('keydown', miss, true);
+      document.removeEventListener('focusin', onFocusIn, true);
+    };
+  }, [phase, pending]);
+
+  // Work inside an iframe (raw-HTML or live-app annotate) never reaches the
+  // listeners above, but moving into it blurs this window. Counted only after
+  // the app's own startup, which may focus a viewer iframe by itself.
+  useEffect(() => {
+    if (phase !== 'waiting' || !pending || !armed) return;
+    const miss = () => setPhase((current) => (current === 'waiting' ? 'missed' : current));
+    let listening = false;
+    const grace = setTimeout(() => {
+      listening = true;
+      window.addEventListener('blur', miss);
+    }, blurGraceMs);
+    return () => {
+      clearTimeout(grace);
+      if (listening) window.removeEventListener('blur', miss);
+    };
+  }, [phase, pending, armed, blurGraceMs]);
+
+  // So does time, counted from the end of the initial load.
+  useEffect(() => {
+    if (phase !== 'waiting' || !pending || !armed) return;
+    const timer = setTimeout(() => {
+      setPhase((current) => (current === 'waiting' ? 'missed' : current));
+    }, windowMs);
+    return () => clearTimeout(timer);
+  }, [phase, pending, armed, windowMs]);
+
+  // Open while the window is still open. Never over a field or a framed page
+  // the reader is in (a comment composer, a search box, a raw-HTML page), even
+  // an autofocused one.
+  useEffect(() => {
+    if (phase !== 'waiting' || !pending || !eligible) return;
+    setPhase(isWorkingIn(document.activeElement) ? 'missed' : 'shown');
+  }, [phase, pending, eligible]);
+
+  return pending && phase === 'shown';
+}

package/hooks/useLatchedTrue.ts

@@ -0,0 +1,15 @@
+import { useEffect, useState } from 'react';
+
+/**
+ * True from the first render where `value` is true, for the life of the
+ * component. The Apps use it to remember that an announcement was shown on
+ * this load, so the next one in the chain waits for a later load even after
+ * the first is dismissed.
+ */
+export function useLatchedTrue(value: boolean): boolean {
+  const [latched, setLatched] = useState(value);
+  useEffect(() => {
+    if (value) setLatched(true);
+  }, [value]);
+  return latched || value;
+}

package/hooks/useLinkedDoc.ts

@@ -14,6 +14,7 @@ import type { ViewerHandle } from "../components/Viewer";
 import type { SidebarTab } from "./useSidebar";
 import type { SourceSaveCapability } from "@plannotator/core/source-save";
 import type { VersionInfo } from "./usePlanDiff";
+import { annotationOwnsHighlight } from "../utils/annotationOwnsHighlight";
 
 export interface LinkedDocLoadData {
   markdown?: string;
@@ -124,6 +125,29 @@ export interface CachedDocState {
   versionInfo?: VersionInfo | null;
 }
 
+/**
+ * The session's documents split the way FEEDBACK must be: the root document
+ * (the plan, the annotated file, or the folder itself) once, and every other
+ * document once under its own path. `getDocAnnotations()` is NOT this split —
+ * it also carries the active document's live state, which the host exports
+ * from its own state too, so exporting both printed the open document twice.
+ */
+export interface FeedbackDocuments {
+  /**
+   * The root document's stashed state while a linked document is open. Null
+   * while the root itself is the active document: its annotations are then
+   * the host's live state, which the host exports itself.
+   */
+  root: (CachedDocState & { renderAs: DocumentRenderAs }) | null;
+  /**
+   * Every document other than the root that carries state, keyed by path:
+   * the cached documents plus the active linked document's live state. The
+   * root's own annotations are never here; a copy of the root's path opened
+   * from the root itself is a separate annotation set and is listed by path.
+   */
+  documents: Map<string, CachedDocState>;
+}
+
 export interface LinkedDocSessionState {
   root: SavedPlanState;
   docs: Map<string, CachedDocState>;
@@ -156,8 +180,12 @@ export interface UseLinkedDocReturn {
   back: () => void;
   /** Dismiss the current error */
   dismissError: () => void;
-  /** All linked doc annotations including the active doc's live state (keyed by filepath) */
+  /** All linked doc annotations including the active doc's live state (keyed by filepath).
+   *  For counts and the cross-file panel; a feedback export reads getFeedbackDocuments(). */
   getDocAnnotations: () => Map<string, CachedDocState>;
+  /** The root document and every other document, each exactly once — what a
+   *  feedback export reads (see FeedbackDocuments). */
+  getFeedbackDocuments: () => FeedbackDocuments;
   /**
    * Replace the stored annotations of a document that is NOT the active one —
    * a cached linked doc, or the stashed source document. This is what lets the
@@ -285,7 +313,7 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
     if (saved.annotations.length) {
       setTimeout(() => {
         viewerRef.current?.clearAllHighlights();
-        viewerRef.current?.applySharedAnnotations(saved.annotations);
+        viewerRef.current?.applySharedAnnotations(saved.annotations.filter(annotationOwnsHighlight));
       }, HIGHLIGHT_REAPPLY_DELAY);
     }
   }, [
@@ -415,7 +443,7 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
     if (cached?.annotations.length) {
       setTimeout(() => {
         viewerRef.current?.clearAllHighlights();
-        viewerRef.current?.applySharedAnnotations(cached.annotations);
+        viewerRef.current?.applySharedAnnotations(cached.annotations.filter(annotationOwnsHighlight));
       }, HIGHLIGHT_REAPPLY_DELAY);
     }
   }, [
@@ -562,7 +590,7 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
     if (state.root.annotations.length) {
       setTimeout(() => {
         viewerRef.current?.clearAllHighlights();
-        viewerRef.current?.applySharedAnnotations(state.root.annotations);
+        viewerRef.current?.applySharedAnnotations(state.root.annotations.filter(annotationOwnsHighlight));
       }, HIGHLIGHT_REAPPLY_DELAY);
     }
   }, [
@@ -644,6 +672,37 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
     // identity of this callback is what tells memoized readers to recompute.
   }, [linkedDoc, annotations, globalAttachments, sourceFilePath, sourceConverted, getDocumentMarkdown, storeRevision]);
 
+  const getFeedbackDocuments = useCallback((): FeedbackDocuments => {
+    const documents = new Map(docCache.current);
+    if (linkedDoc) {
+      documents.set(linkedDoc.filepath, {
+        annotations: [...annotations],
+        globalAttachments: [...globalAttachments],
+        markdown: getDocumentMarkdown?.(linkedDoc.filepath, linkedDoc.markdown) ?? linkedDoc.markdown,
+        isConverted: linkedDoc.isConverted,
+      });
+    }
+    // A cache entry under the root's own path is NOT the root: it is a copy
+    // the reviewer opened from the root itself (an HTML "Home" link, or
+    // index.html#intro from index.html — a backlink only routes through
+    // back() while a linked doc is open). Its comments are a separate set the
+    // counts include, so it is exported under its path, never dropped.
+    const saved = linkedDoc ? savedPlanState.current : null;
+    return {
+      root: saved
+        ? {
+            annotations: [...saved.annotations],
+            globalAttachments: [...saved.globalAttachments],
+            markdown: saved.markdown,
+            isConverted: !!sourceConverted,
+            renderAs: saved.renderAs,
+          }
+        : null,
+      documents,
+    };
+    // storeRevision: same reason as getDocAnnotations above.
+  }, [linkedDoc, annotations, globalAttachments, sourceConverted, getDocumentMarkdown, storeRevision]);
+
   return {
     isActive: linkedDoc !== null,
     filepath: linkedDoc?.filepath ?? null,
@@ -654,6 +713,7 @@ export function useLinkedDoc(options: UseLinkedDocOptions): UseLinkedDocReturn {
     back,
     dismissError,
     getDocAnnotations,
+    getFeedbackDocuments,
     updateStoredAnnotations,
     snapshotSession,
     restoreSession,

package/hooks/useModelCatalogs.ts

@@ -14,7 +14,10 @@ export { effortSelectOptions, modelSelectOptions } from '@plannotator/core/model
  * Claude / Codex model catalogs for the agent launchers (review, Code Tour,
  * Guided Review) — the SAME lists Ask AI shows. Each is the Ask AI provider's
  * discovered list, fetched through `/api/ai/capabilities?activate=<id>` (which
- * runs the provider's server-cached discovery). Nothing is fetched until a
+ * runs the provider's server-cached discovery). When a session bridge makes
+ * Ask AI bridge-only, the server reports these under `catalogProviders`
+ * instead of `providers`, so the launchers keep them while Ask AI cannot
+ * offer them. Nothing is fetched until a
  * surface asks for one engine with `useModelCatalogs(...).load(engine)`, and
  * only when that engine is installed, so opening a launcher spawns only the
  * selected CLI. While a fetch is in flight the static fallback is shown with
@@ -67,7 +70,11 @@ function loadCatalogEntry(engine: CatalogEngine): Promise<LoadedCatalog> {
     load = fetch(`/api/ai/capabilities?activate=${encodeURIComponent(id)}`)
       .then((res) => (res.ok ? res.json() : null))
       .then((data): LoadedCatalog => {
-        const provider = data?.providers?.find((p: { id?: string; name?: string }) => p.id === id || p.name === id);
+        // A server whose Ask AI is a session bridge lists the SDK providers
+        // only under `catalogProviders` (never under `providers`, which Ask AI
+        // reads), so the launchers look in both.
+        const matches = (p: { id?: string; name?: string }) => p.id === id || p.name === id;
+        const provider = data?.providers?.find(matches) ?? data?.catalogProviders?.find(matches);
         const models = provider?.models;
         if (!Array.isArray(models) || models.length === 0) return failed();
         // The server answers 200 with its static fallback when discovery

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@plannotator/ui",
-  "version": "0.49.0",
+  "version": "0.51.0",
+  "license": "Apache-2.0",
   "type": "module",
   "exports": {
     "./components/*": "./components/*.tsx",
@@ -76,7 +77,7 @@
     "@lezer/highlight": "^1.2.3",
     "@pierre/diffs": "1.3.6",
     "@plannotator/atomic-editor": "^0.9.0",
-    "@plannotator/core": "0.25.9",
+    "@plannotator/core": "0.25.11",
     "@plannotator/markdown-editor": "^0.5.0",
     "@plannotator/web-highlighter": "^0.8.1",
     "@tanstack/react-table": "^8.21.3",