wave-code 0.19.8 → 1.0.0

package/dist/stdio/agentBridge.js

@@ -14,9 +14,12 @@
  * - Implement the canUseTool permission flow over the stdio protocol
  * - Handle config updates by destroying and recreating the Agent
  */
-import { Agent, listSessions, searchFiles, PromptHistoryManager, AuthService, PluginCore, } from "wave-agent-sdk";
+import { Agent, listSessions, searchFiles, generateRandomName, getDefaultRemoteBranch, getMessageContent, PromptHistoryManager, AuthService, PluginCore, validateWorktreeRemovalPath, } from "wave-agent-sdk";
 import { INTERNAL_ERROR as PROTOCOL_INTERNAL_ERROR, METHOD_NOT_FOUND as PROTOCOL_METHOD_NOT_FOUND, } from "./protocol.js";
+import { execFileSync } from "node:child_process";
+import { createWorktree, removeWorktree } from "../utils/worktree.js";
 import { logger } from "../utils/logger.js";
+import { isUserCheckpointMessage } from "../utils/rewindCheckpoints.js";
 export class AgentBridge {
     constructor(options) {
         this.sessions = new Map();
@@ -52,6 +55,8 @@ export class AgentBridge {
                 return this.clearMessages(sessionId);
             case "rewindToMessage":
                 return this.rewindToMessage(p.messageId, sessionId);
+            case "listRewindCheckpoints":
+                return this.listRewindCheckpoints(sessionId);
             case "deleteQueuedMessage":
                 return this.deleteQueuedMessage(p.index, sessionId);
             case "updateQueuedMessage":
@@ -102,6 +107,10 @@ export class AgentBridge {
                 return this.enablePlugin(p.pluginId, p.scope, p.workdir, sessionId);
             case "disablePlugin":
                 return this.disablePlugin(p.pluginId, p.scope, p.workdir, sessionId);
+            case "getProjectSettings":
+                return this.getProjectSettings(p.workdir, sessionId);
+            case "setBuiltinPluginEnabled":
+                return this.setBuiltinPluginEnabled(p.pluginId, p.enabled, p.scope, p.workdir, sessionId);
             case "updatePlugin":
                 return this.updatePlugin(p.pluginId, p.workdir, sessionId);
             case "listMarketplaces":
@@ -123,6 +132,13 @@ export class AgentBridge {
                 return this.getWorkflowRuns(sessionId);
             case "stopWorkflowRun":
                 return this.stopWorkflowRun(p.runId, sessionId);
+            // ── Git / worktree (global — no session required) ──
+            case "listGitBranches":
+                return this.listGitBranches(p.workdir);
+            case "createWorktree":
+                return this.createWorktreeSession(p);
+            case "removeWorktree":
+                return this.removeWorktreeSession(p);
             default:
                 throw new RpcError(PROTOCOL_METHOD_NOT_FOUND, `Method not found: ${method}`);
         }
@@ -159,6 +175,8 @@ export class AgentBridge {
             disallowedTools: params.disallowedTools,
             plugins: params.pluginDirs?.map((path) => ({ type: "local", path })),
             mcpServers: params.mcpServers,
+            worktreeName: params.worktreeName,
+            isNewWorktree: params.isNewWorktree,
             canUseTool: (context) => this.canUseTool(context, ctx),
         };
         const agent = await Agent.create(options);
@@ -194,6 +212,98 @@ export class AgentBridge {
         const sessions = await listSessions(workdir || this.getSessionWorkdir(sessionId) || process.cwd());
         return { sessions };
     }
+    // ── Git / worktree ────────────────────────────────────────────
+    listGitBranches(workdir) {
+        if (!workdir) {
+            throw new RpcError(PROTOCOL_INTERNAL_ERROR, "workdir is required");
+        }
+        const gitOpts = {
+            cwd: workdir,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        };
+        let branchesRaw;
+        try {
+            branchesRaw = execFileSync("git", ["for-each-ref", "--format=%(refname:short)", "refs/heads"], gitOpts).trim();
+        }
+        catch {
+            throw new RpcError(PROTOCOL_INTERNAL_ERROR, `Not a git repository (or git unavailable): ${workdir}`);
+        }
+        const branches = branchesRaw
+            ? branchesRaw
+                .split("\n")
+                .map((b) => b.trim())
+                .filter(Boolean)
+            : [];
+        let current = null;
+        try {
+            const head = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], gitOpts).trim();
+            // Detached HEAD prints "HEAD" — treat as no current branch.
+            current = head && head !== "HEAD" ? head : null;
+        }
+        catch {
+            current = null;
+        }
+        return { branches, current };
+    }
+    async createWorktreeSession(params) {
+        if (!params.workdir) {
+            throw new RpcError(PROTOCOL_INTERNAL_ERROR, "workdir is required");
+        }
+        const name = params.name?.trim() || generateRandomName();
+        try {
+            const session = await createWorktree(name, params.workdir, {
+                baseBranch: params.baseBranch,
+            });
+            return {
+                name: session.name,
+                path: session.path,
+                branch: session.branch,
+                repoRoot: session.repoRoot,
+                baseBranch: params.baseBranch ?? getDefaultRemoteBranch(params.workdir),
+                isNew: session.isNew,
+            };
+        }
+        catch (e) {
+            throw new RpcError(PROTOCOL_INTERNAL_ERROR, e.message);
+        }
+    }
+    async removeWorktreeSession(params) {
+        // Align with Claude Code v2.1.216+: refuse to remove a worktree whose path
+        // is a symlink or resolves outside the repo root. Already-removed (missing)
+        // paths pass validation so removal stays idempotent.
+        try {
+            validateWorktreeRemovalPath(params.path, params.repoRoot);
+        }
+        catch (e) {
+            throw new RpcError(PROTOCOL_INTERNAL_ERROR, e.message);
+        }
+        // Trigger the WorktreeRemove hook (before git removal, non-blocking) using
+        // the session that runs in this worktree, if it is still registered.
+        for (const entry of this.sessions.values()) {
+            if (entry.agent.workingDirectory === params.path) {
+                try {
+                    await entry.agent.triggerWorktreeRemoveHook(params.path);
+                }
+                catch (e) {
+                    logger.warn("WorktreeRemove hooks execution failed:", e);
+                }
+                break;
+            }
+        }
+        // removeWorktree is best-effort/idempotent: already-removed worktrees or
+        // branches only log, never throw.
+        await removeWorktree({
+            name: "",
+            path: params.path,
+            branch: params.branch,
+            repoRoot: params.repoRoot,
+            hasUncommittedChanges: false,
+            hasNewCommits: false,
+            isNew: false,
+        });
+        return { ok: true };
+    }
     getSessionInfo(sessionId) {
         const entry = this.requireSession(sessionId);
         return {
@@ -233,6 +343,9 @@ export class AgentBridge {
                 path: p,
             })),
             mcpServers: entry.storedConfig.mcpServers,
+            // Keep worktree context (permission safety) across recreation, but never
+            // re-fire WorktreeCreate — the hook ran at initial creation.
+            worktreeName: entry.storedConfig.worktreeName,
             canUseTool: (context) => this.canUseTool(context, ctx),
         };
         const agent = await Agent.create(options);
@@ -287,6 +400,17 @@ export class AgentBridge {
         await entry.agent.truncateHistory(index);
         return { inputContent: textBlock?.content || "" };
     }
+    async listRewindCheckpoints(sessionId) {
+        const entry = this.requireSession(sessionId);
+        const { messages } = await entry.agent.getFullMessageThread();
+        const checkpoints = messages
+            .filter((m) => isUserCheckpointMessage(m) && m.id)
+            .map((m) => ({
+            id: m.id,
+            content: getMessageContent(m).replace(/\s+/g, " ").trim(),
+        }));
+        return { checkpoints };
+    }
     deleteQueuedMessage(index, sessionId) {
         const entry = this.requireSession(sessionId);
         entry.agent.removeQueuedMessage(index);
@@ -467,6 +591,22 @@ export class AgentBridge {
     async disablePlugin(pluginId, scope, workdir, sessionId) {
         return this.getPluginCore(workdir, sessionId).disablePlugin(pluginId, scope);
     }
+    async getProjectSettings(workdir, sessionId) {
+        return {
+            enabledPlugins: this.getPluginCore(workdir, sessionId).getMergedEnabledPlugins(),
+        };
+    }
+    async setBuiltinPluginEnabled(pluginId, enabled, scope, workdir, sessionId) {
+        const core = this.getPluginCore(workdir, sessionId);
+        const targetScope = scope ?? "project";
+        if (enabled) {
+            await core.enablePlugin(pluginId, targetScope);
+        }
+        else {
+            await core.disablePlugin(pluginId, targetScope);
+        }
+        return { enabledPlugins: core.getMergedEnabledPlugins() };
+    }
     async updatePlugin(pluginId, workdir, sessionId) {
         return this.getPluginCore(workdir, sessionId).updatePlugin(pluginId);
     }

package/dist/stdio/protocol.d.ts

@@ -34,7 +34,7 @@ export declare const INVALID_REQUEST = -32600;
 export declare const METHOD_NOT_FOUND = -32601;
 export declare const INVALID_PARAMS = -32602;
 export declare const INTERNAL_ERROR = -32603;
-export type RequestMethod = "initialize" | "destroy" | "restoreSession" | "listSessions" | "getSessionInfo" | "sendMessage" | "bang" | "abortMessage" | "clearMessages" | "rewindToMessage" | "deleteQueuedMessage" | "updateQueuedMessage" | "deleteQueuedMessageById" | "getMessages" | "getFullMessageThread" | "setPermissionMode" | "getPermissionMode" | "getMcpServers" | "connectMcpServer" | "disconnectMcpServer" | "getSlashCommands" | "searchFiles" | "getPromptHistory" | "searchPromptHistory" | "updateConfig" | "getAuthStatus" | "login" | "logout" | "listPlugins" | "installPlugin" | "uninstallPlugin" | "enablePlugin" | "disablePlugin" | "updatePlugin" | "listMarketplaces" | "addMarketplace" | "removeMarketplace" | "updateMarketplace" | "compact" | "getBackgroundTaskOutput" | "stopBackgroundTask" | "getWorkflowRuns" | "stopWorkflowRun";
+export type RequestMethod = "initialize" | "destroy" | "restoreSession" | "listSessions" | "getSessionInfo" | "sendMessage" | "bang" | "abortMessage" | "clearMessages" | "rewindToMessage" | "listRewindCheckpoints" | "deleteQueuedMessage" | "updateQueuedMessage" | "deleteQueuedMessageById" | "getMessages" | "getFullMessageThread" | "setPermissionMode" | "getPermissionMode" | "getMcpServers" | "connectMcpServer" | "disconnectMcpServer" | "getSlashCommands" | "searchFiles" | "getPromptHistory" | "searchPromptHistory" | "updateConfig" | "getAuthStatus" | "login" | "logout" | "listPlugins" | "installPlugin" | "uninstallPlugin" | "enablePlugin" | "disablePlugin" | "updatePlugin" | "listMarketplaces" | "addMarketplace" | "removeMarketplace" | "updateMarketplace" | "compact" | "getBackgroundTaskOutput" | "stopBackgroundTask" | "getWorkflowRuns" | "stopWorkflowRun" | "listGitBranches" | "createWorktree" | "removeWorktree";
 export type ClientNotificationMethod = "permissionResponse";
 export type ServerNotificationMethod = "messagesChange" | "userMessageAdded" | "assistantMessageAdded" | "assistantContentUpdated" | "assistantReasoningUpdated" | "toolBlockUpdated" | "errorBlockAdded" | "loadingChange" | "commandRunningChange" | "queuedMessagesChange" | "tasksChange" | "sessionIdChange" | "permissionModeChange" | "mcpServersChange" | "workdirChange" | "bangMessageAdded" | "bangMessageUpdated" | "bangMessageCompleted" | "notificationMessageAdded" | "permissionRequest" | "authUrl" | "compactBlockAdded" | "compactionStateChange" | "backgroundTasksChange";
 export declare function isRequest(msg: unknown): msg is JsonRpcRequest;

package/dist/utils/rewindCheckpoints.d.ts

@@ -0,0 +1,8 @@
+import type { Message } from "wave-agent-sdk";
+/**
+ * 判断一条 user 消息能否作为 /rewind 检查点。
+ * 后台任务通知（task_notification）与 hook 注入的消息（source: "hook"）
+ * 都是系统生成、用户不可见的，不能作为回滚点。
+ * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
+ */
+export declare function isUserCheckpointMessage(m: Message): boolean;

package/dist/utils/rewindCheckpoints.js

@@ -0,0 +1,15 @@
+/**
+ * 判断一条 user 消息能否作为 /rewind 检查点。
+ * 后台任务通知（task_notification）与 hook 注入的消息（source: "hook"）
+ * 都是系统生成、用户不可见的，不能作为回滚点。
+ * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
+ */
+export function isUserCheckpointMessage(m) {
+    if (m.role !== "user" || m.isMeta)
+        return false;
+    if (m.blocks.some((b) => b.type === "task_notification"))
+        return false;
+    if (m.blocks.some((b) => b.type === "text" && b.source === "hook"))
+        return false;
+    return true;
+}

package/dist/utils/worktree.d.ts

@@ -7,19 +7,29 @@ export interface WorktreeSession {
     hasNewCommits: boolean;
     isNew: boolean;
 }
+/**
+ * Validate a worktree name before any side effects. Names are slash-separated
+ * slugs: every segment must be non-empty and contain only letters, digits,
+ * dots, underscores, and dashes. The total length is capped at 64 characters
+ * and "." / ".." segments are rejected (path traversal protection).
+ * @throws {Error} When the name is not a valid slug
+ */
+export declare function validateWorktreeSlug(name: string): void;
 /**
  * Create a new git worktree
  * @param name Worktree name
  * @param cwd Current working directory
  * @param options Optional creation options
  * @param options.baseRef "fresh" (default, origin/<default-branch>) | "head" (local HEAD)
+ * @param options.baseBranch Explicit base branch (overrides baseRef)
  * @returns Worktree session details
  */
 export declare function createWorktree(name: string, cwd: string, options?: {
     baseRef?: "fresh" | "head";
-}): WorktreeSession;
+    baseBranch?: string;
+}): Promise<WorktreeSession>;
 /**
  * Remove a git worktree and its associated branch
  * @param session Worktree session details
  */
-export declare function removeWorktree(session: WorktreeSession): void;
+export declare function removeWorktree(session: WorktreeSession): Promise<void>;

package/dist/utils/worktree.js

@@ -1,21 +1,58 @@
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { getDefaultRemoteBranch, getGitMainRepoRoot } from "wave-agent-sdk";
+import { getDefaultRemoteBranch, getGitMainRepoRoot, performPostCreationSetup, } from "wave-agent-sdk";
+// Never use execFileSync here: the shared `wave --stdio` process handles all
+// desktop sessions, so a synchronous git call (especially a multi-second
+// recursive worktree delete or a network fetch) freezes every session.
+const execFileAsync = promisify(execFile);
+// --- Worktree name validation ------------------------------------------------
+const VALID_WORKTREE_SLUG_SEGMENT = /^[a-zA-Z0-9._-]+$/;
+const MAX_WORKTREE_SLUG_LENGTH = 64;
+/**
+ * Validate a worktree name before any side effects. Names are slash-separated
+ * slugs: every segment must be non-empty and contain only letters, digits,
+ * dots, underscores, and dashes. The total length is capped at 64 characters
+ * and "." / ".." segments are rejected (path traversal protection).
+ * @throws {Error} When the name is not a valid slug
+ */
+export function validateWorktreeSlug(name) {
+    if (name.length > MAX_WORKTREE_SLUG_LENGTH) {
+        throw new Error(`Invalid worktree name: "${name}" must be ${MAX_WORKTREE_SLUG_LENGTH} characters or fewer (got ${name.length})`);
+    }
+    for (const segment of name.split("/")) {
+        if (segment === "." || segment === "..") {
+            throw new Error(`Invalid worktree name: "${name}" must not contain "." or ".." path segments`);
+        }
+        if (segment.length === 0 || !VALID_WORKTREE_SLUG_SEGMENT.test(segment)) {
+            throw new Error(`Invalid worktree name: "${name}" each "/"-separated segment must be non-empty and contain only letters, digits, dots, underscores, and dashes`);
+        }
+    }
+}
 /**
  * Create a new git worktree
  * @param name Worktree name
  * @param cwd Current working directory
  * @param options Optional creation options
  * @param options.baseRef "fresh" (default, origin/<default-branch>) | "head" (local HEAD)
+ * @param options.baseBranch Explicit base branch (overrides baseRef)
  * @returns Worktree session details
  */
-export function createWorktree(name, cwd, options) {
+export async function createWorktree(name, cwd, options) {
+    validateWorktreeSlug(name);
+    const session = await createWorktreeInternal(name, cwd, options);
+    if (session.isNew) {
+        await performPostCreationSetup(session.path, session.repoRoot);
+    }
+    return session;
+}
+async function createWorktreeInternal(name, cwd, options) {
     const repoRoot = getGitMainRepoRoot(cwd);
     const worktreePath = path.join(repoRoot, ".wave", "worktrees", name);
     const branchName = `worktree-${name}`;
     const useHead = options?.baseRef === "head";
-    const baseBranch = useHead ? "HEAD" : getDefaultRemoteBranch(cwd);
+    const resolvedBaseBranch = options?.baseBranch ?? (useHead ? "HEAD" : getDefaultRemoteBranch(cwd));
     // Ensure parent directory exists
     const parentDir = path.dirname(worktreePath);
     if (!fs.existsSync(parentDir)) {
@@ -36,9 +73,8 @@ export function createWorktree(name, cwd, options) {
     }
     try {
         // Create worktree and branch
-        execFileSync("git", ["worktree", "add", "-b", branchName, worktreePath, baseBranch], {
+        await execFileAsync("git", ["worktree", "add", "-b", branchName, worktreePath, resolvedBaseBranch], {
             cwd: repoRoot,
-            stdio: ["ignore", "pipe", "pipe"],
         });
         return {
             name,
@@ -55,9 +91,8 @@ export function createWorktree(name, cwd, options) {
         if (stderr.includes("already exists")) {
             // If branch already exists, try to add worktree without -b
             try {
-                execFileSync("git", ["worktree", "add", worktreePath, branchName], {
+                await execFileAsync("git", ["worktree", "add", worktreePath, branchName], {
                     cwd: repoRoot,
-                    stdio: ["ignore", "pipe", "pipe"],
                 });
                 return {
                     name,
@@ -77,15 +112,20 @@ export function createWorktree(name, cwd, options) {
             (stderr.includes("not a valid object name") ||
                 stderr.includes("unknown revision"))) {
             // Base branch not fetched yet — try fetching then retrying
-            const branchNameOnly = baseBranch.split("/").pop();
+            const branchNameOnly = resolvedBaseBranch.split("/").pop();
             try {
-                execFileSync("git", ["fetch", "origin", branchNameOnly], {
+                await execFileAsync("git", ["fetch", "origin", branchNameOnly], {
                     cwd: repoRoot,
-                    stdio: ["ignore", "pipe", "pipe"],
                 });
-                execFileSync("git", ["worktree", "add", "-b", branchName, worktreePath, baseBranch], {
+                await execFileAsync("git", [
+                    "worktree",
+                    "add",
+                    "-b",
+                    branchName,
+                    worktreePath,
+                    resolvedBaseBranch,
+                ], {
                     cwd: repoRoot,
-                    stdio: ["ignore", "pipe", "pipe"],
                 });
                 return {
                     name,
@@ -100,9 +140,8 @@ export function createWorktree(name, cwd, options) {
             catch {
                 // Fetch or retry failed — fall back to HEAD
                 try {
-                    execFileSync("git", ["worktree", "add", "-b", branchName, worktreePath, "HEAD"], {
+                    await execFileAsync("git", ["worktree", "add", "-b", branchName, worktreePath, "HEAD"], {
                         cwd: repoRoot,
-                        stdio: ["ignore", "pipe", "pipe"],
                     });
                     return {
                         name,
@@ -126,31 +165,29 @@ export function createWorktree(name, cwd, options) {
  * Remove a git worktree and its associated branch
  * @param session Worktree session details
  */
-export function removeWorktree(session) {
+export async function removeWorktree(session) {
     const repoRoot = session.repoRoot;
     try {
         // Get current branch in worktree before removing it
         let currentBranch;
         try {
-            currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+            const { stdout } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
                 cwd: session.path,
                 encoding: "utf8",
-                stdio: ["ignore", "pipe", "ignore"],
-            }).trim();
+            });
+            currentBranch = stdout.trim();
         }
         catch {
             // Ignore errors getting current branch
         }
         // Remove worktree
-        execFileSync("git", ["worktree", "remove", "--force", session.path], {
+        await execFileAsync("git", ["worktree", "remove", "--force", session.path], {
             cwd: repoRoot,
-            stdio: ["ignore", "pipe", "pipe"],
         });
         // Delete original branch
         try {
-            execFileSync("git", ["branch", "-D", session.branch], {
+            await execFileAsync("git", ["branch", "-D", session.branch], {
                 cwd: repoRoot,
-                stdio: ["ignore", "pipe", "pipe"],
             });
         }
         catch {
@@ -166,9 +203,8 @@ export function removeWorktree(session) {
                 currentBranch !== "main" &&
                 currentBranch !== "master") {
                 try {
-                    execFileSync("git", ["branch", "-D", currentBranch], {
+                    await execFileAsync("git", ["branch", "-D", currentBranch], {
                         cwd: repoRoot,
-                        stdio: ["ignore", "pipe", "pipe"],
                     });
                 }
                 catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "0.19.8",
+  "version": "1.0.0",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -41,7 +41,7 @@
     "semver": "^7.7.4",
     "yargs": "^17.7.2",
     "zod": "^3.23.8",
-    "wave-agent-sdk": "0.19.8"
+    "wave-agent-sdk": "1.0.0"
   },
   "devDependencies": {
     "@types/react": "^19.1.8",

package/src/cli.tsx

@@ -70,7 +70,7 @@ export async function startCli(options: CliOptions): Promise<void> {
     // Cleanup worktree if requested
     if (shouldRemoveWorktree && worktreeSession) {
       process.chdir(worktreeSession.repoRoot);
-      removeWorktree(worktreeSession);
+      await removeWorktree(worktreeSession);
     }
 
     process.exit(0);

package/src/components/ChatInterface.tsx

@@ -100,6 +100,8 @@ export const ChatInterface: React.FC = () => {
           <InputBox
             isLoading={isLoading}
             isCommandRunning={isCommandRunning}
+            isCompacting={isCompacting}
+            isGoalEvaluating={isGoalEvaluating}
             sendMessage={sendMessage}
             abortMessage={abortMessage}
             mcpServers={mcpServers}

package/src/components/HelpView.tsx

@@ -74,11 +74,17 @@ export const HelpView: React.FC<HelpViewProps> = ({
     { key: "Ctrl+B", description: "Background current task" },
     { key: "Ctrl+V", description: "Paste image" },
     { key: "Ctrl+J", description: "Newline" },
+    { key: "Ctrl+A", description: "Cursor to line start" },
+    { key: "Ctrl+E", description: "Cursor to line end" },
+    { key: "Ctrl+U", description: "Delete to line start" },
+    { key: "Ctrl+K", description: "Delete to line end" },
+    { key: "Ctrl+W", description: "Delete word before cursor" },
     { key: "Shift+Tab", description: "Cycle permission mode" },
     {
       key: "Esc",
       description: "Interrupt AI or command / Cancel selector / Close help",
     },
+    { key: "Esc ×2", description: "Clear input (idle)" },
   ];
 
   const footerText = [

package/src/components/InputBox.tsx

@@ -31,6 +31,8 @@ export const INPUT_PLACEHOLDER_TEXT_PREFIX = INPUT_PLACEHOLDER_TEXT.substring(
 export interface InputBoxProps {
   isLoading?: boolean;
   isCommandRunning?: boolean;
+  isCompacting?: boolean;
+  isGoalEvaluating?: boolean;
   workdir?: string;
   sendMessage?: (
     message: string,
@@ -54,6 +56,10 @@ export interface InputBoxProps {
 }
 
 export const InputBox: React.FC<InputBoxProps> = ({
+  isLoading,
+  isCommandRunning,
+  isCompacting,
+  isGoalEvaluating,
   sendMessage = () => {},
   abortMessage = () => {},
   mcpServers = [],
@@ -92,6 +98,15 @@ export const InputBox: React.FC<InputBoxProps> = ({
 
   const hasQueuedMessages = (queuedMessages?.length ?? 0) > 0;
 
+  // Idle means no AI work in flight. Esc double-press clear only applies when
+  // idle; while busy, Esc keeps its abort semantics.
+  const isIdle = !(
+    isLoading ||
+    isCommandRunning ||
+    isCompacting ||
+    isGoalEvaluating
+  );
+
   const onRecallQueuedMessage = useCallback(() => {
     const msg = recallQueuedMessage();
     if (msg) {
@@ -146,6 +161,8 @@ export const InputBox: React.FC<InputBoxProps> = ({
     setPermissionMode,
     // BTW state
     btwState,
+    // Esc double-press clear pending
+    escClearPending,
     // Main handler
     handleInput,
     // Manager ready state
@@ -166,6 +183,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
     workdir: workingDirectory,
     getFullMessageThread,
     hasQueuedMessages,
+    isIdle,
     onRecallQueuedMessage,
   });
 
@@ -342,6 +360,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
           showPluginManager ||
           showWorkflowManager || (
             <Box flexDirection="column">
+              {escClearPending && <Text color="gray">再次按 Esc 清空输入</Text>}
               <Box
                 borderStyle="single"
                 borderColor="gray"

package/src/components/RewindCommand.tsx

@@ -3,6 +3,7 @@ import { Box, Text, useInput } from "ink";
 import type { Message } from "wave-agent-sdk";
 import { getMessageContent } from "wave-agent-sdk";
 import { rewindSelectorReducer } from "../reducers/rewindSelectorReducer.js";
+import { isUserCheckpointMessage } from "../utils/rewindCheckpoints.js";
 
 export interface RewindCommandProps {
   messages: Message[];
@@ -32,10 +33,11 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
     }
   }, [getFullMessageThread]);
 
-  // Filter user messages as checkpoints, excluding meta messages
+  // Filter user messages as checkpoints, excluding meta messages and
+  // system-generated user-role messages (task notifications, hook injections)
   const checkpoints = messages
     .map((msg, index) => ({ msg, index }))
-    .filter(({ msg }) => msg.role === "user" && !msg.isMeta);
+    .filter(({ msg }) => isUserCheckpointMessage(msg));
 
   const MAX_VISIBLE_ITEMS = 3;
 

package/src/components/TaskList.tsx

@@ -99,12 +99,9 @@ export const TaskList: React.FC = () => {
   const autoHideTimerRef = React.useRef<ReturnType<typeof setTimeout> | null>(
     null,
   );
-  const [autoHidden, setAutoHidden] = React.useState(() => {
-    // If all tasks are already completed on mount (e.g. session restore),
-    // start hidden immediately instead of flashing for 5 seconds.
-    const active = tasks.filter((t) => t.status !== "deleted");
-    return active.length > 0 && active.every((t) => t.status === "completed");
-  });
+  const [autoHidden, setAutoHidden] = React.useState(false);
+  // 是否在当前展示期间观察到过未完成任务；用于区分“任务在眼前完成”与“加载时已全部完成”
+  const hadIncompleteRef = React.useRef(false);
   const [, forceUpdate] = React.useState(0);
 
   const now = Date.now();
@@ -155,24 +152,45 @@ export const TaskList: React.FC = () => {
     activeTasks.length > 0 &&
     activeTasks.every((t) => t.status === "completed");
 
+  // 观察到任务从“存在未完成”变为“全部完成”时保留 5 秒再隐藏；
+  // 加载或恢复到已全部完成的会话时立即隐藏，避免先闪现再消失
   React.useEffect(() => {
-    if (allCompleted && !autoHidden) {
+    if (activeTasks.length === 0) {
+      hadIncompleteRef.current = false;
+      return;
+    }
+    if (!allCompleted) {
+      hadIncompleteRef.current = true;
+      if (autoHidden) {
+        setAutoHidden(false);
+      }
+      return;
+    }
+    if (!hadIncompleteRef.current) {
+      if (!autoHidden) {
+        setAutoHidden(true);
+      }
+      return;
+    }
+    if (!autoHidden) {
       autoHideTimerRef.current = setTimeout(() => {
         setAutoHidden(true);
       }, AUTO_HIDE_DELAY_MS);
     }
-    if (!allCompleted && autoHidden) {
-      setAutoHidden(false);
-    }
     return () => {
       if (autoHideTimerRef.current) {
         clearTimeout(autoHideTimerRef.current);
         autoHideTimerRef.current = null;
       }
     };
-  }, [allCompleted, autoHidden]);
+  }, [allCompleted, autoHidden, activeTasks.length]);
 
-  if (tasks.length === 0 || !isTaskListVisible || autoHidden) {
+  if (
+    tasks.length === 0 ||
+    !isTaskListVisible ||
+    autoHidden ||
+    (allCompleted && !hadIncompleteRef.current)
+  ) {
     return null;
   }