wave-agent-sdk 1.1.5 → 1.3.0

package/dist/managers/aiManager.js

@@ -2,18 +2,20 @@ import * as aiService from "../services/aiService.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { supportsVision } from "../utils/modelCapabilities.js";
 import { persistToolImages } from "../utils/toolImagePersistence.js";
-import { parseTaskNotificationXml, taskNotificationToXml, } from "../utils/notificationXml.js";
+import { parseTaskNotificationXml } from "../utils/notificationXml.js";
 import { estimateContextTokens } from "../utils/tokenCalculation.js";
 import { estimateTokens } from "../utils/tokenEstimate.js";
 import { getTaskReminderTurnCounts, maybeInjectTaskReminder, TASK_REMINDER_CONFIG, } from "../utils/taskReminder.js";
-import { createWriteStream, existsSync } from "node:fs";
-import * as os from "node:os";
+import { getChangedFilesReminder } from "../utils/fileChangeReminder.js";
+import { buildMcpInstructionsAnnouncement, collectAnnouncedServers, } from "../utils/mcpInstructions.js";
+import { buildExecCatalogAnnouncement, collectExecCatalogState, } from "../exec/catalogAnnouncement.js";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import * as path from "node:path";
+import { EDIT_TOOL_NAME, WRITE_TOOL_NAME } from "../constants/tools.js";
 import { buildSystemPrompt, formatCompactSummary, getCompactPrompt, } from "../prompts/index.js";
 import { buildPlanModeReminder, buildPlanModeReEntryReminder, buildExitedPlanModeReminder, wrapInSystemReminder, } from "../prompts/planModeReminders.js";
 import { recoverTruncatedJson } from "../utils/stringUtils.js";
-import { AGENT_TOOL_NAME, TASK_CREATE_TOOL_NAME, TASK_GET_TOOL_NAME, TASK_LIST_TOOL_NAME, TASK_UPDATE_TOOL_NAME, } from "../constants/tools.js";
-import { addConsolidatedAbortListener } from "../utils/abortUtils.js";
 import { logger } from "../utils/globalLogger.js";
 import { startInteractionSpan, endInteractionSpan, startLLMRequestSpan, endLLMRequestSpan, resetTracingState, } from "../telemetry/sessionTracing.js";
 import { logOTelEvent } from "../telemetry/events.js";
@@ -115,6 +117,9 @@ export class AIManager {
     get permissionManager() {
         return this.container.get("PermissionManager");
     }
+    get mcpManager() {
+        return this.container.get("McpManager");
+    }
     get planManager() {
         return this.container.get("PlanManager");
     }
@@ -423,6 +428,12 @@ export class AIManager {
             logger?.warn("Compaction already in progress");
             return;
         }
+        // 压缩绑定发起时的会话：LLM fork 期间用户可能已把 agent 原地切到另一会话
+        // （IDE「历史对话」restoreSession / CLI 与插件 `/clear` 都会换 sessionId，
+        // 且均不被 isCompacting 阻拦）。写入阶段前必须复核，否则摘要块会追加进
+        // 切换后会话的内存列表并持久化进其转录文件（spec message-compact「压缩
+        // 期间的会话保护」；PM 缺陷 3478352534577408）。
+        const sessionIdAtStart = this.messageManager.getSessionId();
         // 1. Run PreCompact hooks
         let hookInstructions;
         if (this.hookManager) {
@@ -443,7 +454,7 @@ export class AIManager {
         this.setIsCompacting(true);
         try {
             const modelConfig = this.getModelConfig();
-            const recentChatMessages = convertMessagesForAPI(messagesToCompact, {
+            const recentChatMessages = await convertMessagesForAPI(messagesToCompact, {
                 supportsVision: supportsVision(modelConfig.capabilities),
             });
             const compactPrompt = getCompactPrompt(mergedInstructions);
@@ -470,7 +481,15 @@ export class AIManager {
             const formattedSummary = formatCompactSummary(summaryContent);
             // 7. Build post-compact context restoration
             const enhancedSummary = await this.buildPostCompactContext(formattedSummary);
-            // 8. Execute message reconstruction
+            // 8. Execute message reconstruction — only if the session is still the
+            // one this compaction started for. Abandoning here skips the entire
+            // write phase (summary append, post-compact context restore, plan-mode
+            // reminder, SessionStart/PostCompact hooks); the spent LLM call is not
+            // recovered and the original session simply stays uncompacted.
+            if (this.messageManager.getSessionId() !== sessionIdAtStart) {
+                logger?.warn(`Compaction abandoned: session switched from ${sessionIdAtStart} to ${this.messageManager.getSessionId()} while the summary was being generated`);
+                return;
+            }
             await this.messageManager.compactMessagesAndUpdateSession(enhancedSummary, compactUsage);
             // Clear readFileState after compaction (aligned with Claude Code's
             // compact flow): a file_unchanged stub would otherwise reference Read
@@ -537,7 +556,10 @@ export class AIManager {
         catch (compactError) {
             this.consecutiveCompactionFailures++;
             logger?.error(`Failed to compact messages (${this.consecutiveCompactionFailures} consecutive): ${compactError instanceof Error ? compactError.message : String(compactError)}`);
-            this.messageManager.addErrorBlock(`Failed to compact conversation history: ${compactError instanceof Error ? compactError.message : String(compactError)}. You may encounter context limit issues.`);
+            // 会话已被切走时错误块同样不得写进切换后的会话（与上面的写入放弃同口径）
+            if (this.messageManager.getSessionId() === sessionIdAtStart) {
+                this.messageManager.addErrorBlock(`Failed to compact conversation history: ${compactError instanceof Error ? compactError.message : String(compactError)}. You may encounter context limit issues.`);
+            }
         }
         finally {
             this.setIsCompacting(false);
@@ -565,6 +587,58 @@ export class AIManager {
             autoMemory: autoMemoryOptions,
         });
     }
+    /**
+     * Announce the connected MCP servers' own usage notes in the conversation,
+     * once per server. Not part of the system prompt: this content appears when a
+     * connection happens, and rewriting the system prompt mid-session would drop
+     * the whole cached prefix (see `utils/mcpInstructions.ts`).
+     */
+    maybeAnnounceMcpInstructions() {
+        const mcpManager = this.mcpManager;
+        // Optional for the same reason as `getEffectiveAdditionalDirectories` above:
+        // hosts and tests register partial McpManager doubles, and a missing
+        // usage-notes channel is not a reason to fail the turn. Bailing out matters
+        // more here than elsewhere — reading an absent manager as "no servers left"
+        // would announce every previously announced server as disconnected.
+        if (!mcpManager || typeof mcpManager.getServerInstructions !== "function") {
+            return;
+        }
+        const available = mcpManager.getServerInstructions((toolName) => this.permissionManager?.isToolDenied?.(toolName) === true);
+        const announced = collectAnnouncedServers(this.messageManager.getMessages());
+        const availableNames = new Set(available.map((server) => server.name));
+        const text = buildMcpInstructionsAnnouncement({
+            added: available.filter((server) => !announced.has(server.name)),
+            removed: Array.from(announced).filter((name) => !availableNames.has(name)),
+        });
+        if (!text)
+            return;
+        this.messageManager.addUserMessage({
+            content: wrapInSystemReminder(text),
+            isMeta: true,
+        });
+    }
+    /**
+     * Announce the MCP catalog in the conversation, whenever the pool renders
+     * differently from the last announcement. Keeping it out of `Exec`'s description
+     * is what makes that declaration a constant: a server connecting would otherwise
+     * rewrite `tools[]`, which sits in the cached prefix (see
+     * `exec/catalogAnnouncement.ts`).
+     */
+    maybeAnnounceExecCatalog() {
+        const toolManager = this.toolManager;
+        // Optional for the same reason as `maybeAnnounceMcpInstructions` above, and it
+        // matters just as much here: reading an absent channel as "the catalog is gone"
+        // would tell the model to stop using every tool an earlier catalog listed.
+        if (!toolManager || typeof toolManager.getExecCatalog !== "function")
+            return;
+        const text = buildExecCatalogAnnouncement(collectExecCatalogState(this.messageManager.getMessages()), toolManager.getExecCatalog());
+        if (!text)
+            return;
+        this.messageManager.addUserMessage({
+            content: wrapInSystemReminder(text),
+            isMeta: true,
+        });
+    }
     resolveFilteredTools() {
         const toolsConfig = this.getFilteredToolsConfig();
         const toolNames = new Set(toolsConfig.map((t) => t.function.name));
@@ -599,9 +673,13 @@ export class AIManager {
         forkMessages.push({ role: "user", content: prompt });
         const { toolsConfig, filteredToolPlugins } = this.resolveFilteredTools();
         const systemPrompt = await this.buildMainSystemPrompt(filteredToolPlugins);
-        // Fresh read-state map so Read/Edit state built up inside the fork never
-        // leaks into the main session's dedup and staleness tracking.
-        const forkReadFileState = new Map();
+        // Clone the parent session's read state so the fork inherits the read/dedup
+        // baseline (aligned with Claude Code's cloneFileStateCache): the fork can
+        // Edit a file the parent already read without re-reading it first. The
+        // clone is an independent Map with copied entries, so reads/writes inside
+        // the fork never leak back into the main session's dedup and staleness
+        // tracking.
+        const forkReadFileState = new Map(Array.from(this.readFileState, ([path, entry]) => [path, { ...entry }]));
         let totalUsage;
         let content;
         for (let turn = 0; turn < options.maxTurns; turn++) {
@@ -709,7 +787,7 @@ export class AIManager {
      */
     async runAutoMemoryFork(messages, prompt, options, abortSignal) {
         const modelConfig = this.getModelConfig();
-        const historyMessages = convertMessagesForAPI(messages, {
+        const historyMessages = await convertMessagesForAPI(messages, {
             supportsVision: supportsVision(modelConfig.capabilities),
         });
         // Give the fork a real signal even when the caller has none, so tools
@@ -729,182 +807,6 @@ export class AIManager {
         }
         return result;
     }
-    /**
-     * Fork subagent ("/subtask"): spawn a background agent that inherits the
-     * parent's full conversation context — the same system prompt, tools, model,
-     * and message prefix as the main loop — so the forked request prefix matches
-     * exactly and the prompt cache is reused. The fork runs to completion in the
-     * background via the shared BackgroundTaskManager (visible in /tasks, log at
-     * `os.tmpdir()/wave-subagent-<taskId>.log`); its final response is enqueued
-     * as a task notification carrying the `<result>` tag, so the main agent
-     * picks it up on the next turn and can act on it.
-     *
-     * Recursion is prevented by denying the Agent tool and the Task management
-     * tools (the fork cannot spawn further subagents or mutate the shared task
-     * list), and by honoring the parent's denied rules for everything else.
-     * Gate-approved tools execute locally in the stripped fork context (no
-     * permission prompts), mirroring the other fork paths.
-     *
-     * Returns the background task ID (empty string when no BackgroundTaskManager
-     * is registered, in which case the fork still runs but without task
-     * bookkeeping or notification).
-     */
-    async runForkSubagent(prompt, options, abortSignal) {
-        const modelConfig = this.getModelConfig();
-        // Snapshot the conversation synchronously: the /subtask handler records
-        // the command echo in the transcript after this call, so the fork never
-        // sees its own trigger message duplicated.
-        const historyMessages = convertMessagesForAPI(this.messageManager.getMessages(), { supportsVision: supportsVision(modelConfig.capabilities) });
-        const backgroundTaskManager = this.backgroundTaskManager;
-        const permissionManager = this.permissionManager;
-        const messageQueue = this.container.has("MessageQueue")
-            ? this.container.get("MessageQueue")
-            : undefined;
-        // Combine the caller's signal with an internal one so a task kill
-        // (BackgroundTaskManager.stopTask / cleanup) aborts the in-flight fork.
-        const abortController = new AbortController();
-        let abortCleanup;
-        if (abortSignal) {
-            abortCleanup = addConsolidatedAbortListener(abortSignal, [
-                () => abortController.abort(),
-            ]);
-        }
-        // Recursion prevention: deny the Agent tool and Task tools, then honor the
-        // parent's denied rules for everything else.
-        const deniedTools = new Set([
-            AGENT_TOOL_NAME,
-            TASK_CREATE_TOOL_NAME,
-            TASK_GET_TOOL_NAME,
-            TASK_UPDATE_TOOL_NAME,
-            TASK_LIST_TOOL_NAME,
-        ]);
-        const canUseTool = (name) => {
-            if (deniedTools.has(name))
-                return false;
-            if (permissionManager?.isToolDenied(name))
-                return false;
-            return true;
-        };
-        const deniedToolMessage = "The Agent tool and Task tools are not available in a fork subagent.";
-        // Background task bookkeeping mirrors subagentManager.executeAgent.
-        let taskId = "";
-        let logStream;
-        if (backgroundTaskManager) {
-            taskId = backgroundTaskManager.generateId();
-            const startTime = Date.now();
-            const logPath = path.join(os.tmpdir(), `wave-subagent-${taskId}.log`);
-            logStream = createWriteStream(logPath, { flags: "a" });
-            backgroundTaskManager.addTask({
-                id: taskId,
-                type: "subagent",
-                status: "running",
-                startTime,
-                description: truncateWithMarker(options.description, 1000),
-                stdout: "",
-                stderr: "",
-                outputPath: logPath,
-                onStop: () => {
-                    logStream?.destroy();
-                    logStream = undefined;
-                    abortController.abort();
-                },
-            });
-            logStream.write(`[${new Date().toISOString()}] Fork subagent started: ${options.description}\n`);
-        }
-        const finish = async (status, content) => {
-            if (!backgroundTaskManager || !taskId)
-                return;
-            const task = backgroundTaskManager.getTask(taskId);
-            if (!task)
-                return;
-            const wasAlreadyKilled = task.status === "killed";
-            const endTime = Date.now();
-            if (status === "completed") {
-                task.status = "completed";
-                task.stdout = content;
-                logStream?.write(`[${new Date().toISOString()}] Final response:\n${content}\n`);
-            }
-            else {
-                task.status = "failed";
-                task.stderr = content;
-                logStream?.write(`[${new Date().toISOString()}] Fork subagent failed: ${content}\n`);
-            }
-            task.endTime = endTime;
-            if (task.startTime)
-                task.runtime = endTime - task.startTime;
-            logStream?.end();
-            logStream = undefined;
-            // Skip the notification when the task was already stopped (e.g. by main
-            // agent shutdown) — mirrors subagentManager's wasAlreadyKilled guard.
-            if (!wasAlreadyKilled && messageQueue) {
-                const description = truncateWithMarker(options.description, 1000);
-                const summary = status === "completed"
-                    ? `Subtask "${description}" completed`
-                    : `Subtask "${description}" failed: ${content}`;
-                messageQueue.enqueueNotification(taskNotificationToXml({
-                    type: "task_notification",
-                    taskId,
-                    taskType: "agent",
-                    status,
-                    summary,
-                    ...(status === "completed" && { result: content }),
-                }));
-            }
-        };
-        // Fire-and-forget: the fork runs to completion in the background; the
-        // caller gets the task ID immediately. Tracked in the async work registry
-        // so destroy() drains it before returning (abort via the task's onStop
-        // makes the loop settle).
-        const forkPromise = (async () => {
-            try {
-                const result = await this.runForkLoop(historyMessages, prompt, {
-                    // /subtask aligns with Claude Code's fork subagent
-                    // (forkSubagent.ts:65): a loose upper bound that practically
-                    // never binds.
-                    maxTurns: options.maxTurns ?? 200,
-                    canUseTool,
-                    deniedToolMessage,
-                }, abortController.signal);
-                if (result.usage && this.callbacks?.onUsageAdded) {
-                    this.callbacks.onUsageAdded({
-                        ...result.usage,
-                        model: modelConfig.model,
-                        operation_type: "agent",
-                    });
-                }
-                if (result.content?.trim()) {
-                    await finish("completed", result.content);
-                }
-                else {
-                    await finish("failed", "Fork subagent produced no text response");
-                }
-            }
-            catch (error) {
-                // Abort is the expected exit for a killed task; stopTask has already
-                // marked it "killed", so no notification is sent.
-                if (abortController.signal.aborted) {
-                    const task = backgroundTaskManager?.getTask(taskId);
-                    if (task && task.status === "running") {
-                        task.status = "killed";
-                        task.endTime = Date.now();
-                        if (task.startTime)
-                            task.runtime = task.endTime - task.startTime;
-                    }
-                    logStream?.end();
-                    logStream = undefined;
-                }
-                else {
-                    logger?.error("Fork subagent execution failed:", error);
-                    await finish("failed", error instanceof Error ? error.message : String(error));
-                }
-            }
-            finally {
-                abortCleanup?.();
-            }
-        })();
-        this.asyncWorkRegistry?.track(forkPromise);
-        return taskId;
-    }
     /**
      * Parse a fork tool call's JSON arguments, recovering truncated JSON the
      * same way the main loop does. Unparseable arguments fall back to `{}` and
@@ -983,7 +885,7 @@ export class AIManager {
         const lastMessage = rawMessages[rawMessages.length - 1];
         const hasInProgressMessage = lastMessage?.role === "assistant" &&
             lastMessage.blocks.some((b) => "stage" in b && b.stage === "streaming");
-        const forkMessages = convertMessagesForAPI(hasInProgressMessage ? rawMessages.slice(0, -1) : rawMessages, { supportsVision: supportsVision(modelConfig.capabilities) });
+        const forkMessages = await convertMessagesForAPI(hasInProgressMessage ? rawMessages.slice(0, -1) : rawMessages, { supportsVision: supportsVision(modelConfig.capabilities) });
         // Mirror the main loop's memory injection so the request prefix matches.
         const { prependContent } = await this.messageManager.getMemoryForInjection();
         if (prependContent.trim()) {
@@ -1112,29 +1014,32 @@ ${question}`;
         // 4. Invoked skills context (with token budget, matching Claude Code)
         const POST_COMPACT_SKILLS_TOKEN_BUDGET = 25000;
         const POST_COMPACT_MAX_TOKENS_PER_SKILL = 5000;
-        const invokedSkillNames = this.messageManager.getInvokedSkillNames(10);
-        if (invokedSkillNames.length > 0 && this.skillManager) {
+        const invokedSkills = this.messageManager.getInvokedSkills?.(10) ?? [];
+        if (invokedSkills.length > 0 && this.skillManager) {
             const invokedSkillParts = [];
             let skillsUsedTokens = 0;
-            for (const skillName of invokedSkillNames) {
+            for (const invoked of invokedSkills) {
                 try {
-                    const skill = await this.skillManager.loadSkill(skillName);
-                    if (!skill)
+                    const skill = await this.skillManager.loadSkill(invoked.skillName);
+                    // Re-inject what the model actually saw (already substituted, with the
+                    // base-directory header). Re-render from the file only when that
+                    // record is missing — never hand the model a raw SKILL.md, whose
+                    // `${WAVE_SKILL_DIR}` would be a literal placeholder
+                    // (spec core/message-compact 场景 4).
+                    let skillContent = invoked.content?.trim() ??
+                        (skill ? this.skillManager.renderSkillContent(skill) : undefined);
+                    if (!skillContent)
                         continue;
-                    const contentMatch = skill.content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
-                    let skillContent = contentMatch
-                        ? contentMatch[1].trim()
-                        : skill.content;
                     const maxSkillChars = POST_COMPACT_MAX_TOKENS_PER_SKILL * 4;
                     if (skillContent.length > maxSkillChars) {
-                        skillContent =
-                            skillContent.slice(0, maxSkillChars) + "\n\n...[truncated]...";
+                        skillContent = `${skillContent.slice(0, maxSkillChars)}\n\n...[truncated]...`;
                     }
                     const skillTokens = estimateTokens(skillContent);
                     if (skillsUsedTokens + skillTokens > POST_COMPACT_SKILLS_TOKEN_BUDGET)
                         break;
                     skillsUsedTokens += skillTokens;
-                    invokedSkillParts.push(`\n\n## ${skill.name}\n${skill.description ? `*${skill.description}*\n\n` : ""}\`\`\`\n${skillContent}\n\`\`\``);
+                    const description = skill?.description;
+                    invokedSkillParts.push(`\n\n## ${skill?.name ?? invoked.skillName}\n${description ? `*${description}*\n\n` : ""}\`\`\`\n${skillContent}\n\`\`\``);
                 }
                 catch {
                     // Skip skills that can't be loaded
@@ -1209,9 +1114,22 @@ ${question}`;
     get skillManager() {
         return this.container.get("SkillManager");
     }
+    get liveConfigManager() {
+        return this.container.get("LiveConfigManager");
+    }
     async sendAIMessage(options = {}) {
         const { recursionDepth = 0, model, allowedRules, maxTokens } = options;
         let turnOffset = recursionDepth;
+        // Pin the settings.json-derived configuration for the whole turn: live
+        // reload can land mid-turn and the turn must not see values shift under it
+        // (core/agent-config.md scenario 5). Nested turns (subagent turns inside
+        // their parent's) share the outer snapshot instead of re-capturing it; the
+        // release at the end of the turn mirrors this capture and lives on the
+        // single exit path of this function.
+        const ownsTurnSnapshot = recursionDepth === 0;
+        if (ownsTurnSnapshot) {
+            this.liveConfigManager?.onTurnStart();
+        }
         // Reserve this turn synchronously before any async work. Bumping the
         // generation invalidates any in-flight turn's end-of-turn cleanup, and
         // recording myGeneration lets us skip cleanup if a newer turn (or abort)
@@ -1271,6 +1189,18 @@ ${question}`;
                 this.abortController = abortController;
                 toolAbortController = new AbortController();
                 this.toolAbortController = toolAbortController;
+                // Every tool call in a turn wires its own abort listener onto the
+                // shared tool signal (see toolAbortController.signal in executeTool),
+                // so a fan-out of >=11 parallel calls trips Node's default 10-listener
+                // cap and spams MaxListenersExceededWarning. The signal dies with the
+                // turn (toolAbortController is cleared in the tool loop), so there is
+                // no real leak — raise the cap to silence the noise. Optional chaining
+                // keeps this a no-op on Node >=26, which removed the EventTarget
+                // warning mechanism (and the setMaxListeners method) entirely.
+                const toolSignal = toolAbortController.signal;
+                const turnSignal = abortController.signal;
+                toolSignal.setMaxListeners?.(0);
+                turnSignal.setMaxListeners?.(0);
             }
             else {
                 // Reuse existing controllers
@@ -1299,14 +1229,33 @@ ${question}`;
                             isMeta: true,
                         });
                     }
+                    // Nested memory: a read inside a subtree pulls in that subtree's
+                    // AGENTS.md (persisted as a meta message, aligned with Claude Code's
+                    // nested_memory attachment). Runs with the rules above — before the
+                    // message snapshot below, so the file lands in this request rather
+                    // than the next one. Optional call: hosts and tests register partial
+                    // MessageManager doubles, and absence reads as "nothing triggered".
+                    const nestedMemories = (await this.messageManager.collectNestedMemoryFiles?.()) ?? [];
+                    for (const memory of nestedMemories) {
+                        this.messageManager.addUserMessage({
+                            content: wrapInSystemReminder(`Contents of ${memory.path}:\n\n${memory.content}`),
+                            isMeta: true,
+                        });
+                    }
                     // Pre-request auto-compaction: estimate the context about to be sent
                     // and compact BEFORE issuing the request, so an over-limit request
                     // never goes out. Skipped on fork paths (they use runForkLoop).
                     await this.maybeAutoCompactBeforeRequest(abortController);
+                    // Announce MCP servers' own usage notes (persisted meta message) before
+                    // the snapshot below, so a server that connected mid-session explains
+                    // itself in the request that can already call it. After compaction, so
+                    // the announcement is not the content that just got summarized away.
+                    this.maybeAnnounceMcpInstructions();
+                    this.maybeAnnounceExecCatalog();
                     // Get recent message history
                     const rawMessages = this.messageManager.getMessages();
                     const currentModelConfig = this.getModelConfig();
-                    const recentMessages = convertMessagesForAPI(rawMessages, {
+                    const recentMessages = await convertMessagesForAPI(rawMessages, {
                         supportsVision: supportsVision(currentModelConfig.capabilities),
                     });
                     // Track if assistant message has been created
@@ -1350,6 +1299,19 @@ ${question}`;
                             isMeta: true,
                         });
                     }
+                    // External file-change reminder (aligned with Claude Code's
+                    // changed_files attachment): notify the agent about files it read
+                    // that were since changed on disk by another process — the
+                    // auto-memory extraction fork, an external editor, another session.
+                    // Persisted as a meta message like the task reminder, so it stays in
+                    // the message prefix the auto-memory fork mirrors for cache reuse.
+                    const changedFilesReminder = await getChangedFilesReminder(this.readFileState);
+                    if (changedFilesReminder) {
+                        this.messageManager.addUserMessage({
+                            content: wrapInSystemReminder(changedFilesReminder),
+                            isMeta: true,
+                        });
+                    }
                     // Add streaming callbacks only if streaming is enabled
                     if (this.stream) {
                         callAgentOptions.onContentUpdate = (content) => {
@@ -1746,6 +1708,9 @@ ${question}`;
                 if (myGeneration === this.turnGeneration) {
                     this.setIsLoading(false);
                 }
+                if (ownsTurnSnapshot) {
+                    this.liveConfigManager?.onTurnEnd();
+                }
                 break outer;
             }
         }
@@ -2005,6 +1970,10 @@ ${question}`;
                 images: toolImages,
                 timestamp: Date.now(),
             });
+            // Plan panel refresh (spec: 计划文件更新后刷新计划面板): a successful
+            // Write/Edit of the plan file broadcasts the new content so hosts can
+            // update an already-open plan panel without waiting for ExitPlanMode.
+            await this.notifyPlanFileUpdate(toolName, toolArgs, toolResult.success);
             // Execute PostToolUse hooks after successful tool completion
             await this.executePostToolUseHooks(toolId, toolName, toolArgs, toolResult);
         }
@@ -2023,6 +1992,39 @@ ${question}`;
             });
         }
     }
+    /**
+     * Plan panel refresh (spec: 计划文件更新后刷新计划面板).
+     *
+     * When a successful `Write`/`Edit` targets the current plan file, read it and
+     * emit the full content so hosts can update an already-open plan panel. The
+     * path comparison mirrors the plan-mode allow branch in PermissionManager so
+     * "the write that was allowed" and "the write that refreshes the panel" stay
+     * the same set. The path is only set while plan mode is active, so post-exit
+     * writes can't reach the panels.
+     */
+    async notifyPlanFileUpdate(toolName, toolArgs, success) {
+        if (!success)
+            return;
+        if (toolName !== WRITE_TOOL_NAME && toolName !== EDIT_TOOL_NAME)
+            return;
+        const targetPath = toolArgs.file_path;
+        if (typeof targetPath !== "string" || targetPath.trim() === "")
+            return;
+        const planFilePath = this.container
+            .get("PermissionManager")
+            ?.getPlanFilePath();
+        if (!planFilePath)
+            return;
+        if (path.resolve(targetPath) !== path.resolve(planFilePath))
+            return;
+        try {
+            const content = await readFile(planFilePath, "utf8");
+            this.callbacks?.onPlanFileUpdated?.(content);
+        }
+        catch (error) {
+            logger?.warn(`Failed to read plan file for panel refresh: ${planFilePath}`, error);
+        }
+    }
     /**
      * Execute PreToolUse hooks before tool execution
      * Returns true if hooks allow tool execution, false if blocked

package/dist/managers/backgroundTaskManager.js

@@ -3,6 +3,7 @@ import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
 import { stripAnsiColors } from "../utils/stringUtils.js";
+import { readTailTextSync } from "../utils/fileUtils.js";
 import { WindowsStreamDecoder } from "../utils/encoding.js";
 import { logger } from "../utils/globalLogger.js";
 import { resolveShellPath } from "../utils/shellResolver.js";
@@ -386,6 +387,19 @@ export class BackgroundTaskManager {
         }
         let stdout = task.stdout;
         let stderr = task.stderr;
+        // A running agent task keeps its tool-call log in `outputPath` while
+        // `stdout` stays empty until the terminal snapshot fills it (see
+        // SubagentManager) — so /tasks shows an empty output block for the whole
+        // run. Fall back to the log file tail to surface live progress.
+        //
+        // Only when the in-memory buffer is empty, and only while running: shell
+        // tasks accumulate stdout chunk by chunk (that buffer is authoritative and
+        // identical to the file), so reading the file on top of it would duplicate
+        // the text; once a task reaches a terminal state the snapshot already
+        // carries the final output.
+        if (!stdout && task.status === "running" && task.outputPath) {
+            stdout = stripAnsiColors(readTailTextSync(task.outputPath));
+        }
         // Apply regex filter if provided
         if (filter) {
             try {

package/dist/managers/bashModeManager.d.ts

@@ -0,0 +1,33 @@
+import { Container } from "../utils/container.js";
+export interface BashModeManagerOptions {
+    workdir: string;
+}
+export interface CommandExecutionResult {
+    exitCode: number;
+    output: string;
+}
+/**
+ * Bash mode (`!command`) execution. The command is surfaced as a user-message
+ * tool block (name: BASH_TOOL_NAME) — the same rendering as fork-skill / `/plan`
+ * outputs (⎿ prefix + markdown, result enters the model context via the
+ * generic `<local-command-stdout>` rule) — and executed through the shared
+ * bash tool engine (shell resolution, CWD tracking, timeout, output handling).
+ */
+export declare class BashModeManager {
+    private container;
+    private workdir;
+    isCommandRunning: boolean;
+    private abortController;
+    onCommandRunningChange?: (running: boolean) => void;
+    constructor(container: Container, options: BashModeManagerOptions);
+    private get messageManager();
+    /**
+     * Merged env (OS env overlaid with this session's settings snapshot) for
+     * bash-mode subprocesses, so settings `env` vars reach them without
+     * polluting other sessions in one `wave --stdio` process.
+     */
+    private get sessionEnv();
+    private setCommandRunning;
+    executeCommand(command: string): Promise<number>;
+    abortCommand(): void;
+}