wave-code 1.2.0 → 1.4.0

package/src/hooks/useRemoteControl.ts

@@ -0,0 +1,324 @@
+/**
+ * Wires the interactive CLI's own session to the remote-control relay.
+ *
+ * The daemon serves its sessions by fanning notifications into a
+ * `RemoteControlSink`; the CLI has no notification fan-out at all — every
+ * surface it has is React state. So this hook supplies that fan-out, under the
+ * same method names and payloads a `--stdio` / daemon process uses, which is what
+ * lets the page treat the two hosts identically — including the remote channel's
+ * 150 ms merge window, which only bites if the frames it merges are the same
+ * ones.
+ *
+ * Two halves, and both have to be the same shape as the bridge's:
+ *
+ * - the callbacks that carry content, which the front end hands over from its own
+ *   agent callbacks (`remoteNotifications` → `notify`);
+ * - the coarse state this hook watches itself (`messagesChange` as a content-free
+ *   structural signal, loading, permission mode, context usage, approvals). The
+ *   page answers a signal by pulling with `getMessages({ since })`, so no payload
+ *   ever rides the signal.
+ */
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import type {
+  BackgroundTask,
+  Message,
+  PermissionDecision,
+  PermissionMode,
+  QueuedMessage,
+  RemoteControlSnapshot,
+  RemoteControlStatus,
+  SlashCommand,
+  Task,
+  ToolPermissionContext,
+} from "wave-agent-sdk";
+import {
+  RemoteControlCliHost,
+  type RemoteControlCliSession,
+} from "../remote/remoteControlCliHost.js";
+import {
+  percentOf,
+  remoteWire,
+  toBackgroundTaskSummaries,
+} from "../remote/remoteNotifications.js";
+import type { RemoteNotify } from "../remote/remoteNotifications.js";
+import { createRemoteControlSinkFactory } from "../remote/remoteControlSink.js";
+import type { RemoteControlSink } from "../remote/remoteControlSink.js";
+
+export interface UseRemoteControlOptions {
+  workdir: string;
+  sessionId: string;
+  messages: Message[];
+  isLoading: boolean;
+  permissionMode: PermissionMode;
+  latestTotalTokens: number;
+  maxInputTokens: 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).
+   */
+  customTitle: () => string | undefined;
+  hasRunningBackgroundWork: boolean;
+  hasPendingMessages: boolean;
+  /**
+   * The session-state family the page re-reads off `getSessionInfo` (spec
+   * remote-control「Web 页作为第五种宿主」场景 26) — current values, so the
+   * long-lived host answers reads even though the session underneath it is
+   * replaced.
+   */
+  tasks: Task[];
+  /** Background tasks as the TUI holds them — read off `getSessionInfo`. */
+  backgroundTasks: BackgroundTask[];
+  isCompacting: boolean;
+  isCommandRunning: boolean;
+  queuedMessages: QueuedMessage[];
+  /** Approvals waiting on the user right now. */
+  pending: Array<{ requestId: string; context: ToolPermissionContext }>;
+  availableTools: () => string[];
+  sendMessage: (text: string, force?: boolean) => void | Promise<void>;
+  abort: () => void;
+  setPermissionMode: (mode: PermissionMode) => void;
+  respondPermission: (requestId: string, decision: PermissionDecision) => void;
+  /** Rename the conversation (the title `wave -r` lists). */
+  renameSession: (title: string) => void | Promise<void>;
+  /** Compact the conversation; errors must propagate (the page shows them). */
+  compact: (customInstructions?: string) => void | Promise<void>;
+  /** Slash commands the page may offer (SDK commands: skills / custom). */
+  slashCommands: () => SlashCommand[];
+}
+
+export interface RemoteControlApi {
+  /** The `enableRemoteControl` switch was on when this process started. */
+  enabled: boolean;
+  status: RemoteControlStatus;
+  getSnapshot: () => RemoteControlSnapshot;
+  /** Dials out. `name` labels this machine on the phone. */
+  connect: (name?: string) => void;
+  disconnect: () => void;
+  /**
+   * Send one notification to the phone under the method name a server host
+   * (`AgentBridge`) would use for the same thing. The front end calls it from its
+   * content-carrying agent callbacks (see `remoteNotifications`) — that is what
+   * makes the two hosts' fan-out identical, and therefore what makes the remote
+   * channel's merge window apply to this host too.
+   */
+  notify: RemoteNotify;
+}
+
+/** The GUI dialog polls once a second for the same reason: there is no push. */
+const STATUS_POLL_MS = 1000;
+
+export function useRemoteControl(
+  options: UseRemoteControlOptions,
+): RemoteControlApi {
+  // Every getter below must read the *current* value: the host outlives any
+  // single render, and the session underneath it is replaced on /resume.
+  const latest = useRef(options);
+  latest.current = options;
+
+  const [sink] = useState<RemoteControlSink | undefined>(() => {
+    // The switch is read once, here, exactly as a server process reads it once
+    // at startup — hence "restart the CLI" in the failure hint.
+    const factory = createRemoteControlSinkFactory(options.workdir);
+    if (!factory) return undefined;
+    return factory(new RemoteControlCliHost(adapterOf(latest)));
+  });
+
+  const [status, setStatus] = useState<RemoteControlStatus>(
+    () => sink?.getSnapshot() ?? { state: "off" },
+  );
+
+  // ── Outbound: state changes the phone renders ─────────────────
+  //
+  // `sendNotification` drops everything while the link is down, which is what
+  // we want: a phone that reconnects re-reads the tail anyway.
+  const sessionId = options.sessionId;
+  const { messages, isLoading, permissionMode, latestTotalTokens } = options;
+
+  const notify = useCallback<RemoteNotify>(
+    (method, params) => {
+      sink?.sendNotification(method, params, latest.current.sessionId);
+    },
+    [sink],
+  );
+
+  // A structural notice, never a payload: the phone answers it by pulling the
+  // tail with `getMessages({ since })`, the same path a cold start takes and the
+  // only one that can carry a 13 MB list. What counts as "structurally changed"
+  // is `useStructureKey`'s business below.
+  const structureKey = useStructureKey(messages, sink !== undefined);
+  useEffect(() => {
+    sink?.sendNotification(
+      "messagesChange",
+      remoteWire.messagesChangeSignal(),
+      sessionId,
+    );
+  }, [sink, structureKey, sessionId]);
+
+  useEffect(() => {
+    sink?.sendNotification(
+      "loadingChange",
+      remoteWire.loadingChange(isLoading),
+      sessionId,
+    );
+  }, [sink, isLoading, sessionId]);
+
+  useEffect(() => {
+    sink?.sendNotification(
+      "permissionModeChange",
+      remoteWire.permissionModeChange(permissionMode),
+      sessionId,
+    );
+  }, [sink, permissionMode, sessionId]);
+
+  useEffect(() => {
+    if (!sink || !sessionId) return;
+    sink.sendNotification(
+      "contextUsage",
+      remoteWire.contextUsage(latestTotalTokens, options.maxInputTokens),
+      sessionId,
+    );
+  }, [sink, sessionId, latestTotalTokens, options.maxInputTokens]);
+
+  // Approvals are announced once, when they appear. The page answers with
+  // `permissionResponse`, which the host routes back into the same promise the
+  // terminal is waiting on — first answer wins, as the spec requires.
+  const announced = useRef<Set<string>>(new Set());
+  useEffect(() => {
+    const pending = latest.current.pending;
+    if (!sink || pending.length === 0) return;
+    for (const request of pending) {
+      if (announced.current.has(request.requestId)) continue;
+      announced.current.add(request.requestId);
+      sink.sendNotification(
+        "permissionRequest",
+        remoteWire.permissionRequest(request.requestId, request.context),
+        sessionId,
+      );
+    }
+    const alive = new Set(pending.map((request) => request.requestId));
+    for (const id of [...announced.current]) {
+      if (!alive.has(id)) announced.current.delete(id);
+    }
+  }, [sink, options.pending, sessionId]);
+
+  // ── Status the command view renders ───────────────────────────
+
+  useEffect(() => {
+    if (!sink) return;
+    const timer = setInterval(() => {
+      setStatus(sink.getSnapshot());
+    }, STATUS_POLL_MS);
+    timer.unref?.();
+    return () => clearInterval(timer);
+  }, [sink]);
+
+  const connect = useCallback(
+    (name?: string) => {
+      sink?.connect(name);
+      setStatus(sink?.getSnapshot() ?? { state: "off" });
+    },
+    [sink],
+  );
+
+  const disconnect = useCallback(() => {
+    sink?.disconnect();
+    setStatus(sink?.getSnapshot() ?? { state: "off" });
+  }, [sink]);
+
+  const getSnapshot = useCallback(
+    () => sink?.getSnapshot() ?? { state: "off" as const },
+    [sink],
+  );
+
+  // The process is going away: drop the outbound connection rather than let
+  // the relay keep a subscription for a session that no longer exists.
+  useEffect(() => {
+    return () => {
+      sink?.stop();
+    };
+  }, [sink]);
+
+  return {
+    enabled: sink !== undefined,
+    status,
+    getSnapshot,
+    connect,
+    disconnect,
+    notify,
+  };
+}
+
+/**
+ * The id composition of the display list, in order — what "the list changed"
+ * means for the remote path — as a key that is stable while the composition is.
+ *
+ * Ids are stable across a streamed message's growth and across in-place edits of
+ * its blocks, so comparing this key is what separates a structural change (a
+ * message appeared, was discarded, or the list was truncated/replaced) from a
+ * delta landing in a message the phone already has. Anchored on the ids rather
+ * than on "the messages state changed" so no call site has to be trusted to
+ * remember to announce a structural change — watching `messages` instead is what
+ * turned every model chunk into a signal plus a phone round trip.
+ *
+ * This runs once per render, and a streamed reply renders once per chunk, so the
+ * two shortcuts are the point: with no sink there is nobody to signal, and an
+ * unchanged id list returns the previous key rather than building a new string.
+ *
+ * The trigger stops at the ids on purpose: `since` is an **exclusive** anchor, so
+ * a signal can only ever deliver entries appended after the phone's own last
+ * message — a change made *inside* that message needs a payload-carrying
+ * notification of its own (see `remoteNotifications`).
+ */
+function useStructureKey(messages: Message[], enabled: boolean): string {
+  const last = useRef<{ ids: string[]; key: string }>({ ids: [], key: "" });
+  if (!enabled) return "";
+  const previous = last.current;
+  if (
+    previous.ids.length === messages.length &&
+    messages.every((message, index) => message.id === previous.ids[index])
+  ) {
+    return previous.key;
+  }
+  const ids = messages.map((message) => message.id);
+  last.current = { ids, key: ids.join("\n") };
+  return last.current.key;
+}
+
+/** The single-session adapter the host is built on. */
+function adapterOf(latest: {
+  current: UseRemoteControlOptions;
+}): RemoteControlCliSession {
+  return {
+    sessionId: () => latest.current.sessionId,
+    workdir: () => latest.current.workdir,
+    displayMessages: () => latest.current.messages,
+    contextUsagePercent: () =>
+      percentOf(
+        latest.current.latestTotalTokens,
+        latest.current.maxInputTokens,
+      ),
+    latestTotalTokens: () => latest.current.latestTotalTokens,
+    permissionMode: () => latest.current.permissionMode,
+    customTitle: () => latest.current.customTitle(),
+    availableTools: () => latest.current.availableTools(),
+    isLoading: () => latest.current.isLoading,
+    hasRunningBackgroundWork: () => latest.current.hasRunningBackgroundWork,
+    hasPendingMessages: () => latest.current.hasPendingMessages,
+    tasks: () => latest.current.tasks,
+    backgroundTasks: () =>
+      toBackgroundTaskSummaries(latest.current.backgroundTasks),
+    isCompacting: () => latest.current.isCompacting,
+    isCommandRunning: () => latest.current.isCommandRunning,
+    queuedMessages: () => latest.current.queuedMessages,
+    pendingPermissions: () => latest.current.pending,
+    sendMessage: (text, force) => latest.current.sendMessage(text, force),
+    abort: () => latest.current.abort(),
+    setPermissionMode: (mode) => latest.current.setPermissionMode(mode),
+    respondPermission: (requestId, decision) =>
+      latest.current.respondPermission(requestId, decision),
+    renameSession: (title) => latest.current.renameSession(title),
+    compact: (customInstructions) => latest.current.compact(customInstructions),
+    slashCommands: () => latest.current.slashCommands(),
+  };
+}

package/src/index.ts

@@ -218,18 +218,30 @@ export async function main() {
           )
           .command(
             "uninstall <plugin>",
-            "Uninstall a plugin",
+            "Uninstall a plugin from one scope (default: the scope it is enabled in for the current directory)",
             (yargs) => {
-              return yargs.positional("plugin", {
-                describe: "Plugin to uninstall (format: name@marketplace)",
-                type: "string",
-              });
+              return yargs
+                .positional("plugin", {
+                  describe: "Plugin to uninstall (format: name@marketplace)",
+                  type: "string",
+                })
+                .option("scope", {
+                  alias: "s",
+                  describe: "Scope to uninstall from",
+                  choices: ["user", "project", "local"],
+                  type: "string",
+                });
             },
             async (argv) => {
               const { uninstallPluginCommand } = await import(
                 "./commands/plugin/uninstall.js"
               );
-              await uninstallPluginCommand(argv as { plugin: string });
+              await uninstallPluginCommand(
+                argv as {
+                  plugin: string;
+                  scope?: Scope;
+                },
+              );
             },
           )
           .command(
@@ -312,8 +324,9 @@ export async function main() {
                     type: "string",
                   })
                   .option("lines", {
-                    describe: "Number of recent messages to show",
-                    default: 20,
+                    describe:
+                      "Number of recent messages to show (0 = status line only)",
+                    default: 1,
                     type: "number",
                   });
               },
@@ -327,6 +340,47 @@ export async function main() {
                 );
               },
             )
+            .command(
+              "wait <sessionId>",
+              "Block until a session goes idle (or waits for approval), then print its final snapshot (exit 0 = idle, 3 = waiting for approval, 1 = error/timeout). Idle = no turn running, no background task/subagent running, nothing queued (same as `wave -p`); a session holding a long-running background task never goes idle, so give it --timeout",
+              (yargs) => {
+                return yargs
+                  .positional("sessionId", {
+                    describe: "Session ID hosted by the daemon",
+                    type: "string",
+                  })
+                  .option("lines", {
+                    describe:
+                      "Number of recent messages to print on exit (0 = status line only)",
+                    default: 1,
+                    type: "number",
+                  })
+                  .option("from-busy", {
+                    describe:
+                      "Wait until the session has been observed busy at least once before accepting idle (removes the stale-snapshot race right after an async `send`; a running background task also counts as busy)",
+                    default: false,
+                    type: "boolean",
+                  })
+                  .option("timeout", {
+                    describe:
+                      "Seconds to wait before giving up (default: wait forever) — required for sessions with a long-running background task, which never go idle",
+                    type: "number",
+                  });
+              },
+              async (argv) => {
+                const { daemonWaitCommand, DEFAULT_DAEMON_SOCKET } =
+                  await import("./daemon/commands.js");
+                await daemonWaitCommand(
+                  DEFAULT_DAEMON_SOCKET,
+                  argv.sessionId as string,
+                  {
+                    lines: argv.lines as number,
+                    fromBusy: argv.fromBusy as boolean,
+                    timeout: argv.timeout as number | undefined,
+                  },
+                );
+              },
+            )
             .command(
               "send <sessionId> <message>",
               "Inject a message into a session (async by default; --wait N to get the reply)",
@@ -483,6 +537,41 @@ export async function main() {
             .demandCommand(1, "Please specify a daemon subcommand");
         },
       )
+      .command(
+        "remote-control [action] [name]",
+        "Serve this machine's sessions to a paired phone (via the wave daemon)",
+        (yargs) => {
+          return yargs
+            .positional("action", {
+              describe: "on | off | status",
+              type: "string",
+              default: "status",
+            })
+            .positional("name", {
+              describe: "Label for this machine, shown on the phone",
+              type: "string",
+            });
+        },
+        async (argv) => {
+          const {
+            remoteControlOnCommand,
+            remoteControlOffCommand,
+            remoteControlStatusCommand,
+          } = await import("./remote/remoteControlCommands.js");
+          const action = (argv.action as string | undefined) ?? "status";
+          if (action === "on") {
+            await remoteControlOnCommand(argv.name as string | undefined);
+          } else if (action === "off") {
+            await remoteControlOffCommand();
+          } else if (action === "status") {
+            await remoteControlStatusCommand();
+          } else {
+            console.error(`Unknown remote-control action: ${action}`);
+            console.error("Usage: wave remote-control [on|off|status] [name]");
+            process.exit(1);
+          }
+        },
+      )
       .command(
         "update",
         "Update WAVE Code to the latest version",

package/src/managers/inputHandlers.ts

@@ -6,6 +6,7 @@ import {
   InputAction,
   InputManagerCallbacks,
   isPasteImageKey,
+  permissionModeCycle,
 } from "./inputReducer.js";
 
 export const expandLongTextPlaceholders = (
@@ -136,15 +137,10 @@ export const cyclePermissionMode = (
   dispatch: React.Dispatch<InputAction>,
   callbacks: Partial<InputManagerCallbacks>,
 ) => {
-  const modes: PermissionMode[] = [
-    "default",
-    "acceptEdits",
-    "bypassPermissions",
-    "plan",
-  ];
-  const currentIndex = modes.indexOf(currentMode);
-  const nextIndex = currentIndex === -1 ? 0 : (currentIndex + 1) % modes.length;
-  const nextMode = modes[nextIndex];
+  const currentIndex = permissionModeCycle.indexOf(currentMode);
+  const nextIndex =
+    currentIndex === -1 ? 0 : (currentIndex + 1) % permissionModeCycle.length;
+  const nextMode = permissionModeCycle[nextIndex];
 
   callbacks.logger?.debug("Cycling permission mode", {
     from: currentMode,
@@ -376,6 +372,8 @@ export const handleCommandSelect = (
           dispatch({ type: "SET_SHOW_HOOKS_MANAGER", payload: true });
         } else if (command === "rewind") {
           dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: true });
+        } else if (command === "resume") {
+          dispatch({ type: "SET_SHOW_RESUME_SELECTOR", payload: true });
         } else if (command === "help") {
           dispatch({ type: "SET_SHOW_HELP", payload: true });
         } else if (command === "status") {
@@ -401,8 +399,14 @@ export const handleCommandSelect = (
           await callbacks.onClearMessages?.();
         } else if (command === "compact") {
           await callbacks.onCompact?.();
+        } else if (command === "reload-plugins") {
+          await callbacks.onReloadPlugins?.();
         } else if (command === "add-dir") {
           await callbacks.onAddDir?.();
+        } else if (command === "rename") {
+          await callbacks.onRenameSession?.();
+        } else if (command === "remote-control") {
+          await callbacks.onRemoteControlCommand?.();
         }
       }
     })();
@@ -756,6 +760,7 @@ export const handleInput = async (
         state.showBackgroundTaskManager ||
         state.showMcpManager ||
         state.showRewindManager ||
+        state.showResumeSelector ||
         state.showHelp ||
         state.showStatusCommand ||
         state.showPluginManager ||
@@ -780,6 +785,7 @@ export const handleInput = async (
     state.showBackgroundTaskManager ||
     state.showMcpManager ||
     state.showRewindManager ||
+    state.showResumeSelector ||
     state.showHelp ||
     state.showStatusCommand ||
     state.showPluginManager ||
@@ -790,6 +796,7 @@ export const handleInput = async (
       state.showBackgroundTaskManager ||
       state.showMcpManager ||
       state.showRewindManager ||
+      state.showResumeSelector ||
       state.showHelp ||
       state.showStatusCommand ||
       state.showPluginManager ||

package/src/managers/inputReducer.ts

@@ -37,6 +37,18 @@ export const btwOverlayActiveRef: { current: boolean } = { current: false };
 
 export const ESC_DOUBLE_PRESS_TIMEOUT_MS = 1000;
 
+/**
+ * Shift+Tab 循环的权限模式顺序（对齐 Claude Code：plan 之后才进入
+ * bypassPermissions）。单独导出，避免 handler 与 reducer 两条路径各写一份
+ * 而漂移。
+ */
+export const permissionModeCycle: PermissionMode[] = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "bypassPermissions",
+];
+
 /**
  * Paste-image shortcut: Ctrl+V everywhere, plus Alt+V on Windows — Windows
  * terminals reserve Ctrl+V for their own system paste, so the key never
@@ -108,7 +120,10 @@ export interface InputManagerCallbacks {
   ) => Promise<string>;
   onClearMessages?: () => Promise<void>;
   onCompact?: (instructions?: string) => Promise<void>;
+  onReloadPlugins?: () => Promise<void>;
   onAddDir?: (args?: string) => Promise<void>;
+  onRenameSession?: (args?: string) => Promise<void>;
+  onRemoteControlCommand?: (args?: string) => Promise<void>;
   onPlanCommand?: (args?: string) => Promise<void> | void;
   sessionId?: string;
   workdir?: string;
@@ -142,6 +157,7 @@ export interface InputState {
   showMcpManager: boolean;
   showAgentsManager: boolean;
   showRewindManager: boolean;
+  showResumeSelector: boolean;
   showHelp: boolean;
   showStatusCommand: boolean;
   showLoginCommand: boolean;
@@ -182,6 +198,7 @@ export const initialState: InputState = {
   showMcpManager: false,
   showAgentsManager: false,
   showRewindManager: false,
+  showResumeSelector: false,
   showHelp: false,
   showStatusCommand: false,
   showLoginCommand: false,
@@ -465,6 +482,7 @@ export type InputAction =
   | { type: "SET_SHOW_MCP_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_AGENTS_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_REWIND_MANAGER"; payload: boolean }
+  | { type: "SET_SHOW_RESUME_SELECTOR"; payload: boolean }
   | { type: "SET_SHOW_HELP"; payload: boolean }
   | { type: "SET_SHOW_STATUS_COMMAND"; payload: boolean }
   | { type: "SET_SHOW_LOGIN_COMMAND"; payload: boolean }
@@ -667,6 +685,12 @@ export function inputReducer(
         showRewindManager: action.payload,
         selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
       };
+    case "SET_SHOW_RESUME_SELECTOR":
+      return {
+        ...state,
+        showResumeSelector: action.payload,
+        selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
+      };
     case "SET_SHOW_HELP":
       return {
         ...state,
@@ -1076,6 +1100,7 @@ export function inputReducer(
             state.showMcpManager ||
             state.showAgentsManager ||
             state.showRewindManager ||
+            state.showResumeSelector ||
             state.showHelp ||
             state.showStatusCommand ||
             state.showLoginCommand ||
@@ -1123,16 +1148,12 @@ export function inputReducer(
 
       // 3. Special Shortcuts
       if (key.tab && key.shift) {
-        const modes: PermissionMode[] = [
-          "default",
-          "acceptEdits",
-          "bypassPermissions",
-          "plan",
-        ];
-        const currentIndex = modes.indexOf(state.permissionMode);
+        const currentIndex = permissionModeCycle.indexOf(state.permissionMode);
         const nextIndex =
-          currentIndex === -1 ? 0 : (currentIndex + 1) % modes.length;
-        const nextMode = modes[nextIndex];
+          currentIndex === -1
+            ? 0
+            : (currentIndex + 1) % permissionModeCycle.length;
+        const nextMode = permissionModeCycle[nextIndex];
         return {
           ...state,
           permissionMode: nextMode,

package/src/print-cli.ts

@@ -5,6 +5,7 @@ import {
   hasNewCommits,
   getDefaultRemoteBranch,
   validateWorktreeRemovalPath,
+  setTelemetryStdoutProtected,
   type WorktreeSession,
 } from "wave-agent-sdk";
 import { displayUsageSummary } from "./utils/usageSummary.js";
@@ -35,6 +36,9 @@ function displayTimingInfo(startTime: Date, showStats: boolean): void {
 }
 
 export async function startPrintCli(options: PrintCliOptions): Promise<void> {
+  // stdout carries the printed result here; console telemetry exporters would
+  // mix structured telemetry into it — strip them at config resolution.
+  setTelemetryStdoutProtected(true);
   const startTime = new Date();
   const {
     restoreSessionId,
@@ -135,6 +139,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       isNewWorktree: worktreeSession?.isNew,
       model,
       mcpServers,
+      entrypoint: "cli",
       // 保持流式模式以获得更好的命令行用户体验
     });