wave-code 1.5.1 → 1.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -29,9 +29,7 @@
   ],
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.81",
-    "@vscode/ripgrep": "^1.18.0",
-    "qrcode": "^1.5.4",
-    "sharp": "^0.35.4"
+    "qrcode": "^1.5.4"
   },
   "devDependencies": {
     "@types/qrcode": "^1.5.6",
@@ -59,7 +57,7 @@
     "wrap-ansi": "^10.0.0",
     "yargs": "^17.7.2",
     "zod": "^3.23.8",
-    "wave-agent-sdk": "1.5.1"
+    "wave-agent-sdk": "1.6.1"
   },
   "engines": {
     "node": ">=22"
@@ -69,11 +67,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

@@ -2,10 +2,51 @@ import React from "react";
 import { render } from "ink";
 import { ensureRuntimeDeps } from "wave-agent-sdk";
 import { App } from "./components/App.js";
+import { getPendingAgentDestroy } from "./contexts/useChat.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";
 
+/**
+ * Upper bound on waiting for `Agent.destroy()` after the UI is gone.
+ *
+ * The teardown is bounded on its own side (its async-work drain has a timeout),
+ * but a wedged MCP child or LSP server must not turn closing the window into a
+ * process that never exits. Past this point the orphan risk is accepted in
+ * exchange for a terminal that actually comes back.
+ */
+const AGENT_DESTROY_TIMEOUT_MS = 5_000;
+
+/**
+ * Await the teardown that the unmount cleanup started.
+ *
+ * React effect cleanups are synchronous, so unmounting only *begins*
+ * `Agent.destroy()`; without this wait, `process.exit()` below terminates the
+ * process while the bash process trees, MCP children and LSP servers that
+ * `destroy()` was about to signal are still alive. Detached bash children then
+ * outlive their parent as launchd-reparented orphans.
+ */
+async function awaitAgentDestroy(): Promise<void> {
+  const pending = getPendingAgentDestroy();
+  if (!pending) return;
+
+  let timeoutHandle: NodeJS.Timeout | undefined;
+  const timeout = new Promise<void>((resolve) => {
+    timeoutHandle = setTimeout(() => {
+      console.warn(
+        "Agent teardown timed out; exiting without waiting further.",
+      );
+      resolve();
+    }, AGENT_DESTROY_TIMEOUT_MS);
+  });
+
+  try {
+    await Promise.race([pending, timeout]);
+  } finally {
+    if (timeoutHandle) clearTimeout(timeoutHandle);
+  }
+}
+
 export interface CliOptions extends BaseAppProps {
   restoreSessionId?: string;
   continueLastSession?: boolean;
@@ -40,8 +81,13 @@ export async function startCli(options: CliOptions): Promise<void> {
 
   // Continue with ink-based UI for normal mode
   let shouldRemoveWorktree = false;
+  let isExiting = false;
 
   const handleExit = (shouldRemove: boolean) => {
+    // A single close can arrive twice (SIGHUP plus the TTY-revocation poll, or
+    // an outside kill racing the keypress). Only the first one may unmount.
+    if (isExiting) return;
+    isExiting = true;
     shouldRemoveWorktree = shouldRemove;
     unmount();
   };
@@ -83,6 +129,10 @@ export async function startCli(options: CliOptions): Promise<void> {
   // Wait for the app to finish unmounting
   await waitUntilExit();
 
+  // ...which only *started* the agent teardown. Let it finish before exiting,
+  // otherwise the bash trees it was about to signal survive as orphans.
+  await awaitAgentDestroy();
+
   try {
     // Clean up old log files
     await cleanupLogs().catch((error) => {
@@ -96,8 +146,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/App.tsx

@@ -1,9 +1,10 @@
-import React, { useState, useEffect, useCallback } from "react";
+import React, { useState, useCallback } from "react";
 import { useInput } from "ink";
 import { ChatInterface } from "./ChatInterface.js";
 import { ChatProvider } from "../contexts/useChat.js";
 import { AppProvider } from "../contexts/useAppConfig.js";
 import { WorktreeExitPrompt } from "./WorktreeExitPrompt.js";
+import { useExitSignals } from "../hooks/useExitSignals.js";
 import {
   hasUncommittedChanges,
   hasNewCommits,
@@ -58,18 +59,11 @@ const ChatWithExitPrompt: React.FC<{
     }
   });
 
-  useEffect(() => {
-    const onSigInt = () => handleSignal();
-    const onSigTerm = () => handleSignal();
-
-    process.on("SIGINT", onSigInt);
-    process.on("SIGTERM", onSigTerm);
-
-    return () => {
-      process.off("SIGINT", onSigInt);
-      process.off("SIGTERM", onSigTerm);
-    };
-  }, [handleSignal]);
+  // Terminal close / outside kill: the worktree prompt still applies, because
+  // the same uncommitted-changes check has to run for an exit nobody typed.
+  useExitSignals(() => {
+    void handleSignal();
+  });
 
   if (isExiting && worktreeStatus) {
     return (
@@ -116,6 +110,12 @@ const AppWithProviders: React.FC<AppWithProvidersProps> = ({
     }
   });
 
+  // An outside kill or a terminal close never reaches `useInput` — it arrives
+  // as a signal, or on macOS as nothing at all. With a worktree, the prompt
+  // component owns that handler (it has uncommitted changes to check first), so
+  // this registration stays out of the way.
+  useExitSignals(() => onExit(false), !worktreeSession);
+
   if (worktreeSession) {
     return (
       <ChatProvider

package/src/components/ChatInterface.tsx

@@ -26,7 +26,8 @@ export const ChatInterface: React.FC = () => {
     isExpanded,
     sessionId,
     latestTotalTokens,
-    maxInputTokens,
+    contextWindow,
+    maxOutputTokens,
     slashCommands,
     hasSlashCommand,
     hooks,
@@ -112,7 +113,8 @@ export const ChatInterface: React.FC = () => {
             hasSlashCommand={hasSlashCommand}
             hooks={hooks}
             latestTotalTokens={latestTotalTokens}
-            maxInputTokens={maxInputTokens}
+            contextWindow={contextWindow}
+            maxOutputTokens={maxOutputTokens}
             showLoginHint={showLoginHint}
           />
         </>

package/src/components/InputBox.tsx

@@ -63,7 +63,8 @@ export interface InputBoxProps {
   >;
   // Token usage
   latestTotalTokens?: number;
-  maxInputTokens?: number;
+  contextWindow?: number;
+  maxOutputTokens?: number;
   // Login hint
   showLoginHint?: boolean;
 }
@@ -81,7 +82,8 @@ export const InputBox: React.FC<InputBoxProps> = ({
   hasSlashCommand = () => false,
   hooks = {},
   latestTotalTokens = 0,
-  maxInputTokens = 200000,
+  contextWindow = 200000,
+  maxOutputTokens = 32000,
   showLoginHint = false,
 }) => {
   const {
@@ -509,7 +511,8 @@ export const InputBox: React.FC<InputBoxProps> = ({
                   />
                   <Notifications
                     latestTotalTokens={latestTotalTokens}
-                    maxInputTokens={maxInputTokens}
+                    contextWindow={contextWindow}
+                    maxOutputTokens={maxOutputTokens}
                     showLoginHint={showLoginHint}
                     pluginHint={pluginHint}
                   />

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/Notifications.tsx

@@ -1,9 +1,11 @@
 import React from "react";
 import { Box, Text } from "ink";
+import { percentOf } from "../remote/remoteNotifications.js";
 
 export interface NotificationsProps {
   latestTotalTokens?: number;
-  maxInputTokens?: number;
+  contextWindow?: number;
+  maxOutputTokens?: number;
   showLoginHint?: boolean;
   /**
    * 一次性中性提示（插件变更待应用 / 重载完成）。由宿主显式设置并在数秒后清除，
@@ -14,13 +16,14 @@ export interface NotificationsProps {
 
 export const Notifications: React.FC<NotificationsProps> = ({
   latestTotalTokens = 0,
-  maxInputTokens = 200000,
+  contextWindow = 200000,
+  maxOutputTokens = 32000,
   showLoginHint = false,
   pluginHint = null,
 }) => {
   const percentage =
     latestTotalTokens > 0
-      ? Math.min(Math.round((latestTotalTokens / maxInputTokens) * 100), 100)
+      ? percentOf(latestTotalTokens, contextWindow, maxOutputTokens)
       : 0;
 
   const contextColor =

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/contexts/useChat.tsx

@@ -14,6 +14,7 @@ import {
 } from "../hooks/useRemoteControl.js";
 import type {
   Message,
+  MessageBlock,
   McpServerStatus,
   BackgroundTask,
   Task,
@@ -100,7 +101,8 @@ export interface ChatContextType {
   recallQueuedMessage: () => QueuedMessage | null;
   removeQueuedMessageById: (id: string) => boolean;
   latestTotalTokens: number;
-  maxInputTokens: number;
+  contextWindow: number;
+  maxOutputTokens: number;
   // Model functionality
   currentModel: string;
   configuredModels: string[];
@@ -201,6 +203,23 @@ export interface ChatContextType {
 
 const ChatContext = createContext<ChatContextType | null>(null);
 
+/**
+ * Handoff for the agent teardown that React unmount can only *start*.
+ *
+ * A React effect cleanup is synchronous: it cannot await `Agent.destroy()`,
+ * whose teardown (bash process trees, MCP children, LSP, async work drain) is
+ * async. `cli.tsx` used to call `process.exit(0)` the moment `waitUntilExit()`
+ * resolved, which cut that teardown short — the detached bash process group
+ * never received its SIGTERM and survived as an orphan. The promise is parked
+ * here so the exit path can await it before exiting.
+ */
+let pendingAgentDestroy: Promise<void> | null = null;
+
+/** The in-flight teardown started by the unmount cleanup, if any. */
+export function getPendingAgentDestroy(): Promise<void> | null {
+  return pendingAgentDestroy;
+}
+
 export const useChat = () => {
   const context = useContext(ChatContext);
   if (!context) {
@@ -363,6 +382,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,
@@ -392,7 +443,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
   const [messages, setMessages] = useState<Message[]>([]);
   const [latestTotalTokens, setLatestTotalTokens] = useState(0);
-  const [maxInputTokens, setMaxInputTokens] = useState(200000);
+  const [contextWindow, setContextWindow] = useState(200000);
+  const [maxOutputTokens, setMaxOutputTokens] = useState(32000);
 
   // All message-state updates apply IMMEDIATELY via setMessages — no data-layer
   // throttling (removed 2026-10-15 after observing fully-immediate rendering in
@@ -726,39 +778,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);
@@ -908,7 +940,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         setWorkingDirectory(agent.currentWorkdir);
         setCurrentModelState(agent.getModelConfig().model || "");
         setConfiguredModels(agent.getConfiguredModels().map((m) => m.name));
-        setMaxInputTokens(agent.getMaxInputTokens());
+        setContextWindow(agent.getContextWindow());
+        setMaxOutputTokens(agent.getMaxOutputTokens?.() ?? 32_000);
 
         // Get initial MCP servers state
         const initialMcpServers = agent.getMcpServers?.() || [];
@@ -1017,16 +1050,23 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   useEffect(() => {
     return () => {
       if (agentRef.current) {
+        const agent = agentRef.current;
         try {
           // Display usage summary before cleanup
-          const usages = agentRef.current.usages;
-          const sessionFilePath = agentRef.current.sessionFilePath;
+          const usages = agent.usages;
+          const sessionFilePath = agent.sessionFilePath;
           displayUsageSummary(usages, sessionFilePath);
         } catch {
           // Silently ignore usage summary errors during cleanup
         }
 
-        agentRef.current.destroy();
+        // Park the promise instead of dropping it: the exit path in `cli.tsx`
+        // awaits it before `process.exit()` so the teardown actually runs
+        // (see `pendingAgentDestroy`). Failures are swallowed so a broken
+        // teardown cannot turn a clean exit into an unhandled rejection.
+        pendingAgentDestroy = agent.destroy().catch((error: unknown) => {
+          logger.warn("Agent teardown failed during exit:", error);
+        });
       }
     };
   }, []);
@@ -1213,7 +1253,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)
                 }`,
@@ -1442,7 +1483,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     isLoading,
     permissionMode,
     latestTotalTokens,
-    maxInputTokens,
+    contextWindow,
+    maxOutputTokens,
     // 手机侧会话列表的标题材料：`customTitle` 不走 React state（agent 自己存着，
     // 重命名后即刻生效），所以按「取当前值」的函数递给门面。
     customTitle: () => agentRef.current?.customTitle,
@@ -1467,8 +1509,10 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     renameSession: (title) => agentRef.current?.renameSession(title),
     compact: (instructions) => compact(instructions),
     slashCommands: () => agentRef.current?.getSlashCommands() ?? [],
-    // 手机页取首屏尾段 / 补差都读 agent 手上那份列表（压缩后的上下文）；它这一侧
-    // 不提供上翻，所以不会带来 `before` 锚点。
+    // 手机页取数都读 agent 手上那份列表（压缩后的上下文）：首屏尾段（`limit`）、
+    // 重连补差（`since`）、滚到顶往回翻（`before` + `limit`）三种窗口原样交给
+    // SDK，切片与 `hasMore` / `anchorLost` 都由它判。分页是 2026-11-06 起远控页
+    // 也有的能力，所以这里不能只认前两种。
     messagePage: (window) =>
       agentRef.current?.getMessagePage(window) ??
       Promise.resolve({ messages: [] }),
@@ -1589,7 +1633,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     recallQueuedMessage,
     removeQueuedMessageById,
     latestTotalTokens,
-    maxInputTokens,
+    contextWindow,
+    maxOutputTokens,
     currentModel,
     configuredModels,
     getConfiguredModels,