wave-code 1.0.7 → 1.0.8

package/dist/components/ChatInterface.js

@@ -57,5 +57,5 @@ export const ChatInterface = () => {
     ]);
     if (!sessionId)
         return null;
-    return (_jsxs(Box, { ref: chatInterfaceRef, flexDirection: "column", children: [_jsx(MessageList, { messages: displayMessages, isExpanded: isExpanded, version: version, workdir: workdir, forceStatic: forceStatic }, remountKey), !isConfirmationVisible && !isExpanded && (_jsxs(_Fragment, { children: [(isLoading || isCommandRunning || isCompacting) && (_jsx(LoadingIndicator, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompacting: isCompacting, latestTotalTokens: latestTotalTokens })), _jsx(TaskList, {}), _jsx(QueuedMessageList, {}), _jsx(InputBox, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompacting: isCompacting, sendMessage: sendMessage, abortMessage: abortMessage, mcpServers: mcpServers, connectMcpServer: connectMcpServer, disconnectMcpServer: disconnectMcpServer, slashCommands: slashCommands, hasSlashCommand: hasSlashCommand, latestTotalTokens: latestTotalTokens, maxInputTokens: maxInputTokens, showLoginHint: showLoginHint })] })), isConfirmationVisible && (_jsxs(_Fragment, { children: [forceStatic ? (_jsx(Static, { items: [{ key: "confirmation-details" }], children: () => (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, isExpanded: isExpanded }, "confirmation-details")) })) : (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, isExpanded: isExpanded })), _jsx(ConfirmationSelector, { toolName: confirmingTool.name, toolInput: confirmingTool.input, suggestedPrefix: confirmingTool.suggestedPrefix, hidePersistentOption: confirmingTool.hidePersistentOption, permissionMode: confirmingTool.permissionMode, isExpanded: isExpanded, onDecision: handleConfirmationDecision, onCancel: handleConfirmationCancel })] }))] }));
+    return (_jsxs(Box, { ref: chatInterfaceRef, flexDirection: "column", children: [_jsx(MessageList, { messages: displayMessages, isExpanded: isExpanded, version: version, workdir: workdir, forceStatic: forceStatic }, remountKey), !isConfirmationVisible && !isExpanded && (_jsxs(_Fragment, { children: [(isLoading || isCommandRunning || isCompacting) && (_jsx(LoadingIndicator, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompacting: isCompacting, latestTotalTokens: latestTotalTokens })), _jsx(TaskList, {}), _jsx(QueuedMessageList, {}), _jsx(InputBox, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompacting: isCompacting, sendMessage: sendMessage, abortMessage: abortMessage, mcpServers: mcpServers, connectMcpServer: connectMcpServer, disconnectMcpServer: disconnectMcpServer, slashCommands: slashCommands, hasSlashCommand: hasSlashCommand, latestTotalTokens: latestTotalTokens, maxInputTokens: maxInputTokens, showLoginHint: showLoginHint })] })), isConfirmationVisible && (_jsxs(_Fragment, { children: [forceStatic ? (_jsx(Static, { items: [{ key: "confirmation-details" }], children: () => (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, warning: confirmingTool.warning, isExpanded: isExpanded }, "confirmation-details")) })) : (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, warning: confirmingTool.warning, isExpanded: isExpanded })), _jsx(ConfirmationSelector, { toolName: confirmingTool.name, toolInput: confirmingTool.input, suggestedPrefix: confirmingTool.suggestedPrefix, hidePersistentOption: confirmingTool.hidePersistentOption, permissionMode: confirmingTool.permissionMode, isExpanded: isExpanded, onDecision: handleConfirmationDecision, onCancel: handleConfirmationCancel })] }))] }));
 };

package/dist/components/ConfirmationDetails.d.ts

@@ -3,6 +3,7 @@ export interface ConfirmationDetailsProps {
     toolName: string;
     toolInput?: Record<string, unknown>;
     planContent?: string;
+    warning?: string;
     isExpanded?: boolean;
 }
 export declare const ConfirmationDetails: React.FC<ConfirmationDetailsProps>;

package/dist/components/ConfirmationDetails.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { BASH_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "wave-agent-sdk";
+import { BASH_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, ARTIFACT_TOOL_NAME, } from "wave-agent-sdk";
 import { DiffDisplay } from "./DiffDisplay.js";
 import { PlanDisplay } from "./PlanDisplay.js";
 import { highlightToAnsi } from "../utils/highlightUtils.js";
@@ -22,14 +22,16 @@ const getActionDescription = (toolName, toolInput) => {
             return "Enter plan mode for complex task planning";
         case ASK_USER_QUESTION_TOOL_NAME:
             return "Answer questions to clarify intent";
+        case ARTIFACT_TOOL_NAME:
+            return `Publish file: ${toolInput.file_path || "unknown file"}`;
         default:
             return "Execute operation";
     }
 };
-export const ConfirmationDetails = ({ toolName, toolInput, planContent, isExpanded = false, }) => {
+export const ConfirmationDetails = ({ toolName, toolInput, planContent, warning, isExpanded = false, }) => {
     const startLineNumber = toolInput?.startLineNumber ??
         (toolName === WRITE_TOOL_NAME ? 1 : undefined);
-    const content = (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "yellow", borderBottom: false, borderLeft: false, borderRight: false, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["Tool: ", toolName] }), _jsx(Text, { color: "yellow", children: getActionDescription(toolName, toolInput) }), _jsx(DiffDisplay, { toolName: toolName, parameters: JSON.stringify(toolInput), startLineNumber: startLineNumber }), toolName !== WRITE_TOOL_NAME &&
+    const content = (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "yellow", borderBottom: false, borderLeft: false, borderRight: false, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["Tool: ", toolName] }), _jsx(Text, { color: "yellow", children: getActionDescription(toolName, toolInput) }), warning && _jsxs(Text, { color: "red", children: ["\u26A0 ", warning] }), _jsx(DiffDisplay, { toolName: toolName, parameters: JSON.stringify(toolInput), startLineNumber: startLineNumber }), toolName !== WRITE_TOOL_NAME &&
                 toolName !== EDIT_TOOL_NAME &&
                 toolName !== EXIT_PLAN_MODE_TOOL_NAME &&
                 toolName !== ENTER_PLAN_MODE_TOOL_NAME &&

package/dist/components/RewindCommand.js

@@ -16,10 +16,17 @@ export const RewindCommand = ({ messages: initialMessages, onSelect, onCancel, g
         }
     }, [getFullMessageThread]);
     // 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 }) => isUserCheckpointMessage(msg));
+    // system-generated user-role messages (task notifications, hook injections).
+    // Compaction is append-only: the same message id appears twice on the full
+    // thread (pre-compact history + post-compact append), so dedupe by id and
+    // keep the last occurrence (matching the folded view the user sees).
+    const checkpointMap = new Map();
+    messages.forEach((msg, index) => {
+        if (!isUserCheckpointMessage(msg))
+            return;
+        checkpointMap.set(msg.id ?? `index:${index}`, { msg, index });
+    });
+    const checkpoints = Array.from(checkpointMap.values());
     const MAX_VISIBLE_ITEMS = 3;
     const [state, dispatch] = useReducer(rewindSelectorReducer, {
         selectedIndex: checkpoints.length - 1,

package/dist/contexts/useChat.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import type { Message, McpServerStatus, BackgroundTask, Task, SlashCommand, SubagentConfiguration, PermissionDecision, PermissionMode, QueuedMessage, WorkflowRun } from "wave-agent-sdk";
+import type { Message, McpServerStatus, BackgroundTask, Task, SlashCommand, SubagentConfiguration, PermissionDecision, PermissionMode, QueuedMessage, WorkflowRun, ToolBlockUpdateCallbackParams } from "wave-agent-sdk";
 import { BaseAppProps } from "../types.js";
 export interface ChatContextType {
     messages: Message[];
@@ -58,8 +58,9 @@ export interface ChatContextType {
         hidePersistentOption?: boolean;
         planContent?: string;
         permissionMode?: PermissionMode;
+        warning?: string;
     };
-    showConfirmation: (toolName: string, toolInput?: Record<string, unknown>, suggestedPrefix?: string, hidePersistentOption?: boolean, planContent?: string, permissionMode?: PermissionMode) => Promise<PermissionDecision>;
+    showConfirmation: (toolName: string, toolInput?: Record<string, unknown>, suggestedPrefix?: string, hidePersistentOption?: boolean, planContent?: string, permissionMode?: PermissionMode, warning?: string) => Promise<PermissionDecision>;
     hideConfirmation: () => void;
     handleConfirmationDecision: (decision: PermissionDecision) => void;
     handleConfirmationCancel: () => void;
@@ -83,4 +84,18 @@ export declare const useChat: () => ChatContextType;
 export interface ChatProviderProps extends BaseAppProps {
     children: React.ReactNode;
 }
+/**
+ * Per-tool window-concat throttle for pure-delta tool parameter streaming:
+ * `parametersChunk` deltas are accumulated independently per tool block id
+ * within the cooldown window, so interleaved multi-tool streams lose no delta
+ * (a plain throttle's single last-args slot would drop every earlier tool's
+ * deltas, leaving the first tool without streaming parameters). `start` /
+ * `running` apply immediately (one-shot snapshots); `end` flushes pending
+ * streaming deltas first, then applies the authoritative parameters/result.
+ */
+export declare function createToolStreamingThrottle(fn: (params: ToolBlockUpdateCallbackParams) => void, wait: number): {
+    (params: ToolBlockUpdateCallbackParams): void;
+    cancel: () => void;
+    flush: () => void;
+};
 export declare const ChatProvider: React.FC<ChatProviderProps>;

package/dist/contexts/useChat.js

@@ -4,7 +4,6 @@ import { useInput, useStdout } from "ink";
 import { useAppConfig } from "./useAppConfig.js";
 import { Agent, OPERATION_CANCELLED_BY_USER, extractLatestTotalTokens, } from "wave-agent-sdk";
 import { logger } from "../utils/logger.js";
-import { throttle } from "../utils/throttle.js";
 import { displayUsageSummary } from "../utils/usageSummary.js";
 import { expandLongTextPlaceholders } from "../managers/inputHandlers.js";
 const ChatContext = createContext(null);
@@ -75,6 +74,86 @@ function createStreamingWindowThrottle(fn, wait) {
     };
     return throttled;
 }
+/**
+ * Per-tool window-concat throttle for pure-delta tool parameter streaming:
+ * `parametersChunk` deltas are accumulated independently per tool block id
+ * within the cooldown window, so interleaved multi-tool streams lose no delta
+ * (a plain throttle's single last-args slot would drop every earlier tool's
+ * deltas, leaving the first tool without streaming parameters). `start` /
+ * `running` apply immediately (one-shot snapshots); `end` flushes pending
+ * streaming deltas first, then applies the authoritative parameters/result.
+ */
+export function createToolStreamingThrottle(fn, wait) {
+    let timer = null;
+    let pending = null;
+    const fire = () => {
+        if (pending && pending.chunks.size > 0) {
+            const { messageId, chunks } = pending;
+            pending = null;
+            for (const [id, chunk] of chunks) {
+                fn({ messageId, id, parametersChunk: chunk, stage: "streaming" });
+            }
+        }
+    };
+    const throttled = (params) => {
+        if (params.stage === "end") {
+            // Flush any deltas still pending inside the cooldown window first
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            fire();
+            fn(params);
+            return;
+        }
+        if (params.stage === "streaming") {
+            if (!pending) {
+                pending = { messageId: params.messageId, chunks: new Map() };
+            }
+            const prev = pending.chunks.get(params.id) || "";
+            pending.chunks.set(params.id, prev + (params.parametersChunk || ""));
+            if (!timer) {
+                timer = setTimeout(() => {
+                    timer = null;
+                    fire();
+                }, wait);
+            }
+            return;
+        }
+        // start / running — one-shot snapshots applied immediately. Drop this
+        // tool's buffered streaming deltas first: start/running carry the
+        // authoritative parameters, and a pending timer would otherwise fire late
+        // with a stale `streaming` event, regressing this tool block's stage back
+        // to streaming (yellow dot -> gray) mid-execution. Other tools' in-flight
+        // chunks are kept so interleaved multi-tool streaming still accumulates.
+        if (pending) {
+            pending.chunks.delete(params.id);
+            if (pending.chunks.size === 0) {
+                pending = null;
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+            }
+        }
+        fn(params);
+    };
+    throttled.cancel = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        pending = null;
+    };
+    throttled.flush = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        fire();
+    };
+    return throttled;
+}
 export const ChatProvider = ({ children, bypassPermissions, permissionMode: initialPermissionMode, pluginDirs, additionalDirectories, tools, allowedTools, disallowedTools, workdir, worktreeSession, originalCwd, version, model, mcpServers, }) => {
     const { restoreSessionId, continueLastSession } = useAppConfig();
     const { stdout } = useStdout();
@@ -142,8 +221,8 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             };
         }));
     }, 500), []);
-    const throttledToolBlockUpdate = useMemo(() => throttle((params) => {
-        const { messageId, id: toolBlockId, ...updates } = params;
+    const throttledToolBlockUpdate = useMemo(() => createToolStreamingThrottle((params) => {
+        const { messageId, id: toolBlockId, parametersChunk, ...updates } = params;
         setMessages((prev) => prev.map((m) => {
             if (m.id !== messageId)
                 return m;
@@ -158,7 +237,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                             id: toolBlockId,
                             name: updates.name || "",
                             stage: updates.stage || "start",
-                            parameters: updates.parameters || "",
+                            parameters: (updates.parameters || "") + (parametersChunk || ""),
                             result: updates.result || "",
                             ...updates,
                         },
@@ -168,7 +247,18 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             return {
                 ...m,
                 blocks: m.blocks.map((b, idx) => idx === toolBlockIndex && b.type === "tool"
-                    ? { ...b, ...updates }
+                    ? {
+                        ...b,
+                        ...updates,
+                        // Streaming carries only the delta; append it to the
+                        // accumulated parameters. start/running/end carry the
+                        // authoritative value and replace wholesale.
+                        parameters: parametersChunk
+                            ? (b.parameters || "") + parametersChunk
+                            : updates.parameters !== undefined
+                                ? updates.parameters
+                                : b.parameters,
+                    }
                     : b),
             };
         }));
@@ -238,7 +328,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         }
     }, []);
     // Permission confirmation methods with queue support
-    const showConfirmation = useCallback(async (toolName, toolInput, suggestedPrefix, hidePersistentOption, planContent, permissionMode) => {
+    const showConfirmation = useCallback(async (toolName, toolInput, suggestedPrefix, hidePersistentOption, planContent, permissionMode, warning) => {
         return new Promise((resolve, reject) => {
             const queueItem = {
                 toolName,
@@ -247,6 +337,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 hidePersistentOption,
                 planContent,
                 permissionMode,
+                warning,
                 resolver: resolve,
                 reject,
             };
@@ -426,7 +517,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             // Create the permission callback inside the try block to access showConfirmation
             const permissionCallback = async (context) => {
                 try {
-                    return await showConfirmation(context.toolName, context.toolInput, context.suggestedPrefix, context.hidePersistentOption, context.planContent, context.permissionMode);
+                    return await showConfirmation(context.toolName, context.toolInput, context.suggestedPrefix, context.hidePersistentOption, context.planContent, context.permissionMode, context.warning);
                 }
                 catch {
                     // If confirmation was cancelled or failed, deny the operation
@@ -718,6 +809,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 hidePersistentOption: next.hidePersistentOption,
                 planContent: next.planContent,
                 permissionMode: next.permissionMode,
+                warning: next.warning,
             });
             setIsConfirmationVisible(true);
             setConfirmationQueue((prev) => prev.slice(1));

package/dist/daemon/commands.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `wave daemon` client subcommands — talk to the wave daemon's unix socket
+ * (JSON-RPC over newline-delimited JSON) to list hosted sessions, inspect
+ * progress, inject messages and respond to pending permission requests.
+ *
+ * All subcommands are non-interactive: results go to stdout, diagnostics to
+ * stderr, and every handler calls process.exit() itself (yargs would fall
+ * through to the TUI otherwise). Every command connects to the fixed default
+ * socket `~/.wave/daemon.sock` — the daemon only runs on remote hosts, so no
+ * `--socket` override is offered (spec: daemon-command.md).
+ *
+ * Attach semantics: `initialize {workdir, restoreSessionId}` + `restoreSession`
+ * re-attach to a live session in the daemon's in-memory registry, or reload a
+ * transcript from disk under the current working directory. A session that is
+ * nowhere (live registry or disk) silently starts a FRESH session under a
+ * different id — the only reliable existence check is the `restoreSession`
+ * rejection ("Session not found: <id>"), after which the junk fresh session
+ * must be destroyed via the envelope sessionId returned by `initialize`.
+ */
+/** Fixed default daemon socket (spec: 默认 socket 固定，无 --socket 覆盖). */
+export declare const DEFAULT_DAEMON_SOCKET: string;
+export declare function daemonListCommand(socketPath: string): Promise<void>;
+export declare function daemonStatusCommand(socketPath: string, sessionId: string, lines?: number): Promise<void>;
+export interface SendOptions {
+    timeout: number;
+}
+/**
+ * Send a message and wait for the reply that corresponds to it.
+ *
+ * Completion detection: `sendMessage` on an idle session resolves only after
+ * the whole turn finishes (InteractionService awaits sendAIMessage), while on a
+ * busy session it enqueues and returns immediately — so stopping on a bare
+ * `loadingChange:false` would exit early on the PREVIOUS turn's completion when
+ * queued behind a busy session. Instead, track the message IDs: `ourUserMessage`
+ * is the user message added when OUR turn starts (userMessageAdded), and the
+ * reply is the last assistantMessageAdded observed after it. A stale
+ * loading:false can then never satisfy the wait condition early (the reply has
+ * not been added yet).
+ */
+export declare function daemonSendCommand(socketPath: string, sessionId: string, message: string, options?: SendOptions): Promise<void>;
+export interface RespondOptions {
+    allow?: boolean;
+    deny?: boolean;
+    reason?: string;
+    answer?: string;
+    rule?: string;
+    mode?: string;
+}
+export declare function daemonRespondCommand(socketPath: string, sessionId: string, requestId: string, options: RespondOptions): Promise<void>;

package/dist/daemon/commands.js

@@ -0,0 +1,341 @@
+/**
+ * `wave daemon` client subcommands — talk to the wave daemon's unix socket
+ * (JSON-RPC over newline-delimited JSON) to list hosted sessions, inspect
+ * progress, inject messages and respond to pending permission requests.
+ *
+ * All subcommands are non-interactive: results go to stdout, diagnostics to
+ * stderr, and every handler calls process.exit() itself (yargs would fall
+ * through to the TUI otherwise). Every command connects to the fixed default
+ * socket `~/.wave/daemon.sock` — the daemon only runs on remote hosts, so no
+ * `--socket` override is offered (spec: daemon-command.md).
+ *
+ * Attach semantics: `initialize {workdir, restoreSessionId}` + `restoreSession`
+ * re-attach to a live session in the daemon's in-memory registry, or reload a
+ * transcript from disk under the current working directory. A session that is
+ * nowhere (live registry or disk) silently starts a FRESH session under a
+ * different id — the only reliable existence check is the `restoreSession`
+ * rejection ("Session not found: <id>"), after which the junk fresh session
+ * must be destroyed via the envelope sessionId returned by `initialize`.
+ */
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { ASK_USER_QUESTION_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, getMessageContent, } from "wave-agent-sdk";
+import { SocketClient } from "./socketClient.js";
+/** Fixed default daemon socket (spec: 默认 socket 固定，无 --socket 覆盖). */
+export const DEFAULT_DAEMON_SOCKET = path.join(os.homedir(), ".wave", "daemon.sock");
+const PERMISSION_MODES = [
+    "default",
+    "bypassPermissions",
+    "acceptEdits",
+    "plan",
+    "dontAsk",
+];
+// ── Connection helpers ─────────────────────────────────────────
+function connectDaemon(socketPath) {
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection(socketPath);
+        socket.once("connect", () => resolve(new SocketClient(socket)));
+        socket.once("error", (err) => {
+            socket.destroy();
+            reject(err);
+        });
+    });
+}
+/** Connect or fail fast with the spec'd error; daemon idle-exits after 60s. */
+async function connectDaemonOrExit(socketPath) {
+    try {
+        return await connectDaemon(socketPath);
+    }
+    catch (err) {
+        const code = err.code;
+        console.error(`无法连接 daemon socket ${socketPath}：daemon 未运行？（daemon 空闲 60 秒自动退出）` +
+            (code ? ` (${code})` : ""));
+        process.exit(1);
+    }
+}
+function fail(message) {
+    console.error(message);
+    process.exit(1);
+}
+/**
+ * Attach to a session; returns the initialized sessionId + working directory.
+ * Exits (nonzero) with the spec'd error when the session exists neither in the
+ * daemon registry nor on disk, destroying the fresh session that `initialize`
+ * silently created.
+ */
+async function attachSession(client, sessionId) {
+    const init = (await client.request("initialize", {
+        workdir: process.cwd(),
+        restoreSessionId: sessionId,
+    }));
+    const initId = init.sessionId;
+    try {
+        await client.request("restoreSession", { sessionId }, initId);
+    }
+    catch (err) {
+        if (err.message.includes("Session not found")) {
+            // initialize silently started a junk fresh session — remove it from the
+            // registry so the failed attach leaves no trace (spec: 会话不存在错误).
+            await client.request("destroy", undefined, initId).catch(() => { });
+            fail(`会话不存在或未被该 daemon 托管：${sessionId}`);
+        }
+        throw err;
+    }
+    return init;
+}
+async function listPendingPermissions(client) {
+    const result = (await client.request("listPendingPermissions"));
+    return result.requests ?? [];
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ── list ───────────────────────────────────────────────────────
+export async function daemonListCommand(socketPath) {
+    let client;
+    try {
+        client = await connectDaemonOrExit(socketPath);
+        const result = (await client.request("listDaemonSessions"));
+        const sessions = result.sessions ?? [];
+        if (sessions.length > 0) {
+            const rows = sessions.map((s) => ({
+                sessionId: s.sessionId,
+                status: s.isLoading ? "生成中" : "空闲",
+                messageCount: String(s.messageCount),
+                workingDirectory: s.workingDirectory,
+            }));
+            const width = (key) => Math.max(...rows.map((r) => r[key].length), key.length);
+            const pad = (value, w) => value.padEnd(w);
+            console.log(`${pad("会话", width("sessionId"))}  ${pad("状态", width("status"))}  ${pad("消息数", width("messageCount"))}  工作目录`);
+            for (const r of rows) {
+                console.log(`${pad(r.sessionId, width("sessionId"))}  ${pad(r.status, width("status"))}  ${pad(r.messageCount, width("messageCount"))}  ${r.workingDirectory}`);
+            }
+        }
+        else {
+            // Daemon idle-exit is normal — an empty registry is not an error.
+            console.log("无会话");
+        }
+    }
+    catch (err) {
+        fail(`wave daemon list 失败：${err.message}`);
+    }
+    finally {
+        await client?.dispose();
+    }
+    // Exits outside the try so the success path's exit is never re-wrapped by the
+    // error handler above.
+    process.exit(0);
+}
+// ── status ─────────────────────────────────────────────────────
+function summarizeToolInput(context) {
+    const input = context.toolInput;
+    if (!input || Object.keys(input).length === 0)
+        return "";
+    let text;
+    try {
+        text = JSON.stringify(input);
+    }
+    catch {
+        text = "";
+    }
+    return text.length > 80 ? `${text.slice(0, 80)}…` : text;
+}
+export async function daemonStatusCommand(socketPath, sessionId, lines = 20) {
+    let client;
+    try {
+        client = await connectDaemonOrExit(socketPath);
+        // Subscribe BEFORE initialize/restoreSession so the replayed loadingChange
+        // snapshot is captured (spec: 依据重放的 loadingChange 快照显示状态).
+        let loading = false;
+        client.onNotification("loadingChange", (params) => {
+            loading = params.loading;
+        });
+        const init = await attachSession(client, sessionId);
+        const initId = init.sessionId;
+        // listPendingPermissions is the authoritative "waiting for approval" signal
+        // (spec: 单凭消息无法区分等审批与执行中，须结合 listPendingPermissions).
+        const pending = (await listPendingPermissions(client)).filter((r) => r.sessionId === initId || r.sessionId === sessionId);
+        const messages = (await client.request("getMessages", undefined, initId));
+        const status = pending.length > 0 ? "等待审批" : loading ? "生成中" : "空闲";
+        console.log(`会话: ${initId}`);
+        console.log(`工作目录: ${init.workingDirectory}`);
+        console.log(`状态: ${status}`);
+        if (pending.length > 0) {
+            console.log("");
+            console.log("待审批请求:");
+            for (const r of pending) {
+                const params = summarizeToolInput(r.context);
+                console.log(`  ${r.requestId}  ${r.context.toolName}${params ? `  ${params}` : ""}`);
+            }
+        }
+        const recent = messages.messages.slice(-lines);
+        if (recent.length > 0) {
+            console.log("");
+            console.log(`最近消息 (${recent.length}):`);
+            for (const m of recent) {
+                const text = getMessageContent(m).replace(/\s+/g, " ").trim();
+                if (!text)
+                    continue; // tool-only messages carry no readable text
+                console.log(`  [${m.role}] ${text}`);
+            }
+        }
+    }
+    catch (err) {
+        fail(`wave daemon status 失败：${err.message}`);
+    }
+    finally {
+        await client?.dispose();
+    }
+    process.exit(0);
+}
+/**
+ * Send a message and wait for the reply that corresponds to it.
+ *
+ * Completion detection: `sendMessage` on an idle session resolves only after
+ * the whole turn finishes (InteractionService awaits sendAIMessage), while on a
+ * busy session it enqueues and returns immediately — so stopping on a bare
+ * `loadingChange:false` would exit early on the PREVIOUS turn's completion when
+ * queued behind a busy session. Instead, track the message IDs: `ourUserMessage`
+ * is the user message added when OUR turn starts (userMessageAdded), and the
+ * reply is the last assistantMessageAdded observed after it. A stale
+ * loading:false can then never satisfy the wait condition early (the reply has
+ * not been added yet).
+ */
+export async function daemonSendCommand(socketPath, sessionId, message, options = { timeout: 600 }) {
+    // connectDaemonOrExit exits on failure — no client to dispose in that case.
+    const client = await connectDaemonOrExit(socketPath);
+    let loading = false;
+    let sent = false;
+    let ourUserMessageId;
+    let replyMessageId;
+    client.onNotification("userMessageAdded", (params) => {
+        if (!sent)
+            return; // ignore messages added during attach
+        ourUserMessageId = params.message.id;
+    });
+    client.onNotification("assistantMessageAdded", (params) => {
+        if (!sent || ourUserMessageId === undefined)
+            return; // not our turn yet
+        replyMessageId = params.message.id;
+    });
+    client.onNotification("loadingChange", (params) => {
+        loading = params.loading;
+    });
+    let initId;
+    try {
+        initId = (await attachSession(client, sessionId)).sessionId;
+        sent = true;
+        await client.request("sendMessage", { text: message }, initId);
+    }
+    catch (err) {
+        client.dispose();
+        fail(`wave daemon send 失败：${err.message}`);
+    }
+    // Wait for the reply that corresponds to our message.
+    const started = Date.now();
+    const timeoutMs = options.timeout === 0 ? Infinity : options.timeout * 1000;
+    while (!(loading === false && replyMessageId !== undefined)) {
+        if (Date.now() - started > timeoutMs) {
+            // Timeout backstop: the most likely cause is a session waiting on a
+            // permission approval — point the user at respond (spec: 不无限期挂起).
+            const pending = (await listPendingPermissions(client)).filter((r) => r.sessionId === sessionId || r.sessionId === initId);
+            client.dispose();
+            if (pending.length > 0) {
+                fail(`会话等待权限审批，请通过 \`wave daemon respond ${sessionId} ${pending[0].requestId}\` 处理后重试`);
+            }
+            fail(options.timeout === 0
+                ? "等待回复超时"
+                : `等待回复超时（${options.timeout} 秒），未收到助手回复`);
+        }
+        await sleep(200);
+    }
+    try {
+        const result = (await client.request("getMessages", undefined, initId));
+        const reply = result.messages.find((m) => m.id === replyMessageId);
+        // Pure final-reply text only; streaming deltas / subagent internals never
+        // reach stdout (spec: send 输出纯净性).
+        if (reply) {
+            const content = getMessageContent(reply).replace(/\s+/g, " ").trim();
+            if (content)
+                console.log(content);
+        }
+    }
+    catch (err) {
+        fail(`wave daemon send 失败：${err.message}`);
+    }
+    finally {
+        client.dispose();
+    }
+    process.exit(0);
+}
+export async function daemonRespondCommand(socketPath, sessionId, requestId, options) {
+    if (!!options.allow === !!options.deny) {
+        fail("请指定 --allow 或 --deny（二选一）");
+    }
+    let client;
+    try {
+        client = await connectDaemonOrExit(socketPath);
+        // The server silently ignores permissionResponse for unknown requestIds —
+        // validate first so the user is never misled into thinking approval landed.
+        const pending = await listPendingPermissions(client);
+        const req = pending.find((r) => r.requestId === requestId);
+        if (!req) {
+            fail("该请求不存在或已处理");
+        }
+        if (req.sessionId && req.sessionId !== sessionId) {
+            // Cross-check before notifying; never touch another session's request.
+            fail("会话不存在或未被该 daemon 托管");
+        }
+        let decision;
+        if (options.deny) {
+            decision = { behavior: "deny", message: options.reason };
+        }
+        else {
+            // Per-tool auto-completion, mirroring the desktop ConfirmationDialog
+            // semantics (spec: 决策并非单一 allow/deny，须按工具智能补全).
+            const toolName = req.context.toolName;
+            if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
+                decision = { behavior: "allow", newPermissionMode: "plan" };
+            }
+            else if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
+                decision = { behavior: "allow", newPermissionMode: "default" };
+            }
+            else if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
+                if (!options.answer) {
+                    fail("AskUserQuestion 请求需要 --answer 提供答案 JSON");
+                }
+                let answers;
+                try {
+                    answers = JSON.parse(options.answer);
+                }
+                catch {
+                    fail("--answer 不是合法的 JSON");
+                }
+                decision = { behavior: "allow", message: JSON.stringify(answers) };
+            }
+            else {
+                decision = { behavior: "allow" };
+            }
+            if (options.rule)
+                decision.newPermissionRule = options.rule;
+            if (options.mode) {
+                if (!PERMISSION_MODES.includes(options.mode)) {
+                    fail(`无效的权限模式：${options.mode}（可选：${PERMISSION_MODES.join("、")}）`);
+                }
+                decision.newPermissionMode = options.mode;
+            }
+        }
+        // Mirror desktop stdioAgent.sendPermissionResponse: envelope sessionId
+        // present, decision built from the pending request's tool.
+        client.notify("permissionResponse", { requestId, decision }, sessionId);
+        console.log(`已处理审批请求：${requestId}`);
+    }
+    catch (err) {
+        fail(`wave daemon respond 失败：${err.message}`);
+    }
+    finally {
+        await client?.dispose();
+    }
+    process.exit(0);
+}