wave-code 1.6.0 → 1.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "1.6.0",
+  "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.6.0"
+    "wave-agent-sdk": "1.6.1"
   },
   "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/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/remote/remoteControlCliHost.ts

@@ -249,10 +249,19 @@ export class RemoteControlCliHost implements RemoteControlHost {
       decision?: unknown;
     };
     if (typeof p.requestId !== "string" || !p.decision) return;
-    this.session.respondPermission(
-      p.requestId,
-      p.decision as PermissionDecision,
-    );
+    const decision = p.decision as PermissionDecision;
+    this.session.respondPermission(p.requestId, decision);
+    // 不带反馈的拒绝 = 用户在页面上关掉了确认卡（关闭键 / Esc），本轮就此结束：
+    // 与桌面端 / VS Code / JetBrains 的 `denied → abortMessage()`、以及 Claude
+    // Code 的 `cancelAndAbort`（无 feedback 直接 abort 整轮）同一条语义。少了这
+    // 一步，手机上关掉提问弹窗后模型会拿着「用户拒绝了操作」继续往下做，而同一
+    // 张卡在桌面端关掉就停（spec ui/confirm-ui.md 场景 2 / 5、remote-web.md
+    // 场景 24）。**带 message 的拒绝不中断**——那是用户给出理由后拒绝这一次工具
+    // 调用，模型要照反馈继续或改问。
+    const rejectionFeedback = decision.message?.trim();
+    if (decision.behavior === "deny" && !rejectionFeedback) {
+      this.session.abort();
+    }
   }
 
   /**
@@ -388,10 +397,17 @@ export class RemoteControlCliHost implements RemoteControlHost {
     messages: Message[];
     contextUsagePercent: number;
     reset?: boolean;
+    anchorLost?: boolean;
+    hasMore?: boolean;
   }> {
     const contextUsagePercent = this.session.contextUsagePercent();
     const window: MessageWindow = {};
     if (typeof p.since === "string") window.since = p.since;
+    // 上翻取更早的锚点（spec ui/message-rendering-system.md「首屏一页，上翻按需
+    // 取更早」，远控页自 2026-11-06 起也翻）。少这一行，`{before, limit}` 会被当成
+    // 「只要一页尾巴」——回的是同一段尾部、`hasMore` 仍是 true，页面每次滚到顶都
+    // 白要一次，永远翻不动。
+    if (typeof p.before === "string") window.before = p.before;
     if (p.limit !== undefined) window.limit = Number(p.limit);
 
     let normalized: MessageWindow | undefined;

package/src/remote/remoteControlService.ts

@@ -696,7 +696,7 @@ export class RemoteControlService implements RemoteControlController {
       // Not even one message fits: there is nothing to send that the phone
       // could render, and an empty list would only make it re-ask forever.
       if (kept > 0) {
-        this.send(pageFrame(replyId, page, kept));
+        this.send(pageFrame(replyId, page, kept, kept < page.messages.length));
         return;
       }
     }
@@ -859,13 +859,19 @@ function pageFrame(
   replyId: number | string,
   page: MessagePage,
   count: number,
+  droppedEarlier = false,
 ): RelayEnvelope {
+  // 裁掉的是**最早**那几条，所以只要真裁过，「更早的还在」就必然成立——哪怕
+  // 宿主那一页说的 `hasMore: false`（上翻取到这条会话最早那一页时正是如此）。
+  // 不在这里改这个字段，页面会照着 false 把上翻开关关掉，被裁掉的几条就再也
+  // 翻不回来了；页大小因此只能是「大概几条」，**条数永远不是终止判据**。
+  const rest = droppedEarlier ? { ...page.rest, hasMore: true } : page.rest;
   return {
     id: replyId,
     method: "result",
     params: {
       result: {
-        ...page.rest,
+        ...rest,
         messages: page.messages.slice(-count),
       },
     },

package/src/remote/remoteNotifications.ts

@@ -28,6 +28,7 @@ import type {
   ToolBlockUpdateCallbackParams,
   ToolPermissionContext,
 } from "wave-agent-sdk";
+import { getAutoCompactThreshold } from "wave-agent-sdk";
 import { toolBlockUpdateForUi } from "../stdio/uiPayload.js";
 
 /**
@@ -45,9 +46,25 @@ type StreamDelta = Parameters<
  * push and its `getSessionInfo` read). 0 when the cap is unknown, so a caller
  * that has one reads a number rather than a special case.
  */
-export function percentOf(tokens: number, maxInputTokens: number): number {
-  if (!maxInputTokens || maxInputTokens <= 0) return 0;
-  return Math.min(100, Math.round((tokens / maxInputTokens) * 100));
+export function percentOf(
+  tokens: number,
+  contextWindow: number,
+  maxOutputTokens = 32_000,
+): number {
+  if (!Number.isFinite(contextWindow) || contextWindow <= 0) return 0;
+  const calculatedThreshold = getAutoCompactThreshold(
+    contextWindow,
+    Number.isFinite(maxOutputTokens) && maxOutputTokens > 0
+      ? maxOutputTokens
+      : 32_000,
+  );
+  // Some host tests auto-mock the SDK barrel wholesale. Keep the wire helper
+  // usable in that environment without changing production's shared formula.
+  const threshold =
+    Number.isFinite(calculatedThreshold) && calculatedThreshold > 0
+      ? calculatedThreshold
+      : contextWindow;
+  return Math.min(100, Math.round((tokens / threshold) * 100));
 }
 
 /** The shapes both hosts put on the wire, keyed by the method they ride under. */
@@ -95,8 +112,12 @@ export const remoteWire = {
     ...(latestTotalTokens === undefined ? {} : { latestTotalTokens }),
   }),
 
-  contextUsage: (latestTotalTokens: number, maxInputTokens: number) => ({
-    percent: percentOf(latestTotalTokens, maxInputTokens),
+  contextUsage: (
+    latestTotalTokens: number,
+    contextWindow: number,
+    maxOutputTokens = 32_000,
+  ) => ({
+    percent: percentOf(latestTotalTokens, contextWindow, maxOutputTokens),
   }),
 
   permissionModeChange: (mode: PermissionMode) => ({ mode }),