wave-code 1.1.0 → 1.1.2

package/src/contexts/useChat.tsx

@@ -5,6 +5,7 @@ import React, {
   useRef,
   useEffect,
   useState,
+  useMemo,
 } from "react";
 import { useInput, useStdout } from "ink";
 import { useAppConfig } from "./useAppConfig.js";
@@ -15,6 +16,7 @@ import type {
   Task,
   SlashCommand,
   SubagentConfiguration,
+  SkillMetadata,
   PermissionDecision,
   PermissionMode,
   QueuedMessage,
@@ -100,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;
@@ -193,6 +197,200 @@ const snapshotMessage = (message: Message): Message => ({
   blocks: message.blocks.map((block) => ({ ...block })),
 });
 
+/**
+ * Pure updater: appends a text-content delta to the target message's text
+ * block (creating it on first delta), applying the stage signal.
+ */
+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,
+      ),
+    };
+  });
+};
+
+/**
+ * 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 }],
+      };
+    }
+    return {
+      ...m,
+      blocks: m.blocks.map((b, idx) =>
+        idx === reasoningBlockIndex && b.type === "reasoning"
+          ? {
+              ...b,
+              content: (b.content || "") + chunk,
+              stage,
+            }
+          : b,
+      ),
+    };
+  });
+};
+
+/**
+ * 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,
+          },
+        ],
+      };
+    }
+    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,
+      ),
+    };
+  });
+};
+
+/**
+ * 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 createThrottledUpdater<T>(
+  apply: (updater: (prev: T) => T) => void,
+  wait: number,
+): {
+  (updater: (prev: T) => T): void;
+  cancel: () => void;
+  flush: () => void;
+} {
+  let timer: NodeJS.Timeout | null = null;
+  let queued: Array<(prev: T) => T> = [];
+
+  const fire = () => {
+    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 = (updater: (prev: T) => T) => {
+    if (timer) {
+      queued.push(updater);
+      return;
+    }
+    // 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 = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    queued = [];
+  };
+
+  throttled.flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    fire();
+  };
+
+  return throttled;
+}
+
 export const ChatProvider: React.FC<ChatProviderProps> = ({
   children,
   bypassPermissions,
@@ -223,132 +421,26 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [latestTotalTokens, setLatestTotalTokens] = useState(0);
   const [maxInputTokens, setMaxInputTokens] = useState(200000);
 
-  // Direct incremental streaming updaters — every delta is applied to the
-  // message state immediately, without a cooldown window. The former 500ms
-  // window-concat throttle is gone: its trailing-edge flush could interleave
-  // with a full-list `refreshMessages` snapshot replacement mid-stream and
-  // re-append old deltas on top of the authoritative content (first-word
-  // duplication). Terminal write frequency is bounded downstream by Ink's
-  // built-in ~30fps output throttle. See
-  // docs/specs/core/stream-content-updates.md.
-  const applyContentUpdate = useCallback((params: StreamingUpdateParams) => {
-    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,
-          ),
-        };
-      }),
-    );
-  }, []);
-
-  const applyReasoningUpdate = useCallback((params: StreamingUpdateParams) => {
-    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,
-          ),
-        };
-      }),
-    );
-  }, []);
-
-  const applyToolBlockUpdate = useCallback(
-    (params: ToolBlockUpdateCallbackParams) => {
-      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,
-            ),
-          };
-        }),
-      );
-    },
+  // 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(
+    () =>
+      createThrottledUpdater<Message[]>((updater) => setMessages(updater), 500),
     [],
   );
 
   useEffect(() => {
     isExpandedRef.current = isExpanded;
-  }, [isExpanded]);
+    if (isExpanded) {
+      // Cancel pending throttled updates so the frozen expanded view isn't overwritten
+      updateMessages.cancel();
+    }
+  }, [isExpanded, updateMessages]);
 
   const [isLoading, setIsLoading] = useState(false);
   const [sessionId, setSessionId] = useState("");
@@ -378,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>(
@@ -447,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(
@@ -491,18 +594,23 @@ 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;
           // Eager snapshot at callback time — React defers updater execution to
-          // the batch flush, so evaluating snapshotMessage inside setMessages
+          // the batch flush, so evaluating snapshotMessage inside the updater
           // would read the SDK message after its in-place mutations.
           const snapshot = snapshotMessage(last);
-          setMessages((prev) =>
+          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;
@@ -512,25 +620,29 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           // 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);
-          setMessages((prev) =>
+          updateMessages((prev) =>
             prev.some((m) => m.id === messageId) ? prev : [...prev, snapshot],
           );
+          updateMessages.flush();
         },
         onAssistantContentUpdated: (params) => {
           if (isExpandedRef.current) return;
-          applyContentUpdate(params);
+          updateMessages((prev) => applyContentDelta(prev, params));
+          if (params.stage === "end") updateMessages.flush();
         },
         onAssistantReasoningUpdated: (params) => {
           if (isExpandedRef.current) return;
-          applyReasoningUpdate(params);
+          updateMessages((prev) => applyReasoningDelta(prev, params));
+          if (params.stage === "end") updateMessages.flush();
         },
         onToolBlockUpdated: (params) => {
           if (isExpandedRef.current) return;
-          applyToolBlockUpdate(params);
+          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
@@ -558,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
               : [
@@ -582,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
                 ? {
@@ -602,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
                 ? {
@@ -622,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);
@@ -772,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);
       }
@@ -791,9 +913,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       originalCwd,
       model,
       initialPermissionMode,
-      applyContentUpdate,
-      applyReasoningUpdate,
-      applyToolBlockUpdate,
+      updateMessages,
       mcpServers,
     ],
   );
@@ -813,6 +933,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     setMcpServerStatuses([]);
     setSlashCommands([]);
     setAgentDefinitions([]);
+    setSkills([]);
     setSessionId("");
     setIsLoading(false);
     setLatestTotalTokens(0);
@@ -832,6 +953,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // Cleanup on unmount
   useEffect(() => {
     return () => {
+      updateMessages.cancel();
       if (agentRef.current) {
         try {
           // Display usage summary before cleanup
@@ -845,7 +967,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         agentRef.current.destroy();
       }
     };
-  }, []);
+  }, [updateMessages]);
 
   // Send message function (including judgment logic)
   const sendMessage = useCallback(
@@ -1188,6 +1310,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     slashCommands,
     hasSlashCommand,
     agentDefinitions,
+    skills,
     permissionMode,
     setPermissionMode,
     isConfirmationVisible,

package/src/hooks/useInputManager.ts

@@ -527,6 +527,10 @@ export const useInputManager = (
     dispatch({ type: "SET_SHOW_WORKFLOW_MANAGER", payload: show });
   }, []);
 
+  const setShowSkillsManager = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_SKILLS_MANAGER", payload: show });
+  }, []);
+
   const setPermissionMode = useCallback(
     (mode: PermissionMode) => {
       dispatch({ type: "SET_PERMISSION_MODE", payload: mode });
@@ -671,6 +675,7 @@ export const useInputManager = (
     showPluginManager: state.showPluginManager,
     showModelSelector: state.showModelSelector,
     showWorkflowManager: state.showWorkflowManager,
+    showSkillsManager: state.showSkillsManager,
     permissionMode: state.permissionMode,
     attachedImages: state.attachedImages,
     btwState: state.btwState,
@@ -717,6 +722,7 @@ export const useInputManager = (
     setShowPluginManager,
     setShowModelSelector,
     setShowWorkflowManager,
+    setShowSkillsManager,
     setPermissionMode,
     setBtwState,
 

package/src/managers/inputHandlers.ts

@@ -369,6 +369,8 @@ export const handleCommandSelect = (
           dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: true });
         } else if (command === "agents") {
           dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: true });
+        } else if (command === "skills") {
+          dispatch({ type: "SET_SHOW_SKILLS_MANAGER", payload: true });
         } else if (command === "rewind") {
           dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: true });
         } else if (command === "help") {

package/src/managers/inputReducer.ts

@@ -138,6 +138,7 @@ export interface InputState {
   showPluginManager: boolean;
   showModelSelector: boolean;
   showWorkflowManager: boolean;
+  showSkillsManager: boolean;
   permissionMode: PermissionMode;
   selectorJustUsed: boolean;
   history: PromptEntry[];
@@ -176,6 +177,7 @@ export const initialState: InputState = {
   showPluginManager: false,
   showModelSelector: false,
   showWorkflowManager: false,
+  showSkillsManager: false,
   permissionMode: "default",
   selectorJustUsed: false,
   history: [],
@@ -457,6 +459,7 @@ export type InputAction =
   | { type: "SET_SHOW_PLUGIN_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_MODEL_SELECTOR"; payload: boolean }
   | { type: "SET_SHOW_WORKFLOW_MANAGER"; payload: boolean }
+  | { type: "SET_SHOW_SKILLS_MANAGER"; payload: boolean }
   | { type: "SET_PERMISSION_MODE"; payload: PermissionMode }
   | { type: "SET_SELECTOR_JUST_USED"; payload: boolean }
   | { type: "INSERT_TEXT_WITH_PLACEHOLDER"; payload: string }
@@ -687,6 +690,12 @@ export function inputReducer(
         showWorkflowManager: action.payload,
         selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
       };
+    case "SET_SHOW_SKILLS_MANAGER":
+      return {
+        ...state,
+        showSkillsManager: action.payload,
+        selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
+      };
     case "SET_PERMISSION_MODE":
       return { ...state, permissionMode: action.payload };
     case "SET_SELECTOR_JUST_USED":

package/src/print-cli.ts

@@ -217,7 +217,9 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
             worktreeSession.repoRoot,
           );
         }
+        process.stdout.write("\nDeleting worktree ...\n");
         await removeWorktree(worktreeSession);
+        process.stdout.write("Done.\n");
       } catch (error) {
         // Never block print-mode exit on worktree cleanup failures
         process.stdout.write(
@@ -273,7 +275,9 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
               worktreeSession.repoRoot,
             );
           }
+          process.stdout.write("\nDeleting worktree ...\n");
           await removeWorktree(worktreeSession);
+          process.stdout.write("Done.\n");
         } catch (error) {
           process.stdout.write(
             `\n⚠️ Skipping worktree removal: ${(error as Error).message}\n`,