mixdog 0.9.86 → 0.9.88

package/src/tui/app/use-pasted-buffers.mjs

@@ -0,0 +1,115 @@
+// Pasted-attachment buffers, extracted from App.jsx. Large pasted images and
+// texts fold into [Image #N] / [Pasted text #N +M lines] prompt tokens; the
+// original payloads live here (ref + mirrored state) until submit expands
+// them back. install* rehydrates a queued/restored draft's buffers, the
+// snapshot clears drop exactly the entries a submit consumed, and register*
+// mints the next token for a fresh paste.
+import { useCallback, useRef, useState } from 'react';
+import { formatImageRef, formatPastedTextRef } from '../paste-attachments.mjs';
+
+export function usePastedBuffers() {
+  const [, setPastedImages] = useState({});
+  const pastedImagesRef = useRef({});
+  const nextPastedImageIdRef = useRef(1);
+  const [, setPastedTexts] = useState({});
+  const pastedTextsRef = useRef({});
+  const nextPastedTextIdRef = useRef(1);
+
+  const installPastedImages = useCallback((images, { merge = true } = {}) => {
+    if (!images || typeof images !== 'object' || Object.keys(images).length === 0) return;
+    const next = merge ? { ...pastedImagesRef.current, ...images } : { ...images };
+    pastedImagesRef.current = next;
+    const maxId = Object.keys(next)
+      .map((id) => Number(id) || 0)
+      .reduce((max, id) => Math.max(max, id), 0);
+    if (maxId >= nextPastedImageIdRef.current) nextPastedImageIdRef.current = maxId + 1;
+    setPastedImages(next);
+  }, []);
+
+  const clearPastedImagesSnapshot = useCallback((snapshot = null) => {
+    if (!snapshot) {
+      if (Object.keys(pastedImagesRef.current || {}).length === 0) return;
+      pastedImagesRef.current = {};
+      setPastedImages({});
+      return;
+    }
+    if (typeof snapshot !== 'object' || Object.keys(snapshot).length === 0) return;
+    const next = { ...pastedImagesRef.current };
+    let changed = false;
+    for (const [id, image] of Object.entries(snapshot)) {
+      if (next[id] === image) {
+        delete next[id];
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    pastedImagesRef.current = next;
+    setPastedImages(next);
+  }, []);
+
+  const registerPastedImage = useCallback((image) => {
+    if (!image || image.type !== 'image' || !image.content) return '';
+    const id = nextPastedImageIdRef.current++;
+    const entry = { ...image, id };
+    pastedImagesRef.current = { ...pastedImagesRef.current, [id]: entry };
+    setPastedImages(pastedImagesRef.current);
+    return formatImageRef(id);
+  }, []);
+
+  const installPastedTexts = useCallback((texts, { merge = true } = {}) => {
+    if (!texts || typeof texts !== 'object' || Object.keys(texts).length === 0) return;
+    const next = merge ? { ...pastedTextsRef.current, ...texts } : { ...texts };
+    pastedTextsRef.current = next;
+    const maxId = Object.keys(next)
+      .map((id) => Number(id) || 0)
+      .reduce((max, id) => Math.max(max, id), 0);
+    if (maxId >= nextPastedTextIdRef.current) nextPastedTextIdRef.current = maxId + 1;
+    setPastedTexts(next);
+  }, []);
+
+  const clearPastedTextsSnapshot = useCallback((snapshot = null) => {
+    if (!snapshot) {
+      if (Object.keys(pastedTextsRef.current || {}).length === 0) return;
+      pastedTextsRef.current = {};
+      setPastedTexts({});
+      return;
+    }
+    if (typeof snapshot !== 'object' || Object.keys(snapshot).length === 0) return;
+    const next = { ...pastedTextsRef.current };
+    let changed = false;
+    for (const [id, text] of Object.entries(snapshot)) {
+      if (next[id] === text) {
+        delete next[id];
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    pastedTextsRef.current = next;
+    setPastedTexts(next);
+  }, []);
+
+  const registerPastedText = useCallback((text) => {
+    const value = String(text ?? '');
+    if (!value) return '';
+    const id = nextPastedTextIdRef.current++;
+    const entry = { id, text: value };
+    pastedTextsRef.current = { ...pastedTextsRef.current, [id]: entry };
+    setPastedTexts(pastedTextsRef.current);
+    return formatPastedTextRef(id, value);
+  }, []);
+
+  return {
+    pastedImagesRef,
+    nextPastedImageIdRef,
+    pastedTextsRef,
+    nextPastedTextIdRef,
+    setPastedImages,
+    setPastedTexts,
+    installPastedImages,
+    clearPastedImagesSnapshot,
+    registerPastedImage,
+    installPastedTexts,
+    clearPastedTextsSnapshot,
+    registerPastedText,
+  };
+}

package/src/tui/app/use-prompt-draft-flow.mjs

@@ -0,0 +1,167 @@
+// Prompt draft + slash palette flow, extracted from App.jsx: keystroke-time
+// draft sync (slash-token lift, history-nav reset, argument hints), the four
+// text-entry prompt cancel paths, and accept/complete/cancel for the slash
+// palette.
+import { useCallback } from 'react';
+import { slashQuery, slashArgumentHint, slashCommandTokenForPaletteAccept } from './slash-commands.mjs';
+
+export function usePromptDraftFlow({
+  dismissWelcomePromptHint,
+  syncPromptLayoutRows,
+  promptHistoryDraftChangeRef,
+  promptHistoryNavRef,
+  resetPromptHistoryNav,
+  setPromptDraft,
+  setPromptDraftOverride,
+  showPromptHint,
+  clearPromptHint,
+  promptHintActiveRef,
+  promptHintTimerRef,
+  slashDismissedFor,
+  setSlashDismissedFor,
+  providerPrompt,
+  channelPrompt,
+  hookPrompt,
+  settingsPrompt,
+  setProviderPrompt,
+  setChannelPrompt,
+  setHookPrompt,
+  setSettingsPrompt,
+  oauthSubmitRef,
+  openProjectPicker,
+  openMemoryCorePicker,
+  openAutoClearPicker,
+  slashCommands,
+  slashIndex,
+  pickerOpenedFromEnterRef,
+  pickerOpenedFromEnterTimerRef,
+  runSlashCommand,
+}) {
+  const onPromptDraftChange = useCallback((value) => {
+    if (String(value ?? '').length > 0) dismissWelcomePromptHint();
+    syncPromptLayoutRows(value);
+    // NOTE: do NOT prune pasted-text entries on edit. A partially-edited token
+    // can be undone back to its intact form, which must still expand on submit;
+    // entries are kept until an accepted submit or an explicit clear. (Memory
+    // cost is bounded and acceptable.)
+    const suppressPromptHint = promptHistoryDraftChangeRef.current;
+    promptHistoryDraftChangeRef.current = false;
+    const historyNav = promptHistoryNavRef.current;
+    if (!value || (historyNav.active && value !== historyNav.lastValue && value !== historyNav.seed)) {
+      resetPromptHistoryNav();
+    }
+    // Only lift the draft into App state when it can affect the slash palette
+    // (a single "/token"). Prose typing renders entirely inside PromptInput's
+    // own state, so App need not re-render — and relayout the full fullscreen
+    // frame — on every keystroke (input lag fix). Entering slash mode and
+    // leaving it both still sync because either prev or next is a slash token.
+    // Clearing/submitting must also sync so a consumed slash command does not
+    // remount later as stale initialValue after a picker/panel closes.
+    const nextSlash = slashQuery(value);
+    setPromptDraft((prev) => {
+      const previousWasSlashFlow = String(prev || '').startsWith('/');
+      if (value === '') return '';
+      return nextSlash !== null || previousWasSlashFlow ? value : prev;
+    });
+    setPromptDraftOverride((prev) => (prev === null ? prev : null));
+    const argumentHint = slashArgumentHint(value);
+    if (argumentHint && !suppressPromptHint) {
+      showPromptHint(argumentHint, 'info');
+    } else if (suppressPromptHint || promptHintActiveRef.current || promptHintTimerRef.current) {
+      // Only clear when a hint is actually live (shown or pending its timer).
+      // clearPromptHint() already early-returns when neither ref is set, but
+      // gating the call here avoids invoking it on EVERY keystroke once a hint
+      // has appeared — that call path otherwise drives a setState → full App
+      // re-render per key, which is costly on long transcripts. Hint-while-
+      // typing still vanishes immediately because the guard includes the active
+      // state; the argumentHint branch above is untouched. The guard no longer
+      // requires a non-empty value: clearing/submitting to '' must also dismiss
+      // a live hint instead of leaving it until its timer expires.
+      clearPromptHint();
+    }
+    if (slashDismissedFor) {
+      setSlashDismissedFor((dismissed) => (dismissed && dismissed !== value ? '' : dismissed));
+    }
+  }, [clearPromptHint, dismissWelcomePromptHint, resetPromptHistoryNav, showPromptHint, slashDismissedFor, syncPromptLayoutRows]);
+
+  const cancelProviderPrompt = useCallback(() => {
+    try { providerPrompt?.login?.cancel?.(); } catch {}
+    oauthSubmitRef.current = false;
+    const onCancel = providerPrompt?.cancelReturn || providerPrompt?.onCancel;
+    const afterSave = providerPrompt?.afterSave;
+    setProviderPrompt(null);
+    if (onCancel) onCancel();
+    else if (afterSave) afterSave();
+  }, [providerPrompt, showPromptHint]);
+
+  const cancelChannelPrompt = useCallback(() => {
+    const onCancel = channelPrompt?.onCancel;
+    const afterSave = channelPrompt?.afterSave;
+    setChannelPrompt(null);
+    if (typeof onCancel === 'function') onCancel();
+    else if (typeof afterSave === 'function') afterSave();
+  }, [channelPrompt, showPromptHint]);
+
+  const cancelHookPrompt = useCallback(() => {
+    setHookPrompt(null);
+  }, [showPromptHint]);
+
+  const cancelSettingsPrompt = useCallback(() => {
+    // The project entry prompts are reached from the project picker; backing out
+    // (Esc) should return to that picker rather than dropping to a bare prompt.
+    const kind = settingsPrompt?.kind;
+    setSettingsPrompt(null);
+    if (kind === 'project-new' || kind === 'project-create-confirm' || kind === 'project-rename') {
+      openProjectPicker();
+    } else if (kind === 'core-add' || kind === 'core-edit' || kind === 'core-delete-confirm') {
+      openMemoryCorePicker();
+    } else if (kind === 'autoclear-provider') {
+      openAutoClearPicker({ advanced: true, returnTo: settingsPrompt?.returnTo });
+    }
+  }, [settingsPrompt, showPromptHint]);
+
+  const acceptSlashPalette = useCallback((draftValue = '') => {
+    const command = slashCommands[slashIndex];
+    if (!command) return false;
+    pickerOpenedFromEnterRef.current = true;
+    if (pickerOpenedFromEnterTimerRef.current) {
+      clearTimeout(pickerOpenedFromEnterTimerRef.current);
+      pickerOpenedFromEnterTimerRef.current = null;
+    }
+    try {
+      return runSlashCommand(slashCommandTokenForPaletteAccept(command, draftValue), '');
+    } finally {
+      pickerOpenedFromEnterTimerRef.current = setTimeout(() => {
+        pickerOpenedFromEnterRef.current = false;
+        pickerOpenedFromEnterTimerRef.current = null;
+      }, 3000);
+    }
+  }, [slashCommands, slashIndex]);
+
+  const completeSlashPalette = useCallback((draftValue = '') => {
+    const command = slashCommands[slashIndex];
+    if (!command) return undefined;
+    const token = slashCommandTokenForPaletteAccept(command, draftValue);
+    return token ? `/${token} ` : undefined;
+  }, [slashCommands, slashIndex]);
+
+  const cancelSlashPalette = useCallback((value = '') => {
+    // Esc clears the slash draft, so the dismissal marker must not survive.
+    // If it stays as "/" then typing "/" again is treated as the same
+    // dismissed query and the palette never re-opens.
+    setSlashDismissedFor('');
+    setPromptDraft('');
+    setPromptDraftOverride({ id: Date.now(), value: '' });
+  }, []);
+
+  return {
+    onPromptDraftChange,
+    cancelProviderPrompt,
+    cancelChannelPrompt,
+    cancelHookPrompt,
+    cancelSettingsPrompt,
+    acceptSlashPalette,
+    completeSlashPalette,
+    cancelSlashPalette,
+  };
+}

package/src/tui/app/use-prompt-hint.mjs

@@ -0,0 +1,58 @@
+// Prompt-hint band, extracted from App.jsx. One transient hint line under the
+// prompt (copy feedback, queue restore notices, slash argument hints) with a
+// single auto-dismiss timer; the active/timer refs let key handlers decide
+// whether a hint currently owns the band before clearing it.
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+const PROMPT_HINT_DISMISS_MS = 2200;
+
+export function usePromptHint() {
+  const [promptHint, setPromptHint] = useState('');
+  const [promptHintTone, setPromptHintTone] = useState('info');
+  const promptHintTimerRef = useRef(null);
+  const promptHintActiveRef = useRef(false);
+
+  const showPromptHint = useCallback((text, tone = 'info') => {
+    if (promptHintTimerRef.current) clearTimeout(promptHintTimerRef.current);
+    promptHintActiveRef.current = true;
+    setPromptHint(String(text || ''));
+    setPromptHintTone(tone);
+    promptHintTimerRef.current = setTimeout(() => {
+      promptHintTimerRef.current = null;
+      promptHintActiveRef.current = false;
+      setPromptHint('');
+      setPromptHintTone('info');
+    }, PROMPT_HINT_DISMISS_MS);
+  }, []);
+
+  // Same band and timer; only the resting tone differs for copy feedback.
+  const showSelectionCopyHint = useCallback(
+    (text, tone = 'plain') => showPromptHint(text, tone),
+    [showPromptHint],
+  );
+
+  const clearPromptHint = useCallback(() => {
+    if (!promptHintActiveRef.current && !promptHintTimerRef.current) return;
+    if (promptHintTimerRef.current) {
+      clearTimeout(promptHintTimerRef.current);
+      promptHintTimerRef.current = null;
+    }
+    promptHintActiveRef.current = false;
+    setPromptHint('');
+    setPromptHintTone('info');
+  }, []);
+
+  useEffect(() => () => {
+    if (promptHintTimerRef.current) clearTimeout(promptHintTimerRef.current);
+  }, []);
+
+  return {
+    promptHint,
+    promptHintTone,
+    promptHintTimerRef,
+    promptHintActiveRef,
+    showPromptHint,
+    showSelectionCopyHint,
+    clearPromptHint,
+  };
+}

package/src/tui/app/use-prompt-queue-history.mjs

@@ -0,0 +1,100 @@
+// Exit + queued-prompt/history plumbing, extracted from App.jsx: the clean
+// two-phase exit (final frame flush, store dispose race, hard-exit timer),
+// queued-message restore into the draft, the engine-published prompt
+// history with its local-scan fallback, and history-nav reset.
+import { useCallback, useMemo } from 'react';
+import { PROMPT_HISTORY_LIMIT } from './transcript-window.mjs';
+import { promptHistoryKey } from './app-format.mjs';
+
+export function usePromptQueueHistory({
+  store,
+  state,
+  exit,
+  exitRequestedRef,
+  setExiting,
+  promptValueRef,
+  promptDraft,
+  showPromptHint,
+  clearPromptHint,
+  installPastedImages,
+  installPastedTexts,
+  syncPromptLayoutRows,
+  setPromptDraftOverride,
+  promptHistoryNavRef,
+}) {
+  // `exiting` removes the inline caret (PromptInput draws none when disabled) and
+  // freezes input for the teardown frame, so the final frame is clean before ink
+  // unmounts. Exit just past the render throttle window so that frame flushes.
+  const requestExit = useCallback(() => {
+    if (exitRequestedRef.current) return;
+    exitRequestedRef.current = true;
+    setExiting(true);
+    const hardExitTimer = setTimeout(() => {
+      try { process.stdout.write('\x1b[?25h\x1b[0m'); } catch {}
+      process.exit(0);
+    }, 2000);
+    hardExitTimer.unref?.();
+    setTimeout(() => {
+      let timer = null;
+      Promise.race([
+        Promise.resolve(store.dispose?.('cli-react-exit', { detach: true })),
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, 350);
+        }),
+      ]).finally(() => {
+        if (timer) clearTimeout(timer);
+        exit();
+      });
+    }, 60);
+  }, [store, exit]);
+
+  const restoreQueuedToPrompt = useCallback((options = {}) => {
+    const restoreDraft = options.restoreDraft !== false;
+    const showHint = options.showHint !== false;
+    const currentText = options.currentText ?? promptValueRef.current ?? promptDraft;
+    const restored = store.restoreQueued?.(currentText);
+    if (!restored || restored.count === 0) {
+      if (showHint) showPromptHint('No queued messages to restore.', 'info');
+      return false;
+    }
+    if (restoreDraft) {
+      if (restored.pastedImages) installPastedImages(restored.pastedImages, { merge: true });
+      if (restored.pastedTexts) installPastedTexts(restored.pastedTexts, { merge: true });
+      syncPromptLayoutRows(restored.text);
+      setPromptDraftOverride({ id: Date.now(), value: restored.text });
+    }
+    if (showHint) {
+      showPromptHint(`restored ${restored.count} queued message${restored.count === 1 ? '' : 's'}`, 'info');
+    } else {
+      clearPromptHint();
+    }
+    return true;
+  }, [store, promptDraft, showPromptHint, clearPromptHint, installPastedImages, syncPromptLayoutRows]);
+
+  const recentPromptHistory = useMemo(() => {
+    // The engine maintains this list incrementally (rebuilt only when a user
+    // item is appended or the transcript is bulk-swapped), so App no longer
+    // rescans all items on every transcript change. Fall back to a local scan
+    // only if the engine did not publish it (older snapshot).
+    if (Array.isArray(state.promptHistoryList)) return state.promptHistoryList;
+    const items = Array.isArray(state.items) ? state.items : [];
+    const seen = new Set();
+    const history = [];
+    for (let i = items.length - 1; i >= 0 && history.length < PROMPT_HISTORY_LIMIT; i -= 1) {
+      const item = items[i];
+      if (item?.kind !== 'user') continue;
+      const text = String(item.text || '').trim();
+      const key = promptHistoryKey(text);
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      history.push(text);
+    }
+    return history;
+  }, [state.promptHistoryList, state.items]);
+
+  const resetPromptHistoryNav = useCallback(() => {
+    promptHistoryNavRef.current = { active: false, index: -1, seed: '', lastValue: '' };
+  }, []);
+
+  return { requestExit, restoreQueuedToPrompt, recentPromptHistory, resetPromptHistoryNav };
+}

package/src/tui/app/use-terminal-chrome.mjs

@@ -0,0 +1,72 @@
+// Terminal chrome, extracted from App.jsx: the debounced resize listener
+// (leading-edge + trailing settle, no-op on unchanged dimensions) and the
+// one-shot extended-keyboard enable (kitty + modifyOtherKeys).
+import { useEffect } from 'react';
+import { terminalSize } from './app-format.mjs';
+import { supportsExtendedKeys, ENABLE_KITTY_KEYBOARD, ENABLE_MODIFY_OTHER_KEYS } from '../keyboard-protocol.mjs';
+
+export function useTerminalChrome({ stdout, isRawModeSupported, setResizeState }) {
+  useEffect(() => {
+    if (!stdout) return undefined;
+    let trailing = null;
+    // Leading-edge fire on the first event of a burst, then coalesce the rest:
+    // events arriving within DEBOUNCE_MS skip the immediate full-layout update
+    // and only refresh the (reset) trailing timer, so a resize storm commits at
+    // most once per window plus one settle update instead of once per event.
+    const DEBOUNCE_MS = 80;
+    let lastRun = 0;
+    const update = () => {
+      setResizeState((prev) => {
+        const next = terminalSize(stdout);
+        // No-op when dimensions are unchanged: the unconditional post-mount
+        // update() otherwise forces an extra full-frame commit (epoch bump)
+        // right after the first paint, which reads as a boot flicker.
+        if (next.columns === prev.columns && next.rows === prev.rows) return prev;
+        return {
+          ...next,
+          epoch: prev.epoch + 1,
+        };
+      });
+    };
+    const onResize = () => {
+      const now = Date.now();
+      if (now - lastRun >= DEBOUNCE_MS) {
+        lastRun = now;
+        update();
+      }
+      if (trailing) clearTimeout(trailing);
+      trailing = setTimeout(() => {
+        trailing = null;
+        lastRun = Date.now();
+        update();
+      }, DEBOUNCE_MS);
+    };
+    stdout.on('resize', onResize);
+    update();
+    return () => {
+      if (trailing) clearTimeout(trailing);
+      stdout.off('resize', onResize);
+    };
+  }, [stdout]);
+
+  // Enable extended keyboard reporting (kitty + xterm modifyOtherKeys)
+  // SYNCHRONOUSLY, ONCE, with NO query/round-trip. ink
+  // turns raw mode on during the first useInput mount (synchronously, inside
+  // render); this mount effect runs in the same commit phase, right after — i.e.
+  // before the user can realistically press a key. We write BOTH enables
+  // unconditionally (the terminal honors whichever it implements; Windows
+  // Terminal 1.24 has no kitty but DOES honor modifyOtherKeys), gated only by the
+  // supportsExtendedKeys() allowlist. Because the enable lands before the first
+  // keypress is read, the FIRST Ctrl+Enter already arrives as a distinguishable
+  // \x1b[27;5;13~ (or kitty \x1b[13;5u) instead of a bare \r — fixing the old
+  // "first Ctrl+Enter submits, second works" race. Teardown lives in index.jsx's
+  // restoreTerminal(). The empty dep array makes this run exactly once on mount.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  useEffect(() => {
+    if (!isRawModeSupported || !stdout?.write) return;
+    if (!supportsExtendedKeys()) return;
+    try {
+      stdout.write(ENABLE_KITTY_KEYBOARD + ENABLE_MODIFY_OTHER_KEYS);
+    } catch { /* terminal may be closing */ }
+  }, []);
+}

package/src/tui/app/use-transcript-activity.mjs

@@ -0,0 +1,131 @@
+// Transcript-activity signatures, extracted from App.jsx: the agent-state
+// revision key, the L2 statusline explore/search pending-tool signature
+// (engine-published fast path + local transcript fallback), and the
+// primitive statusline stats snapshot.
+import { useMemo } from 'react';
+// eslint-disable-next-line import/no-relative-packages
+import { classifyToolCategory } from '../../runtime/shared/tool-surface.mjs';
+
+export function useTranscriptActivity({ state }) {
+  // agentRevision is a cheap change-detection key for downstream consumers, but
+  // JSON.stringify over the worker/job arrays ran on EVERY render (including the
+  // ~120fps streaming reconciles). Memoize on the agent slices so it only
+  // recomputes when agent state actually changes, not on every assistant delta.
+  const agentRevision = useMemo(() => JSON.stringify({
+    workers: (state.agentWorkers || []).map((w) => [w.tag, w.status, w.stage, w.sessionId]).slice(0, 20),
+    jobs: (state.agentJobs || []).map((j) => [j.task_id, j.status, j.tag, j.sessionId, j.startedAt, j.finishedAt, j.error]).slice(0, 20),
+  }), [state.agentWorkers, state.agentJobs]);
+
+  // L2 statusline explore/search segments are the MAIN session's own running
+  // tool cards (NOT agentWorkers/agentJobs). Derive pending counts + oldest
+  // start time straight from the live transcript tool cards. A card is pending
+  // until completedCount >= count. (Do NOT use completedAt as the terminal
+  // signal: engine patchToolCardResult stamps completedAt on EVERY aggregate
+  // result patch even while calls are still running, and reused tail-aggregates
+  // keep a stale completedAt, so it would drop the segment early / skip newly
+  // added pending calls.) Aggregate cards carry a `categories` map; standalone
+  // cards carry name/args resolved
+  // via classifyToolCategory. Keep this CHEAP: build a primitive signature from
+  // only the tool items so streaming flushes that swap
+  // state.items for a fresh array don't restringify the whole transcript and
+  // the StatusLine effect only re-fires when the numbers actually change.
+  const activeToolsSignature = useMemo(() => {
+    // The engine maintains this signature incrementally (updated on tool
+    // start/early-complete/result/turn-end), so App no longer scans every
+    // transcript item on each change. Prefer it; fall back to the local scan
+    // only when the engine did not publish it (older snapshot).
+    if (state.activeToolSummary !== undefined) return state.activeToolSummary || '';
+    const items = state.items || [];
+    let exploreCount = 0;
+    let exploreStart = 0;
+    let searchCount = 0;
+    let searchStart = 0;
+    for (const it of items) {
+      if (!it || it.kind !== 'tool') continue;
+      const count = Math.max(1, Number(it.count || 1));
+      // Resolved check: aggregates stay on the pure completedCount>=count test
+      // because engine patchToolCardResult sets `result` on EVERY aggregate
+      // patch (even partial, completedCount<count), so a `result`-aware check
+      // would drop a still-running aggregate early. Standalone cards mirror
+      // toolItemPendingForRows (done when completedCount>=count OR a result
+      // landed) so an abnormally-finished card (cancelled/errored) that sets a
+      // result without bumping completedCount cannot pin a phantom segment.
+      const done = it.aggregate
+        ? Number(it.completedCount || 0)
+        : Math.max(0, Math.min(count, Number(it.completedCount || (it.result == null ? 0 : count))));
+      if (done >= count) continue; // resolved card (matches toolItemPendingForRows)
+      const started = Number(it.startedAt || 0);
+      let exploreHits = 0;
+      let searchHits = 0;
+      if (it.aggregate && it.categories && typeof it.categories === 'object') {
+        for (const v of Object.values(it.categories)) {
+          const cat = v && typeof v === 'object' ? v.category : null;
+          const c = Math.max(1, Number(v && typeof v === 'object' ? v.count : 1) || 1);
+          if (cat === 'Explore') exploreHits += c;
+          else if (cat === 'Web Research') searchHits += c;
+        }
+      } else if (it.name) {
+        const cat = classifyToolCategory(it.name, it.args || {});
+        if (cat === 'Explore') exploreHits = count;
+        else if (cat === 'Web Research') searchHits = count;
+      }
+      if (exploreHits > 0) {
+        exploreCount += exploreHits;
+        if (started > 0 && (exploreStart === 0 || started < exploreStart)) exploreStart = started;
+      }
+      if (searchHits > 0) {
+        searchCount += searchHits;
+        if (started > 0 && (searchStart === 0 || started < searchStart)) searchStart = started;
+      }
+    }
+    if (!exploreCount && !searchCount) return '';
+    return `${exploreCount}:${exploreStart}:${searchCount}:${searchStart}`;
+  }, [state.activeToolSummary, state.items]);
+
+  const activeTools = useMemo(() => {
+    if (!activeToolsSignature) return null;
+    const [ec, es, sc, ss] = activeToolsSignature.split(':').map((n) => Number(n) || 0);
+    return {
+      explore: { count: ec, startedAt: es },
+      search: { count: sc, startedAt: ss },
+    };
+  }, [activeToolsSignature]);
+
+  // StatusLine only reads a small stats subset; engine clones the full stats
+  // object on many updates. Memoize by field value so identical usage keeps
+  // the same object reference and React.memo / effect deps stay quiet.
+  const statuslineStats = useMemo(() => {
+    const s = state.stats || {};
+    return {
+      currentContextSource: s.currentContextSource ?? null,
+      currentEstimatedContextTokens: s.currentEstimatedContextTokens ?? 0,
+      currentContextTokens: s.currentContextTokens ?? 0,
+      contextTokens: s.contextTokens ?? 0,
+      latestPromptTokens: s.latestPromptTokens ?? 0,
+      latestInputTokens: s.latestInputTokens ?? 0,
+      latestCachedTokens: s.latestCachedTokens ?? 0,
+      latestCacheWriteTokens: s.latestCacheWriteTokens ?? 0,
+      inputTokens: s.inputTokens ?? 0,
+      cachedTokens: s.cachedTokens ?? 0,
+      cacheWriteTokens: s.cacheWriteTokens ?? 0,
+      promptTokens: s.promptTokens ?? 0,
+      turns: s.turns ?? 0,
+    };
+  }, [
+    state.stats?.currentContextSource,
+    state.stats?.currentEstimatedContextTokens,
+    state.stats?.currentContextTokens,
+    state.stats?.contextTokens,
+    state.stats?.latestPromptTokens,
+    state.stats?.latestInputTokens,
+    state.stats?.latestCachedTokens,
+    state.stats?.latestCacheWriteTokens,
+    state.stats?.inputTokens,
+    state.stats?.cachedTokens,
+    state.stats?.cacheWriteTokens,
+    state.stats?.promptTokens,
+    state.stats?.turns,
+  ]);
+
+  return { agentRevision, activeToolsSignature, activeTools, statuslineStats };
+}