Add files using upload-large-folder tool

src/components/LogoV2/EmergencyTip.tsx

@@ -0,0 +1,58 @@
+import * as React from 'react';
+import { useEffect, useMemo } from 'react';
+import { Box, Text } from 'src/ink.js';
+import { getDynamicConfig_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js';
+import { getGlobalConfig, saveGlobalConfig } from 'src/utils/config.js';
+const CONFIG_NAME = 'tengu-top-of-feed-tip';
+export function EmergencyTip(): React.ReactNode {
+  const tip = useMemo(getTipOfFeed, []);
+  // Memoize to prevent re-reads after we save - we want the value at mount time
+  const lastShownTip = useMemo(() => getGlobalConfig().lastShownEmergencyTip, []);
+
+  // Only show if this is a new/different tip
+  const shouldShow = tip.tip && tip.tip !== lastShownTip;
+
+  // Save the tip we're showing so we don't show it again
+  useEffect(() => {
+    if (shouldShow) {
+      saveGlobalConfig(current => {
+        if (current.lastShownEmergencyTip === tip.tip) return current;
+        return {
+          ...current,
+          lastShownEmergencyTip: tip.tip
+        };
+      });
+    }
+  }, [shouldShow, tip.tip]);
+  if (!shouldShow) {
+    return null;
+  }
+  return <Box paddingLeft={2} flexDirection="column">
+      <Text {...tip.color === 'warning' ? {
+      color: 'warning'
+    } : tip.color === 'error' ? {
+      color: 'error'
+    } : {
+      dimColor: true
+    }}>
+        {tip.tip}
+      </Text>
+    </Box>;
+}
+type TipOfFeed = {
+  tip: string;
+  color?: 'dim' | 'warning' | 'error';
+};
+const DEFAULT_TIP: TipOfFeed = {
+  tip: '',
+  color: 'dim'
+};
+
+/**
+ * Get the tip of the feed from dynamic config with caching
+ * Returns cached value immediately, updates in background
+ */
+function getTipOfFeed(): TipOfFeed {
+  return getDynamicConfig_CACHED_MAY_BE_STALE<TipOfFeed>(CONFIG_NAME, DEFAULT_TIP);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/PromptInput/ShimmeredInput.tsx

@@ -0,0 +1,143 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { Ansi, Box, Text, useAnimationFrame } from '../../ink.js';
+import { segmentTextByHighlights, type TextHighlight } from '../../utils/textHighlighting.js';
+import { ShimmerChar } from '../Spinner/ShimmerChar.js';
+type Props = {
+  text: string;
+  highlights: TextHighlight[];
+};
+type LinePart = {
+  text: string;
+  highlight: TextHighlight | undefined;
+  start: number;
+};
+export function HighlightedInput(t0) {
+  const $ = _c(23);
+  const {
+    text,
+    highlights
+  } = t0;
+  let lines;
+  if ($[0] !== highlights || $[1] !== text) {
+    const segments = segmentTextByHighlights(text, highlights);
+    lines = [[]];
+    let pos = 0;
+    for (const segment of segments) {
+      const parts = segment.text.split("\n");
+      for (let i = 0; i < parts.length; i++) {
+        if (i > 0) {
+          lines.push([]);
+          pos = pos + 1;
+        }
+        const part = parts[i];
+        if (part.length > 0) {
+          lines[lines.length - 1].push({
+            text: part,
+            highlight: segment.highlight,
+            start: pos
+          });
+        }
+        pos = pos + part.length;
+      }
+    }
+    $[0] = highlights;
+    $[1] = text;
+    $[2] = lines;
+  } else {
+    lines = $[2];
+  }
+  let t1;
+  if ($[3] !== highlights) {
+    t1 = highlights.some(_temp);
+    $[3] = highlights;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const hasShimmer = t1;
+  let sweepStart = 0;
+  let cycleLength = 1;
+  if (hasShimmer) {
+    let lo = Infinity;
+    let hi = -Infinity;
+    if ($[5] !== hi || $[6] !== highlights || $[7] !== lo) {
+      for (const h_0 of highlights) {
+        if (h_0.shimmerColor) {
+          lo = Math.min(lo, h_0.start);
+          hi = Math.max(hi, h_0.end);
+        }
+      }
+      $[5] = hi;
+      $[6] = highlights;
+      $[7] = lo;
+      $[8] = lo;
+      $[9] = hi;
+    } else {
+      lo = $[8];
+      hi = $[9];
+    }
+    sweepStart = lo - 10;
+    cycleLength = hi - lo + 20;
+  }
+  let t2;
+  if ($[10] !== cycleLength || $[11] !== hasShimmer || $[12] !== lines || $[13] !== sweepStart) {
+    t2 = {
+      lines,
+      hasShimmer,
+      sweepStart,
+      cycleLength
+    };
+    $[10] = cycleLength;
+    $[11] = hasShimmer;
+    $[12] = lines;
+    $[13] = sweepStart;
+    $[14] = t2;
+  } else {
+    t2 = $[14];
+  }
+  const {
+    lines: lines_0,
+    hasShimmer: hasShimmer_0,
+    sweepStart: sweepStart_0,
+    cycleLength: cycleLength_0
+  } = t2;
+  const [ref, time] = useAnimationFrame(hasShimmer_0 ? 50 : null);
+  const glimmerIndex = hasShimmer_0 ? sweepStart_0 + Math.floor(time / 50) % cycleLength_0 : -100;
+  let t3;
+  if ($[15] !== glimmerIndex || $[16] !== lines_0) {
+    let t4;
+    if ($[18] !== glimmerIndex) {
+      t4 = (lineParts, lineIndex) => <Box key={lineIndex}>{lineParts.length === 0 ? <Text> </Text> : lineParts.map((part_0, partIndex) => {
+          if (part_0.highlight?.shimmerColor && part_0.highlight.color) {
+            return <Text key={partIndex}>{part_0.text.split("").map((char, charIndex) => <ShimmerChar key={charIndex} char={char} index={part_0.start + charIndex} glimmerIndex={glimmerIndex} messageColor={part_0.highlight.color} shimmerColor={part_0.highlight.shimmerColor} />)}</Text>;
+          }
+          return <Text key={partIndex} color={part_0.highlight?.color} dimColor={part_0.highlight?.dimColor} inverse={part_0.highlight?.inverse}><Ansi>{part_0.text}</Ansi></Text>;
+        })}</Box>;
+      $[18] = glimmerIndex;
+      $[19] = t4;
+    } else {
+      t4 = $[19];
+    }
+    t3 = lines_0.map(t4);
+    $[15] = glimmerIndex;
+    $[16] = lines_0;
+    $[17] = t3;
+  } else {
+    t3 = $[17];
+  }
+  let t4;
+  if ($[20] !== ref || $[21] !== t3) {
+    t4 = <Box ref={ref} flexDirection="column">{t3}</Box>;
+    $[20] = ref;
+    $[21] = t3;
+    $[22] = t4;
+  } else {
+    t4 = $[22];
+  }
+  return t4;
+}
+function _temp(h) {
+  return h.shimmerColor;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Ansi","Box","Text","useAnimationFrame","segmentTextByHighlights","TextHighlight","ShimmerChar","Props","text","highlights","LinePart","highlight","start","HighlightedInput","t0","$","_c","lines","segments","pos","segment","parts","split","i","length","push","part","t1","some","_temp","hasShimmer","sweepStart","cycleLength","lo","Infinity","hi","h_0","h","shimmerColor","Math","min","max","end","t2","lines_0","hasShimmer_0","sweepStart_0","cycleLength_0","ref","time","glimmerIndex","floor","t3","t4","lineParts","lineIndex","map","part_0","partIndex","color","char","charIndex","dimColor","inverse"],"sources":["ShimmeredInput.tsx"],"sourcesContent":["import * as React from 'react'\nimport { Ansi, Box, Text, useAnimationFrame } from '../../ink.js'\nimport {\n  segmentTextByHighlights,\n  type TextHighlight,\n} from '../../utils/textHighlighting.js'\nimport { ShimmerChar } from '../Spinner/ShimmerChar.js'\n\ntype Props = {\n  text: string\n  highlights: TextHighlight[]\n}\n\ntype LinePart = {\n  text: string\n  highlight: TextHighlight | undefined\n  start: number\n}\n\nexport function HighlightedInput({ text, highlights }: Props): React.ReactNode {\n  // The shimmer animation (below) re-renders this component at 20fps while the\n  // ultrathink keyword is present. text/highlights are referentially stable\n  // across animation ticks (parent doesn't re-render), so memoize everything\n  // that derives from them: segmentTextByHighlights alone is ~85µs/call\n  // (tokenize + sort + O(n²) overlap), which adds up fast at 20fps.\n  const { lines, hasShimmer, sweepStart, cycleLength } = React.useMemo(() => {\n    const segments = segmentTextByHighlights(text, highlights)\n\n    // Split segments by newlines into per-line groups. Ink's row-direction Box\n    // indents continuation lines of a multi-line child to that child's X offset.\n    // By splitting at newlines, each line renders as its own row, avoiding the\n    // incorrect indentation when highlighted text is followed by wrapped content.\n    const lines: LinePart[][] = [[]]\n    let pos = 0\n    for (const segment of segments) {\n      const parts = segment.text.split('\\n')\n      for (let i = 0; i < parts.length; i++) {\n        if (i > 0) {\n          lines.push([])\n          pos += 1\n        }\n        const part = parts[i]!\n        if (part.length > 0) {\n          lines[lines.length - 1]!.push({\n            text: part,\n            highlight: segment.highlight,\n            start: pos,\n          })\n        }\n        pos += part.length\n      }\n    }\n\n    // Scope the sweep to shimmer-highlighted ranges so cycle time doesn't grow\n    // with input length. Padding creates an offscreen pause between sweeps.\n    const hasShimmer = highlights.some(h => h.shimmerColor)\n    let sweepStart = 0\n    let cycleLength = 1\n    if (hasShimmer) {\n      const padding = 10\n      let lo = Infinity\n      let hi = -Infinity\n      for (const h of highlights) {\n        if (h.shimmerColor) {\n          lo = Math.min(lo, h.start)\n          hi = Math.max(hi, h.end)\n        }\n      }\n      sweepStart = lo - padding\n      cycleLength = hi - lo + padding * 2\n    }\n\n    return { lines, hasShimmer, sweepStart, cycleLength }\n  }, [text, highlights])\n\n  const [ref, time] = useAnimationFrame(hasShimmer ? 50 : null)\n  const glimmerIndex = hasShimmer\n    ? sweepStart + (Math.floor(time / 50) % cycleLength)\n    : -100\n\n  return (\n    <Box ref={ref} flexDirection=\"column\">\n      {lines.map((lineParts, lineIndex) => (\n        <Box key={lineIndex}>\n          {lineParts.length === 0 ? (\n            <Text> </Text>\n          ) : (\n            lineParts.map((part, partIndex) => {\n              if (part.highlight?.shimmerColor && part.highlight.color) {\n                return (\n                  <Text key={partIndex}>\n                    {part.text.split('').map((char, charIndex) => (\n                      <ShimmerChar\n                        key={charIndex}\n                        char={char}\n                        index={part.start + charIndex}\n                        glimmerIndex={glimmerIndex}\n                        messageColor={part.highlight!.color!}\n                        shimmerColor={part.highlight!.shimmerColor!}\n                      />\n                    ))}\n                  </Text>\n                )\n              }\n              return (\n                <Text\n                  key={partIndex}\n                  color={part.highlight?.color}\n                  dimColor={part.highlight?.dimColor}\n                  inverse={part.highlight?.inverse}\n                >\n                  <Ansi>{part.text}</Ansi>\n                </Text>\n              )\n            })\n          )}\n        </Box>\n      ))}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/components/PromptInput/useShowFastIconHint.ts

@@ -0,0 +1,31 @@
+import { useEffect, useState } from 'react'
+
+const HINT_DISPLAY_DURATION_MS = 5000
+
+let hasShownThisSession = false
+
+/**
+ * Hook to manage the /fast hint display next to the fast icon.
+ * Shows the hint for 5 seconds once per session.
+ */
+export function useShowFastIconHint(showFastIcon: boolean): boolean {
+  const [showHint, setShowHint] = useState(false)
+
+  useEffect(() => {
+    if (hasShownThisSession || !showFastIcon) {
+      return
+    }
+
+    hasShownThisSession = true
+    setShowHint(true)
+
+    const timer = setTimeout(setShowHint, HINT_DISPLAY_DURATION_MS, false)
+
+    return () => {
+      clearTimeout(timer)
+      setShowHint(false)
+    }
+  }, [showFastIcon])
+
+  return showHint
+}

src/components/Settings/Settings.tsx

@@ -0,0 +1,137 @@
+import { c as _c } from "react/compiler-runtime";
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import * as React from 'react';
+import { Suspense, useState } from 'react';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import { useIsInsideModal, useModalOrTerminalSize } from '../../context/modalContext.js';
+import { Pane } from '../design-system/Pane.js';
+import { Tabs, Tab } from '../design-system/Tabs.js';
+import { Status, buildDiagnostics } from './Status.js';
+import { Config } from './Config.js';
+import { Usage } from './Usage.js';
+import type { LocalJSXCommandContext, CommandResultDisplay } from '../../commands.js';
+type Props = {
+  onClose: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+  context: LocalJSXCommandContext;
+  defaultTab: 'Status' | 'Config' | 'Usage' | 'Gates';
+};
+export function Settings(t0) {
+  const $ = _c(25);
+  const {
+    onClose,
+    context,
+    defaultTab
+  } = t0;
+  const [selectedTab, setSelectedTab] = useState(defaultTab);
+  const [tabsHidden, setTabsHidden] = useState(false);
+  const [configOwnsEsc, setConfigOwnsEsc] = useState(false);
+  const [gatesOwnsEsc, setGatesOwnsEsc] = useState(false);
+  const insideModal = useIsInsideModal();
+  const {
+    rows
+  } = useModalOrTerminalSize(useTerminalSize());
+  const contentHeight = insideModal ? rows + 1 : Math.max(15, Math.min(Math.floor(rows * 0.8), 30));
+  const [diagnosticsPromise] = useState(_temp2);
+  useExitOnCtrlCDWithKeybindings();
+  let t1;
+  if ($[0] !== onClose || $[1] !== tabsHidden) {
+    t1 = () => {
+      if (tabsHidden) {
+        return;
+      }
+      onClose("Status dialog dismissed", {
+        display: "system"
+      });
+    };
+    $[0] = onClose;
+    $[1] = tabsHidden;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const handleEscape = t1;
+  const t2 = !tabsHidden && !(selectedTab === "Config" && configOwnsEsc) && !(selectedTab === "Gates" && gatesOwnsEsc);
+  let t3;
+  if ($[3] !== t2) {
+    t3 = {
+      context: "Settings",
+      isActive: t2
+    };
+    $[3] = t2;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  useKeybinding("confirm:no", handleEscape, t3);
+  let t4;
+  if ($[5] !== context || $[6] !== diagnosticsPromise) {
+    t4 = <Tab key="status" title="Status"><Status context={context} diagnosticsPromise={diagnosticsPromise} /></Tab>;
+    $[5] = context;
+    $[6] = diagnosticsPromise;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  let t5;
+  if ($[8] !== contentHeight || $[9] !== context || $[10] !== onClose) {
+    t5 = <Tab key="config" title="Config"><Suspense fallback={null}><Config context={context} onClose={onClose} setTabsHidden={setTabsHidden} onIsSearchModeChange={setConfigOwnsEsc} contentHeight={contentHeight} /></Suspense></Tab>;
+    $[8] = contentHeight;
+    $[9] = context;
+    $[10] = onClose;
+    $[11] = t5;
+  } else {
+    t5 = $[11];
+  }
+  let t6;
+  if ($[12] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = <Tab key="usage" title="Usage"><Usage /></Tab>;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  let t7;
+  if ($[13] !== contentHeight) {
+    t7 = false ? [<Tab key="gates" title="Gates"><Gates onOwnsEscChange={setGatesOwnsEsc} contentHeight={contentHeight} /></Tab>] : [];
+    $[13] = contentHeight;
+    $[14] = t7;
+  } else {
+    t7 = $[14];
+  }
+  let t8;
+  if ($[15] !== t4 || $[16] !== t5 || $[17] !== t7) {
+    t8 = [t4, t5, t6, ...t7];
+    $[15] = t4;
+    $[16] = t5;
+    $[17] = t7;
+    $[18] = t8;
+  } else {
+    t8 = $[18];
+  }
+  const tabs = t8;
+  const t9 = defaultTab !== "Config" && defaultTab !== "Gates";
+  const t10 = tabsHidden || insideModal ? undefined : contentHeight;
+  let t11;
+  if ($[19] !== selectedTab || $[20] !== t10 || $[21] !== t9 || $[22] !== tabs || $[23] !== tabsHidden) {
+    t11 = <Pane color="permission"><Tabs color="permission" selectedTab={selectedTab} onTabChange={setSelectedTab} hidden={tabsHidden} initialHeaderFocused={t9} contentHeight={t10}>{tabs}</Tabs></Pane>;
+    $[19] = selectedTab;
+    $[20] = t10;
+    $[21] = t9;
+    $[22] = tabs;
+    $[23] = tabsHidden;
+    $[24] = t11;
+  } else {
+    t11 = $[24];
+  }
+  return t11;
+}
+function _temp2() {
+  return buildDiagnostics().catch(_temp);
+}
+function _temp() {
+  return [];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Suspense","useState","useKeybinding","useExitOnCtrlCDWithKeybindings","useTerminalSize","useIsInsideModal","useModalOrTerminalSize","Pane","Tabs","Tab","Status","buildDiagnostics","Config","Usage","LocalJSXCommandContext","CommandResultDisplay","Props","onClose","result","options","display","context","defaultTab","Settings","t0","$","_c","selectedTab","setSelectedTab","tabsHidden","setTabsHidden","configOwnsEsc","setConfigOwnsEsc","gatesOwnsEsc","setGatesOwnsEsc","insideModal","rows","contentHeight","Math","max","min","floor","diagnosticsPromise","_temp2","t1","handleEscape","t2","t3","isActive","t4","t5","t6","Symbol","for","t7","t8","tabs","t9","t10","undefined","t11","catch","_temp"],"sources":["Settings.tsx"],"sourcesContent":["// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered\nimport * as React from 'react'\nimport { Suspense, useState } from 'react'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport {\n  useIsInsideModal,\n  useModalOrTerminalSize,\n} from '../../context/modalContext.js'\nimport { Pane } from '../design-system/Pane.js'\nimport { Tabs, Tab } from '../design-system/Tabs.js'\nimport { Status, buildDiagnostics } from './Status.js'\nimport { Config } from './Config.js'\nimport { Usage } from './Usage.js'\nimport type {\n  LocalJSXCommandContext,\n  CommandResultDisplay,\n} from '../../commands.js'\n\ntype Props = {\n  onClose: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n  context: LocalJSXCommandContext\n  defaultTab: 'Status' | 'Config' | 'Usage' | 'Gates'\n}\n\nexport function Settings({\n  onClose,\n  context,\n  defaultTab,\n}: Props): React.ReactNode {\n  const [selectedTab, setSelectedTab] = useState<string>(defaultTab)\n  const [tabsHidden, setTabsHidden] = useState(false)\n  // True while Config's own Esc handler is active (search mode with content\n  // focused). Settings must cede Esc so search can clear/exit first.\n  const [configOwnsEsc, setConfigOwnsEsc] = useState(false)\n  const [gatesOwnsEsc, setGatesOwnsEsc] = useState(false)\n  // Fixed content height so switching tabs doesn't shift the pane height.\n  // Outside modals cap at min(80% viewport, 30). Inside a Modal the modal's\n  // innerSize.rows IS the ScrollBox viewport — the 0.8 multiplier over-\n  // shrinks, leaving empty rows while Config shows \"↓ N more below\".\n  //\n  // Inside-modal math: Config's paneCap-10 chrome estimate was tuned for\n  // marginY={1} (2 rows) which is stripped inside modals → +2 to recover.\n  // Then -2 for Tabs' header row + its marginTop=1. Plus +1 observed gap\n  // from the paneCap-10 estimate being slightly generous. Net: rows + 1.\n  const insideModal = useIsInsideModal()\n  const { rows } = useModalOrTerminalSize(useTerminalSize())\n  const contentHeight = insideModal\n    ? rows + 1\n    : Math.max(15, Math.min(Math.floor(rows * 0.8), 30))\n  // Kick off diagnostics once when the pane opens. Status use()s this so\n  // it resolves once per /config invocation — no re-fetch flash when\n  // tabbing back to Status (Tab unmounts children when not selected).\n  const [diagnosticsPromise] = useState(() =>\n    buildDiagnostics().catch(() => []),\n  )\n\n  useExitOnCtrlCDWithKeybindings()\n\n  // Handle escape via keybinding - only when not in submenu\n  const handleEscape = () => {\n    // Don't handle escape when a submenu is showing (tabsHidden means submenu is open)\n    // Let the submenu handle escape to return to the main menu\n    if (tabsHidden) {\n      return\n    }\n    // TODO: Update to \"Settings\" dialog once we define '/settings'.\n    onClose('Status dialog dismissed', { display: 'system' })\n  }\n\n  // Disable when submenu is open so the submenu's Dialog can handle ESC,\n  // and when Config's search mode is active so its useInput handler\n  // (clear query → exit search) processes Escape first.\n  useKeybinding('confirm:no', handleEscape, {\n    context: 'Settings',\n    isActive:\n      !tabsHidden &&\n      !(selectedTab === 'Config' && configOwnsEsc) &&\n      !(selectedTab === 'Gates' && gatesOwnsEsc),\n  })\n\n  const tabs = [\n    <Tab key=\"status\" title=\"Status\">\n      <Status context={context} diagnosticsPromise={diagnosticsPromise} />\n    </Tab>,\n    <Tab key=\"config\" title=\"Config\">\n      <Suspense fallback={null}>\n        <Config\n          context={context}\n          onClose={onClose}\n          setTabsHidden={setTabsHidden}\n          onIsSearchModeChange={setConfigOwnsEsc}\n          contentHeight={contentHeight}\n        />\n      </Suspense>\n    </Tab>,\n    <Tab key=\"usage\" title=\"Usage\">\n      <Usage />\n    </Tab>,\n    ...(\"external\" === 'ant'\n      ? [\n          <Tab key=\"gates\" title=\"Gates\">\n            <Gates\n              onOwnsEscChange={setGatesOwnsEsc}\n              contentHeight={contentHeight}\n            />\n          </Tab>,\n        ]\n      : []),\n  ]\n\n  return (\n    <Pane color=\"permission\">\n      <Tabs\n        color=\"permission\"\n        selectedTab={selectedTab}\n        onTabChange={setSelectedTab}\n        hidden={tabsHidden}\n        // Config has interactive content — start with header unfocused so\n        // left/right/tab cycle option values instead of switching tabs.\n        initialHeaderFocused={defaultTab !== 'Config' && defaultTab !== 'Gates'}\n        // Inside a Modal, skip the Tabs-level cap so tall tabs (Status's\n        // MCP list) flow to their natural height for the Modal's ScrollBox\n        // to scroll. Config/Gates still get contentHeight above — they\n        // paginate internally so this only affects Status/Usage.\n        contentHeight={tabsHidden || insideModal ? undefined : contentHeight}\n      >\n        {tabs}\n      </Tabs>\n    </Pane>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/components/Settings/Usage.tsx

@@ -0,0 +1,377 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { extraUsage as extraUsageCommand } from 'src/commands/extra-usage/index.js';
+import { formatCost } from 'src/cost-tracker.js';
+import { getSubscriptionType } from 'src/utils/auth.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import { Box, Text } from '../../ink.js';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import { type ExtraUsage, fetchUtilization, type RateLimit, type Utilization } from '../../services/api/usage.js';
+import { formatResetText } from '../../utils/format.js';
+import { logError } from '../../utils/log.js';
+import { jsonStringify } from '../../utils/slowOperations.js';
+import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js';
+import { Byline } from '../design-system/Byline.js';
+import { ProgressBar } from '../design-system/ProgressBar.js';
+import { isEligibleForOverageCreditGrant, OverageCreditUpsell } from '../LogoV2/OverageCreditUpsell.js';
+type LimitBarProps = {
+  title: string;
+  limit: RateLimit;
+  maxWidth: number;
+  showTimeInReset?: boolean;
+  extraSubtext?: string;
+};
+function LimitBar(t0) {
+  const $ = _c(34);
+  const {
+    title,
+    limit,
+    maxWidth,
+    showTimeInReset: t1,
+    extraSubtext
+  } = t0;
+  const showTimeInReset = t1 === undefined ? true : t1;
+  const {
+    utilization,
+    resets_at
+  } = limit;
+  if (utilization === null) {
+    return null;
+  }
+  const usedText = `${Math.floor(utilization)}% used`;
+  let subtext;
+  if (resets_at) {
+    let t2;
+    if ($[0] !== resets_at || $[1] !== showTimeInReset) {
+      t2 = formatResetText(resets_at, true, showTimeInReset);
+      $[0] = resets_at;
+      $[1] = showTimeInReset;
+      $[2] = t2;
+    } else {
+      t2 = $[2];
+    }
+    subtext = `Resets ${t2}`;
+  }
+  if (extraSubtext) {
+    if (subtext) {
+      subtext = `${extraSubtext} · ${subtext}`;
+    } else {
+      subtext = extraSubtext;
+    }
+  }
+  if (maxWidth >= 62) {
+    let t2;
+    if ($[3] !== title) {
+      t2 = <Text bold={true}>{title}</Text>;
+      $[3] = title;
+      $[4] = t2;
+    } else {
+      t2 = $[4];
+    }
+    const t3 = utilization / 100;
+    let t4;
+    if ($[5] !== t3) {
+      t4 = <ProgressBar ratio={t3} width={50} fillColor="rate_limit_fill" emptyColor="rate_limit_empty" />;
+      $[5] = t3;
+      $[6] = t4;
+    } else {
+      t4 = $[6];
+    }
+    let t5;
+    if ($[7] !== usedText) {
+      t5 = <Text>{usedText}</Text>;
+      $[7] = usedText;
+      $[8] = t5;
+    } else {
+      t5 = $[8];
+    }
+    let t6;
+    if ($[9] !== t4 || $[10] !== t5) {
+      t6 = <Box flexDirection="row" gap={1}>{t4}{t5}</Box>;
+      $[9] = t4;
+      $[10] = t5;
+      $[11] = t6;
+    } else {
+      t6 = $[11];
+    }
+    let t7;
+    if ($[12] !== subtext) {
+      t7 = subtext && <Text dimColor={true}>{subtext}</Text>;
+      $[12] = subtext;
+      $[13] = t7;
+    } else {
+      t7 = $[13];
+    }
+    let t8;
+    if ($[14] !== t2 || $[15] !== t6 || $[16] !== t7) {
+      t8 = <Box flexDirection="column">{t2}{t6}{t7}</Box>;
+      $[14] = t2;
+      $[15] = t6;
+      $[16] = t7;
+      $[17] = t8;
+    } else {
+      t8 = $[17];
+    }
+    return t8;
+  } else {
+    let t2;
+    if ($[18] !== title) {
+      t2 = <Text bold={true}>{title}</Text>;
+      $[18] = title;
+      $[19] = t2;
+    } else {
+      t2 = $[19];
+    }
+    let t3;
+    if ($[20] !== subtext) {
+      t3 = subtext && <><Text> </Text><Text dimColor={true}>· {subtext}</Text></>;
+      $[20] = subtext;
+      $[21] = t3;
+    } else {
+      t3 = $[21];
+    }
+    let t4;
+    if ($[22] !== t2 || $[23] !== t3) {
+      t4 = <Text>{t2}{t3}</Text>;
+      $[22] = t2;
+      $[23] = t3;
+      $[24] = t4;
+    } else {
+      t4 = $[24];
+    }
+    const t5 = utilization / 100;
+    let t6;
+    if ($[25] !== maxWidth || $[26] !== t5) {
+      t6 = <ProgressBar ratio={t5} width={maxWidth} fillColor="rate_limit_fill" emptyColor="rate_limit_empty" />;
+      $[25] = maxWidth;
+      $[26] = t5;
+      $[27] = t6;
+    } else {
+      t6 = $[27];
+    }
+    let t7;
+    if ($[28] !== usedText) {
+      t7 = <Text>{usedText}</Text>;
+      $[28] = usedText;
+      $[29] = t7;
+    } else {
+      t7 = $[29];
+    }
+    let t8;
+    if ($[30] !== t4 || $[31] !== t6 || $[32] !== t7) {
+      t8 = <Box flexDirection="column">{t4}{t6}{t7}</Box>;
+      $[30] = t4;
+      $[31] = t6;
+      $[32] = t7;
+      $[33] = t8;
+    } else {
+      t8 = $[33];
+    }
+    return t8;
+  }
+}
+export function Usage(): React.ReactNode {
+  const [utilization, setUtilization] = useState<Utilization | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const {
+    columns
+  } = useTerminalSize();
+  const availableWidth = columns - 2; // 2 for screen padding
+  const maxWidth = Math.min(availableWidth, 80);
+  const loadUtilization = React.useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await fetchUtilization();
+      setUtilization(data);
+    } catch (err) {
+      logError(err as Error);
+      const axiosError = err as {
+        response?: {
+          data?: unknown;
+        };
+      };
+      const responseBody = axiosError.response?.data ? jsonStringify(axiosError.response.data) : undefined;
+      setError(responseBody ? `Failed to load usage data: ${responseBody}` : 'Failed to load usage data');
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    void loadUtilization();
+  }, [loadUtilization]);
+  useKeybinding('settings:retry', () => {
+    void loadUtilization();
+  }, {
+    context: 'Settings',
+    isActive: !!error && !isLoading
+  });
+  if (error) {
+    return <Box flexDirection="column" gap={1}>
+        <Text color="error">Error: {error}</Text>
+        <Text dimColor>
+          <Byline>
+            <ConfigurableShortcutHint action="settings:retry" context="Settings" fallback="r" description="retry" />
+            <ConfigurableShortcutHint action="confirm:no" context="Settings" fallback="Esc" description="cancel" />
+          </Byline>
+        </Text>
+      </Box>;
+  }
+  if (!utilization) {
+    return <Box flexDirection="column" gap={1}>
+        <Text dimColor>Loading usage data…</Text>
+        <Text dimColor>
+          <ConfigurableShortcutHint action="confirm:no" context="Settings" fallback="Esc" description="cancel" />
+        </Text>
+      </Box>;
+  }
+
+  // Only Max and Team plans have a Sonnet limit that differs from the weekly
+  // limit (see rateLimitMessages.ts). For other plans the bar is redundant.
+  // Show for null (unknown plan) to stay consistent with rateLimitMessages.ts,
+  // which labels it "Sonnet limit" in that case.
+  const subscriptionType = getSubscriptionType();
+  const showSonnetBar = subscriptionType === 'max' || subscriptionType === 'team' || subscriptionType === null;
+  const limits = [{
+    title: 'Current session',
+    limit: utilization.five_hour
+  }, {
+    title: 'Current week (all models)',
+    limit: utilization.seven_day
+  }, ...(showSonnetBar ? [{
+    title: 'Current week (Sonnet only)',
+    limit: utilization.seven_day_sonnet
+  }] : [])];
+  return <Box flexDirection="column" gap={1} width="100%">
+      {limits.some(({
+      limit
+    }) => limit) || <Text dimColor>/usage is only available for subscription plans.</Text>}
+
+      {limits.map(({
+      title,
+      limit: limit_0
+    }) => limit_0 && <LimitBar key={title} title={title} limit={limit_0} maxWidth={maxWidth} />)}
+
+      {utilization.extra_usage && <ExtraUsageSection extraUsage={utilization.extra_usage} maxWidth={maxWidth} />}
+
+      {isEligibleForOverageCreditGrant() && <OverageCreditUpsell maxWidth={maxWidth} />}
+
+      <Text dimColor>
+        <ConfigurableShortcutHint action="confirm:no" context="Settings" fallback="Esc" description="cancel" />
+      </Text>
+    </Box>;
+}
+type ExtraUsageSectionProps = {
+  extraUsage: ExtraUsage;
+  maxWidth: number;
+};
+const EXTRA_USAGE_SECTION_TITLE = 'Extra usage';
+function ExtraUsageSection(t0) {
+  const $ = _c(20);
+  const {
+    extraUsage,
+    maxWidth
+  } = t0;
+  const subscriptionType = getSubscriptionType();
+  const isProOrMax = subscriptionType === "pro" || subscriptionType === "max";
+  if (!isProOrMax) {
+    return false;
+  }
+  if (!extraUsage.is_enabled) {
+    if (extraUsageCommand.isEnabled()) {
+      let t1;
+      if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+        t1 = <Box flexDirection="column"><Text bold={true}>{EXTRA_USAGE_SECTION_TITLE}</Text><Text dimColor={true}>Extra usage not enabled · /extra-usage to enable</Text></Box>;
+        $[0] = t1;
+      } else {
+        t1 = $[0];
+      }
+      return t1;
+    }
+    return null;
+  }
+  if (extraUsage.monthly_limit === null) {
+    let t1;
+    if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = <Box flexDirection="column"><Text bold={true}>{EXTRA_USAGE_SECTION_TITLE}</Text><Text dimColor={true}>Unlimited</Text></Box>;
+      $[1] = t1;
+    } else {
+      t1 = $[1];
+    }
+    return t1;
+  }
+  if (typeof extraUsage.used_credits !== "number" || typeof extraUsage.utilization !== "number") {
+    return null;
+  }
+  const t1 = extraUsage.used_credits / 100;
+  let t2;
+  if ($[2] !== t1) {
+    t2 = formatCost(t1, 2);
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const formattedUsedCredits = t2;
+  const t3 = extraUsage.monthly_limit / 100;
+  let t4;
+  if ($[4] !== t3) {
+    t4 = formatCost(t3, 2);
+    $[4] = t3;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  const formattedMonthlyLimit = t4;
+  let T0;
+  let t5;
+  let t6;
+  let t7;
+  if ($[6] !== extraUsage.utilization) {
+    const now = new Date();
+    const oneMonthReset = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+    T0 = LimitBar;
+    t7 = EXTRA_USAGE_SECTION_TITLE;
+    t5 = extraUsage.utilization;
+    t6 = oneMonthReset.toISOString();
+    $[6] = extraUsage.utilization;
+    $[7] = T0;
+    $[8] = t5;
+    $[9] = t6;
+    $[10] = t7;
+  } else {
+    T0 = $[7];
+    t5 = $[8];
+    t6 = $[9];
+    t7 = $[10];
+  }
+  let t8;
+  if ($[11] !== t5 || $[12] !== t6) {
+    t8 = {
+      utilization: t5,
+      resets_at: t6
+    };
+    $[11] = t5;
+    $[12] = t6;
+    $[13] = t8;
+  } else {
+    t8 = $[13];
+  }
+  const t9 = `${formattedUsedCredits} / ${formattedMonthlyLimit} spent`;
+  let t10;
+  if ($[14] !== T0 || $[15] !== maxWidth || $[16] !== t7 || $[17] !== t8 || $[18] !== t9) {
+    t10 = <T0 title={t7} limit={t8} showTimeInReset={false} extraSubtext={t9} maxWidth={maxWidth} />;
+    $[14] = T0;
+    $[15] = maxWidth;
+    $[16] = t7;
+    $[17] = t8;
+    $[18] = t9;
+    $[19] = t10;
+  } else {
+    t10 = $[19];
+  }
+  return t10;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useState","extraUsage","extraUsageCommand","formatCost","getSubscriptionType","useTerminalSize","Box","Text","useKeybinding","ExtraUsage","fetchUtilization","RateLimit","Utilization","formatResetText","logError","jsonStringify","ConfigurableShortcutHint","Byline","ProgressBar","isEligibleForOverageCreditGrant","OverageCreditUpsell","LimitBarProps","title","limit","maxWidth","showTimeInReset","extraSubtext","LimitBar","t0","$","_c","t1","undefined","utilization","resets_at","usedText","Math","floor","subtext","t2","t3","t4","maxBarWidth","t5","t6","t7","t8","Usage","ReactNode","setUtilization","error","setError","isLoading","setIsLoading","columns","availableWidth","min","loadUtilization","useCallback","data","err","Error","axiosError","response","responseBody","context","isActive","subscriptionType","showSonnetBar","limits","five_hour","seven_day","seven_day_sonnet","some","map","extra_usage","ExtraUsageSectionProps","EXTRA_USAGE_SECTION_TITLE","ExtraUsageSection","isProOrMax","is_enabled","isEnabled","Symbol","for","monthly_limit","used_credits","formattedUsedCredits","formattedMonthlyLimit","T0","now","Date","oneMonthReset","getFullYear","getMonth","toISOString","t9","t10"],"sources":["Usage.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useState } from 'react'\nimport { extraUsage as extraUsageCommand } from 'src/commands/extra-usage/index.js'\nimport { formatCost } from 'src/cost-tracker.js'\nimport { getSubscriptionType } from 'src/utils/auth.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport { Box, Text } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport {\n  type ExtraUsage,\n  fetchUtilization,\n  type RateLimit,\n  type Utilization,\n} from '../../services/api/usage.js'\nimport { formatResetText } from '../../utils/format.js'\nimport { logError } from '../../utils/log.js'\nimport { jsonStringify } from '../../utils/slowOperations.js'\nimport { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js'\nimport { Byline } from '../design-system/Byline.js'\nimport { ProgressBar } from '../design-system/ProgressBar.js'\nimport {\n  isEligibleForOverageCreditGrant,\n  OverageCreditUpsell,\n} from '../LogoV2/OverageCreditUpsell.js'\n\ntype LimitBarProps = {\n  title: string\n  limit: RateLimit\n  maxWidth: number\n  showTimeInReset?: boolean\n  extraSubtext?: string\n}\n\nfunction LimitBar({\n  title,\n  limit,\n  maxWidth,\n  showTimeInReset = true,\n  extraSubtext,\n}: LimitBarProps): React.ReactNode {\n  const { utilization, resets_at } = limit\n  if (utilization === null) {\n    return null\n  }\n\n  // Calculate usage percentage\n  const usedText = `${Math.floor(utilization)}% used`\n\n  let subtext: string | undefined\n  if (resets_at) {\n    subtext = `Resets ${formatResetText(resets_at, true, showTimeInReset)}`\n  }\n\n  if (extraSubtext) {\n    if (subtext) {\n      subtext = `${extraSubtext} · ${subtext}`\n    } else {\n      subtext = extraSubtext\n    }\n  }\n\n  const maxBarWidth = 50\n  const usedLabelSpace = 12\n  if (maxWidth >= maxBarWidth + usedLabelSpace) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>{title}</Text>\n        <Box flexDirection=\"row\" gap={1}>\n          <ProgressBar\n            ratio={utilization / 100}\n            width={maxBarWidth}\n            fillColor=\"rate_limit_fill\"\n            emptyColor=\"rate_limit_empty\"\n          />\n          <Text>{usedText}</Text>\n        </Box>\n        {subtext && <Text dimColor>{subtext}</Text>}\n      </Box>\n    )\n  } else {\n    return (\n      <Box flexDirection=\"column\">\n        <Text>\n          <Text bold>{title}</Text>\n          {subtext && (\n            <>\n              <Text> </Text>\n              <Text dimColor>· {subtext}</Text>\n            </>\n          )}\n        </Text>\n        <ProgressBar\n          ratio={utilization / 100}\n          width={maxWidth}\n          fillColor=\"rate_limit_fill\"\n          emptyColor=\"rate_limit_empty\"\n        />\n        <Text>{usedText}</Text>\n      </Box>\n    )\n  }\n}\n\nexport function Usage(): React.ReactNode {\n  const [utilization, setUtilization] = useState<Utilization | null>(null)\n  const [error, setError] = useState<string | null>(null)\n  const [isLoading, setIsLoading] = useState(true)\n  const { columns } = useTerminalSize()\n\n  const availableWidth = columns - 2 // 2 for screen padding\n  const maxWidth = Math.min(availableWidth, 80)\n\n  const loadUtilization = React.useCallback(async () => {\n    setIsLoading(true)\n    setError(null)\n    try {\n      const data = await fetchUtilization()\n      setUtilization(data)\n    } catch (err) {\n      logError(err as Error)\n      const axiosError = err as { response?: { data?: unknown } }\n      const responseBody = axiosError.response?.data\n        ? jsonStringify(axiosError.response.data)\n        : undefined\n      setError(\n        responseBody\n          ? `Failed to load usage data: ${responseBody}`\n          : 'Failed to load usage data',\n      )\n    } finally {\n      setIsLoading(false)\n    }\n  }, [])\n\n  useEffect(() => {\n    void loadUtilization()\n  }, [loadUtilization])\n\n  useKeybinding(\n    'settings:retry',\n    () => {\n      void loadUtilization()\n    },\n    { context: 'Settings', isActive: !!error && !isLoading },\n  )\n\n  if (error) {\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text color=\"error\">Error: {error}</Text>\n        <Text dimColor>\n          <Byline>\n            <ConfigurableShortcutHint\n              action=\"settings:retry\"\n              context=\"Settings\"\n              fallback=\"r\"\n              description=\"retry\"\n            />\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Settings\"\n              fallback=\"Esc\"\n              description=\"cancel\"\n            />\n          </Byline>\n        </Text>\n      </Box>\n    )\n  }\n\n  if (!utilization) {\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text dimColor>Loading usage data…</Text>\n        <Text dimColor>\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Settings\"\n            fallback=\"Esc\"\n            description=\"cancel\"\n          />\n        </Text>\n      </Box>\n    )\n  }\n\n  // Only Max and Team plans have a Sonnet limit that differs from the weekly\n  // limit (see rateLimitMessages.ts). For other plans the bar is redundant.\n  // Show for null (unknown plan) to stay consistent with rateLimitMessages.ts,\n  // which labels it \"Sonnet limit\" in that case.\n  const subscriptionType = getSubscriptionType()\n  const showSonnetBar =\n    subscriptionType === 'max' ||\n    subscriptionType === 'team' ||\n    subscriptionType === null\n\n  const limits = [\n    {\n      title: 'Current session',\n      limit: utilization.five_hour,\n    },\n    {\n      title: 'Current week (all models)',\n      limit: utilization.seven_day,\n    },\n    ...(showSonnetBar\n      ? [\n          {\n            title: 'Current week (Sonnet only)',\n            limit: utilization.seven_day_sonnet,\n          },\n        ]\n      : []),\n  ]\n\n  return (\n    <Box flexDirection=\"column\" gap={1} width=\"100%\">\n      {limits.some(({ limit }) => limit) || (\n        <Text dimColor>/usage is only available for subscription plans.</Text>\n      )}\n\n      {limits.map(\n        ({ title, limit }) =>\n          limit && (\n            <LimitBar\n              key={title}\n              title={title}\n              limit={limit}\n              maxWidth={maxWidth}\n            />\n          ),\n      )}\n\n      {utilization.extra_usage && (\n        <ExtraUsageSection\n          extraUsage={utilization.extra_usage}\n          maxWidth={maxWidth}\n        />\n      )}\n\n      {isEligibleForOverageCreditGrant() && (\n        <OverageCreditUpsell maxWidth={maxWidth} />\n      )}\n\n      <Text dimColor>\n        <ConfigurableShortcutHint\n          action=\"confirm:no\"\n          context=\"Settings\"\n          fallback=\"Esc\"\n          description=\"cancel\"\n        />\n      </Text>\n    </Box>\n  )\n}\n\ntype ExtraUsageSectionProps = {\n  extraUsage: ExtraUsage\n  maxWidth: number\n}\n\nconst EXTRA_USAGE_SECTION_TITLE = 'Extra usage'\n\nfunction ExtraUsageSection({\n  extraUsage,\n  maxWidth,\n}: ExtraUsageSectionProps): React.ReactNode {\n  const subscriptionType = getSubscriptionType()\n  const isProOrMax = subscriptionType === 'pro' || subscriptionType === 'max'\n  if (!isProOrMax) {\n    // Only show to Pro and Max, consistent with claude.ai non-admin usage settings\n    return false\n  }\n\n  if (!extraUsage.is_enabled) {\n    if (extraUsageCommand.isEnabled()) {\n      return (\n        <Box flexDirection=\"column\">\n          <Text bold>{EXTRA_USAGE_SECTION_TITLE}</Text>\n          <Text dimColor>Extra usage not enabled · /extra-usage to enable</Text>\n        </Box>\n      )\n    }\n\n    return null\n  }\n\n  if (extraUsage.monthly_limit === null) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>{EXTRA_USAGE_SECTION_TITLE}</Text>\n        <Text dimColor>Unlimited</Text>\n      </Box>\n    )\n  }\n\n  if (\n    typeof extraUsage.used_credits !== 'number' ||\n    typeof extraUsage.utilization !== 'number'\n  ) {\n    return null\n  }\n\n  const formattedUsedCredits = formatCost(extraUsage.used_credits / 100, 2)\n  const formattedMonthlyLimit = formatCost(extraUsage.monthly_limit / 100, 2)\n  const now = new Date()\n  const oneMonthReset = new Date(now.getFullYear(), now.getMonth() + 1, 1)\n\n  return (\n    <LimitBar\n      title={EXTRA_USAGE_SECTION_TITLE}\n      limit={{\n        utilization: extraUsage.utilization,\n        // Not applicable for enterprises, but for now we don't render this for them\n        resets_at: oneMonthReset.toISOString(),\n      }}\n      showTimeInReset={false}\n      extraSubtext={`${formattedUsedCredits} / ${formattedMonthlyLimit} spent`}\n      maxWidth={maxWidth}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/components/Spinner/SpinnerGlyph.tsx

@@ -0,0 +1,80 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { Box, Text, useTheme } from '../../ink.js';
+import { getTheme, type Theme } from '../../utils/theme.js';
+import { getDefaultCharacters, interpolateColor, parseRGB, toRGBColor } from './utils.js';
+const DEFAULT_CHARACTERS = getDefaultCharacters();
+const SPINNER_FRAMES = [...DEFAULT_CHARACTERS, ...[...DEFAULT_CHARACTERS].reverse()];
+const REDUCED_MOTION_DOT = '●';
+const REDUCED_MOTION_CYCLE_MS = 2000; // 2-second cycle: 1s visible, 1s dim
+const ERROR_RED = {
+  r: 171,
+  g: 43,
+  b: 63
+};
+type Props = {
+  frame: number;
+  messageColor: keyof Theme;
+  stalledIntensity?: number;
+  reducedMotion?: boolean;
+  time?: number;
+};
+export function SpinnerGlyph(t0) {
+  const $ = _c(9);
+  const {
+    frame,
+    messageColor,
+    stalledIntensity: t1,
+    reducedMotion: t2,
+    time: t3
+  } = t0;
+  const stalledIntensity = t1 === undefined ? 0 : t1;
+  const reducedMotion = t2 === undefined ? false : t2;
+  const time = t3 === undefined ? 0 : t3;
+  const [themeName] = useTheme();
+  const theme = getTheme(themeName);
+  if (reducedMotion) {
+    const isDim = Math.floor(time / (REDUCED_MOTION_CYCLE_MS / 2)) % 2 === 1;
+    let t4;
+    if ($[0] !== isDim || $[1] !== messageColor) {
+      t4 = <Box flexWrap="wrap" height={1} width={2}><Text color={messageColor} dimColor={isDim}>{REDUCED_MOTION_DOT}</Text></Box>;
+      $[0] = isDim;
+      $[1] = messageColor;
+      $[2] = t4;
+    } else {
+      t4 = $[2];
+    }
+    return t4;
+  }
+  const spinnerChar = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+  if (stalledIntensity > 0) {
+    const baseColorStr = theme[messageColor];
+    const baseRGB = baseColorStr ? parseRGB(baseColorStr) : null;
+    if (baseRGB) {
+      const interpolated = interpolateColor(baseRGB, ERROR_RED, stalledIntensity);
+      return <Box flexWrap="wrap" height={1} width={2}><Text color={toRGBColor(interpolated)}>{spinnerChar}</Text></Box>;
+    }
+    const color = stalledIntensity > 0.5 ? "error" : messageColor;
+    let t4;
+    if ($[3] !== color || $[4] !== spinnerChar) {
+      t4 = <Box flexWrap="wrap" height={1} width={2}><Text color={color}>{spinnerChar}</Text></Box>;
+      $[3] = color;
+      $[4] = spinnerChar;
+      $[5] = t4;
+    } else {
+      t4 = $[5];
+    }
+    return t4;
+  }
+  let t4;
+  if ($[6] !== messageColor || $[7] !== spinnerChar) {
+    t4 = <Box flexWrap="wrap" height={1} width={2}><Text color={messageColor}>{spinnerChar}</Text></Box>;
+    $[6] = messageColor;
+    $[7] = spinnerChar;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  return t4;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/Spinner/TeammateSpinnerLine.tsx

@@ -0,0 +1,233 @@
+import figures from 'figures';
+import sample from 'lodash-es/sample.js';
+import * as React from 'react';
+import { useRef, useState } from 'react';
+import { getSpinnerVerbs } from '../../constants/spinnerVerbs.js';
+import { TURN_COMPLETION_VERBS } from '../../constants/turnCompletionVerbs.js';
+import { useElapsedTime } from '../../hooks/useElapsedTime.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import { stringWidth } from '../../ink/stringWidth.js';
+import { Box, Text } from '../../ink.js';
+import type { InProcessTeammateTaskState } from '../../tasks/InProcessTeammateTask/types.js';
+import { summarizeRecentActivities } from '../../utils/collapseReadSearch.js';
+import { formatDuration, formatNumber, truncateToWidth } from '../../utils/format.js';
+import { toInkColor } from '../../utils/ink.js';
+import { TEAMMATE_SELECT_HINT } from './teammateSelectHint.js';
+type Props = {
+  teammate: InProcessTeammateTaskState;
+  isLast: boolean;
+  isSelected?: boolean;
+  isForegrounded?: boolean;
+  allIdle?: boolean;
+  showPreview?: boolean;
+};
+
+/**
+ * Extract the last 3 lines of content from a teammate's conversation.
+ * Shows recent activity from any message type (user or assistant).
+ */
+function getMessagePreview(messages: InProcessTeammateTaskState['messages']): string[] {
+  if (!messages?.length) return [];
+  const allLines: string[] = [];
+  const maxLineLength = 80;
+
+  // Collect lines from recent messages (newest first)
+  for (let i = messages.length - 1; i >= 0 && allLines.length < 3; i--) {
+    const msg = messages[i];
+    // Only process messages that have content (user/assistant messages)
+    if (!msg || msg.type !== 'user' && msg.type !== 'assistant' || !msg.message?.content?.length) {
+      continue;
+    }
+    const content = msg.message.content;
+    for (const block of content) {
+      if (allLines.length >= 3) break;
+      if (!block || typeof block !== 'object') continue;
+      if ('type' in block && block.type === 'tool_use' && 'name' in block) {
+        // Try to show meaningful info from tool input
+        const input = 'input' in block ? block.input as Record<string, unknown> : null;
+        let toolLine = `Using ${block.name}…`;
+        if (input) {
+          // Look for common descriptive fields
+          const desc = input.description as string | undefined || input.prompt as string | undefined || input.command as string | undefined || input.query as string | undefined || input.pattern as string | undefined;
+          if (desc) {
+            toolLine = desc.split('\n')[0] ?? toolLine;
+          }
+        }
+        allLines.push(truncateToWidth(toolLine, maxLineLength));
+      } else if ('type' in block && block.type === 'text' && 'text' in block) {
+        const textLines = (block.text as string).split('\n').filter(l => l.trim());
+        // Take from end of text (most recent lines)
+        for (let j = textLines.length - 1; j >= 0 && allLines.length < 3; j--) {
+          const line = textLines[j];
+          if (!line) continue;
+          allLines.push(truncateToWidth(line, maxLineLength));
+        }
+      }
+    }
+  }
+
+  // Reverse so oldest of the 3 is first (reading order)
+  return allLines.reverse();
+}
+export function TeammateSpinnerLine({
+  teammate,
+  isLast,
+  isSelected,
+  isForegrounded,
+  allIdle,
+  showPreview
+}: Props): React.ReactNode {
+  const [randomVerb] = useState(() => teammate.spinnerVerb ?? sample(getSpinnerVerbs()));
+  const [pastTenseVerb] = useState(() => teammate.pastTenseVerb ?? sample(TURN_COMPLETION_VERBS));
+  const isHighlighted = isSelected || isForegrounded;
+  const treeChar = isHighlighted ? isLast ? '╘═' : '╞═' : isLast ? '└─' : '├─';
+  const nameColor = toInkColor(teammate.identity.color);
+  const {
+    columns
+  } = useTerminalSize();
+
+  // Track when teammate became idle (for "Idle for X..." display)
+  const idleStartRef = useRef<number | null>(null);
+  // Freeze elapsed time when entering all-idle state
+  const frozenDurationRef = useRef<string | null>(null);
+
+  // Track idle start time
+  if (teammate.isIdle && idleStartRef.current === null) {
+    idleStartRef.current = Date.now();
+  } else if (!teammate.isIdle) {
+    idleStartRef.current = null;
+  }
+
+  // Reset frozen duration when leaving all-idle state
+  if (!allIdle && frozenDurationRef.current !== null) {
+    frozenDurationRef.current = null;
+  }
+
+  // Get elapsed idle time (how long they've been idle) - for "Idle for X..." display
+  const idleElapsedTime = useElapsedTime(idleStartRef.current ?? Date.now(), teammate.isIdle && !allIdle);
+
+  // Freeze the duration when we first detect all idle
+  // Use the teammate's actual work time (since task started) for the past-tense display
+  if (allIdle && frozenDurationRef.current === null) {
+    frozenDurationRef.current = formatDuration(Math.max(0, Date.now() - teammate.startTime - (teammate.totalPausedMs ?? 0)));
+  }
+
+  // Use frozen work duration when all idle, otherwise use idle elapsed time
+  const displayTime = allIdle ? frozenDurationRef.current ?? (() => {
+    throw new Error(`frozenDurationRef is null for idle teammate ${teammate.identity.agentName}`);
+  })() : idleElapsedTime;
+
+  // Layout: paddingLeft(3) + pointer(1) + space(1) + treeChar(2) + space(1) = 8 fixed chars
+  // Then optionally: @name + ": " OR just ": "
+  // Then: activity text + optional extras (stats, hints)
+  const basePrefix = 8;
+  const fullAgentName = `@${teammate.identity.agentName}`;
+  const fullNameWidth = stringWidth(fullAgentName);
+
+  // Get stats from progress
+  const toolUseCount = teammate.progress?.toolUseCount ?? 0;
+  const tokenCount = teammate.progress?.tokenCount ?? 0;
+  const statsText = ` · ${toolUseCount} tool ${toolUseCount === 1 ? 'use' : 'uses'} · ${formatNumber(tokenCount)} tokens`;
+  const statsWidth = stringWidth(statsText);
+  const selectHintText = ` · ${TEAMMATE_SELECT_HINT}`;
+  const selectHintWidth = stringWidth(selectHintText);
+  const viewHintText = ' · enter to view';
+  const viewHintWidth = stringWidth(viewHintText);
+
+  // Progressive responsive layout:
+  // Wide (80+): full name + activity + stats + hint
+  // Medium (60-80): full name + activity
+  // Narrow (<60): hide name, just show activity
+  const minActivityWidth = 25;
+
+  // Hide name on narrow terminals (< 60 cols) or if there's not enough room
+  const spaceWithFullName = columns - basePrefix - fullNameWidth - 2;
+  const showName = columns >= 60 && spaceWithFullName >= minActivityWidth;
+  const nameWidth = showName ? fullNameWidth + 2 : 0; // +2 for ": " when name shown
+  const availableForActivity = columns - basePrefix - nameWidth;
+
+  // Progressive hiding: view hint → select hint → stats
+  // Stats always visible (dimmed when not selected); hints only when highlighted/selected
+  const showViewHint = isSelected && !isForegrounded && availableForActivity > viewHintWidth + statsWidth + minActivityWidth + 5;
+  const showSelectHint = isHighlighted && availableForActivity > selectHintWidth + (showViewHint ? viewHintWidth : 0) + statsWidth + minActivityWidth + 5;
+  const showStats = availableForActivity > statsWidth + minActivityWidth + 5;
+
+  // Activity text gets remaining space
+  const extrasCost = (showStats ? statsWidth : 0) + (showSelectHint ? selectHintWidth : 0) + (showViewHint ? viewHintWidth : 0);
+  const activityMaxWidth = Math.max(minActivityWidth, availableForActivity - extrasCost - 1);
+
+  // Format the activity text for active teammates, rolling up search/read ops
+  const activityText = (() => {
+    const activities = teammate.progress?.recentActivities;
+    if (activities && activities.length > 0) {
+      const summary = summarizeRecentActivities(activities);
+      if (summary) return truncateToWidth(summary, activityMaxWidth);
+    }
+    const desc = teammate.progress?.lastActivity?.activityDescription;
+    if (desc) return truncateToWidth(desc, activityMaxWidth);
+    return randomVerb;
+  })();
+
+  // Status rendering logic
+  const renderStatus = (): React.ReactNode => {
+    if (teammate.shutdownRequested) {
+      return <Text dimColor>[stopping]</Text>;
+    }
+    if (teammate.awaitingPlanApproval) {
+      return <Text color="warning">[awaiting approval]</Text>;
+    }
+    if (teammate.isIdle) {
+      if (allIdle) {
+        return <Text dimColor>
+            {pastTenseVerb} for {displayTime}
+          </Text>;
+      }
+      return <Text dimColor>Idle for {idleElapsedTime}</Text>;
+    }
+    // Active - show spinner glyph + activity description (only when not highlighted;
+    // when highlighted, the main spinner above already shows the verb)
+    if (isHighlighted) {
+      return null;
+    }
+    return <Text dimColor>
+        {activityText?.endsWith('…') ? activityText : `${activityText}…`}
+      </Text>;
+  };
+
+  // Get preview lines if enabled
+  const previewLines = showPreview ? getMessagePreview(teammate.messages) : [];
+
+  // Tree continuation character for preview lines
+  const previewTreeChar = isLast ? '   ' : '│  ';
+  return <Box flexDirection="column">
+      <Box paddingLeft={3}>
+        {/* Selection indicator: pointer when selected, otherwise space */}
+        <Text color={isSelected ? 'suggestion' : undefined} bold={isSelected}>
+          {isSelected ? figures.pointer : ' '}
+        </Text>
+        <Text dimColor={!isSelected}>{treeChar} </Text>
+        {/* Agent name: hidden on very narrow screens */}
+        {showName && <Text color={isSelected ? 'suggestion' : nameColor}>
+            @{teammate.identity.agentName}
+          </Text>}
+        {showName && <Text dimColor={!isSelected}>: </Text>}
+        {renderStatus()}
+        {/* Stats: only shown when selected and terminal is wide enough */}
+        {showStats && <Text dimColor>
+            {' '}
+            · {toolUseCount} tool {toolUseCount === 1 ? 'use' : 'uses'} ·{' '}
+            {formatNumber(tokenCount)} tokens
+          </Text>}
+        {/* Hints: select hint when highlighted, view hint when selected but not foregrounded */}
+        {showSelectHint && <Text dimColor> · {TEAMMATE_SELECT_HINT}</Text>}
+        {showViewHint && <Text dimColor> · enter to view</Text>}
+      </Box>
+      {/* Preview lines */}
+      {previewLines.map((line, idx) => <Box key={idx} paddingLeft={3}>
+          <Text dimColor> </Text>
+          <Text dimColor>{previewTreeChar} </Text>
+          <Text dimColor>{line}</Text>
+        </Box>)}
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","sample","React","useRef","useState","getSpinnerVerbs","TURN_COMPLETION_VERBS","useElapsedTime","useTerminalSize","stringWidth","Box","Text","InProcessTeammateTaskState","summarizeRecentActivities","formatDuration","formatNumber","truncateToWidth","toInkColor","TEAMMATE_SELECT_HINT","Props","teammate","isLast","isSelected","isForegrounded","allIdle","showPreview","getMessagePreview","messages","length","allLines","maxLineLength","i","msg","type","message","content","block","input","Record","toolLine","name","desc","description","prompt","command","query","pattern","split","push","textLines","text","filter","l","trim","j","line","reverse","TeammateSpinnerLine","ReactNode","randomVerb","spinnerVerb","pastTenseVerb","isHighlighted","treeChar","nameColor","identity","color","columns","idleStartRef","frozenDurationRef","isIdle","current","Date","now","idleElapsedTime","Math","max","startTime","totalPausedMs","displayTime","Error","agentName","basePrefix","fullAgentName","fullNameWidth","toolUseCount","progress","tokenCount","statsText","statsWidth","selectHintText","selectHintWidth","viewHintText","viewHintWidth","minActivityWidth","spaceWithFullName","showName","nameWidth","availableForActivity","showViewHint","showSelectHint","showStats","extrasCost","activityMaxWidth","activityText","activities","recentActivities","summary","lastActivity","activityDescription","renderStatus","shutdownRequested","awaitingPlanApproval","endsWith","previewLines","previewTreeChar","undefined","pointer","map","idx"],"sources":["TeammateSpinnerLine.tsx"],"sourcesContent":["import figures from 'figures'\nimport sample from 'lodash-es/sample.js'\nimport * as React from 'react'\nimport { useRef, useState } from 'react'\nimport { getSpinnerVerbs } from '../../constants/spinnerVerbs.js'\nimport { TURN_COMPLETION_VERBS } from '../../constants/turnCompletionVerbs.js'\nimport { useElapsedTime } from '../../hooks/useElapsedTime.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport { stringWidth } from '../../ink/stringWidth.js'\nimport { Box, Text } from '../../ink.js'\nimport type { InProcessTeammateTaskState } from '../../tasks/InProcessTeammateTask/types.js'\nimport { summarizeRecentActivities } from '../../utils/collapseReadSearch.js'\nimport {\n  formatDuration,\n  formatNumber,\n  truncateToWidth,\n} from '../../utils/format.js'\nimport { toInkColor } from '../../utils/ink.js'\nimport { TEAMMATE_SELECT_HINT } from './teammateSelectHint.js'\n\ntype Props = {\n  teammate: InProcessTeammateTaskState\n  isLast: boolean\n  isSelected?: boolean\n  isForegrounded?: boolean\n  allIdle?: boolean\n  showPreview?: boolean\n}\n\n/**\n * Extract the last 3 lines of content from a teammate's conversation.\n * Shows recent activity from any message type (user or assistant).\n */\nfunction getMessagePreview(\n  messages: InProcessTeammateTaskState['messages'],\n): string[] {\n  if (!messages?.length) return []\n\n  const allLines: string[] = []\n  const maxLineLength = 80\n\n  // Collect lines from recent messages (newest first)\n  for (let i = messages.length - 1; i >= 0 && allLines.length < 3; i--) {\n    const msg = messages[i]\n    // Only process messages that have content (user/assistant messages)\n    if (\n      !msg ||\n      (msg.type !== 'user' && msg.type !== 'assistant') ||\n      !msg.message?.content?.length\n    ) {\n      continue\n    }\n    const content = msg.message.content\n\n    for (const block of content) {\n      if (allLines.length >= 3) break\n      if (!block || typeof block !== 'object') continue\n\n      if ('type' in block && block.type === 'tool_use' && 'name' in block) {\n        // Try to show meaningful info from tool input\n        const input =\n          'input' in block ? (block.input as Record<string, unknown>) : null\n        let toolLine = `Using ${block.name}…`\n        if (input) {\n          // Look for common descriptive fields\n          const desc =\n            (input.description as string | undefined) ||\n            (input.prompt as string | undefined) ||\n            (input.command as string | undefined) ||\n            (input.query as string | undefined) ||\n            (input.pattern as string | undefined)\n          if (desc) {\n            toolLine = desc.split('\\n')[0] ?? toolLine\n          }\n        }\n        allLines.push(truncateToWidth(toolLine, maxLineLength))\n      } else if ('type' in block && block.type === 'text' && 'text' in block) {\n        const textLines = (block.text as string)\n          .split('\\n')\n          .filter(l => l.trim())\n        // Take from end of text (most recent lines)\n        for (let j = textLines.length - 1; j >= 0 && allLines.length < 3; j--) {\n          const line = textLines[j]\n          if (!line) continue\n          allLines.push(truncateToWidth(line, maxLineLength))\n        }\n      }\n    }\n  }\n\n  // Reverse so oldest of the 3 is first (reading order)\n  return allLines.reverse()\n}\n\nexport function TeammateSpinnerLine({\n  teammate,\n  isLast,\n  isSelected,\n  isForegrounded,\n  allIdle,\n  showPreview,\n}: Props): React.ReactNode {\n  const [randomVerb] = useState(\n    () => teammate.spinnerVerb ?? sample(getSpinnerVerbs()),\n  )\n  const [pastTenseVerb] = useState(\n    () => teammate.pastTenseVerb ?? sample(TURN_COMPLETION_VERBS),\n  )\n  const isHighlighted = isSelected || isForegrounded\n  const treeChar = isHighlighted ? (isLast ? '╘═' : '╞═') : isLast ? '└─' : '├─'\n  const nameColor = toInkColor(teammate.identity.color)\n  const { columns } = useTerminalSize()\n\n  // Track when teammate became idle (for \"Idle for X...\" display)\n  const idleStartRef = useRef<number | null>(null)\n  // Freeze elapsed time when entering all-idle state\n  const frozenDurationRef = useRef<string | null>(null)\n\n  // Track idle start time\n  if (teammate.isIdle && idleStartRef.current === null) {\n    idleStartRef.current = Date.now()\n  } else if (!teammate.isIdle) {\n    idleStartRef.current = null\n  }\n\n  // Reset frozen duration when leaving all-idle state\n  if (!allIdle && frozenDurationRef.current !== null) {\n    frozenDurationRef.current = null\n  }\n\n  // Get elapsed idle time (how long they've been idle) - for \"Idle for X...\" display\n  const idleElapsedTime = useElapsedTime(\n    idleStartRef.current ?? Date.now(),\n    teammate.isIdle && !allIdle,\n  )\n\n  // Freeze the duration when we first detect all idle\n  // Use the teammate's actual work time (since task started) for the past-tense display\n  if (allIdle && frozenDurationRef.current === null) {\n    frozenDurationRef.current = formatDuration(\n      Math.max(\n        0,\n        Date.now() - teammate.startTime - (teammate.totalPausedMs ?? 0),\n      ),\n    )\n  }\n\n  // Use frozen work duration when all idle, otherwise use idle elapsed time\n  const displayTime = allIdle\n    ? (frozenDurationRef.current ??\n      (() => {\n        throw new Error(\n          `frozenDurationRef is null for idle teammate ${teammate.identity.agentName}`,\n        )\n      })())\n    : idleElapsedTime\n\n  // Layout: paddingLeft(3) + pointer(1) + space(1) + treeChar(2) + space(1) = 8 fixed chars\n  // Then optionally: @name + \": \" OR just \": \"\n  // Then: activity text + optional extras (stats, hints)\n  const basePrefix = 8\n  const fullAgentName = `@${teammate.identity.agentName}`\n  const fullNameWidth = stringWidth(fullAgentName)\n\n  // Get stats from progress\n  const toolUseCount = teammate.progress?.toolUseCount ?? 0\n  const tokenCount = teammate.progress?.tokenCount ?? 0\n  const statsText = ` · ${toolUseCount} tool ${toolUseCount === 1 ? 'use' : 'uses'} · ${formatNumber(tokenCount)} tokens`\n  const statsWidth = stringWidth(statsText)\n  const selectHintText = ` · ${TEAMMATE_SELECT_HINT}`\n  const selectHintWidth = stringWidth(selectHintText)\n  const viewHintText = ' · enter to view'\n  const viewHintWidth = stringWidth(viewHintText)\n\n  // Progressive responsive layout:\n  // Wide (80+): full name + activity + stats + hint\n  // Medium (60-80): full name + activity\n  // Narrow (<60): hide name, just show activity\n  const minActivityWidth = 25\n\n  // Hide name on narrow terminals (< 60 cols) or if there's not enough room\n  const spaceWithFullName = columns - basePrefix - fullNameWidth - 2\n  const showName = columns >= 60 && spaceWithFullName >= minActivityWidth\n  const nameWidth = showName ? fullNameWidth + 2 : 0 // +2 for \": \" when name shown\n  const availableForActivity = columns - basePrefix - nameWidth\n\n  // Progressive hiding: view hint → select hint → stats\n  // Stats always visible (dimmed when not selected); hints only when highlighted/selected\n  const showViewHint =\n    isSelected &&\n    !isForegrounded &&\n    availableForActivity > viewHintWidth + statsWidth + minActivityWidth + 5\n  const showSelectHint =\n    isHighlighted &&\n    availableForActivity >\n      selectHintWidth +\n        (showViewHint ? viewHintWidth : 0) +\n        statsWidth +\n        minActivityWidth +\n        5\n  const showStats = availableForActivity > statsWidth + minActivityWidth + 5\n\n  // Activity text gets remaining space\n  const extrasCost =\n    (showStats ? statsWidth : 0) +\n    (showSelectHint ? selectHintWidth : 0) +\n    (showViewHint ? viewHintWidth : 0)\n  const activityMaxWidth = Math.max(\n    minActivityWidth,\n    availableForActivity - extrasCost - 1,\n  )\n\n  // Format the activity text for active teammates, rolling up search/read ops\n  const activityText = (() => {\n    const activities = teammate.progress?.recentActivities\n    if (activities && activities.length > 0) {\n      const summary = summarizeRecentActivities(activities)\n      if (summary) return truncateToWidth(summary, activityMaxWidth)\n    }\n    const desc = teammate.progress?.lastActivity?.activityDescription\n    if (desc) return truncateToWidth(desc, activityMaxWidth)\n    return randomVerb\n  })()\n\n  // Status rendering logic\n  const renderStatus = (): React.ReactNode => {\n    if (teammate.shutdownRequested) {\n      return <Text dimColor>[stopping]</Text>\n    }\n    if (teammate.awaitingPlanApproval) {\n      return <Text color=\"warning\">[awaiting approval]</Text>\n    }\n    if (teammate.isIdle) {\n      if (allIdle) {\n        return (\n          <Text dimColor>\n            {pastTenseVerb} for {displayTime}\n          </Text>\n        )\n      }\n      return <Text dimColor>Idle for {idleElapsedTime}</Text>\n    }\n    // Active - show spinner glyph + activity description (only when not highlighted;\n    // when highlighted, the main spinner above already shows the verb)\n    if (isHighlighted) {\n      return null\n    }\n    return (\n      <Text dimColor>\n        {activityText?.endsWith('…') ? activityText : `${activityText}…`}\n      </Text>\n    )\n  }\n\n  // Get preview lines if enabled\n  const previewLines = showPreview ? getMessagePreview(teammate.messages) : []\n\n  // Tree continuation character for preview lines\n  const previewTreeChar = isLast ? '   ' : '│  '\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box paddingLeft={3}>\n        {/* Selection indicator: pointer when selected, otherwise space */}\n        <Text color={isSelected ? 'suggestion' : undefined} bold={isSelected}>\n          {isSelected ? figures.pointer : ' '}\n        </Text>\n        <Text dimColor={!isSelected}>{treeChar} </Text>\n        {/* Agent name: hidden on very narrow screens */}\n        {showName && (\n          <Text color={isSelected ? 'suggestion' : nameColor}>\n            @{teammate.identity.agentName}\n          </Text>\n        )}\n        {showName && <Text dimColor={!isSelected}>: </Text>}\n        {renderStatus()}\n        {/* Stats: only shown when selected and terminal is wide enough */}\n        {showStats && (\n          <Text dimColor>\n            {' '}\n            · {toolUseCount} tool {toolUseCount === 1 ? 'use' : 'uses'} ·{' '}\n            {formatNumber(tokenCount)} tokens\n          </Text>\n        )}\n        {/* Hints: select hint when highlighted, view hint when selected but not foregrounded */}\n        {showSelectHint && <Text dimColor> · {TEAMMATE_SELECT_HINT}</Text>}\n        {showViewHint && <Text dimColor> · enter to view</Text>}\n      </Box>\n      {/* Preview lines */}\n      {previewLines.map((line, idx) => (\n        <Box key={idx} paddingLeft={3}>\n          <Text dimColor> </Text>\n          <Text dimColor>{previewTreeChar} </Text>\n          <Text dimColor>{line}</Text>\n        </Box>\n      ))}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/components/Spinner/index.ts

@@ -0,0 +1,10 @@
+export { FlashingChar } from './FlashingChar.js'
+export { GlimmerMessage } from './GlimmerMessage.js'
+export { ShimmerChar } from './ShimmerChar.js'
+export { SpinnerGlyph } from './SpinnerGlyph.js'
+export type { SpinnerMode } from './types.js'
+export { useShimmerAnimation } from './useShimmerAnimation.js'
+export { useStalledAnimation } from './useStalledAnimation.js'
+export { getDefaultCharacters, interpolateColor } from './utils.js'
+// Teammate components are NOT exported here - use dynamic require() to enable dead code elimination
+// See REPL.tsx and Spinner.tsx for the correct import pattern

src/components/Spinner/useShimmerAnimation.ts

@@ -0,0 +1,31 @@
+import { useMemo } from 'react'
+import { stringWidth } from '../../ink/stringWidth.js'
+import { type DOMElement, useAnimationFrame } from '../../ink.js'
+import type { SpinnerMode } from './types.js'
+
+export function useShimmerAnimation(
+  mode: SpinnerMode,
+  message: string,
+  isStalled: boolean,
+): [ref: (element: DOMElement | null) => void, glimmerIndex: number] {
+  const glimmerSpeed = mode === 'requesting' ? 50 : 200
+  // Pass null when stalled to unsubscribe from the clock — otherwise the
+  // setInterval keeps firing at 20fps even when the shimmer isn't visible.
+  // Notably, if the caller never attaches `ref` (e.g. conditional JSX),
+  // useTerminalViewport stays at its initial isVisible:true and the
+  // viewport-pause never kicks in, so this is the only stop mechanism.
+  const [ref, time] = useAnimationFrame(isStalled ? null : glimmerSpeed)
+  const messageWidth = useMemo(() => stringWidth(message), [message])
+
+  if (isStalled) {
+    return [ref, -100]
+  }
+
+  const cyclePosition = Math.floor(time / glimmerSpeed)
+  const cycleLength = messageWidth + 20
+
+  if (mode === 'requesting') {
+    return [ref, (cyclePosition % cycleLength) - 10]
+  }
+  return [ref, messageWidth + 10 - (cyclePosition % cycleLength)]
+}

src/components/Spinner/utils.ts

@@ -0,0 +1,84 @@
+import type { RGBColor as RGBColorString } from '../../ink/styles.js'
+import type { RGBColor as RGBColorType } from './types.js'
+
+export function getDefaultCharacters(): string[] {
+  if (process.env.TERM === 'xterm-ghostty') {
+    return ['·', '✢', '✳', '✶', '✻', '*'] // Use * instead of ✽ for Ghostty because the latter renders in a way that's slightly offset
+  }
+  return process.platform === 'darwin'
+    ? ['·', '✢', '✳', '✶', '✻', '✽']
+    : ['·', '✢', '*', '✶', '✻', '✽']
+}
+
+// Interpolate between two RGB colors
+export function interpolateColor(
+  color1: RGBColorType,
+  color2: RGBColorType,
+  t: number, // 0 to 1
+): RGBColorType {
+  return {
+    r: Math.round(color1.r + (color2.r - color1.r) * t),
+    g: Math.round(color1.g + (color2.g - color1.g) * t),
+    b: Math.round(color1.b + (color2.b - color1.b) * t),
+  }
+}
+
+// Convert RGB object to rgb() color string for Text component
+export function toRGBColor(color: RGBColorType): RGBColorString {
+  return `rgb(${color.r},${color.g},${color.b})`
+}
+
+// HSL hue (0-360) to RGB, using voice-mode waveform parameters (s=0.7, l=0.6).
+export function hueToRgb(hue: number): RGBColorType {
+  const h = ((hue % 360) + 360) % 360
+  const s = 0.7
+  const l = 0.6
+  const c = (1 - Math.abs(2 * l - 1)) * s
+  const x = c * (1 - Math.abs(((h / 60) % 2) - 1))
+  const m = l - c / 2
+  let r = 0
+  let g = 0
+  let b = 0
+  if (h < 60) {
+    r = c
+    g = x
+  } else if (h < 120) {
+    r = x
+    g = c
+  } else if (h < 180) {
+    g = c
+    b = x
+  } else if (h < 240) {
+    g = x
+    b = c
+  } else if (h < 300) {
+    r = x
+    b = c
+  } else {
+    r = c
+    b = x
+  }
+  return {
+    r: Math.round((r + m) * 255),
+    g: Math.round((g + m) * 255),
+    b: Math.round((b + m) * 255),
+  }
+}
+
+const RGB_CACHE = new Map<string, RGBColorType | null>()
+
+export function parseRGB(colorStr: string): RGBColorType | null {
+  const cached = RGB_CACHE.get(colorStr)
+  if (cached !== undefined) return cached
+
+  const match = colorStr.match(/rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/)
+  const result = match
+    ? {
+        r: parseInt(match[1]!, 10),
+        g: parseInt(match[2]!, 10),
+        b: parseInt(match[3]!, 10),
+      }
+    : null
+  RGB_CACHE.set(colorStr, result)
+  return result
+}

src/components/StructuredDiff/Fallback.tsx

@@ -0,0 +1,487 @@
+import { c as _c } from "react/compiler-runtime";
+import { diffWordsWithSpace, type StructuredPatchHunk } from 'diff';
+import * as React from 'react';
+import { useMemo } from 'react';
+import type { ThemeName } from 'src/utils/theme.js';
+import { stringWidth } from '../../ink/stringWidth.js';
+import { Box, NoSelect, Text, useTheme, wrapText } from '../../ink.js';
+
+/*
+ * StructuredDiffFallback Component: Word-Level Diff Highlighting Example
+ *
+ * This component shows diff changes with word-level highlighting. Here's a walkthrough:
+ *
+ * Example:
+ * ```
+ * // Original code
+ * function oldName(param) {
+ *   return param.oldProperty;
+ * }
+ *
+ * // Changed code
+ * function newName(param) {
+ *   return param.newProperty;
+ * }
+ * ```
+ *
+ * Processing flow:
+ * 1. Component receives a patch with lines including '+' and '-' prefixes
+ * 2. Lines are transformed into objects with type (add/remove/nochange)
+ * 3. Related add/remove lines are paired (e.g., oldName with newName)
+ * 4. Word-level diffing identifies specific changed parts:
+ *    [
+ *      { value: 'function ', added: undefined, removed: undefined },  // Common
+ *      { value: 'oldName', removed: true },                           // Removed
+ *      { value: 'newName', added: true },                             // Added
+ *      { value: '(param) {', added: undefined, removed: undefined }   // Common
+ *    ]
+ * 5. Renders with enhanced highlighting:
+ *    - Common parts are shown normally
+ *    - Removed words get a darker red background
+ *    - Added words get a darker green background
+ *
+ * This produces a visually clear diff where users can see exactly which words
+ * changed rather than just which lines were modified.
+ */
+
+// Define DiffLine interface to be used throughout the file
+interface DiffLine {
+  code: string;
+  type: 'add' | 'remove' | 'nochange';
+  i: number;
+  originalCode: string;
+  wordDiff?: boolean; // Flag for word-level diffing
+  matchedLine?: DiffLine;
+}
+
+// Line object type for internal functions
+export interface LineObject {
+  code: string;
+  i: number;
+  type: 'add' | 'remove' | 'nochange';
+  originalCode: string;
+  wordDiff?: boolean;
+  matchedLine?: LineObject;
+}
+
+// Type for word-level diff parts
+interface DiffPart {
+  added?: boolean;
+  removed?: boolean;
+  value: string;
+}
+type Props = {
+  patch: StructuredPatchHunk;
+  dim: boolean;
+  width: number;
+};
+
+// Threshold for when we show a full-line diff instead of word-level diffing
+const CHANGE_THRESHOLD = 0.4;
+export function StructuredDiffFallback(t0) {
+  const $ = _c(10);
+  const {
+    patch,
+    dim,
+    width
+  } = t0;
+  const [theme] = useTheme();
+  let t1;
+  if ($[0] !== dim || $[1] !== patch.lines || $[2] !== patch.oldStart || $[3] !== theme || $[4] !== width) {
+    t1 = formatDiff(patch.lines, patch.oldStart, width, dim, theme);
+    $[0] = dim;
+    $[1] = patch.lines;
+    $[2] = patch.oldStart;
+    $[3] = theme;
+    $[4] = width;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const diff = t1;
+  let t2;
+  if ($[6] !== diff) {
+    t2 = diff.map(_temp);
+    $[6] = diff;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  let t3;
+  if ($[8] !== t2) {
+    t3 = <Box flexDirection="column" flexGrow={1}>{t2}</Box>;
+    $[8] = t2;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  return t3;
+}
+
+// Transform lines to line objects with type information
+function _temp(node, i) {
+  return <Box key={i}>{node}</Box>;
+}
+export function transformLinesToObjects(lines: string[]): LineObject[] {
+  return lines.map(code => {
+    if (code.startsWith('+')) {
+      return {
+        code: code.slice(1),
+        i: 0,
+        type: 'add',
+        originalCode: code.slice(1)
+      };
+    }
+    if (code.startsWith('-')) {
+      return {
+        code: code.slice(1),
+        i: 0,
+        type: 'remove',
+        originalCode: code.slice(1)
+      };
+    }
+    return {
+      code: code.slice(1),
+      i: 0,
+      type: 'nochange',
+      originalCode: code.slice(1)
+    };
+  });
+}
+
+// Group adjacent add/remove lines for word-level diffing
+export function processAdjacentLines(lineObjects: LineObject[]): LineObject[] {
+  const processedLines: LineObject[] = [];
+  let i = 0;
+  while (i < lineObjects.length) {
+    const current = lineObjects[i];
+    if (!current) {
+      i++;
+      continue;
+    }
+
+    // Find a sequence of remove followed by add (possible word-level diff candidates)
+    if (current.type === 'remove') {
+      const removeLines: LineObject[] = [current];
+      let j = i + 1;
+
+      // Collect consecutive remove lines
+      while (j < lineObjects.length && lineObjects[j]?.type === 'remove') {
+        const line = lineObjects[j];
+        if (line) {
+          removeLines.push(line);
+        }
+        j++;
+      }
+
+      // Check if there are add lines following the remove lines
+      const addLines: LineObject[] = [];
+      while (j < lineObjects.length && lineObjects[j]?.type === 'add') {
+        const line = lineObjects[j];
+        if (line) {
+          addLines.push(line);
+        }
+        j++;
+      }
+
+      // If we have both remove and add lines, perform word-level diffing
+      if (removeLines.length > 0 && addLines.length > 0) {
+        // For word diffing, we'll compare each pair of lines or the closest available match
+        const pairCount = Math.min(removeLines.length, addLines.length);
+
+        // Add paired lines with word diff info
+        for (let k = 0; k < pairCount; k++) {
+          const removeLine = removeLines[k];
+          const addLine = addLines[k];
+          if (removeLine && addLine) {
+            removeLine.wordDiff = true;
+            addLine.wordDiff = true;
+
+            // Store the matched pair for later word diffing
+            removeLine.matchedLine = addLine;
+            addLine.matchedLine = removeLine;
+          }
+        }
+
+        // Add all remove lines (both paired and unpaired)
+        processedLines.push(...removeLines.filter(Boolean));
+
+        // Then add all add lines (both paired and unpaired)
+        processedLines.push(...addLines.filter(Boolean));
+        i = j; // Skip all the lines we've processed
+      } else {
+        // No matching add lines, just add the current remove line
+        processedLines.push(current);
+        i++;
+      }
+    } else {
+      // Not a remove line, just add it
+      processedLines.push(current);
+      i++;
+    }
+  }
+  return processedLines;
+}
+
+// Calculate word-level diffs between two text strings
+export function calculateWordDiffs(oldText: string, newText: string): DiffPart[] {
+  // Use diffWordsWithSpace instead of diffWords to preserve whitespace
+  // This ensures spaces between tokens like > and { are preserved
+  const result = diffWordsWithSpace(oldText, newText, {
+    ignoreCase: false
+  });
+  return result;
+}
+
+// Process word-level diffs with manual wrapping support
+function generateWordDiffElements(item: DiffLine, width: number, maxWidth: number, dim: boolean, overrideTheme?: ThemeName): React.ReactNode[] | null {
+  const {
+    type,
+    i,
+    wordDiff,
+    matchedLine,
+    originalCode
+  } = item;
+  if (!wordDiff || !matchedLine) {
+    return null; // This function only handles word-level diff rendering
+  }
+  const removedLineText = type === 'remove' ? originalCode : matchedLine.originalCode;
+  const addedLineText = type === 'remove' ? matchedLine.originalCode : originalCode;
+  const wordDiffs = calculateWordDiffs(removedLineText, addedLineText);
+
+  // Check if we should use word-level diffing
+  const totalLength = removedLineText.length + addedLineText.length;
+  const changedLength = wordDiffs.filter(part => part.added || part.removed).reduce((sum, part) => sum + part.value.length, 0);
+  const changeRatio = changedLength / totalLength;
+  if (changeRatio > CHANGE_THRESHOLD || dim) {
+    return null; // Fall back to standard rendering for major changes
+  }
+
+  // Calculate available width for content
+  const diffPrefix = type === 'add' ? '+' : '-';
+  const diffPrefixWidth = diffPrefix.length;
+  const availableContentWidth = Math.max(1, width - maxWidth - 1 - diffPrefixWidth);
+
+  // Manually wrap the word diff parts with better space efficiency
+  const wrappedLines: {
+    content: React.ReactNode[];
+    contentWidth: number;
+  }[] = [];
+  let currentLine: React.ReactNode[] = [];
+  let currentLineWidth = 0;
+  wordDiffs.forEach((part, partIndex) => {
+    // Determine if this part should be shown for this line type
+    let shouldShow = false;
+    let partBgColor: 'diffAddedWord' | 'diffRemovedWord' | undefined;
+    if (type === 'add') {
+      if (part.added) {
+        shouldShow = true;
+        partBgColor = 'diffAddedWord';
+      } else if (!part.removed) {
+        shouldShow = true;
+      }
+    } else if (type === 'remove') {
+      if (part.removed) {
+        shouldShow = true;
+        partBgColor = 'diffRemovedWord';
+      } else if (!part.added) {
+        shouldShow = true;
+      }
+    }
+    if (!shouldShow) return;
+
+    // Use wrapText to wrap this individual part if it's long
+    const partWrapped = wrapText(part.value, availableContentWidth, 'wrap');
+    const partLines = partWrapped.split('\n');
+    partLines.forEach((partLine, lineIdx) => {
+      if (!partLine) return;
+
+      // Check if we need to start a new line
+      if (lineIdx > 0 || currentLineWidth + stringWidth(partLine) > availableContentWidth) {
+        if (currentLine.length > 0) {
+          wrappedLines.push({
+            content: [...currentLine],
+            contentWidth: currentLineWidth
+          });
+          currentLine = [];
+          currentLineWidth = 0;
+        }
+      }
+      currentLine.push(<Text key={`part-${partIndex}-${lineIdx}`} backgroundColor={partBgColor}>
+          {partLine}
+        </Text>);
+      currentLineWidth += stringWidth(partLine);
+    });
+  });
+  if (currentLine.length > 0) {
+    wrappedLines.push({
+      content: currentLine,
+      contentWidth: currentLineWidth
+    });
+  }
+
+  // Render each wrapped line as a separate Text element
+  return wrappedLines.map(({
+    content,
+    contentWidth
+  }, lineIndex) => {
+    const key = `${type}-${i}-${lineIndex}`;
+    const lineBgColor = type === 'add' ? dim ? 'diffAddedDimmed' : 'diffAdded' : dim ? 'diffRemovedDimmed' : 'diffRemoved';
+    const lineNum = lineIndex === 0 ? i : undefined;
+    const lineNumStr = (lineNum !== undefined ? lineNum.toString().padStart(maxWidth) : ' '.repeat(maxWidth)) + ' ';
+    // Calculate padding to fill the entire terminal width
+    const usedWidth = lineNumStr.length + diffPrefixWidth + contentWidth;
+    const padding = Math.max(0, width - usedWidth);
+    return <Box key={key} flexDirection="row">
+        <NoSelect fromLeftEdge>
+          <Text color={overrideTheme ? 'text' : undefined} backgroundColor={lineBgColor} dimColor={dim}>
+            {lineNumStr}
+            {diffPrefix}
+          </Text>
+        </NoSelect>
+        <Text color={overrideTheme ? 'text' : undefined} backgroundColor={lineBgColor} dimColor={dim}>
+          {content}
+          {' '.repeat(padding)}
+        </Text>
+      </Box>;
+  });
+}
+function formatDiff(lines: string[], startingLineNumber: number, width: number, dim: boolean, overrideTheme?: ThemeName): React.ReactNode[] {
+  // Ensure width is at least 1 to prevent rendering issues with very narrow terminals
+  const safeWidth = Math.max(1, Math.floor(width));
+
+  // Step 1: Transform lines to line objects with type information
+  const lineObjects = transformLinesToObjects(lines);
+
+  // Step 2: Group adjacent add/remove lines for word-level diffing
+  const processedLines = processAdjacentLines(lineObjects);
+
+  // Step 3: Number the diff lines
+  const ls = numberDiffLines(processedLines, startingLineNumber);
+
+  // Find max line number width for alignment
+  const maxLineNumber = Math.max(...ls.map(({
+    i
+  }) => i), 0);
+  const maxWidth = Math.max(maxLineNumber.toString().length + 1, 0);
+
+  // Step 4: Render formatting
+  return ls.flatMap((item): React.ReactNode[] => {
+    const {
+      type,
+      code,
+      i,
+      wordDiff,
+      matchedLine
+    } = item;
+
+    // Handle word-level diffing for add/remove pairs
+    if (wordDiff && matchedLine) {
+      const wordDiffElements = generateWordDiffElements(item, safeWidth, maxWidth, dim, overrideTheme);
+
+      // word-diff might refuse (e.g. due to lines being substantially different) in which
+      // case we'll fall through to normal renderin gbelow
+      if (wordDiffElements !== null) {
+        return wordDiffElements;
+      }
+    }
+
+    // Standard rendering for lines without word diffing or as fallback
+    // Calculate available width accounting for line number + space + diff prefix
+    const diffPrefixWidth = 2; // "  " for unchanged, "+ " or "- " for changes
+    const availableContentWidth = Math.max(1, safeWidth - maxWidth - 1 - diffPrefixWidth); // -1 for space after line number
+    const wrappedText = wrapText(code, availableContentWidth, 'wrap');
+    const wrappedLines = wrappedText.split('\n');
+    return wrappedLines.map((line, lineIndex) => {
+      const key = `${type}-${i}-${lineIndex}`;
+      const lineNum = lineIndex === 0 ? i : undefined;
+      const lineNumStr = (lineNum !== undefined ? lineNum.toString().padStart(maxWidth) : ' '.repeat(maxWidth)) + ' ';
+      const sigil = type === 'add' ? '+' : type === 'remove' ? '-' : ' ';
+      // Calculate padding to fill the entire terminal width
+      const contentWidth = lineNumStr.length + 1 + stringWidth(line); // lineNum + sigil + code
+      const padding = Math.max(0, safeWidth - contentWidth);
+      const bgColor = type === 'add' ? dim ? 'diffAddedDimmed' : 'diffAdded' : type === 'remove' ? dim ? 'diffRemovedDimmed' : 'diffRemoved' : undefined;
+
+      // Gutter (line number + sigil) is wrapped in <NoSelect> so fullscreen
+      // text selection yields clean code. bgColor carries across both boxes
+      // so the visual continuity (solid red/green bar) is unchanged.
+      return <Box key={key} flexDirection="row">
+          <NoSelect fromLeftEdge>
+            <Text color={overrideTheme ? 'text' : undefined} backgroundColor={bgColor} dimColor={dim || type === 'nochange'}>
+              {lineNumStr}
+              {sigil}
+            </Text>
+          </NoSelect>
+          <Text color={overrideTheme ? 'text' : undefined} backgroundColor={bgColor} dimColor={dim}>
+            {line}
+            {' '.repeat(padding)}
+          </Text>
+        </Box>;
+    });
+  });
+}
+export function numberDiffLines(diff: LineObject[], startLine: number): DiffLine[] {
+  let i = startLine;
+  const result: DiffLine[] = [];
+  const queue = [...diff];
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const {
+      code,
+      type,
+      originalCode,
+      wordDiff,
+      matchedLine
+    } = current;
+    const line = {
+      code,
+      type,
+      i,
+      originalCode,
+      wordDiff,
+      matchedLine
+    };
+
+    // Update counters based on change type
+    switch (type) {
+      case 'nochange':
+        i++;
+        result.push(line);
+        break;
+      case 'add':
+        i++;
+        result.push(line);
+        break;
+      case 'remove':
+        {
+          result.push(line);
+          let numRemoved = 0;
+          while (queue[0]?.type === 'remove') {
+            i++;
+            const current = queue.shift()!;
+            const {
+              code,
+              type,
+              originalCode,
+              wordDiff,
+              matchedLine
+            } = current;
+            const line = {
+              code,
+              type,
+              i,
+              originalCode,
+              wordDiff,
+              matchedLine
+            };
+            result.push(line);
+            numRemoved++;
+          }
+          i -= numRemoved;
+          break;
+        }
+    }
+  }
+  return result;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["diffWordsWithSpace","StructuredPatchHunk","React","useMemo","ThemeName","stringWidth","Box","NoSelect","Text","useTheme","wrapText","DiffLine","code","type","i","originalCode","wordDiff","matchedLine","LineObject","DiffPart","added","removed","value","Props","patch","dim","width","CHANGE_THRESHOLD","StructuredDiffFallback","t0","$","_c","theme","t1","lines","oldStart","formatDiff","diff","t2","map","_temp","t3","node","transformLinesToObjects","startsWith","slice","processAdjacentLines","lineObjects","processedLines","length","current","removeLines","j","line","push","addLines","pairCount","Math","min","k","removeLine","addLine","filter","Boolean","calculateWordDiffs","oldText","newText","result","ignoreCase","generateWordDiffElements","item","maxWidth","overrideTheme","ReactNode","removedLineText","addedLineText","wordDiffs","totalLength","changedLength","part","reduce","sum","changeRatio","diffPrefix","diffPrefixWidth","availableContentWidth","max","wrappedLines","content","contentWidth","currentLine","currentLineWidth","forEach","partIndex","shouldShow","partBgColor","partWrapped","partLines","split","partLine","lineIdx","lineIndex","key","lineBgColor","lineNum","undefined","lineNumStr","toString","padStart","repeat","usedWidth","padding","startingLineNumber","safeWidth","floor","ls","numberDiffLines","maxLineNumber","flatMap","wordDiffElements","wrappedText","sigil","bgColor","startLine","queue","shift","numRemoved"],"sources":["Fallback.tsx"],"sourcesContent":["import { diffWordsWithSpace, type StructuredPatchHunk } from 'diff'\nimport * as React from 'react'\nimport { useMemo } from 'react'\nimport type { ThemeName } from 'src/utils/theme.js'\nimport { stringWidth } from '../../ink/stringWidth.js'\nimport { Box, NoSelect, Text, useTheme, wrapText } from '../../ink.js'\n\n/*\n * StructuredDiffFallback Component: Word-Level Diff Highlighting Example\n *\n * This component shows diff changes with word-level highlighting. Here's a walkthrough:\n *\n * Example:\n * ```\n * // Original code\n * function oldName(param) {\n *   return param.oldProperty;\n * }\n *\n * // Changed code\n * function newName(param) {\n *   return param.newProperty;\n * }\n * ```\n *\n * Processing flow:\n * 1. Component receives a patch with lines including '+' and '-' prefixes\n * 2. Lines are transformed into objects with type (add/remove/nochange)\n * 3. Related add/remove lines are paired (e.g., oldName with newName)\n * 4. Word-level diffing identifies specific changed parts:\n *    [\n *      { value: 'function ', added: undefined, removed: undefined },  // Common\n *      { value: 'oldName', removed: true },                           // Removed\n *      { value: 'newName', added: true },                             // Added\n *      { value: '(param) {', added: undefined, removed: undefined }   // Common\n *    ]\n * 5. Renders with enhanced highlighting:\n *    - Common parts are shown normally\n *    - Removed words get a darker red background\n *    - Added words get a darker green background\n *\n * This produces a visually clear diff where users can see exactly which words\n * changed rather than just which lines were modified.\n */\n\n// Define DiffLine interface to be used throughout the file\ninterface DiffLine {\n  code: string\n  type: 'add' | 'remove' | 'nochange'\n  i: number\n  originalCode: string\n  wordDiff?: boolean // Flag for word-level diffing\n  matchedLine?: DiffLine\n}\n\n// Line object type for internal functions\nexport interface LineObject {\n  code: string\n  i: number\n  type: 'add' | 'remove' | 'nochange'\n  originalCode: string\n  wordDiff?: boolean\n  matchedLine?: LineObject\n}\n\n// Type for word-level diff parts\ninterface DiffPart {\n  added?: boolean\n  removed?: boolean\n  value: string\n}\n\ntype Props = {\n  patch: StructuredPatchHunk\n  dim: boolean\n  width: number\n}\n\n// Threshold for when we show a full-line diff instead of word-level diffing\nconst CHANGE_THRESHOLD = 0.4\n\nexport function StructuredDiffFallback({\n  patch,\n  dim,\n  width,\n}: Props): React.ReactNode {\n  const [theme] = useTheme()\n  const diff = useMemo(\n    () => formatDiff(patch.lines, patch.oldStart, width, dim, theme),\n    [patch.lines, patch.oldStart, width, dim, theme],\n  )\n\n  return (\n    <Box flexDirection=\"column\" flexGrow={1}>\n      {diff.map((node, i) => (\n        <Box key={i}>{node}</Box>\n      ))}\n    </Box>\n  )\n}\n\n// Transform lines to line objects with type information\nexport function transformLinesToObjects(lines: string[]): LineObject[] {\n  return lines.map(code => {\n    if (code.startsWith('+')) {\n      return {\n        code: code.slice(1),\n        i: 0,\n        type: 'add',\n        originalCode: code.slice(1),\n      }\n    }\n    if (code.startsWith('-')) {\n      return {\n        code: code.slice(1),\n        i: 0,\n        type: 'remove',\n        originalCode: code.slice(1),\n      }\n    }\n    return {\n      code: code.slice(1),\n      i: 0,\n      type: 'nochange',\n      originalCode: code.slice(1),\n    }\n  })\n}\n\n// Group adjacent add/remove lines for word-level diffing\nexport function processAdjacentLines(lineObjects: LineObject[]): LineObject[] {\n  const processedLines: LineObject[] = []\n  let i = 0\n\n  while (i < lineObjects.length) {\n    const current = lineObjects[i]\n    if (!current) {\n      i++\n      continue\n    }\n\n    // Find a sequence of remove followed by add (possible word-level diff candidates)\n    if (current.type === 'remove') {\n      const removeLines: LineObject[] = [current]\n      let j = i + 1\n\n      // Collect consecutive remove lines\n      while (j < lineObjects.length && lineObjects[j]?.type === 'remove') {\n        const line = lineObjects[j]\n        if (line) {\n          removeLines.push(line)\n        }\n        j++\n      }\n\n      // Check if there are add lines following the remove lines\n      const addLines: LineObject[] = []\n      while (j < lineObjects.length && lineObjects[j]?.type === 'add') {\n        const line = lineObjects[j]\n        if (line) {\n          addLines.push(line)\n        }\n        j++\n      }\n\n      // If we have both remove and add lines, perform word-level diffing\n      if (removeLines.length > 0 && addLines.length > 0) {\n        // For word diffing, we'll compare each pair of lines or the closest available match\n        const pairCount = Math.min(removeLines.length, addLines.length)\n\n        // Add paired lines with word diff info\n        for (let k = 0; k < pairCount; k++) {\n          const removeLine = removeLines[k]\n          const addLine = addLines[k]\n\n          if (removeLine && addLine) {\n            removeLine.wordDiff = true\n            addLine.wordDiff = true\n\n            // Store the matched pair for later word diffing\n            removeLine.matchedLine = addLine\n            addLine.matchedLine = removeLine\n          }\n        }\n\n        // Add all remove lines (both paired and unpaired)\n        processedLines.push(...removeLines.filter(Boolean))\n\n        // Then add all add lines (both paired and unpaired)\n        processedLines.push(...addLines.filter(Boolean))\n\n        i = j // Skip all the lines we've processed\n      } else {\n        // No matching add lines, just add the current remove line\n        processedLines.push(current)\n        i++\n      }\n    } else {\n      // Not a remove line, just add it\n      processedLines.push(current)\n      i++\n    }\n  }\n\n  return processedLines\n}\n\n// Calculate word-level diffs between two text strings\nexport function calculateWordDiffs(\n  oldText: string,\n  newText: string,\n): DiffPart[] {\n  // Use diffWordsWithSpace instead of diffWords to preserve whitespace\n  // This ensures spaces between tokens like > and { are preserved\n  const result = diffWordsWithSpace(oldText, newText, { ignoreCase: false })\n\n  return result\n}\n\n// Process word-level diffs with manual wrapping support\nfunction generateWordDiffElements(\n  item: DiffLine,\n  width: number,\n  maxWidth: number,\n  dim: boolean,\n  overrideTheme?: ThemeName,\n): React.ReactNode[] | null {\n  const { type, i, wordDiff, matchedLine, originalCode } = item\n\n  if (!wordDiff || !matchedLine) {\n    return null // This function only handles word-level diff rendering\n  }\n\n  const removedLineText =\n    type === 'remove' ? originalCode : matchedLine.originalCode\n  const addedLineText =\n    type === 'remove' ? matchedLine.originalCode : originalCode\n\n  const wordDiffs = calculateWordDiffs(removedLineText, addedLineText)\n\n  // Check if we should use word-level diffing\n  const totalLength = removedLineText.length + addedLineText.length\n  const changedLength = wordDiffs\n    .filter(part => part.added || part.removed)\n    .reduce((sum, part) => sum + part.value.length, 0)\n  const changeRatio = changedLength / totalLength\n\n  if (changeRatio > CHANGE_THRESHOLD || dim) {\n    return null // Fall back to standard rendering for major changes\n  }\n\n  // Calculate available width for content\n  const diffPrefix = type === 'add' ? '+' : '-'\n  const diffPrefixWidth = diffPrefix.length\n  const availableContentWidth = Math.max(\n    1,\n    width - maxWidth - 1 - diffPrefixWidth,\n  )\n\n  // Manually wrap the word diff parts with better space efficiency\n  const wrappedLines: { content: React.ReactNode[]; contentWidth: number }[] =\n    []\n  let currentLine: React.ReactNode[] = []\n  let currentLineWidth = 0\n\n  wordDiffs.forEach((part, partIndex) => {\n    // Determine if this part should be shown for this line type\n    let shouldShow = false\n    let partBgColor: 'diffAddedWord' | 'diffRemovedWord' | undefined\n\n    if (type === 'add') {\n      if (part.added) {\n        shouldShow = true\n        partBgColor = 'diffAddedWord'\n      } else if (!part.removed) {\n        shouldShow = true\n      }\n    } else if (type === 'remove') {\n      if (part.removed) {\n        shouldShow = true\n        partBgColor = 'diffRemovedWord'\n      } else if (!part.added) {\n        shouldShow = true\n      }\n    }\n\n    if (!shouldShow) return\n\n    // Use wrapText to wrap this individual part if it's long\n    const partWrapped = wrapText(part.value, availableContentWidth, 'wrap')\n    const partLines = partWrapped.split('\\n')\n\n    partLines.forEach((partLine, lineIdx) => {\n      if (!partLine) return\n\n      // Check if we need to start a new line\n      if (\n        lineIdx > 0 ||\n        currentLineWidth + stringWidth(partLine) > availableContentWidth\n      ) {\n        if (currentLine.length > 0) {\n          wrappedLines.push({\n            content: [...currentLine],\n            contentWidth: currentLineWidth,\n          })\n          currentLine = []\n          currentLineWidth = 0\n        }\n      }\n\n      currentLine.push(\n        <Text\n          key={`part-${partIndex}-${lineIdx}`}\n          backgroundColor={partBgColor}\n        >\n          {partLine}\n        </Text>,\n      )\n\n      currentLineWidth += stringWidth(partLine)\n    })\n  })\n\n  if (currentLine.length > 0) {\n    wrappedLines.push({ content: currentLine, contentWidth: currentLineWidth })\n  }\n\n  // Render each wrapped line as a separate Text element\n  return wrappedLines.map(({ content, contentWidth }, lineIndex) => {\n    const key = `${type}-${i}-${lineIndex}`\n    const lineBgColor =\n      type === 'add'\n        ? dim\n          ? 'diffAddedDimmed'\n          : 'diffAdded'\n        : dim\n          ? 'diffRemovedDimmed'\n          : 'diffRemoved'\n    const lineNum = lineIndex === 0 ? i : undefined\n    const lineNumStr =\n      (lineNum !== undefined\n        ? lineNum.toString().padStart(maxWidth)\n        : ' '.repeat(maxWidth)) + ' '\n    // Calculate padding to fill the entire terminal width\n    const usedWidth = lineNumStr.length + diffPrefixWidth + contentWidth\n    const padding = Math.max(0, width - usedWidth)\n\n    return (\n      <Box key={key} flexDirection=\"row\">\n        <NoSelect fromLeftEdge>\n          <Text\n            color={overrideTheme ? 'text' : undefined}\n            backgroundColor={lineBgColor}\n            dimColor={dim}\n          >\n            {lineNumStr}\n            {diffPrefix}\n          </Text>\n        </NoSelect>\n        <Text\n          color={overrideTheme ? 'text' : undefined}\n          backgroundColor={lineBgColor}\n          dimColor={dim}\n        >\n          {content}\n          {' '.repeat(padding)}\n        </Text>\n      </Box>\n    )\n  })\n}\n\nfunction formatDiff(\n  lines: string[],\n  startingLineNumber: number,\n  width: number,\n  dim: boolean,\n  overrideTheme?: ThemeName,\n): React.ReactNode[] {\n  // Ensure width is at least 1 to prevent rendering issues with very narrow terminals\n  const safeWidth = Math.max(1, Math.floor(width))\n\n  // Step 1: Transform lines to line objects with type information\n  const lineObjects = transformLinesToObjects(lines)\n\n  // Step 2: Group adjacent add/remove lines for word-level diffing\n  const processedLines = processAdjacentLines(lineObjects)\n\n  // Step 3: Number the diff lines\n  const ls = numberDiffLines(processedLines, startingLineNumber)\n\n  // Find max line number width for alignment\n  const maxLineNumber = Math.max(...ls.map(({ i }) => i), 0)\n  const maxWidth = Math.max(maxLineNumber.toString().length + 1, 0)\n\n  // Step 4: Render formatting\n  return ls.flatMap((item): React.ReactNode[] => {\n    const { type, code, i, wordDiff, matchedLine } = item\n\n    // Handle word-level diffing for add/remove pairs\n    if (wordDiff && matchedLine) {\n      const wordDiffElements = generateWordDiffElements(\n        item,\n        safeWidth,\n        maxWidth,\n        dim,\n        overrideTheme,\n      )\n\n      // word-diff might refuse (e.g. due to lines being substantially different) in which\n      // case we'll fall through to normal renderin gbelow\n      if (wordDiffElements !== null) {\n        return wordDiffElements\n      }\n    }\n\n    // Standard rendering for lines without word diffing or as fallback\n    // Calculate available width accounting for line number + space + diff prefix\n    const diffPrefixWidth = 2 // \"  \" for unchanged, \"+ \" or \"- \" for changes\n    const availableContentWidth = Math.max(\n      1,\n      safeWidth - maxWidth - 1 - diffPrefixWidth,\n    ) // -1 for space after line number\n    const wrappedText = wrapText(code, availableContentWidth, 'wrap')\n    const wrappedLines = wrappedText.split('\\n')\n\n    return wrappedLines.map((line, lineIndex) => {\n      const key = `${type}-${i}-${lineIndex}`\n      const lineNum = lineIndex === 0 ? i : undefined\n      const lineNumStr =\n        (lineNum !== undefined\n          ? lineNum.toString().padStart(maxWidth)\n          : ' '.repeat(maxWidth)) + ' '\n      const sigil = type === 'add' ? '+' : type === 'remove' ? '-' : ' '\n      // Calculate padding to fill the entire terminal width\n      const contentWidth = lineNumStr.length + 1 + stringWidth(line) // lineNum + sigil + code\n      const padding = Math.max(0, safeWidth - contentWidth)\n\n      const bgColor =\n        type === 'add'\n          ? dim\n            ? 'diffAddedDimmed'\n            : 'diffAdded'\n          : type === 'remove'\n            ? dim\n              ? 'diffRemovedDimmed'\n              : 'diffRemoved'\n            : undefined\n\n      // Gutter (line number + sigil) is wrapped in <NoSelect> so fullscreen\n      // text selection yields clean code. bgColor carries across both boxes\n      // so the visual continuity (solid red/green bar) is unchanged.\n      return (\n        <Box key={key} flexDirection=\"row\">\n          <NoSelect fromLeftEdge>\n            <Text\n              color={overrideTheme ? 'text' : undefined}\n              backgroundColor={bgColor}\n              dimColor={dim || type === 'nochange'}\n            >\n              {lineNumStr}\n              {sigil}\n            </Text>\n          </NoSelect>\n          <Text\n            color={overrideTheme ? 'text' : undefined}\n            backgroundColor={bgColor}\n            dimColor={dim}\n          >\n            {line}\n            {' '.repeat(padding)}\n          </Text>\n        </Box>\n      )\n    })\n  })\n}\n\nexport function numberDiffLines(\n  diff: LineObject[],\n  startLine: number,\n): DiffLine[] {\n  let i = startLine\n  const result: DiffLine[] = []\n  const queue = [...diff]\n\n  while (queue.length > 0) {\n    const current = queue.shift()!\n    const { code, type, originalCode, wordDiff, matchedLine } = current\n    const line = {\n      code,\n      type,\n      i,\n      originalCode,\n      wordDiff,\n      matchedLine,\n    }\n\n    // Update counters based on change type\n    switch (type) {\n      case 'nochange':\n        i++\n        result.push(line)\n        break\n      case 'add':\n        i++\n        result.push(line)\n        break\n      case 'remove': {\n        result.push(line)\n        let numRemoved = 0\n        while (queue[0]?.type === 'remove') {\n          i++\n          const current = queue.shift()!\n          const { code, type, originalCode, wordDiff, matchedLine } = current\n          const line = {\n            code,\n            type,\n            i,\n            originalCode,\n            wordDiff,\n            matchedLine,\n          }\n          result.push(line)\n          numRemoved++\n        }\n        i -= numRemoved\n        break\n      }\n    }\n  }\n\n  return result\n}\n"],"mappings":"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","ignoreList":[]}

src/components/StructuredDiff/colorDiff.ts

@@ -0,0 +1,37 @@
+import {
+  ColorDiff,
+  ColorFile,
+  getSyntaxTheme as nativeGetSyntaxTheme,
+  type SyntaxTheme,
+} from 'color-diff-napi'
+import { isEnvDefinedFalsy } from '../../utils/envUtils.js'
+
+export type ColorModuleUnavailableReason = 'env'
+
+/**
+ * Returns a static reason why the color-diff module is unavailable, or null if available.
+ * 'env' = disabled via CLAUDE_CODE_SYNTAX_HIGHLIGHT
+ *
+ * The TS port of color-diff works in all build modes, so the only way to
+ * disable it is via the env var.
+ */
+export function getColorModuleUnavailableReason(): ColorModuleUnavailableReason | null {
+  if (isEnvDefinedFalsy(process.env.CLAUDE_CODE_SYNTAX_HIGHLIGHT)) {
+    return 'env'
+  }
+  return null
+}
+
+export function expectColorDiff(): typeof ColorDiff | null {
+  return getColorModuleUnavailableReason() === null ? ColorDiff : null
+}
+
+export function expectColorFile(): typeof ColorFile | null {
+  return getColorModuleUnavailableReason() === null ? ColorFile : null
+}
+
+export function getSyntaxTheme(themeName: string): SyntaxTheme | null {
+  return getColorModuleUnavailableReason() === null
+    ? nativeGetSyntaxTheme(themeName)
+    : null
+}

src/components/TrustDialog/TrustDialog.tsx

@@ -0,0 +1,290 @@
+import { c as _c } from "react/compiler-runtime";
+import { homedir } from 'os';
+import React from 'react';
+import { logEvent } from 'src/services/analytics/index.js';
+import { setSessionTrustAccepted } from '../../bootstrap/state.js';
+import type { Command } from '../../commands.js';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+import { Box, Link, Text } from '../../ink.js';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import { getMcpConfigsByScope } from '../../services/mcp/config.js';
+import { BASH_TOOL_NAME } from '../../tools/BashTool/toolName.js';
+import { checkHasTrustDialogAccepted, saveCurrentProjectConfig } from '../../utils/config.js';
+import { getCwd } from '../../utils/cwd.js';
+import { getFsImplementation } from '../../utils/fsOperations.js';
+import { gracefulShutdownSync } from '../../utils/gracefulShutdown.js';
+import { Select } from '../CustomSelect/index.js';
+import { PermissionDialog } from '../permissions/PermissionDialog.js';
+import { getApiKeyHelperSources, getAwsCommandsSources, getBashPermissionSources, getDangerousEnvVarsSources, getGcpCommandsSources, getHooksSources, getOtelHeadersHelperSources } from './utils.js';
+type Props = {
+  onDone(): void;
+  commands?: Command[];
+};
+export function TrustDialog(t0) {
+  const $ = _c(33);
+  const {
+    onDone,
+    commands
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = getMcpConfigsByScope("project");
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const {
+    servers: projectServers
+  } = t1;
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = Object.keys(projectServers);
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  const hasMcpServers = t2.length > 0;
+  let t3;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = getHooksSources();
+    $[2] = t3;
+  } else {
+    t3 = $[2];
+  }
+  const hooksSettingSources = t3;
+  const hasHooks = hooksSettingSources.length > 0;
+  let t4;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = getBashPermissionSources();
+    $[3] = t4;
+  } else {
+    t4 = $[3];
+  }
+  const bashSettingSources = t4;
+  let t5;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = getApiKeyHelperSources();
+    $[4] = t5;
+  } else {
+    t5 = $[4];
+  }
+  const apiKeyHelperSources = t5;
+  const hasApiKeyHelper = apiKeyHelperSources.length > 0;
+  let t6;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = getAwsCommandsSources();
+    $[5] = t6;
+  } else {
+    t6 = $[5];
+  }
+  const awsCommandsSources = t6;
+  const hasAwsCommands = awsCommandsSources.length > 0;
+  let t7;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = getGcpCommandsSources();
+    $[6] = t7;
+  } else {
+    t7 = $[6];
+  }
+  const gcpCommandsSources = t7;
+  const hasGcpCommands = gcpCommandsSources.length > 0;
+  let t8;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t8 = getOtelHeadersHelperSources();
+    $[7] = t8;
+  } else {
+    t8 = $[7];
+  }
+  const otelHeadersHelperSources = t8;
+  const hasOtelHeadersHelper = otelHeadersHelperSources.length > 0;
+  let t9;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t9 = getDangerousEnvVarsSources();
+    $[8] = t9;
+  } else {
+    t9 = $[8];
+  }
+  const dangerousEnvVarsSources = t9;
+  const hasDangerousEnvVars = dangerousEnvVarsSources.length > 0;
+  let t10;
+  if ($[9] !== commands) {
+    t10 = commands?.some(_temp2) ?? false;
+    $[9] = commands;
+    $[10] = t10;
+  } else {
+    t10 = $[10];
+  }
+  const hasSlashCommandBash = t10;
+  let t11;
+  if ($[11] !== commands) {
+    t11 = commands?.some(_temp4) ?? false;
+    $[11] = commands;
+    $[12] = t11;
+  } else {
+    t11 = $[12];
+  }
+  const hasSkillsBash = t11;
+  const hasAnyBashExecution = bashSettingSources.length > 0 || hasSlashCommandBash || hasSkillsBash;
+  const hasTrustDialogAccepted = checkHasTrustDialogAccepted();
+  let t12;
+  let t13;
+  if ($[13] !== hasAnyBashExecution) {
+    t12 = () => {
+      const isHomeDir = homedir() === getCwd();
+      logEvent("tengu_trust_dialog_shown", {
+        isHomeDir,
+        hasMcpServers,
+        hasHooks,
+        hasBashExecution: hasAnyBashExecution,
+        hasApiKeyHelper,
+        hasAwsCommands,
+        hasGcpCommands,
+        hasOtelHeadersHelper,
+        hasDangerousEnvVars
+      });
+    };
+    t13 = [hasMcpServers, hasHooks, hasAnyBashExecution, hasApiKeyHelper, hasAwsCommands, hasGcpCommands, hasOtelHeadersHelper, hasDangerousEnvVars];
+    $[13] = hasAnyBashExecution;
+    $[14] = t12;
+    $[15] = t13;
+  } else {
+    t12 = $[14];
+    t13 = $[15];
+  }
+  React.useEffect(t12, t13);
+  let t14;
+  if ($[16] !== hasAnyBashExecution || $[17] !== onDone) {
+    t14 = function onChange(value) {
+      if (value === "exit") {
+        gracefulShutdownSync(1);
+        return;
+      }
+      const isHomeDir_0 = homedir() === getCwd();
+      logEvent("tengu_trust_dialog_accept", {
+        isHomeDir: isHomeDir_0,
+        hasMcpServers,
+        hasHooks,
+        hasBashExecution: hasAnyBashExecution,
+        hasApiKeyHelper,
+        hasAwsCommands,
+        hasGcpCommands,
+        hasOtelHeadersHelper,
+        hasDangerousEnvVars
+      });
+      if (isHomeDir_0) {
+        setSessionTrustAccepted(true);
+      } else {
+        saveCurrentProjectConfig(_temp5);
+      }
+      onDone();
+    };
+    $[16] = hasAnyBashExecution;
+    $[17] = onDone;
+    $[18] = t14;
+  } else {
+    t14 = $[18];
+  }
+  const onChange = t14;
+  const exitState = useExitOnCtrlCDWithKeybindings(_temp6);
+  let t15;
+  if ($[19] === Symbol.for("react.memo_cache_sentinel")) {
+    t15 = {
+      context: "Confirmation"
+    };
+    $[19] = t15;
+  } else {
+    t15 = $[19];
+  }
+  useKeybinding("confirm:no", _temp7, t15);
+  if (hasTrustDialogAccepted) {
+    setTimeout(onDone);
+    return null;
+  }
+  let t16;
+  let t17;
+  let t18;
+  if ($[20] === Symbol.for("react.memo_cache_sentinel")) {
+    t16 = <Text bold={true}>{getFsImplementation().cwd()}</Text>;
+    t17 = <Text>Quick safety check: Is this a project you created or one you trust? (Like your own code, a well-known open source project, or work from your team). If not, take a moment to review what{"'"}s in this folder first.</Text>;
+    t18 = <Text>Claude Code{"'"}ll be able to read, edit, and execute files here.</Text>;
+    $[20] = t16;
+    $[21] = t17;
+    $[22] = t18;
+  } else {
+    t16 = $[20];
+    t17 = $[21];
+    t18 = $[22];
+  }
+  let t19;
+  if ($[23] === Symbol.for("react.memo_cache_sentinel")) {
+    t19 = <Text dimColor={true}><Link url="https://code.claude.com/docs/en/security">Security guide</Link></Text>;
+    $[23] = t19;
+  } else {
+    t19 = $[23];
+  }
+  let t20;
+  if ($[24] === Symbol.for("react.memo_cache_sentinel")) {
+    t20 = [{
+      label: "Yes, I trust this folder",
+      value: "enable_all"
+    }, {
+      label: "No, exit",
+      value: "exit"
+    }];
+    $[24] = t20;
+  } else {
+    t20 = $[24];
+  }
+  let t21;
+  if ($[25] !== onChange) {
+    t21 = <Select options={t20} onChange={value_0 => onChange(value_0 as 'enable_all' | 'exit')} onCancel={() => onChange("exit")} />;
+    $[25] = onChange;
+    $[26] = t21;
+  } else {
+    t21 = $[26];
+  }
+  let t22;
+  if ($[27] !== exitState.keyName || $[28] !== exitState.pending) {
+    t22 = <Text dimColor={true}>{exitState.pending ? <>Press {exitState.keyName} again to exit</> : <>Enter to confirm · Esc to cancel</>}</Text>;
+    $[27] = exitState.keyName;
+    $[28] = exitState.pending;
+    $[29] = t22;
+  } else {
+    t22 = $[29];
+  }
+  let t23;
+  if ($[30] !== t21 || $[31] !== t22) {
+    t23 = <PermissionDialog color="warning" titleColor="warning" title="Accessing workspace:"><Box flexDirection="column" gap={1} paddingTop={1}>{t16}{t17}{t18}{t19}{t21}{t22}</Box></PermissionDialog>;
+    $[30] = t21;
+    $[31] = t22;
+    $[32] = t23;
+  } else {
+    t23 = $[32];
+  }
+  return t23;
+}
+function _temp7() {
+  gracefulShutdownSync(0);
+}
+function _temp6() {
+  return gracefulShutdownSync(1);
+}
+function _temp5(current) {
+  return {
+    ...current,
+    hasTrustDialogAccepted: true
+  };
+}
+function _temp4(command_0) {
+  return command_0.type === "prompt" && (command_0.loadedFrom === "skills" || command_0.loadedFrom === "plugin") && (command_0.source === "projectSettings" || command_0.source === "localSettings" || command_0.source === "plugin") && command_0.allowedTools?.some(_temp3);
+}
+function _temp3(tool_0) {
+  return tool_0 === BASH_TOOL_NAME || tool_0.startsWith(BASH_TOOL_NAME + "(");
+}
+function _temp2(command) {
+  return command.type === "prompt" && command.loadedFrom === "commands_DEPRECATED" && (command.source === "projectSettings" || command.source === "localSettings") && command.allowedTools?.some(_temp);
+}
+function _temp(tool) {
+  return tool === BASH_TOOL_NAME || tool.startsWith(BASH_TOOL_NAME + "(");
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["homedir","React","logEvent","setSessionTrustAccepted","Command","useExitOnCtrlCDWithKeybindings","Box","Link","Text","useKeybinding","getMcpConfigsByScope","BASH_TOOL_NAME","checkHasTrustDialogAccepted","saveCurrentProjectConfig","getCwd","getFsImplementation","gracefulShutdownSync","Select","PermissionDialog","getApiKeyHelperSources","getAwsCommandsSources","getBashPermissionSources","getDangerousEnvVarsSources","getGcpCommandsSources","getHooksSources","getOtelHeadersHelperSources","Props","onDone","commands","TrustDialog","t0","$","_c","t1","Symbol","for","servers","projectServers","t2","Object","keys","hasMcpServers","length","t3","hooksSettingSources","hasHooks","t4","bashSettingSources","t5","apiKeyHelperSources","hasApiKeyHelper","t6","awsCommandsSources","hasAwsCommands","t7","gcpCommandsSources","hasGcpCommands","t8","otelHeadersHelperSources","hasOtelHeadersHelper","t9","dangerousEnvVarsSources","hasDangerousEnvVars","t10","some","_temp2","hasSlashCommandBash","t11","_temp4","hasSkillsBash","hasAnyBashExecution","hasTrustDialogAccepted","t12","t13","isHomeDir","hasBashExecution","useEffect","t14","onChange","value","isHomeDir_0","_temp5","exitState","_temp6","t15","context","_temp7","setTimeout","t16","t17","t18","cwd","t19","t20","label","t21","value_0","t22","keyName","pending","t23","current","command_0","command","type","loadedFrom","source","allowedTools","_temp3","tool_0","tool","startsWith","_temp"],"sources":["TrustDialog.tsx"],"sourcesContent":["import { homedir } from 'os'\nimport React from 'react'\nimport { logEvent } from 'src/services/analytics/index.js'\nimport { setSessionTrustAccepted } from '../../bootstrap/state.js'\nimport type { Command } from '../../commands.js'\nimport { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport { Box, Link, Text } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport { getMcpConfigsByScope } from '../../services/mcp/config.js'\nimport { BASH_TOOL_NAME } from '../../tools/BashTool/toolName.js'\nimport {\n  checkHasTrustDialogAccepted,\n  saveCurrentProjectConfig,\n} from '../../utils/config.js'\nimport { getCwd } from '../../utils/cwd.js'\nimport { getFsImplementation } from '../../utils/fsOperations.js'\nimport { gracefulShutdownSync } from '../../utils/gracefulShutdown.js'\nimport { Select } from '../CustomSelect/index.js'\nimport { PermissionDialog } from '../permissions/PermissionDialog.js'\nimport {\n  getApiKeyHelperSources,\n  getAwsCommandsSources,\n  getBashPermissionSources,\n  getDangerousEnvVarsSources,\n  getGcpCommandsSources,\n  getHooksSources,\n  getOtelHeadersHelperSources,\n} from './utils.js'\n\ntype Props = {\n  onDone(): void\n  commands?: Command[]\n}\n\nexport function TrustDialog({ onDone, commands }: Props): React.ReactNode {\n  const { servers: projectServers } = getMcpConfigsByScope('project')\n\n  // In all cases, we generally check only the project-level and\n  // project-local-level settings, which we assume that users do not configure\n  // directly compared to user-level settings.\n\n  // Check for MCPs\n  const hasMcpServers = Object.keys(projectServers).length > 0\n  // Check for hooks\n  const hooksSettingSources = getHooksSources()\n  const hasHooks = hooksSettingSources.length > 0\n  // Check whether code execution is allowed in permissions and slash commands\n  const bashSettingSources = getBashPermissionSources()\n  // Check for apiKeyHelper which executes arbitrary commands\n  const apiKeyHelperSources = getApiKeyHelperSources()\n  const hasApiKeyHelper = apiKeyHelperSources.length > 0\n  // Check for AWS commands which execute arbitrary commands\n  const awsCommandsSources = getAwsCommandsSources()\n  const hasAwsCommands = awsCommandsSources.length > 0\n  // Check for GCP commands which execute arbitrary commands\n  const gcpCommandsSources = getGcpCommandsSources()\n  const hasGcpCommands = gcpCommandsSources.length > 0\n  // Check for otelHeadersHelper which executes arbitrary commands\n  const otelHeadersHelperSources = getOtelHeadersHelperSources()\n  const hasOtelHeadersHelper = otelHeadersHelperSources.length > 0\n  // Check for dangerous environment variables (not in SAFE_ENV_VARS)\n  const dangerousEnvVarsSources = getDangerousEnvVarsSources()\n  const hasDangerousEnvVars = dangerousEnvVarsSources.length > 0\n\n  const hasSlashCommandBash =\n    commands?.some(\n      command =>\n        command.type === 'prompt' &&\n        command.loadedFrom === 'commands_DEPRECATED' &&\n        (command.source === 'projectSettings' ||\n          command.source === 'localSettings') &&\n        command.allowedTools?.some(\n          (tool: string) =>\n            tool === BASH_TOOL_NAME || tool.startsWith(BASH_TOOL_NAME + '('),\n        ),\n    ) ?? false\n\n  const hasSkillsBash =\n    commands?.some(\n      command =>\n        command.type === 'prompt' &&\n        (command.loadedFrom === 'skills' || command.loadedFrom === 'plugin') &&\n        (command.source === 'projectSettings' ||\n          command.source === 'localSettings' ||\n          command.source === 'plugin') &&\n        command.allowedTools?.some(\n          (tool: string) =>\n            tool === BASH_TOOL_NAME || tool.startsWith(BASH_TOOL_NAME + '('),\n        ),\n    ) ?? false\n\n  const hasAnyBashExecution =\n    bashSettingSources.length > 0 || hasSlashCommandBash || hasSkillsBash\n\n  const hasTrustDialogAccepted = checkHasTrustDialogAccepted()\n\n  React.useEffect(() => {\n    const isHomeDir = homedir() === getCwd()\n    logEvent('tengu_trust_dialog_shown', {\n      isHomeDir,\n      hasMcpServers,\n      hasHooks,\n      hasBashExecution: hasAnyBashExecution,\n      hasApiKeyHelper,\n      hasAwsCommands,\n      hasGcpCommands,\n      hasOtelHeadersHelper,\n      hasDangerousEnvVars,\n    })\n  }, [\n    hasMcpServers,\n    hasHooks,\n    hasAnyBashExecution,\n    hasApiKeyHelper,\n    hasAwsCommands,\n    hasGcpCommands,\n    hasOtelHeadersHelper,\n    hasDangerousEnvVars,\n  ])\n\n  function onChange(value: 'enable_all' | 'exit') {\n    if (value === 'exit') {\n      gracefulShutdownSync(1)\n      return\n    }\n\n    const isHomeDir = homedir() === getCwd()\n\n    logEvent('tengu_trust_dialog_accept', {\n      isHomeDir,\n      hasMcpServers,\n      hasHooks,\n      hasBashExecution: hasAnyBashExecution,\n      hasApiKeyHelper,\n      hasAwsCommands,\n      hasGcpCommands,\n      hasOtelHeadersHelper,\n      hasDangerousEnvVars,\n    })\n\n    if (isHomeDir) {\n      // For home directory, store trust in session memory only (not persisted to disk)\n      // This allows hooks and other trust-requiring features to work during this session\n      // while preserving the security intent of not permanently trusting home dir\n      setSessionTrustAccepted(true)\n    } else {\n      saveCurrentProjectConfig(current => ({\n        ...current,\n        hasTrustDialogAccepted: true,\n      }))\n    }\n\n    // Do NOT write MCP server settings here. handleMcpjsonServerApprovals in\n    // interactiveHelpers.tsx runs right after this dialog and shows the per-server approval\n    // UI. Writing enabledMcpjsonServers/enableAllProjectMcpServers here would\n    // mark every server 'approved' and silently skip that dialog. See #15558.\n\n    onDone()\n  }\n\n  // Default onExit is useApp().exit() → Ink.unmount(), which tears down the\n  // React tree but never calls onDone(). showSetupScreens() in\n  // interactiveHelpers.tsx awaits a Promise that only resolves via onDone,\n  // so the default would hang the await forever. With keybinding\n  // customization enabled, the chokidar watcher (persistent: true) keeps the\n  // event loop alive and the process freezes. Explicitly exit 1 like \"No\".\n  const exitState = useExitOnCtrlCDWithKeybindings(() =>\n    gracefulShutdownSync(1),\n  )\n\n  // Use configurable keybinding for ESC to cancel/exit\n  useKeybinding(\n    'confirm:no',\n    () => {\n      gracefulShutdownSync(0)\n    },\n    { context: 'Confirmation' },\n  )\n\n  // Automatically resolve the trust dialog if there is nothing to be shown.\n  if (hasTrustDialogAccepted) {\n    setTimeout(onDone)\n    return null\n  }\n\n  return (\n    <PermissionDialog\n      color=\"warning\"\n      titleColor=\"warning\"\n      title=\"Accessing workspace:\"\n    >\n      <Box flexDirection=\"column\" gap={1} paddingTop={1}>\n        <Text bold>{getFsImplementation().cwd()}</Text>\n\n        <Text>\n          Quick safety check: Is this a project you created or one you trust?\n          (Like your own code, a well-known open source project, or work from\n          your team). If not, take a moment to review what{\"'\"}s in this folder\n          first.\n        </Text>\n        <Text>\n          Claude Code{\"'\"}ll be able to read, edit, and execute files here.\n        </Text>\n\n        <Text dimColor>\n          <Link url=\"https://code.claude.com/docs/en/security\">\n            Security guide\n          </Link>\n        </Text>\n\n        <Select\n          options={[\n            { label: 'Yes, I trust this folder', value: 'enable_all' },\n            { label: 'No, exit', value: 'exit' },\n          ]}\n          onChange={value => onChange(value as 'enable_all' | 'exit')}\n          onCancel={() => onChange('exit')}\n        />\n\n        <Text dimColor>\n          {exitState.pending ? (\n            <>Press {exitState.keyName} again to exit</>\n          ) : (\n            <>Enter to confirm · Esc to cancel</>\n          )}\n        </Text>\n      </Box>\n    </PermissionDialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/components/agents/AgentEditor.tsx

@@ -0,0 +1,178 @@
+import chalk from 'chalk';
+import figures from 'figures';
+import * as React from 'react';
+import { useCallback, useMemo, useState } from 'react';
+import { useSetAppState } from 'src/state/AppState.js';
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js';
+import { Box, Text } from '../../ink.js';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import type { Tools } from '../../Tool.js';
+import { type AgentColorName, setAgentColor } from '../../tools/AgentTool/agentColorManager.js';
+import { type AgentDefinition, getActiveAgentsFromList, isCustomAgent, isPluginAgent } from '../../tools/AgentTool/loadAgentsDir.js';
+import { editFileInEditor } from '../../utils/promptEditor.js';
+import { getActualAgentFilePath, updateAgentFile } from './agentFileUtils.js';
+import { ColorPicker } from './ColorPicker.js';
+import { ModelSelector } from './ModelSelector.js';
+import { ToolSelector } from './ToolSelector.js';
+import { getAgentSourceDisplayName } from './utils.js';
+type Props = {
+  agent: AgentDefinition;
+  tools: Tools;
+  onSaved: (message: string) => void;
+  onBack: () => void;
+};
+type EditMode = 'menu' | 'edit-tools' | 'edit-color' | 'edit-model';
+type SaveChanges = {
+  tools?: string[];
+  color?: AgentColorName;
+  model?: string;
+};
+export function AgentEditor({
+  agent,
+  tools,
+  onSaved,
+  onBack
+}: Props): React.ReactNode {
+  const setAppState = useSetAppState();
+  const [editMode, setEditMode] = useState<EditMode>('menu');
+  const [selectedMenuIndex, setSelectedMenuIndex] = useState(0);
+  const [error, setError] = useState<string | null>(null);
+  const [selectedColor, setSelectedColor] = useState<AgentColorName | undefined>(agent.color as AgentColorName | undefined);
+  const handleOpenInEditor = useCallback(async () => {
+    const filePath = getActualAgentFilePath(agent);
+    const result = await editFileInEditor(filePath);
+    if (result.error) {
+      setError(result.error);
+    } else {
+      onSaved(`Opened ${agent.agentType} in editor. If you made edits, restart to load the latest version.`);
+    }
+  }, [agent, onSaved]);
+  const handleSave = useCallback(async (changes: SaveChanges = {}) => {
+    const {
+      tools: newTools,
+      color: newColor,
+      model: newModel
+    } = changes;
+    const finalColor = newColor ?? selectedColor;
+    const hasToolsChanged = newTools !== undefined;
+    const hasModelChanged = newModel !== undefined;
+    const hasColorChanged = finalColor !== agent.color;
+    if (!hasToolsChanged && !hasModelChanged && !hasColorChanged) {
+      return false;
+    }
+    try {
+      // Only custom/plugin agents can be edited
+      // this is for type safety; the UI shouldn't allow editing otherwise
+      if (!isCustomAgent(agent) && !isPluginAgent(agent)) {
+        return false;
+      }
+      await updateAgentFile(agent, agent.whenToUse, newTools ?? agent.tools, agent.getSystemPrompt(), finalColor, newModel ?? agent.model);
+      if (hasColorChanged && finalColor) {
+        setAgentColor(agent.agentType, finalColor);
+      }
+      setAppState(state => {
+        const allAgents = state.agentDefinitions.allAgents.map(a => a.agentType === agent.agentType ? {
+          ...a,
+          tools: newTools ?? a.tools,
+          color: finalColor,
+          model: newModel ?? a.model
+        } : a);
+        return {
+          ...state,
+          agentDefinitions: {
+            ...state.agentDefinitions,
+            activeAgents: getActiveAgentsFromList(allAgents),
+            allAgents
+          }
+        };
+      });
+      onSaved(`Updated agent: ${chalk.bold(agent.agentType)}`);
+      return true;
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to save agent');
+      return false;
+    }
+  }, [agent, selectedColor, onSaved, setAppState]);
+  const menuItems = useMemo(() => [{
+    label: 'Open in editor',
+    action: handleOpenInEditor
+  }, {
+    label: 'Edit tools',
+    action: () => setEditMode('edit-tools')
+  }, {
+    label: 'Edit model',
+    action: () => setEditMode('edit-model')
+  }, {
+    label: 'Edit color',
+    action: () => setEditMode('edit-color')
+  }], [handleOpenInEditor]);
+  const handleEscape = useCallback(() => {
+    setError(null);
+    if (editMode === 'menu') {
+      onBack();
+    } else {
+      setEditMode('menu');
+    }
+  }, [editMode, onBack]);
+  const handleMenuKeyDown = useCallback((e: KeyboardEvent) => {
+    if (e.key === 'up') {
+      e.preventDefault();
+      setSelectedMenuIndex(index => Math.max(0, index - 1));
+    } else if (e.key === 'down') {
+      e.preventDefault();
+      setSelectedMenuIndex(index_0 => Math.min(menuItems.length - 1, index_0 + 1));
+    } else if (e.key === 'return') {
+      e.preventDefault();
+      const selectedItem = menuItems[selectedMenuIndex];
+      if (selectedItem) {
+        void selectedItem.action();
+      }
+    }
+  }, [menuItems, selectedMenuIndex]);
+  useKeybinding('confirm:no', handleEscape, {
+    context: 'Confirmation'
+  });
+  const renderMenu = (): React.ReactNode => <Box flexDirection="column" tabIndex={0} autoFocus onKeyDown={handleMenuKeyDown}>
+      <Text dimColor>Source: {getAgentSourceDisplayName(agent.source)}</Text>
+
+      <Box marginTop={1} flexDirection="column">
+        {menuItems.map((item, index_1) => <Text key={item.label} color={index_1 === selectedMenuIndex ? 'suggestion' : undefined}>
+            {index_1 === selectedMenuIndex ? `${figures.pointer} ` : '  '}
+            {item.label}
+          </Text>)}
+      </Box>
+
+      {error && <Box marginTop={1}>
+          <Text color="error">{error}</Text>
+        </Box>}
+    </Box>;
+  switch (editMode) {
+    case 'menu':
+      return renderMenu();
+    case 'edit-tools':
+      return <ToolSelector tools={tools} initialTools={agent.tools} onComplete={async finalTools => {
+        setEditMode('menu');
+        await handleSave({
+          tools: finalTools
+        });
+      }} />;
+    case 'edit-color':
+      return <ColorPicker agentName={agent.agentType} currentColor={selectedColor || agent.color as AgentColorName || 'automatic'} onConfirm={async color => {
+        setSelectedColor(color);
+        setEditMode('menu');
+        await handleSave({
+          color
+        });
+      }} />;
+    case 'edit-model':
+      return <ModelSelector initialModel={agent.model} onComplete={async model => {
+        setEditMode('menu');
+        await handleSave({
+          model
+        });
+      }} />;
+    default:
+      return null;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","figures","React","useCallback","useMemo","useState","useSetAppState","KeyboardEvent","Box","Text","useKeybinding","Tools","AgentColorName","setAgentColor","AgentDefinition","getActiveAgentsFromList","isCustomAgent","isPluginAgent","editFileInEditor","getActualAgentFilePath","updateAgentFile","ColorPicker","ModelSelector","ToolSelector","getAgentSourceDisplayName","Props","agent","tools","onSaved","message","onBack","EditMode","SaveChanges","color","model","AgentEditor","ReactNode","setAppState","editMode","setEditMode","selectedMenuIndex","setSelectedMenuIndex","error","setError","selectedColor","setSelectedColor","handleOpenInEditor","filePath","result","agentType","handleSave","changes","newTools","newColor","newModel","finalColor","hasToolsChanged","undefined","hasModelChanged","hasColorChanged","whenToUse","getSystemPrompt","state","allAgents","agentDefinitions","map","a","activeAgents","bold","err","Error","menuItems","label","action","handleEscape","handleMenuKeyDown","e","key","preventDefault","index","Math","max","min","length","selectedItem","context","renderMenu","source","item","pointer","finalTools"],"sources":["AgentEditor.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport figures from 'figures'\nimport * as React from 'react'\nimport { useCallback, useMemo, useState } from 'react'\nimport { useSetAppState } from 'src/state/AppState.js'\nimport type { KeyboardEvent } from '../../ink/events/keyboard-event.js'\nimport { Box, Text } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport type { Tools } from '../../Tool.js'\nimport {\n  type AgentColorName,\n  setAgentColor,\n} from '../../tools/AgentTool/agentColorManager.js'\nimport {\n  type AgentDefinition,\n  getActiveAgentsFromList,\n  isCustomAgent,\n  isPluginAgent,\n} from '../../tools/AgentTool/loadAgentsDir.js'\nimport { editFileInEditor } from '../../utils/promptEditor.js'\nimport { getActualAgentFilePath, updateAgentFile } from './agentFileUtils.js'\nimport { ColorPicker } from './ColorPicker.js'\nimport { ModelSelector } from './ModelSelector.js'\nimport { ToolSelector } from './ToolSelector.js'\nimport { getAgentSourceDisplayName } from './utils.js'\n\ntype Props = {\n  agent: AgentDefinition\n  tools: Tools\n  onSaved: (message: string) => void\n  onBack: () => void\n}\n\ntype EditMode = 'menu' | 'edit-tools' | 'edit-color' | 'edit-model'\n\ntype SaveChanges = {\n  tools?: string[]\n  color?: AgentColorName\n  model?: string\n}\n\nexport function AgentEditor({\n  agent,\n  tools,\n  onSaved,\n  onBack,\n}: Props): React.ReactNode {\n  const setAppState = useSetAppState()\n  const [editMode, setEditMode] = useState<EditMode>('menu')\n  const [selectedMenuIndex, setSelectedMenuIndex] = useState(0)\n  const [error, setError] = useState<string | null>(null)\n  const [selectedColor, setSelectedColor] = useState<\n    AgentColorName | undefined\n  >(agent.color as AgentColorName | undefined)\n\n  const handleOpenInEditor = useCallback(async () => {\n    const filePath = getActualAgentFilePath(agent)\n    const result = await editFileInEditor(filePath)\n\n    if (result.error) {\n      setError(result.error)\n    } else {\n      onSaved(\n        `Opened ${agent.agentType} in editor. If you made edits, restart to load the latest version.`,\n      )\n    }\n  }, [agent, onSaved])\n\n  const handleSave = useCallback(\n    async (changes: SaveChanges = {}) => {\n      const { tools: newTools, color: newColor, model: newModel } = changes\n      const finalColor = newColor ?? selectedColor\n      const hasToolsChanged = newTools !== undefined\n      const hasModelChanged = newModel !== undefined\n      const hasColorChanged = finalColor !== agent.color\n\n      if (!hasToolsChanged && !hasModelChanged && !hasColorChanged) {\n        return false\n      }\n\n      try {\n        // Only custom/plugin agents can be edited\n        // this is for type safety; the UI shouldn't allow editing otherwise\n        if (!isCustomAgent(agent) && !isPluginAgent(agent)) {\n          return false\n        }\n\n        await updateAgentFile(\n          agent,\n          agent.whenToUse,\n          newTools ?? agent.tools,\n          agent.getSystemPrompt(),\n          finalColor,\n          newModel ?? agent.model,\n        )\n\n        if (hasColorChanged && finalColor) {\n          setAgentColor(agent.agentType, finalColor)\n        }\n\n        setAppState(state => {\n          const allAgents = state.agentDefinitions.allAgents.map(a =>\n            a.agentType === agent.agentType\n              ? {\n                  ...a,\n                  tools: newTools ?? a.tools,\n                  color: finalColor,\n                  model: newModel ?? a.model,\n                }\n              : a,\n          )\n          return {\n            ...state,\n            agentDefinitions: {\n              ...state.agentDefinitions,\n              activeAgents: getActiveAgentsFromList(allAgents),\n              allAgents,\n            },\n          }\n        })\n\n        onSaved(`Updated agent: ${chalk.bold(agent.agentType)}`)\n        return true\n      } catch (err) {\n        setError(err instanceof Error ? err.message : 'Failed to save agent')\n        return false\n      }\n    },\n    [agent, selectedColor, onSaved, setAppState],\n  )\n\n  const menuItems = useMemo(\n    () => [\n      { label: 'Open in editor', action: handleOpenInEditor },\n      { label: 'Edit tools', action: () => setEditMode('edit-tools') },\n      { label: 'Edit model', action: () => setEditMode('edit-model') },\n      { label: 'Edit color', action: () => setEditMode('edit-color') },\n    ],\n    [handleOpenInEditor],\n  )\n\n  const handleEscape = useCallback(() => {\n    setError(null)\n    if (editMode === 'menu') {\n      onBack()\n    } else {\n      setEditMode('menu')\n    }\n  }, [editMode, onBack])\n\n  const handleMenuKeyDown = useCallback(\n    (e: KeyboardEvent) => {\n      if (e.key === 'up') {\n        e.preventDefault()\n        setSelectedMenuIndex(index => Math.max(0, index - 1))\n      } else if (e.key === 'down') {\n        e.preventDefault()\n        setSelectedMenuIndex(index => Math.min(menuItems.length - 1, index + 1))\n      } else if (e.key === 'return') {\n        e.preventDefault()\n        const selectedItem = menuItems[selectedMenuIndex]\n        if (selectedItem) {\n          void selectedItem.action()\n        }\n      }\n    },\n    [menuItems, selectedMenuIndex],\n  )\n\n  useKeybinding('confirm:no', handleEscape, { context: 'Confirmation' })\n\n  const renderMenu = (): React.ReactNode => (\n    <Box\n      flexDirection=\"column\"\n      tabIndex={0}\n      autoFocus\n      onKeyDown={handleMenuKeyDown}\n    >\n      <Text dimColor>Source: {getAgentSourceDisplayName(agent.source)}</Text>\n\n      <Box marginTop={1} flexDirection=\"column\">\n        {menuItems.map((item, index) => (\n          <Text\n            key={item.label}\n            color={index === selectedMenuIndex ? 'suggestion' : undefined}\n          >\n            {index === selectedMenuIndex ? `${figures.pointer} ` : '  '}\n            {item.label}\n          </Text>\n        ))}\n      </Box>\n\n      {error && (\n        <Box marginTop={1}>\n          <Text color=\"error\">{error}</Text>\n        </Box>\n      )}\n    </Box>\n  )\n\n  switch (editMode) {\n    case 'menu':\n      return renderMenu()\n\n    case 'edit-tools':\n      return (\n        <ToolSelector\n          tools={tools}\n          initialTools={agent.tools}\n          onComplete={async finalTools => {\n            setEditMode('menu')\n            await handleSave({ tools: finalTools })\n          }}\n        />\n      )\n\n    case 'edit-color':\n      return (\n        <ColorPicker\n          agentName={agent.agentType}\n          currentColor={\n            selectedColor || (agent.color as AgentColorName) || 'automatic'\n          }\n          onConfirm={async color => {\n            setSelectedColor(color)\n            setEditMode('menu')\n            await handleSave({ color })\n          }}\n        />\n      )\n\n    case 'edit-model':\n      return (\n        <ModelSelector\n          initialModel={agent.model}\n          onComplete={async model => {\n            setEditMode('menu')\n            await handleSave({ model })\n          }}\n        />\n      )\n\n    default:\n      return null\n  }\n}\n"],"mappings":"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","ignoreList":[]}

src/components/agents/AgentNavigationFooter.tsx

@@ -0,0 +1,26 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+import { Box, Text } from '../../ink.js';
+type Props = {
+  instructions?: string;
+};
+export function AgentNavigationFooter(t0) {
+  const $ = _c(2);
+  const {
+    instructions: t1
+  } = t0;
+  const instructions = t1 === undefined ? "Press \u2191\u2193 to navigate \xB7 Enter to select \xB7 Esc to go back" : t1;
+  const exitState = useExitOnCtrlCDWithKeybindings();
+  const t2 = exitState.pending ? `Press ${exitState.keyName} again to exit` : instructions;
+  let t3;
+  if ($[0] !== t2) {
+    t3 = <Box marginLeft={2}><Text dimColor={true}>{t2}</Text></Box>;
+    $[0] = t2;
+    $[1] = t3;
+  } else {
+    t3 = $[1];
+  }
+  return t3;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/agents/AgentsMenu.tsx

@@ -0,0 +1,800 @@
+import { c as _c } from "react/compiler-runtime";
+import chalk from 'chalk';
+import * as React from 'react';
+import { useCallback, useMemo, useState } from 'react';
+import type { SettingSource } from 'src/utils/settings/constants.js';
+import type { CommandResultDisplay } from '../../commands.js';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+import { useMergedTools } from '../../hooks/useMergedTools.js';
+import { Box, Text } from '../../ink.js';
+import { useAppState, useSetAppState } from '../../state/AppState.js';
+import type { Tools } from '../../Tool.js';
+import { type ResolvedAgent, resolveAgentOverrides } from '../../tools/AgentTool/agentDisplay.js';
+import { type AgentDefinition, getActiveAgentsFromList } from '../../tools/AgentTool/loadAgentsDir.js';
+import { toError } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { Select } from '../CustomSelect/select.js';
+import { Dialog } from '../design-system/Dialog.js';
+import { AgentDetail } from './AgentDetail.js';
+import { AgentEditor } from './AgentEditor.js';
+import { AgentNavigationFooter } from './AgentNavigationFooter.js';
+import { AgentsList } from './AgentsList.js';
+import { deleteAgentFromFile } from './agentFileUtils.js';
+import { CreateAgentWizard } from './new-agent-creation/CreateAgentWizard.js';
+import type { ModeState } from './types.js';
+type Props = {
+  tools: Tools;
+  onExit: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+};
+export function AgentsMenu(t0) {
+  const $ = _c(157);
+  const {
+    tools,
+    onExit
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = {
+      mode: "list-agents",
+      source: "all"
+    };
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const [modeState, setModeState] = useState(t1);
+  const agentDefinitions = useAppState(_temp);
+  const mcpTools = useAppState(_temp2);
+  const toolPermissionContext = useAppState(_temp3);
+  const setAppState = useSetAppState();
+  const {
+    allAgents,
+    activeAgents: agents
+  } = agentDefinitions;
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = [];
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  const [changes, setChanges] = useState(t2);
+  const mergedTools = useMergedTools(tools, mcpTools, toolPermissionContext);
+  useExitOnCtrlCDWithKeybindings();
+  let t3;
+  if ($[2] !== allAgents) {
+    t3 = allAgents.filter(_temp4);
+    $[2] = allAgents;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  let t4;
+  if ($[4] !== allAgents) {
+    t4 = allAgents.filter(_temp5);
+    $[4] = allAgents;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  let t5;
+  if ($[6] !== allAgents) {
+    t5 = allAgents.filter(_temp6);
+    $[6] = allAgents;
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  let t6;
+  if ($[8] !== allAgents) {
+    t6 = allAgents.filter(_temp7);
+    $[8] = allAgents;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  let t7;
+  if ($[10] !== allAgents) {
+    t7 = allAgents.filter(_temp8);
+    $[10] = allAgents;
+    $[11] = t7;
+  } else {
+    t7 = $[11];
+  }
+  let t8;
+  if ($[12] !== allAgents) {
+    t8 = allAgents.filter(_temp9);
+    $[12] = allAgents;
+    $[13] = t8;
+  } else {
+    t8 = $[13];
+  }
+  let t9;
+  if ($[14] !== allAgents) {
+    t9 = allAgents.filter(_temp0);
+    $[14] = allAgents;
+    $[15] = t9;
+  } else {
+    t9 = $[15];
+  }
+  let t10;
+  if ($[16] !== allAgents || $[17] !== t3 || $[18] !== t4 || $[19] !== t5 || $[20] !== t6 || $[21] !== t7 || $[22] !== t8 || $[23] !== t9) {
+    t10 = {
+      "built-in": t3,
+      userSettings: t4,
+      projectSettings: t5,
+      policySettings: t6,
+      localSettings: t7,
+      flagSettings: t8,
+      plugin: t9,
+      all: allAgents
+    };
+    $[16] = allAgents;
+    $[17] = t3;
+    $[18] = t4;
+    $[19] = t5;
+    $[20] = t6;
+    $[21] = t7;
+    $[22] = t8;
+    $[23] = t9;
+    $[24] = t10;
+  } else {
+    t10 = $[24];
+  }
+  const agentsBySource = t10;
+  let t11;
+  if ($[25] === Symbol.for("react.memo_cache_sentinel")) {
+    t11 = message => {
+      setChanges(prev => [...prev, message]);
+      setModeState({
+        mode: "list-agents",
+        source: "all"
+      });
+    };
+    $[25] = t11;
+  } else {
+    t11 = $[25];
+  }
+  const handleAgentCreated = t11;
+  let t12;
+  if ($[26] !== setAppState) {
+    t12 = async agent => {
+      ;
+      try {
+        await deleteAgentFromFile(agent);
+        setAppState(state => {
+          const allAgents_0 = state.agentDefinitions.allAgents.filter(a_6 => !(a_6.agentType === agent.agentType && a_6.source === agent.source));
+          return {
+            ...state,
+            agentDefinitions: {
+              ...state.agentDefinitions,
+              allAgents: allAgents_0,
+              activeAgents: getActiveAgentsFromList(allAgents_0)
+            }
+          };
+        });
+        setChanges(prev_0 => [...prev_0, `Deleted agent: ${chalk.bold(agent.agentType)}`]);
+        setModeState({
+          mode: "list-agents",
+          source: "all"
+        });
+      } catch (t13) {
+        const error = t13;
+        logError(toError(error));
+      }
+    };
+    $[26] = setAppState;
+    $[27] = t12;
+  } else {
+    t12 = $[27];
+  }
+  const handleAgentDeleted = t12;
+  switch (modeState.mode) {
+    case "list-agents":
+      {
+        let t13;
+        if ($[28] !== agentsBySource || $[29] !== modeState.source) {
+          t13 = modeState.source === "all" ? [...agentsBySource["built-in"], ...agentsBySource.userSettings, ...agentsBySource.projectSettings, ...agentsBySource.localSettings, ...agentsBySource.policySettings, ...agentsBySource.flagSettings, ...agentsBySource.plugin] : agentsBySource[modeState.source];
+          $[28] = agentsBySource;
+          $[29] = modeState.source;
+          $[30] = t13;
+        } else {
+          t13 = $[30];
+        }
+        const agentsToShow = t13;
+        let t14;
+        if ($[31] !== agents || $[32] !== agentsToShow) {
+          t14 = resolveAgentOverrides(agentsToShow, agents);
+          $[31] = agents;
+          $[32] = agentsToShow;
+          $[33] = t14;
+        } else {
+          t14 = $[33];
+        }
+        const allResolved = t14;
+        const resolvedAgents = allResolved;
+        let t15;
+        if ($[34] !== changes || $[35] !== onExit) {
+          t15 = () => {
+            const exitMessage = changes.length > 0 ? `Agent changes:\n${changes.join("\n")}` : undefined;
+            onExit(exitMessage ?? "Agents dialog dismissed", {
+              display: changes.length === 0 ? "system" : undefined
+            });
+          };
+          $[34] = changes;
+          $[35] = onExit;
+          $[36] = t15;
+        } else {
+          t15 = $[36];
+        }
+        let t16;
+        if ($[37] !== modeState) {
+          t16 = agent_0 => setModeState({
+            mode: "agent-menu",
+            agent: agent_0,
+            previousMode: modeState
+          });
+          $[37] = modeState;
+          $[38] = t16;
+        } else {
+          t16 = $[38];
+        }
+        let t17;
+        if ($[39] === Symbol.for("react.memo_cache_sentinel")) {
+          t17 = () => setModeState({
+            mode: "create-agent"
+          });
+          $[39] = t17;
+        } else {
+          t17 = $[39];
+        }
+        let t18;
+        if ($[40] !== changes || $[41] !== modeState.source || $[42] !== resolvedAgents || $[43] !== t15 || $[44] !== t16) {
+          t18 = <AgentsList source={modeState.source} agents={resolvedAgents} onBack={t15} onSelect={t16} onCreateNew={t17} changes={changes} />;
+          $[40] = changes;
+          $[41] = modeState.source;
+          $[42] = resolvedAgents;
+          $[43] = t15;
+          $[44] = t16;
+          $[45] = t18;
+        } else {
+          t18 = $[45];
+        }
+        let t19;
+        if ($[46] === Symbol.for("react.memo_cache_sentinel")) {
+          t19 = <AgentNavigationFooter />;
+          $[46] = t19;
+        } else {
+          t19 = $[46];
+        }
+        let t20;
+        if ($[47] !== t18) {
+          t20 = <>{t18}{t19}</>;
+          $[47] = t18;
+          $[48] = t20;
+        } else {
+          t20 = $[48];
+        }
+        return t20;
+      }
+    case "create-agent":
+      {
+        let t13;
+        if ($[49] === Symbol.for("react.memo_cache_sentinel")) {
+          t13 = () => setModeState({
+            mode: "list-agents",
+            source: "all"
+          });
+          $[49] = t13;
+        } else {
+          t13 = $[49];
+        }
+        let t14;
+        if ($[50] !== agents || $[51] !== mergedTools) {
+          t14 = <CreateAgentWizard tools={mergedTools} existingAgents={agents} onComplete={handleAgentCreated} onCancel={t13} />;
+          $[50] = agents;
+          $[51] = mergedTools;
+          $[52] = t14;
+        } else {
+          t14 = $[52];
+        }
+        return t14;
+      }
+    case "agent-menu":
+      {
+        let t13;
+        if ($[53] !== allAgents || $[54] !== modeState.agent.agentType || $[55] !== modeState.agent.source) {
+          let t14;
+          if ($[57] !== modeState.agent.agentType || $[58] !== modeState.agent.source) {
+            t14 = a_9 => a_9.agentType === modeState.agent.agentType && a_9.source === modeState.agent.source;
+            $[57] = modeState.agent.agentType;
+            $[58] = modeState.agent.source;
+            $[59] = t14;
+          } else {
+            t14 = $[59];
+          }
+          t13 = allAgents.find(t14);
+          $[53] = allAgents;
+          $[54] = modeState.agent.agentType;
+          $[55] = modeState.agent.source;
+          $[56] = t13;
+        } else {
+          t13 = $[56];
+        }
+        const freshAgent_1 = t13;
+        const agentToUse = freshAgent_1 || modeState.agent;
+        const isEditable = agentToUse.source !== "built-in" && agentToUse.source !== "plugin" && agentToUse.source !== "flagSettings";
+        let t14;
+        if ($[60] === Symbol.for("react.memo_cache_sentinel")) {
+          t14 = {
+            label: "View agent",
+            value: "view"
+          };
+          $[60] = t14;
+        } else {
+          t14 = $[60];
+        }
+        let t15;
+        if ($[61] !== isEditable) {
+          t15 = isEditable ? [{
+            label: "Edit agent",
+            value: "edit"
+          }, {
+            label: "Delete agent",
+            value: "delete"
+          }] : [];
+          $[61] = isEditable;
+          $[62] = t15;
+        } else {
+          t15 = $[62];
+        }
+        let t16;
+        if ($[63] === Symbol.for("react.memo_cache_sentinel")) {
+          t16 = {
+            label: "Back",
+            value: "back"
+          };
+          $[63] = t16;
+        } else {
+          t16 = $[63];
+        }
+        let t17;
+        if ($[64] !== t15) {
+          t17 = [t14, ...t15, t16];
+          $[64] = t15;
+          $[65] = t17;
+        } else {
+          t17 = $[65];
+        }
+        const menuItems = t17;
+        let t18;
+        if ($[66] !== agentToUse || $[67] !== modeState) {
+          t18 = value_0 => {
+            bb129: switch (value_0) {
+              case "view":
+                {
+                  setModeState({
+                    mode: "view-agent",
+                    agent: agentToUse,
+                    previousMode: modeState.previousMode
+                  });
+                  break bb129;
+                }
+              case "edit":
+                {
+                  setModeState({
+                    mode: "edit-agent",
+                    agent: agentToUse,
+                    previousMode: modeState
+                  });
+                  break bb129;
+                }
+              case "delete":
+                {
+                  setModeState({
+                    mode: "delete-confirm",
+                    agent: agentToUse,
+                    previousMode: modeState
+                  });
+                  break bb129;
+                }
+              case "back":
+                {
+                  setModeState(modeState.previousMode);
+                }
+            }
+          };
+          $[66] = agentToUse;
+          $[67] = modeState;
+          $[68] = t18;
+        } else {
+          t18 = $[68];
+        }
+        const handleMenuSelect = t18;
+        let t19;
+        if ($[69] !== modeState.previousMode) {
+          t19 = () => setModeState(modeState.previousMode);
+          $[69] = modeState.previousMode;
+          $[70] = t19;
+        } else {
+          t19 = $[70];
+        }
+        let t20;
+        if ($[71] !== modeState.previousMode) {
+          t20 = () => setModeState(modeState.previousMode);
+          $[71] = modeState.previousMode;
+          $[72] = t20;
+        } else {
+          t20 = $[72];
+        }
+        let t21;
+        if ($[73] !== handleMenuSelect || $[74] !== menuItems || $[75] !== t20) {
+          t21 = <Select options={menuItems} onChange={handleMenuSelect} onCancel={t20} />;
+          $[73] = handleMenuSelect;
+          $[74] = menuItems;
+          $[75] = t20;
+          $[76] = t21;
+        } else {
+          t21 = $[76];
+        }
+        let t22;
+        if ($[77] !== changes) {
+          t22 = changes.length > 0 && <Box marginTop={1}><Text dimColor={true}>{changes[changes.length - 1]}</Text></Box>;
+          $[77] = changes;
+          $[78] = t22;
+        } else {
+          t22 = $[78];
+        }
+        let t23;
+        if ($[79] !== t21 || $[80] !== t22) {
+          t23 = <Box flexDirection="column">{t21}{t22}</Box>;
+          $[79] = t21;
+          $[80] = t22;
+          $[81] = t23;
+        } else {
+          t23 = $[81];
+        }
+        let t24;
+        if ($[82] !== modeState.agent.agentType || $[83] !== t19 || $[84] !== t23) {
+          t24 = <Dialog title={modeState.agent.agentType} onCancel={t19} hideInputGuide={true}>{t23}</Dialog>;
+          $[82] = modeState.agent.agentType;
+          $[83] = t19;
+          $[84] = t23;
+          $[85] = t24;
+        } else {
+          t24 = $[85];
+        }
+        let t25;
+        if ($[86] === Symbol.for("react.memo_cache_sentinel")) {
+          t25 = <AgentNavigationFooter />;
+          $[86] = t25;
+        } else {
+          t25 = $[86];
+        }
+        let t26;
+        if ($[87] !== t24) {
+          t26 = <>{t24}{t25}</>;
+          $[87] = t24;
+          $[88] = t26;
+        } else {
+          t26 = $[88];
+        }
+        return t26;
+      }
+    case "view-agent":
+      {
+        let t13;
+        if ($[89] !== allAgents || $[90] !== modeState.agent) {
+          let t14;
+          if ($[92] !== modeState.agent) {
+            t14 = a_8 => a_8.agentType === modeState.agent.agentType && a_8.source === modeState.agent.source;
+            $[92] = modeState.agent;
+            $[93] = t14;
+          } else {
+            t14 = $[93];
+          }
+          t13 = allAgents.find(t14);
+          $[89] = allAgents;
+          $[90] = modeState.agent;
+          $[91] = t13;
+        } else {
+          t13 = $[91];
+        }
+        const freshAgent_0 = t13;
+        const agentToDisplay = freshAgent_0 || modeState.agent;
+        let t14;
+        if ($[94] !== agentToDisplay || $[95] !== modeState.previousMode) {
+          t14 = () => setModeState({
+            mode: "agent-menu",
+            agent: agentToDisplay,
+            previousMode: modeState.previousMode
+          });
+          $[94] = agentToDisplay;
+          $[95] = modeState.previousMode;
+          $[96] = t14;
+        } else {
+          t14 = $[96];
+        }
+        let t15;
+        if ($[97] !== agentToDisplay || $[98] !== modeState.previousMode) {
+          t15 = () => setModeState({
+            mode: "agent-menu",
+            agent: agentToDisplay,
+            previousMode: modeState.previousMode
+          });
+          $[97] = agentToDisplay;
+          $[98] = modeState.previousMode;
+          $[99] = t15;
+        } else {
+          t15 = $[99];
+        }
+        let t16;
+        if ($[100] !== agentToDisplay || $[101] !== allAgents || $[102] !== mergedTools || $[103] !== t15) {
+          t16 = <AgentDetail agent={agentToDisplay} tools={mergedTools} allAgents={allAgents} onBack={t15} />;
+          $[100] = agentToDisplay;
+          $[101] = allAgents;
+          $[102] = mergedTools;
+          $[103] = t15;
+          $[104] = t16;
+        } else {
+          t16 = $[104];
+        }
+        let t17;
+        if ($[105] !== agentToDisplay.agentType || $[106] !== t14 || $[107] !== t16) {
+          t17 = <Dialog title={agentToDisplay.agentType} onCancel={t14} hideInputGuide={true}>{t16}</Dialog>;
+          $[105] = agentToDisplay.agentType;
+          $[106] = t14;
+          $[107] = t16;
+          $[108] = t17;
+        } else {
+          t17 = $[108];
+        }
+        let t18;
+        if ($[109] === Symbol.for("react.memo_cache_sentinel")) {
+          t18 = <AgentNavigationFooter instructions="Press Enter or Esc to go back" />;
+          $[109] = t18;
+        } else {
+          t18 = $[109];
+        }
+        let t19;
+        if ($[110] !== t17) {
+          t19 = <>{t17}{t18}</>;
+          $[110] = t17;
+          $[111] = t19;
+        } else {
+          t19 = $[111];
+        }
+        return t19;
+      }
+    case "delete-confirm":
+      {
+        let t13;
+        if ($[112] === Symbol.for("react.memo_cache_sentinel")) {
+          t13 = [{
+            label: "Yes, delete",
+            value: "yes"
+          }, {
+            label: "No, cancel",
+            value: "no"
+          }];
+          $[112] = t13;
+        } else {
+          t13 = $[112];
+        }
+        const deleteOptions = t13;
+        let t14;
+        if ($[113] !== modeState) {
+          t14 = () => {
+            if ("previousMode" in modeState) {
+              setModeState(modeState.previousMode);
+            }
+          };
+          $[113] = modeState;
+          $[114] = t14;
+        } else {
+          t14 = $[114];
+        }
+        let t15;
+        if ($[115] !== modeState.agent.agentType) {
+          t15 = <Text>Are you sure you want to delete the agent{" "}<Text bold={true}>{modeState.agent.agentType}</Text>?</Text>;
+          $[115] = modeState.agent.agentType;
+          $[116] = t15;
+        } else {
+          t15 = $[116];
+        }
+        let t16;
+        if ($[117] !== modeState.agent.source) {
+          t16 = <Box marginTop={1}><Text dimColor={true}>Source: {modeState.agent.source}</Text></Box>;
+          $[117] = modeState.agent.source;
+          $[118] = t16;
+        } else {
+          t16 = $[118];
+        }
+        let t17;
+        if ($[119] !== handleAgentDeleted || $[120] !== modeState) {
+          t17 = value => {
+            if (value === "yes") {
+              handleAgentDeleted(modeState.agent);
+            } else {
+              if ("previousMode" in modeState) {
+                setModeState(modeState.previousMode);
+              }
+            }
+          };
+          $[119] = handleAgentDeleted;
+          $[120] = modeState;
+          $[121] = t17;
+        } else {
+          t17 = $[121];
+        }
+        let t18;
+        if ($[122] !== modeState) {
+          t18 = () => {
+            if ("previousMode" in modeState) {
+              setModeState(modeState.previousMode);
+            }
+          };
+          $[122] = modeState;
+          $[123] = t18;
+        } else {
+          t18 = $[123];
+        }
+        let t19;
+        if ($[124] !== t17 || $[125] !== t18) {
+          t19 = <Box marginTop={1}><Select options={deleteOptions} onChange={t17} onCancel={t18} /></Box>;
+          $[124] = t17;
+          $[125] = t18;
+          $[126] = t19;
+        } else {
+          t19 = $[126];
+        }
+        let t20;
+        if ($[127] !== t14 || $[128] !== t15 || $[129] !== t16 || $[130] !== t19) {
+          t20 = <Dialog title="Delete agent" onCancel={t14} color="error">{t15}{t16}{t19}</Dialog>;
+          $[127] = t14;
+          $[128] = t15;
+          $[129] = t16;
+          $[130] = t19;
+          $[131] = t20;
+        } else {
+          t20 = $[131];
+        }
+        let t21;
+        if ($[132] === Symbol.for("react.memo_cache_sentinel")) {
+          t21 = <AgentNavigationFooter instructions={"Press \u2191\u2193 to navigate, Enter to select, Esc to cancel"} />;
+          $[132] = t21;
+        } else {
+          t21 = $[132];
+        }
+        let t22;
+        if ($[133] !== t20) {
+          t22 = <>{t20}{t21}</>;
+          $[133] = t20;
+          $[134] = t22;
+        } else {
+          t22 = $[134];
+        }
+        return t22;
+      }
+    case "edit-agent":
+      {
+        let t13;
+        if ($[135] !== allAgents || $[136] !== modeState.agent) {
+          let t14;
+          if ($[138] !== modeState.agent) {
+            t14 = a_7 => a_7.agentType === modeState.agent.agentType && a_7.source === modeState.agent.source;
+            $[138] = modeState.agent;
+            $[139] = t14;
+          } else {
+            t14 = $[139];
+          }
+          t13 = allAgents.find(t14);
+          $[135] = allAgents;
+          $[136] = modeState.agent;
+          $[137] = t13;
+        } else {
+          t13 = $[137];
+        }
+        const freshAgent = t13;
+        const agentToEdit = freshAgent || modeState.agent;
+        const t14 = `Edit agent: ${agentToEdit.agentType}`;
+        let t15;
+        if ($[140] !== modeState.previousMode) {
+          t15 = () => setModeState(modeState.previousMode);
+          $[140] = modeState.previousMode;
+          $[141] = t15;
+        } else {
+          t15 = $[141];
+        }
+        let t16;
+        let t17;
+        if ($[142] !== modeState.previousMode) {
+          t16 = message_0 => {
+            handleAgentCreated(message_0);
+            setModeState(modeState.previousMode);
+          };
+          t17 = () => setModeState(modeState.previousMode);
+          $[142] = modeState.previousMode;
+          $[143] = t16;
+          $[144] = t17;
+        } else {
+          t16 = $[143];
+          t17 = $[144];
+        }
+        let t18;
+        if ($[145] !== agentToEdit || $[146] !== mergedTools || $[147] !== t16 || $[148] !== t17) {
+          t18 = <AgentEditor agent={agentToEdit} tools={mergedTools} onSaved={t16} onBack={t17} />;
+          $[145] = agentToEdit;
+          $[146] = mergedTools;
+          $[147] = t16;
+          $[148] = t17;
+          $[149] = t18;
+        } else {
+          t18 = $[149];
+        }
+        let t19;
+        if ($[150] !== t14 || $[151] !== t15 || $[152] !== t18) {
+          t19 = <Dialog title={t14} onCancel={t15} hideInputGuide={true}>{t18}</Dialog>;
+          $[150] = t14;
+          $[151] = t15;
+          $[152] = t18;
+          $[153] = t19;
+        } else {
+          t19 = $[153];
+        }
+        let t20;
+        if ($[154] === Symbol.for("react.memo_cache_sentinel")) {
+          t20 = <AgentNavigationFooter />;
+          $[154] = t20;
+        } else {
+          t20 = $[154];
+        }
+        let t21;
+        if ($[155] !== t19) {
+          t21 = <>{t19}{t20}</>;
+          $[155] = t19;
+          $[156] = t21;
+        } else {
+          t21 = $[156];
+        }
+        return t21;
+      }
+    default:
+      {
+        return null;
+      }
+  }
+}
+function _temp0(a_5) {
+  return a_5.source === "plugin";
+}
+function _temp9(a_4) {
+  return a_4.source === "flagSettings";
+}
+function _temp8(a_3) {
+  return a_3.source === "localSettings";
+}
+function _temp7(a_2) {
+  return a_2.source === "policySettings";
+}
+function _temp6(a_1) {
+  return a_1.source === "projectSettings";
+}
+function _temp5(a_0) {
+  return a_0.source === "userSettings";
+}
+function _temp4(a) {
+  return a.source === "built-in";
+}
+function _temp3(s_1) {
+  return s_1.toolPermissionContext;
+}
+function _temp2(s_0) {
+  return s_0.mcp.tools;
+}
+function _temp(s) {
+  return s.agentDefinitions;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","React","useCallback","useMemo","useState","SettingSource","CommandResultDisplay","useExitOnCtrlCDWithKeybindings","useMergedTools","Box","Text","useAppState","useSetAppState","Tools","ResolvedAgent","resolveAgentOverrides","AgentDefinition","getActiveAgentsFromList","toError","logError","Select","Dialog","AgentDetail","AgentEditor","AgentNavigationFooter","AgentsList","deleteAgentFromFile","CreateAgentWizard","ModeState","Props","tools","onExit","result","options","display","AgentsMenu","t0","$","_c","t1","Symbol","for","mode","source","modeState","setModeState","agentDefinitions","_temp","mcpTools","_temp2","toolPermissionContext","_temp3","setAppState","allAgents","activeAgents","agents","t2","changes","setChanges","mergedTools","t3","filter","_temp4","t4","_temp5","t5","_temp6","t6","_temp7","t7","_temp8","t8","_temp9","t9","_temp0","t10","userSettings","projectSettings","policySettings","localSettings","flagSettings","plugin","all","agentsBySource","t11","message","prev","handleAgentCreated","t12","agent","state","allAgents_0","a_6","a","agentType","prev_0","bold","t13","error","handleAgentDeleted","agentsToShow","t14","allResolved","resolvedAgents","t15","exitMessage","length","join","undefined","t16","agent_0","previousMode","t17","t18","t19","t20","a_9","find","freshAgent_1","agentToUse","isEditable","label","value","menuItems","value_0","bb129","handleMenuSelect","t21","t22","t23","t24","t25","t26","a_8","freshAgent_0","agentToDisplay","deleteOptions","a_7","freshAgent","agentToEdit","message_0","a_5","a_4","a_3","a_2","a_1","a_0","s_1","s","s_0","mcp"],"sources":["AgentsMenu.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport * as React from 'react'\nimport { useCallback, useMemo, useState } from 'react'\nimport type { SettingSource } from 'src/utils/settings/constants.js'\nimport type { CommandResultDisplay } from '../../commands.js'\nimport { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport { useMergedTools } from '../../hooks/useMergedTools.js'\nimport { Box, Text } from '../../ink.js'\nimport { useAppState, useSetAppState } from '../../state/AppState.js'\nimport type { Tools } from '../../Tool.js'\nimport {\n  type ResolvedAgent,\n  resolveAgentOverrides,\n} from '../../tools/AgentTool/agentDisplay.js'\nimport {\n  type AgentDefinition,\n  getActiveAgentsFromList,\n} from '../../tools/AgentTool/loadAgentsDir.js'\nimport { toError } from '../../utils/errors.js'\nimport { logError } from '../../utils/log.js'\nimport { Select } from '../CustomSelect/select.js'\nimport { Dialog } from '../design-system/Dialog.js'\nimport { AgentDetail } from './AgentDetail.js'\nimport { AgentEditor } from './AgentEditor.js'\nimport { AgentNavigationFooter } from './AgentNavigationFooter.js'\nimport { AgentsList } from './AgentsList.js'\nimport { deleteAgentFromFile } from './agentFileUtils.js'\nimport { CreateAgentWizard } from './new-agent-creation/CreateAgentWizard.js'\nimport type { ModeState } from './types.js'\n\ntype Props = {\n  tools: Tools\n  onExit: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n}\n\nexport function AgentsMenu({ tools, onExit }: Props): React.ReactNode {\n  const [modeState, setModeState] = useState<ModeState>({\n    mode: 'list-agents',\n    source: 'all',\n  })\n  const agentDefinitions = useAppState(s => s.agentDefinitions)\n  const mcpTools = useAppState(s => s.mcp.tools)\n  const toolPermissionContext = useAppState(s => s.toolPermissionContext)\n  const setAppState = useSetAppState()\n  const { allAgents, activeAgents: agents } = agentDefinitions\n  const [changes, setChanges] = useState<string[]>([])\n\n  // Get MCP tools from app state and merge with local tools\n  const mergedTools = useMergedTools(tools, mcpTools, toolPermissionContext)\n\n  useExitOnCtrlCDWithKeybindings()\n\n  const agentsBySource: Record<\n    SettingSource | 'all' | 'built-in' | 'plugin',\n    AgentDefinition[]\n  > = useMemo(\n    () => ({\n      'built-in': allAgents.filter(a => a.source === 'built-in'),\n      userSettings: allAgents.filter(a => a.source === 'userSettings'),\n      projectSettings: allAgents.filter(a => a.source === 'projectSettings'),\n      policySettings: allAgents.filter(a => a.source === 'policySettings'),\n      localSettings: allAgents.filter(a => a.source === 'localSettings'),\n      flagSettings: allAgents.filter(a => a.source === 'flagSettings'),\n      plugin: allAgents.filter(a => a.source === 'plugin'),\n      all: allAgents,\n    }),\n    [allAgents],\n  )\n\n  const handleAgentCreated = useCallback((message: string) => {\n    setChanges(prev => [...prev, message])\n    setModeState({ mode: 'list-agents', source: 'all' })\n  }, [])\n\n  const handleAgentDeleted = useCallback(\n    async (agent: AgentDefinition) => {\n      try {\n        await deleteAgentFromFile(agent)\n        setAppState(state => {\n          const allAgents = state.agentDefinitions.allAgents.filter(\n            a =>\n              !(a.agentType === agent.agentType && a.source === agent.source),\n          )\n          return {\n            ...state,\n            agentDefinitions: {\n              ...state.agentDefinitions,\n              allAgents,\n              activeAgents: getActiveAgentsFromList(allAgents),\n            },\n          }\n        })\n\n        setChanges(prev => [\n          ...prev,\n          `Deleted agent: ${chalk.bold(agent.agentType)}`,\n        ])\n        // Go back to the agents list after deletion\n        setModeState({ mode: 'list-agents', source: 'all' })\n      } catch (error) {\n        logError(toError(error))\n      }\n    },\n    [setAppState],\n  )\n\n  // Render based on mode\n  switch (modeState.mode) {\n    case 'list-agents': {\n      const agentsToShow =\n        modeState.source === 'all'\n          ? [\n              ...agentsBySource['built-in'],\n              ...agentsBySource['userSettings'],\n              ...agentsBySource['projectSettings'],\n              ...agentsBySource['localSettings'],\n              ...agentsBySource['policySettings'],\n              ...agentsBySource['flagSettings'],\n              ...agentsBySource['plugin'],\n            ]\n          : agentsBySource[modeState.source]\n\n      // Resolve overrides and filter to the agents we want to show\n      const allResolved = resolveAgentOverrides(agentsToShow, agents)\n      const resolvedAgents: ResolvedAgent[] = allResolved\n\n      return (\n        <>\n          <AgentsList\n            source={modeState.source}\n            agents={resolvedAgents}\n            onBack={() => {\n              const exitMessage =\n                changes.length > 0\n                  ? `Agent changes:\\n${changes.join('\\n')}`\n                  : undefined\n              onExit(exitMessage ?? 'Agents dialog dismissed', {\n                display: changes.length === 0 ? 'system' : undefined,\n              })\n            }}\n            onSelect={agent =>\n              setModeState({\n                mode: 'agent-menu',\n                agent,\n                previousMode: modeState,\n              })\n            }\n            onCreateNew={() => setModeState({ mode: 'create-agent' })}\n            changes={changes}\n          />\n          <AgentNavigationFooter />\n        </>\n      )\n    }\n\n    case 'create-agent':\n      return (\n        <CreateAgentWizard\n          tools={mergedTools}\n          existingAgents={agents}\n          onComplete={handleAgentCreated}\n          onCancel={() => setModeState({ mode: 'list-agents', source: 'all' })}\n        />\n      )\n\n    case 'agent-menu': {\n      // Always use fresh agent data\n      const freshAgent = allAgents.find(\n        a =>\n          a.agentType === modeState.agent.agentType &&\n          a.source === modeState.agent.source,\n      )\n      const agentToUse = freshAgent || modeState.agent\n\n      const isEditable =\n        agentToUse.source !== 'built-in' &&\n        agentToUse.source !== 'plugin' &&\n        agentToUse.source !== 'flagSettings'\n      const menuItems = [\n        { label: 'View agent', value: 'view' },\n        ...(isEditable\n          ? [\n              { label: 'Edit agent', value: 'edit' },\n              { label: 'Delete agent', value: 'delete' },\n            ]\n          : []),\n        { label: 'Back', value: 'back' },\n      ]\n\n      const handleMenuSelect = (value: string): void => {\n        switch (value) {\n          case 'view':\n            setModeState({\n              mode: 'view-agent',\n              agent: agentToUse,\n              previousMode: modeState.previousMode,\n            })\n            break\n          case 'edit':\n            setModeState({\n              mode: 'edit-agent',\n              agent: agentToUse,\n              previousMode: modeState,\n            })\n            break\n          case 'delete':\n            setModeState({\n              mode: 'delete-confirm',\n              agent: agentToUse,\n              previousMode: modeState,\n            })\n            break\n          case 'back':\n            setModeState(modeState.previousMode)\n            break\n        }\n      }\n\n      return (\n        <>\n          <Dialog\n            title={modeState.agent.agentType}\n            onCancel={() => setModeState(modeState.previousMode)}\n            hideInputGuide\n          >\n            <Box flexDirection=\"column\">\n              <Select\n                options={menuItems}\n                onChange={handleMenuSelect}\n                onCancel={() => setModeState(modeState.previousMode)}\n              />\n              {changes.length > 0 && (\n                <Box marginTop={1}>\n                  <Text dimColor>{changes[changes.length - 1]}</Text>\n                </Box>\n              )}\n            </Box>\n          </Dialog>\n          <AgentNavigationFooter />\n        </>\n      )\n    }\n\n    case 'view-agent': {\n      // Always use fresh agent data from allAgents\n      const freshAgent = allAgents.find(\n        a =>\n          a.agentType === modeState.agent.agentType &&\n          a.source === modeState.agent.source,\n      )\n      const agentToDisplay = freshAgent || modeState.agent\n\n      return (\n        <>\n          <Dialog\n            title={agentToDisplay.agentType}\n            onCancel={() =>\n              setModeState({\n                mode: 'agent-menu',\n                agent: agentToDisplay,\n                previousMode: modeState.previousMode,\n              })\n            }\n            hideInputGuide\n          >\n            <AgentDetail\n              agent={agentToDisplay}\n              tools={mergedTools}\n              allAgents={allAgents}\n              onBack={() =>\n                setModeState({\n                  mode: 'agent-menu',\n                  agent: agentToDisplay,\n                  previousMode: modeState.previousMode,\n                })\n              }\n            />\n          </Dialog>\n          <AgentNavigationFooter instructions=\"Press Enter or Esc to go back\" />\n        </>\n      )\n    }\n\n    case 'delete-confirm': {\n      const deleteOptions = [\n        { label: 'Yes, delete', value: 'yes' },\n        { label: 'No, cancel', value: 'no' },\n      ]\n\n      return (\n        <>\n          <Dialog\n            title=\"Delete agent\"\n            onCancel={() => {\n              if ('previousMode' in modeState)\n                setModeState(modeState.previousMode)\n            }}\n            color=\"error\"\n          >\n            <Text>\n              Are you sure you want to delete the agent{' '}\n              <Text bold>{modeState.agent.agentType}</Text>?\n            </Text>\n            <Box marginTop={1}>\n              <Text dimColor>Source: {modeState.agent.source}</Text>\n            </Box>\n            <Box marginTop={1}>\n              <Select\n                options={deleteOptions}\n                onChange={(value: string) => {\n                  if (value === 'yes') {\n                    void handleAgentDeleted(modeState.agent)\n                  } else {\n                    if ('previousMode' in modeState) {\n                      setModeState(modeState.previousMode)\n                    }\n                  }\n                }}\n                onCancel={() => {\n                  if ('previousMode' in modeState) {\n                    setModeState(modeState.previousMode)\n                  }\n                }}\n              />\n            </Box>\n          </Dialog>\n          <AgentNavigationFooter instructions=\"Press ↑↓ to navigate, Enter to select, Esc to cancel\" />\n        </>\n      )\n    }\n\n    case 'edit-agent': {\n      // Always use fresh agent data\n      const freshAgent = allAgents.find(\n        a =>\n          a.agentType === modeState.agent.agentType &&\n          a.source === modeState.agent.source,\n      )\n      const agentToEdit = freshAgent || modeState.agent\n\n      return (\n        <>\n          <Dialog\n            title={`Edit agent: ${agentToEdit.agentType}`}\n            onCancel={() => setModeState(modeState.previousMode)}\n            hideInputGuide\n          >\n            <AgentEditor\n              agent={agentToEdit}\n              tools={mergedTools}\n              onSaved={message => {\n                handleAgentCreated(message)\n                setModeState(modeState.previousMode)\n              }}\n              onBack={() => setModeState(modeState.previousMode)}\n            />\n          </Dialog>\n          <AgentNavigationFooter />\n        </>\n      )\n    }\n\n    default:\n      return null\n  }\n}\n"],"mappings":"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","ignoreList":[]}

src/components/agents/ModelSelector.tsx

@@ -0,0 +1,68 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { Box, Text } from '../../ink.js';
+import { getAgentModelOptions } from '../../utils/model/agent.js';
+import { Select } from '../CustomSelect/select.js';
+interface ModelSelectorProps {
+  initialModel?: string;
+  onComplete: (model?: string) => void;
+  onCancel?: () => void;
+}
+export function ModelSelector(t0) {
+  const $ = _c(11);
+  const {
+    initialModel,
+    onComplete,
+    onCancel
+  } = t0;
+  let t1;
+  if ($[0] !== initialModel) {
+    bb0: {
+      const base = getAgentModelOptions();
+      if (initialModel && !base.some(o => o.value === initialModel)) {
+        t1 = [{
+          value: initialModel,
+          label: initialModel,
+          description: "Current model (custom ID)"
+        }, ...base];
+        break bb0;
+      }
+      t1 = base;
+    }
+    $[0] = initialModel;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const modelOptions = t1;
+  const defaultModel = initialModel ?? "sonnet";
+  let t2;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <Box marginBottom={1}><Text dimColor={true}>Model determines the agent's reasoning capabilities and speed.</Text></Box>;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  let t3;
+  if ($[3] !== onCancel || $[4] !== onComplete) {
+    t3 = () => onCancel ? onCancel() : onComplete(undefined);
+    $[3] = onCancel;
+    $[4] = onComplete;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] !== defaultModel || $[7] !== modelOptions || $[8] !== onComplete || $[9] !== t3) {
+    t4 = <Box flexDirection="column">{t2}<Select options={modelOptions} defaultValue={defaultModel} onChange={onComplete} onCancel={t3} /></Box>;
+    $[6] = defaultModel;
+    $[7] = modelOptions;
+    $[8] = onComplete;
+    $[9] = t3;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  return t4;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/agents/new-agent-creation/wizard-steps/MethodStep.tsx

@@ -0,0 +1,80 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { type ReactNode } from 'react';
+import { Box } from '../../../../ink.js';
+import { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js';
+import { Select } from '../../../CustomSelect/select.js';
+import { Byline } from '../../../design-system/Byline.js';
+import { KeyboardShortcutHint } from '../../../design-system/KeyboardShortcutHint.js';
+import { useWizard } from '../../../wizard/index.js';
+import { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js';
+import type { AgentWizardData } from '../types.js';
+export function MethodStep() {
+  const $ = _c(11);
+  const {
+    goNext,
+    goBack,
+    updateWizardData,
+    goToStep
+  } = useWizard();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [{
+      label: "Generate with Claude (recommended)",
+      value: "generate"
+    }, {
+      label: "Manual configuration",
+      value: "manual"
+    }];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const methodOptions = t0;
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <Byline><KeyboardShortcutHint shortcut={"\u2191\u2193"} action="navigate" /><KeyboardShortcutHint shortcut="Enter" action="select" /><ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="go back" /></Byline>;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== goNext || $[3] !== goToStep || $[4] !== updateWizardData) {
+    t2 = value => {
+      const method = value as 'generate' | 'manual';
+      updateWizardData({
+        method,
+        wasGenerated: method === "generate"
+      });
+      if (method === "generate") {
+        goNext();
+      } else {
+        goToStep(3);
+      }
+    };
+    $[2] = goNext;
+    $[3] = goToStep;
+    $[4] = updateWizardData;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] !== goBack) {
+    t3 = () => goBack();
+    $[6] = goBack;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  let t4;
+  if ($[8] !== t2 || $[9] !== t3) {
+    t4 = <WizardDialogLayout subtitle="Creation method" footerText={t1}><Box><Select key="method-select" options={methodOptions} onChange={t2} onCancel={t3} /></Box></WizardDialogLayout>;
+    $[8] = t2;
+    $[9] = t3;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  return t4;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/messages/UserToolResultMessage/UserToolResultMessage.tsx

@@ -0,0 +1,106 @@
+import { c as _c } from "react/compiler-runtime";
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs';
+import * as React from 'react';
+import type { Tools } from '../../../Tool.js';
+import type { NormalizedUserMessage, ProgressMessage } from '../../../types/message.js';
+import { type buildMessageLookups, CANCEL_MESSAGE, INTERRUPT_MESSAGE_FOR_TOOL_USE, REJECT_MESSAGE } from '../../../utils/messages.js';
+import { UserToolCanceledMessage } from './UserToolCanceledMessage.js';
+import { UserToolErrorMessage } from './UserToolErrorMessage.js';
+import { UserToolRejectMessage } from './UserToolRejectMessage.js';
+import { UserToolSuccessMessage } from './UserToolSuccessMessage.js';
+import { useGetToolFromMessages } from './utils.js';
+type Props = {
+  param: ToolResultBlockParam;
+  message: NormalizedUserMessage;
+  lookups: ReturnType<typeof buildMessageLookups>;
+  progressMessagesForMessage: ProgressMessage[];
+  style?: 'condensed';
+  tools: Tools;
+  verbose: boolean;
+  width: number | string;
+  isTranscriptMode?: boolean;
+};
+export function UserToolResultMessage(t0) {
+  const $ = _c(28);
+  const {
+    param,
+    message,
+    lookups,
+    progressMessagesForMessage,
+    style,
+    tools,
+    verbose,
+    width,
+    isTranscriptMode
+  } = t0;
+  const toolUse = useGetToolFromMessages(param.tool_use_id, tools, lookups);
+  if (!toolUse) {
+    return null;
+  }
+  if (typeof param.content === "string" && param.content.startsWith(CANCEL_MESSAGE)) {
+    let t1;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = <UserToolCanceledMessage />;
+      $[0] = t1;
+    } else {
+      t1 = $[0];
+    }
+    return t1;
+  }
+  if (typeof param.content === "string" && param.content.startsWith(REJECT_MESSAGE) || param.content === INTERRUPT_MESSAGE_FOR_TOOL_USE) {
+    const t1 = toolUse.toolUse.input as {
+      [key: string]: unknown;
+    };
+    let t2;
+    if ($[1] !== isTranscriptMode || $[2] !== lookups || $[3] !== progressMessagesForMessage || $[4] !== style || $[5] !== t1 || $[6] !== toolUse.tool || $[7] !== tools || $[8] !== verbose) {
+      t2 = <UserToolRejectMessage input={t1} progressMessagesForMessage={progressMessagesForMessage} tool={toolUse.tool} tools={tools} lookups={lookups} style={style} verbose={verbose} isTranscriptMode={isTranscriptMode} />;
+      $[1] = isTranscriptMode;
+      $[2] = lookups;
+      $[3] = progressMessagesForMessage;
+      $[4] = style;
+      $[5] = t1;
+      $[6] = toolUse.tool;
+      $[7] = tools;
+      $[8] = verbose;
+      $[9] = t2;
+    } else {
+      t2 = $[9];
+    }
+    return t2;
+  }
+  if (param.is_error) {
+    let t1;
+    if ($[10] !== isTranscriptMode || $[11] !== param || $[12] !== progressMessagesForMessage || $[13] !== toolUse.tool || $[14] !== tools || $[15] !== verbose) {
+      t1 = <UserToolErrorMessage progressMessagesForMessage={progressMessagesForMessage} tool={toolUse.tool} tools={tools} param={param} verbose={verbose} isTranscriptMode={isTranscriptMode} />;
+      $[10] = isTranscriptMode;
+      $[11] = param;
+      $[12] = progressMessagesForMessage;
+      $[13] = toolUse.tool;
+      $[14] = tools;
+      $[15] = verbose;
+      $[16] = t1;
+    } else {
+      t1 = $[16];
+    }
+    return t1;
+  }
+  let t1;
+  if ($[17] !== isTranscriptMode || $[18] !== lookups || $[19] !== message || $[20] !== progressMessagesForMessage || $[21] !== style || $[22] !== toolUse.tool || $[23] !== toolUse.toolUse.id || $[24] !== tools || $[25] !== verbose || $[26] !== width) {
+    t1 = <UserToolSuccessMessage message={message} lookups={lookups} toolUseID={toolUse.toolUse.id} progressMessagesForMessage={progressMessagesForMessage} style={style} tool={toolUse.tool} tools={tools} verbose={verbose} width={width} isTranscriptMode={isTranscriptMode} />;
+    $[17] = isTranscriptMode;
+    $[18] = lookups;
+    $[19] = message;
+    $[20] = progressMessagesForMessage;
+    $[21] = style;
+    $[22] = toolUse.tool;
+    $[23] = toolUse.toolUse.id;
+    $[24] = tools;
+    $[25] = verbose;
+    $[26] = width;
+    $[27] = t1;
+  } else {
+    t1 = $[27];
+  }
+  return t1;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ToolResultBlockParam","React","Tools","NormalizedUserMessage","ProgressMessage","buildMessageLookups","CANCEL_MESSAGE","INTERRUPT_MESSAGE_FOR_TOOL_USE","REJECT_MESSAGE","UserToolCanceledMessage","UserToolErrorMessage","UserToolRejectMessage","UserToolSuccessMessage","useGetToolFromMessages","Props","param","message","lookups","ReturnType","progressMessagesForMessage","style","tools","verbose","width","isTranscriptMode","UserToolResultMessage","t0","$","_c","toolUse","tool_use_id","content","startsWith","t1","Symbol","for","input","key","t2","tool","is_error","id"],"sources":["UserToolResultMessage.tsx"],"sourcesContent":["import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'\nimport * as React from 'react'\nimport type { Tools } from '../../../Tool.js'\nimport type {\n  NormalizedUserMessage,\n  ProgressMessage,\n} from '../../../types/message.js'\nimport {\n  type buildMessageLookups,\n  CANCEL_MESSAGE,\n  INTERRUPT_MESSAGE_FOR_TOOL_USE,\n  REJECT_MESSAGE,\n} from '../../../utils/messages.js'\nimport { UserToolCanceledMessage } from './UserToolCanceledMessage.js'\nimport { UserToolErrorMessage } from './UserToolErrorMessage.js'\nimport { UserToolRejectMessage } from './UserToolRejectMessage.js'\nimport { UserToolSuccessMessage } from './UserToolSuccessMessage.js'\nimport { useGetToolFromMessages } from './utils.js'\n\ntype Props = {\n  param: ToolResultBlockParam\n  message: NormalizedUserMessage\n  lookups: ReturnType<typeof buildMessageLookups>\n  progressMessagesForMessage: ProgressMessage[]\n  style?: 'condensed'\n  tools: Tools\n  verbose: boolean\n  width: number | string\n  isTranscriptMode?: boolean\n}\n\nexport function UserToolResultMessage({\n  param,\n  message,\n  lookups,\n  progressMessagesForMessage,\n  style,\n  tools,\n  verbose,\n  width,\n  isTranscriptMode,\n}: Props): React.ReactNode {\n  const toolUse = useGetToolFromMessages(param.tool_use_id, tools, lookups)\n  if (!toolUse) {\n    return null\n  }\n\n  if (\n    typeof param.content === 'string' &&\n    param.content.startsWith(CANCEL_MESSAGE)\n  ) {\n    return <UserToolCanceledMessage />\n  }\n\n  if (\n    (typeof param.content === 'string' &&\n      param.content.startsWith(REJECT_MESSAGE)) ||\n    param.content === INTERRUPT_MESSAGE_FOR_TOOL_USE\n  ) {\n    return (\n      <UserToolRejectMessage\n        input={toolUse.toolUse.input as { [key: string]: unknown }}\n        progressMessagesForMessage={progressMessagesForMessage}\n        tool={toolUse.tool}\n        tools={tools}\n        lookups={lookups}\n        style={style}\n        verbose={verbose}\n        isTranscriptMode={isTranscriptMode}\n      />\n    )\n  }\n\n  if (param.is_error) {\n    return (\n      <UserToolErrorMessage\n        progressMessagesForMessage={progressMessagesForMessage}\n        tool={toolUse.tool}\n        tools={tools}\n        param={param}\n        verbose={verbose}\n        isTranscriptMode={isTranscriptMode}\n      />\n    )\n  }\n\n  return (\n    <UserToolSuccessMessage\n      message={message}\n      lookups={lookups}\n      toolUseID={toolUse.toolUse.id}\n      progressMessagesForMessage={progressMessagesForMessage}\n      style={style}\n      tool={toolUse.tool}\n      tools={tools}\n      verbose={verbose}\n      width={width}\n      isTranscriptMode={isTranscriptMode}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/components/permissions/AskUserQuestionPermissionRequest/QuestionView.tsx

@@ -0,0 +1,465 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import React, { useCallback, useState } from 'react';
+import type { KeyboardEvent } from '../../../ink/events/keyboard-event.js';
+import { Box, Text } from '../../../ink.js';
+import { useAppState } from '../../../state/AppState.js';
+import type { Question, QuestionOption } from '../../../tools/AskUserQuestionTool/AskUserQuestionTool.js';
+import type { PastedContent } from '../../../utils/config.js';
+import { getExternalEditor } from '../../../utils/editor.js';
+import { toIDEDisplayName } from '../../../utils/ide.js';
+import type { ImageDimensions } from '../../../utils/imageResizer.js';
+import { editPromptInEditor } from '../../../utils/promptEditor.js';
+import { type OptionWithDescription, Select, SelectMulti } from '../../CustomSelect/index.js';
+import { Divider } from '../../design-system/Divider.js';
+import { FilePathLink } from '../../FilePathLink.js';
+import { PermissionRequestTitle } from '../PermissionRequestTitle.js';
+import { PreviewQuestionView } from './PreviewQuestionView.js';
+import { QuestionNavigationBar } from './QuestionNavigationBar.js';
+import type { QuestionState } from './use-multiple-choice-state.js';
+type Props = {
+  question: Question;
+  questions: Question[];
+  currentQuestionIndex: number;
+  answers: Record<string, string>;
+  questionStates: Record<string, QuestionState>;
+  hideSubmitTab?: boolean;
+  planFilePath?: string;
+  pastedContents?: Record<number, PastedContent>;
+  minContentHeight?: number;
+  minContentWidth?: number;
+  onUpdateQuestionState: (questionText: string, updates: Partial<QuestionState>, isMultiSelect: boolean) => void;
+  onAnswer: (questionText: string, label: string | string[], textInput?: string, shouldAdvance?: boolean) => void;
+  onTextInputFocus: (isInInput: boolean) => void;
+  onCancel: () => void;
+  onSubmit: () => void;
+  onTabPrev?: () => void;
+  onTabNext?: () => void;
+  onRespondToClaude: () => void;
+  onFinishPlanInterview: () => void;
+  onImagePaste?: (base64Image: string, mediaType?: string, filename?: string, dimensions?: ImageDimensions, sourcePath?: string) => void;
+  onRemoveImage?: (id: number) => void;
+};
+export function QuestionView(t0) {
+  const $ = _c(114);
+  const {
+    question,
+    questions,
+    currentQuestionIndex,
+    answers,
+    questionStates,
+    hideSubmitTab: t1,
+    planFilePath,
+    minContentHeight,
+    minContentWidth,
+    onUpdateQuestionState,
+    onAnswer,
+    onTextInputFocus,
+    onCancel,
+    onSubmit,
+    onTabPrev,
+    onTabNext,
+    onRespondToClaude,
+    onFinishPlanInterview,
+    onImagePaste,
+    pastedContents,
+    onRemoveImage
+  } = t0;
+  const hideSubmitTab = t1 === undefined ? false : t1;
+  const isInPlanMode = useAppState(_temp) === "plan";
+  const [isFooterFocused, setIsFooterFocused] = useState(false);
+  const [footerIndex, setFooterIndex] = useState(0);
+  const [isOtherFocused, setIsOtherFocused] = useState(false);
+  let t2;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    const editor = getExternalEditor();
+    t2 = editor ? toIDEDisplayName(editor) : null;
+    $[0] = t2;
+  } else {
+    t2 = $[0];
+  }
+  const editorName = t2;
+  let t3;
+  if ($[1] !== onTextInputFocus) {
+    t3 = value => {
+      const isOther = value === "__other__";
+      setIsOtherFocused(isOther);
+      onTextInputFocus(isOther);
+    };
+    $[1] = onTextInputFocus;
+    $[2] = t3;
+  } else {
+    t3 = $[2];
+  }
+  const handleFocus = t3;
+  let t4;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = () => {
+      setIsFooterFocused(true);
+    };
+    $[3] = t4;
+  } else {
+    t4 = $[3];
+  }
+  const handleDownFromLastItem = t4;
+  let t5;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = () => {
+      setIsFooterFocused(false);
+    };
+    $[4] = t5;
+  } else {
+    t5 = $[4];
+  }
+  const handleUpFromFooter = t5;
+  let t6;
+  if ($[5] !== footerIndex || $[6] !== isFooterFocused || $[7] !== isInPlanMode || $[8] !== onCancel || $[9] !== onFinishPlanInterview || $[10] !== onRespondToClaude) {
+    t6 = e => {
+      if (!isFooterFocused) {
+        return;
+      }
+      if (e.key === "up" || e.ctrl && e.key === "p") {
+        e.preventDefault();
+        if (footerIndex === 0) {
+          handleUpFromFooter();
+        } else {
+          setFooterIndex(0);
+        }
+        return;
+      }
+      if (e.key === "down" || e.ctrl && e.key === "n") {
+        e.preventDefault();
+        if (isInPlanMode && footerIndex === 0) {
+          setFooterIndex(1);
+        }
+        return;
+      }
+      if (e.key === "return") {
+        e.preventDefault();
+        if (footerIndex === 0) {
+          onRespondToClaude();
+        } else {
+          onFinishPlanInterview();
+        }
+        return;
+      }
+      if (e.key === "escape") {
+        e.preventDefault();
+        onCancel();
+      }
+    };
+    $[5] = footerIndex;
+    $[6] = isFooterFocused;
+    $[7] = isInPlanMode;
+    $[8] = onCancel;
+    $[9] = onFinishPlanInterview;
+    $[10] = onRespondToClaude;
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  const handleKeyDown = t6;
+  let handleOpenEditor;
+  let questionText;
+  let t7;
+  if ($[12] !== onUpdateQuestionState || $[13] !== question || $[14] !== questionStates) {
+    const textOptions = question.options.map(_temp2);
+    questionText = question.question;
+    const questionState = questionStates[questionText];
+    let t8;
+    if ($[18] !== onUpdateQuestionState || $[19] !== question.multiSelect || $[20] !== questionText) {
+      t8 = async (currentValue, setValue) => {
+        const result = await editPromptInEditor(currentValue);
+        if (result.content !== null && result.content !== currentValue) {
+          setValue(result.content);
+          onUpdateQuestionState(questionText, {
+            textInputValue: result.content
+          }, question.multiSelect ?? false);
+        }
+      };
+      $[18] = onUpdateQuestionState;
+      $[19] = question.multiSelect;
+      $[20] = questionText;
+      $[21] = t8;
+    } else {
+      t8 = $[21];
+    }
+    handleOpenEditor = t8;
+    const t9 = question.multiSelect ? "Type something" : "Type something.";
+    const t10 = questionState?.textInputValue ?? "";
+    let t11;
+    if ($[22] !== onUpdateQuestionState || $[23] !== question.multiSelect || $[24] !== questionText) {
+      t11 = value_0 => {
+        onUpdateQuestionState(questionText, {
+          textInputValue: value_0
+        }, question.multiSelect ?? false);
+      };
+      $[22] = onUpdateQuestionState;
+      $[23] = question.multiSelect;
+      $[24] = questionText;
+      $[25] = t11;
+    } else {
+      t11 = $[25];
+    }
+    let t12;
+    if ($[26] !== t10 || $[27] !== t11 || $[28] !== t9) {
+      t12 = {
+        type: "input" as const,
+        value: "__other__",
+        label: "Other",
+        placeholder: t9,
+        initialValue: t10,
+        onChange: t11
+      };
+      $[26] = t10;
+      $[27] = t11;
+      $[28] = t9;
+      $[29] = t12;
+    } else {
+      t12 = $[29];
+    }
+    const otherOption = t12;
+    t7 = [...textOptions, otherOption];
+    $[12] = onUpdateQuestionState;
+    $[13] = question;
+    $[14] = questionStates;
+    $[15] = handleOpenEditor;
+    $[16] = questionText;
+    $[17] = t7;
+  } else {
+    handleOpenEditor = $[15];
+    questionText = $[16];
+    t7 = $[17];
+  }
+  const options = t7;
+  const hasAnyPreview = !question.multiSelect && question.options.some(_temp3);
+  if (hasAnyPreview) {
+    let t8;
+    if ($[30] !== answers || $[31] !== currentQuestionIndex || $[32] !== hideSubmitTab || $[33] !== minContentHeight || $[34] !== minContentWidth || $[35] !== onAnswer || $[36] !== onCancel || $[37] !== onFinishPlanInterview || $[38] !== onRespondToClaude || $[39] !== onTabNext || $[40] !== onTabPrev || $[41] !== onTextInputFocus || $[42] !== onUpdateQuestionState || $[43] !== question || $[44] !== questionStates || $[45] !== questions) {
+      t8 = <PreviewQuestionView question={question} questions={questions} currentQuestionIndex={currentQuestionIndex} answers={answers} questionStates={questionStates} hideSubmitTab={hideSubmitTab} minContentHeight={minContentHeight} minContentWidth={minContentWidth} onUpdateQuestionState={onUpdateQuestionState} onAnswer={onAnswer} onTextInputFocus={onTextInputFocus} onCancel={onCancel} onTabPrev={onTabPrev} onTabNext={onTabNext} onRespondToClaude={onRespondToClaude} onFinishPlanInterview={onFinishPlanInterview} />;
+      $[30] = answers;
+      $[31] = currentQuestionIndex;
+      $[32] = hideSubmitTab;
+      $[33] = minContentHeight;
+      $[34] = minContentWidth;
+      $[35] = onAnswer;
+      $[36] = onCancel;
+      $[37] = onFinishPlanInterview;
+      $[38] = onRespondToClaude;
+      $[39] = onTabNext;
+      $[40] = onTabPrev;
+      $[41] = onTextInputFocus;
+      $[42] = onUpdateQuestionState;
+      $[43] = question;
+      $[44] = questionStates;
+      $[45] = questions;
+      $[46] = t8;
+    } else {
+      t8 = $[46];
+    }
+    return t8;
+  }
+  let t8;
+  if ($[47] !== isInPlanMode || $[48] !== planFilePath) {
+    t8 = isInPlanMode && planFilePath && <Box flexDirection="column" gap={0}><Divider color="inactive" /><Text color="inactive">Planning: <FilePathLink filePath={planFilePath} /></Text></Box>;
+    $[47] = isInPlanMode;
+    $[48] = planFilePath;
+    $[49] = t8;
+  } else {
+    t8 = $[49];
+  }
+  let t9;
+  if ($[50] === Symbol.for("react.memo_cache_sentinel")) {
+    t9 = <Box marginTop={-1}><Divider color="inactive" /></Box>;
+    $[50] = t9;
+  } else {
+    t9 = $[50];
+  }
+  let t10;
+  if ($[51] !== answers || $[52] !== currentQuestionIndex || $[53] !== hideSubmitTab || $[54] !== questions) {
+    t10 = <QuestionNavigationBar questions={questions} currentQuestionIndex={currentQuestionIndex} answers={answers} hideSubmitTab={hideSubmitTab} />;
+    $[51] = answers;
+    $[52] = currentQuestionIndex;
+    $[53] = hideSubmitTab;
+    $[54] = questions;
+    $[55] = t10;
+  } else {
+    t10 = $[55];
+  }
+  let t11;
+  if ($[56] !== question.question) {
+    t11 = <PermissionRequestTitle title={question.question} color="text" />;
+    $[56] = question.question;
+    $[57] = t11;
+  } else {
+    t11 = $[57];
+  }
+  let t12;
+  if ($[58] !== currentQuestionIndex || $[59] !== handleFocus || $[60] !== handleOpenEditor || $[61] !== isFooterFocused || $[62] !== onAnswer || $[63] !== onCancel || $[64] !== onImagePaste || $[65] !== onRemoveImage || $[66] !== onSubmit || $[67] !== onUpdateQuestionState || $[68] !== options || $[69] !== pastedContents || $[70] !== question.multiSelect || $[71] !== question.question || $[72] !== questionStates || $[73] !== questionText || $[74] !== questions.length) {
+    t12 = <Box marginTop={1}>{question.multiSelect ? <SelectMulti key={question.question} options={options} defaultValue={questionStates[question.question]?.selectedValue as string[] | undefined} onChange={values => {
+        onUpdateQuestionState(questionText, {
+          selectedValue: values
+        }, true);
+        const textInput = values.includes("__other__") ? questionStates[questionText]?.textInputValue : undefined;
+        const finalValues = values.filter(_temp4).concat(textInput ? [textInput] : []);
+        onAnswer(questionText, finalValues, undefined, false);
+      }} onFocus={handleFocus} onCancel={onCancel} submitButtonText={currentQuestionIndex === questions.length - 1 ? "Submit" : "Next"} onSubmit={onSubmit} onDownFromLastItem={handleDownFromLastItem} isDisabled={isFooterFocused} onOpenEditor={handleOpenEditor} onImagePaste={onImagePaste} pastedContents={pastedContents} onRemoveImage={onRemoveImage} /> : <Select key={question.question} options={options} defaultValue={questionStates[question.question]?.selectedValue as string | undefined} onChange={value_1 => {
+        onUpdateQuestionState(questionText, {
+          selectedValue: value_1
+        }, false);
+        const textInput_0 = value_1 === "__other__" ? questionStates[questionText]?.textInputValue : undefined;
+        onAnswer(questionText, value_1, textInput_0);
+      }} onFocus={handleFocus} onCancel={onCancel} onDownFromLastItem={handleDownFromLastItem} isDisabled={isFooterFocused} layout="compact-vertical" onOpenEditor={handleOpenEditor} onImagePaste={onImagePaste} pastedContents={pastedContents} onRemoveImage={onRemoveImage} />}</Box>;
+    $[58] = currentQuestionIndex;
+    $[59] = handleFocus;
+    $[60] = handleOpenEditor;
+    $[61] = isFooterFocused;
+    $[62] = onAnswer;
+    $[63] = onCancel;
+    $[64] = onImagePaste;
+    $[65] = onRemoveImage;
+    $[66] = onSubmit;
+    $[67] = onUpdateQuestionState;
+    $[68] = options;
+    $[69] = pastedContents;
+    $[70] = question.multiSelect;
+    $[71] = question.question;
+    $[72] = questionStates;
+    $[73] = questionText;
+    $[74] = questions.length;
+    $[75] = t12;
+  } else {
+    t12 = $[75];
+  }
+  let t13;
+  if ($[76] === Symbol.for("react.memo_cache_sentinel")) {
+    t13 = <Divider color="inactive" />;
+    $[76] = t13;
+  } else {
+    t13 = $[76];
+  }
+  let t14;
+  if ($[77] !== footerIndex || $[78] !== isFooterFocused) {
+    t14 = isFooterFocused && footerIndex === 0 ? <Text color="suggestion">{figures.pointer}</Text> : <Text> </Text>;
+    $[77] = footerIndex;
+    $[78] = isFooterFocused;
+    $[79] = t14;
+  } else {
+    t14 = $[79];
+  }
+  const t15 = isFooterFocused && footerIndex === 0 ? "suggestion" : undefined;
+  const t16 = options.length + 1;
+  let t17;
+  if ($[80] !== t15 || $[81] !== t16) {
+    t17 = <Text color={t15}>{t16}. Chat about this</Text>;
+    $[80] = t15;
+    $[81] = t16;
+    $[82] = t17;
+  } else {
+    t17 = $[82];
+  }
+  let t18;
+  if ($[83] !== t14 || $[84] !== t17) {
+    t18 = <Box flexDirection="row" gap={1}>{t14}{t17}</Box>;
+    $[83] = t14;
+    $[84] = t17;
+    $[85] = t18;
+  } else {
+    t18 = $[85];
+  }
+  let t19;
+  if ($[86] !== footerIndex || $[87] !== isFooterFocused || $[88] !== isInPlanMode || $[89] !== options.length) {
+    t19 = isInPlanMode && <Box flexDirection="row" gap={1}>{isFooterFocused && footerIndex === 1 ? <Text color="suggestion">{figures.pointer}</Text> : <Text> </Text>}<Text color={isFooterFocused && footerIndex === 1 ? "suggestion" : undefined}>{options.length + 2}. Skip interview and plan immediately</Text></Box>;
+    $[86] = footerIndex;
+    $[87] = isFooterFocused;
+    $[88] = isInPlanMode;
+    $[89] = options.length;
+    $[90] = t19;
+  } else {
+    t19 = $[90];
+  }
+  let t20;
+  if ($[91] !== t18 || $[92] !== t19) {
+    t20 = <Box flexDirection="column">{t13}{t18}{t19}</Box>;
+    $[91] = t18;
+    $[92] = t19;
+    $[93] = t20;
+  } else {
+    t20 = $[93];
+  }
+  let t21;
+  if ($[94] !== questions.length) {
+    t21 = questions.length === 1 ? <>{figures.arrowUp}/{figures.arrowDown} to navigate</> : "Tab/Arrow keys to navigate";
+    $[94] = questions.length;
+    $[95] = t21;
+  } else {
+    t21 = $[95];
+  }
+  let t22;
+  if ($[96] !== isOtherFocused) {
+    t22 = isOtherFocused && editorName && <> · ctrl+g to edit in {editorName}</>;
+    $[96] = isOtherFocused;
+    $[97] = t22;
+  } else {
+    t22 = $[97];
+  }
+  let t23;
+  if ($[98] !== t21 || $[99] !== t22) {
+    t23 = <Box marginTop={1}><Text color="inactive" dimColor={true}>Enter to select ·{" "}{t21}{t22}{" "}· Esc to cancel</Text></Box>;
+    $[98] = t21;
+    $[99] = t22;
+    $[100] = t23;
+  } else {
+    t23 = $[100];
+  }
+  let t24;
+  if ($[101] !== minContentHeight || $[102] !== t12 || $[103] !== t20 || $[104] !== t23) {
+    t24 = <Box flexDirection="column" minHeight={minContentHeight}>{t12}{t20}{t23}</Box>;
+    $[101] = minContentHeight;
+    $[102] = t12;
+    $[103] = t20;
+    $[104] = t23;
+    $[105] = t24;
+  } else {
+    t24 = $[105];
+  }
+  let t25;
+  if ($[106] !== t10 || $[107] !== t11 || $[108] !== t24) {
+    t25 = <Box flexDirection="column" paddingTop={0}>{t10}{t11}{t24}</Box>;
+    $[106] = t10;
+    $[107] = t11;
+    $[108] = t24;
+    $[109] = t25;
+  } else {
+    t25 = $[109];
+  }
+  let t26;
+  if ($[110] !== handleKeyDown || $[111] !== t25 || $[112] !== t8) {
+    t26 = <Box flexDirection="column" marginTop={0} tabIndex={0} autoFocus={true} onKeyDown={handleKeyDown}>{t8}{t9}{t25}</Box>;
+    $[110] = handleKeyDown;
+    $[111] = t25;
+    $[112] = t8;
+    $[113] = t26;
+  } else {
+    t26 = $[113];
+  }
+  return t26;
+}
+function _temp4(v) {
+  return v !== "__other__";
+}
+function _temp3(opt_0) {
+  return opt_0.preview;
+}
+function _temp2(opt) {
+  return {
+    type: "text" as const,
+    value: opt.label,
+    label: opt.label,
+    description: opt.description
+  };
+}
+function _temp(s) {
+  return s.toolPermissionContext.mode;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useCallback","useState","KeyboardEvent","Box","Text","useAppState","Question","QuestionOption","PastedContent","getExternalEditor","toIDEDisplayName","ImageDimensions","editPromptInEditor","OptionWithDescription","Select","SelectMulti","Divider","FilePathLink","PermissionRequestTitle","PreviewQuestionView","QuestionNavigationBar","QuestionState","Props","question","questions","currentQuestionIndex","answers","Record","questionStates","hideSubmitTab","planFilePath","pastedContents","minContentHeight","minContentWidth","onUpdateQuestionState","questionText","updates","Partial","isMultiSelect","onAnswer","label","textInput","shouldAdvance","onTextInputFocus","isInInput","onCancel","onSubmit","onTabPrev","onTabNext","onRespondToClaude","onFinishPlanInterview","onImagePaste","base64Image","mediaType","filename","dimensions","sourcePath","onRemoveImage","id","QuestionView","t0","$","_c","t1","undefined","isInPlanMode","_temp","isFooterFocused","setIsFooterFocused","footerIndex","setFooterIndex","isOtherFocused","setIsOtherFocused","t2","Symbol","for","editor","editorName","t3","value","isOther","handleFocus","t4","handleDownFromLastItem","t5","handleUpFromFooter","t6","e","key","ctrl","preventDefault","handleKeyDown","handleOpenEditor","t7","textOptions","options","map","_temp2","questionState","t8","multiSelect","currentValue","setValue","result","content","textInputValue","t9","t10","t11","value_0","t12","type","const","placeholder","initialValue","onChange","otherOption","hasAnyPreview","some","_temp3","length","selectedValue","values","includes","finalValues","filter","_temp4","concat","value_1","textInput_0","t13","t14","pointer","t15","t16","t17","t18","t19","t20","t21","arrowUp","arrowDown","t22","t23","t24","t25","t26","v","opt_0","opt","preview","description","s","toolPermissionContext","mode"],"sources":["QuestionView.tsx"],"sourcesContent":["import figures from 'figures'\nimport React, { useCallback, useState } from 'react'\nimport type { KeyboardEvent } from '../../../ink/events/keyboard-event.js'\nimport { Box, Text } from '../../../ink.js'\nimport { useAppState } from '../../../state/AppState.js'\nimport type {\n  Question,\n  QuestionOption,\n} from '../../../tools/AskUserQuestionTool/AskUserQuestionTool.js'\nimport type { PastedContent } from '../../../utils/config.js'\nimport { getExternalEditor } from '../../../utils/editor.js'\nimport { toIDEDisplayName } from '../../../utils/ide.js'\nimport type { ImageDimensions } from '../../../utils/imageResizer.js'\nimport { editPromptInEditor } from '../../../utils/promptEditor.js'\nimport {\n  type OptionWithDescription,\n  Select,\n  SelectMulti,\n} from '../../CustomSelect/index.js'\nimport { Divider } from '../../design-system/Divider.js'\nimport { FilePathLink } from '../../FilePathLink.js'\nimport { PermissionRequestTitle } from '../PermissionRequestTitle.js'\nimport { PreviewQuestionView } from './PreviewQuestionView.js'\nimport { QuestionNavigationBar } from './QuestionNavigationBar.js'\nimport type { QuestionState } from './use-multiple-choice-state.js'\n\ntype Props = {\n  question: Question\n  questions: Question[]\n  currentQuestionIndex: number\n  answers: Record<string, string>\n  questionStates: Record<string, QuestionState>\n  hideSubmitTab?: boolean\n  planFilePath?: string\n  pastedContents?: Record<number, PastedContent>\n  minContentHeight?: number\n  minContentWidth?: number\n  onUpdateQuestionState: (\n    questionText: string,\n    updates: Partial<QuestionState>,\n    isMultiSelect: boolean,\n  ) => void\n  onAnswer: (\n    questionText: string,\n    label: string | string[],\n    textInput?: string,\n    shouldAdvance?: boolean,\n  ) => void\n  onTextInputFocus: (isInInput: boolean) => void\n  onCancel: () => void\n  onSubmit: () => void\n  onTabPrev?: () => void\n  onTabNext?: () => void\n  onRespondToClaude: () => void\n  onFinishPlanInterview: () => void\n  onImagePaste?: (\n    base64Image: string,\n    mediaType?: string,\n    filename?: string,\n    dimensions?: ImageDimensions,\n    sourcePath?: string,\n  ) => void\n  onRemoveImage?: (id: number) => void\n}\n\nexport function QuestionView({\n  question,\n  questions,\n  currentQuestionIndex,\n  answers,\n  questionStates,\n  hideSubmitTab = false,\n  planFilePath,\n  minContentHeight,\n  minContentWidth,\n  onUpdateQuestionState,\n  onAnswer,\n  onTextInputFocus,\n  onCancel,\n  onSubmit,\n  onTabPrev,\n  onTabNext,\n  onRespondToClaude,\n  onFinishPlanInterview,\n  onImagePaste,\n  pastedContents,\n  onRemoveImage,\n}: Props): React.ReactNode {\n  const isInPlanMode = useAppState(s => s.toolPermissionContext.mode) === 'plan'\n  const [isFooterFocused, setIsFooterFocused] = useState(false)\n  const [footerIndex, setFooterIndex] = useState(0)\n  const [isOtherFocused, setIsOtherFocused] = useState(false)\n\n  const editor = getExternalEditor()\n  const editorName = editor ? toIDEDisplayName(editor) : null\n\n  const handleFocus = useCallback(\n    (value: string) => {\n      const isOther = value === '__other__'\n      setIsOtherFocused(isOther)\n      onTextInputFocus(isOther)\n    },\n    [onTextInputFocus],\n  )\n\n  const handleDownFromLastItem = useCallback(() => {\n    setIsFooterFocused(true)\n  }, [])\n\n  const handleUpFromFooter = useCallback(() => {\n    setIsFooterFocused(false)\n  }, [])\n\n  // Handle keyboard input when footer is focused\n  const handleKeyDown = useCallback(\n    (e: KeyboardEvent) => {\n      if (!isFooterFocused) return\n\n      if (e.key === 'up' || (e.ctrl && e.key === 'p')) {\n        e.preventDefault()\n        if (footerIndex === 0) {\n          handleUpFromFooter()\n        } else {\n          setFooterIndex(0)\n        }\n        return\n      }\n\n      if (e.key === 'down' || (e.ctrl && e.key === 'n')) {\n        e.preventDefault()\n        if (isInPlanMode && footerIndex === 0) {\n          setFooterIndex(1)\n        }\n        return\n      }\n\n      if (e.key === 'return') {\n        e.preventDefault()\n        if (footerIndex === 0) {\n          onRespondToClaude()\n        } else {\n          onFinishPlanInterview()\n        }\n        return\n      }\n\n      if (e.key === 'escape') {\n        e.preventDefault()\n        onCancel()\n      }\n    },\n    [\n      isFooterFocused,\n      footerIndex,\n      isInPlanMode,\n      handleUpFromFooter,\n      onRespondToClaude,\n      onFinishPlanInterview,\n      onCancel,\n    ],\n  )\n\n  const textOptions: OptionWithDescription<string>[] = question.options.map(\n    (opt: QuestionOption) => ({\n      type: 'text' as const,\n      value: opt.label,\n      label: opt.label,\n      description: opt.description,\n    }),\n  )\n\n  const questionText = question.question\n  const questionState = questionStates[questionText]\n\n  const handleOpenEditor = useCallback(\n    async (currentValue: string, setValue: (value: string) => void) => {\n      const result = await editPromptInEditor(currentValue)\n\n      if (result.content !== null && result.content !== currentValue) {\n        // Update the Select's internal state for immediate UI update\n        setValue(result.content)\n        // Also update the question state for persistence\n        onUpdateQuestionState(\n          questionText,\n          { textInputValue: result.content },\n          question.multiSelect ?? false,\n        )\n      }\n    },\n    [questionText, onUpdateQuestionState, question.multiSelect],\n  )\n\n  const otherOption: OptionWithDescription<string> = {\n    type: 'input' as const,\n    value: '__other__',\n    label: 'Other',\n    placeholder: question.multiSelect ? 'Type something' : 'Type something.',\n    initialValue: questionState?.textInputValue ?? '',\n    onChange: (value: string) => {\n      onUpdateQuestionState(\n        questionText,\n        { textInputValue: value },\n        question.multiSelect ?? false,\n      )\n    },\n  }\n\n  const options = [...textOptions, otherOption]\n\n  // Check if any option has a preview and it's not multi-select\n  // Previews only supported for single-select questions\n  const hasAnyPreview =\n    !question.multiSelect && question.options.some(opt => opt.preview)\n\n  // Delegate to PreviewQuestionView for carousel-style preview mode\n  if (hasAnyPreview) {\n    return (\n      <PreviewQuestionView\n        question={question}\n        questions={questions}\n        currentQuestionIndex={currentQuestionIndex}\n        answers={answers}\n        questionStates={questionStates}\n        hideSubmitTab={hideSubmitTab}\n        minContentHeight={minContentHeight}\n        minContentWidth={minContentWidth}\n        onUpdateQuestionState={onUpdateQuestionState}\n        onAnswer={onAnswer}\n        onTextInputFocus={onTextInputFocus}\n        onCancel={onCancel}\n        onTabPrev={onTabPrev}\n        onTabNext={onTabNext}\n        onRespondToClaude={onRespondToClaude}\n        onFinishPlanInterview={onFinishPlanInterview}\n      />\n    )\n  }\n\n  return (\n    <Box\n      flexDirection=\"column\"\n      marginTop={0}\n      tabIndex={0}\n      autoFocus\n      onKeyDown={handleKeyDown}\n    >\n      {isInPlanMode && planFilePath && (\n        <Box flexDirection=\"column\" gap={0}>\n          <Divider color=\"inactive\" />\n          <Text color=\"inactive\">\n            Planning: <FilePathLink filePath={planFilePath} />\n          </Text>\n        </Box>\n      )}\n      <Box marginTop={-1}>\n        <Divider color=\"inactive\" />\n      </Box>\n      <Box flexDirection=\"column\" paddingTop={0}>\n        <QuestionNavigationBar\n          questions={questions}\n          currentQuestionIndex={currentQuestionIndex}\n          answers={answers}\n          hideSubmitTab={hideSubmitTab}\n        />\n        <PermissionRequestTitle title={question.question} color={'text'} />\n\n        <Box flexDirection=\"column\" minHeight={minContentHeight}>\n          <Box marginTop={1}>\n            {question.multiSelect ? (\n              <SelectMulti\n                key={question.question}\n                options={options}\n                defaultValue={\n                  questionStates[question.question]?.selectedValue as\n                    | string[]\n                    | undefined\n                }\n                onChange={(values: string[]) => {\n                  onUpdateQuestionState(\n                    questionText,\n                    { selectedValue: values },\n                    true,\n                  )\n                  const textInput = values.includes('__other__')\n                    ? questionStates[questionText]?.textInputValue\n                    : undefined\n                  const finalValues = values\n                    .filter(v => v !== '__other__')\n                    .concat(textInput ? [textInput] : [])\n                  onAnswer(questionText, finalValues, undefined, false)\n                }}\n                onFocus={handleFocus}\n                onCancel={onCancel}\n                submitButtonText={\n                  currentQuestionIndex === questions.length - 1\n                    ? 'Submit'\n                    : 'Next'\n                }\n                onSubmit={onSubmit}\n                onDownFromLastItem={handleDownFromLastItem}\n                isDisabled={isFooterFocused}\n                onOpenEditor={handleOpenEditor}\n                onImagePaste={onImagePaste}\n                pastedContents={pastedContents}\n                onRemoveImage={onRemoveImage}\n              />\n            ) : (\n              <Select\n                key={question.question}\n                options={options}\n                defaultValue={\n                  questionStates[question.question]?.selectedValue as\n                    | string\n                    | undefined\n                }\n                onChange={(value: string) => {\n                  onUpdateQuestionState(\n                    questionText,\n                    { selectedValue: value },\n                    false,\n                  )\n                  const textInput =\n                    value === '__other__'\n                      ? questionStates[questionText]?.textInputValue\n                      : undefined\n                  onAnswer(questionText, value, textInput)\n                }}\n                onFocus={handleFocus}\n                onCancel={onCancel}\n                onDownFromLastItem={handleDownFromLastItem}\n                isDisabled={isFooterFocused}\n                layout=\"compact-vertical\"\n                onOpenEditor={handleOpenEditor}\n                onImagePaste={onImagePaste}\n                pastedContents={pastedContents}\n                onRemoveImage={onRemoveImage}\n              />\n            )}\n          </Box>\n          {/* Footer section - always visible, separate from Select */}\n          <Box flexDirection=\"column\">\n            <Divider color=\"inactive\" />\n            <Box flexDirection=\"row\" gap={1}>\n              {isFooterFocused && footerIndex === 0 ? (\n                <Text color=\"suggestion\">{figures.pointer}</Text>\n              ) : (\n                <Text> </Text>\n              )}\n              <Text\n                color={\n                  isFooterFocused && footerIndex === 0\n                    ? 'suggestion'\n                    : undefined\n                }\n              >\n                {options.length + 1}. Chat about this\n              </Text>\n            </Box>\n            {isInPlanMode && (\n              <Box flexDirection=\"row\" gap={1}>\n                {isFooterFocused && footerIndex === 1 ? (\n                  <Text color=\"suggestion\">{figures.pointer}</Text>\n                ) : (\n                  <Text> </Text>\n                )}\n                <Text\n                  color={\n                    isFooterFocused && footerIndex === 1\n                      ? 'suggestion'\n                      : undefined\n                  }\n                >\n                  {options.length + 2}. Skip interview and plan immediately\n                </Text>\n              </Box>\n            )}\n          </Box>\n          <Box marginTop={1}>\n            <Text color=\"inactive\" dimColor>\n              Enter to select ·{' '}\n              {questions.length === 1 ? (\n                <>\n                  {figures.arrowUp}/{figures.arrowDown} to navigate\n                </>\n              ) : (\n                'Tab/Arrow keys to navigate'\n              )}\n              {isOtherFocused && editorName && (\n                <> · ctrl+g to edit in {editorName}</>\n              )}{' '}\n              · Esc to cancel\n            </Text>\n          </Box>\n        </Box>\n      </Box>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/entrypoints/sdk/controlSchemas.ts

@@ -0,0 +1,663 @@
+/**
+ * SDK Control Schemas - Zod schemas for the control protocol.
+ *
+ * These schemas define the control protocol between SDK implementations and the CLI.
+ * Used by SDK builders (e.g., Python SDK) to communicate with the CLI process.
+ *
+ * SDK consumers should use coreSchemas.ts instead.
+ */
+
+import { z } from 'zod/v4'
+import { lazySchema } from '../../utils/lazySchema.js'
+import {
+  AccountInfoSchema,
+  AgentDefinitionSchema,
+  AgentInfoSchema,
+  FastModeStateSchema,
+  HookEventSchema,
+  HookInputSchema,
+  McpServerConfigForProcessTransportSchema,
+  McpServerStatusSchema,
+  ModelInfoSchema,
+  PermissionModeSchema,
+  PermissionUpdateSchema,
+  SDKMessageSchema,
+  SDKPostTurnSummaryMessageSchema,
+  SDKStreamlinedTextMessageSchema,
+  SDKStreamlinedToolUseSummaryMessageSchema,
+  SDKUserMessageSchema,
+  SlashCommandSchema,
+} from './coreSchemas.js'
+
+// ============================================================================
+// External Type Placeholders
+// ============================================================================
+
+// JSONRPCMessage from @modelcontextprotocol/sdk - treat as unknown
+export const JSONRPCMessagePlaceholder = lazySchema(() => z.unknown())
+
+// ============================================================================
+// Hook Callback Types
+// ============================================================================
+
+export const SDKHookCallbackMatcherSchema = lazySchema(() =>
+  z
+    .object({
+      matcher: z.string().optional(),
+      hookCallbackIds: z.array(z.string()),
+      timeout: z.number().optional(),
+    })
+    .describe('Configuration for matching and routing hook callbacks.'),
+)
+
+// ============================================================================
+// Control Request Types
+// ============================================================================
+
+export const SDKControlInitializeRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('initialize'),
+      hooks: z
+        .record(HookEventSchema(), z.array(SDKHookCallbackMatcherSchema()))
+        .optional(),
+      sdkMcpServers: z.array(z.string()).optional(),
+      jsonSchema: z.record(z.string(), z.unknown()).optional(),
+      systemPrompt: z.string().optional(),
+      appendSystemPrompt: z.string().optional(),
+      agents: z.record(z.string(), AgentDefinitionSchema()).optional(),
+      promptSuggestions: z.boolean().optional(),
+      agentProgressSummaries: z.boolean().optional(),
+    })
+    .describe(
+      'Initializes the SDK session with hooks, MCP servers, and agent configuration.',
+    ),
+)
+
+export const SDKControlInitializeResponseSchema = lazySchema(() =>
+  z
+    .object({
+      commands: z.array(SlashCommandSchema()),
+      agents: z.array(AgentInfoSchema()),
+      output_style: z.string(),
+      available_output_styles: z.array(z.string()),
+      models: z.array(ModelInfoSchema()),
+      account: AccountInfoSchema(),
+      pid: z
+        .number()
+        .optional()
+        .describe('@internal CLI process PID for tmux socket isolation'),
+      fast_mode_state: FastModeStateSchema().optional(),
+    })
+    .describe(
+      'Response from session initialization with available commands, models, and account info.',
+    ),
+)
+
+export const SDKControlInterruptRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('interrupt'),
+    })
+    .describe('Interrupts the currently running conversation turn.'),
+)
+
+
+export const SDKControlPermissionRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('can_use_tool'),
+      tool_name: z.string(),
+      input: z.record(z.string(), z.unknown()),
+      permission_suggestions: z.array(PermissionUpdateSchema()).optional(),
+      blocked_path: z.string().optional(),
+      decision_reason: z.string().optional(),
+      title: z.string().optional(),
+      display_name: z.string().optional(),
+      tool_use_id: z.string(),
+      agent_id: z.string().optional(),
+      description: z.string().optional(),
+    })
+    .describe('Requests permission to use a tool with the given input.'),
+)
+
+export const SDKControlSetPermissionModeRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('set_permission_mode'),
+      mode: PermissionModeSchema(),
+      ultraplan: z
+        .boolean()
+        .optional()
+        .describe('@internal CCR ultraplan session marker.'),
+    })
+    .describe('Sets the permission mode for tool execution handling.'),
+)
+
+export const SDKControlSetModelRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('set_model'),
+      model: z.string().optional(),
+    })
+    .describe('Sets the model to use for subsequent conversation turns.'),
+)
+
+export const SDKControlSetMaxThinkingTokensRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('set_max_thinking_tokens'),
+      max_thinking_tokens: z.number().nullable(),
+    })
+    .describe(
+      'Sets the maximum number of thinking tokens for extended thinking.',
+    ),
+)
+
+export const SDKControlMcpStatusRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('mcp_status'),
+    })
+    .describe('Requests the current status of all MCP server connections.'),
+)
+
+export const SDKControlMcpStatusResponseSchema = lazySchema(() =>
+  z
+    .object({
+      mcpServers: z.array(McpServerStatusSchema()),
+    })
+    .describe(
+      'Response containing the current status of all MCP server connections.',
+    ),
+)
+
+export const SDKControlGetContextUsageRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('get_context_usage'),
+    })
+    .describe(
+      'Requests a breakdown of current context window usage by category.',
+    ),
+)
+
+const ContextCategorySchema = lazySchema(() =>
+  z.object({
+    name: z.string(),
+    tokens: z.number(),
+    color: z.string(),
+    isDeferred: z.boolean().optional(),
+  }),
+)
+
+const ContextGridSquareSchema = lazySchema(() =>
+  z.object({
+    color: z.string(),
+    isFilled: z.boolean(),
+    categoryName: z.string(),
+    tokens: z.number(),
+    percentage: z.number(),
+    squareFullness: z.number(),
+  }),
+)
+
+export const SDKControlGetContextUsageResponseSchema = lazySchema(() =>
+  z
+    .object({
+      categories: z.array(ContextCategorySchema()),
+      totalTokens: z.number(),
+      maxTokens: z.number(),
+      rawMaxTokens: z.number(),
+      percentage: z.number(),
+      gridRows: z.array(z.array(ContextGridSquareSchema())),
+      model: z.string(),
+      memoryFiles: z.array(
+        z.object({
+          path: z.string(),
+          type: z.string(),
+          tokens: z.number(),
+        }),
+      ),
+      mcpTools: z.array(
+        z.object({
+          name: z.string(),
+          serverName: z.string(),
+          tokens: z.number(),
+          isLoaded: z.boolean().optional(),
+        }),
+      ),
+      deferredBuiltinTools: z
+        .array(
+          z.object({
+            name: z.string(),
+            tokens: z.number(),
+            isLoaded: z.boolean(),
+          }),
+        )
+        .optional(),
+      systemTools: z
+        .array(z.object({ name: z.string(), tokens: z.number() }))
+        .optional(),
+      systemPromptSections: z
+        .array(z.object({ name: z.string(), tokens: z.number() }))
+        .optional(),
+      agents: z.array(
+        z.object({
+          agentType: z.string(),
+          source: z.string(),
+          tokens: z.number(),
+        }),
+      ),
+      slashCommands: z
+        .object({
+          totalCommands: z.number(),
+          includedCommands: z.number(),
+          tokens: z.number(),
+        })
+        .optional(),
+      skills: z
+        .object({
+          totalSkills: z.number(),
+          includedSkills: z.number(),
+          tokens: z.number(),
+          skillFrontmatter: z.array(
+            z.object({
+              name: z.string(),
+              source: z.string(),
+              tokens: z.number(),
+            }),
+          ),
+        })
+        .optional(),
+      autoCompactThreshold: z.number().optional(),
+      isAutoCompactEnabled: z.boolean(),
+      messageBreakdown: z
+        .object({
+          toolCallTokens: z.number(),
+          toolResultTokens: z.number(),
+          attachmentTokens: z.number(),
+          assistantMessageTokens: z.number(),
+          userMessageTokens: z.number(),
+          toolCallsByType: z.array(
+            z.object({
+              name: z.string(),
+              callTokens: z.number(),
+              resultTokens: z.number(),
+            }),
+          ),
+          attachmentsByType: z.array(
+            z.object({ name: z.string(), tokens: z.number() }),
+          ),
+        })
+        .optional(),
+      apiUsage: z
+        .object({
+          input_tokens: z.number(),
+          output_tokens: z.number(),
+          cache_creation_input_tokens: z.number(),
+          cache_read_input_tokens: z.number(),
+        })
+        .nullable(),
+    })
+    .describe(
+      'Breakdown of current context window usage by category (system prompt, tools, messages, etc.).',
+    ),
+)
+
+export const SDKControlRewindFilesRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('rewind_files'),
+      user_message_id: z.string(),
+      dry_run: z.boolean().optional(),
+    })
+    .describe('Rewinds file changes made since a specific user message.'),
+)
+
+export const SDKControlRewindFilesResponseSchema = lazySchema(() =>
+  z
+    .object({
+      canRewind: z.boolean(),
+      error: z.string().optional(),
+      filesChanged: z.array(z.string()).optional(),
+      insertions: z.number().optional(),
+      deletions: z.number().optional(),
+    })
+    .describe('Result of a rewindFiles operation.'),
+)
+
+export const SDKControlCancelAsyncMessageRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('cancel_async_message'),
+      message_uuid: z.string(),
+    })
+    .describe(
+      'Drops a pending async user message from the command queue by uuid. No-op if already dequeued for execution.',
+    ),
+)
+
+export const SDKControlCancelAsyncMessageResponseSchema = lazySchema(() =>
+  z
+    .object({
+      cancelled: z.boolean(),
+    })
+    .describe(
+      'Result of a cancel_async_message operation. cancelled=false means the message was not in the queue (already dequeued or never enqueued).',
+    ),
+)
+
+export const SDKControlSeedReadStateRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('seed_read_state'),
+      path: z.string(),
+      mtime: z.number(),
+    })
+    .describe(
+      'Seeds the readFileState cache with a path+mtime entry. Use when a prior Read was removed from context (e.g. by snip) so Edit validation would fail despite the client having observed the Read. The mtime lets the CLI detect if the file changed since the seeded Read — same staleness check as the normal path.',
+    ),
+)
+
+export const SDKHookCallbackRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('hook_callback'),
+      callback_id: z.string(),
+      input: HookInputSchema(),
+      tool_use_id: z.string().optional(),
+    })
+    .describe('Delivers a hook callback with its input data.'),
+)
+
+export const SDKControlMcpMessageRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('mcp_message'),
+      server_name: z.string(),
+      message: JSONRPCMessagePlaceholder(),
+    })
+    .describe('Sends a JSON-RPC message to a specific MCP server.'),
+)
+
+export const SDKControlMcpSetServersRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('mcp_set_servers'),
+      servers: z.record(z.string(), McpServerConfigForProcessTransportSchema()),
+    })
+    .describe('Replaces the set of dynamically managed MCP servers.'),
+)
+
+export const SDKControlMcpSetServersResponseSchema = lazySchema(() =>
+  z
+    .object({
+      added: z.array(z.string()),
+      removed: z.array(z.string()),
+      errors: z.record(z.string(), z.string()),
+    })
+    .describe(
+      'Result of replacing the set of dynamically managed MCP servers.',
+    ),
+)
+
+export const SDKControlReloadPluginsRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('reload_plugins'),
+    })
+    .describe(
+      'Reloads plugins from disk and returns the refreshed session components.',
+    ),
+)
+
+export const SDKControlReloadPluginsResponseSchema = lazySchema(() =>
+  z
+    .object({
+      commands: z.array(SlashCommandSchema()),
+      agents: z.array(AgentInfoSchema()),
+      plugins: z.array(
+        z.object({
+          name: z.string(),
+          path: z.string(),
+          source: z.string().optional(),
+        }),
+      ),
+      mcpServers: z.array(McpServerStatusSchema()),
+      error_count: z.number(),
+    })
+    .describe(
+      'Refreshed commands, agents, plugins, and MCP server status after reload.',
+    ),
+)
+
+export const SDKControlMcpReconnectRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('mcp_reconnect'),
+      serverName: z.string(),
+    })
+    .describe('Reconnects a disconnected or failed MCP server.'),
+)
+
+export const SDKControlMcpToggleRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('mcp_toggle'),
+      serverName: z.string(),
+      enabled: z.boolean(),
+    })
+    .describe('Enables or disables an MCP server.'),
+)
+
+
+export const SDKControlStopTaskRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('stop_task'),
+      task_id: z.string(),
+    })
+    .describe('Stops a running task.'),
+)
+
+export const SDKControlApplyFlagSettingsRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('apply_flag_settings'),
+      settings: z.record(z.string(), z.unknown()),
+    })
+    .describe(
+      'Merges the provided settings into the flag settings layer, updating the active configuration.',
+    ),
+)
+
+export const SDKControlGetSettingsRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('get_settings'),
+    })
+    .describe(
+      'Returns the effective merged settings and the raw per-source settings.',
+    ),
+)
+
+export const SDKControlGetSettingsResponseSchema = lazySchema(() =>
+  z
+    .object({
+      effective: z.record(z.string(), z.unknown()),
+      sources: z
+        .array(
+          z.object({
+            source: z.enum([
+              'userSettings',
+              'projectSettings',
+              'localSettings',
+              'flagSettings',
+              'policySettings',
+            ]),
+            settings: z.record(z.string(), z.unknown()),
+          }),
+        )
+        .describe(
+          'Ordered low-to-high priority — later entries override earlier ones.',
+        ),
+      applied: z
+        .object({
+          model: z.string(),
+          // String levels only — numeric effort is ant-only and the
+          // Zod→proto generator can't emit enum∪number unions.
+          effort: z.enum(['low', 'medium', 'high', 'max']).nullable(),
+        })
+        .optional()
+        .describe(
+          'Runtime-resolved values after env overrides, session state, and model-specific defaults are applied. Unlike `effective` (disk merge), these reflect what will actually be sent to the API.',
+        ),
+    })
+    .describe(
+      'Effective merged settings plus raw per-source settings in merge order.',
+    ),
+)
+
+export const SDKControlElicitationRequestSchema = lazySchema(() =>
+  z
+    .object({
+      subtype: z.literal('elicitation'),
+      mcp_server_name: z.string(),
+      message: z.string(),
+      mode: z.enum(['form', 'url']).optional(),
+      url: z.string().optional(),
+      elicitation_id: z.string().optional(),
+      requested_schema: z.record(z.string(), z.unknown()).optional(),
+    })
+    .describe(
+      'Requests the SDK consumer to handle an MCP elicitation (user input request).',
+    ),
+)
+
+export const SDKControlElicitationResponseSchema = lazySchema(() =>
+  z
+    .object({
+      action: z.enum(['accept', 'decline', 'cancel']),
+      content: z.record(z.string(), z.unknown()).optional(),
+    })
+    .describe('Response from the SDK consumer for an elicitation request.'),
+)
+
+
+// ============================================================================
+// Control Request/Response Wrappers
+// ============================================================================
+
+export const SDKControlRequestInnerSchema = lazySchema(() =>
+  z.union([
+    SDKControlInterruptRequestSchema(),
+    SDKControlPermissionRequestSchema(),
+    SDKControlInitializeRequestSchema(),
+    SDKControlSetPermissionModeRequestSchema(),
+    SDKControlSetModelRequestSchema(),
+    SDKControlSetMaxThinkingTokensRequestSchema(),
+    SDKControlMcpStatusRequestSchema(),
+    SDKControlGetContextUsageRequestSchema(),
+    SDKHookCallbackRequestSchema(),
+    SDKControlMcpMessageRequestSchema(),
+    SDKControlRewindFilesRequestSchema(),
+    SDKControlCancelAsyncMessageRequestSchema(),
+    SDKControlSeedReadStateRequestSchema(),
+    SDKControlMcpSetServersRequestSchema(),
+    SDKControlReloadPluginsRequestSchema(),
+    SDKControlMcpReconnectRequestSchema(),
+    SDKControlMcpToggleRequestSchema(),
+    SDKControlStopTaskRequestSchema(),
+    SDKControlApplyFlagSettingsRequestSchema(),
+    SDKControlGetSettingsRequestSchema(),
+    SDKControlElicitationRequestSchema(),
+  ]),
+)
+
+export const SDKControlRequestSchema = lazySchema(() =>
+  z.object({
+    type: z.literal('control_request'),
+    request_id: z.string(),
+    request: SDKControlRequestInnerSchema(),
+  }),
+)
+
+export const ControlResponseSchema = lazySchema(() =>
+  z.object({
+    subtype: z.literal('success'),
+    request_id: z.string(),
+    response: z.record(z.string(), z.unknown()).optional(),
+  }),
+)
+
+export const ControlErrorResponseSchema = lazySchema(() =>
+  z.object({
+    subtype: z.literal('error'),
+    request_id: z.string(),
+    error: z.string(),
+    pending_permission_requests: z
+      .array(z.lazy(() => SDKControlRequestSchema()))
+      .optional(),
+  }),
+)
+
+export const SDKControlResponseSchema = lazySchema(() =>
+  z.object({
+    type: z.literal('control_response'),
+    response: z.union([ControlResponseSchema(), ControlErrorResponseSchema()]),
+  }),
+)
+
+export const SDKControlCancelRequestSchema = lazySchema(() =>
+  z
+    .object({
+      type: z.literal('control_cancel_request'),
+      request_id: z.string(),
+    })
+    .describe('Cancels a currently open control request.'),
+)
+
+export const SDKKeepAliveMessageSchema = lazySchema(() =>
+  z
+    .object({
+      type: z.literal('keep_alive'),
+    })
+    .describe('Keep-alive message to maintain WebSocket connection.'),
+)
+
+export const SDKUpdateEnvironmentVariablesMessageSchema = lazySchema(() =>
+  z
+    .object({
+      type: z.literal('update_environment_variables'),
+      variables: z.record(z.string(), z.string()),
+    })
+    .describe('Updates environment variables at runtime.'),
+)
+
+// ============================================================================
+// Aggregate Message Types
+// ============================================================================
+
+export const StdoutMessageSchema = lazySchema(() =>
+  z.union([
+    SDKMessageSchema(),
+    SDKStreamlinedTextMessageSchema(),
+    SDKStreamlinedToolUseSummaryMessageSchema(),
+    SDKPostTurnSummaryMessageSchema(),
+    SDKControlResponseSchema(),
+    SDKControlRequestSchema(),
+    SDKControlCancelRequestSchema(),
+    SDKKeepAliveMessageSchema(),
+  ]),
+)
+
+export const StdinMessageSchema = lazySchema(() =>
+  z.union([
+    SDKUserMessageSchema(),
+    SDKControlRequestSchema(),
+    SDKControlResponseSchema(),
+    SDKKeepAliveMessageSchema(),
+    SDKUpdateEnvironmentVariablesMessageSchema(),
+  ]),
+)

src/harness/evaluation/README.md

@@ -0,0 +1,108 @@
+# Evaluation Harness
+
+This module instantiates a public task bundle into an isolated run directory,
+runs one source-native Claude Code `QueryEngine` session, executes hidden judge
+attempts, and writes compact JSONL trajectories for later skill extraction.
+
+## Source-Native Architecture
+
+The harness entrypoint calls `runSourceTaskLoop`, which creates exactly one `SourceClaudeSessionAgent` for the run. That session
+constructs `QueryEngine` directly from the local Claude source and reuses it
+across judge feedback rounds.
+
+Per run:
+
+1. `createTaskRun` copies only public task files into `runs/<run_id>/public`.
+2. `resolveTaskRuntime` verifies the task Python before agent startup.
+3. `SourceClaudeSessionAgent` builds a minimal tool pool from Claude source
+   tools plus the in-process `finalize_submission` tool.
+4. `createHarnessCanUseTool` enforces run-local read/write policy for tool use.
+5. `DefaultJudgeRunner` copies private judge assets into `.judge_private` only
+   when a judge attempt is triggered.
+
+Batch mode is source-only: repeated `--task` values are dispatched as one worker
+process per run. The removed legacy runtime is rejected explicitly.
+
+## Loop Semantics
+
+`max_rounds` means maximum judge attempts, not maximum agent tool calls. A judge
+attempt is triggered only when the agent calls `finalize_submission` and output
+validation passes against the public output contract. Validation failures are
+returned as recoverable tool feedback and do not consume a judge round.
+
+Natural-language messages such as "done" are ignored. If an agent turn ends
+without a passing `finalize_submission`, the harness gives exactly one
+same-round no-finalize recovery prompt. Recovery does not auto-validate,
+auto-submit, or auto-judge; if it still ends without a passing
+`finalize_submission`, the run fails or times out without a judge attempt.
+
+Missing `workspace/plan.md` or `workspace/plans/round_NN.md` files are recorded
+as warnings, not hard blockers, when outputs are otherwise valid.
+
+## Task Visibility
+
+Agent-visible paths are limited to the current run:
+
+- `public/`: read-only public task bundle.
+- `workspace/`: writable solver code, notes, and scratch files.
+- `outputs/`: writable final submission files.
+- `logs/agent/`: writable agent logs.
+
+Private `evaluation/`, `std_code/`, reference output, and judge data paths are
+not copied into the agent-visible workspace. They are available only to the
+external judge under `runs/.judge_private/<run_id>/`.
+
+The initial prompt now includes a compact public file manifest, output contract,
+visible case summary, and the full public README. No `public/HARNESS_HINTS.md`
+file is generated.
+
+## Runtime Resolution
+
+The harness resolves Python once before creating the Claude session. It reads
+`public/envs/env_manifest.json`, chooses the platform-specific Python path, and
+falls back to conventional runtime locations:
+
+- Windows: `public/envs/runtime/.venv/Scripts/python.exe`
+- POSIX/WSL: `public/envs/runtime/.venv/bin/python`
+- POSIX/WSL alternate: `public/envs/runtime/.venv-posix/bin/python`
+
+If no runtime exists, the run exits as `infra_error`; the agent is not asked to
+repair virtual environments or install packages.
+
+Virtual-environment directories are linked into the run instead of copied, so a
+run does not spend minutes duplicating `site-packages`.
+
+## Trajectories
+
+`SourceTrajectoryWriter` writes two append-only files:
+
+- `logs/trajectory.clean.jsonl`: compact training-friendly records.
+- `logs/trajectory.raw.jsonl`: raw source events for debugging.
+
+Static context is written once as `run_context`. Judge feedback is compacted
+before being sent as a continuation prompt in the same session, while the raw
+judge JSON stays in `trajectory.raw.jsonl` for debugging.
+
+Clean trajectories also record validation pass/fail events, run warnings, and
+no-finalize recovery markers. Raw trajectories preserve source events exactly;
+clean trajectories filter standalone punctuation-only assistant text such as
+`.` or `...`.
+
+## CLI
+
+```bash
+bun src/harness/evaluation/cli.ts --task <task_id> --runs-dir output/runs --max-rounds 3 --timeout-seconds 1800 --temperature 1 --thinking disabled
+```
+
+`--system-prompt <path>` is a debug-only explicit override. Normal source-native
+runs use the built-in lean system contract plus the generated initial prompt;
+there is no default `config/AGENT.md`.
+
+The default LLM options are `--thinking disabled --temperature 1`. With
+thinking disabled, temperature is sent to the model. With `--thinking adaptive`,
+temperature is intentionally omitted and logged as ignored in run metadata.
+
+`--max-turns-per-round <n>` caps agentic turns within one judge round. It is
+optional; full implementation regressions usually leave it unset and rely on
+`--timeout-seconds` as the whole-loop hard timeout. Set a cap when diagnosing
+no-finalize loops or running short smoke tests.

src/harness/evaluation/batchRunner.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, test } from 'bun:test'
+import { runEvaluationBatch, type SpawnEvaluationWorker } from './batchRunner.js'
+
+describe('runEvaluationBatch', () => {
+  test('spawns one worker process per task in source batch mode', async () => {
+    const spawned: Array<{ command: string; args: string[]; timeoutMs?: number }> = []
+    const spawnWorker: SpawnEvaluationWorker = async request => {
+      spawned.push({
+        command: request.command,
+        args: request.args,
+        timeoutMs: request.timeoutMs,
+      })
+      return { taskId: request.taskId, exitCode: 0 }
+    }
+
+    const result = await runEvaluationBatch({
+      taskIds: ['task_a', 'task_b'],
+      tasksDir: 'tasks',
+      runsDir: 'output/runs',
+      maxRounds: 2,
+      maxTurnsPerRound: 9,
+      timeoutSeconds: 120,
+      concurrency: 3,
+      workerTimeoutGraceSeconds: 10,
+      temperature: 0.2,
+      thinking: 'adaptive',
+      timestamp: '20260513_010203',
+      systemPromptPath: 'config/debug-prompt.md',
+      verbose: false,
+      spawnWorker,
+    })
+
+    expect(result.ok).toBe(true)
+    expect(spawned).toHaveLength(2)
+    expect(spawned[0].args).toContain('--worker-run')
+    expect(spawned[0].args).toContain('--task')
+    expect(spawned[0].args).toContain('task_a')
+    expect(spawned[0].args).toContain('--max-turns-per-round')
+    expect(spawned[0].args).toContain('9')
+    expect(spawned[0].args).toContain('--temperature')
+    expect(spawned[0].args).toContain('0.2')
+    expect(spawned[0].args).toContain('--thinking')
+    expect(spawned[0].args).toContain('adaptive')
+    expect(spawned[0].timeoutMs).toBe(130000)
+    expect(spawned[1].args).toContain('task_b')
+  })
+
+  test('runs workers as a fixed-size pipeline', async () => {
+    const started: string[] = []
+    const resolvers = new Map<string, (exitCode: number) => void>()
+    const spawnWorker: SpawnEvaluationWorker = request => {
+      started.push(request.taskId)
+      return new Promise(resolve => {
+        resolvers.set(request.taskId, exitCode =>
+          resolve({ taskId: request.taskId, exitCode }),
+        )
+      })
+    }
+
+    const running = runEvaluationBatch({
+      taskIds: ['a', 'b', 'c', 'd', 'e'],
+      tasksDir: 'tasks',
+      runsDir: 'output/runs',
+      maxRounds: 1,
+      timeoutSeconds: 120,
+      concurrency: 3,
+      temperature: 1,
+      thinking: 'disabled',
+      verbose: false,
+      spawnWorker,
+    })
+
+    await Promise.resolve()
+    expect(started).toEqual(['a', 'b', 'c'])
+
+    resolvers.get('b')?.(0)
+    await Promise.resolve()
+    expect(started).toEqual(['a', 'b', 'c', 'd'])
+
+    resolvers.get('a')?.(0)
+    await Promise.resolve()
+    expect(started).toEqual(['a', 'b', 'c', 'd', 'e'])
+
+    for (const taskId of ['c', 'd', 'e']) {
+      resolvers.get(taskId)?.(0)
+    }
+    const result = await running
+    expect(result.ok).toBe(true)
+    expect(result.workers.map(worker => worker.taskId)).toEqual(['a', 'b', 'c', 'd', 'e'])
+  })
+
+  test('continues launching queued workers after a worker fails', async () => {
+    const started: string[] = []
+    const spawnWorker: SpawnEvaluationWorker = async request => {
+      started.push(request.taskId)
+      return { taskId: request.taskId, exitCode: request.taskId === 'a' ? 1 : 0 }
+    }
+
+    const result = await runEvaluationBatch({
+      taskIds: ['a', 'b', 'c'],
+      tasksDir: 'tasks',
+      runsDir: 'output/runs',
+      maxRounds: 1,
+      timeoutSeconds: 120,
+      concurrency: 1,
+      temperature: 1,
+      thinking: 'disabled',
+      verbose: false,
+      spawnWorker,
+    })
+
+    expect(started).toEqual(['a', 'b', 'c'])
+    expect(result.ok).toBe(false)
+    expect(result.workers.map(worker => worker.exitCode)).toEqual([1, 0, 0])
+  })
+
+  test('passes worker watchdog timeout to spawned workers', async () => {
+    const timeouts: Array<number | undefined> = []
+    const spawnWorker: SpawnEvaluationWorker = async request => {
+      timeouts.push(request.timeoutMs)
+      return { taskId: request.taskId, exitCode: 0 }
+    }
+
+    await runEvaluationBatch({
+      taskIds: ['task_a'],
+      tasksDir: 'tasks',
+      runsDir: 'output/runs',
+      maxRounds: 1,
+      timeoutSeconds: 10,
+      workerTimeoutGraceSeconds: 7,
+      concurrency: 3,
+      temperature: 1,
+      thinking: 'disabled',
+      verbose: false,
+      spawnWorker,
+    })
+
+    expect(timeouts).toEqual([17000])
+  })
+})

src/harness/evaluation/batchRunner.ts

@@ -0,0 +1,148 @@
+export type EvaluationWorkerRequest = {
+  taskId: string
+  command: string
+  args: string[]
+  timeoutMs?: number
+}
+
+export type EvaluationWorkerResult = {
+  taskId: string
+  exitCode: number
+}
+
+export type SpawnEvaluationWorker = (
+  request: EvaluationWorkerRequest,
+) => Promise<EvaluationWorkerResult>
+
+export type RunEvaluationBatchInput = {
+  taskIds: string[]
+  tasksDir: string
+  runsDir: string
+  maxRounds: number
+  maxTurnsPerRound?: number
+  timeoutSeconds: number
+  temperature: number
+  thinking: 'disabled' | 'adaptive'
+  systemPromptPath?: string
+  timestamp?: string
+  concurrency?: number
+  workerTimeoutGraceSeconds?: number
+  verbose: boolean
+  spawnWorker?: SpawnEvaluationWorker
+}
+
+export type RunEvaluationBatchResult = {
+  ok: boolean
+  workers: EvaluationWorkerResult[]
+}
+
+function pushOption(args: string[], name: string, value: string | number | undefined): void {
+  if (value === undefined) return
+  args.push(name, String(value))
+}
+
+function workerArgs(input: RunEvaluationBatchInput, taskId: string): string[] {
+  const args = [
+    'src/harness/evaluation/cli.ts',
+    '--worker-run',
+    '--agent-runtime',
+    'source',
+    '--task',
+    taskId,
+  ]
+  pushOption(args, '--tasks-dir', input.tasksDir)
+  pushOption(args, '--runs-dir', input.runsDir)
+  pushOption(args, '--max-rounds', input.maxRounds)
+  pushOption(args, '--max-turns-per-round', input.maxTurnsPerRound)
+  pushOption(args, '--timeout-seconds', input.timeoutSeconds)
+  pushOption(args, '--temperature', input.temperature)
+  pushOption(args, '--thinking', input.thinking)
+  pushOption(args, '--system-prompt', input.systemPromptPath)
+  pushOption(args, '--timestamp', input.timestamp)
+  if (!input.verbose) args.push('--quiet')
+  return args
+}
+
+const defaultSpawnWorker: SpawnEvaluationWorker = request => {
+  const child = Bun.spawn([request.command, ...request.args], {
+    stdout: 'inherit',
+    stderr: 'inherit',
+    env: process.env,
+  })
+  const exited = child.exited.then(exitCode => ({
+    taskId: request.taskId,
+    exitCode,
+  }))
+  if (!request.timeoutMs) return exited
+
+  let timedOut = false
+  let timeoutTimer: ReturnType<typeof setTimeout> | undefined
+  let killTimer: ReturnType<typeof setTimeout> | undefined
+  const timeout = new Promise<EvaluationWorkerResult>(resolve => {
+    timeoutTimer = setTimeout(() => {
+      timedOut = true
+      child.kill('SIGTERM')
+      killTimer = setTimeout(() => child.kill('SIGKILL'), 5000)
+      killTimer.unref?.()
+      resolve({ taskId: request.taskId, exitCode: 124 })
+    }, request.timeoutMs)
+    timeoutTimer.unref?.()
+  })
+
+  void child.exited.finally(() => {
+    if (killTimer) clearTimeout(killTimer)
+  })
+
+  return Promise.race([exited, timeout]).finally(() => {
+    if (timeoutTimer) clearTimeout(timeoutTimer)
+    if (!timedOut && killTimer) clearTimeout(killTimer)
+  })
+}
+
+export async function runEvaluationBatch(
+  input: RunEvaluationBatchInput,
+): Promise<RunEvaluationBatchResult> {
+  const spawnWorker = input.spawnWorker ?? defaultSpawnWorker
+  const command = process.execPath
+  const concurrency = Math.max(1, input.concurrency ?? 3)
+  const timeoutMs =
+    (input.timeoutSeconds + (input.workerTimeoutGraceSeconds ?? 60)) * 1000
+  const workers: Array<EvaluationWorkerResult | undefined> = new Array(
+    input.taskIds.length,
+  )
+  let nextIndex = 0
+
+  async function runLane(): Promise<void> {
+    for (;;) {
+      const index = nextIndex
+      nextIndex++
+      if (index >= input.taskIds.length) return
+
+      const taskId = input.taskIds[index]
+      try {
+        workers[index] = await spawnWorker({
+          taskId,
+          command,
+          args: workerArgs(input, taskId),
+          timeoutMs,
+        })
+      } catch {
+        workers[index] = { taskId, exitCode: 1 }
+      }
+    }
+  }
+
+  const laneCount = Math.min(concurrency, input.taskIds.length)
+  await Promise.all(Array.from({ length: laneCount }, () => runLane()))
+
+  const completedWorkers = workers.map((worker, index) =>
+    worker ?? {
+      taskId: input.taskIds[index],
+      exitCode: 1,
+    },
+  )
+  return {
+    ok: completedWorkers.every(worker => worker.exitCode === 0),
+    workers: completedWorkers,
+  }
+}

src/harness/evaluation/biomnibenchAdapter.ts

@@ -0,0 +1,120 @@
+/**
+ * biomnibenchAdapter.ts
+ *
+ * Adapter for BioMniBench-organized tasks (Docker-based data analysis tasks
+ * with `da-X-Y/` structure). These tasks differ from the imaging task format
+ * that `my_claude` was originally designed for:
+ *
+ *   Imaging tasks (original):                BioMniBench tasks (this adapter):
+ *   - envs/env_manifest.json                 - envs/Dockerfile (no manifest)
+ *   - envs/runtime/.venv/bin/python          - shared venv at <repoRoot>/shared_venv
+ *   - output_schema.json                     - README.md (free-form output)
+ *   - visible_data/cases.json                - visible_data/ (raw data files)
+ *   - evaluation/judge.py                    - evaluation/llm_judge.py + rubric.txt
+ *   - submission as outputs/*.npz            - submission as trace.md + answer.txt
+ *   - full task_manifest.json                - minimal task_manifest.json (only task_id)
+ *
+ * Detection is conservative: a task is treated as BioMniBench when the task
+ * directory contains BOTH `envs/Dockerfile` and `evaluation/rubric.txt`. Tasks
+ * that look like imaging tasks (env_manifest.json present) always take the
+ * legacy code path.
+ */
+
+import { existsSync } from 'fs'
+import { readFile } from 'fs/promises'
+import { join, resolve, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import type { TaskManifest } from './types.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+/** Repository root for my_claude_biomnibench (3 levels above this file). */
+const REPO_ROOT = resolve(__dirname, '..', '..', '..')
+
+/** Default shared Python venv (conda env via symlink) used by all biomnibench tasks. */
+export const SHARED_VENV_DIR = resolve(REPO_ROOT, 'shared_venv')
+
+/** Path to the qwen-backed LLM judge script bundled with the harness. */
+export const QWEN_JUDGE_SCRIPT = resolve(REPO_ROOT, 'llm_judge_qwen.py')
+
+/** Heuristic detection of a BioMniBench-organized task directory. */
+export function isBioMniBenchTask(taskDir: string): boolean {
+  const dockerfile = join(taskDir, 'envs', 'Dockerfile')
+  const rubric = join(taskDir, 'evaluation', 'rubric.txt')
+  const envManifest = join(taskDir, 'envs', 'env_manifest.json')
+  // If env_manifest.json is present, treat as imaging task (legacy path).
+  if (existsSync(envManifest)) return false
+  return existsSync(dockerfile) && existsSync(rubric)
+}
+
+/** Resolve the Python interpreter to use for a BioMniBench task. */
+export function resolveSharedPython(): string | null {
+  const candidates = [
+    join(SHARED_VENV_DIR, 'bin', 'python'),
+    join(SHARED_VENV_DIR, 'bin', 'python3'),
+  ]
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+/**
+ * Construct an in-memory `TaskManifest` for a BioMniBench task. The on-disk
+ * `task_manifest.json` only contains the task id; this synthesises the fields
+ * the rest of the harness depends on.
+ */
+export function buildBioMniBenchManifest(taskId: string): TaskManifest {
+  return {
+    version: 1,
+    task_id: taskId,
+    public_bundle: [
+      'README.md',
+      'data',
+      'visible_data',
+    ],
+    private_judge_bundle: ['evaluation/'],
+    entrypoints: {
+      judge: 'evaluation/llm_judge.py',
+    },
+    submission: {
+      output_dir: 'outputs',
+    },
+  }
+}
+
+/** Read and merge an on-disk task_manifest.json with the synthesized one. */
+export async function loadBioMniBenchManifest(taskDir: string, taskId: string): Promise<TaskManifest> {
+  const synthesised = buildBioMniBenchManifest(taskId)
+  const manifestPath = join(taskDir, 'task_manifest.json')
+  if (!existsSync(manifestPath)) return synthesised
+  try {
+    const raw = await readFile(manifestPath, 'utf8')
+    const onDisk = JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw) as Partial<TaskManifest>
+    return {
+      ...synthesised,
+      ...onDisk,
+      task_id: taskId,
+      // Always keep the synthesised entrypoints/submission unless caller already set them.
+      entrypoints: { ...synthesised.entrypoints, ...(onDisk.entrypoints ?? {}) },
+      submission: { ...synthesised.submission, ...(onDisk.submission ?? {}) },
+      public_bundle: onDisk.public_bundle ?? synthesised.public_bundle,
+      private_judge_bundle: onDisk.private_judge_bundle ?? synthesised.private_judge_bundle,
+    }
+  } catch {
+    return synthesised
+  }
+}
+
+/** Build the initial agent prompt for a BioMniBench task using the README. */
+export async function buildBioMniBenchSystemContext(taskDir: string): Promise<string> {
+  const readmePath = join(taskDir, 'README.md')
+  let readme = ''
+  try {
+    readme = await readFile(readmePath, 'utf8')
+  } catch {
+    readme = '(no README available)'
+  }
+  return readme
+}

src/harness/evaluation/cli.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'bun:test'
+import { exitCodeForLoopStatus, parseEvaluationCliArgs } from './cli.js'
+
+describe('parseEvaluationCliArgs', () => {
+  test('requires task id and parses loop controls', () => {
+    const parsed = parseEvaluationCliArgs([
+      '--task',
+      'demo_task',
+      '--max-rounds',
+      '4',
+      '--timeout-seconds',
+      '120',
+      '--concurrency',
+      '3',
+      '--worker-timeout-grace-seconds',
+      '15',
+      '--max-turns-per-round',
+      '9',
+      '--agent-runtime',
+      'source',
+      '--runs-dir',
+      'output/runs',
+    ])
+
+    expect(parsed.taskId).toBe('demo_task')
+    expect(parsed.maxRounds).toBe(4)
+    expect(parsed.maxTurnsPerRound).toBe(9)
+    expect(parsed.timeoutSeconds).toBe(120)
+    expect(parsed.concurrency).toBe(3)
+    expect(parsed.workerTimeoutGraceSeconds).toBe(15)
+    expect(parsed.runsDir).toBe('output/runs')
+    expect(parsed.agentRuntime).toBe('source')
+    expect(parsed.temperature).toBe(1)
+    expect(parsed.thinking).toBe('disabled')
+    expect(parsed.taskIds).toEqual(['demo_task'])
+    expect(parsed.systemPromptPath).toBeUndefined()
+  })
+
+  test('parses repeated tasks for source batch mode', () => {
+    const parsed = parseEvaluationCliArgs([
+      '--task',
+      'task_a,task_b',
+      '--task',
+      'task_c',
+      '--quiet',
+    ])
+
+    expect(parsed.taskId).toBe('task_a')
+    expect(parsed.taskIds).toEqual(['task_a', 'task_b', 'task_c'])
+    expect(parsed.maxTurnsPerRound).toBeUndefined()
+    expect(parsed.verbose).toBe(false)
+  })
+
+  test('rejects removed legacy subprocess runtime', () => {
+    expect(() =>
+      parseEvaluationCliArgs(['--task', 'demo_task', '--agent-runtime', 'legacy-subprocess']),
+    ).toThrow('legacy-subprocess has been removed')
+  })
+
+  test('parses temperature and thinking controls', () => {
+    const parsed = parseEvaluationCliArgs([
+      '--task',
+      'demo_task',
+      '--temperature',
+      '0.2',
+      '--thinking',
+      'adaptive',
+    ])
+
+    expect(parsed.temperature).toBe(0.2)
+    expect(parsed.thinking).toBe('adaptive')
+  })
+
+  test('rejects invalid temperature and thinking values', () => {
+    expect(() =>
+      parseEvaluationCliArgs(['--task', 'demo_task', '--temperature', 'hot']),
+    ).toThrow('--temperature')
+    expect(() =>
+      parseEvaluationCliArgs(['--task', 'demo_task', '--temperature', '2']),
+    ).toThrow('--temperature')
+    expect(() =>
+      parseEvaluationCliArgs(['--task', 'demo_task', '--thinking', 'enabled']),
+    ).toThrow('--thinking')
+  })
+
+  test('maps loop status to process exit code', () => {
+    expect(exitCodeForLoopStatus('success')).toBe(0)
+    expect(exitCodeForLoopStatus('failed')).toBe(1)
+    expect(exitCodeForLoopStatus('timeout')).toBe(1)
+    expect(exitCodeForLoopStatus('infra_error')).toBe(1)
+  })
+})

src/harness/evaluation/runEventLogger.ts

@@ -0,0 +1,139 @@
+import { appendFile, mkdir } from 'fs/promises'
+import { join } from 'path'
+import type { SourceAgentEvent, TaskRun } from './types.js'
+
+export type RunEventType =
+  | 'run_started'
+  | 'agent_step_started'
+  | 'agent_step_finished'
+  | 'agent_step_error'
+  | 'agent_recovery_started'
+  | 'agent_recovery_finished'
+  | 'agent_event'
+  | 'submission_validation_failed'
+  | 'submission_validation_passed'
+  | 'run_warning'
+  | 'judge_started'
+  | 'judge_finished'
+  | 'run_finished'
+
+export type RunEvent = {
+  timestamp: string
+  run_id: string
+  task_id: string
+  type: RunEventType
+  judge_round?: number
+  agent_step?: number
+  message?: string
+  details?: unknown
+}
+
+export type RunEventLoggerInput = {
+  taskRun: TaskRun
+  verbose?: boolean
+}
+
+function shorten(value: string, maxLength = 240): string {
+  return value.length <= maxLength ? value : `${value.slice(0, maxLength)}...`
+}
+
+export function summarizeAgentEvent(event: SourceAgentEvent): Record<string, unknown> {
+  if (event.type === 'assistant_text') {
+    return { type: event.type, text_length: event.text.length }
+  }
+  if (event.type === 'tool_call') {
+    return { type: event.type, tool: event.tool, toolUseId: event.toolUseId }
+  }
+  if (event.type === 'tool_result') {
+    return {
+      type: event.type,
+      ok: event.ok,
+      toolUseId: event.toolUseId,
+      text_tail: event.text?.slice(-1000),
+    }
+  }
+  if (event.type === 'policy_deny') {
+    return { type: event.type, tool: event.tool, reason: event.reason }
+  }
+  if (event.type === 'trajectory_warning') {
+    return {
+      type: event.type,
+      code: event.code,
+      message: event.message,
+      details: event.details,
+    }
+  }
+  if (event.type === 'run_warning') {
+    return {
+      type: event.type,
+      code: event.code,
+      message: event.message,
+      details: event.details,
+    }
+  }
+  if (event.type === 'submission_validation_failed') {
+    return {
+      type: event.type,
+      ok: event.result.ok,
+      issue_count: event.result.issues.length,
+      normalized_files: event.result.normalizedFiles,
+      issues: event.result.issues,
+    }
+  }
+  if (event.type === 'submission_validation_passed') {
+    return {
+      type: event.type,
+      ok: event.result.ok,
+      normalized_files: event.result.normalizedFiles,
+    }
+  }
+  if (event.type === 'agent_result') {
+    return {
+      type: event.type,
+      subtype: event.subtype,
+      stopReason: event.stopReason,
+      isError: event.isError,
+      durationMs: event.durationMs,
+      errors: event.errors,
+    }
+  }
+  return { type: event.type, summary: event.summary, files: event.files }
+}
+
+function formatConsoleEvent(event: RunEvent): string {
+  const prefix = `[${event.timestamp}] ${event.type}`
+  const round = event.judge_round ? ` round=${event.judge_round}` : ''
+  const step = event.agent_step ? ` step=${event.agent_step}` : ''
+  const message = event.message ? ` ${shorten(event.message)}` : ''
+  return `${prefix}${round}${step}${message}`
+}
+
+export class RunEventLogger {
+  readonly path: string
+  private readonly taskRun: TaskRun
+  private readonly verbose: boolean
+
+  constructor(input: RunEventLoggerInput) {
+    this.taskRun = input.taskRun
+    this.verbose = Boolean(input.verbose)
+    this.path = join(input.taskRun.logsDir, 'run_events.jsonl')
+  }
+
+  async log(
+    type: RunEventType,
+    event: Omit<Partial<RunEvent>, 'timestamp' | 'run_id' | 'task_id' | 'type'> = {},
+  ): Promise<void> {
+    const record: RunEvent = {
+      timestamp: new Date().toISOString(),
+      run_id: this.taskRun.runId,
+      task_id: this.taskRun.taskId,
+      type,
+      ...event,
+    }
+    await mkdir(this.taskRun.logsDir, { recursive: true })
+    await appendFile(this.path, `${JSON.stringify(record)}\n`, 'utf8')
+    if (this.verbose) {
+      process.stderr.write(`${formatConsoleEvent(record)}\n`)
+    }
+  }
+}

src/harness/evaluation/sourceContextBuilder.ts

@@ -0,0 +1,466 @@
+import { readdir, readFile } from 'fs/promises'
+import { join, relative } from 'path'
+import type {
+  JudgeResult,
+  PriorSubtaskContext,
+  RuntimeInfo,
+  TaskRun,
+} from './types.js'
+import { isBioMniBenchTask } from './biomnibenchAdapter.js'
+
+type OutputSchema = {
+  submission?: {
+    path_template?: string
+  }
+  path_template?: string
+  arrays?: Array<{
+    key?: string
+    shape?: unknown
+    dtype?: unknown
+  }>
+  validation?: {
+    finite_only?: boolean
+  }
+}
+
+type CasesConfig = {
+  cases?: Array<{
+    id?: string
+    input_dir?: string
+    params?: string
+    expected_output?: string
+    description?: string
+  }>
+}
+
+type CompactJudgeFeedback = {
+  format: string
+  reasons: string[]
+  failedMetrics: string[]
+  passedMetrics: string[]
+  message?: string
+}
+
+function stripUtf8Bom(value: string): string {
+  return value.charCodeAt(0) === 0xfeff ? value.slice(1) : value
+}
+
+async function readJsonIfExists<T>(path: string): Promise<T | undefined> {
+  try {
+    return JSON.parse(stripUtf8Bom(await readFile(path, 'utf8'))) as T
+  } catch {
+    return undefined
+  }
+}
+
+function roundPlanPath(round: number): string {
+  return `workspace/plans/round_${String(round).padStart(2, '0')}.md`
+}
+
+function shouldSkipPublicPath(relativePath: string): boolean {
+  const parts = relativePath.replace(/\\/g, '/').split('/')
+  return parts.includes('.venv') || parts.includes('.venv-posix')
+}
+
+async function collectPublicFiles(
+  publicDir: string,
+  currentDir = publicDir,
+): Promise<string[]> {
+  const entries = await readdir(currentDir, { withFileTypes: true })
+  const files: string[] = []
+  for (const entry of entries) {
+    const absolutePath = join(currentDir, entry.name)
+    const relativePath = relative(publicDir, absolutePath).replace(/\\/g, '/')
+    if (shouldSkipPublicPath(relativePath)) continue
+    if (entry.isDirectory()) {
+      files.push(...(await collectPublicFiles(publicDir, absolutePath)))
+      continue
+    }
+    if (entry.isFile()) files.push(relativePath)
+  }
+  return files.sort((a, b) => a.localeCompare(b))
+}
+
+function formatPublicFiles(files: string[]): string {
+  if (files.length === 0) return '(No public files found.)'
+  return files.map(file => `- ${file}`).join('\n')
+}
+
+function formatShape(shape: unknown): string {
+  return Array.isArray(shape) ? `[${shape.join(',')}]` : 'unspecified'
+}
+
+function formatDtype(dtype: unknown): string {
+  if (Array.isArray(dtype)) return dtype.map(String).join('|')
+  if (typeof dtype === 'string') return dtype
+  return 'unspecified'
+}
+
+function buildOutputContract(schema: OutputSchema | undefined): string {
+  if (!schema) {
+    return 'Output schema summary unavailable. Read public/output_schema.json if needed.'
+  }
+  const pattern =
+    schema.submission?.path_template ?? schema.path_template ?? 'outputs/{case_id}.npz'
+  const lines = [`Required file pattern: ${pattern}`, 'Required arrays:']
+  const arrays = schema.arrays ?? []
+  if (arrays.length === 0) {
+    lines.push('- (No array requirements found in output_schema.json.)')
+  } else {
+    const finite = schema.validation?.finite_only === false ? '' : ', finite'
+    for (const item of arrays) {
+      lines.push(
+        `- ${item.key ?? '(unnamed)'}: shape ${formatShape(item.shape)}, dtype ${formatDtype(item.dtype)}${finite}`,
+      )
+    }
+  }
+  return lines.join('\n')
+}
+
+function buildVisibleCases(cases: CasesConfig | undefined): string {
+  const items = cases?.cases ?? []
+  if (items.length === 0) return '(No visible cases listed.)'
+  return items
+    .map(item =>
+      [
+        `- ${item.id ?? '(unknown_case)'}:`,
+        item.input_dir ? `  input_dir: ${item.input_dir}` : undefined,
+        item.params ? `  params: ${item.params}` : undefined,
+        item.expected_output ? `  expected_output: ${item.expected_output}` : undefined,
+        item.description ? `  description: ${item.description}` : undefined,
+      ]
+        .filter(Boolean)
+        .join('\n'),
+    )
+    .join('\n')
+}
+
+/** Maximum characters of generated code we inline per prior sub-task. */
+const PRIOR_CODE_CHAR_LIMIT = 6000
+
+/** Maximum characters of description we inline per prior sub-task. */
+const PRIOR_DESCRIPTION_CHAR_LIMIT = 1200
+
+function truncateForPrompt(value: string, limit: number, label: string): string {
+  if (!value) return ''
+  if (value.length <= limit) return value
+  const head = value.slice(0, limit)
+  return `${head}\n... [${label} truncated: ${value.length - limit} more chars elided]`
+}
+
+/**
+ * Render the prior sub-task block that gets prepended to each new sub-task's
+ * initial prompt in true-serial mode. Returns an empty string when no prior
+ * sub-tasks are supplied so the prompt stays identical to single-task mode.
+ */
+function formatPriorSubtasks(priorSubtasks: PriorSubtaskContext[] | undefined): string {
+  if (!priorSubtasks || priorSubtasks.length === 0) return ''
+  const blocks: string[] = [
+    '<prior_subtasks>',
+    'You are continuing a serial multi-sub-task study. Earlier sub-tasks from the',
+    'same parent paper have already been solved by you in a separate evaluation',
+    'session. Their final solver code and outcomes are provided below so you can:',
+    '  - reuse data-loading patterns, column names, and preprocessing logic you',
+    '    already established, instead of re-deriving them;',
+    '  - avoid repeating mistakes that previously failed judge;',
+    '  - keep results consistent across sub-tasks (e.g. same filtering thresholds,',
+    '    same train/test splits, same statistical conventions).',
+    'Each sub-task is independently judged - do NOT assume their outputs/ files',
+    'are available to your current run. Always re-read the data files yourself.',
+    '',
+  ]
+  for (const prior of priorSubtasks) {
+    blocks.push('<prior_subtask>')
+    blocks.push(`task_id: ${prior.taskId}`)
+    if (typeof prior.taskIdx === 'number') {
+      blocks.push(`task_idx: ${prior.taskIdx}`)
+    }
+    if (prior.status) {
+      blocks.push(`status: ${prior.status}`)
+    }
+    if (typeof prior.passed === 'boolean') {
+      blocks.push(`judge_passed: ${prior.passed}`)
+    }
+    if (prior.description) {
+      blocks.push('<description>')
+      blocks.push(
+        truncateForPrompt(
+          prior.description.trim(),
+          PRIOR_DESCRIPTION_CHAR_LIMIT,
+          'description',
+        ),
+      )
+      blocks.push('</description>')
+    }
+    if (prior.generatedCode) {
+      blocks.push(`<generated_code language="python">`)
+      blocks.push(
+        truncateForPrompt(
+          prior.generatedCode,
+          PRIOR_CODE_CHAR_LIMIT,
+          'generated_code',
+        ),
+      )
+      blocks.push('</generated_code>')
+    }
+    if (prior.judgeFeedback) {
+      blocks.push('<judge_feedback>')
+      blocks.push(prior.judgeFeedback.trim())
+      blocks.push('</judge_feedback>')
+    }
+    if (prior.notes) {
+      blocks.push('<notes>')
+      blocks.push(prior.notes.trim())
+      blocks.push('</notes>')
+    }
+    blocks.push('</prior_subtask>')
+    blocks.push('')
+  }
+  blocks.push('</prior_subtasks>')
+  return blocks.join('\n')
+}
+
+export function buildSourceSystemPrompt(extra?: string): string {
+  return [
+    'You are an autonomous solver inside a source-native evaluation harness.',
+    '',
+    'Goal: produce valid final submission files for the current public task.',
+    '',
+    'Use only run-local paths:',
+    '- public/: read-only public task data.',
+    '- workspace/: writable scratch, plans, and solver code.',
+    '- outputs/: writable final submission files.',
+    '- logs/agent/: optional notes.',
+    '',
+    'Do not access private judge data, original task directories, other runs, parent directories, home directories, or system secrets.',
+    '',
+    'Use the provided Python runtime. Do not install packages or create/repair environments.',
+    '',
+    'Planning discipline:',
+    '- You may inspect necessary public files before planning.',
+    '- For each judge round, once you understand the task and any judge feedback, write a detailed, task-specific plan before implementation, long computation, or submission.',
+    '- Write the round plan to workspace/plans/round_NN.md and copy the current round plan to workspace/plan.md.',
+    '- The plan should be as detailed as needed: include task understanding, public data observations, assumptions, algorithm strategy, validation strategy, risks, and concrete execution steps.',
+    '- Avoid generic filler. Every plan section should contain information specific to this task or this judge feedback.',
+    '- Do not use TodoWrite; plans must be file artifacts.',
+    '',
+    'Round closure discipline:',
+    '- Judge feedback is more valuable than private speculation. Prefer submitting a valid best attempt over running open-ended experiments.',
+    '- In each judge round, run only a small set of focused experiments, then select the best solver, regenerate outputs/, validate the file format, and call finalize_submission.',
+    '- If you believe outputs/ already contains files matching the output contract, submit the best available valid output instead of continuing unbounded exploration.',
+    '',
+    'Experiment discipline:',
+    '- Put non-trivial Python experiments in workspace/experiments/*.py or workspace/*.py.',
+    '- Do not put long Python programs in Bash python -c; Bash should run scripts or short validation commands.',
+    '',
+    'When final output files exist under outputs/, call finalize_submission. A text answer is not a submission.',
+    extra?.trim(),
+  ]
+    .filter(Boolean)
+    .join('\n')
+}
+
+export async function buildInitialSourcePrompt(input: {
+  taskRun: TaskRun
+  runtime: RuntimeInfo
+  userTask: string
+  maxRounds: number
+  priorSubtasks?: PriorSubtaskContext[]
+}): Promise<string> {
+  const { taskRun, runtime, userTask, maxRounds, priorSubtasks } = input
+  const priorBlock = formatPriorSubtasks(priorSubtasks)
+
+  // BioMniBench tasks have free-form output (trace.md + answer.txt) instead
+  // of array-based submissions; use a tailored prompt that omits schema/cases.
+  if (isBioMniBenchTask(taskRun.taskDir)) {
+    const publicFiles = await collectPublicFiles(taskRun.publicDir)
+    return [
+      '<run_context>',
+      `task_id: ${taskRun.taskId}`,
+      'cwd: run root',
+      `python: ${runtime.displayPath}`,
+      `max_judge_rounds: ${maxRounds}`,
+      'submission_dir: outputs/',
+      'current_plan_file: workspace/plan.md',
+      `round_plan_file: ${roundPlanPath(1)}`,
+      '</run_context>',
+      '',
+      '<public_files>',
+      formatPublicFiles(publicFiles),
+      '</public_files>',
+      ...(priorBlock ? ['', priorBlock] : []),
+      '',
+      '<task_statement>',
+      userTask.trim() || '(No README.md content was found; inspect public/.)',
+      '</task_statement>',
+      '',
+      '<output_contract>',
+      'This is a BioMniBench data analysis task. The judge is an LLM that scores',
+      'your work against a rubric. You MUST produce exactly two files:',
+      '  - outputs/trace.md      Detailed analysis trace: code you ran, intermediate',
+      '                          results, plots described in text, reasoning.',
+      '  - outputs/answer.txt    Concise final answer to the task question.',
+      'Both files are evaluated by an LLM judge against a hidden rubric. Be specific,',
+      'show numerical results, and reference the data you actually computed.',
+      '</output_contract>',
+      '',
+      '<visible_cases>',
+      'No discrete cases. Data files are in public/data/ and public/visible_data/.',
+      'Read public/README.md for the full task description and data dictionary.',
+      '</visible_cases>',
+      '',
+      '<workflow>',
+      '1. Read public/README.md carefully for the task question, data files, and any constraints.',
+      '2. Inspect public/data/ and public/visible_data/ to understand the actual file formats.',
+      '3. Write a detailed task-specific plan to ' + roundPlanPath(1) + ' and refresh workspace/plan.md.',
+      '4. Write Python solver code under workspace/ or workspace/experiments/.',
+      '5. IMPORTANT: cwd is run root. Use public/data/ etc., NOT ../public/data/.',
+      '6. The shared Python env already has pandas, numpy, scipy, scanpy, anndata, sklearn, statsmodels, matplotlib, seaborn, openpyxl. Do NOT install packages.',
+      '7. After computing your answer, write outputs/trace.md (analysis trace) and outputs/answer.txt (final answer).',
+      '8. Call finalize_submission. The judge will score against a rubric.',
+      '</workflow>',
+    ].join('\n')
+  }
+
+  const [publicFiles, schema, cases] = await Promise.all([
+    collectPublicFiles(taskRun.publicDir),
+    readJsonIfExists<OutputSchema>(join(taskRun.publicDir, 'output_schema.json')),
+    readJsonIfExists<CasesConfig>(join(taskRun.publicDir, 'visible_data', 'cases.json')),
+  ])
+
+  return [
+    '<run_context>',
+    `task_id: ${taskRun.taskId}`,
+    'cwd: run root',
+    `python: ${runtime.displayPath}`,
+    `max_judge_rounds: ${maxRounds}`,
+    'submission_dir: outputs/',
+    'current_plan_file: workspace/plan.md',
+    `round_plan_file: ${roundPlanPath(1)}`,
+    '</run_context>',
+    '',
+    '<public_files>',
+    formatPublicFiles(publicFiles),
+    '</public_files>',
+    ...(priorBlock ? ['', priorBlock] : []),
+    '',
+    '<task_statement>',
+    userTask.trim() || '(No README.md content was found; inspect public/.)',
+    '</task_statement>',
+    '',
+    '<output_contract>',
+    buildOutputContract(schema),
+    '</output_contract>',
+    '',
+    '<visible_cases>',
+    buildVisibleCases(cases),
+    '</visible_cases>',
+    '',
+    '<workflow>',
+    '1. Use <output_contract> and <visible_cases> as the submission contract. Inspect relevant public case input files for raw keys, shapes, dtypes, finite status, and value ranges before choosing a solver; do not assume array structure.',
+    `2. Once you understand the task, write ${roundPlanPath(1)} and refresh workspace/plan.md.`,
+    '3. Write solver code under workspace/ and longer experiments under workspace/experiments/.',
+    '4. IMPORTANT: Your cwd is run root. Always use paths relative to run root. Data files are at public/workdir/, NOT ../public/workdir/. When writing code in workspace/, use public/workdir/ for data paths.',
+    '5. Use Bash for short commands or to run scripts; do not use long inline python -c programs.',
+    '6. Run a bounded set of focused experiments, then choose the best current solver.',
+    '7. Write final submission files under outputs/ and run a quick local format check against <output_contract>.',
+    '8. Call finalize_submission. The judge feedback is more valuable than private speculation.',
+    '</workflow>',
+  ].join('\n')
+}
+
+function unique(values: string[]): string[] {
+  return [...new Set(values.filter(Boolean))]
+}
+
+export function compactJudgeFeedback(judgeResult: JudgeResult): CompactJudgeFeedback {
+  const raw = judgeResult.raw as
+    | {
+        cases?: Array<{
+          reason?: unknown
+          format?: { status?: unknown }
+          metrics?: Array<{ name?: unknown; status?: unknown }>
+        }>
+      }
+    | undefined
+  const cases = raw && typeof raw === 'object' && Array.isArray(raw.cases) ? raw.cases : []
+  if (cases.length === 0) {
+    return {
+      format: 'unknown',
+      reasons: [],
+      failedMetrics: [],
+      passedMetrics: [],
+      message: judgeResult.feedback || '(no feedback)',
+    }
+  }
+
+  const formatStatuses = unique(
+    cases.map(item => String(item.format?.status ?? 'unknown')),
+  )
+  const reasons = unique(cases.map(item => String(item.reason ?? '')).filter(Boolean))
+  const metrics = cases.flatMap(item => item.metrics ?? [])
+  return {
+    format: formatStatuses.length === 1 ? formatStatuses[0] : formatStatuses.join('|'),
+    reasons,
+    failedMetrics: unique(
+      metrics
+        .filter(item => item.status === 'fail')
+        .map(item => String(item.name ?? '(unnamed_metric)')),
+    ),
+    passedMetrics: unique(
+      metrics
+        .filter(item => item.status === 'pass')
+        .map(item => String(item.name ?? '(unnamed_metric)')),
+    ),
+  }
+}
+
+function formatList(label: string, values: string[]): string[] {
+  if (values.length === 0) return [`${label}: []`]
+  return [`${label}:`, ...values.map(value => `- ${value}`)]
+}
+
+export function buildJudgeFeedbackPrompt(input: {
+  round: number
+  maxRounds: number
+  judgeResult: JudgeResult
+}): string {
+  const { round, maxRounds, judgeResult } = input
+  const nextRound = round + 1
+  const compact = compactJudgeFeedback(judgeResult)
+  return [
+    '<judge_feedback>',
+    `round: ${round}/${maxRounds}`,
+    `status: ${judgeResult.status}`,
+    `reward: ${judgeResult.reward}`,
+    `format: ${compact.format}`,
+    `reason: ${compact.reasons.join('|') || 'none'}`,
+    ...formatList('failed_metrics', compact.failedMetrics),
+    ...formatList('passed_metrics', compact.passedMetrics),
+    ...(compact.message ? [`message: ${compact.message}`] : []),
+    '</judge_feedback>',
+    '',
+    '<workflow>',
+    `Before modifying code for this feedback, understand the feedback, then write ${roundPlanPath(nextRound)} and refresh workspace/plan.md.`,
+    'Make one focused fix or a small bounded experiment set, validate again, regenerate outputs, then submit the best current output to the judge with finalize_submission.',
+    'Before finalize_submission, revalidate outputs against the same contract.',
+    'Use workspace/experiments/*.py for longer probes; do not put long Python programs in Bash python -c.',
+    '</workflow>',
+  ].join('\n')
+}
+
+export function buildNoFinalizeRecoveryPrompt(input: {
+  round: number
+  maxRounds: number
+}): string {
+  return [
+    '<no_finalize_recovery>',
+    `round: ${input.round}/${input.maxRounds}`,
+    'Your previous turn ended without finalize_submission.',
+    'Do not start new open-ended research or long experiments.',
+    'If you believe outputs/ contains valid final files, call finalize_submission now with a concise summary.',
+    'If outputs/ is missing or invalid, make only the shortest necessary format fix, then call finalize_submission.',
+    'If you cannot create a valid output, briefly explain the blocker and stop.',
+    '</no_finalize_recovery>',
+  ].join('\n')
+}

src/harness/evaluation/sourceLlmOptions.ts

@@ -0,0 +1,23 @@
+import type { ThinkingConfig } from '../../utils/thinking.js'
+import type { EvaluationLlmOptions } from './types.js'
+
+export type SourceLlmQueryOptions = {
+  thinkingConfig: ThinkingConfig
+  temperatureOverride?: number
+}
+
+export function buildSourceLlmQueryOptions(
+  options: EvaluationLlmOptions | undefined,
+): SourceLlmQueryOptions {
+  const llmOptions = options ?? { temperature: 1, thinking: 'disabled' as const }
+  if (llmOptions.thinking === 'adaptive') {
+    return {
+      thinkingConfig: { type: 'adaptive' },
+      temperatureOverride: undefined,
+    }
+  }
+  return {
+    thinkingConfig: { type: 'disabled' },
+    temperatureOverride: llmOptions.temperature,
+  }
+}

src/harness/evaluation/sourcePublicIntegrity.ts

@@ -0,0 +1,203 @@
+import { lstat, mkdir, readFile, readdir, rm, stat, writeFile } from 'fs/promises'
+import { dirname, join, relative, resolve } from 'path'
+
+export type PublicSnapshotEntry = {
+  entry_type: 'file' | 'dir'
+  size: number
+  mtimeMs: number
+  content?: Buffer
+}
+
+export type PublicSnapshot = Map<string, PublicSnapshotEntry>
+
+export type PublicSnapshotOptions = {
+  includeFileContents?: boolean
+  contentPathFilter?: (relativePath: string) => boolean
+}
+
+export type PublicMutation = {
+  type: 'created' | 'modified' | 'deleted'
+  path: string
+  entry_type: 'file' | 'dir'
+}
+
+export type PublicRestoreResult = {
+  removedCreatedPaths: string[]
+  restoredPaths: string[]
+  unrestoredPaths: string[]
+}
+
+function toPublicRelative(root: string, path: string): string {
+  return relative(root, path).replace(/\\/g, '/')
+}
+
+async function walkPublic(
+  root: string,
+  current: string,
+  snapshot: PublicSnapshot,
+  options: PublicSnapshotOptions,
+): Promise<void> {
+  const entries = await readdir(current, { withFileTypes: true })
+  for (const entry of entries) {
+    const fullPath = join(current, entry.name)
+    const linkMetadata = await lstat(fullPath)
+    const isSymlink = linkMetadata.isSymbolicLink()
+    let metadata = linkMetadata
+    if (isSymlink) {
+      try {
+        metadata = await stat(fullPath)
+      } catch {
+        metadata = linkMetadata
+      }
+    }
+    const isDirectory = metadata.isDirectory()
+    const relativePath = toPublicRelative(root, fullPath)
+    const snapshotEntry: PublicSnapshotEntry = {
+      entry_type: isDirectory ? 'dir' : 'file',
+      size: linkMetadata.size,
+      mtimeMs: linkMetadata.mtimeMs,
+    }
+    if (
+      !isDirectory &&
+      !isSymlink &&
+      options.includeFileContents &&
+      (!options.contentPathFilter || options.contentPathFilter(relativePath))
+    ) {
+      snapshotEntry.content = await readFile(fullPath)
+    }
+    snapshot.set(relativePath, snapshotEntry)
+    if (isDirectory && !isSymlink) {
+      await walkPublic(root, fullPath, snapshot, options)
+    }
+  }
+}
+
+export async function takePublicSnapshot(
+  publicDir: string,
+  options: PublicSnapshotOptions = {},
+): Promise<PublicSnapshot> {
+  const snapshot: PublicSnapshot = new Map()
+  await walkPublic(publicDir, publicDir, snapshot, options)
+  return snapshot
+}
+
+export function diffPublicSnapshots(
+  before: PublicSnapshot,
+  after: PublicSnapshot,
+  limit = 50,
+): PublicMutation[] {
+  const mutations: PublicMutation[] = []
+
+  for (const [path, afterEntry] of after.entries()) {
+    const beforeEntry = before.get(path)
+    if (!beforeEntry) {
+      mutations.push({
+        type: 'created',
+        path,
+        entry_type: afterEntry.entry_type,
+      })
+    } else if (
+      beforeEntry.entry_type !== afterEntry.entry_type ||
+      beforeEntry.size !== afterEntry.size ||
+      beforeEntry.mtimeMs !== afterEntry.mtimeMs ||
+      (beforeEntry.content !== undefined &&
+        afterEntry.content !== undefined &&
+        !beforeEntry.content.equals(afterEntry.content))
+    ) {
+      mutations.push({
+        type: 'modified',
+        path,
+        entry_type: afterEntry.entry_type,
+      })
+    }
+    if (mutations.length >= limit) return mutations
+  }
+
+  for (const [path, beforeEntry] of before.entries()) {
+    if (!after.has(path)) {
+      mutations.push({
+        type: 'deleted',
+        path,
+        entry_type: beforeEntry.entry_type,
+      })
+    }
+    if (mutations.length >= limit) return mutations
+  }
+
+  return mutations
+}
+
+function isInside(path: string, parent: string): boolean {
+  const resolvedChild = resolve(path)
+  const resolvedBase = resolve(parent)
+  const child = process.platform === 'win32' ? resolvedChild.toLowerCase() : resolvedChild
+  const base = process.platform === 'win32' ? resolvedBase.toLowerCase() : resolvedBase
+  return child === base || child.startsWith(`${base}\\`) || child.startsWith(`${base}/`)
+}
+
+export async function cleanupCreatedPublicEntries(
+  publicDir: string,
+  mutations: PublicMutation[],
+): Promise<string[]> {
+  const created = mutations
+    .filter(mutation => mutation.type === 'created')
+    .map(mutation => mutation.path)
+    .sort((a, b) => b.length - a.length)
+  const removed: string[] = []
+
+  for (const relativePath of created) {
+    const target = resolve(publicDir, relativePath)
+    if (!isInside(target, publicDir) || target === resolve(publicDir)) continue
+    await rm(target, { recursive: true, force: true })
+    removed.push(relativePath)
+  }
+
+  return removed
+}
+
+export async function restorePublicSnapshotMutations(
+  publicDir: string,
+  before: PublicSnapshot,
+  mutations: PublicMutation[],
+): Promise<PublicRestoreResult> {
+  const result: PublicRestoreResult = {
+    removedCreatedPaths: [],
+    restoredPaths: [],
+    unrestoredPaths: [],
+  }
+
+  result.removedCreatedPaths = await cleanupCreatedPublicEntries(publicDir, mutations)
+
+  const deletedDirs = mutations
+    .filter(mutation => mutation.type === 'deleted')
+    .filter(mutation => before.get(mutation.path)?.entry_type === 'dir')
+    .map(mutation => mutation.path)
+    .sort((a, b) => a.length - b.length)
+
+  for (const relativePath of deletedDirs) {
+    const target = resolve(publicDir, relativePath)
+    if (!isInside(target, publicDir) || target === resolve(publicDir)) continue
+    await mkdir(target, { recursive: true })
+    result.restoredPaths.push(relativePath)
+  }
+
+  const filesToRestore = mutations
+    .filter(mutation => mutation.type === 'modified' || mutation.type === 'deleted')
+    .filter(mutation => before.get(mutation.path)?.entry_type === 'file')
+    .map(mutation => mutation.path)
+    .sort((a, b) => a.length - b.length)
+
+  for (const relativePath of filesToRestore) {
+    const beforeEntry = before.get(relativePath)
+    const target = resolve(publicDir, relativePath)
+    if (!beforeEntry?.content || !isInside(target, publicDir)) {
+      result.unrestoredPaths.push(relativePath)
+      continue
+    }
+    await mkdir(dirname(target), { recursive: true })
+    await writeFile(target, beforeEntry.content)
+    result.restoredPaths.push(relativePath)
+  }
+
+  return result
+}

src/harness/evaluation/taskEnvironment.ts

@@ -0,0 +1,202 @@
+import { existsSync } from 'fs'
+import { cp, mkdir, readFile, symlink, writeFile } from 'fs/promises'
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'path'
+import type { TaskManifest, TaskRun } from './types.js'
+import { isBioMniBenchTask, loadBioMniBenchManifest } from './biomnibenchAdapter.js'
+
+export type CreateTaskRunInput = {
+  taskId: string
+  tasksDir?: string
+  runsDir?: string
+  timestamp?: string
+}
+
+function makeTimestamp(date = new Date()): string {
+  const pad = (value: number) => String(value).padStart(2, '0')
+  return [
+    date.getFullYear(),
+    pad(date.getMonth() + 1),
+    pad(date.getDate()),
+    '_',
+    pad(date.getHours()),
+    pad(date.getMinutes()),
+    pad(date.getSeconds()),
+  ].join('')
+}
+
+function isPathInside(child: string, parent: string): boolean {
+  const normalizedChild = resolve(child)
+  const normalizedParent = resolve(parent)
+  const comparisonChild =
+    process.platform === 'win32' ? normalizedChild.toLowerCase() : normalizedChild
+  const comparisonParent =
+    process.platform === 'win32' ? normalizedParent.toLowerCase() : normalizedParent
+  return (
+    comparisonChild === comparisonParent ||
+    comparisonChild.startsWith(`${comparisonParent}\\`) ||
+    comparisonChild.startsWith(`${comparisonParent}/`)
+  )
+}
+
+function assertRelativeBundlePath(path: string): string {
+  const normalized = path.replace(/\\/g, '/').replace(/\/+$/, '')
+  if (!normalized || isAbsolute(normalized) || normalized.split('/').includes('..')) {
+    throw new Error(`Unsafe task bundle path: ${path}`)
+  }
+  return normalized
+}
+
+function resolveInside(base: string, relativePath: string): string {
+  const target = resolve(base, relativePath)
+  if (!isPathInside(target, base)) {
+    throw new Error(`Unsafe task bundle path escapes root: ${relativePath}`)
+  }
+  return target
+}
+
+function isPrivatePath(path: string): boolean {
+  const first = path.replace(/\\/g, '/').split('/')[0]
+  return first === 'evaluation' || first === 'std_code'
+}
+
+async function readTaskManifest(taskDir: string): Promise<TaskManifest> {
+  const raw = await readFile(join(taskDir, 'task_manifest.json'), 'utf8')
+  return JSON.parse(stripUtf8Bom(raw)) as TaskManifest
+}
+
+async function loadTaskManifestForTask(taskDir: string, taskId: string): Promise<TaskManifest> {
+  // BioMniBench tasks have a minimal on-disk manifest; synthesise/merge fields.
+  if (isBioMniBenchTask(taskDir)) {
+    return loadBioMniBenchManifest(taskDir, taskId)
+  }
+  return readTaskManifest(taskDir)
+}
+
+function stripUtf8Bom(value: string): string {
+  return value.charCodeAt(0) === 0xfeff ? value.slice(1) : value
+}
+
+function uniquePublicBundleEntries(manifest: TaskManifest): string[] {
+  const entries = new Set<string>()
+  for (const entry of manifest.public_bundle ?? []) {
+    entries.add(assertRelativeBundlePath(entry))
+  }
+
+  // Some task manifests expose envs/runtime/ but put env_manifest.json in the
+  // environment entrypoint. The manifest is public and is needed to resolve
+  // cross-platform Python paths, so include it explicitly.
+  if (manifest.entrypoints?.environment) {
+    entries.add(assertRelativeBundlePath(manifest.entrypoints.environment))
+  }
+
+  return [...entries].filter(entry => !isPrivatePath(entry))
+}
+
+async function copyPublicEntry(taskDir: string, publicDir: string, entry: string): Promise<void> {
+  const source = resolveInside(taskDir, entry)
+  const destination = resolveInside(publicDir, entry)
+  if (!existsSync(source)) return
+
+  await mkdir(dirname(destination), { recursive: true })
+  await cp(source, destination, {
+    recursive: true,
+    force: true,
+    errorOnExist: false,
+    filter: sourcePath => shouldCopyForCurrentHost(sourcePath),
+  })
+}
+
+function isVirtualEnvPath(sourcePath: string): boolean {
+  const segments = sourcePath.replace(/\\/g, '/').split('/')
+  return segments.includes('.venv') || segments.includes('.venv-posix')
+}
+
+function shouldCopyForCurrentHost(sourcePath: string): boolean {
+  return !isVirtualEnvPath(sourcePath)
+}
+
+async function linkDirectory(source: string, destination: string): Promise<void> {
+  if (existsSync(destination)) return
+  await mkdir(dirname(destination), { recursive: true })
+  await symlink(source, destination, process.platform === 'win32' ? 'junction' : 'dir')
+}
+
+async function linkHostRuntime(taskDir: string, publicDir: string): Promise<void> {
+  const runtimeRoot = join('envs', 'runtime')
+  const candidates =
+    process.platform === 'win32' ? ['.venv'] : ['.venv-posix', '.venv']
+
+  for (const candidate of candidates) {
+    const source = resolveInside(taskDir, join(runtimeRoot, candidate))
+    if (!existsSync(source)) continue
+    const destination = resolveInside(publicDir, join(runtimeRoot, candidate))
+    await linkDirectory(source, destination)
+    return
+  }
+}
+
+export async function createTaskRun(input: CreateTaskRunInput): Promise<TaskRun> {
+  const tasksDir = resolve(input.tasksDir ?? 'tasks')
+  const runsDir = resolve(input.runsDir ?? 'runs')
+  const taskDir = resolveInside(tasksDir, input.taskId)
+  const manifest = await loadTaskManifestForTask(taskDir, input.taskId)
+  if (manifest.task_id !== input.taskId) {
+    throw new Error(
+      `Task manifest id mismatch: expected ${input.taskId}, got ${manifest.task_id}`,
+    )
+  }
+
+  const timestamp = input.timestamp ?? makeTimestamp()
+  const runId = `${input.taskId}_${timestamp}`
+  const runDir = join(runsDir, runId)
+  const judgeDir = join(runsDir, '.judge_private', runId)
+  const publicDir = join(runDir, 'public')
+  const workspaceDir = join(runDir, 'workspace')
+  const outputsDir = join(runDir, manifest.submission?.output_dir ?? 'outputs')
+  const logsDir = join(runDir, 'logs')
+
+  await mkdir(publicDir, { recursive: true })
+  await mkdir(workspaceDir, { recursive: true })
+  await mkdir(join(workspaceDir, 'plans'), { recursive: true })
+  await mkdir(join(workspaceDir, 'experiments'), { recursive: true })
+  await mkdir(outputsDir, { recursive: true })
+  await mkdir(logsDir, { recursive: true })
+  await mkdir(join(logsDir, 'agent'), { recursive: true })
+  await mkdir(judgeDir, { recursive: true })
+
+  for (const entry of uniquePublicBundleEntries(manifest)) {
+    await copyPublicEntry(taskDir, publicDir, entry)
+  }
+  await linkHostRuntime(taskDir, publicDir)
+
+  const runManifest = {
+    version: 1,
+    task_id: input.taskId,
+    run_id: runId,
+    source_task_dir: taskDir,
+    public_dir: relative(runDir, publicDir),
+    workspace_dir: basename(workspaceDir),
+    outputs_dir: relative(runDir, outputsDir),
+    logs_dir: basename(logsDir),
+    created_at: new Date().toISOString(),
+  }
+
+  await writeFile(
+    join(runDir, 'run_manifest.json'),
+    `${JSON.stringify(runManifest, null, 2)}\n`,
+    'utf8',
+  )
+
+  return {
+    taskId: input.taskId,
+    runId,
+    runDir,
+    judgeDir,
+    publicDir,
+    workspaceDir,
+    outputsDir,
+    logsDir,
+    taskDir,
+    manifest,
+  }
+}

src/hooks/notifs/useAutoModeUnavailableNotification.ts

@@ -0,0 +1,56 @@
+import { feature } from 'bun:bundle'
+import { useEffect, useRef } from 'react'
+import { useNotifications } from 'src/context/notifications.js'
+import { getIsRemoteMode } from '../../bootstrap/state.js'
+import { useAppState } from '../../state/AppState.js'
+import type { PermissionMode } from '../../utils/permissions/PermissionMode.js'
+import {
+  getAutoModeUnavailableNotification,
+  getAutoModeUnavailableReason,
+} from '../../utils/permissions/permissionSetup.js'
+import { hasAutoModeOptIn } from '../../utils/settings/settings.js'
+
+/**
+ * Shows a one-shot notification when the shift-tab carousel wraps past where
+ * auto mode would have been. Covers all reasons (settings, circuit-breaker,
+ * org-allowlist). The startup case (defaultMode: auto silently downgraded) is
+ * handled by verifyAutoModeGateAccess → checkAndDisableAutoModeIfNeeded.
+ */
+export function useAutoModeUnavailableNotification(): void {
+  const { addNotification } = useNotifications()
+  const mode = useAppState(s => s.toolPermissionContext.mode)
+  const isAutoModeAvailable = useAppState(
+    s => s.toolPermissionContext.isAutoModeAvailable,
+  )
+  const shownRef = useRef(false)
+  const prevModeRef = useRef<PermissionMode>(mode)
+
+  useEffect(() => {
+    const prevMode = prevModeRef.current
+    prevModeRef.current = mode
+
+    if (!feature('TRANSCRIPT_CLASSIFIER')) return
+    if (getIsRemoteMode()) return
+    if (shownRef.current) return
+
+    const wrappedPastAutoSlot =
+      mode === 'default' &&
+      prevMode !== 'default' &&
+      prevMode !== 'auto' &&
+      !isAutoModeAvailable &&
+      hasAutoModeOptIn()
+
+    if (!wrappedPastAutoSlot) return
+
+    const reason = getAutoModeUnavailableReason()
+    if (!reason) return
+
+    shownRef.current = true
+    addNotification({
+      key: 'auto-mode-unavailable',
+      text: getAutoModeUnavailableNotification(reason),
+      color: 'warning',
+      priority: 'medium',
+    })
+  }, [mode, isAutoModeAvailable, addNotification])
+}

src/hooks/notifs/useFastModeNotification.tsx

@@ -0,0 +1,162 @@
+import { c as _c } from "react/compiler-runtime";
+import { useEffect } from 'react';
+import { useNotifications } from 'src/context/notifications.js';
+import { useAppState, useSetAppState } from 'src/state/AppState.js';
+import { type CooldownReason, isFastModeEnabled, onCooldownExpired, onCooldownTriggered, onFastModeOverageRejection, onOrgFastModeChanged } from 'src/utils/fastMode.js';
+import { formatDuration } from 'src/utils/format.js';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+const COOLDOWN_STARTED_KEY = 'fast-mode-cooldown-started';
+const COOLDOWN_EXPIRED_KEY = 'fast-mode-cooldown-expired';
+const ORG_CHANGED_KEY = 'fast-mode-org-changed';
+const OVERAGE_REJECTED_KEY = 'fast-mode-overage-rejected';
+export function useFastModeNotification() {
+  const $ = _c(13);
+  const {
+    addNotification
+  } = useNotifications();
+  const isFastMode = useAppState(_temp);
+  const setAppState = useSetAppState();
+  let t0;
+  let t1;
+  if ($[0] !== addNotification || $[1] !== isFastMode || $[2] !== setAppState) {
+    t0 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (!isFastModeEnabled()) {
+        return;
+      }
+      return onOrgFastModeChanged(orgEnabled => {
+        if (orgEnabled) {
+          addNotification({
+            key: ORG_CHANGED_KEY,
+            color: "fastMode",
+            priority: "immediate",
+            text: "Fast mode is now available \xB7 /fast to turn on"
+          });
+        } else {
+          if (isFastMode) {
+            setAppState(_temp2);
+            addNotification({
+              key: ORG_CHANGED_KEY,
+              color: "warning",
+              priority: "immediate",
+              text: "Fast mode has been disabled by your organization"
+            });
+          }
+        }
+      });
+    };
+    t1 = [addNotification, isFastMode, setAppState];
+    $[0] = addNotification;
+    $[1] = isFastMode;
+    $[2] = setAppState;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t0 = $[3];
+    t1 = $[4];
+  }
+  useEffect(t0, t1);
+  let t2;
+  let t3;
+  if ($[5] !== addNotification || $[6] !== setAppState) {
+    t2 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (!isFastModeEnabled()) {
+        return;
+      }
+      return onFastModeOverageRejection(message => {
+        setAppState(_temp3);
+        addNotification({
+          key: OVERAGE_REJECTED_KEY,
+          color: "warning",
+          priority: "immediate",
+          text: message
+        });
+      });
+    };
+    t3 = [addNotification, setAppState];
+    $[5] = addNotification;
+    $[6] = setAppState;
+    $[7] = t2;
+    $[8] = t3;
+  } else {
+    t2 = $[7];
+    t3 = $[8];
+  }
+  useEffect(t2, t3);
+  let t4;
+  let t5;
+  if ($[9] !== addNotification || $[10] !== isFastMode) {
+    t4 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (!isFastMode) {
+        return;
+      }
+      const unsubTriggered = onCooldownTriggered((resetAt, reason) => {
+        const resetIn = formatDuration(resetAt - Date.now(), {
+          hideTrailingZeros: true
+        });
+        const message_0 = getCooldownMessage(reason, resetIn);
+        addNotification({
+          key: COOLDOWN_STARTED_KEY,
+          invalidates: [COOLDOWN_EXPIRED_KEY],
+          text: message_0,
+          color: "warning",
+          priority: "immediate"
+        });
+      });
+      const unsubExpired = onCooldownExpired(() => {
+        addNotification({
+          key: COOLDOWN_EXPIRED_KEY,
+          invalidates: [COOLDOWN_STARTED_KEY],
+          color: "fastMode",
+          text: "Fast limit reset \xB7 now using fast mode",
+          priority: "immediate"
+        });
+      });
+      return () => {
+        unsubTriggered();
+        unsubExpired();
+      };
+    };
+    t5 = [addNotification, isFastMode];
+    $[9] = addNotification;
+    $[10] = isFastMode;
+    $[11] = t4;
+    $[12] = t5;
+  } else {
+    t4 = $[11];
+    t5 = $[12];
+  }
+  useEffect(t4, t5);
+}
+function _temp3(prev_0) {
+  return {
+    ...prev_0,
+    fastMode: false
+  };
+}
+function _temp2(prev) {
+  return {
+    ...prev,
+    fastMode: false
+  };
+}
+function _temp(s) {
+  return s.fastMode;
+}
+function getCooldownMessage(reason: CooldownReason, resetIn: string): string {
+  switch (reason) {
+    case 'overloaded':
+      return `Fast mode overloaded and is temporarily unavailable · resets in ${resetIn}`;
+    case 'rate_limit':
+      return `Fast limit reached and temporarily disabled · resets in ${resetIn}`;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useEffect","useNotifications","useAppState","useSetAppState","CooldownReason","isFastModeEnabled","onCooldownExpired","onCooldownTriggered","onFastModeOverageRejection","onOrgFastModeChanged","formatDuration","getIsRemoteMode","COOLDOWN_STARTED_KEY","COOLDOWN_EXPIRED_KEY","ORG_CHANGED_KEY","OVERAGE_REJECTED_KEY","useFastModeNotification","$","_c","addNotification","isFastMode","_temp","setAppState","t0","t1","orgEnabled","key","color","priority","text","_temp2","t2","t3","message","_temp3","t4","t5","unsubTriggered","resetAt","reason","resetIn","Date","now","hideTrailingZeros","message_0","getCooldownMessage","invalidates","unsubExpired","prev_0","prev","fastMode","s"],"sources":["useFastModeNotification.tsx"],"sourcesContent":["import { useEffect } from 'react'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { useAppState, useSetAppState } from 'src/state/AppState.js'\nimport {\n  type CooldownReason,\n  isFastModeEnabled,\n  onCooldownExpired,\n  onCooldownTriggered,\n  onFastModeOverageRejection,\n  onOrgFastModeChanged,\n} from 'src/utils/fastMode.js'\nimport { formatDuration } from 'src/utils/format.js'\nimport { getIsRemoteMode } from '../../bootstrap/state.js'\n\nconst COOLDOWN_STARTED_KEY = 'fast-mode-cooldown-started'\nconst COOLDOWN_EXPIRED_KEY = 'fast-mode-cooldown-expired'\nconst ORG_CHANGED_KEY = 'fast-mode-org-changed'\nconst OVERAGE_REJECTED_KEY = 'fast-mode-overage-rejected'\n\nexport function useFastModeNotification(): void {\n  const { addNotification } = useNotifications()\n  const isFastMode = useAppState(s => s.fastMode)\n  const setAppState = useSetAppState()\n\n  // Notify when org fast mode status changes\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (!isFastModeEnabled()) {\n      return\n    }\n\n    return onOrgFastModeChanged(orgEnabled => {\n      if (orgEnabled) {\n        addNotification({\n          key: ORG_CHANGED_KEY,\n          color: 'fastMode',\n          priority: 'immediate',\n          text: 'Fast mode is now available · /fast to turn on',\n        })\n      } else if (isFastMode) {\n        // Org disabled fast mode — permanently turn off fast mode\n        setAppState(prev => ({ ...prev, fastMode: false }))\n        addNotification({\n          key: ORG_CHANGED_KEY,\n          color: 'warning',\n          priority: 'immediate',\n          text: 'Fast mode has been disabled by your organization',\n        })\n      }\n    })\n  }, [addNotification, isFastMode, setAppState])\n\n  // Notify when fast mode is rejected due to overage/extra usage issues\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (!isFastModeEnabled()) return\n\n    return onFastModeOverageRejection(message => {\n      setAppState(prev => ({ ...prev, fastMode: false }))\n      addNotification({\n        key: OVERAGE_REJECTED_KEY,\n        color: 'warning',\n        priority: 'immediate',\n        text: message,\n      })\n    })\n  }, [addNotification, setAppState])\n\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (!isFastMode) {\n      return\n    }\n\n    const unsubTriggered = onCooldownTriggered((resetAt, reason) => {\n      const resetIn = formatDuration(resetAt - Date.now(), {\n        hideTrailingZeros: true,\n      })\n      const message = getCooldownMessage(reason, resetIn)\n      addNotification({\n        key: COOLDOWN_STARTED_KEY,\n        invalidates: [COOLDOWN_EXPIRED_KEY],\n        text: message,\n        color: 'warning',\n        priority: 'immediate',\n      })\n    })\n    const unsubExpired = onCooldownExpired(() => {\n      addNotification({\n        key: COOLDOWN_EXPIRED_KEY,\n        invalidates: [COOLDOWN_STARTED_KEY],\n        color: 'fastMode',\n        text: `Fast limit reset · now using fast mode`,\n        priority: 'immediate',\n      })\n    })\n    return () => {\n      unsubTriggered()\n      unsubExpired()\n    }\n  }, [addNotification, isFastMode])\n}\n\nfunction getCooldownMessage(reason: CooldownReason, resetIn: string): string {\n  switch (reason) {\n    case 'overloaded':\n      return `Fast mode overloaded and is temporarily unavailable · resets in ${resetIn}`\n    case 'rate_limit':\n      return `Fast limit reached and temporarily disabled · resets in ${resetIn}`\n  }\n}\n"],"mappings":"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","ignoreList":[]}

src/hooks/notifs/useIDEStatusIndicator.tsx

@@ -0,0 +1,186 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useEffect, useRef } from 'react';
+import { useNotifications } from 'src/context/notifications.js';
+import { Text } from 'src/ink.js';
+import type { MCPServerConnection } from 'src/services/mcp/types.js';
+import { getGlobalConfig, saveGlobalConfig } from 'src/utils/config.js';
+import { detectIDEs, type IDEExtensionInstallationStatus, isJetBrainsIde, isSupportedTerminal } from 'src/utils/ide.js';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+import { useIdeConnectionStatus } from '../useIdeConnectionStatus.js';
+import type { IDESelection } from '../useIdeSelection.js';
+const MAX_IDE_HINT_SHOW_COUNT = 5;
+type Props = {
+  ideInstallationStatus: IDEExtensionInstallationStatus | null;
+  ideSelection: IDESelection | undefined;
+  mcpClients: MCPServerConnection[];
+};
+export function useIDEStatusIndicator(t0) {
+  const $ = _c(26);
+  const {
+    ideSelection,
+    mcpClients,
+    ideInstallationStatus
+  } = t0;
+  const {
+    addNotification,
+    removeNotification
+  } = useNotifications();
+  const {
+    status: ideStatus,
+    ideName
+  } = useIdeConnectionStatus(mcpClients);
+  const hasShownHintRef = useRef(false);
+  let t1;
+  if ($[0] !== ideInstallationStatus) {
+    t1 = ideInstallationStatus ? isJetBrainsIde(ideInstallationStatus?.ideType) : false;
+    $[0] = ideInstallationStatus;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const isJetBrains = t1;
+  const showIDEInstallErrorOrJetBrainsInfo = ideInstallationStatus?.error || isJetBrains;
+  const shouldShowIdeSelection = ideStatus === "connected" && (ideSelection?.filePath || ideSelection?.text && ideSelection.lineCount > 0);
+  const shouldShowConnected = ideStatus === "connected" && !shouldShowIdeSelection;
+  const showIDEInstallError = showIDEInstallErrorOrJetBrainsInfo && !isJetBrains && !shouldShowConnected && !shouldShowIdeSelection;
+  const showJetBrainsInfo = showIDEInstallErrorOrJetBrainsInfo && isJetBrains && !shouldShowConnected && !shouldShowIdeSelection;
+  let t2;
+  let t3;
+  if ($[2] !== addNotification || $[3] !== ideStatus || $[4] !== removeNotification || $[5] !== showJetBrainsInfo) {
+    t2 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (isSupportedTerminal() || ideStatus !== null || showJetBrainsInfo) {
+        removeNotification("ide-status-hint");
+        return;
+      }
+      if (hasShownHintRef.current || (getGlobalConfig().ideHintShownCount ?? 0) >= MAX_IDE_HINT_SHOW_COUNT) {
+        return;
+      }
+      const timeoutId = setTimeout(_temp2, 3000, hasShownHintRef, addNotification);
+      return () => clearTimeout(timeoutId);
+    };
+    t3 = [addNotification, removeNotification, ideStatus, showJetBrainsInfo];
+    $[2] = addNotification;
+    $[3] = ideStatus;
+    $[4] = removeNotification;
+    $[5] = showJetBrainsInfo;
+    $[6] = t2;
+    $[7] = t3;
+  } else {
+    t2 = $[6];
+    t3 = $[7];
+  }
+  useEffect(t2, t3);
+  let t4;
+  let t5;
+  if ($[8] !== addNotification || $[9] !== ideName || $[10] !== ideStatus || $[11] !== removeNotification || $[12] !== showIDEInstallError || $[13] !== showJetBrainsInfo) {
+    t4 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (showIDEInstallError || showJetBrainsInfo || ideStatus !== "disconnected" || !ideName) {
+        removeNotification("ide-status-disconnected");
+        return;
+      }
+      addNotification({
+        key: "ide-status-disconnected",
+        text: `${ideName} disconnected`,
+        color: "error",
+        priority: "medium"
+      });
+    };
+    t5 = [addNotification, removeNotification, ideStatus, ideName, showIDEInstallError, showJetBrainsInfo];
+    $[8] = addNotification;
+    $[9] = ideName;
+    $[10] = ideStatus;
+    $[11] = removeNotification;
+    $[12] = showIDEInstallError;
+    $[13] = showJetBrainsInfo;
+    $[14] = t4;
+    $[15] = t5;
+  } else {
+    t4 = $[14];
+    t5 = $[15];
+  }
+  useEffect(t4, t5);
+  let t6;
+  let t7;
+  if ($[16] !== addNotification || $[17] !== removeNotification || $[18] !== showJetBrainsInfo) {
+    t6 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (!showJetBrainsInfo) {
+        removeNotification("ide-status-jetbrains-disconnected");
+        return;
+      }
+      addNotification({
+        key: "ide-status-jetbrains-disconnected",
+        text: "IDE plugin not connected \xB7 /status for info",
+        priority: "medium"
+      });
+    };
+    t7 = [addNotification, removeNotification, showJetBrainsInfo];
+    $[16] = addNotification;
+    $[17] = removeNotification;
+    $[18] = showJetBrainsInfo;
+    $[19] = t6;
+    $[20] = t7;
+  } else {
+    t6 = $[19];
+    t7 = $[20];
+  }
+  useEffect(t6, t7);
+  let t8;
+  let t9;
+  if ($[21] !== addNotification || $[22] !== removeNotification || $[23] !== showIDEInstallError) {
+    t8 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (!showIDEInstallError) {
+        removeNotification("ide-status-install-error");
+        return;
+      }
+      addNotification({
+        key: "ide-status-install-error",
+        text: "IDE extension install failed (see /status for info)",
+        color: "error",
+        priority: "medium"
+      });
+    };
+    t9 = [addNotification, removeNotification, showIDEInstallError];
+    $[21] = addNotification;
+    $[22] = removeNotification;
+    $[23] = showIDEInstallError;
+    $[24] = t8;
+    $[25] = t9;
+  } else {
+    t8 = $[24];
+    t9 = $[25];
+  }
+  useEffect(t8, t9);
+}
+function _temp2(hasShownHintRef_0, addNotification_0) {
+  detectIDEs(true).then(infos => {
+    const ideName_0 = infos[0]?.name;
+    if (ideName_0 && !hasShownHintRef_0.current) {
+      hasShownHintRef_0.current = true;
+      saveGlobalConfig(_temp);
+      addNotification_0({
+        key: "ide-status-hint",
+        jsx: <Text dimColor={true}>/ide for <Text color="ide">{ideName_0}</Text></Text>,
+        priority: "low"
+      });
+    }
+  });
+}
+function _temp(current) {
+  return {
+    ...current,
+    ideHintShownCount: (current.ideHintShownCount ?? 0) + 1
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useRef","useNotifications","Text","MCPServerConnection","getGlobalConfig","saveGlobalConfig","detectIDEs","IDEExtensionInstallationStatus","isJetBrainsIde","isSupportedTerminal","getIsRemoteMode","useIdeConnectionStatus","IDESelection","MAX_IDE_HINT_SHOW_COUNT","Props","ideInstallationStatus","ideSelection","mcpClients","useIDEStatusIndicator","t0","$","_c","addNotification","removeNotification","status","ideStatus","ideName","hasShownHintRef","t1","ideType","isJetBrains","showIDEInstallErrorOrJetBrainsInfo","error","shouldShowIdeSelection","filePath","text","lineCount","shouldShowConnected","showIDEInstallError","showJetBrainsInfo","t2","t3","current","ideHintShownCount","timeoutId","setTimeout","_temp2","clearTimeout","t4","t5","key","color","priority","t6","t7","t8","t9","hasShownHintRef_0","addNotification_0","then","infos","ideName_0","name","_temp","jsx"],"sources":["useIDEStatusIndicator.tsx"],"sourcesContent":["import React, { useEffect, useRef } from 'react'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { Text } from 'src/ink.js'\nimport type { MCPServerConnection } from 'src/services/mcp/types.js'\nimport { getGlobalConfig, saveGlobalConfig } from 'src/utils/config.js'\nimport {\n  detectIDEs,\n  type IDEExtensionInstallationStatus,\n  isJetBrainsIde,\n  isSupportedTerminal,\n} from 'src/utils/ide.js'\nimport { getIsRemoteMode } from '../../bootstrap/state.js'\nimport { useIdeConnectionStatus } from '../useIdeConnectionStatus.js'\nimport type { IDESelection } from '../useIdeSelection.js'\n\nconst MAX_IDE_HINT_SHOW_COUNT = 5\n\ntype Props = {\n  ideInstallationStatus: IDEExtensionInstallationStatus | null\n  ideSelection: IDESelection | undefined\n  mcpClients: MCPServerConnection[]\n}\n\nexport function useIDEStatusIndicator({\n  ideSelection,\n  mcpClients,\n  ideInstallationStatus,\n}: Props): void {\n  const { addNotification, removeNotification } = useNotifications()\n  const { status: ideStatus, ideName } = useIdeConnectionStatus(mcpClients)\n  const hasShownHintRef = useRef(false)\n\n  const isJetBrains = ideInstallationStatus\n    ? isJetBrainsIde(ideInstallationStatus?.ideType)\n    : false\n  const showIDEInstallErrorOrJetBrainsInfo =\n    ideInstallationStatus?.error || isJetBrains\n\n  const shouldShowIdeSelection =\n    ideStatus === 'connected' &&\n    (ideSelection?.filePath ||\n      (ideSelection?.text && ideSelection.lineCount > 0))\n\n  // Only show the connected if not showing context\n  const shouldShowConnected =\n    ideStatus === 'connected' && !shouldShowIdeSelection\n\n  const showIDEInstallError =\n    showIDEInstallErrorOrJetBrainsInfo &&\n    !isJetBrains &&\n    !shouldShowConnected &&\n    !shouldShowIdeSelection\n\n  const showJetBrainsInfo =\n    showIDEInstallErrorOrJetBrainsInfo &&\n    isJetBrains &&\n    !shouldShowConnected &&\n    !shouldShowIdeSelection\n\n  // Show the /ide command hint if running from an external terminal and found running IDE(s)\n  // Delay showing hint to avoid brief flash during auto-connect startup\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (isSupportedTerminal() || ideStatus !== null || showJetBrainsInfo) {\n      removeNotification('ide-status-hint')\n      return\n    }\n    // Wait a bit to let auto-connect happen first, avoiding brief hint flash\n    if (\n      hasShownHintRef.current ||\n      (getGlobalConfig().ideHintShownCount ?? 0) >= MAX_IDE_HINT_SHOW_COUNT\n    ) {\n      return\n    }\n    const timeoutId = setTimeout(\n      (hasShownHintRef, addNotification) => {\n        void detectIDEs(true).then(infos => {\n          const ideName = infos[0]?.name\n          if (ideName && !hasShownHintRef.current) {\n            hasShownHintRef.current = true\n            saveGlobalConfig(current => ({\n              ...current,\n              ideHintShownCount: (current.ideHintShownCount ?? 0) + 1,\n            }))\n            addNotification({\n              key: 'ide-status-hint',\n              jsx: (\n                <Text dimColor>\n                  /ide for <Text color=\"ide\">{ideName}</Text>\n                </Text>\n              ),\n              priority: 'low',\n            })\n          }\n        })\n      },\n      3000,\n      hasShownHintRef,\n      addNotification,\n    )\n    return () => clearTimeout(timeoutId)\n  }, [addNotification, removeNotification, ideStatus, showJetBrainsInfo])\n\n  // Show IDE disconnected/failed notification when status is disconnected\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (\n      showIDEInstallError ||\n      showJetBrainsInfo ||\n      ideStatus !== 'disconnected' ||\n      !ideName\n    ) {\n      removeNotification('ide-status-disconnected')\n      return\n    }\n    addNotification({\n      key: 'ide-status-disconnected',\n      text: `${ideName} disconnected`,\n      color: 'error',\n      priority: 'medium',\n    })\n  }, [\n    addNotification,\n    removeNotification,\n    ideStatus,\n    ideName,\n    showIDEInstallError,\n    showJetBrainsInfo,\n  ])\n\n  // Show JetBrains plugin not connected hint\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (!showJetBrainsInfo) {\n      removeNotification('ide-status-jetbrains-disconnected')\n      return\n    }\n    addNotification({\n      key: 'ide-status-jetbrains-disconnected',\n      text: 'IDE plugin not connected · /status for info',\n      priority: 'medium',\n    })\n  }, [addNotification, removeNotification, showJetBrainsInfo])\n\n  // Show IDE install error\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (!showIDEInstallError) {\n      removeNotification('ide-status-install-error')\n      return\n    }\n    addNotification({\n      key: 'ide-status-install-error',\n      text: 'IDE extension install failed (see /status for info)',\n      color: 'error',\n      priority: 'medium',\n    })\n  }, [addNotification, removeNotification, showIDEInstallError])\n}\n"],"mappings":"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","ignoreList":[]}

src/hooks/notifs/useLspInitializationNotification.tsx

@@ -0,0 +1,143 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useInterval } from 'usehooks-ts';
+import { getIsRemoteMode, getIsScrollDraining } from '../../bootstrap/state.js';
+import { useNotifications } from '../../context/notifications.js';
+import { Text } from '../../ink.js';
+import { getInitializationStatus, getLspServerManager } from '../../services/lsp/manager.js';
+import { useSetAppState } from '../../state/AppState.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+const LSP_POLL_INTERVAL_MS = 5000;
+
+/**
+ * Hook that polls LSP status and shows a notification when:
+ * 1. Manager initialization fails
+ * 2. Any LSP server enters an error state
+ *
+ * Also adds errors to appState.plugins.errors for /doctor display.
+ *
+ * Only active when ENABLE_LSP_TOOL is set.
+ */
+export function useLspInitializationNotification() {
+  const $ = _c(10);
+  const {
+    addNotification
+  } = useNotifications();
+  const setAppState = useSetAppState();
+  const [shouldPoll, setShouldPoll] = React.useState(_temp);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = new Set();
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const notifiedErrorsRef = React.useRef(t0);
+  let t1;
+  if ($[1] !== addNotification || $[2] !== setAppState) {
+    t1 = (source, errorMessage) => {
+      const errorKey = `${source}:${errorMessage}`;
+      if (notifiedErrorsRef.current.has(errorKey)) {
+        return;
+      }
+      notifiedErrorsRef.current.add(errorKey);
+      logForDebugging(`LSP error: ${source} - ${errorMessage}`);
+      setAppState(prev => {
+        const existingKeys = new Set(prev.plugins.errors.map(_temp2));
+        const stateErrorKey = `generic-error:${source}:${errorMessage}`;
+        if (existingKeys.has(stateErrorKey)) {
+          return prev;
+        }
+        return {
+          ...prev,
+          plugins: {
+            ...prev.plugins,
+            errors: [...prev.plugins.errors, {
+              type: "generic-error" as const,
+              source,
+              error: errorMessage
+            }]
+          }
+        };
+      });
+      const displayName = source.startsWith("plugin:") ? source.split(":")[1] ?? source : source;
+      addNotification({
+        key: `lsp-error-${source}`,
+        jsx: <><Text color="error">LSP for {displayName} failed</Text><Text dimColor={true}> · /plugin for details</Text></>,
+        priority: "medium",
+        timeoutMs: 8000
+      });
+    };
+    $[1] = addNotification;
+    $[2] = setAppState;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const addError = t1;
+  let t2;
+  if ($[4] !== addError) {
+    t2 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (getIsScrollDraining()) {
+        return;
+      }
+      const status = getInitializationStatus();
+      if (status.status === "failed") {
+        addError("lsp-manager", status.error.message);
+        setShouldPoll(false);
+        return;
+      }
+      if (status.status === "pending" || status.status === "not-started") {
+        return;
+      }
+      const manager = getLspServerManager();
+      if (manager) {
+        const servers = manager.getAllServers();
+        for (const [serverName, server] of servers) {
+          if (server.state === "error" && server.lastError) {
+            addError(serverName, server.lastError.message);
+          }
+        }
+      }
+    };
+    $[4] = addError;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const poll = t2;
+  useInterval(poll, shouldPoll ? LSP_POLL_INTERVAL_MS : null);
+  let t3;
+  let t4;
+  if ($[6] !== poll || $[7] !== shouldPoll) {
+    t3 = () => {
+      if (getIsRemoteMode() || !shouldPoll) {
+        return;
+      }
+      poll();
+    };
+    t4 = [poll, shouldPoll];
+    $[6] = poll;
+    $[7] = shouldPoll;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t3 = $[8];
+    t4 = $[9];
+  }
+  React.useEffect(t3, t4);
+}
+function _temp2(e) {
+  if (e.type === "generic-error") {
+    return `generic-error:${e.source}:${e.error}`;
+  }
+  return `${e.type}:${e.source}`;
+}
+function _temp() {
+  return isEnvTruthy("true");
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useInterval","getIsRemoteMode","getIsScrollDraining","useNotifications","Text","getInitializationStatus","getLspServerManager","useSetAppState","logForDebugging","isEnvTruthy","LSP_POLL_INTERVAL_MS","useLspInitializationNotification","$","_c","addNotification","setAppState","shouldPoll","setShouldPoll","useState","_temp","t0","Symbol","for","Set","notifiedErrorsRef","useRef","t1","source","errorMessage","errorKey","current","has","add","prev","existingKeys","plugins","errors","map","_temp2","stateErrorKey","type","const","error","displayName","startsWith","split","key","jsx","priority","timeoutMs","addError","t2","status","message","manager","servers","getAllServers","serverName","server","state","lastError","poll","t3","t4","useEffect","e"],"sources":["useLspInitializationNotification.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useInterval } from 'usehooks-ts'\nimport { getIsRemoteMode, getIsScrollDraining } from '../../bootstrap/state.js'\nimport { useNotifications } from '../../context/notifications.js'\nimport { Text } from '../../ink.js'\nimport {\n  getInitializationStatus,\n  getLspServerManager,\n} from '../../services/lsp/manager.js'\nimport { useSetAppState } from '../../state/AppState.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\n\nconst LSP_POLL_INTERVAL_MS = 5000\n\n/**\n * Hook that polls LSP status and shows a notification when:\n * 1. Manager initialization fails\n * 2. Any LSP server enters an error state\n *\n * Also adds errors to appState.plugins.errors for /doctor display.\n *\n * Only active when ENABLE_LSP_TOOL is set.\n */\nexport function useLspInitializationNotification(): void {\n  const { addNotification } = useNotifications()\n  const setAppState = useSetAppState()\n  // Lazy initializer — eager form re-evaluates isEnvTruthy on every REPL\n  // render (the arg expression runs even though useState ignores it after\n  // mount). Showed up as 7.2s isEnvTruthy self-time during PageUp spam\n  // after #24498 swapped cheap !!process.env.X for isEnvTruthy().\n  const [shouldPoll, setShouldPoll] = React.useState(() =>\n    isEnvTruthy(\"true\"),\n  )\n  // Track which errors we've already notified about to avoid duplicates\n  const notifiedErrorsRef = React.useRef<Set<string>>(new Set())\n\n  const addError = React.useCallback(\n    (source: string, errorMessage: string) => {\n      const errorKey = `${source}:${errorMessage}`\n      if (notifiedErrorsRef.current.has(errorKey)) {\n        return // Already notified\n      }\n      notifiedErrorsRef.current.add(errorKey)\n\n      logForDebugging(`LSP error: ${source} - ${errorMessage}`)\n\n      // Add error to appState.plugins.errors\n      setAppState(prev => {\n        // Check if this error already exists to avoid duplicates\n        const existingKeys = new Set(\n          prev.plugins.errors.map(e => {\n            if (e.type === 'generic-error') {\n              return `generic-error:${e.source}:${e.error}`\n            }\n            return `${e.type}:${e.source}`\n          }),\n        )\n\n        const stateErrorKey = `generic-error:${source}:${errorMessage}`\n        if (existingKeys.has(stateErrorKey)) {\n          return prev\n        }\n\n        return {\n          ...prev,\n          plugins: {\n            ...prev.plugins,\n            errors: [\n              ...prev.plugins.errors,\n              {\n                type: 'generic-error' as const,\n                source,\n                error: errorMessage,\n              },\n            ],\n          },\n        }\n      })\n\n      // Show notification - extract plugin name from source like \"plugin:typescript-lsp:typescript\"\n      const displayName = source.startsWith('plugin:')\n        ? (source.split(':')[1] ?? source)\n        : source\n\n      addNotification({\n        key: `lsp-error-${source}`,\n        jsx: (\n          <>\n            <Text color=\"error\">LSP for {displayName} failed</Text>\n            <Text dimColor> · /plugin for details</Text>\n          </>\n        ),\n        priority: 'medium',\n        timeoutMs: 8000,\n      })\n    },\n    [addNotification, setAppState],\n  )\n\n  const poll = React.useCallback(() => {\n    if (getIsRemoteMode()) return\n    // Skip during scroll drain — iterating all LSP servers + setAppState\n    // competes for the event loop with scroll frames. Next interval picks up.\n    if (getIsScrollDraining()) return\n\n    const status = getInitializationStatus()\n\n    // Check manager initialization status\n    if (status.status === 'failed') {\n      addError('lsp-manager', status.error.message)\n      setShouldPoll(false)\n      return\n    }\n\n    if (status.status === 'pending' || status.status === 'not-started') {\n      // Still initializing, continue polling\n      return\n    }\n\n    // Manager initialized successfully - check for server errors\n    const manager = getLspServerManager()\n    if (manager) {\n      const servers = manager.getAllServers()\n      for (const [serverName, server] of servers) {\n        if (server.state === 'error' && server.lastError) {\n          addError(serverName, server.lastError.message)\n        }\n      }\n    }\n    // Continue polling to detect future server errors\n  }, [addError])\n\n  useInterval(poll, shouldPoll ? LSP_POLL_INTERVAL_MS : null)\n\n  // Initial poll on mount\n  React.useEffect(() => {\n    if (getIsRemoteMode() || !shouldPoll) return\n    poll()\n  }, [poll, shouldPoll])\n}\n"],"mappings":"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","ignoreList":[]}

src/hooks/notifs/useMcpConnectivityStatus.tsx

@@ -0,0 +1,88 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect } from 'react';
+import { useNotifications } from 'src/context/notifications.js';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+import { Text } from '../../ink.js';
+import { hasClaudeAiMcpEverConnected } from '../../services/mcp/claudeai.js';
+import type { MCPServerConnection } from '../../services/mcp/types.js';
+type Props = {
+  mcpClients?: MCPServerConnection[];
+};
+const EMPTY_MCP_CLIENTS: MCPServerConnection[] = [];
+export function useMcpConnectivityStatus(t0) {
+  const $ = _c(4);
+  const {
+    mcpClients: t1
+  } = t0;
+  const mcpClients = t1 === undefined ? EMPTY_MCP_CLIENTS : t1;
+  const {
+    addNotification
+  } = useNotifications();
+  let t2;
+  let t3;
+  if ($[0] !== addNotification || $[1] !== mcpClients) {
+    t2 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      const failedLocalClients = mcpClients.filter(_temp);
+      const failedClaudeAiClients = mcpClients.filter(_temp2);
+      const needsAuthLocalServers = mcpClients.filter(_temp3);
+      const needsAuthClaudeAiServers = mcpClients.filter(_temp4);
+      if (failedLocalClients.length === 0 && failedClaudeAiClients.length === 0 && needsAuthLocalServers.length === 0 && needsAuthClaudeAiServers.length === 0) {
+        return;
+      }
+      if (failedLocalClients.length > 0) {
+        addNotification({
+          key: "mcp-failed",
+          jsx: <><Text color="error">{failedLocalClients.length} MCP{" "}{failedLocalClients.length === 1 ? "server" : "servers"} failed</Text><Text dimColor={true}> · /mcp</Text></>,
+          priority: "medium"
+        });
+      }
+      if (failedClaudeAiClients.length > 0) {
+        addNotification({
+          key: "mcp-claudeai-failed",
+          jsx: <><Text color="error">{failedClaudeAiClients.length} claude.ai{" "}{failedClaudeAiClients.length === 1 ? "connector" : "connectors"}{" "}unavailable</Text><Text dimColor={true}> · /mcp</Text></>,
+          priority: "medium"
+        });
+      }
+      if (needsAuthLocalServers.length > 0) {
+        addNotification({
+          key: "mcp-needs-auth",
+          jsx: <><Text color="warning">{needsAuthLocalServers.length} MCP{" "}{needsAuthLocalServers.length === 1 ? "server needs" : "servers need"}{" "}auth</Text><Text dimColor={true}> · /mcp</Text></>,
+          priority: "medium"
+        });
+      }
+      if (needsAuthClaudeAiServers.length > 0) {
+        addNotification({
+          key: "mcp-claudeai-needs-auth",
+          jsx: <><Text color="warning">{needsAuthClaudeAiServers.length} claude.ai{" "}{needsAuthClaudeAiServers.length === 1 ? "connector needs" : "connectors need"}{" "}auth</Text><Text dimColor={true}> · /mcp</Text></>,
+          priority: "medium"
+        });
+      }
+    };
+    t3 = [addNotification, mcpClients];
+    $[0] = addNotification;
+    $[1] = mcpClients;
+    $[2] = t2;
+    $[3] = t3;
+  } else {
+    t2 = $[2];
+    t3 = $[3];
+  }
+  useEffect(t2, t3);
+}
+function _temp4(client_2) {
+  return client_2.type === "needs-auth" && client_2.config.type === "claudeai-proxy" && hasClaudeAiMcpEverConnected(client_2.name);
+}
+function _temp3(client_1) {
+  return client_1.type === "needs-auth" && client_1.config.type !== "claudeai-proxy";
+}
+function _temp2(client_0) {
+  return client_0.type === "failed" && client_0.config.type === "claudeai-proxy" && hasClaudeAiMcpEverConnected(client_0.name);
+}
+function _temp(client) {
+  return client.type === "failed" && client.config.type !== "sse-ide" && client.config.type !== "ws-ide" && client.config.type !== "claudeai-proxy";
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useNotifications","getIsRemoteMode","Text","hasClaudeAiMcpEverConnected","MCPServerConnection","Props","mcpClients","EMPTY_MCP_CLIENTS","useMcpConnectivityStatus","t0","$","_c","t1","undefined","addNotification","t2","t3","failedLocalClients","filter","_temp","failedClaudeAiClients","_temp2","needsAuthLocalServers","_temp3","needsAuthClaudeAiServers","_temp4","length","key","jsx","priority","client_2","client","type","config","name","client_1","client_0"],"sources":["useMcpConnectivityStatus.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect } from 'react'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { getIsRemoteMode } from '../../bootstrap/state.js'\nimport { Text } from '../../ink.js'\nimport { hasClaudeAiMcpEverConnected } from '../../services/mcp/claudeai.js'\nimport type { MCPServerConnection } from '../../services/mcp/types.js'\n\ntype Props = {\n  mcpClients?: MCPServerConnection[]\n}\n\nconst EMPTY_MCP_CLIENTS: MCPServerConnection[] = []\n\nexport function useMcpConnectivityStatus({\n  mcpClients = EMPTY_MCP_CLIENTS,\n}: Props): void {\n  const { addNotification } = useNotifications()\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    const failedLocalClients = mcpClients.filter(\n      client =>\n        client.type === 'failed' &&\n        client.config.type !== 'sse-ide' &&\n        client.config.type !== 'ws-ide' &&\n        client.config.type !== 'claudeai-proxy',\n    )\n    // claude.ai failures get a separate notification: they almost always indicate\n    // a toolbox-service outage (shared auth backend), not a local config issue.\n    // Only flag connectors that have previously connected successfully — an\n    // org-configured connector that's been needs-auth since it appeared is one\n    // the user has ignored and shouldn't nag about; one that was working\n    // yesterday and is now failed is a state change worth surfacing.\n    const failedClaudeAiClients = mcpClients.filter(\n      client =>\n        client.type === 'failed' &&\n        client.config.type === 'claudeai-proxy' &&\n        hasClaudeAiMcpEverConnected(client.name),\n    )\n    const needsAuthLocalServers = mcpClients.filter(\n      client =>\n        client.type === 'needs-auth' && client.config.type !== 'claudeai-proxy',\n    )\n    const needsAuthClaudeAiServers = mcpClients.filter(\n      client =>\n        client.type === 'needs-auth' &&\n        client.config.type === 'claudeai-proxy' &&\n        hasClaudeAiMcpEverConnected(client.name),\n    )\n    if (\n      failedLocalClients.length === 0 &&\n      failedClaudeAiClients.length === 0 &&\n      needsAuthLocalServers.length === 0 &&\n      needsAuthClaudeAiServers.length === 0\n    ) {\n      return\n    }\n    if (failedLocalClients.length > 0) {\n      addNotification({\n        key: 'mcp-failed',\n        jsx: (\n          <>\n            <Text color=\"error\">\n              {failedLocalClients.length} MCP{' '}\n              {failedLocalClients.length === 1 ? 'server' : 'servers'} failed\n            </Text>\n            <Text dimColor> · /mcp</Text>\n          </>\n        ),\n        priority: 'medium',\n      })\n    }\n    if (failedClaudeAiClients.length > 0) {\n      addNotification({\n        key: 'mcp-claudeai-failed',\n        jsx: (\n          <>\n            <Text color=\"error\">\n              {failedClaudeAiClients.length} claude.ai{' '}\n              {failedClaudeAiClients.length === 1 ? 'connector' : 'connectors'}{' '}\n              unavailable\n            </Text>\n            <Text dimColor> · /mcp</Text>\n          </>\n        ),\n        priority: 'medium',\n      })\n    }\n    if (needsAuthLocalServers.length > 0) {\n      addNotification({\n        key: 'mcp-needs-auth',\n        jsx: (\n          <>\n            <Text color=\"warning\">\n              {needsAuthLocalServers.length} MCP{' '}\n              {needsAuthLocalServers.length === 1\n                ? 'server needs'\n                : 'servers need'}{' '}\n              auth\n            </Text>\n            <Text dimColor> · /mcp</Text>\n          </>\n        ),\n        priority: 'medium',\n      })\n    }\n    if (needsAuthClaudeAiServers.length > 0) {\n      addNotification({\n        key: 'mcp-claudeai-needs-auth',\n        jsx: (\n          <>\n            <Text color=\"warning\">\n              {needsAuthClaudeAiServers.length} claude.ai{' '}\n              {needsAuthClaudeAiServers.length === 1\n                ? 'connector needs'\n                : 'connectors need'}{' '}\n              auth\n            </Text>\n            <Text dimColor> · /mcp</Text>\n          </>\n        ),\n        priority: 'medium',\n      })\n    }\n  }, [addNotification, mcpClients])\n}\n"],"mappings":"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","ignoreList":[]}

src/hooks/notifs/useModelMigrationNotifications.tsx

@@ -0,0 +1,52 @@
+import type { Notification } from 'src/context/notifications.js';
+import { type GlobalConfig, getGlobalConfig } from 'src/utils/config.js';
+import { useStartupNotification } from './useStartupNotification.js';
+
+// Shows a one-time notification right after a model migration writes its
+// timestamp to config. Each entry reads its own timestamp field(s) and emits
+// a notification if the write happened within the last 3s (i.e. this launch).
+// Future model migrations: add an entry to MIGRATIONS below.
+const MIGRATIONS: ((c: GlobalConfig) => Notification | undefined)[] = [
+// Sonnet 4.5 → 4.6 (pro/max/team premium)
+c => {
+  if (!recent(c.sonnet45To46MigrationTimestamp)) return;
+  return {
+    key: 'sonnet-46-update',
+    text: 'Model updated to Sonnet 4.6',
+    color: 'suggestion',
+    priority: 'high',
+    timeoutMs: 3000
+  };
+},
+// Opus Pro → default, or pinned 4.0/4.1 → opus alias. Both land on the
+// current Opus default (4.6 for 1P).
+c => {
+  const isLegacyRemap = Boolean(c.legacyOpusMigrationTimestamp);
+  const ts = c.legacyOpusMigrationTimestamp ?? c.opusProMigrationTimestamp;
+  if (!recent(ts)) return;
+  return {
+    key: 'opus-pro-update',
+    text: isLegacyRemap ? 'Model updated to Opus 4.6 · Set CLAUDE_CODE_DISABLE_LEGACY_MODEL_REMAP=1 to opt out' : 'Model updated to Opus 4.6',
+    color: 'suggestion',
+    priority: 'high',
+    timeoutMs: isLegacyRemap ? 8000 : 3000
+  };
+}];
+export function useModelMigrationNotifications() {
+  useStartupNotification(_temp);
+}
+function _temp() {
+  const config = getGlobalConfig();
+  const notifs = [];
+  for (const migration of MIGRATIONS) {
+    const notif = migration(config);
+    if (notif) {
+      notifs.push(notif);
+    }
+  }
+  return notifs.length > 0 ? notifs : null;
+}
+function recent(ts: number | undefined): boolean {
+  return ts !== undefined && Date.now() - ts < 3000;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/hooks/notifs/useNpmDeprecationNotification.tsx

@@ -0,0 +1,25 @@
+import { isInBundledMode } from 'src/utils/bundledMode.js';
+import { getCurrentInstallationType } from 'src/utils/doctorDiagnostic.js';
+import { isEnvTruthy } from 'src/utils/envUtils.js';
+import { useStartupNotification } from './useStartupNotification.js';
+const NPM_DEPRECATION_MESSAGE = 'Claude Code has switched from npm to native installer. Run `claude install` or see https://docs.anthropic.com/en/docs/claude-code/getting-started for more options.';
+export function useNpmDeprecationNotification() {
+  useStartupNotification(_temp);
+}
+async function _temp() {
+  if (isInBundledMode() || isEnvTruthy(process.env.DISABLE_INSTALLATION_CHECKS)) {
+    return null;
+  }
+  const installationType = await getCurrentInstallationType();
+  if (installationType === "development") {
+    return null;
+  }
+  return {
+    timeoutMs: 15000,
+    key: "npm-deprecation-warning",
+    text: NPM_DEPRECATION_MESSAGE,
+    color: "warning",
+    priority: "high"
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/hooks/notifs/usePluginAutoupdateNotification.tsx

@@ -0,0 +1,83 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+import { useNotifications } from '../../context/notifications.js';
+import { Text } from '../../ink.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { onPluginsAutoUpdated } from '../../utils/plugins/pluginAutoupdate.js';
+
+/**
+ * Hook that displays a notification when plugins have been auto-updated.
+ * The notification tells the user to run /reload-plugins to apply the updates.
+ */
+export function usePluginAutoupdateNotification() {
+  const $ = _c(7);
+  const {
+    addNotification
+  } = useNotifications();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const [updatedPlugins, setUpdatedPlugins] = useState(t0);
+  let t1;
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      const unsubscribe = onPluginsAutoUpdated(plugins => {
+        logForDebugging(`Plugin autoupdate notification: ${plugins.length} plugin(s) updated`);
+        setUpdatedPlugins(plugins);
+      });
+      return unsubscribe;
+    };
+    t2 = [];
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  let t3;
+  let t4;
+  if ($[3] !== addNotification || $[4] !== updatedPlugins) {
+    t3 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (updatedPlugins.length === 0) {
+        return;
+      }
+      const pluginNames = updatedPlugins.map(_temp);
+      const displayNames = pluginNames.length <= 2 ? pluginNames.join(" and ") : `${pluginNames.length} plugins`;
+      addNotification({
+        key: "plugin-autoupdate-restart",
+        jsx: <><Text color="success">{pluginNames.length === 1 ? "Plugin" : "Plugins"} updated:{" "}{displayNames}</Text><Text dimColor={true}> · Run /reload-plugins to apply</Text></>,
+        priority: "low",
+        timeoutMs: 10000
+      });
+      logForDebugging(`Showing plugin autoupdate notification for: ${pluginNames.join(", ")}`);
+    };
+    t4 = [updatedPlugins, addNotification];
+    $[3] = addNotification;
+    $[4] = updatedPlugins;
+    $[5] = t3;
+    $[6] = t4;
+  } else {
+    t3 = $[5];
+    t4 = $[6];
+  }
+  useEffect(t3, t4);
+}
+function _temp(id) {
+  const atIndex = id.indexOf("@");
+  return atIndex > 0 ? id.substring(0, atIndex) : id;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/hooks/notifs/usePluginInstallationStatus.tsx

@@ -0,0 +1,128 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useMemo } from 'react';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+import { useNotifications } from '../../context/notifications.js';
+import { Text } from '../../ink.js';
+import { useAppState } from '../../state/AppState.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { plural } from '../../utils/stringUtils.js';
+export function usePluginInstallationStatus() {
+  const $ = _c(20);
+  const {
+    addNotification
+  } = useNotifications();
+  const installationStatus = useAppState(_temp);
+  let t0;
+  bb0: {
+    if (!installationStatus) {
+      let t1;
+      if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+        t1 = {
+          totalFailed: 0,
+          failedMarketplacesCount: 0,
+          failedPluginsCount: 0
+        };
+        $[0] = t1;
+      } else {
+        t1 = $[0];
+      }
+      t0 = t1;
+      break bb0;
+    }
+    let t1;
+    if ($[1] !== installationStatus.marketplaces) {
+      t1 = installationStatus.marketplaces.filter(_temp2);
+      $[1] = installationStatus.marketplaces;
+      $[2] = t1;
+    } else {
+      t1 = $[2];
+    }
+    const failedMarketplaces = t1;
+    let t2;
+    if ($[3] !== installationStatus.plugins) {
+      t2 = installationStatus.plugins.filter(_temp3);
+      $[3] = installationStatus.plugins;
+      $[4] = t2;
+    } else {
+      t2 = $[4];
+    }
+    const failedPlugins = t2;
+    const t3 = failedMarketplaces.length + failedPlugins.length;
+    let t4;
+    if ($[5] !== failedMarketplaces.length || $[6] !== failedPlugins.length || $[7] !== t3) {
+      t4 = {
+        totalFailed: t3,
+        failedMarketplacesCount: failedMarketplaces.length,
+        failedPluginsCount: failedPlugins.length
+      };
+      $[5] = failedMarketplaces.length;
+      $[6] = failedPlugins.length;
+      $[7] = t3;
+      $[8] = t4;
+    } else {
+      t4 = $[8];
+    }
+    t0 = t4;
+  }
+  const {
+    totalFailed,
+    failedMarketplacesCount,
+    failedPluginsCount
+  } = t0;
+  let t1;
+  if ($[9] !== addNotification || $[10] !== failedMarketplacesCount || $[11] !== failedPluginsCount || $[12] !== installationStatus || $[13] !== totalFailed) {
+    t1 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (!installationStatus) {
+        logForDebugging("No installation status to monitor");
+        return;
+      }
+      if (totalFailed === 0) {
+        return;
+      }
+      logForDebugging(`Plugin installation status: ${failedMarketplacesCount} failed marketplaces, ${failedPluginsCount} failed plugins`);
+      if (totalFailed === 0) {
+        return;
+      }
+      logForDebugging(`Adding notification for ${totalFailed} failed installations`);
+      addNotification({
+        key: "plugin-install-failed",
+        jsx: <><Text color="error">{totalFailed} {plural(totalFailed, "plugin")} failed to install</Text><Text dimColor={true}> · /plugin for details</Text></>,
+        priority: "medium"
+      });
+    };
+    $[9] = addNotification;
+    $[10] = failedMarketplacesCount;
+    $[11] = failedPluginsCount;
+    $[12] = installationStatus;
+    $[13] = totalFailed;
+    $[14] = t1;
+  } else {
+    t1 = $[14];
+  }
+  let t2;
+  if ($[15] !== addNotification || $[16] !== failedMarketplacesCount || $[17] !== failedPluginsCount || $[18] !== totalFailed) {
+    t2 = [addNotification, totalFailed, failedMarketplacesCount, failedPluginsCount];
+    $[15] = addNotification;
+    $[16] = failedMarketplacesCount;
+    $[17] = failedPluginsCount;
+    $[18] = totalFailed;
+    $[19] = t2;
+  } else {
+    t2 = $[19];
+  }
+  useEffect(t1, t2);
+}
+function _temp3(p) {
+  return p.status === "failed";
+}
+function _temp2(m) {
+  return m.status === "failed";
+}
+function _temp(s) {
+  return s.plugins.installationStatus;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useMemo","getIsRemoteMode","useNotifications","Text","useAppState","logForDebugging","plural","usePluginInstallationStatus","$","_c","addNotification","installationStatus","_temp","t0","bb0","t1","Symbol","for","totalFailed","failedMarketplacesCount","failedPluginsCount","marketplaces","filter","_temp2","failedMarketplaces","t2","plugins","_temp3","failedPlugins","t3","length","t4","key","jsx","priority","p","status","m","s"],"sources":["usePluginInstallationStatus.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useMemo } from 'react'\nimport { getIsRemoteMode } from '../../bootstrap/state.js'\nimport { useNotifications } from '../../context/notifications.js'\nimport { Text } from '../../ink.js'\nimport { useAppState } from '../../state/AppState.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { plural } from '../../utils/stringUtils.js'\n\nexport function usePluginInstallationStatus(): void {\n  const { addNotification } = useNotifications()\n  const installationStatus = useAppState(s => s.plugins.installationStatus)\n\n  // Memoize the failed counts to prevent unnecessary effect triggers\n  const { totalFailed, failedMarketplacesCount, failedPluginsCount } =\n    useMemo(() => {\n      if (!installationStatus) {\n        return {\n          totalFailed: 0,\n          failedMarketplacesCount: 0,\n          failedPluginsCount: 0,\n        }\n      }\n\n      const failedMarketplaces = installationStatus.marketplaces.filter(\n        m => m.status === 'failed',\n      )\n      const failedPlugins = installationStatus.plugins.filter(\n        p => p.status === 'failed',\n      )\n\n      return {\n        totalFailed: failedMarketplaces.length + failedPlugins.length,\n        failedMarketplacesCount: failedMarketplaces.length,\n        failedPluginsCount: failedPlugins.length,\n      }\n    }, [installationStatus])\n\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (!installationStatus) {\n      logForDebugging('No installation status to monitor')\n      return\n    }\n\n    if (totalFailed === 0) {\n      return\n    }\n\n    logForDebugging(\n      `Plugin installation status: ${failedMarketplacesCount} failed marketplaces, ${failedPluginsCount} failed plugins`,\n    )\n\n    if (totalFailed === 0) {\n      return\n    }\n\n    // Add notification for failures\n    logForDebugging(\n      `Adding notification for ${totalFailed} failed installations`,\n    )\n    addNotification({\n      key: 'plugin-install-failed',\n      jsx: (\n        <>\n          <Text color=\"error\">\n            {totalFailed} {plural(totalFailed, 'plugin')} failed to install\n          </Text>\n          <Text dimColor> · /plugin for details</Text>\n        </>\n      ),\n      priority: 'medium',\n    })\n  }, [\n    addNotification,\n    totalFailed,\n    failedMarketplacesCount,\n    failedPluginsCount,\n  ])\n}\n"],"mappings":"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","ignoreList":[]}

src/hooks/notifs/useRateLimitWarningNotification.tsx

@@ -0,0 +1,114 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { useNotifications } from 'src/context/notifications.js';
+import { Text } from 'src/ink.js';
+import { getRateLimitWarning, getUsingOverageText } from 'src/services/claudeAiLimits.js';
+import { useClaudeAiLimits } from 'src/services/claudeAiLimitsHook.js';
+import { getSubscriptionType } from 'src/utils/auth.js';
+import { hasClaudeAiBillingAccess } from 'src/utils/billing.js';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+export function useRateLimitWarningNotification(model) {
+  const $ = _c(17);
+  const {
+    addNotification
+  } = useNotifications();
+  const claudeAiLimits = useClaudeAiLimits();
+  let t0;
+  if ($[0] !== claudeAiLimits || $[1] !== model) {
+    t0 = getRateLimitWarning(claudeAiLimits, model);
+    $[0] = claudeAiLimits;
+    $[1] = model;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const rateLimitWarning = t0;
+  let t1;
+  if ($[3] !== claudeAiLimits) {
+    t1 = getUsingOverageText(claudeAiLimits);
+    $[3] = claudeAiLimits;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const usingOverageText = t1;
+  const shownWarningRef = useRef(null);
+  let t2;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = getSubscriptionType();
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const subscriptionType = t2;
+  let t3;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = hasClaudeAiBillingAccess();
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  const hasBillingAccess = t3;
+  const isTeamOrEnterprise = subscriptionType === "team" || subscriptionType === "enterprise";
+  const [hasShownOverageNotification, setHasShownOverageNotification] = useState(false);
+  let t4;
+  let t5;
+  if ($[7] !== addNotification || $[8] !== claudeAiLimits.isUsingOverage || $[9] !== hasShownOverageNotification || $[10] !== usingOverageText) {
+    t4 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (claudeAiLimits.isUsingOverage && !hasShownOverageNotification && (!isTeamOrEnterprise || hasBillingAccess)) {
+        addNotification({
+          key: "limit-reached",
+          text: usingOverageText,
+          priority: "immediate"
+        });
+        setHasShownOverageNotification(true);
+      } else {
+        if (!claudeAiLimits.isUsingOverage && hasShownOverageNotification) {
+          setHasShownOverageNotification(false);
+        }
+      }
+    };
+    t5 = [claudeAiLimits.isUsingOverage, usingOverageText, hasShownOverageNotification, addNotification, hasBillingAccess, isTeamOrEnterprise];
+    $[7] = addNotification;
+    $[8] = claudeAiLimits.isUsingOverage;
+    $[9] = hasShownOverageNotification;
+    $[10] = usingOverageText;
+    $[11] = t4;
+    $[12] = t5;
+  } else {
+    t4 = $[11];
+    t5 = $[12];
+  }
+  useEffect(t4, t5);
+  let t6;
+  let t7;
+  if ($[13] !== addNotification || $[14] !== rateLimitWarning) {
+    t6 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (rateLimitWarning && rateLimitWarning !== shownWarningRef.current) {
+        shownWarningRef.current = rateLimitWarning;
+        addNotification({
+          key: "rate-limit-warning",
+          jsx: <Text><Text color="warning">{rateLimitWarning}</Text></Text>,
+          priority: "high"
+        });
+      }
+    };
+    t7 = [rateLimitWarning, addNotification];
+    $[13] = addNotification;
+    $[14] = rateLimitWarning;
+    $[15] = t6;
+    $[16] = t7;
+  } else {
+    t6 = $[15];
+    t7 = $[16];
+  }
+  useEffect(t6, t7);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useMemo","useRef","useState","useNotifications","Text","getRateLimitWarning","getUsingOverageText","useClaudeAiLimits","getSubscriptionType","hasClaudeAiBillingAccess","getIsRemoteMode","useRateLimitWarningNotification","model","$","_c","addNotification","claudeAiLimits","t0","rateLimitWarning","t1","usingOverageText","shownWarningRef","t2","Symbol","for","subscriptionType","t3","hasBillingAccess","isTeamOrEnterprise","hasShownOverageNotification","setHasShownOverageNotification","t4","t5","isUsingOverage","key","text","priority","t6","t7","current","jsx"],"sources":["useRateLimitWarningNotification.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { Text } from 'src/ink.js'\nimport {\n  getRateLimitWarning,\n  getUsingOverageText,\n} from 'src/services/claudeAiLimits.js'\nimport { useClaudeAiLimits } from 'src/services/claudeAiLimitsHook.js'\nimport { getSubscriptionType } from 'src/utils/auth.js'\nimport { hasClaudeAiBillingAccess } from 'src/utils/billing.js'\nimport { getIsRemoteMode } from '../../bootstrap/state.js'\n\nexport function useRateLimitWarningNotification(model: string): void {\n  const { addNotification } = useNotifications()\n  const claudeAiLimits = useClaudeAiLimits()\n  // claudeAiLimits reference is stable until statusListeners fire (API\n  // response), so these skip the Intl formatting work on most REPL renders.\n  const rateLimitWarning = useMemo(\n    () => getRateLimitWarning(claudeAiLimits, model),\n    [claudeAiLimits, model],\n  )\n  const usingOverageText = useMemo(\n    () => getUsingOverageText(claudeAiLimits),\n    [claudeAiLimits],\n  )\n  const shownWarningRef = useRef<string | null>(null)\n  const subscriptionType = getSubscriptionType()\n  const hasBillingAccess = hasClaudeAiBillingAccess()\n  const isTeamOrEnterprise =\n    subscriptionType === 'team' || subscriptionType === 'enterprise'\n\n  // Track overage mode transitions\n  const [hasShownOverageNotification, setHasShownOverageNotification] =\n    useState(false)\n\n  // Show immediate notification when entering overage mode\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (\n      claudeAiLimits.isUsingOverage &&\n      !hasShownOverageNotification &&\n      (!isTeamOrEnterprise || hasBillingAccess)\n    ) {\n      addNotification({\n        key: 'limit-reached',\n        text: usingOverageText,\n        priority: 'immediate',\n      })\n      setHasShownOverageNotification(true)\n    } else if (!claudeAiLimits.isUsingOverage && hasShownOverageNotification) {\n      // Reset when no longer in overage mode\n      setHasShownOverageNotification(false)\n    }\n  }, [\n    claudeAiLimits.isUsingOverage,\n    usingOverageText,\n    hasShownOverageNotification,\n    addNotification,\n    hasBillingAccess,\n    isTeamOrEnterprise,\n  ])\n\n  // Show warning notification for approaching limits\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (rateLimitWarning && rateLimitWarning !== shownWarningRef.current) {\n      shownWarningRef.current = rateLimitWarning\n      addNotification({\n        key: 'rate-limit-warning',\n        jsx: (\n          <Text>\n            <Text color=\"warning\">{rateLimitWarning}</Text>\n          </Text>\n        ),\n        priority: 'high',\n      })\n    }\n  }, [rateLimitWarning, addNotification])\n}\n"],"mappings":"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","ignoreList":[]}

src/hooks/notifs/useStartupNotification.ts

@@ -0,0 +1,41 @@
+import { useEffect, useRef } from 'react'
+import { getIsRemoteMode } from '../../bootstrap/state.js'
+import {
+  type Notification,
+  useNotifications,
+} from '../../context/notifications.js'
+import { logError } from '../../utils/log.js'
+
+type Result = Notification | Notification[] | null
+
+/**
+ * Fires notification(s) once on mount. Encapsulates the remote-mode gate and
+ * once-per-session ref guard that was hand-rolled across 10+ notifs/ hooks.
+ *
+ * The compute fn runs exactly once on first effect. Return null to skip,
+ * a Notification to fire one, or an array to fire several. Sync or async.
+ * Rejections are routed to logError.
+ */
+export function useStartupNotification(
+  compute: () => Result | Promise<Result>,
+): void {
+  const { addNotification } = useNotifications()
+  const hasRunRef = useRef(false)
+  const computeRef = useRef(compute)
+  computeRef.current = compute
+
+  useEffect(() => {
+    if (getIsRemoteMode() || hasRunRef.current) return
+    hasRunRef.current = true
+
+    void Promise.resolve()
+      .then(() => computeRef.current())
+      .then(result => {
+        if (!result) return
+        for (const n of Array.isArray(result) ? result : [result]) {
+          addNotification(n)
+        }
+      })
+      .catch(logError)
+  }, [addNotification])
+}

src/hooks/notifs/useTeammateShutdownNotification.ts

@@ -0,0 +1,78 @@
+import { useEffect, useRef } from 'react'
+import { getIsRemoteMode } from '../../bootstrap/state.js'
+import {
+  type Notification,
+  useNotifications,
+} from '../../context/notifications.js'
+import { useAppState } from '../../state/AppState.js'
+import { isInProcessTeammateTask } from '../../tasks/InProcessTeammateTask/types.js'
+
+function parseCount(notif: Notification): number {
+  if (!('text' in notif)) {
+    return 1
+  }
+  const match = notif.text.match(/^(\d+)/)
+  return match?.[1] ? parseInt(match[1], 10) : 1
+}
+
+function foldSpawn(acc: Notification, _incoming: Notification): Notification {
+  return makeSpawnNotif(parseCount(acc) + 1)
+}
+
+function makeSpawnNotif(count: number): Notification {
+  return {
+    key: 'teammate-spawn',
+    text: count === 1 ? '1 agent spawned' : `${count} agents spawned`,
+    priority: 'low',
+    timeoutMs: 5000,
+    fold: foldSpawn,
+  }
+}
+
+function foldShutdown(
+  acc: Notification,
+  _incoming: Notification,
+): Notification {
+  return makeShutdownNotif(parseCount(acc) + 1)
+}
+
+function makeShutdownNotif(count: number): Notification {
+  return {
+    key: 'teammate-shutdown',
+    text: count === 1 ? '1 agent shut down' : `${count} agents shut down`,
+    priority: 'low',
+    timeoutMs: 5000,
+    fold: foldShutdown,
+  }
+}
+
+/**
+ * Fires batched notifications when in-process teammates spawn or shut down.
+ * Uses fold() to combine repeated events into a single notification
+ * like "3 agents spawned" or "2 agents shut down".
+ */
+export function useTeammateLifecycleNotification(): void {
+  const tasks = useAppState(s => s.tasks)
+  const { addNotification } = useNotifications()
+  const seenRunningRef = useRef<Set<string>>(new Set())
+  const seenCompletedRef = useRef<Set<string>>(new Set())
+
+  useEffect(() => {
+    if (getIsRemoteMode()) return
+    for (const [id, task] of Object.entries(tasks)) {
+      if (!isInProcessTeammateTask(task)) {
+        continue
+      }
+
+      if (task.status === 'running' && !seenRunningRef.current.has(id)) {
+        seenRunningRef.current.add(id)
+        addNotification(makeSpawnNotif(1))
+      }
+
+      if (task.status === 'completed' && !seenCompletedRef.current.has(id)) {
+        seenCompletedRef.current.add(id)
+        addNotification(makeShutdownNotif(1))
+      }
+    }
+  }, [tasks, addNotification])
+}

src/hooks/toolPermission/handlers/coordinatorHandler.ts

@@ -0,0 +1,65 @@
+import { feature } from 'bun:bundle'
+import type { PendingClassifierCheck } from '../../../types/permissions.js'
+import { logError } from '../../../utils/log.js'
+import type { PermissionDecision } from '../../../utils/permissions/PermissionResult.js'
+import type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js'
+import type { PermissionContext } from '../PermissionContext.js'
+
+type CoordinatorPermissionParams = {
+  ctx: PermissionContext
+  pendingClassifierCheck?: PendingClassifierCheck | undefined
+  updatedInput: Record<string, unknown> | undefined
+  suggestions: PermissionUpdate[] | undefined
+  permissionMode: string | undefined
+}
+
+/**
+ * Handles the coordinator worker permission flow.
+ *
+ * For coordinator workers, automated checks (hooks and classifier) are
+ * awaited sequentially before falling through to the interactive dialog.
+ *
+ * Returns a PermissionDecision if the automated checks resolved the
+ * permission, or null if the caller should fall through to the
+ * interactive dialog.
+ */
+async function handleCoordinatorPermission(
+  params: CoordinatorPermissionParams,
+): Promise<PermissionDecision | null> {
+  const { ctx, updatedInput, suggestions, permissionMode } = params
+
+  try {
+    // 1. Try permission hooks first (fast, local)
+    const hookResult = await ctx.runHooks(
+      permissionMode,
+      suggestions,
+      updatedInput,
+    )
+    if (hookResult) return hookResult
+
+    // 2. Try classifier (slow, inference -- bash only)
+    const classifierResult = feature('BASH_CLASSIFIER')
+      ? await ctx.tryClassifier?.(params.pendingClassifierCheck, updatedInput)
+      : null
+    if (classifierResult) {
+      return classifierResult
+    }
+  } catch (error) {
+    // If automated checks fail unexpectedly, fall through to show the dialog
+    // so the user can decide manually. Non-Error throws get a context prefix
+    // so the log is traceable — intentionally NOT toError(), which would drop
+    // the prefix.
+    if (error instanceof Error) {
+      logError(error)
+    } else {
+      logError(new Error(`Automated permission check failed: ${String(error)}`))
+    }
+  }
+
+  // 3. Neither resolved (or checks failed) -- fall through to dialog below.
+  // Hooks already ran, classifier already consumed.
+  return null
+}
+
+export { handleCoordinatorPermission }
+export type { CoordinatorPermissionParams }

src/hooks/toolPermission/handlers/interactiveHandler.ts

@@ -0,0 +1,536 @@
+import { feature } from 'bun:bundle'
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources/messages.mjs'
+import { randomUUID } from 'crypto'
+import { logForDebugging } from 'src/utils/debug.js'
+import { getAllowedChannels } from '../../../bootstrap/state.js'
+import type { BridgePermissionCallbacks } from '../../../bridge/bridgePermissionCallbacks.js'
+import { getTerminalFocused } from '../../../ink/terminal-focus-state.js'
+import {
+  CHANNEL_PERMISSION_REQUEST_METHOD,
+  type ChannelPermissionRequestParams,
+  findChannelEntry,
+} from '../../../services/mcp/channelNotification.js'
+import type { ChannelPermissionCallbacks } from '../../../services/mcp/channelPermissions.js'
+import {
+  filterPermissionRelayClients,
+  shortRequestId,
+  truncateForPreview,
+} from '../../../services/mcp/channelPermissions.js'
+import { executeAsyncClassifierCheck } from '../../../tools/BashTool/bashPermissions.js'
+import { BASH_TOOL_NAME } from '../../../tools/BashTool/toolName.js'
+import {
+  clearClassifierChecking,
+  setClassifierApproval,
+  setClassifierChecking,
+  setYoloClassifierApproval,
+} from '../../../utils/classifierApprovals.js'
+import { errorMessage } from '../../../utils/errors.js'
+import type { PermissionDecision } from '../../../utils/permissions/PermissionResult.js'
+import type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js'
+import { hasPermissionsToUseTool } from '../../../utils/permissions/permissions.js'
+import type { PermissionContext } from '../PermissionContext.js'
+import { createResolveOnce } from '../PermissionContext.js'
+
+type InteractivePermissionParams = {
+  ctx: PermissionContext
+  description: string
+  result: PermissionDecision & { behavior: 'ask' }
+  awaitAutomatedChecksBeforeDialog: boolean | undefined
+  bridgeCallbacks?: BridgePermissionCallbacks
+  channelCallbacks?: ChannelPermissionCallbacks
+}
+
+/**
+ * Handles the interactive (main-agent) permission flow.
+ *
+ * Pushes a ToolUseConfirm entry to the confirm queue with callbacks:
+ * onAbort, onAllow, onReject, recheckPermission, onUserInteraction.
+ *
+ * Runs permission hooks and bash classifier checks asynchronously in the
+ * background, racing them against user interaction. Uses a resolve-once
+ * guard and `userInteracted` flag to prevent multiple resolutions.
+ *
+ * This function does NOT return a Promise -- it sets up callbacks that
+ * eventually call `resolve()` to resolve the outer promise owned by
+ * the caller.
+ */
+function handleInteractivePermission(
+  params: InteractivePermissionParams,
+  resolve: (decision: PermissionDecision) => void,
+): void {
+  const {
+    ctx,
+    description,
+    result,
+    awaitAutomatedChecksBeforeDialog,
+    bridgeCallbacks,
+    channelCallbacks,
+  } = params
+
+  const { resolve: resolveOnce, isResolved, claim } = createResolveOnce(resolve)
+  let userInteracted = false
+  let checkmarkTransitionTimer: ReturnType<typeof setTimeout> | undefined
+  // Hoisted so onDismissCheckmark (Esc during checkmark window) can also
+  // remove the abort listener — not just the timer callback.
+  let checkmarkAbortHandler: (() => void) | undefined
+  const bridgeRequestId = bridgeCallbacks ? randomUUID() : undefined
+  // Hoisted so local/hook/classifier wins can remove the pending channel
+  // entry. No "tell remote to dismiss" equivalent — the text sits in your
+  // phone, and a stale "yes abc123" after local-resolve falls through
+  // tryConsumeReply (entry gone) and gets enqueued as normal chat.
+  let channelUnsubscribe: (() => void) | undefined
+
+  const permissionPromptStartTimeMs = Date.now()
+  const displayInput = result.updatedInput ?? ctx.input
+
+  function clearClassifierIndicator(): void {
+    if (feature('BASH_CLASSIFIER')) {
+      ctx.updateQueueItem({ classifierCheckInProgress: false })
+    }
+  }
+
+  ctx.pushToQueue({
+    assistantMessage: ctx.assistantMessage,
+    tool: ctx.tool,
+    description,
+    input: displayInput,
+    toolUseContext: ctx.toolUseContext,
+    toolUseID: ctx.toolUseID,
+    permissionResult: result,
+    permissionPromptStartTimeMs,
+    ...(feature('BASH_CLASSIFIER')
+      ? {
+          classifierCheckInProgress:
+            !!result.pendingClassifierCheck &&
+            !awaitAutomatedChecksBeforeDialog,
+        }
+      : {}),
+    onUserInteraction() {
+      // Called when user starts interacting with the permission dialog
+      // (e.g., arrow keys, tab, typing feedback)
+      // Hide the classifier indicator since auto-approve is no longer possible
+      //
+      // Grace period: ignore interactions in the first 200ms to prevent
+      // accidental keypresses from canceling the classifier prematurely
+      const GRACE_PERIOD_MS = 200
+      if (Date.now() - permissionPromptStartTimeMs < GRACE_PERIOD_MS) {
+        return
+      }
+      userInteracted = true
+      clearClassifierChecking(ctx.toolUseID)
+      clearClassifierIndicator()
+    },
+    onDismissCheckmark() {
+      if (checkmarkTransitionTimer) {
+        clearTimeout(checkmarkTransitionTimer)
+        checkmarkTransitionTimer = undefined
+        if (checkmarkAbortHandler) {
+          ctx.toolUseContext.abortController.signal.removeEventListener(
+            'abort',
+            checkmarkAbortHandler,
+          )
+          checkmarkAbortHandler = undefined
+        }
+        ctx.removeFromQueue()
+      }
+    },
+    onAbort() {
+      if (!claim()) return
+      if (bridgeCallbacks && bridgeRequestId) {
+        bridgeCallbacks.sendResponse(bridgeRequestId, {
+          behavior: 'deny',
+          message: 'User aborted',
+        })
+        bridgeCallbacks.cancelRequest(bridgeRequestId)
+      }
+      channelUnsubscribe?.()
+      ctx.logCancelled()
+      ctx.logDecision(
+        { decision: 'reject', source: { type: 'user_abort' } },
+        { permissionPromptStartTimeMs },
+      )
+      resolveOnce(ctx.cancelAndAbort(undefined, true))
+    },
+    async onAllow(
+      updatedInput,
+      permissionUpdates: PermissionUpdate[],
+      feedback?: string,
+      contentBlocks?: ContentBlockParam[],
+    ) {
+      if (!claim()) return // atomic check-and-mark before await
+
+      if (bridgeCallbacks && bridgeRequestId) {
+        bridgeCallbacks.sendResponse(bridgeRequestId, {
+          behavior: 'allow',
+          updatedInput,
+          updatedPermissions: permissionUpdates,
+        })
+        bridgeCallbacks.cancelRequest(bridgeRequestId)
+      }
+      channelUnsubscribe?.()
+
+      resolveOnce(
+        await ctx.handleUserAllow(
+          updatedInput,
+          permissionUpdates,
+          feedback,
+          permissionPromptStartTimeMs,
+          contentBlocks,
+          result.decisionReason,
+        ),
+      )
+    },
+    onReject(feedback?: string, contentBlocks?: ContentBlockParam[]) {
+      if (!claim()) return
+
+      if (bridgeCallbacks && bridgeRequestId) {
+        bridgeCallbacks.sendResponse(bridgeRequestId, {
+          behavior: 'deny',
+          message: feedback ?? 'User denied permission',
+        })
+        bridgeCallbacks.cancelRequest(bridgeRequestId)
+      }
+      channelUnsubscribe?.()
+
+      ctx.logDecision(
+        {
+          decision: 'reject',
+          source: { type: 'user_reject', hasFeedback: !!feedback },
+        },
+        { permissionPromptStartTimeMs },
+      )
+      resolveOnce(ctx.cancelAndAbort(feedback, undefined, contentBlocks))
+    },
+    async recheckPermission() {
+      if (isResolved()) return
+      const freshResult = await hasPermissionsToUseTool(
+        ctx.tool,
+        ctx.input,
+        ctx.toolUseContext,
+        ctx.assistantMessage,
+        ctx.toolUseID,
+      )
+      if (freshResult.behavior === 'allow') {
+        // claim() (atomic check-and-mark), not isResolved() — the async
+        // hasPermissionsToUseTool call above opens a window where CCR
+        // could have responded in flight. Matches onAllow/onReject/hook
+        // paths. cancelRequest tells CCR to dismiss its prompt — without
+        // it, the web UI shows a stale prompt for a tool that's already
+        // executing (particularly visible when recheck is triggered by
+        // a CCR-initiated mode switch, the very case this callback exists
+        // for after useReplBridge started calling it).
+        if (!claim()) return
+        if (bridgeCallbacks && bridgeRequestId) {
+          bridgeCallbacks.cancelRequest(bridgeRequestId)
+        }
+        channelUnsubscribe?.()
+        ctx.removeFromQueue()
+        ctx.logDecision({ decision: 'accept', source: 'config' })
+        resolveOnce(ctx.buildAllow(freshResult.updatedInput ?? ctx.input))
+      }
+    },
+  })
+
+  // Race 4: Bridge permission response from CCR (claude.ai)
+  // When the bridge is connected, send the permission request to CCR and
+  // subscribe for a response. Whichever side (CLI or CCR) responds first
+  // wins via claim().
+  //
+  // All tools are forwarded — CCR's generic allow/deny modal handles any
+  // tool, and can return `updatedInput` when it has a dedicated renderer
+  // (e.g. plan edit). Tools whose local dialog injects fields (ReviewArtifact
+  // `selected`, AskUserQuestion `answers`) tolerate the field being missing
+  // so generic remote approval degrades gracefully instead of throwing.
+  if (bridgeCallbacks && bridgeRequestId) {
+    bridgeCallbacks.sendRequest(
+      bridgeRequestId,
+      ctx.tool.name,
+      displayInput,
+      ctx.toolUseID,
+      description,
+      result.suggestions,
+      result.blockedPath,
+    )
+
+    const signal = ctx.toolUseContext.abortController.signal
+    const unsubscribe = bridgeCallbacks.onResponse(
+      bridgeRequestId,
+      response => {
+        if (!claim()) return // Local user/hook/classifier already responded
+        signal.removeEventListener('abort', unsubscribe)
+        clearClassifierChecking(ctx.toolUseID)
+        clearClassifierIndicator()
+        ctx.removeFromQueue()
+        channelUnsubscribe?.()
+
+        if (response.behavior === 'allow') {
+          if (response.updatedPermissions?.length) {
+            void ctx.persistPermissions(response.updatedPermissions)
+          }
+          ctx.logDecision(
+            {
+              decision: 'accept',
+              source: {
+                type: 'user',
+                permanent: !!response.updatedPermissions?.length,
+              },
+            },
+            { permissionPromptStartTimeMs },
+          )
+          resolveOnce(ctx.buildAllow(response.updatedInput ?? displayInput))
+        } else {
+          ctx.logDecision(
+            {
+              decision: 'reject',
+              source: {
+                type: 'user_reject',
+                hasFeedback: !!response.message,
+              },
+            },
+            { permissionPromptStartTimeMs },
+          )
+          resolveOnce(ctx.cancelAndAbort(response.message))
+        }
+      },
+    )
+
+    signal.addEventListener('abort', unsubscribe, { once: true })
+  }
+
+  // Channel permission relay — races alongside the bridge block above. Send a
+  // permission prompt to every active channel (Telegram, iMessage, etc.) via
+  // its MCP send_message tool, then race the reply against local/bridge/hook/
+  // classifier. The inbound "yes abc123" is intercepted in the notification
+  // handler (useManageMCPConnections.ts) BEFORE enqueue, so it never reaches
+  // Claude as a conversation turn.
+  //
+  // Unlike the bridge block, this still guards on `requiresUserInteraction` —
+  // channel replies are pure yes/no with no `updatedInput` path. In practice
+  // the guard is dead code today: all three `requiresUserInteraction` tools
+  // (ExitPlanMode, AskUserQuestion, ReviewArtifact) return `isEnabled()===false`
+  // when channels are configured, so they never reach this handler.
+  //
+  // Fire-and-forget send: if callTool fails (channel down, tool missing),
+  // the subscription never fires and another racer wins. Graceful degradation
+  // — the local dialog is always there as the floor.
+  if (
+    (feature('KAIROS') || feature('KAIROS_CHANNELS')) &&
+    channelCallbacks &&
+    !ctx.tool.requiresUserInteraction?.()
+  ) {
+    const channelRequestId = shortRequestId(ctx.toolUseID)
+    const allowedChannels = getAllowedChannels()
+    const channelClients = filterPermissionRelayClients(
+      ctx.toolUseContext.getAppState().mcp.clients,
+      name => findChannelEntry(name, allowedChannels) !== undefined,
+    )
+
+    if (channelClients.length > 0) {
+      // Outbound is structured too (Kenneth's symmetry ask) — server owns
+      // message formatting for its platform (Telegram markdown, iMessage
+      // rich text, Discord embed). CC sends the RAW parts; server composes.
+      // The old callTool('send_message', {text,content,message}) triple-key
+      // hack is gone — no more guessing which arg name each plugin takes.
+      const params: ChannelPermissionRequestParams = {
+        request_id: channelRequestId,
+        tool_name: ctx.tool.name,
+        description,
+        input_preview: truncateForPreview(displayInput),
+      }
+
+      for (const client of channelClients) {
+        if (client.type !== 'connected') continue // refine for TS
+        void client.client
+          .notification({
+            method: CHANNEL_PERMISSION_REQUEST_METHOD,
+            params,
+          })
+          .catch(e => {
+            logForDebugging(
+              `Channel permission_request failed for ${client.name}: ${errorMessage(e)}`,
+              { level: 'error' },
+            )
+          })
+      }
+
+      const channelSignal = ctx.toolUseContext.abortController.signal
+      // Wrap so BOTH the map delete AND the abort-listener teardown happen
+      // at every call site. The 6 channelUnsubscribe?.() sites after local/
+      // hook/classifier wins previously only deleted the map entry — the
+      // dead closure stayed registered on the session-scoped abort signal
+      // until the session ended. Not a functional bug (Map.delete is
+      // idempotent), but it held the closure alive.
+      const mapUnsub = channelCallbacks.onResponse(
+        channelRequestId,
+        response => {
+          if (!claim()) return // Another racer won
+          channelUnsubscribe?.() // both: map delete + listener remove
+          clearClassifierChecking(ctx.toolUseID)
+          clearClassifierIndicator()
+          ctx.removeFromQueue()
+          // Bridge is the other remote — tell it we're done.
+          if (bridgeCallbacks && bridgeRequestId) {
+            bridgeCallbacks.cancelRequest(bridgeRequestId)
+          }
+
+          if (response.behavior === 'allow') {
+            ctx.logDecision(
+              {
+                decision: 'accept',
+                source: { type: 'user', permanent: false },
+              },
+              { permissionPromptStartTimeMs },
+            )
+            resolveOnce(ctx.buildAllow(displayInput))
+          } else {
+            ctx.logDecision(
+              {
+                decision: 'reject',
+                source: { type: 'user_reject', hasFeedback: false },
+              },
+              { permissionPromptStartTimeMs },
+            )
+            resolveOnce(
+              ctx.cancelAndAbort(`Denied via channel ${response.fromServer}`),
+            )
+          }
+        },
+      )
+      channelUnsubscribe = () => {
+        mapUnsub()
+        channelSignal.removeEventListener('abort', channelUnsubscribe!)
+      }
+
+      channelSignal.addEventListener('abort', channelUnsubscribe, {
+        once: true,
+      })
+    }
+  }
+
+  // Skip hooks if they were already awaited in the coordinator branch above
+  if (!awaitAutomatedChecksBeforeDialog) {
+    // Execute PermissionRequest hooks asynchronously
+    // If hook returns a decision before user responds, apply it
+    void (async () => {
+      if (isResolved()) return
+      const currentAppState = ctx.toolUseContext.getAppState()
+      const hookDecision = await ctx.runHooks(
+        currentAppState.toolPermissionContext.mode,
+        result.suggestions,
+        result.updatedInput,
+        permissionPromptStartTimeMs,
+      )
+      if (!hookDecision || !claim()) return
+      if (bridgeCallbacks && bridgeRequestId) {
+        bridgeCallbacks.cancelRequest(bridgeRequestId)
+      }
+      channelUnsubscribe?.()
+      ctx.removeFromQueue()
+      resolveOnce(hookDecision)
+    })()
+  }
+
+  // Execute bash classifier check asynchronously (if applicable)
+  if (
+    feature('BASH_CLASSIFIER') &&
+    result.pendingClassifierCheck &&
+    ctx.tool.name === BASH_TOOL_NAME &&
+    !awaitAutomatedChecksBeforeDialog
+  ) {
+    // UI indicator for "classifier running" — set here (not in
+    // toolExecution.ts) so commands that auto-allow via prefix rules
+    // don't flash the indicator for a split second before allow returns.
+    setClassifierChecking(ctx.toolUseID)
+    void executeAsyncClassifierCheck(
+      result.pendingClassifierCheck,
+      ctx.toolUseContext.abortController.signal,
+      ctx.toolUseContext.options.isNonInteractiveSession,
+      {
+        shouldContinue: () => !isResolved() && !userInteracted,
+        onComplete: () => {
+          clearClassifierChecking(ctx.toolUseID)
+          clearClassifierIndicator()
+        },
+        onAllow: decisionReason => {
+          if (!claim()) return
+          if (bridgeCallbacks && bridgeRequestId) {
+            bridgeCallbacks.cancelRequest(bridgeRequestId)
+          }
+          channelUnsubscribe?.()
+          clearClassifierChecking(ctx.toolUseID)
+
+          const matchedRule =
+            decisionReason.type === 'classifier'
+              ? (decisionReason.reason.match(
+                  /^Allowed by prompt rule: "(.+)"$/,
+                )?.[1] ?? decisionReason.reason)
+              : undefined
+
+          // Show auto-approved transition with dimmed options
+          if (feature('TRANSCRIPT_CLASSIFIER')) {
+            ctx.updateQueueItem({
+              classifierCheckInProgress: false,
+              classifierAutoApproved: true,
+              classifierMatchedRule: matchedRule,
+            })
+          }
+
+          if (
+            feature('TRANSCRIPT_CLASSIFIER') &&
+            decisionReason.type === 'classifier'
+          ) {
+            if (decisionReason.classifier === 'auto-mode') {
+              setYoloClassifierApproval(ctx.toolUseID, decisionReason.reason)
+            } else if (matchedRule) {
+              setClassifierApproval(ctx.toolUseID, matchedRule)
+            }
+          }
+
+          ctx.logDecision(
+            { decision: 'accept', source: { type: 'classifier' } },
+            { permissionPromptStartTimeMs },
+          )
+          resolveOnce(ctx.buildAllow(ctx.input, { decisionReason }))
+
+          // Keep checkmark visible, then remove dialog.
+          // 3s if terminal is focused (user can see it), 1s if not.
+          // User can dismiss early with Esc via onDismissCheckmark.
+          const signal = ctx.toolUseContext.abortController.signal
+          checkmarkAbortHandler = () => {
+            if (checkmarkTransitionTimer) {
+              clearTimeout(checkmarkTransitionTimer)
+              checkmarkTransitionTimer = undefined
+              // Sibling Bash error can fire this (StreamingToolExecutor
+              // cascades via siblingAbortController) — must drop the
+              // cosmetic ✓ dialog or it blocks the next queued item.
+              ctx.removeFromQueue()
+            }
+          }
+          const checkmarkMs = getTerminalFocused() ? 3000 : 1000
+          checkmarkTransitionTimer = setTimeout(() => {
+            checkmarkTransitionTimer = undefined
+            if (checkmarkAbortHandler) {
+              signal.removeEventListener('abort', checkmarkAbortHandler)
+              checkmarkAbortHandler = undefined
+            }
+            ctx.removeFromQueue()
+          }, checkmarkMs)
+          signal.addEventListener('abort', checkmarkAbortHandler, {
+            once: true,
+          })
+        },
+      },
+    ).catch(error => {
+      // Log classifier API errors for debugging but don't propagate them as interruptions
+      // These errors can be network failures, rate limits, or model issues - not user cancellations
+      logForDebugging(`Async classifier check failed: ${errorMessage(error)}`, {
+        level: 'error',
+      })
+    })
+  }
+}
+
+// --
+
+export { handleInteractivePermission }
+export type { InteractivePermissionParams }

src/hooks/toolPermission/handlers/swarmWorkerHandler.ts

@@ -0,0 +1,159 @@
+import { feature } from 'bun:bundle'
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources/messages.mjs'
+import type { PendingClassifierCheck } from '../../../types/permissions.js'
+import { isAgentSwarmsEnabled } from '../../../utils/agentSwarmsEnabled.js'
+import { toError } from '../../../utils/errors.js'
+import { logError } from '../../../utils/log.js'
+import type { PermissionDecision } from '../../../utils/permissions/PermissionResult.js'
+import type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js'
+import {
+  createPermissionRequest,
+  isSwarmWorker,
+  sendPermissionRequestViaMailbox,
+} from '../../../utils/swarm/permissionSync.js'
+import { registerPermissionCallback } from '../../useSwarmPermissionPoller.js'
+import type { PermissionContext } from '../PermissionContext.js'
+import { createResolveOnce } from '../PermissionContext.js'
+
+type SwarmWorkerPermissionParams = {
+  ctx: PermissionContext
+  description: string
+  pendingClassifierCheck?: PendingClassifierCheck | undefined
+  updatedInput: Record<string, unknown> | undefined
+  suggestions: PermissionUpdate[] | undefined
+}
+
+/**
+ * Handles the swarm worker permission flow.
+ *
+ * When running as a swarm worker:
+ * 1. Tries classifier auto-approval for bash commands
+ * 2. Forwards the permission request to the leader via mailbox
+ * 3. Registers callbacks for when the leader responds
+ * 4. Sets the pending indicator while waiting
+ *
+ * Returns a PermissionDecision if the classifier auto-approves,
+ * or a Promise that resolves when the leader responds.
+ * Returns null if swarms are not enabled or this is not a swarm worker,
+ * so the caller can fall through to interactive handling.
+ */
+async function handleSwarmWorkerPermission(
+  params: SwarmWorkerPermissionParams,
+): Promise<PermissionDecision | null> {
+  if (!isAgentSwarmsEnabled() || !isSwarmWorker()) {
+    return null
+  }
+
+  const { ctx, description, updatedInput, suggestions } = params
+
+  // For bash commands, try classifier auto-approval before forwarding to
+  // the leader. Agents await the classifier result (rather than racing it
+  // against user interaction like the main agent).
+  const classifierResult = feature('BASH_CLASSIFIER')
+    ? await ctx.tryClassifier?.(params.pendingClassifierCheck, updatedInput)
+    : null
+  if (classifierResult) {
+    return classifierResult
+  }
+
+  // Forward permission request to the leader via mailbox
+  try {
+    const clearPendingRequest = (): void =>
+      ctx.toolUseContext.setAppState(prev => ({
+        ...prev,
+        pendingWorkerRequest: null,
+      }))
+
+    const decision = await new Promise<PermissionDecision>(resolve => {
+      const { resolve: resolveOnce, claim } = createResolveOnce(resolve)
+
+      // Create the permission request
+      const request = createPermissionRequest({
+        toolName: ctx.tool.name,
+        toolUseId: ctx.toolUseID,
+        input: ctx.input,
+        description,
+        permissionSuggestions: suggestions,
+      })
+
+      // Register callback BEFORE sending the request to avoid race condition
+      // where leader responds before callback is registered
+      registerPermissionCallback({
+        requestId: request.id,
+        toolUseId: ctx.toolUseID,
+        async onAllow(
+          allowedInput: Record<string, unknown> | undefined,
+          permissionUpdates: PermissionUpdate[],
+          feedback?: string,
+          contentBlocks?: ContentBlockParam[],
+        ) {
+          if (!claim()) return // atomic check-and-mark before await
+          clearPendingRequest()
+
+          // Merge the updated input with the original input
+          const finalInput =
+            allowedInput && Object.keys(allowedInput).length > 0
+              ? allowedInput
+              : ctx.input
+
+          resolveOnce(
+            await ctx.handleUserAllow(
+              finalInput,
+              permissionUpdates,
+              feedback,
+              undefined,
+              contentBlocks,
+            ),
+          )
+        },
+        onReject(feedback?: string, contentBlocks?: ContentBlockParam[]) {
+          if (!claim()) return
+          clearPendingRequest()
+
+          ctx.logDecision({
+            decision: 'reject',
+            source: { type: 'user_reject', hasFeedback: !!feedback },
+          })
+
+          resolveOnce(ctx.cancelAndAbort(feedback, undefined, contentBlocks))
+        },
+      })
+
+      // Now that callback is registered, send the request to the leader
+      void sendPermissionRequestViaMailbox(request)
+
+      // Show visual indicator that we're waiting for leader approval
+      ctx.toolUseContext.setAppState(prev => ({
+        ...prev,
+        pendingWorkerRequest: {
+          toolName: ctx.tool.name,
+          toolUseId: ctx.toolUseID,
+          description,
+        },
+      }))
+
+      // If the abort signal fires while waiting for the leader response,
+      // resolve the promise with a cancel decision so it does not hang.
+      ctx.toolUseContext.abortController.signal.addEventListener(
+        'abort',
+        () => {
+          if (!claim()) return
+          clearPendingRequest()
+          ctx.logCancelled()
+          resolveOnce(ctx.cancelAndAbort(undefined, true))
+        },
+        { once: true },
+      )
+    })
+
+    return decision
+  } catch (error) {
+    // If swarm permission submission fails, fall back to local handling
+    logError(toError(error))
+    // Continue to local UI handling below
+    return null
+  }
+}
+
+export { handleSwarmWorkerPermission }
+export type { SwarmWorkerPermissionParams }

src/hooks/toolPermission/permissionLogging.ts

@@ -0,0 +1,238 @@
+// Centralized analytics/telemetry logging for tool permission decisions.
+// All permission approve/reject events flow through logPermissionDecision(),
+// which fans out to Statsig analytics, OTel telemetry, and code-edit metrics.
+import { feature } from 'bun:bundle'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from 'src/services/analytics/index.js'
+import { sanitizeToolNameForAnalytics } from 'src/services/analytics/metadata.js'
+import { getCodeEditToolDecisionCounter } from '../../bootstrap/state.js'
+import type { Tool as ToolType, ToolUseContext } from '../../Tool.js'
+import { getLanguageName } from '../../utils/cliHighlight.js'
+import { SandboxManager } from '../../utils/sandbox/sandbox-adapter.js'
+import { logOTelEvent } from '../../utils/telemetry/events.js'
+import type {
+  PermissionApprovalSource,
+  PermissionRejectionSource,
+} from './PermissionContext.js'
+
+type PermissionLogContext = {
+  tool: ToolType
+  input: unknown
+  toolUseContext: ToolUseContext
+  messageId: string
+  toolUseID: string
+}
+
+// Discriminated union: 'accept' pairs with approval sources, 'reject' with rejection sources
+type PermissionDecisionArgs =
+  | { decision: 'accept'; source: PermissionApprovalSource | 'config' }
+  | { decision: 'reject'; source: PermissionRejectionSource | 'config' }
+
+const CODE_EDITING_TOOLS = ['Edit', 'Write', 'NotebookEdit']
+
+function isCodeEditingTool(toolName: string): boolean {
+  return CODE_EDITING_TOOLS.includes(toolName)
+}
+
+// Builds OTel counter attributes for code editing tools, enriching with
+// language when the tool's target file path can be extracted from input
+async function buildCodeEditToolAttributes(
+  tool: ToolType,
+  input: unknown,
+  decision: 'accept' | 'reject',
+  source: string,
+): Promise<Record<string, string>> {
+  // Derive language from file path if the tool exposes one (e.g., Edit, Write)
+  let language: string | undefined
+  if (tool.getPath && input) {
+    const parseResult = tool.inputSchema.safeParse(input)
+    if (parseResult.success) {
+      const filePath = tool.getPath(parseResult.data)
+      if (filePath) {
+        language = await getLanguageName(filePath)
+      }
+    }
+  }
+
+  return {
+    decision,
+    source,
+    tool_name: tool.name,
+    ...(language && { language }),
+  }
+}
+
+// Flattens structured source into a string label for analytics/OTel events
+function sourceToString(
+  source: PermissionApprovalSource | PermissionRejectionSource,
+): string {
+  if (
+    (feature('BASH_CLASSIFIER') || feature('TRANSCRIPT_CLASSIFIER')) &&
+    source.type === 'classifier'
+  ) {
+    return 'classifier'
+  }
+  switch (source.type) {
+    case 'hook':
+      return 'hook'
+    case 'user':
+      return source.permanent ? 'user_permanent' : 'user_temporary'
+    case 'user_abort':
+      return 'user_abort'
+    case 'user_reject':
+      return 'user_reject'
+    default:
+      return 'unknown'
+  }
+}
+
+function baseMetadata(
+  messageId: string,
+  toolName: string,
+  waitMs: number | undefined,
+): { [key: string]: boolean | number | undefined } {
+  return {
+    messageID:
+      messageId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    toolName: sanitizeToolNameForAnalytics(toolName),
+    sandboxEnabled: SandboxManager.isSandboxingEnabled(),
+    // Only include wait time when the user was actually prompted (not auto-approved)
+    ...(waitMs !== undefined && { waiting_for_user_permission_ms: waitMs }),
+  }
+}
+
+// Emits a distinct analytics event name per approval source for funnel analysis
+function logApprovalEvent(
+  tool: ToolType,
+  messageId: string,
+  source: PermissionApprovalSource | 'config',
+  waitMs: number | undefined,
+): void {
+  if (source === 'config') {
+    // Auto-approved by allowlist in settings -- no user wait time
+    logEvent(
+      'tengu_tool_use_granted_in_config',
+      baseMetadata(messageId, tool.name, undefined),
+    )
+    return
+  }
+  if (
+    (feature('BASH_CLASSIFIER') || feature('TRANSCRIPT_CLASSIFIER')) &&
+    source.type === 'classifier'
+  ) {
+    logEvent(
+      'tengu_tool_use_granted_by_classifier',
+      baseMetadata(messageId, tool.name, waitMs),
+    )
+    return
+  }
+  switch (source.type) {
+    case 'user':
+      logEvent(
+        source.permanent
+          ? 'tengu_tool_use_granted_in_prompt_permanent'
+          : 'tengu_tool_use_granted_in_prompt_temporary',
+        baseMetadata(messageId, tool.name, waitMs),
+      )
+      break
+    case 'hook':
+      logEvent('tengu_tool_use_granted_by_permission_hook', {
+        ...baseMetadata(messageId, tool.name, waitMs),
+        permanent: source.permanent ?? false,
+      })
+      break
+    default:
+      break
+  }
+}
+
+// Rejections share a single event name, differentiated by metadata fields
+function logRejectionEvent(
+  tool: ToolType,
+  messageId: string,
+  source: PermissionRejectionSource | 'config',
+  waitMs: number | undefined,
+): void {
+  if (source === 'config') {
+    // Denied by denylist in settings
+    logEvent(
+      'tengu_tool_use_denied_in_config',
+      baseMetadata(messageId, tool.name, undefined),
+    )
+    return
+  }
+  logEvent('tengu_tool_use_rejected_in_prompt', {
+    ...baseMetadata(messageId, tool.name, waitMs),
+    // Distinguish hook rejections from user rejections via separate fields
+    ...(source.type === 'hook'
+      ? { isHook: true }
+      : {
+          hasFeedback:
+            source.type === 'user_reject' ? source.hasFeedback : false,
+        }),
+  })
+}
+
+// Single entry point for all permission decision logging. Called by permission
+// handlers after every approve/reject. Fans out to: analytics events, OTel
+// telemetry, code-edit OTel counters, and toolUseContext decision storage.
+function logPermissionDecision(
+  ctx: PermissionLogContext,
+  args: PermissionDecisionArgs,
+  permissionPromptStartTimeMs?: number,
+): void {
+  const { tool, input, toolUseContext, messageId, toolUseID } = ctx
+  const { decision, source } = args
+
+  const waiting_for_user_permission_ms =
+    permissionPromptStartTimeMs !== undefined
+      ? Date.now() - permissionPromptStartTimeMs
+      : undefined
+
+  // Log the analytics event
+  if (args.decision === 'accept') {
+    logApprovalEvent(
+      tool,
+      messageId,
+      args.source,
+      waiting_for_user_permission_ms,
+    )
+  } else {
+    logRejectionEvent(
+      tool,
+      messageId,
+      args.source,
+      waiting_for_user_permission_ms,
+    )
+  }
+
+  const sourceString = source === 'config' ? 'config' : sourceToString(source)
+
+  // Track code editing tool metrics
+  if (isCodeEditingTool(tool.name)) {
+    void buildCodeEditToolAttributes(tool, input, decision, sourceString).then(
+      attributes => getCodeEditToolDecisionCounter()?.add(1, attributes),
+    )
+  }
+
+  // Persist decision on the context so downstream code can inspect what happened
+  if (!toolUseContext.toolDecisions) {
+    toolUseContext.toolDecisions = new Map()
+  }
+  toolUseContext.toolDecisions.set(toolUseID, {
+    source: sourceString,
+    decision,
+    timestamp: Date.now(),
+  })
+
+  void logOTelEvent('tool_decision', {
+    decision,
+    source: sourceString,
+    tool_name: sanitizeToolNameForAnalytics(tool.name),
+  })
+}
+
+export { isCodeEditingTool, buildCodeEditToolAttributes, logPermissionDecision }
+export type { PermissionLogContext, PermissionDecisionArgs }

src/ink/components/AlternateScreen.tsx

@@ -0,0 +1,80 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { type PropsWithChildren, useContext, useInsertionEffect } from 'react';
+import instances from '../instances.js';
+import { DISABLE_MOUSE_TRACKING, ENABLE_MOUSE_TRACKING, ENTER_ALT_SCREEN, EXIT_ALT_SCREEN } from '../termio/dec.js';
+import { TerminalWriteContext } from '../useTerminalNotification.js';
+import Box from './Box.js';
+import { TerminalSizeContext } from './TerminalSizeContext.js';
+type Props = PropsWithChildren<{
+  /** Enable SGR mouse tracking (wheel + click/drag). Default true. */
+  mouseTracking?: boolean;
+}>;
+
+/**
+ * Run children in the terminal's alternate screen buffer, constrained to
+ * the viewport height. While mounted:
+ *
+ * - Enters the alt screen (DEC 1049), clears it, homes the cursor
+ * - Constrains its own height to the terminal row count, so overflow must
+ *   be handled via `overflow: scroll` / flexbox (no native scrollback)
+ * - Optionally enables SGR mouse tracking (wheel + click/drag) — events
+ *   surface as `ParsedKey` (wheel) and update the Ink instance's
+ *   selection state (click/drag)
+ *
+ * On unmount, disables mouse tracking and exits the alt screen, restoring
+ * the main screen's content. Safe for use in ctrl-o transcript overlays
+ * and similar temporary fullscreen views — the main screen is preserved.
+ *
+ * Notifies the Ink instance via `setAltScreenActive()` so the renderer
+ * keeps the cursor inside the viewport (preventing the cursor-restore LF
+ * from scrolling content) and so signal-exit cleanup can exit the alt
+ * screen if the component's own unmount doesn't run.
+ */
+export function AlternateScreen(t0) {
+  const $ = _c(7);
+  const {
+    children,
+    mouseTracking: t1
+  } = t0;
+  const mouseTracking = t1 === undefined ? true : t1;
+  const size = useContext(TerminalSizeContext);
+  const writeRaw = useContext(TerminalWriteContext);
+  let t2;
+  let t3;
+  if ($[0] !== mouseTracking || $[1] !== writeRaw) {
+    t2 = () => {
+      const ink = instances.get(process.stdout);
+      if (!writeRaw) {
+        return;
+      }
+      writeRaw(ENTER_ALT_SCREEN + "\x1B[2J\x1B[H" + (mouseTracking ? ENABLE_MOUSE_TRACKING : ""));
+      ink?.setAltScreenActive(true, mouseTracking);
+      return () => {
+        ink?.setAltScreenActive(false);
+        ink?.clearTextSelection();
+        writeRaw((mouseTracking ? DISABLE_MOUSE_TRACKING : "") + EXIT_ALT_SCREEN);
+      };
+    };
+    t3 = [writeRaw, mouseTracking];
+    $[0] = mouseTracking;
+    $[1] = writeRaw;
+    $[2] = t2;
+    $[3] = t3;
+  } else {
+    t2 = $[2];
+    t3 = $[3];
+  }
+  useInsertionEffect(t2, t3);
+  const t4 = size?.rows ?? 24;
+  let t5;
+  if ($[4] !== children || $[5] !== t4) {
+    t5 = <Box flexDirection="column" height={t4} width="100%" flexShrink={0}>{children}</Box>;
+    $[4] = children;
+    $[5] = t4;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  return t5;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/ink/components/App.tsx

@@ -0,0 +1,658 @@
+import React, { PureComponent, type ReactNode } from 'react';
+import { updateLastInteractionTime } from '../../bootstrap/state.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { stopCapturingEarlyInput } from '../../utils/earlyInput.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+import { isMouseClicksDisabled } from '../../utils/fullscreen.js';
+import { logError } from '../../utils/log.js';
+import { EventEmitter } from '../events/emitter.js';
+import { InputEvent } from '../events/input-event.js';
+import { TerminalFocusEvent } from '../events/terminal-focus-event.js';
+import { INITIAL_STATE, type ParsedInput, type ParsedKey, type ParsedMouse, parseMultipleKeypresses } from '../parse-keypress.js';
+import reconciler from '../reconciler.js';
+import { finishSelection, hasSelection, type SelectionState, startSelection } from '../selection.js';
+import { isXtermJs, setXtversionName, supportsExtendedKeys } from '../terminal.js';
+import { getTerminalFocused, setTerminalFocused } from '../terminal-focus-state.js';
+import { TerminalQuerier, xtversion } from '../terminal-querier.js';
+import { DISABLE_KITTY_KEYBOARD, DISABLE_MODIFY_OTHER_KEYS, ENABLE_KITTY_KEYBOARD, ENABLE_MODIFY_OTHER_KEYS, FOCUS_IN, FOCUS_OUT } from '../termio/csi.js';
+import { DBP, DFE, DISABLE_MOUSE_TRACKING, EBP, EFE, HIDE_CURSOR, SHOW_CURSOR } from '../termio/dec.js';
+import AppContext from './AppContext.js';
+import { ClockProvider } from './ClockContext.js';
+import CursorDeclarationContext, { type CursorDeclarationSetter } from './CursorDeclarationContext.js';
+import ErrorOverview from './ErrorOverview.js';
+import StdinContext from './StdinContext.js';
+import { TerminalFocusProvider } from './TerminalFocusContext.js';
+import { TerminalSizeContext } from './TerminalSizeContext.js';
+
+// Platforms that support Unix-style process suspension (SIGSTOP/SIGCONT)
+const SUPPORTS_SUSPEND = process.platform !== 'win32';
+
+// After this many milliseconds of stdin silence, the next chunk triggers
+// a terminal mode re-assert (mouse tracking). Catches tmux detach→attach,
+// ssh reconnect, and laptop wake — the terminal resets DEC private modes
+// but no signal reaches us. 5s is well above normal inter-keystroke gaps
+// but short enough that the first scroll after reattach works.
+const STDIN_RESUME_GAP_MS = 5000;
+type Props = {
+  readonly children: ReactNode;
+  readonly stdin: NodeJS.ReadStream;
+  readonly stdout: NodeJS.WriteStream;
+  readonly stderr: NodeJS.WriteStream;
+  readonly exitOnCtrlC: boolean;
+  readonly onExit: (error?: Error) => void;
+  readonly terminalColumns: number;
+  readonly terminalRows: number;
+  // Text selection state. App mutates this directly from mouse events
+  // and calls onSelectionChange to trigger a repaint. Mouse events only
+  // arrive when <AlternateScreen> (or similar) enables mouse tracking,
+  // so the handler is always wired but dormant until tracking is on.
+  readonly selection: SelectionState;
+  readonly onSelectionChange: () => void;
+  // Dispatch a click at (col, row) — hit-tests the DOM tree and bubbles
+  // onClick handlers. Returns true if a DOM handler consumed the click.
+  // No-op (returns false) outside fullscreen mode (Ink.dispatchClick
+  // gates on altScreenActive).
+  readonly onClickAt: (col: number, row: number) => boolean;
+  // Dispatch hover (onMouseEnter/onMouseLeave) as the pointer moves over
+  // DOM elements. Called for mode-1003 motion events with no button held.
+  // No-op outside fullscreen (Ink.dispatchHover gates on altScreenActive).
+  readonly onHoverAt: (col: number, row: number) => void;
+  // Look up the OSC 8 hyperlink at (col, row) synchronously at click
+  // time. Returns the URL or undefined. The browser-open is deferred by
+  // MULTI_CLICK_TIMEOUT_MS so double-click can cancel it.
+  readonly getHyperlinkAt: (col: number, row: number) => string | undefined;
+  // Open a hyperlink URL in the browser. Called after the timer fires.
+  readonly onOpenHyperlink: (url: string) => void;
+  // Called on double/triple-click PRESS at (col, row). count=2 selects
+  // the word under the cursor; count=3 selects the line. Ink reads the
+  // screen buffer to find word/line boundaries and mutates selection,
+  // setting isDragging=true so a subsequent drag extends by word/line.
+  readonly onMultiClick: (col: number, row: number, count: 2 | 3) => void;
+  // Called on drag-motion. Mode-aware: char mode updates focus to the
+  // exact cell; word/line mode snaps to word/line boundaries. Needs
+  // screen-buffer access (word boundaries) so lives on Ink, not here.
+  readonly onSelectionDrag: (col: number, row: number) => void;
+  // Called when stdin data arrives after a >STDIN_RESUME_GAP_MS gap.
+  // Ink re-asserts terminal modes: extended key reporting, and (when in
+  // fullscreen) re-enters alt-screen + mouse tracking. Idempotent on the
+  // terminal side. Optional so testing.tsx doesn't need to stub it.
+  readonly onStdinResume?: () => void;
+  // Receives the declared native-cursor position from useDeclaredCursor
+  // so ink.tsx can park the terminal cursor there after each frame.
+  // Enables IME composition at the input caret and lets screen readers /
+  // magnifiers track the input. Optional so testing.tsx doesn't stub it.
+  readonly onCursorDeclaration?: CursorDeclarationSetter;
+  // Dispatch a keyboard event through the DOM tree. Called for each
+  // parsed key alongside the legacy EventEmitter path.
+  readonly dispatchKeyboardEvent: (parsedKey: ParsedKey) => void;
+};
+
+// Multi-click detection thresholds. 500ms is the macOS default; a small
+// position tolerance allows for trackpad jitter between clicks.
+const MULTI_CLICK_TIMEOUT_MS = 500;
+const MULTI_CLICK_DISTANCE = 1;
+type State = {
+  readonly error?: Error;
+};
+
+// Root component for all Ink apps
+// It renders stdin and stdout contexts, so that children can access them if needed
+// It also handles Ctrl+C exiting and cursor visibility
+export default class App extends PureComponent<Props, State> {
+  static displayName = 'InternalApp';
+  static getDerivedStateFromError(error: Error) {
+    return {
+      error
+    };
+  }
+  override state = {
+    error: undefined
+  };
+
+  // Count how many components enabled raw mode to avoid disabling
+  // raw mode until all components don't need it anymore
+  rawModeEnabledCount = 0;
+  internal_eventEmitter = new EventEmitter();
+  keyParseState = INITIAL_STATE;
+  // Timer for flushing incomplete escape sequences
+  incompleteEscapeTimer: NodeJS.Timeout | null = null;
+  // Timeout durations for incomplete sequences (ms)
+  readonly NORMAL_TIMEOUT = 50; // Short timeout for regular esc sequences
+  readonly PASTE_TIMEOUT = 500; // Longer timeout for paste operations
+
+  // Terminal query/response dispatch. Responses arrive on stdin (parsed
+  // out by parse-keypress) and are routed to pending promise resolvers.
+  querier = new TerminalQuerier(this.props.stdout);
+
+  // Multi-click tracking for double/triple-click text selection. A click
+  // within MULTI_CLICK_TIMEOUT_MS and MULTI_CLICK_DISTANCE of the previous
+  // click increments clickCount; otherwise it resets to 1.
+  lastClickTime = 0;
+  lastClickCol = -1;
+  lastClickRow = -1;
+  clickCount = 0;
+  // Deferred hyperlink-open timer — cancelled if a second click arrives
+  // within MULTI_CLICK_TIMEOUT_MS (so double-clicking a hyperlink selects
+  // the word without also opening the browser). DOM onClick dispatch is
+  // NOT deferred — it returns true from onClickAt and skips this timer.
+  pendingHyperlinkTimer: ReturnType<typeof setTimeout> | null = null;
+  // Last mode-1003 motion position. Terminals already dedupe to cell
+  // granularity but this also lets us skip dispatchHover entirely on
+  // repeat events (drag-then-release at same cell, etc.).
+  lastHoverCol = -1;
+  lastHoverRow = -1;
+
+  // Timestamp of last stdin chunk. Used to detect long gaps (tmux attach,
+  // ssh reconnect, laptop wake) and trigger terminal mode re-assert.
+  // Initialized to now so startup doesn't false-trigger.
+  lastStdinTime = Date.now();
+
+  // Determines if TTY is supported on the provided stdin
+  isRawModeSupported(): boolean {
+    return this.props.stdin.isTTY;
+  }
+  override render() {
+    return <TerminalSizeContext.Provider value={{
+      columns: this.props.terminalColumns,
+      rows: this.props.terminalRows
+    }}>
+        <AppContext.Provider value={{
+        exit: this.handleExit
+      }}>
+          <StdinContext.Provider value={{
+          stdin: this.props.stdin,
+          setRawMode: this.handleSetRawMode,
+          isRawModeSupported: this.isRawModeSupported(),
+          internal_exitOnCtrlC: this.props.exitOnCtrlC,
+          internal_eventEmitter: this.internal_eventEmitter,
+          internal_querier: this.querier
+        }}>
+            <TerminalFocusProvider>
+              <ClockProvider>
+                <CursorDeclarationContext.Provider value={this.props.onCursorDeclaration ?? (() => {})}>
+                  {this.state.error ? <ErrorOverview error={this.state.error as Error} /> : this.props.children}
+                </CursorDeclarationContext.Provider>
+              </ClockProvider>
+            </TerminalFocusProvider>
+          </StdinContext.Provider>
+        </AppContext.Provider>
+      </TerminalSizeContext.Provider>;
+  }
+  override componentDidMount() {
+    // In accessibility mode, keep the native cursor visible for screen magnifiers and other tools
+    if (this.props.stdout.isTTY && !isEnvTruthy(process.env.CLAUDE_CODE_ACCESSIBILITY)) {
+      this.props.stdout.write(HIDE_CURSOR);
+    }
+  }
+  override componentWillUnmount() {
+    if (this.props.stdout.isTTY) {
+      this.props.stdout.write(SHOW_CURSOR);
+    }
+
+    // Clear any pending timers
+    if (this.incompleteEscapeTimer) {
+      clearTimeout(this.incompleteEscapeTimer);
+      this.incompleteEscapeTimer = null;
+    }
+    if (this.pendingHyperlinkTimer) {
+      clearTimeout(this.pendingHyperlinkTimer);
+      this.pendingHyperlinkTimer = null;
+    }
+    // ignore calling setRawMode on an handle stdin it cannot be called
+    if (this.isRawModeSupported()) {
+      this.handleSetRawMode(false);
+    }
+  }
+  override componentDidCatch(error: Error) {
+    this.handleExit(error);
+  }
+  handleSetRawMode = (isEnabled: boolean): void => {
+    const {
+      stdin
+    } = this.props;
+    if (!this.isRawModeSupported()) {
+      if (stdin === process.stdin) {
+        throw new Error('Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported');
+      } else {
+        throw new Error('Raw mode is not supported on the stdin provided to Ink.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported');
+      }
+    }
+    stdin.setEncoding('utf8');
+    if (isEnabled) {
+      // Ensure raw mode is enabled only once
+      if (this.rawModeEnabledCount === 0) {
+        // Stop early input capture right before we add our own readable handler.
+        // Both use the same stdin 'readable' + read() pattern, so they can't
+        // coexist -- our handler would drain stdin before Ink's can see it.
+        // The buffered text is preserved for REPL.tsx via consumeEarlyInput().
+        stopCapturingEarlyInput();
+        stdin.ref();
+        stdin.setRawMode(true);
+        stdin.addListener('readable', this.handleReadable);
+        // Enable bracketed paste mode
+        this.props.stdout.write(EBP);
+        // Enable terminal focus reporting (DECSET 1004)
+        this.props.stdout.write(EFE);
+        // Enable extended key reporting so ctrl+shift+<letter> is
+        // distinguishable from ctrl+<letter>. We write both the kitty stack
+        // push (CSI >1u) and xterm modifyOtherKeys level 2 (CSI >4;2m) —
+        // terminals honor whichever they implement (tmux only accepts the
+        // latter).
+        if (supportsExtendedKeys()) {
+          this.props.stdout.write(ENABLE_KITTY_KEYBOARD);
+          this.props.stdout.write(ENABLE_MODIFY_OTHER_KEYS);
+        }
+        // Probe terminal identity. XTVERSION survives SSH (query/reply goes
+        // through the pty), unlike TERM_PROGRAM. Used for wheel-scroll base
+        // detection when env vars are absent. Fire-and-forget: the DA1
+        // sentinel bounds the round-trip, and if the terminal ignores the
+        // query, flush() still resolves and name stays undefined.
+        // Deferred to next tick so it fires AFTER the current synchronous
+        // init sequence completes — avoids interleaving with alt-screen/mouse
+        // tracking enable writes that may happen in the same render cycle.
+        setImmediate(() => {
+          void Promise.all([this.querier.send(xtversion()), this.querier.flush()]).then(([r]) => {
+            if (r) {
+              setXtversionName(r.name);
+              logForDebugging(`XTVERSION: terminal identified as "${r.name}"`);
+            } else {
+              logForDebugging('XTVERSION: no reply (terminal ignored query)');
+            }
+          });
+        });
+      }
+      this.rawModeEnabledCount++;
+      return;
+    }
+
+    // Disable raw mode only when no components left that are using it
+    if (--this.rawModeEnabledCount === 0) {
+      this.props.stdout.write(DISABLE_MODIFY_OTHER_KEYS);
+      this.props.stdout.write(DISABLE_KITTY_KEYBOARD);
+      // Disable terminal focus reporting (DECSET 1004)
+      this.props.stdout.write(DFE);
+      // Disable bracketed paste mode
+      this.props.stdout.write(DBP);
+      stdin.setRawMode(false);
+      stdin.removeListener('readable', this.handleReadable);
+      stdin.unref();
+    }
+  };
+
+  // Helper to flush incomplete escape sequences
+  flushIncomplete = (): void => {
+    // Clear the timer reference
+    this.incompleteEscapeTimer = null;
+
+    // Only proceed if we have incomplete sequences
+    if (!this.keyParseState.incomplete) return;
+
+    // Fullscreen: if stdin has data waiting, it's almost certainly the
+    // continuation of the buffered sequence (e.g. `[<64;74;16M` after a
+    // lone ESC). Node's event loop runs the timers phase before the poll
+    // phase, so when a heavy render blocks the loop past 50ms, this timer
+    // fires before the queued readable event even though the bytes are
+    // already buffered. Re-arm instead of flushing: handleReadable will
+    // drain stdin next and clear this timer. Prevents both the spurious
+    // Escape key and the lost scroll event.
+    if (this.props.stdin.readableLength > 0) {
+      this.incompleteEscapeTimer = setTimeout(this.flushIncomplete, this.NORMAL_TIMEOUT);
+      return;
+    }
+
+    // Process incomplete as a flush operation (input=null)
+    // This reuses all existing parsing logic
+    this.processInput(null);
+  };
+
+  // Process input through the parser and handle the results
+  processInput = (input: string | Buffer | null): void => {
+    // Parse input using our state machine
+    const [keys, newState] = parseMultipleKeypresses(this.keyParseState, input);
+    this.keyParseState = newState;
+
+    // Process ALL keys in a SINGLE discreteUpdates call to prevent
+    // "Maximum update depth exceeded" error when many keys arrive at once
+    // (e.g., from paste operations or holding keys rapidly).
+    // This batches all state updates from handleInput and all useInput
+    // listeners together within one high-priority update context.
+    if (keys.length > 0) {
+      reconciler.discreteUpdates(processKeysInBatch, this, keys, undefined, undefined);
+    }
+
+    // If we have incomplete escape sequences, set a timer to flush them
+    if (this.keyParseState.incomplete) {
+      // Cancel any existing timer first
+      if (this.incompleteEscapeTimer) {
+        clearTimeout(this.incompleteEscapeTimer);
+      }
+      this.incompleteEscapeTimer = setTimeout(this.flushIncomplete, this.keyParseState.mode === 'IN_PASTE' ? this.PASTE_TIMEOUT : this.NORMAL_TIMEOUT);
+    }
+  };
+  handleReadable = (): void => {
+    // Detect long stdin gaps (tmux attach, ssh reconnect, laptop wake).
+    // The terminal may have reset DEC private modes; re-assert mouse
+    // tracking. Checked before the read loop so one Date.now() covers
+    // all chunks in this readable event.
+    const now = Date.now();
+    if (now - this.lastStdinTime > STDIN_RESUME_GAP_MS) {
+      this.props.onStdinResume?.();
+    }
+    this.lastStdinTime = now;
+    try {
+      let chunk;
+      while ((chunk = this.props.stdin.read() as string | null) !== null) {
+        // Process the input chunk
+        this.processInput(chunk);
+      }
+    } catch (error) {
+      // In Bun, an uncaught throw inside a stream 'readable' handler can
+      // permanently wedge the stream: data stays buffered and 'readable'
+      // never re-emits. Catching here ensures the stream stays healthy so
+      // subsequent keystrokes are still delivered.
+      logError(error);
+
+      // Re-attach the listener in case the exception detached it.
+      // Bun may remove the listener after an error; without this,
+      // the session freezes permanently (stdin reader dead, event loop alive).
+      const {
+        stdin
+      } = this.props;
+      if (this.rawModeEnabledCount > 0 && !stdin.listeners('readable').includes(this.handleReadable)) {
+        logForDebugging('handleReadable: re-attaching stdin readable listener after error recovery', {
+          level: 'warn'
+        });
+        stdin.addListener('readable', this.handleReadable);
+      }
+    }
+  };
+  handleInput = (input: string | undefined): void => {
+    // Exit on Ctrl+C
+    if (input === '\x03' && this.props.exitOnCtrlC) {
+      this.handleExit();
+    }
+
+    // Note: Ctrl+Z (suspend) is now handled in processKeysInBatch using the
+    // parsed key to support both raw (\x1a) and CSI u format from Kitty
+    // keyboard protocol terminals (Ghostty, iTerm2, kitty, WezTerm)
+  };
+  handleExit = (error?: Error): void => {
+    if (this.isRawModeSupported()) {
+      this.handleSetRawMode(false);
+    }
+    this.props.onExit(error);
+  };
+  handleTerminalFocus = (isFocused: boolean): void => {
+    // setTerminalFocused notifies subscribers: TerminalFocusProvider (context)
+    // and Clock (interval speed) — no App setState needed.
+    setTerminalFocused(isFocused);
+  };
+  handleSuspend = (): void => {
+    if (!this.isRawModeSupported()) {
+      return;
+    }
+
+    // Store the exact raw mode count to restore it properly
+    const rawModeCountBeforeSuspend = this.rawModeEnabledCount;
+
+    // Completely disable raw mode before suspending
+    while (this.rawModeEnabledCount > 0) {
+      this.handleSetRawMode(false);
+    }
+
+    // Show cursor, disable focus reporting, and disable mouse tracking
+    // before suspending. DISABLE_MOUSE_TRACKING is a no-op if tracking
+    // wasn't enabled, so it's safe to emit unconditionally — without
+    // it, SGR mouse sequences would appear as garbled text at the
+    // shell prompt while suspended.
+    if (this.props.stdout.isTTY) {
+      this.props.stdout.write(SHOW_CURSOR + DFE + DISABLE_MOUSE_TRACKING);
+    }
+
+    // Emit suspend event for Claude Code to handle. Mostly just has a notification
+    this.internal_eventEmitter.emit('suspend');
+
+    // Set up resume handler
+    const resumeHandler = () => {
+      // Restore raw mode to exact previous state
+      for (let i = 0; i < rawModeCountBeforeSuspend; i++) {
+        if (this.isRawModeSupported()) {
+          this.handleSetRawMode(true);
+        }
+      }
+
+      // Hide cursor (unless in accessibility mode) and re-enable focus reporting after resuming
+      if (this.props.stdout.isTTY) {
+        if (!isEnvTruthy(process.env.CLAUDE_CODE_ACCESSIBILITY)) {
+          this.props.stdout.write(HIDE_CURSOR);
+        }
+        // Re-enable focus reporting to restore terminal state
+        this.props.stdout.write(EFE);
+      }
+
+      // Emit resume event for Claude Code to handle
+      this.internal_eventEmitter.emit('resume');
+      process.removeListener('SIGCONT', resumeHandler);
+    };
+    process.on('SIGCONT', resumeHandler);
+    process.kill(process.pid, 'SIGSTOP');
+  };
+}
+
+// Helper to process all keys within a single discrete update context.
+// discreteUpdates expects (fn, a, b, c, d) -> fn(a, b, c, d)
+function processKeysInBatch(app: App, items: ParsedInput[], _unused1: undefined, _unused2: undefined): void {
+  // Update interaction time for notification timeout tracking.
+  // This is called from the central input handler to avoid having multiple
+  // stdin listeners that can cause race conditions and dropped input.
+  // Terminal responses (kind: 'response') are automated, not user input.
+  // Mode-1003 no-button motion is also excluded — passive cursor drift is
+  // not engagement (would suppress idle notifications + defer housekeeping).
+  if (items.some(i => i.kind === 'key' || i.kind === 'mouse' && !((i.button & 0x20) !== 0 && (i.button & 0x03) === 3))) {
+    updateLastInteractionTime();
+  }
+  for (const item of items) {
+    // Terminal responses (DECRPM, DA1, OSC replies, etc.) are not user
+    // input — route them to the querier to resolve pending promises.
+    if (item.kind === 'response') {
+      app.querier.onResponse(item.response);
+      continue;
+    }
+
+    // Mouse click/drag events update selection state (fullscreen only).
+    // Terminal sends 1-indexed col/row; convert to 0-indexed for the
+    // screen buffer. Button bit 0x20 = drag (motion while button held).
+    if (item.kind === 'mouse') {
+      handleMouseEvent(app, item);
+      continue;
+    }
+    const sequence = item.sequence;
+
+    // Handle terminal focus events (DECSET 1004)
+    if (sequence === FOCUS_IN) {
+      app.handleTerminalFocus(true);
+      const event = new TerminalFocusEvent('terminalfocus');
+      app.internal_eventEmitter.emit('terminalfocus', event);
+      continue;
+    }
+    if (sequence === FOCUS_OUT) {
+      app.handleTerminalFocus(false);
+      // Defensive: if we lost the release event (mouse released outside
+      // terminal window — some emulators drop it rather than capturing the
+      // pointer), focus-out is the next observable signal that the drag is
+      // over. Without this, drag-to-scroll's timer runs until the scroll
+      // boundary is hit.
+      if (app.props.selection.isDragging) {
+        finishSelection(app.props.selection);
+        app.props.onSelectionChange();
+      }
+      const event = new TerminalFocusEvent('terminalblur');
+      app.internal_eventEmitter.emit('terminalblur', event);
+      continue;
+    }
+
+    // Failsafe: if we receive input, the terminal must be focused
+    if (!getTerminalFocused()) {
+      setTerminalFocused(true);
+    }
+
+    // Handle Ctrl+Z (suspend) using parsed key to support both raw (\x1a) and
+    // CSI u format (\x1b[122;5u) from Kitty keyboard protocol terminals
+    if (item.name === 'z' && item.ctrl && SUPPORTS_SUSPEND) {
+      app.handleSuspend();
+      continue;
+    }
+    app.handleInput(sequence);
+    const event = new InputEvent(item);
+    app.internal_eventEmitter.emit('input', event);
+
+    // Also dispatch through the DOM tree so onKeyDown handlers fire.
+    app.props.dispatchKeyboardEvent(item);
+  }
+}
+
+/** Exported for testing. Mutates app.props.selection and click/hover state. */
+export function handleMouseEvent(app: App, m: ParsedMouse): void {
+  // Allow disabling click handling while keeping wheel scroll (which goes
+  // through the keybinding system as 'wheelup'/'wheeldown', not here).
+  if (isMouseClicksDisabled()) return;
+  const sel = app.props.selection;
+  // Terminal coords are 1-indexed; screen buffer is 0-indexed
+  const col = m.col - 1;
+  const row = m.row - 1;
+  const baseButton = m.button & 0x03;
+  if (m.action === 'press') {
+    if ((m.button & 0x20) !== 0 && baseButton === 3) {
+      // Mode-1003 motion with no button held. Dispatch hover; skip the
+      // rest of this handler (no selection, no click-count side effects).
+      // Lost-release recovery: no-button motion while isDragging=true means
+      // the release happened outside the terminal window (iTerm2 doesn't
+      // capture the pointer past window bounds, so the SGR 'm' never
+      // arrives). Finish the selection here so copy-on-select fires. The
+      // FOCUS_OUT handler covers the "switched apps" case but not "released
+      // past the edge, came back" — and tmux drops focus events unless
+      // `focus-events on` is set, so this is the more reliable signal.
+      if (sel.isDragging) {
+        finishSelection(sel);
+        app.props.onSelectionChange();
+      }
+      if (col === app.lastHoverCol && row === app.lastHoverRow) return;
+      app.lastHoverCol = col;
+      app.lastHoverRow = row;
+      app.props.onHoverAt(col, row);
+      return;
+    }
+    if (baseButton !== 0) {
+      // Non-left press breaks the multi-click chain.
+      app.clickCount = 0;
+      return;
+    }
+    if ((m.button & 0x20) !== 0) {
+      // Drag motion: mode-aware extension (char/word/line). onSelectionDrag
+      // calls notifySelectionChange internally — no extra onSelectionChange.
+      app.props.onSelectionDrag(col, row);
+      return;
+    }
+    // Lost-release fallback for mode-1002-only terminals: a fresh press
+    // while isDragging=true means the previous release was dropped (cursor
+    // left the window). Finish that selection so copy-on-select fires
+    // before startSelection/onMultiClick clobbers it. Mode-1003 terminals
+    // hit the no-button-motion recovery above instead, so this is rare.
+    if (sel.isDragging) {
+      finishSelection(sel);
+      app.props.onSelectionChange();
+    }
+    // Fresh left press. Detect multi-click HERE (not on release) so the
+    // word/line highlight appears immediately and a subsequent drag can
+    // extend by word/line like native macOS. Previously detected on
+    // release, which meant (a) visible latency before the word highlights
+    // and (b) double-click+drag fell through to char-mode selection.
+    const now = Date.now();
+    const nearLast = now - app.lastClickTime < MULTI_CLICK_TIMEOUT_MS && Math.abs(col - app.lastClickCol) <= MULTI_CLICK_DISTANCE && Math.abs(row - app.lastClickRow) <= MULTI_CLICK_DISTANCE;
+    app.clickCount = nearLast ? app.clickCount + 1 : 1;
+    app.lastClickTime = now;
+    app.lastClickCol = col;
+    app.lastClickRow = row;
+    if (app.clickCount >= 2) {
+      // Cancel any pending hyperlink-open from the first click — this is
+      // a double-click, not a single-click on a link.
+      if (app.pendingHyperlinkTimer) {
+        clearTimeout(app.pendingHyperlinkTimer);
+        app.pendingHyperlinkTimer = null;
+      }
+      // Cap at 3 (line select) for quadruple+ clicks.
+      const count = app.clickCount === 2 ? 2 : 3;
+      app.props.onMultiClick(col, row, count);
+      return;
+    }
+    startSelection(sel, col, row);
+    // SGR bit 0x08 = alt (xterm.js wires altKey here, not metaKey — see
+    // comment at the hyperlink-open guard below). On macOS xterm.js,
+    // receiving alt means macOptionClickForcesSelection is OFF (otherwise
+    // xterm.js would have consumed the event for native selection).
+    sel.lastPressHadAlt = (m.button & 0x08) !== 0;
+    app.props.onSelectionChange();
+    return;
+  }
+
+  // Release: end the drag even for non-zero button codes. Some terminals
+  // encode release with the motion bit or button=3 "no button" (carried
+  // over from pre-SGR X10 encoding) — filtering those would orphan
+  // isDragging=true and leave drag-to-scroll's timer running until the
+  // scroll boundary. Only act on non-left releases when we ARE dragging
+  // (so an unrelated middle/right click-release doesn't touch selection).
+  if (baseButton !== 0) {
+    if (!sel.isDragging) return;
+    finishSelection(sel);
+    app.props.onSelectionChange();
+    return;
+  }
+  finishSelection(sel);
+  // NOTE: unlike the old release-based detection we do NOT reset clickCount
+  // on release-after-drag. This aligns with NSEvent.clickCount semantics:
+  // an intervening drag doesn't break the click chain. Practical upside:
+  // trackpad jitter during an intended double-click (press→wobble→release
+  // →press) now correctly resolves to word-select instead of breaking to a
+  // fresh single click. The nearLast window (500ms, 1 cell) bounds the
+  // effect — a deliberate drag past that just starts a fresh chain.
+  // A press+release with no drag in char mode is a click: anchor set,
+  // focus null → hasSelection false. In word/line mode the press already
+  // set anchor+focus (hasSelection true), so release just keeps the
+  // highlight. The anchor check guards against an orphaned release (no
+  // prior press — e.g. button was held when mouse tracking was enabled).
+  if (!hasSelection(sel) && sel.anchor) {
+    // Single click: dispatch DOM click immediately (cursor repositioning
+    // etc. are latency-sensitive). If no DOM handler consumed it, defer
+    // the hyperlink check so a second click can cancel it.
+    if (!app.props.onClickAt(col, row)) {
+      // Resolve the hyperlink URL synchronously while the screen buffer
+      // still reflects what the user clicked — deferring only the
+      // browser-open so double-click can cancel it.
+      const url = app.props.getHyperlinkAt(col, row);
+      // xterm.js (VS Code, Cursor, Windsurf, etc.) has its own OSC 8 link
+      // handler that fires on Cmd+click *without consuming the mouse event*
+      // (Linkifier._handleMouseUp calls link.activate() but never
+      // preventDefault/stopPropagation). The click is also forwarded to the
+      // pty as SGR, so both VS Code's terminalLinkManager AND our handler
+      // here would open the URL — twice. We can't filter on Cmd: xterm.js
+      // drops metaKey before SGR encoding (ICoreMouseEvent has no meta
+      // field; the SGR bit we call 'meta' is wired to alt). Let xterm.js
+      // own link-opening; Cmd+click is the native UX there anyway.
+      // TERM_PROGRAM is the sync fast-path; isXtermJs() is the XTVERSION
+      // probe result (catches SSH + non-VS Code embedders like Hyper).
+      if (url && process.env.TERM_PROGRAM !== 'vscode' && !isXtermJs()) {
+        // Clear any prior pending timer — clicking a second link
+        // supersedes the first (only the latest click opens).
+        if (app.pendingHyperlinkTimer) {
+          clearTimeout(app.pendingHyperlinkTimer);
+        }
+        app.pendingHyperlinkTimer = setTimeout((app, url) => {
+          app.pendingHyperlinkTimer = null;
+          app.props.onOpenHyperlink(url);
+        }, MULTI_CLICK_TIMEOUT_MS, app, url);
+      }
+    }
+  }
+  app.props.onSelectionChange();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","PureComponent","ReactNode","updateLastInteractionTime","logForDebugging","stopCapturingEarlyInput","isEnvTruthy","isMouseClicksDisabled","logError","EventEmitter","InputEvent","TerminalFocusEvent","INITIAL_STATE","ParsedInput","ParsedKey","ParsedMouse","parseMultipleKeypresses","reconciler","finishSelection","hasSelection","SelectionState","startSelection","isXtermJs","setXtversionName","supportsExtendedKeys","getTerminalFocused","setTerminalFocused","TerminalQuerier","xtversion","DISABLE_KITTY_KEYBOARD","DISABLE_MODIFY_OTHER_KEYS","ENABLE_KITTY_KEYBOARD","ENABLE_MODIFY_OTHER_KEYS","FOCUS_IN","FOCUS_OUT","DBP","DFE","DISABLE_MOUSE_TRACKING","EBP","EFE","HIDE_CURSOR","SHOW_CURSOR","AppContext","ClockProvider","CursorDeclarationContext","CursorDeclarationSetter","ErrorOverview","StdinContext","TerminalFocusProvider","TerminalSizeContext","SUPPORTS_SUSPEND","process","platform","STDIN_RESUME_GAP_MS","Props","children","stdin","NodeJS","ReadStream","stdout","WriteStream","stderr","exitOnCtrlC","onExit","error","Error","terminalColumns","terminalRows","selection","onSelectionChange","onClickAt","col","row","onHoverAt","getHyperlinkAt","onOpenHyperlink","url","onMultiClick","count","onSelectionDrag","onStdinResume","onCursorDeclaration","dispatchKeyboardEvent","parsedKey","MULTI_CLICK_TIMEOUT_MS","MULTI_CLICK_DISTANCE","State","App","displayName","getDerivedStateFromError","state","undefined","rawModeEnabledCount","internal_eventEmitter","keyParseState","incompleteEscapeTimer","Timeout","NORMAL_TIMEOUT","PASTE_TIMEOUT","querier","props","lastClickTime","lastClickCol","lastClickRow","clickCount","pendingHyperlinkTimer","ReturnType","setTimeout","lastHoverCol","lastHoverRow","lastStdinTime","Date","now","isRawModeSupported","isTTY","render","columns","rows","exit","handleExit","setRawMode","handleSetRawMode","internal_exitOnCtrlC","internal_querier","componentDidMount","env","CLAUDE_CODE_ACCESSIBILITY","write","componentWillUnmount","clearTimeout","componentDidCatch","isEnabled","setEncoding","ref","addListener","handleReadable","setImmediate","Promise","all","send","flush","then","r","name","removeListener","unref","flushIncomplete","incomplete","readableLength","processInput","input","Buffer","keys","newState","length","discreteUpdates","processKeysInBatch","mode","chunk","read","listeners","includes","level","handleInput","handleTerminalFocus","isFocused","handleSuspend","rawModeCountBeforeSuspend","emit","resumeHandler","i","on","kill","pid","app","items","_unused1","_unused2","some","kind","button","item","onResponse","response","handleMouseEvent","sequence","event","isDragging","ctrl","m","sel","baseButton","action","nearLast","Math","abs","lastPressHadAlt","anchor","TERM_PROGRAM"],"sources":["App.tsx"],"sourcesContent":["import React, { PureComponent, type ReactNode } from 'react'\nimport { updateLastInteractionTime } from '../../bootstrap/state.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { stopCapturingEarlyInput } from '../../utils/earlyInput.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\nimport { isMouseClicksDisabled } from '../../utils/fullscreen.js'\nimport { logError } from '../../utils/log.js'\nimport { EventEmitter } from '../events/emitter.js'\nimport { InputEvent } from '../events/input-event.js'\nimport { TerminalFocusEvent } from '../events/terminal-focus-event.js'\nimport {\n  INITIAL_STATE,\n  type ParsedInput,\n  type ParsedKey,\n  type ParsedMouse,\n  parseMultipleKeypresses,\n} from '../parse-keypress.js'\nimport reconciler from '../reconciler.js'\nimport {\n  finishSelection,\n  hasSelection,\n  type SelectionState,\n  startSelection,\n} from '../selection.js'\nimport {\n  isXtermJs,\n  setXtversionName,\n  supportsExtendedKeys,\n} from '../terminal.js'\nimport {\n  getTerminalFocused,\n  setTerminalFocused,\n} from '../terminal-focus-state.js'\nimport { TerminalQuerier, xtversion } from '../terminal-querier.js'\nimport {\n  DISABLE_KITTY_KEYBOARD,\n  DISABLE_MODIFY_OTHER_KEYS,\n  ENABLE_KITTY_KEYBOARD,\n  ENABLE_MODIFY_OTHER_KEYS,\n  FOCUS_IN,\n  FOCUS_OUT,\n} from '../termio/csi.js'\nimport {\n  DBP,\n  DFE,\n  DISABLE_MOUSE_TRACKING,\n  EBP,\n  EFE,\n  HIDE_CURSOR,\n  SHOW_CURSOR,\n} from '../termio/dec.js'\nimport AppContext from './AppContext.js'\nimport { ClockProvider } from './ClockContext.js'\nimport CursorDeclarationContext, {\n  type CursorDeclarationSetter,\n} from './CursorDeclarationContext.js'\nimport ErrorOverview from './ErrorOverview.js'\nimport StdinContext from './StdinContext.js'\nimport { TerminalFocusProvider } from './TerminalFocusContext.js'\nimport { TerminalSizeContext } from './TerminalSizeContext.js'\n\n// Platforms that support Unix-style process suspension (SIGSTOP/SIGCONT)\nconst SUPPORTS_SUSPEND = process.platform !== 'win32'\n\n// After this many milliseconds of stdin silence, the next chunk triggers\n// a terminal mode re-assert (mouse tracking). Catches tmux detach→attach,\n// ssh reconnect, and laptop wake — the terminal resets DEC private modes\n// but no signal reaches us. 5s is well above normal inter-keystroke gaps\n// but short enough that the first scroll after reattach works.\nconst STDIN_RESUME_GAP_MS = 5000\n\ntype Props = {\n  readonly children: ReactNode\n  readonly stdin: NodeJS.ReadStream\n  readonly stdout: NodeJS.WriteStream\n  readonly stderr: NodeJS.WriteStream\n  readonly exitOnCtrlC: boolean\n  readonly onExit: (error?: Error) => void\n  readonly terminalColumns: number\n  readonly terminalRows: number\n  // Text selection state. App mutates this directly from mouse events\n  // and calls onSelectionChange to trigger a repaint. Mouse events only\n  // arrive when <AlternateScreen> (or similar) enables mouse tracking,\n  // so the handler is always wired but dormant until tracking is on.\n  readonly selection: SelectionState\n  readonly onSelectionChange: () => void\n  // Dispatch a click at (col, row) — hit-tests the DOM tree and bubbles\n  // onClick handlers. Returns true if a DOM handler consumed the click.\n  // No-op (returns false) outside fullscreen mode (Ink.dispatchClick\n  // gates on altScreenActive).\n  readonly onClickAt: (col: number, row: number) => boolean\n  // Dispatch hover (onMouseEnter/onMouseLeave) as the pointer moves over\n  // DOM elements. Called for mode-1003 motion events with no button held.\n  // No-op outside fullscreen (Ink.dispatchHover gates on altScreenActive).\n  readonly onHoverAt: (col: number, row: number) => void\n  // Look up the OSC 8 hyperlink at (col, row) synchronously at click\n  // time. Returns the URL or undefined. The browser-open is deferred by\n  // MULTI_CLICK_TIMEOUT_MS so double-click can cancel it.\n  readonly getHyperlinkAt: (col: number, row: number) => string | undefined\n  // Open a hyperlink URL in the browser. Called after the timer fires.\n  readonly onOpenHyperlink: (url: string) => void\n  // Called on double/triple-click PRESS at (col, row). count=2 selects\n  // the word under the cursor; count=3 selects the line. Ink reads the\n  // screen buffer to find word/line boundaries and mutates selection,\n  // setting isDragging=true so a subsequent drag extends by word/line.\n  readonly onMultiClick: (col: number, row: number, count: 2 | 3) => void\n  // Called on drag-motion. Mode-aware: char mode updates focus to the\n  // exact cell; word/line mode snaps to word/line boundaries. Needs\n  // screen-buffer access (word boundaries) so lives on Ink, not here.\n  readonly onSelectionDrag: (col: number, row: number) => void\n  // Called when stdin data arrives after a >STDIN_RESUME_GAP_MS gap.\n  // Ink re-asserts terminal modes: extended key reporting, and (when in\n  // fullscreen) re-enters alt-screen + mouse tracking. Idempotent on the\n  // terminal side. Optional so testing.tsx doesn't need to stub it.\n  readonly onStdinResume?: () => void\n  // Receives the declared native-cursor position from useDeclaredCursor\n  // so ink.tsx can park the terminal cursor there after each frame.\n  // Enables IME composition at the input caret and lets screen readers /\n  // magnifiers track the input. Optional so testing.tsx doesn't stub it.\n  readonly onCursorDeclaration?: CursorDeclarationSetter\n  // Dispatch a keyboard event through the DOM tree. Called for each\n  // parsed key alongside the legacy EventEmitter path.\n  readonly dispatchKeyboardEvent: (parsedKey: ParsedKey) => void\n}\n\n// Multi-click detection thresholds. 500ms is the macOS default; a small\n// position tolerance allows for trackpad jitter between clicks.\nconst MULTI_CLICK_TIMEOUT_MS = 500\nconst MULTI_CLICK_DISTANCE = 1\n\ntype State = {\n  readonly error?: Error\n}\n\n// Root component for all Ink apps\n// It renders stdin and stdout contexts, so that children can access them if needed\n// It also handles Ctrl+C exiting and cursor visibility\nexport default class App extends PureComponent<Props, State> {\n  static displayName = 'InternalApp'\n\n  static getDerivedStateFromError(error: Error) {\n    return { error }\n  }\n\n  override state = {\n    error: undefined,\n  }\n\n  // Count how many components enabled raw mode to avoid disabling\n  // raw mode until all components don't need it anymore\n  rawModeEnabledCount = 0\n\n  internal_eventEmitter = new EventEmitter()\n  keyParseState = INITIAL_STATE\n  // Timer for flushing incomplete escape sequences\n  incompleteEscapeTimer: NodeJS.Timeout | null = null\n  // Timeout durations for incomplete sequences (ms)\n  readonly NORMAL_TIMEOUT = 50 // Short timeout for regular esc sequences\n  readonly PASTE_TIMEOUT = 500 // Longer timeout for paste operations\n\n  // Terminal query/response dispatch. Responses arrive on stdin (parsed\n  // out by parse-keypress) and are routed to pending promise resolvers.\n  querier = new TerminalQuerier(this.props.stdout)\n\n  // Multi-click tracking for double/triple-click text selection. A click\n  // within MULTI_CLICK_TIMEOUT_MS and MULTI_CLICK_DISTANCE of the previous\n  // click increments clickCount; otherwise it resets to 1.\n  lastClickTime = 0\n  lastClickCol = -1\n  lastClickRow = -1\n  clickCount = 0\n  // Deferred hyperlink-open timer — cancelled if a second click arrives\n  // within MULTI_CLICK_TIMEOUT_MS (so double-clicking a hyperlink selects\n  // the word without also opening the browser). DOM onClick dispatch is\n  // NOT deferred — it returns true from onClickAt and skips this timer.\n  pendingHyperlinkTimer: ReturnType<typeof setTimeout> | null = null\n  // Last mode-1003 motion position. Terminals already dedupe to cell\n  // granularity but this also lets us skip dispatchHover entirely on\n  // repeat events (drag-then-release at same cell, etc.).\n  lastHoverCol = -1\n  lastHoverRow = -1\n\n  // Timestamp of last stdin chunk. Used to detect long gaps (tmux attach,\n  // ssh reconnect, laptop wake) and trigger terminal mode re-assert.\n  // Initialized to now so startup doesn't false-trigger.\n  lastStdinTime = Date.now()\n\n  // Determines if TTY is supported on the provided stdin\n  isRawModeSupported(): boolean {\n    return this.props.stdin.isTTY\n  }\n\n  override render() {\n    return (\n      <TerminalSizeContext.Provider\n        value={{\n          columns: this.props.terminalColumns,\n          rows: this.props.terminalRows,\n        }}\n      >\n        <AppContext.Provider\n          value={{\n            exit: this.handleExit,\n          }}\n        >\n          <StdinContext.Provider\n            value={{\n              stdin: this.props.stdin,\n              setRawMode: this.handleSetRawMode,\n              isRawModeSupported: this.isRawModeSupported(),\n\n              internal_exitOnCtrlC: this.props.exitOnCtrlC,\n\n              internal_eventEmitter: this.internal_eventEmitter,\n              internal_querier: this.querier,\n            }}\n          >\n            <TerminalFocusProvider>\n              <ClockProvider>\n                <CursorDeclarationContext.Provider\n                  value={this.props.onCursorDeclaration ?? (() => {})}\n                >\n                  {this.state.error ? (\n                    <ErrorOverview error={this.state.error as Error} />\n                  ) : (\n                    this.props.children\n                  )}\n                </CursorDeclarationContext.Provider>\n              </ClockProvider>\n            </TerminalFocusProvider>\n          </StdinContext.Provider>\n        </AppContext.Provider>\n      </TerminalSizeContext.Provider>\n    )\n  }\n\n  override componentDidMount() {\n    // In accessibility mode, keep the native cursor visible for screen magnifiers and other tools\n    if (\n      this.props.stdout.isTTY &&\n      !isEnvTruthy(process.env.CLAUDE_CODE_ACCESSIBILITY)\n    ) {\n      this.props.stdout.write(HIDE_CURSOR)\n    }\n  }\n\n  override componentWillUnmount() {\n    if (this.props.stdout.isTTY) {\n      this.props.stdout.write(SHOW_CURSOR)\n    }\n\n    // Clear any pending timers\n    if (this.incompleteEscapeTimer) {\n      clearTimeout(this.incompleteEscapeTimer)\n      this.incompleteEscapeTimer = null\n    }\n    if (this.pendingHyperlinkTimer) {\n      clearTimeout(this.pendingHyperlinkTimer)\n      this.pendingHyperlinkTimer = null\n    }\n    // ignore calling setRawMode on an handle stdin it cannot be called\n    if (this.isRawModeSupported()) {\n      this.handleSetRawMode(false)\n    }\n  }\n\n  override componentDidCatch(error: Error) {\n    this.handleExit(error)\n  }\n\n  handleSetRawMode = (isEnabled: boolean): void => {\n    const { stdin } = this.props\n\n    if (!this.isRawModeSupported()) {\n      if (stdin === process.stdin) {\n        throw new Error(\n          'Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.\\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported',\n        )\n      } else {\n        throw new Error(\n          'Raw mode is not supported on the stdin provided to Ink.\\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported',\n        )\n      }\n    }\n\n    stdin.setEncoding('utf8')\n\n    if (isEnabled) {\n      // Ensure raw mode is enabled only once\n      if (this.rawModeEnabledCount === 0) {\n        // Stop early input capture right before we add our own readable handler.\n        // Both use the same stdin 'readable' + read() pattern, so they can't\n        // coexist -- our handler would drain stdin before Ink's can see it.\n        // The buffered text is preserved for REPL.tsx via consumeEarlyInput().\n        stopCapturingEarlyInput()\n        stdin.ref()\n        stdin.setRawMode(true)\n        stdin.addListener('readable', this.handleReadable)\n        // Enable bracketed paste mode\n        this.props.stdout.write(EBP)\n        // Enable terminal focus reporting (DECSET 1004)\n        this.props.stdout.write(EFE)\n        // Enable extended key reporting so ctrl+shift+<letter> is\n        // distinguishable from ctrl+<letter>. We write both the kitty stack\n        // push (CSI >1u) and xterm modifyOtherKeys level 2 (CSI >4;2m) —\n        // terminals honor whichever they implement (tmux only accepts the\n        // latter).\n        if (supportsExtendedKeys()) {\n          this.props.stdout.write(ENABLE_KITTY_KEYBOARD)\n          this.props.stdout.write(ENABLE_MODIFY_OTHER_KEYS)\n        }\n        // Probe terminal identity. XTVERSION survives SSH (query/reply goes\n        // through the pty), unlike TERM_PROGRAM. Used for wheel-scroll base\n        // detection when env vars are absent. Fire-and-forget: the DA1\n        // sentinel bounds the round-trip, and if the terminal ignores the\n        // query, flush() still resolves and name stays undefined.\n        // Deferred to next tick so it fires AFTER the current synchronous\n        // init sequence completes — avoids interleaving with alt-screen/mouse\n        // tracking enable writes that may happen in the same render cycle.\n        setImmediate(() => {\n          void Promise.all([\n            this.querier.send(xtversion()),\n            this.querier.flush(),\n          ]).then(([r]) => {\n            if (r) {\n              setXtversionName(r.name)\n              logForDebugging(`XTVERSION: terminal identified as \"${r.name}\"`)\n            } else {\n              logForDebugging('XTVERSION: no reply (terminal ignored query)')\n            }\n          })\n        })\n      }\n\n      this.rawModeEnabledCount++\n      return\n    }\n\n    // Disable raw mode only when no components left that are using it\n    if (--this.rawModeEnabledCount === 0) {\n      this.props.stdout.write(DISABLE_MODIFY_OTHER_KEYS)\n      this.props.stdout.write(DISABLE_KITTY_KEYBOARD)\n      // Disable terminal focus reporting (DECSET 1004)\n      this.props.stdout.write(DFE)\n      // Disable bracketed paste mode\n      this.props.stdout.write(DBP)\n      stdin.setRawMode(false)\n      stdin.removeListener('readable', this.handleReadable)\n      stdin.unref()\n    }\n  }\n\n  // Helper to flush incomplete escape sequences\n  flushIncomplete = (): void => {\n    // Clear the timer reference\n    this.incompleteEscapeTimer = null\n\n    // Only proceed if we have incomplete sequences\n    if (!this.keyParseState.incomplete) return\n\n    // Fullscreen: if stdin has data waiting, it's almost certainly the\n    // continuation of the buffered sequence (e.g. `[<64;74;16M` after a\n    // lone ESC). Node's event loop runs the timers phase before the poll\n    // phase, so when a heavy render blocks the loop past 50ms, this timer\n    // fires before the queued readable event even though the bytes are\n    // already buffered. Re-arm instead of flushing: handleReadable will\n    // drain stdin next and clear this timer. Prevents both the spurious\n    // Escape key and the lost scroll event.\n    if (this.props.stdin.readableLength > 0) {\n      this.incompleteEscapeTimer = setTimeout(\n        this.flushIncomplete,\n        this.NORMAL_TIMEOUT,\n      )\n      return\n    }\n\n    // Process incomplete as a flush operation (input=null)\n    // This reuses all existing parsing logic\n    this.processInput(null)\n  }\n\n  // Process input through the parser and handle the results\n  processInput = (input: string | Buffer | null): void => {\n    // Parse input using our state machine\n    const [keys, newState] = parseMultipleKeypresses(this.keyParseState, input)\n    this.keyParseState = newState\n\n    // Process ALL keys in a SINGLE discreteUpdates call to prevent\n    // \"Maximum update depth exceeded\" error when many keys arrive at once\n    // (e.g., from paste operations or holding keys rapidly).\n    // This batches all state updates from handleInput and all useInput\n    // listeners together within one high-priority update context.\n    if (keys.length > 0) {\n      reconciler.discreteUpdates(\n        processKeysInBatch,\n        this,\n        keys,\n        undefined,\n        undefined,\n      )\n    }\n\n    // If we have incomplete escape sequences, set a timer to flush them\n    if (this.keyParseState.incomplete) {\n      // Cancel any existing timer first\n      if (this.incompleteEscapeTimer) {\n        clearTimeout(this.incompleteEscapeTimer)\n      }\n      this.incompleteEscapeTimer = setTimeout(\n        this.flushIncomplete,\n        this.keyParseState.mode === 'IN_PASTE'\n          ? this.PASTE_TIMEOUT\n          : this.NORMAL_TIMEOUT,\n      )\n    }\n  }\n\n  handleReadable = (): void => {\n    // Detect long stdin gaps (tmux attach, ssh reconnect, laptop wake).\n    // The terminal may have reset DEC private modes; re-assert mouse\n    // tracking. Checked before the read loop so one Date.now() covers\n    // all chunks in this readable event.\n    const now = Date.now()\n    if (now - this.lastStdinTime > STDIN_RESUME_GAP_MS) {\n      this.props.onStdinResume?.()\n    }\n    this.lastStdinTime = now\n    try {\n      let chunk\n      while ((chunk = this.props.stdin.read() as string | null) !== null) {\n        // Process the input chunk\n        this.processInput(chunk)\n      }\n    } catch (error) {\n      // In Bun, an uncaught throw inside a stream 'readable' handler can\n      // permanently wedge the stream: data stays buffered and 'readable'\n      // never re-emits. Catching here ensures the stream stays healthy so\n      // subsequent keystrokes are still delivered.\n      logError(error)\n\n      // Re-attach the listener in case the exception detached it.\n      // Bun may remove the listener after an error; without this,\n      // the session freezes permanently (stdin reader dead, event loop alive).\n      const { stdin } = this.props\n      if (\n        this.rawModeEnabledCount > 0 &&\n        !stdin.listeners('readable').includes(this.handleReadable)\n      ) {\n        logForDebugging(\n          'handleReadable: re-attaching stdin readable listener after error recovery',\n          { level: 'warn' },\n        )\n        stdin.addListener('readable', this.handleReadable)\n      }\n    }\n  }\n\n  handleInput = (input: string | undefined): void => {\n    // Exit on Ctrl+C\n    if (input === '\\x03' && this.props.exitOnCtrlC) {\n      this.handleExit()\n    }\n\n    // Note: Ctrl+Z (suspend) is now handled in processKeysInBatch using the\n    // parsed key to support both raw (\\x1a) and CSI u format from Kitty\n    // keyboard protocol terminals (Ghostty, iTerm2, kitty, WezTerm)\n  }\n\n  handleExit = (error?: Error): void => {\n    if (this.isRawModeSupported()) {\n      this.handleSetRawMode(false)\n    }\n\n    this.props.onExit(error)\n  }\n\n  handleTerminalFocus = (isFocused: boolean): void => {\n    // setTerminalFocused notifies subscribers: TerminalFocusProvider (context)\n    // and Clock (interval speed) — no App setState needed.\n    setTerminalFocused(isFocused)\n  }\n\n  handleSuspend = (): void => {\n    if (!this.isRawModeSupported()) {\n      return\n    }\n\n    // Store the exact raw mode count to restore it properly\n    const rawModeCountBeforeSuspend = this.rawModeEnabledCount\n\n    // Completely disable raw mode before suspending\n    while (this.rawModeEnabledCount > 0) {\n      this.handleSetRawMode(false)\n    }\n\n    // Show cursor, disable focus reporting, and disable mouse tracking\n    // before suspending. DISABLE_MOUSE_TRACKING is a no-op if tracking\n    // wasn't enabled, so it's safe to emit unconditionally — without\n    // it, SGR mouse sequences would appear as garbled text at the\n    // shell prompt while suspended.\n    if (this.props.stdout.isTTY) {\n      this.props.stdout.write(SHOW_CURSOR + DFE + DISABLE_MOUSE_TRACKING)\n    }\n\n    // Emit suspend event for Claude Code to handle. Mostly just has a notification\n    this.internal_eventEmitter.emit('suspend')\n\n    // Set up resume handler\n    const resumeHandler = () => {\n      // Restore raw mode to exact previous state\n      for (let i = 0; i < rawModeCountBeforeSuspend; i++) {\n        if (this.isRawModeSupported()) {\n          this.handleSetRawMode(true)\n        }\n      }\n\n      // Hide cursor (unless in accessibility mode) and re-enable focus reporting after resuming\n      if (this.props.stdout.isTTY) {\n        if (!isEnvTruthy(process.env.CLAUDE_CODE_ACCESSIBILITY)) {\n          this.props.stdout.write(HIDE_CURSOR)\n        }\n        // Re-enable focus reporting to restore terminal state\n        this.props.stdout.write(EFE)\n      }\n\n      // Emit resume event for Claude Code to handle\n      this.internal_eventEmitter.emit('resume')\n\n      process.removeListener('SIGCONT', resumeHandler)\n    }\n\n    process.on('SIGCONT', resumeHandler)\n    process.kill(process.pid, 'SIGSTOP')\n  }\n}\n\n// Helper to process all keys within a single discrete update context.\n// discreteUpdates expects (fn, a, b, c, d) -> fn(a, b, c, d)\nfunction processKeysInBatch(\n  app: App,\n  items: ParsedInput[],\n  _unused1: undefined,\n  _unused2: undefined,\n): void {\n  // Update interaction time for notification timeout tracking.\n  // This is called from the central input handler to avoid having multiple\n  // stdin listeners that can cause race conditions and dropped input.\n  // Terminal responses (kind: 'response') are automated, not user input.\n  // Mode-1003 no-button motion is also excluded — passive cursor drift is\n  // not engagement (would suppress idle notifications + defer housekeeping).\n  if (\n    items.some(\n      i =>\n        i.kind === 'key' ||\n        (i.kind === 'mouse' &&\n          !((i.button & 0x20) !== 0 && (i.button & 0x03) === 3)),\n    )\n  ) {\n    updateLastInteractionTime()\n  }\n\n  for (const item of items) {\n    // Terminal responses (DECRPM, DA1, OSC replies, etc.) are not user\n    // input — route them to the querier to resolve pending promises.\n    if (item.kind === 'response') {\n      app.querier.onResponse(item.response)\n      continue\n    }\n\n    // Mouse click/drag events update selection state (fullscreen only).\n    // Terminal sends 1-indexed col/row; convert to 0-indexed for the\n    // screen buffer. Button bit 0x20 = drag (motion while button held).\n    if (item.kind === 'mouse') {\n      handleMouseEvent(app, item)\n      continue\n    }\n\n    const sequence = item.sequence\n\n    // Handle terminal focus events (DECSET 1004)\n    if (sequence === FOCUS_IN) {\n      app.handleTerminalFocus(true)\n      const event = new TerminalFocusEvent('terminalfocus')\n      app.internal_eventEmitter.emit('terminalfocus', event)\n      continue\n    }\n    if (sequence === FOCUS_OUT) {\n      app.handleTerminalFocus(false)\n      // Defensive: if we lost the release event (mouse released outside\n      // terminal window — some emulators drop it rather than capturing the\n      // pointer), focus-out is the next observable signal that the drag is\n      // over. Without this, drag-to-scroll's timer runs until the scroll\n      // boundary is hit.\n      if (app.props.selection.isDragging) {\n        finishSelection(app.props.selection)\n        app.props.onSelectionChange()\n      }\n      const event = new TerminalFocusEvent('terminalblur')\n      app.internal_eventEmitter.emit('terminalblur', event)\n      continue\n    }\n\n    // Failsafe: if we receive input, the terminal must be focused\n    if (!getTerminalFocused()) {\n      setTerminalFocused(true)\n    }\n\n    // Handle Ctrl+Z (suspend) using parsed key to support both raw (\\x1a) and\n    // CSI u format (\\x1b[122;5u) from Kitty keyboard protocol terminals\n    if (item.name === 'z' && item.ctrl && SUPPORTS_SUSPEND) {\n      app.handleSuspend()\n      continue\n    }\n\n    app.handleInput(sequence)\n    const event = new InputEvent(item)\n    app.internal_eventEmitter.emit('input', event)\n\n    // Also dispatch through the DOM tree so onKeyDown handlers fire.\n    app.props.dispatchKeyboardEvent(item)\n  }\n}\n\n/** Exported for testing. Mutates app.props.selection and click/hover state. */\nexport function handleMouseEvent(app: App, m: ParsedMouse): void {\n  // Allow disabling click handling while keeping wheel scroll (which goes\n  // through the keybinding system as 'wheelup'/'wheeldown', not here).\n  if (isMouseClicksDisabled()) return\n\n  const sel = app.props.selection\n  // Terminal coords are 1-indexed; screen buffer is 0-indexed\n  const col = m.col - 1\n  const row = m.row - 1\n  const baseButton = m.button & 0x03\n\n  if (m.action === 'press') {\n    if ((m.button & 0x20) !== 0 && baseButton === 3) {\n      // Mode-1003 motion with no button held. Dispatch hover; skip the\n      // rest of this handler (no selection, no click-count side effects).\n      // Lost-release recovery: no-button motion while isDragging=true means\n      // the release happened outside the terminal window (iTerm2 doesn't\n      // capture the pointer past window bounds, so the SGR 'm' never\n      // arrives). Finish the selection here so copy-on-select fires. The\n      // FOCUS_OUT handler covers the \"switched apps\" case but not \"released\n      // past the edge, came back\" — and tmux drops focus events unless\n      // `focus-events on` is set, so this is the more reliable signal.\n      if (sel.isDragging) {\n        finishSelection(sel)\n        app.props.onSelectionChange()\n      }\n      if (col === app.lastHoverCol && row === app.lastHoverRow) return\n      app.lastHoverCol = col\n      app.lastHoverRow = row\n      app.props.onHoverAt(col, row)\n      return\n    }\n    if (baseButton !== 0) {\n      // Non-left press breaks the multi-click chain.\n      app.clickCount = 0\n      return\n    }\n    if ((m.button & 0x20) !== 0) {\n      // Drag motion: mode-aware extension (char/word/line). onSelectionDrag\n      // calls notifySelectionChange internally — no extra onSelectionChange.\n      app.props.onSelectionDrag(col, row)\n      return\n    }\n    // Lost-release fallback for mode-1002-only terminals: a fresh press\n    // while isDragging=true means the previous release was dropped (cursor\n    // left the window). Finish that selection so copy-on-select fires\n    // before startSelection/onMultiClick clobbers it. Mode-1003 terminals\n    // hit the no-button-motion recovery above instead, so this is rare.\n    if (sel.isDragging) {\n      finishSelection(sel)\n      app.props.onSelectionChange()\n    }\n    // Fresh left press. Detect multi-click HERE (not on release) so the\n    // word/line highlight appears immediately and a subsequent drag can\n    // extend by word/line like native macOS. Previously detected on\n    // release, which meant (a) visible latency before the word highlights\n    // and (b) double-click+drag fell through to char-mode selection.\n    const now = Date.now()\n    const nearLast =\n      now - app.lastClickTime < MULTI_CLICK_TIMEOUT_MS &&\n      Math.abs(col - app.lastClickCol) <= MULTI_CLICK_DISTANCE &&\n      Math.abs(row - app.lastClickRow) <= MULTI_CLICK_DISTANCE\n    app.clickCount = nearLast ? app.clickCount + 1 : 1\n    app.lastClickTime = now\n    app.lastClickCol = col\n    app.lastClickRow = row\n    if (app.clickCount >= 2) {\n      // Cancel any pending hyperlink-open from the first click — this is\n      // a double-click, not a single-click on a link.\n      if (app.pendingHyperlinkTimer) {\n        clearTimeout(app.pendingHyperlinkTimer)\n        app.pendingHyperlinkTimer = null\n      }\n      // Cap at 3 (line select) for quadruple+ clicks.\n      const count = app.clickCount === 2 ? 2 : 3\n      app.props.onMultiClick(col, row, count)\n      return\n    }\n    startSelection(sel, col, row)\n    // SGR bit 0x08 = alt (xterm.js wires altKey here, not metaKey — see\n    // comment at the hyperlink-open guard below). On macOS xterm.js,\n    // receiving alt means macOptionClickForcesSelection is OFF (otherwise\n    // xterm.js would have consumed the event for native selection).\n    sel.lastPressHadAlt = (m.button & 0x08) !== 0\n    app.props.onSelectionChange()\n    return\n  }\n\n  // Release: end the drag even for non-zero button codes. Some terminals\n  // encode release with the motion bit or button=3 \"no button\" (carried\n  // over from pre-SGR X10 encoding) — filtering those would orphan\n  // isDragging=true and leave drag-to-scroll's timer running until the\n  // scroll boundary. Only act on non-left releases when we ARE dragging\n  // (so an unrelated middle/right click-release doesn't touch selection).\n  if (baseButton !== 0) {\n    if (!sel.isDragging) return\n    finishSelection(sel)\n    app.props.onSelectionChange()\n    return\n  }\n  finishSelection(sel)\n  // NOTE: unlike the old release-based detection we do NOT reset clickCount\n  // on release-after-drag. This aligns with NSEvent.clickCount semantics:\n  // an intervening drag doesn't break the click chain. Practical upside:\n  // trackpad jitter during an intended double-click (press→wobble→release\n  // →press) now correctly resolves to word-select instead of breaking to a\n  // fresh single click. The nearLast window (500ms, 1 cell) bounds the\n  // effect — a deliberate drag past that just starts a fresh chain.\n  // A press+release with no drag in char mode is a click: anchor set,\n  // focus null → hasSelection false. In word/line mode the press already\n  // set anchor+focus (hasSelection true), so release just keeps the\n  // highlight. The anchor check guards against an orphaned release (no\n  // prior press — e.g. button was held when mouse tracking was enabled).\n  if (!hasSelection(sel) && sel.anchor) {\n    // Single click: dispatch DOM click immediately (cursor repositioning\n    // etc. are latency-sensitive). If no DOM handler consumed it, defer\n    // the hyperlink check so a second click can cancel it.\n    if (!app.props.onClickAt(col, row)) {\n      // Resolve the hyperlink URL synchronously while the screen buffer\n      // still reflects what the user clicked — deferring only the\n      // browser-open so double-click can cancel it.\n      const url = app.props.getHyperlinkAt(col, row)\n      // xterm.js (VS Code, Cursor, Windsurf, etc.) has its own OSC 8 link\n      // handler that fires on Cmd+click *without consuming the mouse event*\n      // (Linkifier._handleMouseUp calls link.activate() but never\n      // preventDefault/stopPropagation). The click is also forwarded to the\n      // pty as SGR, so both VS Code's terminalLinkManager AND our handler\n      // here would open the URL — twice. We can't filter on Cmd: xterm.js\n      // drops metaKey before SGR encoding (ICoreMouseEvent has no meta\n      // field; the SGR bit we call 'meta' is wired to alt). Let xterm.js\n      // own link-opening; Cmd+click is the native UX there anyway.\n      // TERM_PROGRAM is the sync fast-path; isXtermJs() is the XTVERSION\n      // probe result (catches SSH + non-VS Code embedders like Hyper).\n      if (url && process.env.TERM_PROGRAM !== 'vscode' && !isXtermJs()) {\n        // Clear any prior pending timer — clicking a second link\n        // supersedes the first (only the latest click opens).\n        if (app.pendingHyperlinkTimer) {\n          clearTimeout(app.pendingHyperlinkTimer)\n        }\n        app.pendingHyperlinkTimer = setTimeout(\n          (app, url) => {\n            app.pendingHyperlinkTimer = null\n            app.props.onOpenHyperlink(url)\n          },\n          MULTI_CLICK_TIMEOUT_MS,\n          app,\n          url,\n        )\n      }\n    }\n  }\n  app.props.onSelectionChange()\n}\n"],"mappings":"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","ignoreList":[]}