wave-code 1.0.10 → 1.1.1

package/src/contexts/useChat.tsx

@@ -16,6 +16,7 @@ import type {
   Task,
   SlashCommand,
   SubagentConfiguration,
+  SkillMetadata,
   PermissionDecision,
   PermissionMode,
   QueuedMessage,
@@ -42,6 +43,9 @@ export interface ChatContextType {
   isLoading: boolean;
   isCommandRunning: boolean;
   isCompacting: boolean;
+  /** Accumulated streaming text from the compaction fork, shown as the
+   * last-30-chars tail on the CLI compacting loading indicator. */
+  compactionStream: string;
   // Message display state
   isExpanded: boolean;
   isTaskListVisible: boolean;
@@ -98,6 +102,8 @@ export interface ChatContextType {
   hasSlashCommand: (commandId: string) => boolean;
   // Agent definitions (for /agents overlay)
   agentDefinitions: SubagentConfiguration[];
+  // Skill metadata (for /skills overlay)
+  skills: SkillMetadata[];
   // Permission functionality
   permissionMode: PermissionMode;
   setPermissionMode: (mode: PermissionMode) => void;
@@ -144,8 +150,6 @@ export interface ChatContextType {
   workdir?: string;
   // Agent recreation (e.g. after plugin install)
   recreateAgent: () => void;
-  // Trigger WorktreeRemove hook BEFORE agent destruction
-  triggerWorktreeRemoveHook: (worktreePath: string) => Promise<void>;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -178,6 +182,15 @@ interface StreamingUpdateParams {
  * reasoning and text content alike. See docs/specs/core/stream-content-updates.md.
  * The clone must be at least one layer deep (message + blocks) so the in-place
  * block mutation never leaks into consumer state.
+ *
+ * IMPORTANT: the caller must invoke this EAGERLY at callback time and capture
+ * the result before scheduling any state update. React batches setState calls
+ * that happen in the same synchronous tick and runs the updater functions only
+ * at flush time — after the SDK has already written the first chunk into the
+ * shared message. A snapshot evaluated inside the updater (lazily) would copy
+ * the post-mutation blocks, and the first delta append would then double-count
+ * the first word ("HelloHello") whenever `onAssistantMessageAdded` and the
+ * first delta callback land in the same batch.
  */
 const snapshotMessage = (message: Message): Message => ({
   ...message,
@@ -185,149 +198,178 @@ const snapshotMessage = (message: Message): Message => ({
 });
 
 /**
- * Window-concat throttle for pure-delta streaming updates: chunks arriving
- * within the cooldown window are merged so no delta is lost (a dropped delta
- * would permanently lose content, unlike the accumulated-payload throttle it
- * replaces). Leading edge fires immediately; the trailing edge carries only
- * chunks that arrived within the window. `end` flushes any pending deltas
- * first, then forwards the end signal right away.
+ * Pure updater: appends a text-content delta to the target message's text
+ * block (creating it on first delta), applying the stage signal.
  */
-function createStreamingWindowThrottle(
-  fn: (params: StreamingUpdateParams) => void,
-  wait: number,
-): {
-  (params: StreamingUpdateParams): void;
-  cancel: () => void;
-  flush: () => void;
-} {
-  let timer: NodeJS.Timeout | null = null;
-  let pending: { messageId: string; chunk: string } | null = null;
-
-  const fire = (stage: "streaming" | "end") => {
-    if (pending) {
-      fn({ ...pending, stage });
-      pending = null;
-    }
-  };
-
-  const throttled = (params: StreamingUpdateParams) => {
-    if (params.stage === "end") {
-      // Flush any deltas still pending inside the cooldown window first
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      fire("streaming");
-      fn(params);
-      return;
-    }
-    if (pending) {
-      pending.chunk += params.chunk;
-    } else {
-      pending = { messageId: params.messageId, chunk: params.chunk };
-    }
-    if (!timer) {
-      // Leading edge: fire the current delta immediately, then reset pending so
-      // the trailing edge only carries chunks arriving within this window
-      fire("streaming");
-      timer = setTimeout(() => {
-        timer = null;
-        fire("streaming");
-      }, wait);
+const applyContentDelta = (
+  prev: Message[],
+  params: StreamingUpdateParams,
+): Message[] => {
+  const { messageId, chunk, stage } = params;
+  return prev.map((m) => {
+    if (m.id !== messageId) return m;
+    const textBlockIndex = m.blocks.findIndex((b) => b.type === "text");
+    if (textBlockIndex === -1) {
+      return {
+        ...m,
+        blocks: [...m.blocks, { type: "text", content: chunk, stage }],
+      };
     }
-  };
+    return {
+      ...m,
+      blocks: m.blocks.map((b, idx) =>
+        idx === textBlockIndex && b.type === "text"
+          ? {
+              ...b,
+              content: (b.content || "") + chunk,
+              stage,
+            }
+          : b,
+      ),
+    };
+  });
+};
 
-  throttled.cancel = () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
+/**
+ * Pure updater: appends a reasoning delta to the target message's reasoning
+ * block (creating it on first delta), applying the stage signal.
+ */
+const applyReasoningDelta = (
+  prev: Message[],
+  params: StreamingUpdateParams,
+): Message[] => {
+  const { messageId, chunk, stage } = params;
+  return prev.map((m) => {
+    if (m.id !== messageId) return m;
+    const reasoningBlockIndex = m.blocks.findIndex(
+      (b) => b.type === "reasoning",
+    );
+    if (reasoningBlockIndex === -1) {
+      return {
+        ...m,
+        blocks: [...m.blocks, { type: "reasoning", content: chunk, stage }],
+      };
     }
-    pending = null;
-  };
+    return {
+      ...m,
+      blocks: m.blocks.map((b, idx) =>
+        idx === reasoningBlockIndex && b.type === "reasoning"
+          ? {
+              ...b,
+              content: (b.content || "") + chunk,
+              stage,
+            }
+          : b,
+      ),
+    };
+  });
+};
 
-  throttled.flush = () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
+/**
+ * Pure updater: applies a tool block update. Streaming carries only the
+ * `parametersChunk` delta, appended to the accumulated parameters;
+ * start/running/end carry the authoritative value and replace wholesale.
+ */
+const applyToolBlockUpdate = (
+  prev: Message[],
+  params: ToolBlockUpdateCallbackParams,
+): Message[] => {
+  const { messageId, id: toolBlockId, parametersChunk, ...updates } = params;
+  return prev.map((m) => {
+    if (m.id !== messageId) return m;
+    const toolBlockIndex = m.blocks.findIndex(
+      (b) => b.type === "tool" && b.id === toolBlockId,
+    );
+    if (toolBlockIndex === -1) {
+      return {
+        ...m,
+        blocks: [
+          ...m.blocks,
+          {
+            type: "tool",
+            id: toolBlockId,
+            name: updates.name || "",
+            stage: updates.stage || "start",
+            parameters: (updates.parameters || "") + (parametersChunk || ""),
+            result: updates.result || "",
+            ...updates,
+          },
+        ],
+      };
     }
-    fire("streaming");
-  };
-
-  return throttled;
-}
+    return {
+      ...m,
+      blocks: m.blocks.map((b, idx) =>
+        idx === toolBlockIndex && b.type === "tool"
+          ? {
+              ...b,
+              ...updates,
+              parameters: parametersChunk
+                ? (b.parameters || "") + parametersChunk
+                : updates.parameters !== undefined
+                  ? updates.parameters
+                  : b.parameters,
+            }
+          : b,
+      ),
+    };
+  });
+};
 
 /**
- * Per-tool window-concat throttle for pure-delta tool parameter streaming:
- * `parametersChunk` deltas are accumulated independently per tool block id
- * within the cooldown window, so interleaved multi-tool streams lose no delta
- * (a plain throttle's single last-args slot would drop every earlier tool's
- * deltas, leaving the first tool without streaming parameters). `start` /
- * `running` apply immediately (one-shot snapshots); `end` flushes pending
- * streaming deltas first, then applies the authoritative parameters/result.
+ * Single throttled updater entry for ALL message-state updates. The one
+ * 500ms window-concat window replaces the previous three-channel throttles
+ * (content/reasoning/tool), so every message-state update — including the
+ * tool `running` stage's high-frequency `shortResult`/`result` updates from
+ * bash — coalesces into the same window.
+ *
+ * Semantics: leading edge applies immediately and opens a window; updates
+ * arriving within the window are queued in arrival order (FIFO) and applied
+ * at the trailing edge as ONE composed updater, so no update is lost and no
+ * update is reordered. `flush` applies queued updates immediately (used by
+ * end signals and one-shot structural updates); `cancel` drops queued
+ * updates (used by refreshMessages after pulling the authoritative snapshot —
+ * the queued updates are already contained in it).
+ *
+ * The FIFO queue structurally replaces the old tool throttle's "drop a
+ * tool's buffered streaming deltas when running arrives" logic: a running
+ * updater is queued BEHIND the streaming chunks that preceded it and applies
+ * after them, so a stale streaming event can never flush after running and
+ * regress the stage (yellow dot -> gray). See
+ * docs/specs/core/stream-content-updates.md.
  */
-export function createToolStreamingThrottle(
-  fn: (params: ToolBlockUpdateCallbackParams) => void,
+export function createThrottledUpdater<T>(
+  apply: (updater: (prev: T) => T) => void,
   wait: number,
 ): {
-  (params: ToolBlockUpdateCallbackParams): void;
+  (updater: (prev: T) => T): void;
   cancel: () => void;
   flush: () => void;
 } {
   let timer: NodeJS.Timeout | null = null;
-  let pending: { messageId: string; chunks: Map<string, string> } | null = null;
+  let queued: Array<(prev: T) => T> = [];
 
   const fire = () => {
-    if (pending && pending.chunks.size > 0) {
-      const { messageId, chunks } = pending;
-      pending = null;
-      for (const [id, chunk] of chunks) {
-        fn({ messageId, id, parametersChunk: chunk, stage: "streaming" });
-      }
-    }
+    if (queued.length === 0) return;
+    const batch = queued;
+    queued = [];
+    // Compose the whole batch into a single updater applied in FIFO order —
+    // one state commit per trailing edge, no update dropped, no reordering.
+    apply((prev) => batch.reduce((acc, upd) => upd(acc), prev));
   };
 
-  const throttled = (params: ToolBlockUpdateCallbackParams) => {
-    if (params.stage === "end") {
-      // Flush any deltas still pending inside the cooldown window first
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      fire();
-      fn(params);
-      return;
-    }
-    if (params.stage === "streaming") {
-      if (!pending) {
-        pending = { messageId: params.messageId, chunks: new Map() };
-      }
-      const prev = pending.chunks.get(params.id) || "";
-      pending.chunks.set(params.id, prev + (params.parametersChunk || ""));
-      if (!timer) {
-        timer = setTimeout(() => {
-          timer = null;
-          fire();
-        }, wait);
-      }
+  const throttled = (updater: (prev: T) => T) => {
+    if (timer) {
+      queued.push(updater);
       return;
     }
-    // start / running — one-shot snapshots applied immediately. Drop this
-    // tool's buffered streaming deltas first: start/running carry the
-    // authoritative parameters, and a pending timer would otherwise fire late
-    // with a stale `streaming` event, regressing this tool block's stage back
-    // to streaming (yellow dot -> gray) mid-execution. Other tools' in-flight
-    // chunks are kept so interleaved multi-tool streaming still accumulates.
-    if (pending) {
-      pending.chunks.delete(params.id);
-      if (pending.chunks.size === 0) {
-        pending = null;
-        if (timer) {
-          clearTimeout(timer);
-          timer = null;
-        }
-      }
-    }
-    fn(params);
+    // Leading edge: apply immediately, then open a window whose trailing
+    // edge only carries updates arriving within the window.
+    apply(updater);
+    timer = setTimeout(() => {
+      timer = null;
+      fire();
+    }, wait);
   };
 
   throttled.cancel = () => {
@@ -335,7 +377,7 @@ export function createToolStreamingThrottle(
       clearTimeout(timer);
       timer = null;
     }
-    pending = null;
+    queued = [];
   };
 
   throttled.flush = () => {
@@ -379,135 +421,16 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [latestTotalTokens, setLatestTotalTokens] = useState(0);
   const [maxInputTokens, setMaxInputTokens] = useState(200000);
 
-  // Throttled incremental streaming updaters — 500ms window-concat, the same
-  // interval as the pre-incremental throttledSetMessages. Chunks are pure
-  // deltas: within-window chunks are merged so none is dropped, and
-  // `stage === "end"` flushes pending deltas + applies the end signal
-  // immediately so completion results are never delayed.
-  const throttledContentUpdate = useMemo(
+  // Single throttled entry for ALL message-state updates — one 500ms
+  // window-concat window shared by every callback (content/reasoning deltas,
+  // tool parametersChunk, tool `running` stage shortResult/result, one-shot
+  // structural updates). The tool `running` stage used to bypass throttling
+  // (bash shortResult height changes per chunk → layout flicker); routing it
+  // through the same window as streaming deltas coalesces it to ≤1 render per
+  // window. See createThrottledUpdater + docs/specs/core/stream-content-updates.md.
+  const updateMessages = useMemo(
     () =>
-      createStreamingWindowThrottle((params) => {
-        const { messageId, chunk, stage } = params;
-        setMessages((prev) =>
-          prev.map((m) => {
-            if (m.id !== messageId) return m;
-            const textBlockIndex = m.blocks.findIndex((b) => b.type === "text");
-            if (textBlockIndex === -1) {
-              return {
-                ...m,
-                blocks: [...m.blocks, { type: "text", content: chunk, stage }],
-              };
-            }
-            return {
-              ...m,
-              blocks: m.blocks.map((b, idx) =>
-                idx === textBlockIndex && b.type === "text"
-                  ? {
-                      ...b,
-                      content: (b.content || "") + chunk,
-                      stage,
-                    }
-                  : b,
-              ),
-            };
-          }),
-        );
-      }, 500),
-    [],
-  );
-
-  const throttledReasoningUpdate = useMemo(
-    () =>
-      createStreamingWindowThrottle((params) => {
-        const { messageId, chunk, stage } = params;
-        setMessages((prev) =>
-          prev.map((m) => {
-            if (m.id !== messageId) return m;
-            const reasoningBlockIndex = m.blocks.findIndex(
-              (b) => b.type === "reasoning",
-            );
-            if (reasoningBlockIndex === -1) {
-              return {
-                ...m,
-                blocks: [
-                  ...m.blocks,
-                  { type: "reasoning", content: chunk, stage },
-                ],
-              };
-            }
-            return {
-              ...m,
-              blocks: m.blocks.map((b, idx) =>
-                idx === reasoningBlockIndex && b.type === "reasoning"
-                  ? {
-                      ...b,
-                      content: (b.content || "") + chunk,
-                      stage,
-                    }
-                  : b,
-              ),
-            };
-          }),
-        );
-      }, 500),
-    [],
-  );
-
-  const throttledToolBlockUpdate = useMemo(
-    () =>
-      createToolStreamingThrottle((params) => {
-        const {
-          messageId,
-          id: toolBlockId,
-          parametersChunk,
-          ...updates
-        } = params;
-        setMessages((prev) =>
-          prev.map((m) => {
-            if (m.id !== messageId) return m;
-            const toolBlockIndex = m.blocks.findIndex(
-              (b) => b.type === "tool" && b.id === toolBlockId,
-            );
-            if (toolBlockIndex === -1) {
-              return {
-                ...m,
-                blocks: [
-                  ...m.blocks,
-                  {
-                    type: "tool",
-                    id: toolBlockId,
-                    name: updates.name || "",
-                    stage: updates.stage || "start",
-                    parameters:
-                      (updates.parameters || "") + (parametersChunk || ""),
-                    result: updates.result || "",
-                    ...updates,
-                  },
-                ],
-              };
-            }
-            return {
-              ...m,
-              blocks: m.blocks.map((b, idx) =>
-                idx === toolBlockIndex && b.type === "tool"
-                  ? {
-                      ...b,
-                      ...updates,
-                      // Streaming carries only the delta; append it to the
-                      // accumulated parameters. start/running/end carry the
-                      // authoritative value and replace wholesale.
-                      parameters: parametersChunk
-                        ? (b.parameters || "") + parametersChunk
-                        : updates.parameters !== undefined
-                          ? updates.parameters
-                          : b.parameters,
-                    }
-                  : b,
-              ),
-            };
-          }),
-        );
-      }, 500),
+      createThrottledUpdater<Message[]>((updater) => setMessages(updater), 500),
     [],
   );
 
@@ -515,21 +438,15 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     isExpandedRef.current = isExpanded;
     if (isExpanded) {
       // Cancel pending throttled updates so the frozen expanded view isn't overwritten
-      throttledContentUpdate.cancel();
-      throttledReasoningUpdate.cancel();
-      throttledToolBlockUpdate.cancel();
+      updateMessages.cancel();
     }
-  }, [
-    isExpanded,
-    throttledContentUpdate,
-    throttledReasoningUpdate,
-    throttledToolBlockUpdate,
-  ]);
+  }, [isExpanded, updateMessages]);
 
   const [isLoading, setIsLoading] = useState(false);
   const [sessionId, setSessionId] = useState("");
   const [isCommandRunning, setIsCommandRunning] = useState(false);
   const [isCompacting, setIsCompacting] = useState(false);
+  const [compactionStream, setCompactionStream] = useState("");
   const [currentModel, setCurrentModelState] = useState("");
   const [configuredModels, setConfiguredModels] = useState<string[]>([]);
   const [queuedMessages, setQueuedMessages] = useState<QueuedMessage[]>([]);
@@ -553,6 +470,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [agentDefinitions, setAgentDefinitions] = useState<
     SubagentConfiguration[]
   >([]);
+  // Skill metadata (for /skills overlay)
+  const [skills, setSkills] = useState<SkillMetadata[]>([]);
 
   // Permission state
   const [permissionMode, setPermissionModeState] = useState<PermissionMode>(
@@ -603,8 +522,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [remountKey, setRemountKey] = useState(0);
 
   // Full terminal clear + remount so Ink's append-only <Static> re-renders.
-  // Used on structural actions (/clear, /compact, rewind, ctrl-o, forceStatic
-  // exit) where stale Static output must not linger on screen.
+  // Used on structural actions (/clear, /compact, rewind, ctrl-o) where stale
+  // Static output must not linger on screen.
   const forceRemount = useCallback(() => {
     stdout?.write("\u001b[2J\u001b[3J\u001b[0;0H", () => {
       setRemountKey((prev) => prev + 1);
@@ -622,10 +541,19 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const refreshMessages = useCallback(() => {
     if (!isExpandedRef.current && agentRef.current) {
       const msgs = agentRef.current.messages.map(snapshotMessage);
+      // Snapshot-safe: the full-list replacement makes the SDK state
+      // authoritative. Any update still queued inside the 500ms throttle
+      // window was applied to the SDK before this pull, so it is already
+      // contained in `msgs` — dropping it prevents the trailing-edge flush
+      // from re-appending the pre-refresh chunk on top of the snapshot
+      // (first-word duplication). Updates arriving after the pull start fresh
+      // windows and append on top of the snapshot. See
+      // docs/specs/core/stream-content-updates.md.
+      updateMessages.cancel();
       setMessages(msgs);
       setLatestTotalTokens(extractLatestTotalTokens(msgs));
     }
-  }, []);
+  }, [updateMessages]);
 
   // Permission confirmation methods with queue support
   const showConfirmation = useCallback(
@@ -666,43 +594,55 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
       const callbacks: AgentCallbacks = {
         // ── Incremental message updates (no full-list pushes) ──────
+        // All of these funnel through the single throttled `updateMessages`
+        // entry, so every message-state update shares one 500ms window.
         onUserMessageAdded: () => {
           if (isExpandedRef.current || !agentRef.current) return;
           const msgs = agentRef.current.messages;
           const last = msgs[msgs.length - 1];
           if (!last || last.role !== "user") return;
-          setMessages((prev) =>
-            prev.some((m) => m.id === last.id)
-              ? prev
-              : [...prev, snapshotMessage(last)],
+          // Eager snapshot at callback time — React defers updater execution to
+          // the batch flush, so evaluating snapshotMessage inside the updater
+          // would read the SDK message after its in-place mutations.
+          const snapshot = snapshotMessage(last);
+          updateMessages((prev) =>
+            prev.some((m) => m.id === last.id) ? prev : [...prev, snapshot],
           );
+          // One-shot structural update — flush immediately so the message
+          // card appears at once (queuing it gains no coalescing).
+          updateMessages.flush();
         },
         onAssistantMessageAdded: (messageId: string) => {
           if (isExpandedRef.current || !agentRef.current) return;
           const msg = agentRef.current.messages.find((m) => m.id === messageId);
           if (!msg) return;
-          setMessages((prev) =>
-            prev.some((m) => m.id === messageId)
-              ? prev
-              : [...prev, snapshotMessage(msg)],
+          // Eager snapshot (see onUserMessageAdded): `addAssistantMessage()`
+          // fires this callback BEFORE the first delta writes into the shared
+          // message, so capturing here copies the pre-mutation (empty) blocks.
+          const snapshot = snapshotMessage(msg);
+          updateMessages((prev) =>
+            prev.some((m) => m.id === messageId) ? prev : [...prev, snapshot],
           );
+          updateMessages.flush();
         },
         onAssistantContentUpdated: (params) => {
           if (isExpandedRef.current) return;
-          throttledContentUpdate(params);
+          updateMessages((prev) => applyContentDelta(prev, params));
+          if (params.stage === "end") updateMessages.flush();
         },
         onAssistantReasoningUpdated: (params) => {
           if (isExpandedRef.current) return;
-          throttledReasoningUpdate(params);
+          updateMessages((prev) => applyReasoningDelta(prev, params));
+          if (params.stage === "end") updateMessages.flush();
         },
         onToolBlockUpdated: (params) => {
           if (isExpandedRef.current) return;
-          throttledToolBlockUpdate(params);
-          if (params.stage === "end") throttledToolBlockUpdate.flush();
+          updateMessages((prev) => applyToolBlockUpdate(prev, params));
+          if (params.stage === "end") updateMessages.flush();
         },
         onErrorBlockAdded: (error: string) => {
           if (isExpandedRef.current) return;
-          setMessages((prev) => {
+          updateMessages((prev) => {
             // Append to the LAST message only if it is an assistant message
             // (the current turn's in-flight reply). If the last message is a
             // user message, the error belongs BELOW it — create a new
@@ -730,10 +670,13 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
               },
             ];
           });
+          // One-shot structural update — flush immediately (errors must not be
+          // delayed by a streaming window).
+          updateMessages.flush();
         },
         onAddBangMessage: (command, messageId) => {
           if (isExpandedRef.current) return;
-          setMessages((prev) =>
+          updateMessages((prev) =>
             prev.some((m) => m.id === messageId)
               ? prev
               : [
@@ -754,10 +697,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
                   },
                 ],
           );
+          updateMessages.flush();
         },
         onUpdateBangMessage: (command, output, messageId) => {
           if (isExpandedRef.current) return;
-          setMessages((prev) =>
+          updateMessages((prev) =>
             prev.map((m) =>
               m.id === messageId
                 ? {
@@ -774,7 +718,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         },
         onCompleteBangMessage: (command, exitCode, messageId, output) => {
           if (isExpandedRef.current) return;
-          setMessages((prev) =>
+          updateMessages((prev) =>
             prev.map((m) =>
               m.id === messageId
                 ? {
@@ -794,6 +738,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
                 : m,
             ),
           );
+          // Completion signal — flush so the final state applies immediately.
+          updateMessages.flush();
         },
         onLatestTotalTokensChange: (tokens) => {
           setLatestTotalTokens(tokens);
@@ -806,6 +752,14 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         },
         onCompactionStateChange: (isCompactingState) => {
           setIsCompacting(isCompactingState);
+          if (!isCompactingState) {
+            setCompactionStream("");
+          }
+        },
+        onCompactionContentUpdate: (content) => {
+          // The SDK delivers the accumulated compaction text; the loading
+          // indicator renders only its last 30 characters (streaming tail).
+          setCompactionStream(content);
         },
         onBackgroundTasksChange: async (tasks) => {
           setBackgroundTasks([...tasks]);
@@ -936,6 +890,10 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         const initialAgentDefinitions =
           agent.getSubagentConfigurations?.() || [];
         setAgentDefinitions(initialAgentDefinitions);
+
+        // Get initial skill metadata
+        const initialSkills = agent.getSkillMetadata?.() || [];
+        setSkills(initialSkills);
       } catch (error) {
         console.error("Failed to initialize AI manager:", error);
       }
@@ -955,9 +913,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       originalCwd,
       model,
       initialPermissionMode,
-      throttledContentUpdate,
-      throttledReasoningUpdate,
-      throttledToolBlockUpdate,
+      updateMessages,
       mcpServers,
     ],
   );
@@ -977,6 +933,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     setMcpServerStatuses([]);
     setSlashCommands([]);
     setAgentDefinitions([]);
+    setSkills([]);
     setSessionId("");
     setIsLoading(false);
     setLatestTotalTokens(0);
@@ -996,9 +953,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // Cleanup on unmount
   useEffect(() => {
     return () => {
-      throttledContentUpdate.cancel();
-      throttledReasoningUpdate.cancel();
-      throttledToolBlockUpdate.cancel();
+      updateMessages.cancel();
       if (agentRef.current) {
         try {
           // Display usage summary before cleanup
@@ -1012,19 +967,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         agentRef.current.destroy();
       }
     };
-  }, [
-    throttledContentUpdate,
-    throttledReasoningUpdate,
-    throttledToolBlockUpdate,
-  ]);
-
-  // Trigger WorktreeRemove hook BEFORE agent destruction
-  const triggerWorktreeRemoveHook = useCallback(
-    async (worktreePath: string) => {
-      await agentRef.current?.triggerWorktreeRemoveHook(worktreePath);
-    },
-    [],
-  );
+  }, [updateMessages]);
 
   // Send message function (including judgment logic)
   const sendMessage = useCallback(
@@ -1354,6 +1297,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     getConfiguredModels,
     setModel,
     isCompacting,
+    compactionStream,
     mcpServers: mcpServerStatuses,
     connectMcpServer,
     disconnectMcpServer,
@@ -1366,6 +1310,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     slashCommands,
     hasSlashCommand,
     agentDefinitions,
+    skills,
     permissionMode,
     setPermissionMode,
     isConfirmationVisible,
@@ -1387,7 +1332,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     version,
     workdir,
     recreateAgent,
-    triggerWorktreeRemoveHook,
   };
 
   return (