@within-7/minto 0.1.7 → 0.3.0

package/dist/hooks/useAgentTokenStats.js

@@ -0,0 +1,72 @@
+import { useState, useEffect } from "react";
+import { tokenStatsManager } from "@core/tokenStatsManager";
+function useAgentTokenStats(agentId) {
+  const [stats, setStats] = useState(() => {
+    if (!agentId) return null;
+    return tokenStatsManager.getAgentStats(agentId);
+  });
+  useEffect(() => {
+    if (!agentId) {
+      setStats(null);
+      return;
+    }
+    const initialStats = tokenStatsManager.getAgentStats(agentId);
+    if (initialStats) {
+      setStats(initialStats);
+    }
+    const unsubscribe = tokenStatsManager.onAgentStatsUpdate(
+      agentId,
+      (newStats) => {
+        setStats(newStats);
+      }
+    );
+    return unsubscribe;
+  }, [agentId]);
+  return stats;
+}
+function useGlobalTokenStats() {
+  const [stats, setStats] = useState(
+    () => tokenStatsManager.getGlobalStats()
+  );
+  useEffect(() => {
+    const unsubscribe = tokenStatsManager.onGlobalStatsUpdate((newStats) => {
+      setStats(newStats);
+    });
+    return unsubscribe;
+  }, []);
+  return stats;
+}
+function useAllAgentTokenStats() {
+  const [stats, setStats] = useState(
+    () => tokenStatsManager.getAllAgentStats()
+  );
+  useEffect(() => {
+    const unsubscribe = tokenStatsManager.onStatsUpdate((event) => {
+      setStats(tokenStatsManager.getAllAgentStats());
+    });
+    return unsubscribe;
+  }, []);
+  return stats;
+}
+function formatTokenCount(count) {
+  if (count >= 1e6) {
+    return `${(count / 1e6).toFixed(1)}M`;
+  }
+  if (count >= 1e3) {
+    return `${(count / 1e3).toFixed(1)}k`;
+  }
+  return count.toString();
+}
+function getTokenSummary(stats) {
+  const input = formatTokenCount(stats.totalInputTokens);
+  const output = formatTokenCount(stats.totalOutputTokens);
+  return `${input} in / ${output} out`;
+}
+export {
+  formatTokenCount,
+  getTokenSummary,
+  useAgentTokenStats,
+  useAllAgentTokenStats,
+  useGlobalTokenStats
+};
+//# sourceMappingURL=useAgentTokenStats.js.map

package/dist/hooks/useAgentTokenStats.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useAgentTokenStats.ts"],
+  "sourcesContent": ["/**\n * useAgentTokenStats Hook\n *\n * Provides real-time access to token statistics for a specific agent.\n * Subscribes to TokenStatsManager events for automatic updates.\n *\n * Usage:\n * ```tsx\n * function SubagentDisplay({ agentId }) {\n *   const stats = useAgentTokenStats(agentId)\n *\n *   if (!stats) return <Text>Loading...</Text>\n *\n *   return (\n *     <Text>\n *       {stats.grandTotalTokens.toLocaleString()} tokens\n *     </Text>\n *   )\n * }\n * ```\n */\n\nimport { useState, useEffect, useCallback } from 'react'\nimport { tokenStatsManager } from '@core/tokenStatsManager'\nimport type { AggregatedTokenStats } from '@core/tokenStats'\n\n/**\n * Hook for accessing token statistics for a specific agent\n *\n * @param agentId - The agent ID to track\n * @returns Current token statistics or null if not found\n */\nexport function useAgentTokenStats(\n  agentId: string | undefined,\n): AggregatedTokenStats | null {\n  const [stats, setStats] = useState<AggregatedTokenStats | null>(() => {\n    if (!agentId) return null\n    return tokenStatsManager.getAgentStats(agentId)\n  })\n\n  useEffect(() => {\n    if (!agentId) {\n      setStats(null)\n      return\n    }\n\n    // Get initial stats\n    const initialStats = tokenStatsManager.getAgentStats(agentId)\n    if (initialStats) {\n      setStats(initialStats)\n    }\n\n    // Subscribe to updates\n    const unsubscribe = tokenStatsManager.onAgentStatsUpdate(\n      agentId,\n      newStats => {\n        setStats(newStats)\n      },\n    )\n\n    return unsubscribe\n  }, [agentId])\n\n  return stats\n}\n\n/**\n * Hook for accessing global token statistics\n *\n * @returns Current global token statistics\n */\nexport function useGlobalTokenStats(): AggregatedTokenStats {\n  const [stats, setStats] = useState<AggregatedTokenStats>(() =>\n    tokenStatsManager.getGlobalStats(),\n  )\n\n  useEffect(() => {\n    // Subscribe to global updates\n    const unsubscribe = tokenStatsManager.onGlobalStatsUpdate(newStats => {\n      setStats(newStats)\n    })\n\n    return unsubscribe\n  }, [])\n\n  return stats\n}\n\n/**\n * Hook for accessing all agent statistics\n *\n * @returns Map of agentId to token statistics\n */\nexport function useAllAgentTokenStats(): Map<string, AggregatedTokenStats> {\n  const [stats, setStats] = useState<Map<string, AggregatedTokenStats>>(() =>\n    tokenStatsManager.getAllAgentStats(),\n  )\n\n  useEffect(() => {\n    // Subscribe to all updates\n    const unsubscribe = tokenStatsManager.onStatsUpdate(event => {\n      // Refresh the entire map on any update\n      setStats(tokenStatsManager.getAllAgentStats())\n    })\n\n    return unsubscribe\n  }, [])\n\n  return stats\n}\n\n/**\n * Format token count for display\n *\n * @param count - Token count to format\n * @returns Formatted string (e.g., \"1.2k\", \"45.3k\", \"1.2M\")\n */\nexport function formatTokenCount(count: number): string {\n  if (count >= 1_000_000) {\n    return `${(count / 1_000_000).toFixed(1)}M`\n  }\n  if (count >= 1_000) {\n    return `${(count / 1_000).toFixed(1)}k`\n  }\n  return count.toString()\n}\n\n/**\n * Get a summary string of token usage\n *\n * @param stats - Token statistics to summarize\n * @returns Formatted summary (e.g., \"1.2k in / 0.5k out\")\n */\nexport function getTokenSummary(stats: AggregatedTokenStats): string {\n  const input = formatTokenCount(stats.totalInputTokens)\n  const output = formatTokenCount(stats.totalOutputTokens)\n  return `${input} in / ${output} out`\n}\n"],
+  "mappings": "AAsBA,SAAS,UAAU,iBAA8B;AACjD,SAAS,yBAAyB;AAS3B,SAAS,mBACd,SAC6B;AAC7B,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAsC,MAAM;AACpE,QAAI,CAAC,QAAS,QAAO;AACrB,WAAO,kBAAkB,cAAc,OAAO;AAAA,EAChD,CAAC;AAED,YAAU,MAAM;AACd,QAAI,CAAC,SAAS;AACZ,eAAS,IAAI;AACb;AAAA,IACF;AAGA,UAAM,eAAe,kBAAkB,cAAc,OAAO;AAC5D,QAAI,cAAc;AAChB,eAAS,YAAY;AAAA,IACvB;AAGA,UAAM,cAAc,kBAAkB;AAAA,MACpC;AAAA,MACA,cAAY;AACV,iBAAS,QAAQ;AAAA,MACnB;AAAA,IACF;AAEA,WAAO;AAAA,EACT,GAAG,CAAC,OAAO,CAAC;AAEZ,SAAO;AACT;AAOO,SAAS,sBAA4C;AAC1D,QAAM,CAAC,OAAO,QAAQ,IAAI;AAAA,IAA+B,MACvD,kBAAkB,eAAe;AAAA,EACnC;AAEA,YAAU,MAAM;AAEd,UAAM,cAAc,kBAAkB,oBAAoB,cAAY;AACpE,eAAS,QAAQ;AAAA,IACnB,CAAC;AAED,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;AAOO,SAAS,wBAA2D;AACzE,QAAM,CAAC,OAAO,QAAQ,IAAI;AAAA,IAA4C,MACpE,kBAAkB,iBAAiB;AAAA,EACrC;AAEA,YAAU,MAAM;AAEd,UAAM,cAAc,kBAAkB,cAAc,WAAS;AAE3D,eAAS,kBAAkB,iBAAiB,CAAC;AAAA,IAC/C,CAAC;AAED,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;AAQO,SAAS,iBAAiB,OAAuB;AACtD,MAAI,SAAS,KAAW;AACtB,WAAO,IAAI,QAAQ,KAAW,QAAQ,CAAC,CAAC;AAAA,EAC1C;AACA,MAAI,SAAS,KAAO;AAClB,WAAO,IAAI,QAAQ,KAAO,QAAQ,CAAC,CAAC;AAAA,EACtC;AACA,SAAO,MAAM,SAAS;AACxB;AAQO,SAAS,gBAAgB,OAAqC;AACnE,QAAM,QAAQ,iBAAiB,MAAM,gBAAgB;AACrD,QAAM,SAAS,iBAAiB,MAAM,iBAAiB;AACvD,SAAO,GAAG,KAAK,SAAS,MAAM;AAChC;",
+  "names": []
+}

package/dist/hooks/useAgentTranscripts.js

@@ -0,0 +1,140 @@
+import { useState, useEffect, useMemo, useCallback, useRef } from "react";
+import {
+  transcriptEmitter,
+  getAgentTranscript
+} from "../utils/agentTranscripts.js";
+function useAgentTranscripts(agentIds) {
+  const [transcripts, setTranscripts] = useState(
+    () => /* @__PURE__ */ new Map()
+  );
+  const lazyLoadCacheRef = useRef(/* @__PURE__ */ new Map());
+  const syncScheduledRef = useRef(false);
+  const trackedAgentIds = useMemo(
+    () => agentIds ? new Set(agentIds) : null,
+    [agentIds?.join(",")]
+  );
+  useEffect(() => {
+    const handleUpdate = (event) => {
+      if (trackedAgentIds && !trackedAgentIds.has(event.agentId)) {
+        return;
+      }
+      setTranscripts((prev) => {
+        const next = new Map(prev);
+        next.set(event.agentId, event.transcript);
+        return next;
+      });
+    };
+    transcriptEmitter.on("update", handleUpdate);
+    if (trackedAgentIds) {
+      for (const agentId of trackedAgentIds) {
+        const transcript = getAgentTranscript(agentId);
+        if (transcript) {
+          setTranscripts((prev) => {
+            const next = new Map(prev);
+            next.set(agentId, transcript);
+            return next;
+          });
+        }
+      }
+    }
+    return () => {
+      transcriptEmitter.off("update", handleUpdate);
+    };
+  }, [trackedAgentIds]);
+  const getTranscriptCallback = useCallback(
+    (agentId) => {
+      const cached = transcripts.get(agentId);
+      if (cached) {
+        return cached;
+      }
+      const lazyCached = lazyLoadCacheRef.current.get(agentId);
+      if (lazyCached) {
+        return lazyCached;
+      }
+      const loaded = getAgentTranscript(agentId);
+      if (loaded) {
+        lazyLoadCacheRef.current.set(agentId, loaded);
+      }
+      return loaded;
+    },
+    [transcripts]
+  );
+  useEffect(() => {
+    if (lazyLoadCacheRef.current.size > 0 && !syncScheduledRef.current) {
+      syncScheduledRef.current = true;
+      const timeoutId = setTimeout(() => {
+        setTranscripts((prev) => {
+          const next = new Map(prev);
+          for (const [agentId, transcript] of lazyLoadCacheRef.current) {
+            if (!next.has(agentId)) {
+              next.set(agentId, transcript);
+            }
+          }
+          return next;
+        });
+        lazyLoadCacheRef.current = /* @__PURE__ */ new Map();
+        syncScheduledRef.current = false;
+      }, 0);
+      return () => {
+        clearTimeout(timeoutId);
+        syncScheduledRef.current = false;
+      };
+    }
+  }, [transcripts]);
+  const refreshTranscript = useCallback((agentId) => {
+    const fresh = getAgentTranscript(agentId);
+    if (fresh) {
+      setTranscripts((prev) => {
+        const next = new Map(prev);
+        next.set(agentId, fresh);
+        return next;
+      });
+    }
+  }, []);
+  const activeCount = useMemo(() => {
+    let count = 0;
+    for (const transcript of transcripts.values()) {
+      if (transcript.status === "running" || transcript.status === "pending") {
+        count++;
+      }
+    }
+    return count;
+  }, [transcripts]);
+  return {
+    transcripts,
+    getTranscript: getTranscriptCallback,
+    refreshTranscript,
+    activeCount
+  };
+}
+function useAgentTranscript(agentId) {
+  const [transcript, setTranscript] = useState(() => {
+    if (!agentId) return null;
+    return getAgentTranscript(agentId);
+  });
+  useEffect(() => {
+    if (!agentId) {
+      setTranscript(null);
+      return;
+    }
+    const initial = getAgentTranscript(agentId);
+    if (initial) {
+      setTranscript(initial);
+    }
+    const handleUpdate = (event) => {
+      if (event.agentId === agentId) {
+        setTranscript(event.transcript);
+      }
+    };
+    transcriptEmitter.on("update", handleUpdate);
+    return () => {
+      transcriptEmitter.off("update", handleUpdate);
+    };
+  }, [agentId]);
+  return transcript;
+}
+export {
+  useAgentTranscript,
+  useAgentTranscripts
+};
+//# sourceMappingURL=useAgentTranscripts.js.map

package/dist/hooks/useAgentTranscripts.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useAgentTranscripts.ts"],
+  "sourcesContent": ["/**\n * useAgentTranscripts Hook\n *\n * Provides real-time access to agent transcripts with automatic updates.\n * Subscribes to transcript events and maintains a reactive map of transcripts.\n */\n\nimport { useState, useEffect, useMemo, useCallback, useRef } from 'react'\nimport {\n  transcriptEmitter,\n  getAgentTranscript,\n  type AgentTranscript,\n  type TranscriptEvent,\n} from '@utils/agentTranscripts'\n\ninterface UseAgentTranscriptsResult {\n  /** Map of agentId to transcript */\n  transcripts: Map<string, AgentTranscript>\n  /** Get transcript by agentId */\n  getTranscript: (agentId: string) => AgentTranscript | null\n  /** Force refresh of a specific transcript */\n  refreshTranscript: (agentId: string) => void\n  /** Number of active transcripts */\n  activeCount: number\n}\n\n/**\n * Hook for accessing agent transcripts with real-time updates\n *\n * @param agentIds - Optional list of specific agent IDs to track\n * @returns Transcript state and utilities\n */\nexport function useAgentTranscripts(\n  agentIds?: string[],\n): UseAgentTranscriptsResult {\n  // State to hold current transcripts\n  const [transcripts, setTranscripts] = useState<Map<string, AgentTranscript>>(\n    () => new Map(),\n  )\n\n  // Ref-based cache for lazy loading during render (avoids setState during render)\n  // This allows getTranscript to return cached values synchronously without triggering re-renders\n  const lazyLoadCacheRef = useRef<Map<string, AgentTranscript>>(new Map())\n\n  // Prevent duplicate sync scheduling - avoids infinite render loops\n  const syncScheduledRef = useRef<boolean>(false)\n\n  // Track which agents we're interested in\n  const trackedAgentIds = useMemo(\n    () => (agentIds ? new Set(agentIds) : null),\n    [agentIds?.join(',')],\n  )\n\n  // Handle transcript updates\n  useEffect(() => {\n    const handleUpdate = (event: TranscriptEvent) => {\n      // If we have a tracked list and this agent isn't in it, skip\n      if (trackedAgentIds && !trackedAgentIds.has(event.agentId)) {\n        return\n      }\n\n      setTranscripts(prev => {\n        const next = new Map(prev)\n        next.set(event.agentId, event.transcript)\n        return next\n      })\n    }\n\n    // Subscribe to all transcript updates\n    transcriptEmitter.on('update', handleUpdate)\n\n    // Initial load for tracked agents\n    if (trackedAgentIds) {\n      for (const agentId of trackedAgentIds) {\n        const transcript = getAgentTranscript(agentId)\n        if (transcript) {\n          setTranscripts(prev => {\n            const next = new Map(prev)\n            next.set(agentId, transcript)\n            return next\n          })\n        }\n      }\n    }\n\n    return () => {\n      transcriptEmitter.off('update', handleUpdate)\n    }\n  }, [trackedAgentIds])\n\n  // Get transcript by ID (with fallback to disk)\n  // IMPORTANT: This function may be called during render (e.g., by ParallelTasksGroupView),\n  // so we must NOT call setTranscripts here. Instead, we use a ref-based cache for lazy loading\n  // and schedule state updates via useEffect.\n  const getTranscriptCallback = useCallback(\n    (agentId: string): AgentTranscript | null => {\n      // Check state first (reactive updates)\n      const cached = transcripts.get(agentId)\n      if (cached) {\n        return cached\n      }\n\n      // Check ref cache (lazy loaded during render)\n      const lazyCached = lazyLoadCacheRef.current.get(agentId)\n      if (lazyCached) {\n        return lazyCached\n      }\n\n      // Try to load from disk - store in ref only (no setState during render!)\n      const loaded = getAgentTranscript(agentId)\n      if (loaded) {\n        lazyLoadCacheRef.current.set(agentId, loaded)\n      }\n      return loaded\n    },\n    [transcripts],\n  )\n\n  // Sync lazy-loaded transcripts from ref cache to state after render\n  // This ensures state stays up-to-date for future renders without causing\n  // \"Cannot update component while rendering\" warnings\n  useEffect(() => {\n    if (lazyLoadCacheRef.current.size > 0 && !syncScheduledRef.current) {\n      syncScheduledRef.current = true\n      const timeoutId = setTimeout(() => {\n        setTranscripts(prev => {\n          const next = new Map(prev)\n          for (const [agentId, transcript] of lazyLoadCacheRef.current) {\n            if (!next.has(agentId)) {\n              next.set(agentId, transcript)\n            }\n          }\n          return next\n        })\n        lazyLoadCacheRef.current = new Map()\n        syncScheduledRef.current = false\n      }, 0)\n      return () => {\n        clearTimeout(timeoutId)\n        syncScheduledRef.current = false\n      }\n    }\n  }, [transcripts])\n\n  // Force refresh a specific transcript\n  const refreshTranscript = useCallback((agentId: string) => {\n    const fresh = getAgentTranscript(agentId)\n    if (fresh) {\n      setTranscripts(prev => {\n        const next = new Map(prev)\n        next.set(agentId, fresh)\n        return next\n      })\n    }\n  }, [])\n\n  // Count active (non-completed) transcripts\n  const activeCount = useMemo(() => {\n    let count = 0\n    for (const transcript of transcripts.values()) {\n      if (transcript.status === 'running' || transcript.status === 'pending') {\n        count++\n      }\n    }\n    return count\n  }, [transcripts])\n\n  return {\n    transcripts,\n    getTranscript: getTranscriptCallback,\n    refreshTranscript,\n    activeCount,\n  }\n}\n\n/**\n * Simplified hook for single transcript tracking\n */\nexport function useAgentTranscript(\n  agentId: string | undefined,\n): AgentTranscript | null {\n  const [transcript, setTranscript] = useState<AgentTranscript | null>(() => {\n    if (!agentId) return null\n    return getAgentTranscript(agentId)\n  })\n\n  useEffect(() => {\n    if (!agentId) {\n      setTranscript(null)\n      return\n    }\n\n    // Load initial\n    const initial = getAgentTranscript(agentId)\n    if (initial) {\n      setTranscript(initial)\n    }\n\n    // Subscribe to updates for this specific agent\n    const handleUpdate = (event: TranscriptEvent) => {\n      if (event.agentId === agentId) {\n        setTranscript(event.transcript)\n      }\n    }\n\n    transcriptEmitter.on('update', handleUpdate)\n    return () => {\n      transcriptEmitter.off('update', handleUpdate)\n    }\n  }, [agentId])\n\n  return transcript\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/hooks/useAnimationSync.js

@@ -0,0 +1,53 @@
+import { useState, useEffect } from "react";
+import { animationSync, ANIMATION_INTERVALS } from "../utils/animationSync.js";
+function useAnimationSync() {
+  const [state, setState] = useState(
+    () => animationSync.getFrame()
+  );
+  useEffect(() => {
+    const unsubscribe = animationSync.subscribe((frame) => {
+      setState(frame);
+    });
+    return unsubscribe;
+  }, []);
+  return state;
+}
+function useSpinnerAnimation(frames) {
+  const [frameIndex, setFrameIndex] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrameIndex((f) => (f + 1) % frames.length);
+    }, ANIMATION_INTERVALS.SPINNER);
+    return () => clearInterval(timer);
+  }, [frames.length]);
+  return frames[frameIndex] || frames[0] || "";
+}
+function useBlinkAnimation() {
+  const [visible, setVisible] = useState(true);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setVisible((v) => !v);
+    }, ANIMATION_INTERVALS.BLINK);
+    return () => clearInterval(timer);
+  }, []);
+  return visible;
+}
+function useElapsedTime(startTime) {
+  const [elapsed, setElapsed] = useState(0);
+  const start = startTime ?? Date.now();
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setElapsed(Math.floor((Date.now() - start) / 1e3));
+    }, ANIMATION_INTERVALS.ELAPSED_TIME);
+    return () => clearInterval(timer);
+  }, [start]);
+  return elapsed;
+}
+export {
+  ANIMATION_INTERVALS,
+  useAnimationSync,
+  useBlinkAnimation,
+  useElapsedTime,
+  useSpinnerAnimation
+};
+//# sourceMappingURL=useAnimationSync.js.map

package/dist/hooks/useAnimationSync.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useAnimationSync.ts"],
+  "sourcesContent": ["/**\n * React hook for synchronized animations across components\n *\n * Provides synchronized animation state that updates at consistent intervals:\n * - Spinner: 120ms\n * - Blinking: 600ms\n * - Elapsed Time: 1000ms\n *\n * Usage:\n * ```tsx\n * function MySpinner() {\n *   const { spinnerFrame, blinkVisible, elapsedSeconds } = useAnimationSync()\n *   const spinnerChars = ['\u00B7', '\u2722', '\u2733', '\u2217', '\u273B', '\u273D']\n *   return <Text>{spinnerChars[spinnerFrame % spinnerChars.length]}</Text>\n * }\n * ```\n */\n\nimport { useState, useEffect, useCallback } from 'react'\nimport { animationSync, ANIMATION_INTERVALS } from '@utils/animationSync'\n\nexport interface AnimationState {\n  spinnerFrame: number\n  blinkVisible: boolean\n  elapsedSeconds: number\n}\n\n/**\n * Hook for synchronized animation state\n * Components using this hook will animate in sync with each other\n */\nexport function useAnimationSync(): AnimationState {\n  const [state, setState] = useState<AnimationState>(() =>\n    animationSync.getFrame(),\n  )\n\n  useEffect(() => {\n    const unsubscribe = animationSync.subscribe(frame => {\n      setState(frame)\n    })\n\n    return unsubscribe\n  }, [])\n\n  return state\n}\n\n/**\n * Hook for just the spinner animation (120ms interval)\n * Lighter weight than full animation sync if you only need spinner\n */\nexport function useSpinnerAnimation(frames: string[]): string {\n  const [frameIndex, setFrameIndex] = useState(0)\n\n  useEffect(() => {\n    const timer = setInterval(() => {\n      setFrameIndex(f => (f + 1) % frames.length)\n    }, ANIMATION_INTERVALS.SPINNER)\n\n    return () => clearInterval(timer)\n  }, [frames.length])\n\n  return frames[frameIndex] || frames[0] || ''\n}\n\n/**\n * Hook for blinking animation (600ms interval)\n */\nexport function useBlinkAnimation(): boolean {\n  const [visible, setVisible] = useState(true)\n\n  useEffect(() => {\n    const timer = setInterval(() => {\n      setVisible(v => !v)\n    }, ANIMATION_INTERVALS.BLINK)\n\n    return () => clearInterval(timer)\n  }, [])\n\n  return visible\n}\n\n/**\n * Hook for elapsed time counter (1000ms interval)\n */\nexport function useElapsedTime(startTime?: number): number {\n  const [elapsed, setElapsed] = useState(0)\n  const start = startTime ?? Date.now()\n\n  useEffect(() => {\n    const timer = setInterval(() => {\n      setElapsed(Math.floor((Date.now() - start) / 1000))\n    }, ANIMATION_INTERVALS.ELAPSED_TIME)\n\n    return () => clearInterval(timer)\n  }, [start])\n\n  return elapsed\n}\n\n// Re-export intervals for convenience\nexport { ANIMATION_INTERVALS }\n"],
+  "mappings": "AAkBA,SAAS,UAAU,iBAA8B;AACjD,SAAS,eAAe,2BAA2B;AAY5C,SAAS,mBAAmC;AACjD,QAAM,CAAC,OAAO,QAAQ,IAAI;AAAA,IAAyB,MACjD,cAAc,SAAS;AAAA,EACzB;AAEA,YAAU,MAAM;AACd,UAAM,cAAc,cAAc,UAAU,WAAS;AACnD,eAAS,KAAK;AAAA,IAChB,CAAC;AAED,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;AAMO,SAAS,oBAAoB,QAA0B;AAC5D,QAAM,CAAC,YAAY,aAAa,IAAI,SAAS,CAAC;AAE9C,YAAU,MAAM;AACd,UAAM,QAAQ,YAAY,MAAM;AAC9B,oBAAc,QAAM,IAAI,KAAK,OAAO,MAAM;AAAA,IAC5C,GAAG,oBAAoB,OAAO;AAE9B,WAAO,MAAM,cAAc,KAAK;AAAA,EAClC,GAAG,CAAC,OAAO,MAAM,CAAC;AAElB,SAAO,OAAO,UAAU,KAAK,OAAO,CAAC,KAAK;AAC5C;AAKO,SAAS,oBAA6B;AAC3C,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,IAAI;AAE3C,YAAU,MAAM;AACd,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,OAAK,CAAC,CAAC;AAAA,IACpB,GAAG,oBAAoB,KAAK;AAE5B,WAAO,MAAM,cAAc,KAAK;AAAA,EAClC,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;AAKO,SAAS,eAAe,WAA4B;AACzD,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,CAAC;AACxC,QAAM,QAAQ,aAAa,KAAK,IAAI;AAEpC,YAAU,MAAM;AACd,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,KAAK,OAAO,KAAK,IAAI,IAAI,SAAS,GAAI,CAAC;AAAA,IACpD,GAAG,oBAAoB,YAAY;AAEnC,WAAO,MAAM,cAAc,KAAK;AAAA,EAClC,GAAG,CAAC,KAAK,CAAC;AAEV,SAAO;AACT;",
+  "names": []
+}

package/dist/hooks/useArrowKeyHistory.js

@@ -1,12 +1,14 @@
 import { useState } from "react";
 import { getHistory } from "../history.js";
+import { sanitizeInput } from "../utils/sanitizeInput.js";
 function useArrowKeyHistory(onSetInput, currentInput) {
   const [historyIndex, setHistoryIndex] = useState(0);
   const [lastTypedInput, setLastTypedInput] = useState("");
   const updateInput = (input) => {
     if (input !== void 0) {
-      const mode = input.startsWith("!") ? "bash" : "prompt";
-      const value = mode === "bash" ? input.slice(1) : input;
+      const sanitized = sanitizeInput(input);
+      const mode = sanitized.startsWith("!") ? "bash" : "prompt";
+      const value = mode === "bash" ? sanitized.slice(1) : sanitized;
       onSetInput(value, mode);
     }
   };

package/dist/hooks/useArrowKeyHistory.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/hooks/useArrowKeyHistory.ts"],
-  "sourcesContent": ["import { useState } from 'react'\nimport { getHistory } from '@history'\n\nexport function useArrowKeyHistory(\n  onSetInput: (value: string, mode: 'bash' | 'prompt') => void,\n  currentInput: string,\n) {\n  const [historyIndex, setHistoryIndex] = useState(0)\n  const [lastTypedInput, setLastTypedInput] = useState('')\n\n  const updateInput = (input: string | undefined) => {\n    if (input !== undefined) {\n      const mode = input.startsWith('!') ? 'bash' : 'prompt'\n      const value = mode === 'bash' ? input.slice(1) : input\n      onSetInput(value, mode)\n    }\n  }\n\n  function onHistoryUp() {\n    const latestHistory = getHistory()\n    if (historyIndex < latestHistory.length) {\n      if (historyIndex === 0 && currentInput.trim() !== '') {\n        setLastTypedInput(currentInput)\n      }\n      const newIndex = historyIndex + 1\n      setHistoryIndex(newIndex)\n      updateInput(latestHistory[historyIndex])\n    }\n  }\n\n  function onHistoryDown() {\n    const latestHistory = getHistory()\n    if (historyIndex > 1) {\n      const newIndex = historyIndex - 1\n      setHistoryIndex(newIndex)\n      updateInput(latestHistory[newIndex - 1])\n    } else if (historyIndex === 1) {\n      setHistoryIndex(0)\n      updateInput(lastTypedInput)\n    }\n  }\n\n  function resetHistory() {\n    setLastTypedInput('')\n    setHistoryIndex(0)\n  }\n\n  return {\n    historyIndex,\n    setHistoryIndex,\n    onHistoryUp,\n    onHistoryDown,\n    resetHistory,\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAEpB,SAAS,mBACd,YACA,cACA;AACA,QAAM,CAAC,cAAc,eAAe,IAAI,SAAS,CAAC;AAClD,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,SAAS,EAAE;AAEvD,QAAM,cAAc,CAAC,UAA8B;AACjD,QAAI,UAAU,QAAW;AACvB,YAAM,OAAO,MAAM,WAAW,GAAG,IAAI,SAAS;AAC9C,YAAM,QAAQ,SAAS,SAAS,MAAM,MAAM,CAAC,IAAI;AACjD,iBAAW,OAAO,IAAI;AAAA,IACxB;AAAA,EACF;AAEA,WAAS,cAAc;AACrB,UAAM,gBAAgB,WAAW;AACjC,QAAI,eAAe,cAAc,QAAQ;AACvC,UAAI,iBAAiB,KAAK,aAAa,KAAK,MAAM,IAAI;AACpD,0BAAkB,YAAY;AAAA,MAChC;AACA,YAAM,WAAW,eAAe;AAChC,sBAAgB,QAAQ;AACxB,kBAAY,cAAc,YAAY,CAAC;AAAA,IACzC;AAAA,EACF;AAEA,WAAS,gBAAgB;AACvB,UAAM,gBAAgB,WAAW;AACjC,QAAI,eAAe,GAAG;AACpB,YAAM,WAAW,eAAe;AAChC,sBAAgB,QAAQ;AACxB,kBAAY,cAAc,WAAW,CAAC,CAAC;AAAA,IACzC,WAAW,iBAAiB,GAAG;AAC7B,sBAAgB,CAAC;AACjB,kBAAY,cAAc;AAAA,IAC5B;AAAA,EACF;AAEA,WAAS,eAAe;AACtB,sBAAkB,EAAE;AACpB,oBAAgB,CAAC;AAAA,EACnB;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
+  "sourcesContent": ["import { useState } from 'react'\nimport { getHistory } from '@history'\nimport { sanitizeInput } from '@utils/sanitizeInput'\n\nexport function useArrowKeyHistory(\n  onSetInput: (value: string, mode: 'bash' | 'prompt') => void,\n  currentInput: string,\n) {\n  const [historyIndex, setHistoryIndex] = useState(0)\n  const [lastTypedInput, setLastTypedInput] = useState('')\n\n  const updateInput = (input: string | undefined) => {\n    if (input !== undefined) {\n      // Sanitize input to remove dangerous escape sequences\n      // This prevents corrupt history entries (like \"\\x1b\\x1bclear\") from\n      // triggering terminal resets when loaded\n      const sanitized = sanitizeInput(input)\n      const mode = sanitized.startsWith('!') ? 'bash' : 'prompt'\n      const value = mode === 'bash' ? sanitized.slice(1) : sanitized\n      onSetInput(value, mode)\n    }\n  }\n\n  function onHistoryUp() {\n    const latestHistory = getHistory()\n    if (historyIndex < latestHistory.length) {\n      if (historyIndex === 0 && currentInput.trim() !== '') {\n        setLastTypedInput(currentInput)\n      }\n      const newIndex = historyIndex + 1\n      setHistoryIndex(newIndex)\n      updateInput(latestHistory[historyIndex])\n    }\n  }\n\n  function onHistoryDown() {\n    const latestHistory = getHistory()\n    if (historyIndex > 1) {\n      const newIndex = historyIndex - 1\n      setHistoryIndex(newIndex)\n      updateInput(latestHistory[newIndex - 1])\n    } else if (historyIndex === 1) {\n      setHistoryIndex(0)\n      updateInput(lastTypedInput)\n    }\n  }\n\n  function resetHistory() {\n    setLastTypedInput('')\n    setHistoryIndex(0)\n  }\n\n  return {\n    historyIndex,\n    setHistoryIndex,\n    onHistoryUp,\n    onHistoryDown,\n    resetHistory,\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,qBAAqB;AAEvB,SAAS,mBACd,YACA,cACA;AACA,QAAM,CAAC,cAAc,eAAe,IAAI,SAAS,CAAC;AAClD,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,SAAS,EAAE;AAEvD,QAAM,cAAc,CAAC,UAA8B;AACjD,QAAI,UAAU,QAAW;AAIvB,YAAM,YAAY,cAAc,KAAK;AACrC,YAAM,OAAO,UAAU,WAAW,GAAG,IAAI,SAAS;AAClD,YAAM,QAAQ,SAAS,SAAS,UAAU,MAAM,CAAC,IAAI;AACrD,iBAAW,OAAO,IAAI;AAAA,IACxB;AAAA,EACF;AAEA,WAAS,cAAc;AACrB,UAAM,gBAAgB,WAAW;AACjC,QAAI,eAAe,cAAc,QAAQ;AACvC,UAAI,iBAAiB,KAAK,aAAa,KAAK,MAAM,IAAI;AACpD,0BAAkB,YAAY;AAAA,MAChC;AACA,YAAM,WAAW,eAAe;AAChC,sBAAgB,QAAQ;AACxB,kBAAY,cAAc,YAAY,CAAC;AAAA,IACzC;AAAA,EACF;AAEA,WAAS,gBAAgB;AACvB,UAAM,gBAAgB,WAAW;AACjC,QAAI,eAAe,GAAG;AACpB,YAAM,WAAW,eAAe;AAChC,sBAAgB,QAAQ;AACxB,kBAAY,cAAc,WAAW,CAAC,CAAC;AAAA,IACzC,WAAW,iBAAiB,GAAG;AAC7B,sBAAgB,CAAC;AACjB,kBAAY,cAAc;AAAA,IAC5B;AAAA,EACF;AAEA,WAAS,eAAe;AACtB,sBAAkB,EAAE;AACpB,oBAAgB,CAAC;AAAA,EACnB;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
   "names": []
 }

package/dist/hooks/useCanUseTool.js

@@ -3,6 +3,7 @@ import { hasPermissionsToUseTool } from "../permissions.js";
 import { BashTool, inputSchema } from "../tools/BashTool/BashTool.js";
 import { getCommandSubcommandPrefix } from "../utils/commands.js";
 import { REJECT_MESSAGE } from "../utils/messages.js";
+import { getToolDescriptionAsync } from "../Tool.js";
 import { AbortError } from "../utils/errors.js";
 import { logError } from "../utils/log.js";
 function useCanUseTool(setToolUseConfirm) {
@@ -34,7 +35,8 @@ function useCanUseTool(setToolUseConfirm) {
             return;
           }
           const [description, commandPrefix] = await Promise.all([
-            tool.description(input),
+            // Use getToolDescriptionAsync for safe async access
+            getToolDescriptionAsync(tool, input),
             tool === BashTool ? getCommandSubcommandPrefix(
               inputSchema.parse(input).command,
               // already validated upstream, so ok to parse (as opposed to safeParse)

package/dist/hooks/useCanUseTool.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/hooks/useCanUseTool.ts"],
-  "sourcesContent": ["import React, { useCallback } from 'react'\nimport { hasPermissionsToUseTool } from '@permissions'\nimport { BashTool, inputSchema } from '@tools/BashTool/BashTool'\nimport { getCommandSubcommandPrefix } from '@utils/commands'\nimport { REJECT_MESSAGE } from '@utils/messages'\nimport type { Tool as ToolType, ToolUseContext } from '@tool'\nimport { AssistantMessage } from '@query'\nimport { ToolUseConfirm } from '@components/permissions/PermissionRequest'\nimport { AbortError } from '@utils/errors'\nimport { logError } from '@utils/log'\n\ntype SetState<T> = React.Dispatch<React.SetStateAction<T>>\n\nexport type CanUseToolFn = (\n  tool: ToolType,\n  input: { [key: string]: unknown },\n  toolUseContext: ToolUseContext,\n  assistantMessage: AssistantMessage,\n) => Promise<{ result: true } | { result: false; message: string }>\n\nfunction useCanUseTool(\n  setToolUseConfirm: SetState<ToolUseConfirm | null>,\n): CanUseToolFn {\n  return useCallback<CanUseToolFn>(\n    async (tool, input, toolUseContext, assistantMessage) => {\n      return new Promise(resolve => {\n        function logCancelledEvent() {}\n\n        function resolveWithCancelledAndAbortAllToolCalls() {\n          resolve({\n            result: false,\n            message: REJECT_MESSAGE,\n          })\n          // Trigger a synthetic assistant message in query(), to cancel\n          // any other pending tool uses and stop further requests to the\n          // API and wait for user input.\n          toolUseContext.abortController.abort()\n        }\n\n        if (toolUseContext.abortController.signal.aborted) {\n          logCancelledEvent()\n          resolveWithCancelledAndAbortAllToolCalls()\n          return\n        }\n\n        return hasPermissionsToUseTool(\n          tool,\n          input,\n          toolUseContext,\n          assistantMessage,\n        )\n          .then(async result => {\n            // Has permissions to use tool, granted in config\n            if (result.result) {\n              resolve({ result: true })\n              return\n            }\n\n            const [description, commandPrefix] = await Promise.all([\n              tool.description(input as never),\n              tool === BashTool\n                ? getCommandSubcommandPrefix(\n                    inputSchema.parse(input).command, // already validated upstream, so ok to parse (as opposed to safeParse)\n                    toolUseContext.abortController.signal,\n                  )\n                : Promise.resolve(null),\n            ])\n\n            if (toolUseContext.abortController.signal.aborted) {\n              logCancelledEvent()\n              resolveWithCancelledAndAbortAllToolCalls()\n              return\n            }\n\n            // Does not have permissions to use tool, ask the user\n            setToolUseConfirm({\n              assistantMessage,\n              tool,\n              description,\n              input,\n              commandPrefix,\n              riskScore: null,\n              onAbort() {\n                logCancelledEvent()\n                resolveWithCancelledAndAbortAllToolCalls()\n              },\n              onAllow(type) {\n                if (type === 'permanent') {\n                } else {\n                }\n                resolve({ result: true })\n              },\n              onReject() {\n                resolveWithCancelledAndAbortAllToolCalls()\n              },\n            })\n          })\n          .catch(error => {\n            if (error instanceof AbortError) {\n              logCancelledEvent()\n              resolveWithCancelledAndAbortAllToolCalls()\n            } else {\n              logError(error)\n            }\n          })\n      })\n    },\n    [setToolUseConfirm],\n  )\n}\n\nexport default useCanUseTool\n"],
-  "mappings": "AAAA,SAAgB,mBAAmB;AACnC,SAAS,+BAA+B;AACxC,SAAS,UAAU,mBAAmB;AACtC,SAAS,kCAAkC;AAC3C,SAAS,sBAAsB;AAI/B,SAAS,kBAAkB;AAC3B,SAAS,gBAAgB;AAWzB,SAAS,cACP,mBACc;AACd,SAAO;AAAA,IACL,OAAO,MAAM,OAAO,gBAAgB,qBAAqB;AACvD,aAAO,IAAI,QAAQ,aAAW;AAC5B,iBAAS,oBAAoB;AAAA,QAAC;AAE9B,iBAAS,2CAA2C;AAClD,kBAAQ;AAAA,YACN,QAAQ;AAAA,YACR,SAAS;AAAA,UACX,CAAC;AAID,yBAAe,gBAAgB,MAAM;AAAA,QACvC;AAEA,YAAI,eAAe,gBAAgB,OAAO,SAAS;AACjD,4BAAkB;AAClB,mDAAyC;AACzC;AAAA,QACF;AAEA,eAAO;AAAA,UACL;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF,EACG,KAAK,OAAM,WAAU;AAEpB,cAAI,OAAO,QAAQ;AACjB,oBAAQ,EAAE,QAAQ,KAAK,CAAC;AACxB;AAAA,UACF;AAEA,gBAAM,CAAC,aAAa,aAAa,IAAI,MAAM,QAAQ,IAAI;AAAA,YACrD,KAAK,YAAY,KAAc;AAAA,YAC/B,SAAS,WACL;AAAA,cACE,YAAY,MAAM,KAAK,EAAE;AAAA;AAAA,cACzB,eAAe,gBAAgB;AAAA,YACjC,IACA,QAAQ,QAAQ,IAAI;AAAA,UAC1B,CAAC;AAED,cAAI,eAAe,gBAAgB,OAAO,SAAS;AACjD,8BAAkB;AAClB,qDAAyC;AACzC;AAAA,UACF;AAGA,4BAAkB;AAAA,YAChB;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA,WAAW;AAAA,YACX,UAAU;AACR,gCAAkB;AAClB,uDAAyC;AAAA,YAC3C;AAAA,YACA,QAAQ,MAAM;AACZ,kBAAI,SAAS,aAAa;AAAA,cAC1B,OAAO;AAAA,cACP;AACA,sBAAQ,EAAE,QAAQ,KAAK,CAAC;AAAA,YAC1B;AAAA,YACA,WAAW;AACT,uDAAyC;AAAA,YAC3C;AAAA,UACF,CAAC;AAAA,QACH,CAAC,EACA,MAAM,WAAS;AACd,cAAI,iBAAiB,YAAY;AAC/B,8BAAkB;AAClB,qDAAyC;AAAA,UAC3C,OAAO;AACL,qBAAS,KAAK;AAAA,UAChB;AAAA,QACF,CAAC;AAAA,MACL,CAAC;AAAA,IACH;AAAA,IACA,CAAC,iBAAiB;AAAA,EACpB;AACF;AAEA,IAAO,wBAAQ;",
+  "sourcesContent": ["import React, { useCallback } from 'react'\nimport { hasPermissionsToUseTool } from '@permissions'\nimport { BashTool, inputSchema } from '@tools/BashTool/BashTool'\nimport { getCommandSubcommandPrefix } from '@utils/commands'\nimport { REJECT_MESSAGE } from '@utils/messages'\nimport type { Tool as ToolType, ToolUseContext } from '@tool'\nimport { getToolDescriptionAsync } from '@tool'\nimport { AssistantMessage } from '@query'\nimport { ToolUseConfirm } from '@components/permissions/PermissionRequest'\nimport { AbortError } from '@utils/errors'\nimport { logError } from '@utils/log'\n\ntype SetState<T> = React.Dispatch<React.SetStateAction<T>>\n\nexport type CanUseToolFn = (\n  tool: ToolType,\n  input: { [key: string]: unknown },\n  toolUseContext: ToolUseContext,\n  assistantMessage: AssistantMessage,\n) => Promise<{ result: true } | { result: false; message: string }>\n\nfunction useCanUseTool(\n  setToolUseConfirm: SetState<ToolUseConfirm | null>,\n): CanUseToolFn {\n  return useCallback<CanUseToolFn>(\n    async (tool, input, toolUseContext, assistantMessage) => {\n      return new Promise(resolve => {\n        function logCancelledEvent() {}\n\n        function resolveWithCancelledAndAbortAllToolCalls() {\n          resolve({\n            result: false,\n            message: REJECT_MESSAGE,\n          })\n          // Trigger a synthetic assistant message in query(), to cancel\n          // any other pending tool uses and stop further requests to the\n          // API and wait for user input.\n          toolUseContext.abortController.abort()\n        }\n\n        if (toolUseContext.abortController.signal.aborted) {\n          logCancelledEvent()\n          resolveWithCancelledAndAbortAllToolCalls()\n          return\n        }\n\n        return hasPermissionsToUseTool(\n          tool,\n          input,\n          toolUseContext,\n          assistantMessage,\n        )\n          .then(async result => {\n            // Has permissions to use tool, granted in config\n            if (result.result) {\n              resolve({ result: true })\n              return\n            }\n\n            const [description, commandPrefix] = await Promise.all([\n              // Use getToolDescriptionAsync for safe async access\n              getToolDescriptionAsync(tool, input),\n              tool === BashTool\n                ? getCommandSubcommandPrefix(\n                    inputSchema.parse(input).command, // already validated upstream, so ok to parse (as opposed to safeParse)\n                    toolUseContext.abortController.signal,\n                  )\n                : Promise.resolve(null),\n            ])\n\n            if (toolUseContext.abortController.signal.aborted) {\n              logCancelledEvent()\n              resolveWithCancelledAndAbortAllToolCalls()\n              return\n            }\n\n            // Does not have permissions to use tool, ask the user\n            setToolUseConfirm({\n              assistantMessage,\n              tool,\n              description,\n              input,\n              commandPrefix,\n              riskScore: null,\n              onAbort() {\n                logCancelledEvent()\n                resolveWithCancelledAndAbortAllToolCalls()\n              },\n              onAllow(type) {\n                if (type === 'permanent') {\n                } else {\n                }\n                resolve({ result: true })\n              },\n              onReject() {\n                resolveWithCancelledAndAbortAllToolCalls()\n              },\n            })\n          })\n          .catch(error => {\n            if (error instanceof AbortError) {\n              logCancelledEvent()\n              resolveWithCancelledAndAbortAllToolCalls()\n            } else {\n              logError(error)\n            }\n          })\n      })\n    },\n    [setToolUseConfirm],\n  )\n}\n\nexport default useCanUseTool\n"],
+  "mappings": "AAAA,SAAgB,mBAAmB;AACnC,SAAS,+BAA+B;AACxC,SAAS,UAAU,mBAAmB;AACtC,SAAS,kCAAkC;AAC3C,SAAS,sBAAsB;AAE/B,SAAS,+BAA+B;AAGxC,SAAS,kBAAkB;AAC3B,SAAS,gBAAgB;AAWzB,SAAS,cACP,mBACc;AACd,SAAO;AAAA,IACL,OAAO,MAAM,OAAO,gBAAgB,qBAAqB;AACvD,aAAO,IAAI,QAAQ,aAAW;AAC5B,iBAAS,oBAAoB;AAAA,QAAC;AAE9B,iBAAS,2CAA2C;AAClD,kBAAQ;AAAA,YACN,QAAQ;AAAA,YACR,SAAS;AAAA,UACX,CAAC;AAID,yBAAe,gBAAgB,MAAM;AAAA,QACvC;AAEA,YAAI,eAAe,gBAAgB,OAAO,SAAS;AACjD,4BAAkB;AAClB,mDAAyC;AACzC;AAAA,QACF;AAEA,eAAO;AAAA,UACL;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF,EACG,KAAK,OAAM,WAAU;AAEpB,cAAI,OAAO,QAAQ;AACjB,oBAAQ,EAAE,QAAQ,KAAK,CAAC;AACxB;AAAA,UACF;AAEA,gBAAM,CAAC,aAAa,aAAa,IAAI,MAAM,QAAQ,IAAI;AAAA;AAAA,YAErD,wBAAwB,MAAM,KAAK;AAAA,YACnC,SAAS,WACL;AAAA,cACE,YAAY,MAAM,KAAK,EAAE;AAAA;AAAA,cACzB,eAAe,gBAAgB;AAAA,YACjC,IACA,QAAQ,QAAQ,IAAI;AAAA,UAC1B,CAAC;AAED,cAAI,eAAe,gBAAgB,OAAO,SAAS;AACjD,8BAAkB;AAClB,qDAAyC;AACzC;AAAA,UACF;AAGA,4BAAkB;AAAA,YAChB;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA,WAAW;AAAA,YACX,UAAU;AACR,gCAAkB;AAClB,uDAAyC;AAAA,YAC3C;AAAA,YACA,QAAQ,MAAM;AACZ,kBAAI,SAAS,aAAa;AAAA,cAC1B,OAAO;AAAA,cACP;AACA,sBAAQ,EAAE,QAAQ,KAAK,CAAC;AAAA,YAC1B;AAAA,YACA,WAAW;AACT,uDAAyC;AAAA,YAC3C;AAAA,UACF,CAAC;AAAA,QACH,CAAC,EACA,MAAM,WAAS;AACd,cAAI,iBAAiB,YAAY;AAC/B,8BAAkB;AAClB,qDAAyC;AAAA,UAC3C,OAAO;AACL,qBAAS,KAAK;AAAA,UAChB;AAAA,QACF,CAAC;AAAA,MACL,CAAC;AAAA,IACH;AAAA,IACA,CAAC,iBAAiB;AAAA,EACpB;AACF;AAEA,IAAO,wBAAQ;",
   "names": []
 }

package/dist/hooks/useExitOnCtrlCD.js

@@ -1,7 +1,8 @@
 import { useInput } from "ink";
 import { useDoublePress } from "./useDoublePress.js";
 import { useState } from "react";
-function useExitOnCtrlCD(onExit) {
+function useExitOnCtrlCD(onExit, options = {}) {
+  const { isActive = true } = options;
   const [exitState, setExitState] = useState({
     pending: false,
     keyName: null
@@ -14,10 +15,13 @@ function useExitOnCtrlCD(onExit) {
     (pending) => setExitState({ pending, keyName: "Ctrl-D" }),
     onExit
   );
-  useInput((input, key) => {
-    if (key.ctrl && input === "c") handleCtrlC();
-    if (key.ctrl && input === "d") handleCtrlD();
-  });
+  useInput(
+    (input, key) => {
+      if (key.ctrl && input === "c") handleCtrlC();
+      if (key.ctrl && input === "d") handleCtrlD();
+    },
+    { isActive }
+  );
   return exitState;
 }
 export {

package/dist/hooks/useExitOnCtrlCD.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/hooks/useExitOnCtrlCD.ts"],
-  "sourcesContent": ["import { useInput } from 'ink'\nimport { useDoublePress } from './useDoublePress'\nimport { useState } from 'react'\n\ntype ExitState = {\n  pending: boolean\n  keyName: 'Ctrl-C' | 'Ctrl-D' | null\n}\n\nexport function useExitOnCtrlCD(onExit: () => void): ExitState {\n  const [exitState, setExitState] = useState<ExitState>({\n    pending: false,\n    keyName: null,\n  })\n\n  const handleCtrlC = useDoublePress(\n    pending => setExitState({ pending, keyName: 'Ctrl-C' }),\n    onExit,\n  )\n  const handleCtrlD = useDoublePress(\n    pending => setExitState({ pending, keyName: 'Ctrl-D' }),\n    onExit,\n  )\n\n  useInput((input, key) => {\n    if (key.ctrl && input === 'c') handleCtrlC()\n    if (key.ctrl && input === 'd') handleCtrlD()\n  })\n\n  return exitState\n}\n"],
-  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,sBAAsB;AAC/B,SAAS,gBAAgB;AAOlB,SAAS,gBAAgB,QAA+B;AAC7D,QAAM,CAAC,WAAW,YAAY,IAAI,SAAoB;AAAA,IACpD,SAAS;AAAA,IACT,SAAS;AAAA,EACX,CAAC;AAED,QAAM,cAAc;AAAA,IAClB,aAAW,aAAa,EAAE,SAAS,SAAS,SAAS,CAAC;AAAA,IACtD;AAAA,EACF;AACA,QAAM,cAAc;AAAA,IAClB,aAAW,aAAa,EAAE,SAAS,SAAS,SAAS,CAAC;AAAA,IACtD;AAAA,EACF;AAEA,WAAS,CAAC,OAAO,QAAQ;AACvB,QAAI,IAAI,QAAQ,UAAU,IAAK,aAAY;AAC3C,QAAI,IAAI,QAAQ,UAAU,IAAK,aAAY;AAAA,EAC7C,CAAC;AAED,SAAO;AACT;",
+  "sourcesContent": ["import { useInput } from 'ink'\nimport { useDoublePress } from './useDoublePress'\nimport { useState } from 'react'\n\ntype ExitState = {\n  pending: boolean\n  keyName: 'Ctrl-C' | 'Ctrl-D' | null\n}\n\ntype Options = {\n  isActive?: boolean\n}\n\nexport function useExitOnCtrlCD(\n  onExit: () => void,\n  options: Options = {},\n): ExitState {\n  const { isActive = true } = options\n  const [exitState, setExitState] = useState<ExitState>({\n    pending: false,\n    keyName: null,\n  })\n\n  const handleCtrlC = useDoublePress(\n    pending => setExitState({ pending, keyName: 'Ctrl-C' }),\n    onExit,\n  )\n  const handleCtrlD = useDoublePress(\n    pending => setExitState({ pending, keyName: 'Ctrl-D' }),\n    onExit,\n  )\n\n  // Support isActive option to conditionally enable/disable input handling\n  // This helps prevent EventEmitter listener accumulation in nested components\n  useInput(\n    (input, key) => {\n      if (key.ctrl && input === 'c') handleCtrlC()\n      if (key.ctrl && input === 'd') handleCtrlD()\n    },\n    { isActive },\n  )\n\n  return exitState\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,sBAAsB;AAC/B,SAAS,gBAAgB;AAWlB,SAAS,gBACd,QACA,UAAmB,CAAC,GACT;AACX,QAAM,EAAE,WAAW,KAAK,IAAI;AAC5B,QAAM,CAAC,WAAW,YAAY,IAAI,SAAoB;AAAA,IACpD,SAAS;AAAA,IACT,SAAS;AAAA,EACX,CAAC;AAED,QAAM,cAAc;AAAA,IAClB,aAAW,aAAa,EAAE,SAAS,SAAS,SAAS,CAAC;AAAA,IACtD;AAAA,EACF;AACA,QAAM,cAAc;AAAA,IAClB,aAAW,aAAa,EAAE,SAAS,SAAS,SAAS,CAAC;AAAA,IACtD;AAAA,EACF;AAIA;AAAA,IACE,CAAC,OAAO,QAAQ;AACd,UAAI,IAAI,QAAQ,UAAU,IAAK,aAAY;AAC3C,UAAI,IAAI,QAAQ,UAAU,IAAK,aAAY;AAAA,IAC7C;AAAA,IACA,EAAE,SAAS;AAAA,EACb;AAEA,SAAO;AACT;",
   "names": []
 }

package/dist/hooks/useHookStatus.js

@@ -0,0 +1,40 @@
+import { useState, useEffect, useCallback } from "react";
+import { hookStatusEmitter } from "../services/hookExecutor.js";
+function useHookStatus(enabled) {
+  const [state, setState] = useState({
+    recentEvents: [],
+    successCount: 0,
+    failureCount: 0
+  });
+  const handleStatus = useCallback((event) => {
+    setState((prev) => ({
+      recentEvents: [...prev.recentEvents.slice(-9), event],
+      // Keep last 10
+      successCount: prev.successCount + (event.success ? 1 : 0),
+      failureCount: prev.failureCount + (event.success ? 0 : 1)
+    }));
+  }, []);
+  useEffect(() => {
+    if (!enabled) return;
+    hookStatusEmitter.on("status", handleStatus);
+    return () => {
+      hookStatusEmitter.off("status", handleStatus);
+    };
+  }, [enabled, handleStatus]);
+  return state;
+}
+function formatHookStatus(event) {
+  const timestamp = new Date(event.timestamp).toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: true
+  });
+  const status = event.success ? "\u2713" : "\u2717";
+  return `${timestamp} ${status} ${event.message}`;
+}
+export {
+  formatHookStatus,
+  useHookStatus
+};
+//# sourceMappingURL=useHookStatus.js.map

package/dist/hooks/useHookStatus.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useHookStatus.ts"],
+  "sourcesContent": ["/**\n * Hook Status Tracking for Verbose Mode\n *\n * Listens to hookStatusEmitter and provides status information\n * for display in verbose mode.\n */\n\nimport { useState, useEffect, useCallback } from 'react'\nimport { hookStatusEmitter, HookStatusEvent } from '@services/hookExecutor'\n\ninterface HookStatusState {\n  /** Recent hook events (last 10) */\n  recentEvents: HookStatusEvent[]\n  /** Count of successful hooks */\n  successCount: number\n  /** Count of failed hooks */\n  failureCount: number\n}\n\n/**\n * Hook to track hook status events for verbose mode display\n *\n * @param enabled - Whether to listen for events (should be verbose mode)\n * @returns Hook status state\n */\nexport function useHookStatus(enabled: boolean): HookStatusState {\n  const [state, setState] = useState<HookStatusState>({\n    recentEvents: [],\n    successCount: 0,\n    failureCount: 0,\n  })\n\n  const handleStatus = useCallback((event: HookStatusEvent) => {\n    setState(prev => ({\n      recentEvents: [...prev.recentEvents.slice(-9), event], // Keep last 10\n      successCount: prev.successCount + (event.success ? 1 : 0),\n      failureCount: prev.failureCount + (event.success ? 0 : 1),\n    }))\n  }, [])\n\n  useEffect(() => {\n    if (!enabled) return\n\n    hookStatusEmitter.on('status', handleStatus)\n    return () => {\n      hookStatusEmitter.off('status', handleStatus)\n    }\n  }, [enabled, handleStatus])\n\n  return state\n}\n\n/**\n * Format hook status for display\n */\nexport function formatHookStatus(event: HookStatusEvent): string {\n  const timestamp = new Date(event.timestamp).toLocaleTimeString('en-US', {\n    hour: 'numeric',\n    minute: '2-digit',\n    second: '2-digit',\n    hour12: true,\n  })\n  const status = event.success ? '\u2713' : '\u2717'\n  return `${timestamp} ${status} ${event.message}`\n}\n"],
+  "mappings": "AAOA,SAAS,UAAU,WAAW,mBAAmB;AACjD,SAAS,yBAA0C;AAiB5C,SAAS,cAAc,SAAmC;AAC/D,QAAM,CAAC,OAAO,QAAQ,IAAI,SAA0B;AAAA,IAClD,cAAc,CAAC;AAAA,IACf,cAAc;AAAA,IACd,cAAc;AAAA,EAChB,CAAC;AAED,QAAM,eAAe,YAAY,CAAC,UAA2B;AAC3D,aAAS,WAAS;AAAA,MAChB,cAAc,CAAC,GAAG,KAAK,aAAa,MAAM,EAAE,GAAG,KAAK;AAAA;AAAA,MACpD,cAAc,KAAK,gBAAgB,MAAM,UAAU,IAAI;AAAA,MACvD,cAAc,KAAK,gBAAgB,MAAM,UAAU,IAAI;AAAA,IACzD,EAAE;AAAA,EACJ,GAAG,CAAC,CAAC;AAEL,YAAU,MAAM;AACd,QAAI,CAAC,QAAS;AAEd,sBAAkB,GAAG,UAAU,YAAY;AAC3C,WAAO,MAAM;AACX,wBAAkB,IAAI,UAAU,YAAY;AAAA,IAC9C;AAAA,EACF,GAAG,CAAC,SAAS,YAAY,CAAC;AAE1B,SAAO;AACT;AAKO,SAAS,iBAAiB,OAAgC;AAC/D,QAAM,YAAY,IAAI,KAAK,MAAM,SAAS,EAAE,mBAAmB,SAAS;AAAA,IACtE,MAAM;AAAA,IACN,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV,CAAC;AACD,QAAM,SAAS,MAAM,UAAU,WAAM;AACrC,SAAO,GAAG,SAAS,IAAI,MAAM,IAAI,MAAM,OAAO;AAChD;",
+  "names": []
+}

package/dist/hooks/useLogMessages.js

@@ -1,14 +1,41 @@
-import { useEffect } from "react";
+import { useEffect, useRef } from "react";
 import { overwriteLog, getMessagesPath } from "../utils/log.js";
+function serializeMessageForLog(message) {
+  if (message.type === "progress") {
+    const progressMsg = message;
+    return {
+      type: "progress",
+      uuid: progressMsg.uuid,
+      toolUseID: progressMsg.toolUseID,
+      // Convert Set to Array for JSON serialization
+      siblingToolUseIDs: Array.from(progressMsg.siblingToolUseIDs),
+      // Keep the content (AssistantMessage) for display
+      content: progressMsg.content
+    };
+  }
+  return message;
+}
 function useLogMessages(messages, messageLogName, forkNumber) {
+  const messagesRef = useRef(messages);
+  messagesRef.current = messages;
+  useEffect(() => {
+    return () => {
+      if (messagesRef.current.length > 0) {
+        const serialized = messagesRef.current.map(serializeMessageForLog);
+        overwriteLog(getMessagesPath(messageLogName, forkNumber, 0), serialized);
+      }
+    };
+  }, [messageLogName, forkNumber]);
   useEffect(() => {
+    const serializedMessages = messages.map(serializeMessageForLog);
     overwriteLog(
       getMessagesPath(messageLogName, forkNumber, 0),
-      messages.filter((_) => _.type !== "progress")
+      serializedMessages
     );
   }, [messages, messageLogName, forkNumber]);
 }
 export {
+  serializeMessageForLog,
   useLogMessages
 };
 //# sourceMappingURL=useLogMessages.js.map

package/dist/hooks/useLogMessages.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/hooks/useLogMessages.ts"],
-  "sourcesContent": ["import { useEffect } from 'react'\nimport { type Message } from '@query'\nimport { overwriteLog, getMessagesPath } from '@utils/log'\n\nexport function useLogMessages(\n  messages: Message[],\n  messageLogName: string,\n  forkNumber: number,\n): void {\n  useEffect(() => {\n    overwriteLog(\n      getMessagesPath(messageLogName, forkNumber, 0),\n      messages.filter(_ => _.type !== 'progress'),\n    )\n  }, [messages, messageLogName, forkNumber])\n}\n"],
-  "mappings": "AAAA,SAAS,iBAAiB;AAE1B,SAAS,cAAc,uBAAuB;AAEvC,SAAS,eACd,UACA,gBACA,YACM;AACN,YAAU,MAAM;AACd;AAAA,MACE,gBAAgB,gBAAgB,YAAY,CAAC;AAAA,MAC7C,SAAS,OAAO,OAAK,EAAE,SAAS,UAAU;AAAA,IAC5C;AAAA,EACF,GAAG,CAAC,UAAU,gBAAgB,UAAU,CAAC;AAC3C;",
+  "sourcesContent": ["import { useEffect, useRef } from 'react'\nimport { type Message, type ProgressMessage } from '@query'\nimport { overwriteLog, getMessagesPath } from '@utils/log'\n\n/**\n * Serialize a message for persistence.\n * Progress messages need special handling because they contain Sets that\n * cannot be directly JSON serialized, and they include references to tools\n * that would create circular references.\n *\n * Exported for use in REPL's onInterrupt to force-save messages before abort.\n */\nexport function serializeMessageForLog(message: Message): object {\n  if (message.type === 'progress') {\n    // Convert Set to Array for JSON serialization\n    // Only keep essential fields - omit tools and normalizedMessages to avoid circular refs\n    const progressMsg = message as ProgressMessage\n    return {\n      type: 'progress',\n      uuid: progressMsg.uuid,\n      toolUseID: progressMsg.toolUseID,\n      // Convert Set to Array for JSON serialization\n      siblingToolUseIDs: Array.from(progressMsg.siblingToolUseIDs),\n      // Keep the content (AssistantMessage) for display\n      content: progressMsg.content,\n    }\n  }\n  return message\n}\n\nexport function useLogMessages(\n  messages: Message[],\n  messageLogName: string,\n  forkNumber: number,\n): void {\n  // Keep a ref to messages for cleanup function access\n  // This ensures we can save the latest messages even during unmount\n  const messagesRef = useRef(messages)\n  messagesRef.current = messages\n\n  // Defensive cleanup: ensure messages are saved when component unmounts\n  // This catches cases where ESC interrupt or other state changes might\n  // cause the component to unmount before the regular save effect runs\n  useEffect(() => {\n    return () => {\n      if (messagesRef.current.length > 0) {\n        const serialized = messagesRef.current.map(serializeMessageForLog)\n        overwriteLog(getMessagesPath(messageLogName, forkNumber, 0), serialized)\n      }\n    }\n  }, [messageLogName, forkNumber])\n\n  // Regular save effect: runs on every messages change\n  useEffect(() => {\n    // Serialize all messages including progress messages\n    // Progress messages are essential for proper tool use grouping on resume\n    const serializedMessages = messages.map(serializeMessageForLog)\n    overwriteLog(\n      getMessagesPath(messageLogName, forkNumber, 0),\n      serializedMessages,\n    )\n  }, [messages, messageLogName, forkNumber])\n}\n"],
+  "mappings": "AAAA,SAAS,WAAW,cAAc;AAElC,SAAS,cAAc,uBAAuB;AAUvC,SAAS,uBAAuB,SAA0B;AAC/D,MAAI,QAAQ,SAAS,YAAY;AAG/B,UAAM,cAAc;AACpB,WAAO;AAAA,MACL,MAAM;AAAA,MACN,MAAM,YAAY;AAAA,MAClB,WAAW,YAAY;AAAA;AAAA,MAEvB,mBAAmB,MAAM,KAAK,YAAY,iBAAiB;AAAA;AAAA,MAE3D,SAAS,YAAY;AAAA,IACvB;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,eACd,UACA,gBACA,YACM;AAGN,QAAM,cAAc,OAAO,QAAQ;AACnC,cAAY,UAAU;AAKtB,YAAU,MAAM;AACd,WAAO,MAAM;AACX,UAAI,YAAY,QAAQ,SAAS,GAAG;AAClC,cAAM,aAAa,YAAY,QAAQ,IAAI,sBAAsB;AACjE,qBAAa,gBAAgB,gBAAgB,YAAY,CAAC,GAAG,UAAU;AAAA,MACzE;AAAA,IACF;AAAA,EACF,GAAG,CAAC,gBAAgB,UAAU,CAAC;AAG/B,YAAU,MAAM;AAGd,UAAM,qBAAqB,SAAS,IAAI,sBAAsB;AAC9D;AAAA,MACE,gBAAgB,gBAAgB,YAAY,CAAC;AAAA,MAC7C;AAAA,IACF;AAAA,EACF,GAAG,CAAC,UAAU,gBAAgB,UAAU,CAAC;AAC3C;",
   "names": []
 }

package/dist/hooks/useMessageGroups.js

@@ -0,0 +1,43 @@
+import { useMemo } from "react";
+import { MessageGroupManager } from "../utils/messageGroupManager.js";
+import { DISPLAY_CONFIGS } from "../types/messageGroup.js";
+function useMessageGroups(normalizedMessages, unresolvedToolUseIDs, inProgressToolUseIDs, verbose = false) {
+  const displayConfig = useMemo(
+    () => verbose ? DISPLAY_CONFIGS.verbose : DISPLAY_CONFIGS.normal,
+    [verbose]
+  );
+  const managerState = useMemo(() => {
+    const manager2 = new MessageGroupManager();
+    manager2.identifyGroups(normalizedMessages);
+    manager2.updateResolutionStates(unresolvedToolUseIDs, inProgressToolUseIDs);
+    const groups2 = manager2.getAllGroups();
+    const groupById2 = new Map(groups2.map((g) => [g.id, g]));
+    return { manager: manager2, groups: groups2, groupById: groupById2 };
+  }, [normalizedMessages, unresolvedToolUseIDs, inProgressToolUseIDs]);
+  const { manager, groups, groupById } = managerState;
+  const getGroupForMessage = useMemo(
+    () => (messageUuid) => manager.getGroupByMessageUuid(messageUuid),
+    [manager]
+  );
+  const getGroupForToolUse = useMemo(
+    () => (toolUseId) => manager.getGroupByToolUseId(toolUseId),
+    [manager]
+  );
+  const shouldGroupBeStatic = useMemo(
+    () => (group) => manager.shouldGroupBeStatic(group),
+    [manager]
+  );
+  return {
+    groups,
+    manager,
+    groupById,
+    getGroupForMessage,
+    getGroupForToolUse,
+    shouldGroupBeStatic,
+    displayConfig
+  };
+}
+export {
+  useMessageGroups
+};
+//# sourceMappingURL=useMessageGroups.js.map

package/dist/hooks/useMessageGroups.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useMessageGroups.ts"],
+  "sourcesContent": ["/**\n * useMessageGroups Hook\n *\n * Provides integration between MessageGroupManager and React components.\n * Handles group identification, resolution state updates, and memoization.\n */\n\nimport { useMemo } from 'react'\nimport type { NormalizedMessage } from '@utils/messages'\nimport type { AgentTranscript } from '@utils/agentTranscripts'\nimport { MessageGroupManager } from '@utils/messageGroupManager'\nimport type { MessageGroup, DisplayConfig } from '@minto-types/messageGroup'\nimport { DISPLAY_CONFIGS } from '@minto-types/messageGroup'\n\ninterface UseMessageGroupsResult {\n  /** All identified message groups */\n  groups: MessageGroup[]\n  /** Group manager instance for direct access */\n  manager: MessageGroupManager\n  /** Map of group ID to group */\n  groupById: Map<string, MessageGroup>\n  /** Get group for a specific message UUID */\n  getGroupForMessage: (messageUuid: string) => MessageGroup | undefined\n  /** Get group for a specific toolUseId */\n  getGroupForToolUse: (toolUseId: string) => MessageGroup | undefined\n  /** Check if a group should be rendered as static */\n  shouldGroupBeStatic: (group: MessageGroup) => boolean\n  /** Current display configuration */\n  displayConfig: DisplayConfig\n}\n\n/**\n * Hook for managing message groups in React components\n *\n * @param normalizedMessages - Normalized message array\n * @param unresolvedToolUseIDs - Set of unresolved tool use IDs\n * @param inProgressToolUseIDs - Set of in-progress tool use IDs\n * @param verbose - Whether verbose mode is enabled\n * @returns Message group utilities and state\n */\nexport function useMessageGroups(\n  normalizedMessages: NormalizedMessage[],\n  unresolvedToolUseIDs: Set<string>,\n  inProgressToolUseIDs: Set<string>,\n  verbose: boolean = false,\n): UseMessageGroupsResult {\n  // Select display config based on verbose mode\n  const displayConfig = useMemo(\n    () => (verbose ? DISPLAY_CONFIGS.verbose : DISPLAY_CONFIGS.normal),\n    [verbose],\n  )\n\n  // Create and update message group manager\n  // Memoized to only recompute when dependencies change\n  const managerState = useMemo(() => {\n    const manager = new MessageGroupManager()\n\n    // Identify groups from messages\n    manager.identifyGroups(normalizedMessages)\n\n    // Update resolution states\n    manager.updateResolutionStates(unresolvedToolUseIDs, inProgressToolUseIDs)\n\n    // Get all groups\n    const groups = manager.getAllGroups()\n    const groupById = new Map(groups.map(g => [g.id, g]))\n\n    return { manager, groups, groupById }\n  }, [normalizedMessages, unresolvedToolUseIDs, inProgressToolUseIDs])\n\n  const { manager, groups, groupById } = managerState\n\n  // Helper to get group for a message\n  const getGroupForMessage = useMemo(\n    () => (messageUuid: string) => manager.getGroupByMessageUuid(messageUuid),\n    [manager],\n  )\n\n  // Helper to get group for a toolUseId\n  const getGroupForToolUse = useMemo(\n    () => (toolUseId: string) => manager.getGroupByToolUseId(toolUseId),\n    [manager],\n  )\n\n  // Helper to check if group should be static\n  const shouldGroupBeStatic = useMemo(\n    () => (group: MessageGroup) => manager.shouldGroupBeStatic(group),\n    [manager],\n  )\n\n  return {\n    groups,\n    manager,\n    groupById,\n    getGroupForMessage,\n    getGroupForToolUse,\n    shouldGroupBeStatic,\n    displayConfig,\n  }\n}\n"],
+  "mappings": "AAOA,SAAS,eAAe;AAGxB,SAAS,2BAA2B;AAEpC,SAAS,uBAAuB;AA4BzB,SAAS,iBACd,oBACA,sBACA,sBACA,UAAmB,OACK;AAExB,QAAM,gBAAgB;AAAA,IACpB,MAAO,UAAU,gBAAgB,UAAU,gBAAgB;AAAA,IAC3D,CAAC,OAAO;AAAA,EACV;AAIA,QAAM,eAAe,QAAQ,MAAM;AACjC,UAAMA,WAAU,IAAI,oBAAoB;AAGxC,IAAAA,SAAQ,eAAe,kBAAkB;AAGzC,IAAAA,SAAQ,uBAAuB,sBAAsB,oBAAoB;AAGzE,UAAMC,UAASD,SAAQ,aAAa;AACpC,UAAME,aAAY,IAAI,IAAID,QAAO,IAAI,OAAK,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;AAEpD,WAAO,EAAE,SAAAD,UAAS,QAAAC,SAAQ,WAAAC,WAAU;AAAA,EACtC,GAAG,CAAC,oBAAoB,sBAAsB,oBAAoB,CAAC;AAEnE,QAAM,EAAE,SAAS,QAAQ,UAAU,IAAI;AAGvC,QAAM,qBAAqB;AAAA,IACzB,MAAM,CAAC,gBAAwB,QAAQ,sBAAsB,WAAW;AAAA,IACxE,CAAC,OAAO;AAAA,EACV;AAGA,QAAM,qBAAqB;AAAA,IACzB,MAAM,CAAC,cAAsB,QAAQ,oBAAoB,SAAS;AAAA,IAClE,CAAC,OAAO;AAAA,EACV;AAGA,QAAM,sBAAsB;AAAA,IAC1B,MAAM,CAAC,UAAwB,QAAQ,oBAAoB,KAAK;AAAA,IAChE,CAAC,OAAO;AAAA,EACV;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
+  "names": ["manager", "groups", "groupById"]
+}