wave-code 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -59,7 +59,7 @@
     "wrap-ansi": "^10.0.0",
     "yargs": "^17.7.2",
     "zod": "^3.23.8",
-    "wave-agent-sdk": "1.5.0"
+    "wave-agent-sdk": "1.6.0"
   },
   "engines": {
     "node": ">=22"
@@ -69,11 +69,11 @@
     "wave": "tsx --tsconfig tsconfig.dev.json src/index.ts",
     "build": "rimraf dist && node scripts/bundle.mjs",
     "type-check": "tsc --noEmit --incremental",
-    "test": "vitest run --reporter=dot",
-    "test:coverage": "vitest run --coverage --reporter=dot",
-    "test:unit": "vitest run --reporter=dot --exclude 'tests/integration/**' --exclude '**/*.integration.test.ts'",
-    "test:unit:coverage": "vitest run --coverage --reporter=dot --exclude 'tests/integration/**' --exclude '**/*.integration.test.ts'",
-    "test:integration": "vitest run --reporter=dot tests/integration .integration.test",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:unit": "vitest run --exclude 'tests/integration/**' --exclude '**/*.integration.test.ts'",
+    "test:unit:coverage": "vitest run --coverage --exclude 'tests/integration/**' --exclude '**/*.integration.test.ts'",
+    "test:integration": "vitest run tests/integration .integration.test",
     "lint": "oxlint",
     "format": "prettier --write ."
   }

package/src/cli.tsx

@@ -3,7 +3,7 @@ import { render } from "ink";
 import { ensureRuntimeDeps } from "wave-agent-sdk";
 import { App } from "./components/App.js";
 import { cleanupLogs } from "./utils/logger.js";
-import { removeWorktree } from "./utils/worktree.js";
+import { describeWorktreeSurvival, removeWorktree } from "./utils/worktree.js";
 import { BaseAppProps } from "./types.js";
 
 export interface CliOptions extends BaseAppProps {
@@ -96,8 +96,14 @@ export async function startCli(options: CliOptions): Promise<void> {
     if (shouldRemoveWorktree && worktreeSession) {
       process.stdout.write("\nDeleting worktree ...\n");
       process.chdir(worktreeSession.repoRoot);
-      await removeWorktree(worktreeSession);
-      process.stdout.write("Done.\n");
+      // "Done." only when it is: removal is best-effort, and a surviving
+      // directory (with its branch kept for it) needs the cleanup commands
+      // printed rather than a success line over the leftovers.
+      process.stdout.write(
+        (await removeWorktree(worktreeSession))
+          ? "Done.\n"
+          : `\n${describeWorktreeSurvival(worktreeSession)}\n`,
+      );
     }
 
     process.exit(0);

package/src/components/FileSelector.tsx

@@ -1,18 +1,18 @@
 import React, { useReducer, useEffect } from "react";
 import { Box, Text, useInput } from "ink";
-import type { FileItem } from "wave-agent-sdk";
+import type { FileSelectorItem } from "../managers/inputReducer.js";
 import {
   selectorReducer,
   type SelectorState,
 } from "../reducers/selectorReducer.js";
 
-export { type FileItem } from "wave-agent-sdk";
+export type { FileSelectorItem };
 
 export interface FileSelectorProps {
-  files: FileItem[];
+  files: FileSelectorItem[];
   searchQuery: string;
   isLoading?: boolean;
-  onSelect: (filePath: string) => void;
+  onSelect: (item: FileSelectorItem) => void;
   onCancel: () => void;
 }
 
@@ -23,11 +23,11 @@ export const FileSelector: React.FC<FileSelectorProps> = ({
   onSelect,
   onCancel,
 }) => {
-  const [state, dispatch] = useReducer(selectorReducer<FileItem>, {
+  const [state, dispatch] = useReducer(selectorReducer<FileSelectorItem>, {
     selectedIndex: 0,
     pendingDecision: null,
     items: [],
-  } as SelectorState<FileItem>);
+  } as SelectorState<FileSelectorItem>);
 
   const { selectedIndex, pendingDecision, items: filesInState } = state;
 
@@ -42,7 +42,7 @@ export const FileSelector: React.FC<FileSelectorProps> = ({
 
     if (pendingDecision === "select" || pendingDecision === "insert") {
       if (filesInState.length > 0 && selectedIndex < filesInState.length) {
-        onSelect(filesInState[selectedIndex].path);
+        onSelect(filesInState[selectedIndex]);
       }
     } else if (pendingDecision === "cancel") {
       onCancel();
@@ -124,8 +124,11 @@ export const FileSelector: React.FC<FileSelectorProps> = ({
                 backgroundColor={isSelected ? "cyan" : undefined}
               >
                 {isSelected ? "▶ " : "  "}
-                {fileItem.path}
+                {fileItem.agentName ? `@${fileItem.agentName}` : fileItem.path}
               </Text>
+              {fileItem.agentDescription && (
+                <Text dimColor> {fileItem.agentDescription}</Text>
+              )}
             </Box>
           );
         })}

package/src/components/HelpView.tsx

@@ -65,7 +65,7 @@ export const HelpView: React.FC<HelpViewProps> = ({
   });
 
   const helpItems = [
-    { key: "@", description: "Reference files" },
+    { key: "@", description: "Reference files or subagents" },
     { key: "/", description: "Commands" },
     { key: "!", description: "Shell commands (e.g. !ls)" },
     { key: "Ctrl+R", description: "Search history" },

package/src/components/InputBox.tsx

@@ -90,8 +90,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
     handleRewindSelect,
     resumeSession,
     backgroundCurrentTask,
-    messages,
-    getFullMessageThread,
+    getRewindCheckpoints,
     sessionId,
     workingDirectory,
     askBtw,
@@ -212,10 +211,10 @@ export const InputBox: React.FC<InputBoxProps> = ({
     onPlanCommand: handlePlanCommand,
     sessionId,
     workdir: workingDirectory,
-    getFullMessageThread,
     hasQueuedMessages,
     isIdle,
     onRecallQueuedMessage,
+    subagentConfigurations: agentDefinitions,
   });
 
   // Keep setInputText ref updated for queue callbacks
@@ -402,10 +401,9 @@ export const InputBox: React.FC<InputBoxProps> = ({
 
       {showRewindManager && (
         <RewindCommand
-          messages={messages}
           onSelect={handleRewindSelectWithClose}
           onCancel={handleRewindCancel}
-          getFullMessageThread={getFullMessageThread}
+          getCheckpoints={getRewindCheckpoints}
         />
       )}
 

package/src/components/McpManager.tsx

@@ -157,6 +157,26 @@ export const McpManager: React.FC<McpManagerProps> = ({
               </Text>
             </Box>
           )}
+          {/* Not dialed yet (lazy dial): the tool list comes from the local
+              snapshot of the last successful connection, and says so. */}
+          {selectedServer.status !== "connected" &&
+            selectedServer.toolsFromCache && (
+              <Box>
+                <Text>
+                  <Text color="blue">Tools:</Text>{" "}
+                  {selectedServer.toolsFromCache.length} tools{" "}
+                  <Text color="gray" dimColor>
+                    (cached
+                    {selectedServer.toolsCachedAt
+                      ? ` · last connected ${formatTime(
+                          selectedServer.toolsCachedAt,
+                        )}`
+                      : ""}
+                    )
+                  </Text>
+                </Text>
+              </Box>
+            )}
           {selectedServer.capabilities && (
             <Box>
               <Text>
@@ -270,6 +290,12 @@ export const McpManager: React.FC<McpManagerProps> = ({
             {server.status === "connected" && server.toolCount && (
               <Text color="green"> · {server.toolCount} tools</Text>
             )}
+            {server.status !== "connected" && server.toolsFromCache && (
+              <Text color="gray" dimColor>
+                {" "}
+                · {server.toolsFromCache.length} tools (cached)
+              </Text>
+            )}
           </Text>
           {index === state.selectedIndex && (
             <Box marginLeft={4} flexDirection="column">

package/src/components/MessageBlockItem.tsx

@@ -41,9 +41,21 @@ export const MessageBlockItem = ({
         </Box>
       )}
 
-      {block.type === "error" && (
+      {/* A line for the human, never sent to the model (see NoticeBlock in the
+          SDK): a failed turn (`error`, red) or a hook's status line (`info`,
+          muted). */}
+      {block.type === "notice" && (
         <Box>
-          <Text color="red">Error: {block.content}</Text>
+          {block.level === "error" ? (
+            <Text color="red">Error: {block.content}</Text>
+          ) : (
+            <Text
+              color={block.level === "warning" ? "yellow" : "gray"}
+              dimColor
+            >
+              {block.content}
+            </Text>
+          )}
         </Box>
       )}
 

package/src/components/RemoteControlView.tsx

@@ -1,7 +1,7 @@
 /**
  * RemoteControlView — `/remote-control` 的覆盖层（把这条前台会话交给手机）。
  *
- * 规格：docs/specs/ui/remote-control.md「前台 CLI 会话也能被手机接管」。
+ * 规格：docs/specs/remote/remote-web.md「前台 CLI 会话也能被手机接管」。
  *
  * **这个斜杠命令不带参数**：没有 `on` / `off` / `status` 子命令，也不收机器名。
  * 判据是「状态自己决定动作」——`off` / `error` 时唯一合法动作是开启，`connecting`

package/src/components/RewindCommand.tsx

@@ -1,84 +1,78 @@
 import React, { useState, useReducer, useEffect } from "react";
 import { Box, Text, useInput } from "ink";
-import type { Message } from "wave-agent-sdk";
-import { getMessageContent } from "wave-agent-sdk";
+import type { RewindCheckpoint } from "wave-agent-sdk";
 import { rewindSelectorReducer } from "../reducers/rewindSelectorReducer.js";
-import { isUserCheckpointMessage } from "../utils/rewindCheckpoints.js";
+
+/** 稳定的空表：加载期也要能渲染，但不能每帧造一个新数组（effect 依赖它）。 */
+const NO_CHECKPOINTS: RewindCheckpoint[] = [];
 
 export interface RewindCommandProps {
-  messages: Message[];
+  /**
+   * 取检查点表。SDK 扫转录当场投影，内存里不留整条线程——这一屏要的只是
+   * 「哪几条能回滚到」和它们在完整线程里的位置。
+   */
+  getCheckpoints: () => Promise<RewindCheckpoint[]>;
+  /** 参数是在完整线程里的绝对位置，直接喂 `truncateHistory(index)`。 */
   onSelect: (index: number) => void;
   onCancel: () => void;
-  getFullMessageThread?: () => Promise<{
-    messages: Message[];
-    sessionIds: string[];
-  }>;
 }
 
 export const RewindCommand: React.FC<RewindCommandProps> = ({
-  messages: initialMessages,
+  getCheckpoints,
   onSelect,
   onCancel,
-  getFullMessageThread,
 }) => {
-  const [messages, setMessages] = useState<Message[]>(initialMessages);
-  const [isLoading, setIsLoading] = useState(!!getFullMessageThread);
+  const [checkpoints, setCheckpoints] = useState<RewindCheckpoint[] | null>(
+    null,
+  );
+  const isLoading = checkpoints === null;
 
   useEffect(() => {
-    if (getFullMessageThread) {
-      getFullMessageThread().then(({ messages: fullMessages }) => {
-        setMessages(fullMessages);
-        setIsLoading(false);
-      });
-    }
-  }, [getFullMessageThread]);
-
-  // Filter user messages as checkpoints, excluding meta messages and
-  // system-generated user-role messages (task notifications, hook injections).
-  // Compaction is append-only: the same message id appears twice on the full
-  // thread (pre-compact history + post-compact append), so dedupe by id and
-  // keep the last occurrence (matching the folded view the user sees).
-  const checkpointMap = new Map<string, { msg: Message; index: number }>();
-  messages.forEach((msg, index) => {
-    if (!isUserCheckpointMessage(msg)) return;
-    checkpointMap.set(msg.id ?? `index:${index}`, { msg, index });
-  });
-  const checkpoints = Array.from(checkpointMap.values());
+    let cancelled = false;
+    getCheckpoints().then((loaded) => {
+      if (!cancelled) setCheckpoints(loaded);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [getCheckpoints]);
+
+  const items = checkpoints ?? NO_CHECKPOINTS;
 
   const MAX_VISIBLE_ITEMS = 3;
 
   const [state, dispatch] = useReducer(rewindSelectorReducer, {
-    selectedIndex: checkpoints.length - 1,
+    selectedIndex: items.length - 1,
     pendingDecision: null,
   });
 
   const { selectedIndex, pendingDecision } = state;
 
-  // Update selectedIndex when checkpoints change (after loading full thread)
+  // Update selectedIndex when checkpoints arrive
   useEffect(() => {
-    dispatch({ type: "RESET_INDEX", index: checkpoints.length - 1 });
-  }, [checkpoints.length]);
+    dispatch({ type: "RESET_INDEX", index: items.length - 1 });
+  }, [items.length]);
 
   // Handle decisions from reducer
   useEffect(() => {
     if (!pendingDecision) return;
 
     if (pendingDecision === "select") {
-      if (checkpoints.length > 0 && selectedIndex >= 0) {
-        onSelect(checkpoints[selectedIndex].index);
+      if (items.length > 0 && selectedIndex >= 0) {
+        onSelect(items[selectedIndex].index);
       }
     } else if (pendingDecision === "cancel") {
       onCancel();
     }
 
     dispatch({ type: "CLEAR_DECISION" });
-  }, [pendingDecision, selectedIndex, checkpoints, onSelect, onCancel]);
+  }, [pendingDecision, selectedIndex, items, onSelect, onCancel]);
 
   useInput((input, key) => {
     dispatch({
       type: "HANDLE_KEY",
       key,
-      maxIndex: checkpoints.length - 1,
+      maxIndex: items.length - 1,
     });
   });
 
@@ -92,12 +86,12 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
         borderLeft={false}
         borderRight={false}
       >
-        <Text color="cyan">Loading full message thread...</Text>
+        <Text color="cyan">Loading rewind checkpoints...</Text>
       </Box>
     );
   }
 
-  if (checkpoints.length === 0) {
+  if (items.length === 0) {
     return (
       <Box
         flexDirection="column"
@@ -118,10 +112,10 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
     0,
     Math.min(
       selectedIndex - Math.floor(MAX_VISIBLE_ITEMS / 2),
-      Math.max(0, checkpoints.length - MAX_VISIBLE_ITEMS),
+      Math.max(0, items.length - MAX_VISIBLE_ITEMS),
     ),
   );
-  const visibleCheckpoints = checkpoints.slice(
+  const visibleCheckpoints = items.slice(
     startIndex,
     startIndex + MAX_VISIBLE_ITEMS,
   );
@@ -146,19 +140,19 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
         {visibleCheckpoints.map((checkpoint, index) => {
           const actualIndex = startIndex + index;
           const isSelected = actualIndex === selectedIndex;
-          const content = getMessageContent(checkpoint.msg)
+          const content = checkpoint.content
             .replace(/\n/g, "\\n")
             .substring(0, 60);
 
           return (
-            <Box key={checkpoint.index}>
+            <Box key={checkpoint.id}>
               <Text
                 color={isSelected ? "black" : "white"}
                 backgroundColor={isSelected ? "cyan" : undefined}
               >
                 {isSelected ? "▶ " : "  "}[{checkpoint.index}]{" "}
                 {content || "(No text content)"}
-                {actualIndex === checkpoints.length - 1 ? " (Latest)" : ""}
+                {actualIndex === items.length - 1 ? " (Latest)" : ""}
               </Text>
             </Box>
           );

package/src/contexts/useChat.tsx

@@ -14,6 +14,7 @@ import {
 } from "../hooks/useRemoteControl.js";
 import type {
   Message,
+  MessageBlock,
   McpServerStatus,
   BackgroundTask,
   Task,
@@ -26,6 +27,7 @@ import type {
   QueuedMessage,
   WorkflowRun,
   ToolBlockUpdateCallbackParams,
+  RewindCheckpoint,
 } from "wave-agent-sdk";
 import {
   Agent,
@@ -184,10 +186,8 @@ export interface ChatContextType {
   forceRemount: (options?: { preserveScrollback?: boolean }) => void;
   // Rewind functionality
   handleRewindSelect: (index: number) => Promise<void>;
-  getFullMessageThread: () => Promise<{
-    messages: Message[];
-    sessionIds: string[];
-  }>;
+  /** `/rewind` 的检查点表：SDK 扫转录投影，CLI 不留整条线程。 */
+  getRewindCheckpoints: () => Promise<RewindCheckpoint[]>;
   // Status metadata
   getGatewayConfig: () => import("wave-agent-sdk").GatewayConfig;
   getModelConfig: () => import("wave-agent-sdk").ModelConfig;
@@ -364,6 +364,38 @@ const applyToolBlockUpdate = (
   });
 };
 
+/**
+ * Append a block to the last message — only when it is an assistant message
+ * (the current turn's in-flight reply). If the last message is a user message,
+ * the block belongs BELOW it: create a new assistant message instead of
+ * polluting the stale assistant from an earlier turn. Same rule the webview
+ * reducer applies (APPEND_NOTICE_BLOCK).
+ *
+ * Both the error and the system line use this: the SDK appends them to the
+ * same place (`appendBlockToLastAssistant`), so the CLI must not invent a
+ * second placement rule.
+ */
+const appendBlockToLastAssistant = (
+  prev: Message[],
+  block: MessageBlock,
+): Message[] => {
+  const last = prev[prev.length - 1];
+  if (last && last.role === "assistant") {
+    return prev.map((m, idx) =>
+      idx === prev.length - 1 ? { ...m, blocks: [...m.blocks, block] } : m,
+    );
+  }
+  return [
+    ...prev,
+    {
+      id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+      role: "assistant",
+      timestamp: new Date().toISOString(),
+      blocks: [block],
+    },
+  ];
+};
+
 export const ChatProvider: React.FC<ChatProviderProps> = ({
   children,
   bypassPermissions,
@@ -727,39 +759,19 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           // `end` carries the authoritative final values.
           setMessages((prev) => applyToolBlockUpdate(prev, params));
         },
-        onErrorBlockAdded: (error: string) => {
-          remoteStream?.onErrorBlockAdded(error);
+        onNoticeAdded: ({ level, content }) => {
+          remoteStream?.onNoticeAdded({ level, content });
           if (isExpandedRef.current) return;
-          // One-shot structural update — applied directly (errors must not be
-          // delayed by the tool-running window).
-          setMessages((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
-            // assistant message instead of polluting the stale assistant from
-            // an earlier turn (which surfaced the error above the latest
-            // user message and accumulated it there).
-            const last = prev[prev.length - 1];
-            if (last && last.role === "assistant") {
-              return prev.map((m, idx) =>
-                idx === prev.length - 1
-                  ? {
-                      ...m,
-                      blocks: [...m.blocks, { type: "error", content: error }],
-                    }
-                  : m,
-              );
-            }
-            return [
-              ...prev,
-              {
-                id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
-                role: "assistant",
-                timestamp: new Date().toISOString(),
-                blocks: [{ type: "error", content: error }],
-              },
-            ];
-          });
+          // One-shot structural update — applied directly (a failure must not
+          // be delayed by the tool-running window; a hook's round line must
+          // not wait for the next `refreshMessages`).
+          setMessages((prev) =>
+            appendBlockToLastAssistant(prev, {
+              type: "notice",
+              level,
+              content,
+            }),
+          );
         },
         onLatestTotalTokensChange: (tokens) => {
           setLatestTotalTokens(tokens);
@@ -782,9 +794,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           }
         },
         onCompactionContentUpdate: (content) => {
-          // The SDK delivers the accumulated compaction text; the loading
-          // indicator renders only its last 30 characters (streaming tail).
-          setCompactionStream(content);
+          // Delta of newly produced compaction text — appended; the loading
+          // indicator renders only the last 30 characters (streaming tail).
+          setCompactionStream((prev) => prev + content);
         },
         onBackgroundTasksChange: async (tasks) => {
           setBackgroundTasks([...tasks]);
@@ -1214,7 +1226,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
             timestamp: new Date().toISOString(),
             blocks: [
               {
-                type: "error",
+                type: "notice",
+                level: "error",
                 content: `Failed to resume conversation: ${
                   error instanceof Error ? error.message : String(error)
                 }`,
@@ -1468,12 +1481,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     renameSession: (title) => agentRef.current?.renameSession(title),
     compact: (instructions) => compact(instructions),
     slashCommands: () => agentRef.current?.getSlashCommands() ?? [],
-    // 手机页取首屏尾段 / 补差都读 agent 手上那份列表（压缩后的上下文），不去
-    // 转录里找压缩前的历史。
+    // 手机页取首屏尾段 / 补差都读 agent 手上那份列表（压缩后的上下文）；它这一侧
+    // 不提供上翻，所以不会带来 `before` 锚点。
     messagePage: (window) =>
-      Promise.resolve(
-        agentRef.current?.getMessagePage(window) ?? { messages: [] },
-      ),
+      agentRef.current?.getMessagePage(window) ??
+      Promise.resolve({ messages: [] }),
     currentThread: () =>
       Promise.resolve([...(agentRef.current?.messages ?? [])]),
     threadSummary: () =>
@@ -1505,11 +1517,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     [forceRemount, refreshMessages],
   );
 
-  const getFullMessageThread = useCallback(async () => {
+  const getRewindCheckpoints = useCallback(async () => {
     if (agentRef.current) {
-      return await agentRef.current.getFullMessageThread();
+      return await agentRef.current.getRewindCheckpoints();
     }
-    return { messages: [], sessionIds: [] };
+    return [];
   }, []);
 
   const getGatewayConfig = useCallback(() => {
@@ -1630,7 +1642,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     remountKey,
     forceRemount,
     handleRewindSelect,
-    getFullMessageThread,
+    getRewindCheckpoints,
 
     getGatewayConfig,
     getModelConfig,