wave-code 1.0.7 → 1.0.9

package/bin/wave-code.js

@@ -1,5 +1,26 @@
 #!/usr/bin/env node
 
+import { readFileSync, writeSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// `wave -v` / `wave --version` must be fast: editors probe the installed CLI
+// version on every launch (e.g. the desktop app's auto-update check). Loading
+// the full app graph (wave-agent-sdk, ink, highlight.js, ...) just to print
+// the version takes 2-3s+ on a warm machine and can exceed callers' probe
+// timeouts on cold starts (AV scan of freshly installed files), which they
+// misread as "CLI missing/corrupt" → spurious re-installs. Print the version
+// straight from package.json and exit before touching the app graph.
+const versionArgs = ["-v", "--version"];
+if (process.argv.slice(2).some((a) => versionArgs.includes(a))) {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  const packageJson = JSON.parse(
+    readFileSync(path.resolve(__dirname, "../package.json"), "utf-8"),
+  );
+  writeSync(1, `${packageJson.version}\n`);
+  process.exit(0);
+}
+
 // Import and start the CLI
 import("../dist/index.js")
   .then(async ({ main }) => {

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);
@@ -15,6 +14,21 @@ export const useChat = () => {
     }
     return context;
 };
+/**
+ * Snapshot a SDK message for consumer state. The SDK mutates its internal
+ * message blocks in-place BEFORE firing the delta callback (it writes the full
+ * accumulated value to the shared block, then computes the chunk delta by
+ * slicing the new value). A consumer that pushed the SDK message object by
+ * live reference would read the already-updated block and append the delta
+ * again — the first delta is double-counted ("LetLet me think..."), affecting
+ * reasoning and text content alike. See docs/specs/core/stream-content-updates.md.
+ * The clone must be at least one layer deep (message + blocks) so the in-place
+ * block mutation never leaks into consumer state.
+ */
+const snapshotMessage = (message) => ({
+    ...message,
+    blocks: message.blocks.map((block) => ({ ...block })),
+});
 /**
  * Window-concat throttle for pure-delta streaming updates: chunks arriving
  * within the cooldown window are merged so no delta is lost (a dropped delta
@@ -75,6 +89,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 +236,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 +252,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 +262,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),
             };
         }));
@@ -232,13 +337,13 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     // the incremental callbacks in initializeAgent below.
     const refreshMessages = useCallback(() => {
         if (!isExpandedRef.current && agentRef.current) {
-            const msgs = [...agentRef.current.messages];
+            const msgs = agentRef.current.messages.map(snapshotMessage);
             setMessages(msgs);
             setLatestTotalTokens(extractLatestTotalTokens(msgs));
         }
     }, []);
     // 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 +352,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 hidePersistentOption,
                 planContent,
                 permissionMode,
+                warning,
                 resolver: resolve,
                 reject,
             };
@@ -266,7 +372,9 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 const last = msgs[msgs.length - 1];
                 if (!last || last.role !== "user")
                     return;
-                setMessages((prev) => prev.some((m) => m.id === last.id) ? prev : [...prev, last]);
+                setMessages((prev) => prev.some((m) => m.id === last.id)
+                    ? prev
+                    : [...prev, snapshotMessage(last)]);
             },
             onAssistantMessageAdded: (messageId) => {
                 if (isExpandedRef.current || !agentRef.current)
@@ -274,7 +382,9 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 const msg = agentRef.current.messages.find((m) => m.id === messageId);
                 if (!msg)
                     return;
-                setMessages((prev) => prev.some((m) => m.id === messageId) ? prev : [...prev, msg]);
+                setMessages((prev) => prev.some((m) => m.id === messageId)
+                    ? prev
+                    : [...prev, snapshotMessage(msg)]);
             },
             onAssistantContentUpdated: (params) => {
                 if (isExpandedRef.current)
@@ -426,7 +536,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
@@ -471,9 +581,10 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 };
                 agent.setWorktreeSession(session);
             }
-            // Get initial state
+            // Get initial state — snapshot the SDK messages (never hold live
+            // references; see snapshotMessage)
             setSessionId(agent.sessionId);
-            setMessages(agent.messages);
+            setMessages(agent.messages.map(snapshotMessage));
             setIsLoading(agent.isLoading);
             setLatestTotalTokens(extractLatestTotalTokens(agent.messages));
             setIsCommandRunning(agent.isCommandRunning);
@@ -718,6 +829,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>;