cli-jaw 2.2.11 → 2.2.13

package/public/manager/src/code/CodeTranscript.tsx

@@ -1,15 +1,33 @@
-import { lazy, Suspense, useCallback, type KeyboardEvent, type RefObject } from 'react';
+import { lazy, Suspense, useCallback, useRef, type KeyboardEvent, type RefObject } from 'react';
 import type { ToolContent, TranscriptEntry } from './code-types';
 import { useCodeTranscriptVirtualRows } from './useCodeTranscriptVirtualRows';
+import { useThrottledMarkdown } from './use-throttled-markdown';
 
 const MarkdownRenderer = lazy(() => import('../notes/rendering/MarkdownRenderer').then(m => ({ default: m.MarkdownRenderer })));
 
+/**
+ * D1: assistant markdown is re-parsed in full on every update, so a per-token
+ * render is O(L²) in message length. Throttle the text adaptively (80ms under
+ * 2k chars up to 400ms past ~50k) before it reaches the markdown pipeline.
+ * Trailing-edge, so the final text always lands without a turn-done signal.
+ */
+function AssistantMarkdown({ text, onOpenLocalFile }: { text: string; onOpenLocalFile?: ((path: string) => void) | undefined }) {
+    const throttled = useThrottledMarkdown(text);
+    return (
+        <Suspense fallback={<span>{throttled}</span>}>
+            <MarkdownRenderer markdown={throttled} tableMode="linear" onLocalFileOpen={onOpenLocalFile} />
+        </Suspense>
+    );
+}
+
 type CodeTranscriptProps = {
     messages: TranscriptEntry[];
     sending: boolean;
     workingDir: string;
     transcriptRef: RefObject<HTMLDivElement | null>;
     onOpenLocalFile?: ((path: string) => void) | undefined;
+    /** Switching sessions must discard index-keyed row measurements (050 D2). */
+    sessionId?: string | null | undefined;
 };
 
 function renderToolContent(content: ToolContent, index: number) {
@@ -165,9 +183,7 @@ function renderCodeMessage(msg: TranscriptEntry, i: number, onOpenLocalFile?: ((
                     <span className="code-message-role">{msg.role === 'user' ? 'You' : 'JWC'}</span>
                     <div className="code-message-text">
                         {msg.role === 'assistant' ? (
-                            <Suspense fallback={<span>{msg.text}</span>}>
-                                <MarkdownRenderer markdown={msg.text} tableMode="linear" onLocalFileOpen={onOpenLocalFile} />
-                            </Suspense>
+                            <AssistantMarkdown text={msg.text} onOpenLocalFile={onOpenLocalFile} />
                         ) : msg.text}
                     </div>
                 </>
@@ -185,18 +201,26 @@ function renderSendingMessage() {
     );
 }
 
-export function CodeTranscript({ messages, sending, workingDir, transcriptRef, onOpenLocalFile }: CodeTranscriptProps) {
+export function CodeTranscript({ messages, sending, workingDir, transcriptRef, onOpenLocalFile, sessionId }: CodeTranscriptProps) {
     const showSending = sending && messages[messages.length - 1]?.role !== 'assistant';
     const rowCount = messages.length + (showSending ? 1 : 0);
+    // D3: these two callbacks used to depend on `messages`. Every streaming
+    // token makes a new array identity, so both were re-created, which
+    // invalidated the virtualizer's layout effect and forced a full
+    // setOptions + _willUpdate + setSnapshot — a second render pass per token.
+    // Read through a ref instead so only `count` actually changes.
+    const messagesRef = useRef(messages);
+    messagesRef.current = messages;
     const getItemKey = useCallback((index: number): string | number => {
-        const msg = messages[index];
+        const msg = messagesRef.current[index];
         return msg ? transcriptMessageKey(msg, index) : `sending-${index}`;
-    }, [messages]);
+    }, []);
     const estimateSize = useCallback((index: number): number => (
-        estimateTranscriptRowSize(messages[index])
-    ), [messages]);
+        estimateTranscriptRowSize(messagesRef.current[index])
+    ), []);
     const virtual = useCodeTranscriptVirtualRows({
         count: rowCount,
+        resetKey: sessionId ?? null,
         scrollElementRef: transcriptRef,
         getItemKey,
         estimateSize,

package/public/manager/src/code/CodeWorkbench.tsx

@@ -95,7 +95,7 @@ export function CodeWorkbench(props: CodeWorkbenchProps) {
                     {props.transportState === 'reconnecting' ? 'Live updates reconnecting…' : 'Live updates disconnected — retrying.'}
                 </section>
             )}
-            <CodeTranscript messages={props.messages} sending={props.sending} workingDir={props.codeWorkingDir} transcriptRef={props.transcriptRef} onOpenLocalFile={props.onOpenLocalFile} />
+            <CodeTranscript messages={props.messages} sending={props.sending} workingDir={props.codeWorkingDir} transcriptRef={props.transcriptRef} onOpenLocalFile={props.onOpenLocalFile} sessionId={props.activeSessionId} />
             <CodePermissionQueue permissions={props.permissions} onAnswer={props.onPermissionAnswer} />
             <div className="code-composer-dock">
                 <div className="code-composer-surface" aria-label="Code composer controls">

package/public/manager/src/code/code-event-dedupe.ts

@@ -1,5 +1,25 @@
 import type { CodeSessionReplayEvent } from './code-session-client';
 import type { CodeEvent } from './useCodeEvents';
+import { fnv1a32 } from '../lib/fnv1a';
+import { addBounded } from '../lib/bounded-set';
+
+/**
+ * D3 (260803 unit, 050 phase): the dedupe key used to embed the FULL chunk
+ * text, so the set retained roughly a second copy of the whole transcript and
+ * grew for the session's lifetime.
+ *
+ * Collision domain, stated precisely: `stableId` is a message id or SSE event
+ * id, and a message id is minted once per TURN — every delta of one assistant
+ * turn shares it. So within a turn the text really was the discriminator, and
+ * hashing it does concentrate risk there. What bounds it is that the key also
+ * carries the text length, so only same-length chunks of the same turn can
+ * collide: roughly 10^3 same-length items against 2^32, i.e. ~10^-4.
+ *
+ * The consequence of a collision is a hard drop — `shouldDropDuplicateCodeChunk`
+ * returns before the append — so it is worth keeping that number honest rather
+ * than calling stableId "unique".
+ */
+const MAX_SEEN_KEYS = 2000;
 
 type ChunkLikeEvent = Pick<CodeEvent, 'event' | 'sessionId' | 'update' | 'sseEventId'>;
 export type AssistantChunkMergeAction = 'append' | 'drop' | 'replace';
@@ -29,14 +49,18 @@ export function codeChunkEventKey(event: ChunkLikeEvent, text: string): string |
         : '';
     const stableId = messageId ? `msg:${messageId}` : sseEventId ? `sse:${sseEventId}` : '';
     if (!stableId) return null;
-    return `${event.sessionId ?? ''}:${event.event}:${stableId}:${text}`;
+    return `${event.sessionId ?? ''}:${event.event}:${stableId}:${text.length}:${fnv1a32(text)}`;
 }
 
 export function rememberCodeChunkEvents(seen: Set<string>, events: CodeSessionReplayEvent[]): void {
     for (const event of events) {
         const text = textFromCodeChunk(event.update);
         const key = codeChunkEventKey(event, text);
-        if (key) seen.add(key);
+        // Seeding from a session replay must NOT evict its own earlier entries:
+        // a replay longer than the bound would drop keys for content already on
+        // screen, and the next matching live chunk would be appended again as
+        // "new". Size the bound to the replay, then let the live path trim.
+        if (key) addBounded(seen, key, Math.max(MAX_SEEN_KEYS, events.length));
     }
 }
 
@@ -44,7 +68,7 @@ export function shouldDropDuplicateCodeChunk(seen: Set<string>, event: ChunkLike
     const key = codeChunkEventKey(event, text);
     if (!key) return false;
     if (seen.has(key)) return true;
-    seen.add(key);
+    addBounded(seen, key, MAX_SEEN_KEYS);
     return false;
 }
 

package/public/manager/src/code/use-code-transcript-scroll.ts

@@ -12,16 +12,41 @@ export function useCodeTranscriptScroll(messages: TranscriptEntry[], sending: bo
     const latestTranscriptFootprint = useMemo(() => {
         const last = messages[messages.length - 1];
         if (!last) return 'empty';
-        const toolContentSize = last.toolContent?.reduce((total, content) => total + JSON.stringify(content).length, 0) ?? 0;
+        // D5: this used to JSON.stringify the whole toolContent on every
+        // `messages` identity change — i.e. every streaming token — which
+        // serializes hundreds of KB just to build a change-detection string.
+        // Length fields discriminate the same transitions at O(items) cost.
+        const toolContentSize = last.toolContent?.reduce((total, content) => {
+            const c = content as { text?: string; diff?: string; output?: string };
+            return total + (c.text?.length ?? 0) + (c.diff?.length ?? 0) + (c.output?.length ?? 0);
+        }, 0) ?? 0;
         return `${messages.length}:${last.role}:${last.text.length}:${last.toolOutput?.length ?? 0}:${toolContentSize}:${last.toolStatus ?? ''}`;
     }, [messages]);
 
+    // D4: coalesce every scroll request onto a single in-flight frame. The old
+    // shape queued a rAF *plus* a nested 80ms timeout per call, and callers fire
+    // per SSE event, so ~40 tok/s produced ~120 layout-forcing callbacks per
+    // second with two smooth-scroll animations fighting each other.
+    const pendingFrameRef = useRef<number | null>(null);
+    const settleTimerRef = useRef<number | null>(null);
+
+    useEffect(() => () => {
+        if (pendingFrameRef.current !== null) cancelAnimationFrame(pendingFrameRef.current);
+        if (settleTimerRef.current !== null) window.clearTimeout(settleTimerRef.current);
+    }, []);
+
     const scrollTranscriptToBottom = useCallback((behavior: ScrollBehavior = 'smooth') => {
-        window.requestAnimationFrame(() => {
+        if (pendingFrameRef.current !== null) return;
+        pendingFrameRef.current = window.requestAnimationFrame(() => {
+            pendingFrameRef.current = null;
             const node = transcriptRef.current;
             if (!node) return;
             node.scrollTo({ top: node.scrollHeight, behavior });
-            window.setTimeout(() => {
+            // One trailing correction, not one per call: content that lands
+            // after this frame still needs a final snap.
+            if (settleTimerRef.current !== null) window.clearTimeout(settleTimerRef.current);
+            settleTimerRef.current = window.setTimeout(() => {
+                settleTimerRef.current = null;
                 const latest = transcriptRef.current;
                 if (!latest) return;
                 latest.scrollTo({ top: latest.scrollHeight, behavior: 'auto' });

package/public/manager/src/code/use-throttled-markdown.ts

@@ -0,0 +1,75 @@
+import { useEffect, useRef, useState } from 'react';
+
+/**
+ * D1 (260803 unit, 020 phase) — adaptive streaming throttle.
+ *
+ * Rendering assistant markdown re-parses the FULL accumulated text on every
+ * update (remark → rehype → sanitize → KaTeX), so per-render cost grows with
+ * message length and a naive per-token render is O(L²) overall.
+ *
+ * The legacy UI reached this conclusion first; these constants are lifted
+ * verbatim from public/js/streaming-render.ts:18-30 rather than re-derived,
+ * so both renderers behave the same under load.
+ */
+const FULL_RENDER_THRESHOLD = 2000;
+const THROTTLE_MS = 80;
+const THROTTLE_MAX_MS = 400;
+
+export function throttleMsFor(textLength: number): number {
+    if (textLength <= FULL_RENDER_THRESHOLD) return THROTTLE_MS;
+    const scaled = THROTTLE_MS * (textLength / FULL_RENDER_THRESHOLD);
+    return Math.min(THROTTLE_MAX_MS, Math.round(scaled));
+}
+
+/**
+ * Returns `text` throttled by the adaptive interval above. Growth is rate
+ * limited; a shrink or replacement (new message, session switch) applies
+ * immediately so the view never shows stale content from another turn.
+ *
+ * Always trailing-edge: the final value lands even if the last change arrives
+ * inside a throttle window, so no explicit "turn done" signal is needed.
+ */
+export function useThrottledMarkdown(text: string): string {
+    const [visible, setVisible] = useState(text);
+    const lastEmitRef = useRef(0);
+    const timerRef = useRef<number | null>(null);
+
+    useEffect(() => {
+        // Only a pure append is streaming growth. A prefix-only check would
+        // treat an in-place edit past the compared window as growth and hold
+        // stale text for up to one interval; comparing the full visible string
+        // is exact, and only runs on the fast path.
+        const isAppend = text.length >= visible.length && text.startsWith(visible);
+        if (!isAppend) {
+            if (timerRef.current !== null) {
+                window.clearTimeout(timerRef.current);
+                timerRef.current = null;
+            }
+            lastEmitRef.current = Date.now();
+            setVisible(text);
+            return;
+        }
+        if (text === visible) return;
+
+        const wait = throttleMsFor(text.length);
+        const since = Date.now() - lastEmitRef.current;
+        if (since >= wait) {
+            lastEmitRef.current = Date.now();
+            setVisible(text);
+            return;
+        }
+
+        if (timerRef.current !== null) window.clearTimeout(timerRef.current);
+        timerRef.current = window.setTimeout(() => {
+            timerRef.current = null;
+            lastEmitRef.current = Date.now();
+            setVisible(text);
+        }, wait - since);
+    }, [text, visible]);
+
+    useEffect(() => () => {
+        if (timerRef.current !== null) window.clearTimeout(timerRef.current);
+    }, []);
+
+    return visible;
+}

package/public/manager/src/code/useCodeTranscriptVirtualRows.ts

@@ -24,6 +24,12 @@ export type CodeTranscriptVirtualRows = {
 
 export function useCodeTranscriptVirtualRows(args: {
     count: number;
+    /**
+     * Changing this discards measurements. Normally the session id: row heights
+     * are keyed by index, so carrying them into a different transcript retains
+     * memory AND mis-measures the new rows.
+     */
+    resetKey?: string | null;
     scrollElementRef: RefObject<HTMLDivElement | null>;
     getItemKey: (index: number) => string | number;
     estimateSize?: (index: number) => number;
@@ -57,6 +63,19 @@ export function useCodeTranscriptVirtualRows(args: {
 
     useEffect(() => virtualizer._didMount(), [virtualizer]);
 
+    // D2 (260803 unit, 050 phase): the instance lives in a ref that was never
+    // cleared, so measured row sizes survived session switches.
+    //
+    // Use the public `measure()` rather than emptying `measurementsCache`.
+    // The durable store is `itemSizeCache` (private, cleared only by
+    // `measure()`); `measurementsCache` is reassigned to a fresh lazy view on
+    // every recompute, so clearing it releases nothing.
+    useEffect(() => {
+        virtualizer.measure();
+    }, [virtualizer, args.resetKey]);
+
+    useEffect(() => () => { virtualizerRef.current = null; }, []);
+
     useLayoutEffect(() => {
         virtualizer.setOptions({
             ...virtualizer.options,

package/public/manager/src/electron-metrics.tsx

@@ -77,6 +77,13 @@ export function ElectronMetricsPanel(props: ElectronMetricsPanelProps = {}) {
         let timer: ReturnType<typeof setTimeout> | null = null;
 
         const tick = async () => {
+            // D4: skip the work while the window is hidden, but keep the timer
+            // chain alive so it resumes instantly on return. A poller that
+            // exists to REPORT memory pressure should not be creating idle cost.
+            if (typeof document !== 'undefined' && document.hidden) {
+                if (!cancelled) timer = setTimeout(tick, POLL_INTERVAL_MS);
+                return;
+            }
             try {
                 const result = await fetchElectronMetrics();
                 if (cancelled) return;

package/public/manager/src/jaw-ceo/useJawCeo.ts

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
+import { addBounded } from '../lib/bounded-set';
 import type { ManagerEvent } from '../types';
 import {
     continueJawCeoCompletion,
@@ -90,6 +91,9 @@ function toJawCeoEvent(event: ManagerEvent): JawCeoManagerEvent | null {
     };
 }
 
+/** Bound for the CEO console's event dedupe set (050 D3). */
+const MAX_SEEN_EVENT_KEYS = 2000;
+
 export type UseJawCeoArgs = {
     selectedPort: number | null;
     documentVisible: boolean;
@@ -162,7 +166,8 @@ export function useJawCeo(args: UseJawCeoArgs): JawCeoController {
             if (!event) continue;
             const key = eventKey(event);
             if (seenEventKeysRef.current.has(key)) continue;
-            seenEventKeysRef.current.add(key);
+            // Same unbounded-growth pattern as the code transcript (050 D3).
+            addBounded(seenEventKeysRef.current, key, MAX_SEEN_EVENT_KEYS);
             freshEvents.push(event);
         }
         if (freshEvents.length === 0) return;

package/public/manager/src/jaw-ceo/useJawCeoVirtualTimeline.ts

@@ -81,6 +81,11 @@ export function useJawCeoVirtualTimeline(args: {
 
     useEffect(() => virtualizer._didMount(), [virtualizer]);
 
+    // D2 sibling (050 phase): release the instance on unmount. The CEO console
+    // has no per-session key to reset against — it renders one continuous
+    // timeline — so only the retention half applies here.
+    useEffect(() => () => { virtualizerRef.current = null; }, []);
+
     useLayoutEffect(() => {
         virtualizer.setOptions({
             ...virtualizer.options,

package/public/manager/src/lib/bounded-set.ts

@@ -0,0 +1,15 @@
+/**
+ * Insertion-ordered Set with a FIFO bound. `Set` already preserves insertion
+ * order, so the oldest entry is simply the first key — no side queue needed.
+ *
+ * Used for streaming dedupe sets, which otherwise grow for the lifetime of a
+ * session (260803 unit, 050 phase D3).
+ */
+export function addBounded(set: Set<string>, key: string, max: number): void {
+    set.add(key);
+    while (set.size > max) {
+        const oldest = set.values().next();
+        if (oldest.done) return;
+        set.delete(oldest.value);
+    }
+}

package/public/manager/src/lib/fnv1a.ts

@@ -0,0 +1,14 @@
+/**
+ * FNV-1a 32-bit. Cheap, dependency-free, and good enough for cache/dedupe keys
+ * where the alternative is embedding a full copy of the hashed text.
+ * t3code uses the same function for its highlight cache keys
+ * (apps/web/src/components/ChatMarkdown.tsx:307).
+ */
+export function fnv1a32(input: string): string {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i += 1) {
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(36);
+}

package/public/manager/src/notes/rendering/CodeBlock.tsx

@@ -1,15 +1,22 @@
-import { useState } from 'react';
+import { memo, useMemo, useState } from 'react';
 import { copyText } from '../../clipboard/copy-text';
-import { highlightCode } from './highlight-languages';
+import { highlightCodeCached } from './highlight-cache';
 
 type CodeBlockProps = {
     code: string;
     language?: string;
 };
 
-export function CodeBlock(props: CodeBlockProps) {
+function CodeBlockImpl(props: CodeBlockProps) {
     const [copied, setCopied] = useState(false);
-    const result = highlightCode(props.code, props.language);
+    // D2: highlighting used to run synchronously in the render body on every
+    // parent render — i.e. on every streaming token — and again on each
+    // virtualized remount. useMemo covers re-renders, the module cache covers
+    // remounts, and the cache applies the oversize cutoff.
+    const result = useMemo(
+        () => highlightCodeCached(props.code, props.language),
+        [props.code, props.language],
+    );
     const label = result.language || 'text';
 
     async function copyCode(): Promise<void> {
@@ -39,3 +46,5 @@ export function CodeBlock(props: CodeBlockProps) {
         </div>
     );
 }
+
+export const CodeBlock = memo(CodeBlockImpl);

package/public/manager/src/notes/rendering/MarkdownRenderer.tsx

@@ -1,4 +1,4 @@
-import { Children, createElement, isValidElement, useMemo } from 'react';
+import { Children, createElement, isValidElement, memo, useMemo } from 'react';
 import type { MouseEvent } from 'react';
 import type { ComponentProps, CSSProperties, ReactNode } from 'react';
 import ReactMarkdown from 'react-markdown';
@@ -188,7 +188,7 @@ function splitChildrenWithLocalFileLinks(
     return out;
 }
 
-export function MarkdownRenderer(props: MarkdownRendererProps) {
+function MarkdownRendererImpl(props: MarkdownRendererProps) {
     const renderedMarkdown = useMemo(
         () => splitPreviewFrontmatter(props.markdown).body,
         [props.markdown],
@@ -201,6 +201,11 @@ export function MarkdownRenderer(props: MarkdownRendererProps) {
         onNavigate: props.onWikiLinkNavigate ?? NOOP_NAVIGATE,
     }), [props.outgoing, props.notes, props.onWikiLinkNavigate]);
 
+    // D1: this whole block used to run in the render body, minting ~20 fresh
+    // component identities per render. React keys reconciliation off element
+    // type identity, so new types mean unmount + remount of the entire rendered
+    // subtree — on every streaming token, for the full accumulated text.
+    const components = useMemo<Components>(() => {
     const inlineTransform = (children: ReactNode, keyPrefix: string): ReactNode => {
         const withWikiLinks = splitChildrenWithWikiLinks(children, wikiCtx, keyPrefix);
         return splitChildrenWithLocalFileLinks(withWikiLinks, props.onLocalFileOpen, keyPrefix);
@@ -304,6 +309,8 @@ export function MarkdownRenderer(props: MarkdownRendererProps) {
         components.th = linearCellTransform('th');
         components.td = linearCellTransform('td');
     }
+        return components;
+    }, [wikiCtx, props.onLocalFileOpen, props.tableMode]);
 
     return (
         <ReactMarkdown
@@ -320,3 +327,8 @@ export function MarkdownRenderer(props: MarkdownRendererProps) {
         </ReactMarkdown>
     );
 }
+
+// D1: memo so an unchanged past message is not re-rendered when a sibling
+// updates. Default shallow compare is correct here — every prop is either a
+// primitive or a reference the caller already keeps stable.
+export const MarkdownRenderer = memo(MarkdownRendererImpl);

package/public/manager/src/notes/rendering/highlight-cache.ts

@@ -0,0 +1,111 @@
+import { highlightCode, normalizeCodeLanguage, type HighlightResult } from './highlight-languages';
+
+/**
+ * D2 (260803 unit, 020 phase): `highlightCode` is pure but was called straight
+ * from a render body, so a large block was re-tokenized on every parent render
+ * and again every time a virtualized row scrolled back into view.
+ *
+ * Bounds are deliberately smaller than t3code's 500 entries / 50MB
+ * (apps/web/src/components/ChatMarkdown.tsx:110): highlighting is one panel
+ * among many here and this phase exists to reduce RAM, not trade it.
+ */
+const MAX_ENTRIES = 200;
+const MAX_BYTES = 8 * 1024 * 1024;
+
+/**
+ * Skip highlighting entirely past this size. hljs cost is superlinear in
+ * pathological input, and a minified bundle pasted into a message should not
+ * stall the main thread. t3code caps per line (tokenizeMaxLineLength: 1_000);
+ * hljs has no such knob, so we cap the whole block instead.
+ */
+const MAX_HIGHLIGHT_CHARS = 100_000;
+
+/**
+ * Reject pathological single lines before hljs ever sees them. A minified
+ * bundle pasted into a message is one enormous line, and tokenizer cost is
+ * superlinear there. t3code enforces the same idea with
+ * `tokenizeMaxLineLength: 1_000` (apps/web/src/components/DiffWorkerPoolProvider.tsx:75);
+ * hljs exposes no equivalent option, so we pre-check instead.
+ */
+const MAX_HIGHLIGHT_LINE_CHARS = 1_000;
+
+type Entry = { result: HighlightResult; bytes: number };
+
+// Map preserves insertion order, which gives LRU for free: delete + re-set on
+// hit moves an entry to the newest position.
+const cache = new Map<string, Entry>();
+let cachedBytes = 0;
+
+function estimateBytes(key: string, result: HighlightResult): number {
+    // The key embeds a full copy of the source, so counting only the html
+    // would undercount retention by roughly half.
+    return (key.length + result.html.length) * 2;
+}
+
+function evictUntilWithinBounds(): void {
+    while ((cache.size > MAX_ENTRIES || cachedBytes > MAX_BYTES) && cache.size > 0) {
+        const oldest = cache.keys().next();
+        if (oldest.done) break;
+        const entry = cache.get(oldest.value);
+        cache.delete(oldest.value);
+        if (entry) cachedBytes -= entry.bytes;
+    }
+}
+
+function escapeHtml(code: string): string {
+    return code.replace(/[&<>"']/g, value => ({
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#39;',
+    })[value] ?? value);
+}
+
+function hasOverlongLine(code: string): boolean {
+    let lineStart = 0;
+    for (let i = 0; i < code.length; i += 1) {
+        if (code.charCodeAt(i) !== 10) continue;
+        if (i - lineStart > MAX_HIGHLIGHT_LINE_CHARS) return true;
+        lineStart = i + 1;
+    }
+    return code.length - lineStart > MAX_HIGHLIGHT_LINE_CHARS;
+}
+
+export function highlightCodeCached(code: string, language?: string): HighlightResult {
+    // Normalize first: `TypeScript`, `typescript`, and `language-typescript`
+    // all resolve to one result, so they must share one cache entry.
+    const normalized = normalizeCodeLanguage(language);
+
+    if (code.length > MAX_HIGHLIGHT_CHARS || hasOverlongLine(code)) {
+        return { html: escapeHtml(code), language: normalized, highlighted: false };
+    }
+
+    const key = `${normalized}\u0000${code}`;
+    const hit = cache.get(key);
+    if (hit) {
+        cache.delete(key);
+        cache.set(key, hit);
+        return hit.result;
+    }
+
+    const result = highlightCode(code, language);
+    const bytes = estimateBytes(key, result);
+    // A single oversized entry would evict everything else for no benefit.
+    if (bytes <= MAX_BYTES) {
+        cache.set(key, { result, bytes });
+        cachedBytes += bytes;
+        evictUntilWithinBounds();
+    }
+    return result;
+}
+
+/** Test seam. */
+export function __resetHighlightCache(): void {
+    cache.clear();
+    cachedBytes = 0;
+}
+
+export function __highlightCacheStats(): { entries: number; bytes: number } {
+    return { entries: cache.size, bytes: cachedBytes };
+}

package/public/manager/src/notes/useNotesExternalSync.ts

@@ -31,7 +31,12 @@ export function useNotesExternalSync(active: boolean): void {
         }
 
         void poll();
-        const timer = setInterval(() => void poll(), POLL_INTERVAL_MS);
+        // D4: a hidden window cannot show an external change, so polling for
+        // one is pure idle cost. Matches useRemindersFeed's guard.
+        const timer = setInterval(() => {
+            if (typeof document !== 'undefined' && document.hidden) return;
+            void poll();
+        }, POLL_INTERVAL_MS);
         return () => { cancelled = true; clearInterval(timer); };
     }, [active]);
 }

package/public/manager/src/settings/pages/Agent.tsx

@@ -17,6 +17,8 @@ import {
     optionList,
     runtimeEffortFor,
     runtimeModelFor,
+    coerceEffortForModel,
+    effortChoicesForModel,
     type ActiveOverride,
     type CliMeta,
     type PerCliEntry,
@@ -193,8 +195,8 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
         ? optionList(activeMeta.modelsByProvider?.[activeProvider] || activeMeta.models, draft.model)
         : optionList(activeMeta.models, draft.model);
     const activeEffortOptions = hasProviders
-        ? (activeMeta.effortsByProvider?.[activeProvider] || activeMeta.efforts)
-        : activeMeta.efforts;
+        ? effortChoicesForModel(activeMeta, draft.model, activeMeta.effortsByProvider?.[activeProvider] || activeMeta.efforts, activeProvider)
+        : effortChoicesForModel(activeMeta, draft.model);
     const workingDirError = draft.workingDir.trim() ? null : 'Required';
 
     if (state.kind === 'loading') return <PageLoading />;
@@ -248,7 +250,9 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
                     const models = activeMeta.modelsByProvider?.[next] || [];
                     const efforts = activeMeta.effortsByProvider?.[next] || [];
                     const nextModel = models.includes(draft.model) ? draft.model : (models[0] || '');
-                    const nextEffort = efforts.includes(draft.effort) ? draft.effort : '';
+                    // Resolve against the NEW provider+model pair: the same model
+                    // id can allow different efforts per provider.
+                    const nextEffort = coerceEffortForModel(activeMeta, nextModel, draft.effort, efforts, next);
                     setRuntimeDraft({ ...draft, provider: next, model: nextModel, effort: nextEffort });
                     setEntry(`perCli.${draft.cli}.provider`, {
                         value: next,
@@ -267,12 +271,29 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
                     });
                 }}
                 onModelChange={(next) => {
-                    setRuntimeDraft({ ...draft, model: next });
+                    // Efforts are per-model on a live opencodex catalog, so a
+                    // model switch can strand an effort the new model does not
+                    // support — and that value would reach the wire verbatim.
+                    const nextEffort = coerceEffortForModel(
+                        activeMeta,
+                        next,
+                        draft.effort,
+                        hasProviders ? (activeMeta.effortsByProvider?.[activeProvider] || activeMeta.efforts) : undefined,
+                        hasProviders ? activeProvider : undefined,
+                    );
+                    setRuntimeDraft({ ...draft, model: next, effort: nextEffort });
                     setEntry(`activeOverrides.${draft.cli}.model`, {
                         value: next,
                         original: runtimeModelFor(draft.cli, perCli, activeOverrides),
                         valid: next.trim().length > 0,
                     });
+                    if (nextEffort !== draft.effort) {
+                        setEntry(`activeOverrides.${draft.cli}.effort`, {
+                            value: nextEffort,
+                            original: runtimeEffortFor(draft.cli, perCli, activeOverrides),
+                            valid: true,
+                        });
+                    }
                 }}
                 onEffortChange={(next) => {
                     setRuntimeDraft({ ...draft, effort: next });