wave-code 0.19.8 → 0.19.9

package/dist/cli.js

@@ -23,7 +23,7 @@ export async function startCli(options) {
         // Cleanup worktree if requested
         if (shouldRemoveWorktree && worktreeSession) {
             process.chdir(worktreeSession.repoRoot);
-            removeWorktree(worktreeSession);
+            await removeWorktree(worktreeSession);
         }
         process.exit(0);
     }

package/dist/components/TaskList.js

@@ -80,12 +80,9 @@ export const TaskList = () => {
     const completionTimestampsRef = React.useRef(new Map());
     const previousCompletedIdsRef = React.useRef(null);
     const autoHideTimerRef = React.useRef(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();
     const activeTasks = tasks.filter((t) => t.status !== "deleted");
@@ -125,23 +122,42 @@ export const TaskList = () => {
     // Auto-hide logic: when all active tasks are completed
     const allCompleted = 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]);
-    if (tasks.length === 0 || !isTaskListVisible || autoHidden) {
+    }, [allCompleted, autoHidden, activeTasks.length]);
+    if (tasks.length === 0 ||
+        !isTaskListVisible ||
+        autoHidden ||
+        (allCompleted && !hadIncompleteRef.current)) {
         return null;
     }
     const displayLimit = getDisplayLimit(stdout?.rows);

package/dist/index.js

@@ -237,7 +237,7 @@ export async function main() {
                 name = generateRandomName();
             }
             const baseRef = loadMergedWaveConfig(originalCwd)?.worktree?.baseRef;
-            worktreeSession = createWorktree(name, originalCwd, { baseRef });
+            worktreeSession = await createWorktree(name, originalCwd, { baseRef });
             // Note: the full worktree session (originalCwd etc.) is injected into the
             // agent's DI container after the agent is created in useChat.tsx. This keeps
             // worktree state per-session instead of process-global.

package/dist/print-cli.js

@@ -138,7 +138,7 @@ export async function startPrintCli(options) {
             const hasChanges = hasUncommittedChanges(cwd);
             const hasCommits = hasNewCommits(cwd, baseBranch);
             if (!hasChanges && !hasCommits) {
-                removeWorktree(worktreeSession);
+                await removeWorktree(worktreeSession);
             }
             else {
                 process.stdout.write(`\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`);
@@ -170,7 +170,7 @@ export async function startPrintCli(options) {
                 const hasChanges = hasUncommittedChanges(cwd);
                 const hasCommits = hasNewCommits(cwd, baseBranch);
                 if (!hasChanges && !hasCommits) {
-                    removeWorktree(worktreeSession);
+                    await removeWorktree(worktreeSession);
                 }
                 else {
                     process.stdout.write(`\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`);

package/dist/stdio/agentBridge.d.ts

@@ -33,6 +33,9 @@ export declare class AgentBridge {
     private destroy;
     private restoreSession;
     private listSessions;
+    private listGitBranches;
+    private createWorktreeSession;
+    private removeWorktreeSession;
     private getSessionInfo;
     private updateConfig;
     private sendMessage;
@@ -40,6 +43,7 @@ export declare class AgentBridge {
     private abortMessage;
     private clearMessages;
     private rewindToMessage;
+    private listRewindCheckpoints;
     private deleteQueuedMessage;
     private updateQueuedMessage;
     private deleteQueuedMessageById;
@@ -69,6 +73,8 @@ export declare class AgentBridge {
     private uninstallPlugin;
     private enablePlugin;
     private disablePlugin;
+    private getProjectSettings;
+    private setBuiltinPluginEnabled;
     private updatePlugin;
     private listMarketplaces;
     private addMarketplace;

package/dist/stdio/agentBridge.js

@@ -14,8 +14,10 @@
  * - 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, } 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";
 export class AgentBridge {
     constructor(options) {
@@ -52,6 +54,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 +106,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 +131,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 +174,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 +211,76 @@ 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) {
+        // 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 +320,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 +377,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) => m.role === "user" && !m.isMeta && 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 +568,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/worktree.d.ts

@@ -13,13 +13,15 @@ export interface WorktreeSession {
  * @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,27 @@
-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";
+// 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);
 /**
  * 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) {
     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 +42,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 +60,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 +81,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 +109,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 +134,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 +172,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": "0.19.9",
   "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": "0.19.9"
   },
   "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/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;
   }
 

package/src/index.ts

@@ -326,7 +326,7 @@ export async function main() {
         name = generateRandomName();
       }
       const baseRef = loadMergedWaveConfig(originalCwd)?.worktree?.baseRef;
-      worktreeSession = createWorktree(name, originalCwd, { baseRef });
+      worktreeSession = await createWorktree(name, originalCwd, { baseRef });
 
       // Note: the full worktree session (originalCwd etc.) is injected into the
       // agent's DI container after the agent is created in useChat.tsx. This keeps

package/src/print-cli.ts

@@ -194,7 +194,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       const hasCommits = hasNewCommits(cwd, baseBranch);
 
       if (!hasChanges && !hasCommits) {
-        removeWorktree(worktreeSession);
+        await removeWorktree(worktreeSession);
       } else {
         process.stdout.write(
           `\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`,
@@ -230,7 +230,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
         const hasCommits = hasNewCommits(cwd, baseBranch);
 
         if (!hasChanges && !hasCommits) {
-          removeWorktree(worktreeSession);
+          await removeWorktree(worktreeSession);
         } else {
           process.stdout.write(
             `\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`,

package/src/stdio/agentBridge.ts

@@ -34,6 +34,9 @@ import {
   type Scope,
   listSessions,
   searchFiles,
+  generateRandomName,
+  getDefaultRemoteBranch,
+  getMessageContent,
   PromptHistoryManager,
   AuthService,
   PluginCore,
@@ -44,6 +47,8 @@ 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";
 
 export type NotificationEmitter = (
@@ -72,6 +77,8 @@ interface InitializeParams {
   disallowedTools?: string[];
   pluginDirs?: string[];
   mcpServers?: Record<string, McpServerConfig>;
+  worktreeName?: string;
+  isNewWorktree?: boolean;
 }
 
 interface UpdateConfigParams {
@@ -163,6 +170,8 @@ export class AgentBridge {
         return this.clearMessages(sessionId);
       case "rewindToMessage":
         return this.rewindToMessage(p.messageId as string, sessionId);
+      case "listRewindCheckpoints":
+        return this.listRewindCheckpoints(sessionId);
       case "deleteQueuedMessage":
         return this.deleteQueuedMessage(p.index as number, sessionId);
       case "updateQueuedMessage":
@@ -250,6 +259,19 @@ export class AgentBridge {
           p.workdir as string | undefined,
           sessionId,
         );
+      case "getProjectSettings":
+        return this.getProjectSettings(
+          p.workdir as string | undefined,
+          sessionId,
+        );
+      case "setBuiltinPluginEnabled":
+        return this.setBuiltinPluginEnabled(
+          p.pluginId as string,
+          p.enabled as boolean,
+          p.scope as Scope | undefined,
+          p.workdir as string | undefined,
+          sessionId,
+        );
       case "updatePlugin":
         return this.updatePlugin(
           p.pluginId as string,
@@ -298,6 +320,22 @@ export class AgentBridge {
       case "stopWorkflowRun":
         return this.stopWorkflowRun(p.runId as string, sessionId);
 
+      // ── Git / worktree (global — no session required) ──
+      case "listGitBranches":
+        return this.listGitBranches(p.workdir as string | undefined);
+      case "createWorktree":
+        return this.createWorktreeSession(
+          p as unknown as {
+            workdir: string;
+            baseBranch?: string;
+            name?: string;
+          },
+        );
+      case "removeWorktree":
+        return this.removeWorktreeSession(
+          p as unknown as { path: string; branch: string; repoRoot: string },
+        );
+
       default:
         throw new RpcError(
           PROTOCOL_METHOD_NOT_FOUND,
@@ -349,6 +387,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: ToolPermissionContext) =>
         this.canUseTool(context, ctx),
     };
@@ -400,6 +440,106 @@ export class AgentBridge {
     return { sessions };
   }
 
+  // ── Git / worktree ────────────────────────────────────────────
+
+  private listGitBranches(workdir?: string): {
+    branches: string[];
+    current: string | null;
+  } {
+    if (!workdir) {
+      throw new RpcError(PROTOCOL_INTERNAL_ERROR, "workdir is required");
+    }
+    const gitOpts = {
+      cwd: workdir,
+      encoding: "utf8" as const,
+      stdio: ["ignore", "pipe", "pipe"] as ["ignore", "pipe", "pipe"],
+    };
+    let branchesRaw: string;
+    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: string | null = 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 };
+  }
+
+  private async createWorktreeSession(params: {
+    workdir: string;
+    baseBranch?: string;
+    name?: string;
+  }): Promise<{
+    name: string;
+    path: string;
+    branch: string;
+    repoRoot: string;
+    baseBranch: string;
+    isNew: boolean;
+  }> {
+    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 as Error).message);
+    }
+  }
+
+  private async removeWorktreeSession(params: {
+    path: string;
+    branch: string;
+    repoRoot: string;
+  }): Promise<{ ok: true }> {
+    // 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 };
+  }
+
   private getSessionInfo(sessionId?: string): {
     sessionId: string;
     workingDirectory: string;
@@ -450,6 +590,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: ToolPermissionContext) =>
         this.canUseTool(context, ctx),
     };
@@ -535,6 +678,20 @@ export class AgentBridge {
     return { inputContent: textBlock?.content || "" };
   }
 
+  private async listRewindCheckpoints(sessionId?: string): Promise<{
+    checkpoints: Array<{ id: string; content: string }>;
+  }> {
+    const entry = this.requireSession(sessionId);
+    const { messages } = await entry.agent.getFullMessageThread();
+    const checkpoints = messages
+      .filter((m) => m.role === "user" && !m.isMeta && m.id)
+      .map((m) => ({
+        id: m.id as string,
+        content: getMessageContent(m).replace(/\s+/g, " ").trim(),
+      }));
+    return { checkpoints };
+  }
+
   private deleteQueuedMessage(index: number, sessionId?: string): null {
     const entry = this.requireSession(sessionId);
     entry.agent.removeQueuedMessage(index);
@@ -837,6 +994,35 @@ export class AgentBridge {
     );
   }
 
+  private async getProjectSettings(
+    workdir?: string,
+    sessionId?: string,
+  ): Promise<{ enabledPlugins: Record<string, boolean> }> {
+    return {
+      enabledPlugins: this.getPluginCore(
+        workdir,
+        sessionId,
+      ).getMergedEnabledPlugins(),
+    };
+  }
+
+  private async setBuiltinPluginEnabled(
+    pluginId: string,
+    enabled: boolean,
+    scope: Scope | undefined,
+    workdir?: string,
+    sessionId?: string,
+  ): Promise<{ enabledPlugins: Record<string, boolean> }> {
+    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() };
+  }
+
   private async updatePlugin(
     pluginId: string,
     workdir?: string,

package/src/stdio/protocol.ts

@@ -57,6 +57,7 @@ export type RequestMethod =
   | "abortMessage"
   | "clearMessages"
   | "rewindToMessage"
+  | "listRewindCheckpoints"
   | "deleteQueuedMessage"
   | "updateQueuedMessage"
   | "deleteQueuedMessageById"
@@ -91,7 +92,11 @@ export type RequestMethod =
   | "getBackgroundTaskOutput"
   | "stopBackgroundTask"
   | "getWorkflowRuns"
-  | "stopWorkflowRun";
+  | "stopWorkflowRun"
+  // Git / worktree (global — no session required)
+  | "listGitBranches"
+  | "createWorktree"
+  | "removeWorktree";
 
 // ── Client → Server notification methods ────────────────────────
 

package/src/utils/worktree.ts

@@ -1,8 +1,14 @@
-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";
 
+// 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);
+
 export interface WorktreeSession {
   name: string;
   path: string;
@@ -19,18 +25,20 @@ export interface WorktreeSession {
  * @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(
+export async function createWorktree(
   name: string,
   cwd: string,
-  options?: { baseRef?: "fresh" | "head" },
-): WorktreeSession {
+  options?: { baseRef?: "fresh" | "head"; baseBranch?: string },
+): Promise<WorktreeSession> {
   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);
@@ -54,12 +62,11 @@ export function createWorktree(
 
   try {
     // Create worktree and branch
-    execFileSync(
+    await execFileAsync(
       "git",
-      ["worktree", "add", "-b", branchName, worktreePath, baseBranch],
+      ["worktree", "add", "-b", branchName, worktreePath, resolvedBaseBranch],
       {
         cwd: repoRoot,
-        stdio: ["ignore", "pipe", "pipe"],
       },
     );
 
@@ -73,14 +80,18 @@ export function createWorktree(
       isNew: true,
     };
   } catch (error: unknown) {
-    const stderr = (error as { stderr?: Buffer }).stderr?.toString() || "";
+    const stderr =
+      (error as { stderr?: Buffer | string }).stderr?.toString() || "";
     if (stderr.includes("already exists")) {
       // If branch already exists, try to add worktree without -b
       try {
-        execFileSync("git", ["worktree", "add", worktreePath, branchName], {
-          cwd: repoRoot,
-          stdio: ["ignore", "pipe", "pipe"],
-        });
+        await execFileAsync(
+          "git",
+          ["worktree", "add", worktreePath, branchName],
+          {
+            cwd: repoRoot,
+          },
+        );
         return {
           name,
           path: worktreePath,
@@ -102,18 +113,23 @@ export function createWorktree(
         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(
+        await execFileAsync(
           "git",
-          ["worktree", "add", "-b", branchName, worktreePath, baseBranch],
+          [
+            "worktree",
+            "add",
+            "-b",
+            branchName,
+            worktreePath,
+            resolvedBaseBranch,
+          ],
           {
             cwd: repoRoot,
-            stdio: ["ignore", "pipe", "pipe"],
           },
         );
         return {
@@ -128,12 +144,11 @@ export function createWorktree(
       } catch {
         // Fetch or retry failed — fall back to HEAD
         try {
-          execFileSync(
+          await execFileAsync(
             "git",
             ["worktree", "add", "-b", branchName, worktreePath, "HEAD"],
             {
               cwd: repoRoot,
-              stdio: ["ignore", "pipe", "pipe"],
             },
           );
           return {
@@ -162,37 +177,39 @@ export function createWorktree(
  * Remove a git worktree and its associated branch
  * @param session Worktree session details
  */
-export function removeWorktree(session: WorktreeSession): void {
+export async function removeWorktree(session: WorktreeSession): Promise<void> {
   const repoRoot = session.repoRoot;
 
   try {
     // Get current branch in worktree before removing it
     let currentBranch: string | undefined;
     try {
-      currentBranch = execFileSync(
+      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], {
-      cwd: repoRoot,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
+    await execFileAsync(
+      "git",
+      ["worktree", "remove", "--force", session.path],
+      {
+        cwd: repoRoot,
+      },
+    );
 
     // Delete original branch
     try {
-      execFileSync("git", ["branch", "-D", session.branch], {
+      await execFileAsync("git", ["branch", "-D", session.branch], {
         cwd: repoRoot,
-        stdio: ["ignore", "pipe", "pipe"],
       });
     } catch {
       // Ignore errors deleting original branch
@@ -213,9 +230,8 @@ export function removeWorktree(session: WorktreeSession): void {
         currentBranch !== "master"
       ) {
         try {
-          execFileSync("git", ["branch", "-D", currentBranch], {
+          await execFileAsync("git", ["branch", "-D", currentBranch], {
             cwd: repoRoot,
-            stdio: ["ignore", "pipe", "pipe"],
           });
         } catch {
           // Ignore errors deleting current branch