wave-code 1.6.0 → 1.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -29,16 +29,14 @@
   ],
   "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",
     "@types/react": "^19.3.0",
     "@types/semver": "^7.7.1",
     "@types/yargs": "^17.0.0",
-    "@vitest/coverage-v8": "^4.1.7",
+    "@vitest/coverage-v8": "^5.1.0",
     "chalk": "^5.6.2",
     "diff": "^8.0.2",
     "esbuild": "^0.28.1",
@@ -55,11 +53,11 @@
     "semver": "^7.7.4",
     "string-width": "^8.2.2",
     "tsx": "^4.20.4",
-    "vitest": "^4.1.7",
+    "vitest": "^5.1.0",
     "wrap-ansi": "^10.0.0",
     "yargs": "^17.7.2",
     "zod": "^3.23.8",
-    "wave-agent-sdk": "1.6.0"
+    "wave-agent-sdk": "1.6.2"
   },
   "engines": {
     "node": ">=22"

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 { 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) => {

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

@@ -6,6 +6,7 @@ import {
   selectorReducer,
   type SelectorState,
 } from "../reducers/selectorReducer.js";
+import { toOneLine } from "../utils/oneLine.js";
 
 export interface CommandSelectorProps {
   searchQuery: string;
@@ -140,9 +141,11 @@ export const CommandSelector: React.FC<CommandSelectorProps> = ({
                 {isSelected ? "▶ " : "  "}/{command.id}
               </Text>
               {isSelected && (
-                <Box marginLeft={4}>
-                  <Text color="gray" dimColor>
-                    {command.description}
+                <Box marginLeft={4} minHeight={1}>
+                  {/* One line, always: the slot keeps the menu height stable
+                      whatever the description's length. */}
+                  <Text color="gray" dimColor wrap="truncate">
+                    {toOneLine(command.description ?? "")}
                   </Text>
                 </Box>
               )}

package/src/components/FileSelector.tsx

@@ -5,6 +5,7 @@ import {
   selectorReducer,
   type SelectorState,
 } from "../reducers/selectorReducer.js";
+import { toOneLine } from "../utils/oneLine.js";
 
 export type { FileSelectorItem };
 
@@ -119,15 +120,25 @@ export const FileSelector: React.FC<FileSelectorProps> = ({
 
           return (
             <Box key={fileItem.path}>
-              <Text
-                color={isSelected ? "black" : "white"}
-                backgroundColor={isSelected ? "cyan" : undefined}
-              >
-                {isSelected ? "▶ " : "  "}
-                {fileItem.agentName ? `@${fileItem.agentName}` : fileItem.path}
-              </Text>
+              {/* The name keeps its width; the description gives way. */}
+              <Box flexShrink={0}>
+                <Text
+                  color={isSelected ? "black" : "white"}
+                  backgroundColor={isSelected ? "cyan" : undefined}
+                >
+                  {isSelected ? "▶ " : "  "}
+                  {fileItem.agentName
+                    ? `@${fileItem.agentName}`
+                    : fileItem.path}
+                </Text>
+              </Box>
               {fileItem.agentDescription && (
-                <Text dimColor> {fileItem.agentDescription}</Text>
+                <Box flexShrink={1}>
+                  <Text dimColor wrap="truncate">
+                    {" "}
+                    {toOneLine(fileItem.agentDescription)}
+                  </Text>
+                </Box>
               )}
             </Box>
           );

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

@@ -101,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[];
@@ -202,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) {
@@ -425,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
@@ -921,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?.() || [];
@@ -1030,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);
+        });
       }
     };
   }, []);
@@ -1456,7 +1483,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     isLoading,
     permissionMode,
     latestTotalTokens,
-    maxInputTokens,
+    contextWindow,
+    maxOutputTokens,
     // 手机侧会话列表的标题材料：`customTitle` 不走 React state（agent 自己存着，
     // 重命名后即刻生效），所以按「取当前值」的函数递给门面。
     customTitle: () => agentRef.current?.customTitle,
@@ -1481,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: [] }),
@@ -1603,7 +1633,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     recallQueuedMessage,
     removeQueuedMessageById,
     latestTotalTokens,
-    maxInputTokens,
+    contextWindow,
+    maxOutputTokens,
     currentModel,
     configuredModels,
     getConfiguredModels,

package/src/hooks/useExitSignals.ts

@@ -0,0 +1,83 @@
+import { useEffect, useRef } from "react";
+
+/**
+ * Process-level exit detection for the interactive CLI.
+ *
+ * Ink runs the terminal in raw mode, so Ctrl-C normally arrives as a keypress
+ * (`useInput`) rather than a signal — but the signals still arrive when the
+ * process is killed from outside, and the terminal itself sends one when the
+ * user closes the window. Every one of those paths has to unwind through React
+ * unmount, because that is what triggers `Agent.destroy()`; without a handler
+ * Node applies the default action and terminates on the spot, leaving the
+ * agent's async teardown — and every child process it owns — unreaped.
+ *
+ * `SIGHUP` is the one that actually bit us. The Bash tool spawns its shell with
+ * `detached: true`, which makes the child the leader of its own process group
+ * and therefore immune to the terminal's SIGHUP broadcast. If nothing reaps it,
+ * the shell and everything under it survive as launchd-reparented orphans
+ * (observed: one `zsh -> ping -> tail` group alive for almost three days).
+ * Claude Code registers the same signal for the same reason.
+ *
+ * The polling branch covers macOS specifically: closing a terminal there
+ * revokes the TTY file descriptors *instead of* delivering a signal, leaving
+ * the process alive but unable to read or write. Nothing else would ever
+ * notice, so the stdio handles are probed on the same 30s cadence Claude Code
+ * uses in `gracefulShutdown`.
+ */
+const TTY_REVOCATION_CHECK_INTERVAL_MS = 30_000;
+
+/**
+ * Invoke `onExitSignal` on SIGINT / SIGTERM / SIGHUP, and when the controlling
+ * TTY is revoked out from under the process.
+ *
+ * `onExitSignal` is held in a ref, so callers do not need to memoize it and a
+ * re-render does not churn the signal registrations. Callers are responsible
+ * for making the teardown itself idempotent: a single terminal close can arrive
+ * as a signal *and* as a revoked TTY.
+ *
+ * @param enabled - set false to skip registration entirely (e.g. a wrapper
+ *   component that renders a child which owns the handler).
+ */
+export function useExitSignals(onExitSignal: () => void, enabled = true): void {
+  const handlerRef = useRef(onExitSignal);
+  handlerRef.current = onExitSignal;
+
+  useEffect(() => {
+    if (!enabled) return;
+
+    const handle = () => handlerRef.current();
+
+    // Windows has no SIGHUP: the event never fires there, so registering it
+    // would only imply a coverage the platform cannot provide.
+    const signals: NodeJS.Signals[] =
+      process.platform === "win32"
+        ? ["SIGINT", "SIGTERM"]
+        : ["SIGINT", "SIGTERM", "SIGHUP"];
+    for (const signal of signals) {
+      process.on(signal, handle);
+    }
+
+    // Only meaningful for an interactive terminal; piping either stream out
+    // means the handles legitimately stop being readable/writable.
+    let ttyRevocationPoll: NodeJS.Timeout | undefined;
+    if (process.stdin.isTTY) {
+      ttyRevocationPoll = setInterval(() => {
+        if (!process.stdout.writable || !process.stdin.readable) {
+          // Stop polling before handing off: the revoked TTY stays revoked, so
+          // a surviving interval would re-fire the teardown every 30s.
+          if (ttyRevocationPoll) clearInterval(ttyRevocationPoll);
+          handle();
+        }
+      }, TTY_REVOCATION_CHECK_INTERVAL_MS);
+      // Never keep the process alive just to poll for its own death.
+      ttyRevocationPoll.unref();
+    }
+
+    return () => {
+      for (const signal of signals) {
+        process.off(signal, handle);
+      }
+      if (ttyRevocationPoll) clearInterval(ttyRevocationPoll);
+    };
+  }, [enabled]);
+}

package/src/hooks/useRemoteControl.ts

@@ -61,7 +61,8 @@ export interface UseRemoteControlOptions {
   isLoading: boolean;
   permissionMode: PermissionMode;
   latestTotalTokens: number;
-  maxInputTokens: number;
+  contextWindow: number;
+  maxOutputTokens: number;
   /**
    * The title `/rename` sets, read live off the agent — the page's session list
    * labels the row with it (and the page itself may be the one that renamed it).
@@ -194,10 +195,20 @@ export function useRemoteControl(
     if (!sink || !sessionId) return;
     sink.sendNotification(
       "contextUsage",
-      remoteWire.contextUsage(latestTotalTokens, options.maxInputTokens),
+      remoteWire.contextUsage(
+        latestTotalTokens,
+        options.contextWindow,
+        options.maxOutputTokens,
+      ),
       sessionId,
     );
-  }, [sink, sessionId, latestTotalTokens, options.maxInputTokens]);
+  }, [
+    sink,
+    sessionId,
+    latestTotalTokens,
+    options.contextWindow,
+    options.maxOutputTokens,
+  ]);
 
   // Approvals are announced once, when they appear. The page answers with
   // `permissionResponse`, which the host routes back into the same promise the
@@ -318,7 +329,8 @@ function adapterOf(latest: {
     contextUsagePercent: () =>
       percentOf(
         latest.current.latestTotalTokens,
-        latest.current.maxInputTokens,
+        latest.current.contextWindow,
+        latest.current.maxOutputTokens,
       ),
     latestTotalTokens: () => latest.current.latestTotalTokens,
     permissionMode: () => latest.current.permissionMode,

package/src/managers/inputReducer.ts

@@ -39,7 +39,7 @@ export interface FileSelectorItem {
   type: "file" | "directory" | "agent";
   /** 子代理名（`type === "agent"` 时有值），也是插入正文的名字。 */
   agentName?: string;
-  /** 子代理定义的 description，作为条目的第二行说明。 */
+  /** 子代理定义的 description，接在名字后面同一行显示；超宽截断成一行。 */
   agentDescription?: string;
 }