wave-agent-sdk 1.0.5 → 1.0.6

package/dist/agent.d.ts

@@ -14,7 +14,6 @@ export declare class Agent {
     private permissionManager;
     private planManager;
     private subagentManager;
-    private forkedAgentManager;
     private slashCommandManager;
     private pluginManager;
     private skillManager;
@@ -24,6 +23,7 @@ export declare class Agent {
     private messageQueue;
     private dispatchPromise;
     private isAborting;
+    private dispatchAborted;
     private memoryRuleManager;
     private liveConfigManager;
     private taskManager;
@@ -269,6 +269,28 @@ export declare class Agent {
      * @returns Promise that resolves to the AI's answer
      */
     askBtw(question: string, abortSignal?: AbortSignal, onContent?: (content: string) => void, onReasoning?: (content: string) => void): Promise<string>;
+    /**
+     * Start a fork subagent in the background (the "/subtask" command path).
+     *
+     * The fork inherits the parent's full conversation context — same system
+     * prompt, tools, model, and message prefix — so the prompt cache is reused,
+     * then works independently in the background. On completion its final
+     * response is delivered back to the main conversation as a task notification
+     * carrying the `<result>` tag. Recursion is prevented inside the fork (the
+     * Agent tool and Task tools are denied).
+     *
+     * @param prompt - The task description for the fork subagent
+     * @param options - Background task label and optional loose turn bound
+     * @param options.description - Display label for the background task
+     * @param options.maxTurns - Loose turn bound (defaults to 200, aligned with
+     * Claude Code's fork subagent)
+     * @param abortSignal - Optional signal to abort the fork
+     * @returns Promise that resolves to the background task ID
+     */
+    forkSubagent(prompt: string, options: {
+        description: string;
+        maxTurns?: number;
+    }, abortSignal?: AbortSignal): Promise<string>;
     /**
      * Send a message to the AI agent with optional images
      *

package/dist/agent.js

@@ -54,6 +54,7 @@ export class Agent {
         this.bangManager = null;
         this.dispatchPromise = null; // Track current dispatch for teardown
         this.isAborting = false; // Guard: prevents tryDispatch from firing during abortMessage
+        this.dispatchAborted = false; // Set on abort while a dispatch is running: suppress the .finally re-check so preserved notifications don't get dispatched after abort
         this.sessionStartTime = Date.now();
         const { logger, workdir, systemPrompt, stream = true } = options;
         // Set working directory early as we need it for loading configuration
@@ -106,7 +107,6 @@ export class Agent {
         this.toolManager = this.container.get("ToolManager");
         this.liveConfigManager = this.container.get("LiveConfigManager");
         this.subagentManager = this.container.get("SubagentManager");
-        this.forkedAgentManager = this.container.get("ForkedAgentManager");
         this.aiManager = this.container.get("AIManager");
         this.slashCommandManager = this.container.get("SlashCommandManager");
         this.pluginManager = this.container.get("PluginManager");
@@ -265,6 +265,8 @@ export class Agent {
     tryDispatch() {
         if (this.isAborting)
             return; // Suppress dispatch during abort to prevent queued notifications from being dispatched as a side-effect
+        if (this.dispatchAborted)
+            return; // Aborted mid-dispatch: don't start a new dispatch (the user interrupted this turn)
         if (this.messageQueue.state !== "idle")
             return;
         if (!this.messageQueue.hasPending())
@@ -279,7 +281,10 @@ export class Agent {
             .finally(() => {
             this.messageQueue.transitionTo("idle");
             this.dispatchPromise = null;
-            this.tryDispatch(); // Re-check after processing
+            if (!this.dispatchAborted) {
+                this.tryDispatch(); // Re-check after processing
+            }
+            this.dispatchAborted = false;
         });
     }
     /**
@@ -571,6 +576,12 @@ export class Agent {
         // from dispatching preserved notifications as a new AI turn during the abort.
         this.isAborting = true;
         try {
+            // If a queued dispatch is in flight (e.g. a notification turn was being
+            // processed), remember the abort so the .finally re-check won't start a
+            // new dispatch with the preserved notifications right after aborting.
+            if (this.dispatchPromise) {
+                this.dispatchAborted = true;
+            }
             if (this.aiManager.isLoading || this.isCommandRunning) {
                 // Clear user-facing queue items first to prevent processQueuedMessage
                 // from dequeuing when abortAIMessage triggers onLoadingChange(false).
@@ -684,8 +695,6 @@ export class Agent {
         }
         // Cleanup subagent manager
         this.subagentManager.cleanup();
-        // Cleanup forked agent manager
-        await this.forkedAgentManager.cleanup();
         // Drain an in-flight auto-memory extraction fork so the process doesn't
         // exit mid-extraction
         try {
@@ -732,6 +741,27 @@ export class Agent {
         const result = await this.aiManager.runBtwFork(question, abortSignal, onContent, onReasoning);
         return result.content ?? result.error ?? "No response received";
     }
+    /**
+     * Start a fork subagent in the background (the "/subtask" command path).
+     *
+     * The fork inherits the parent's full conversation context — same system
+     * prompt, tools, model, and message prefix — so the prompt cache is reused,
+     * then works independently in the background. On completion its final
+     * response is delivered back to the main conversation as a task notification
+     * carrying the `<result>` tag. Recursion is prevented inside the fork (the
+     * Agent tool and Task tools are denied).
+     *
+     * @param prompt - The task description for the fork subagent
+     * @param options - Background task label and optional loose turn bound
+     * @param options.description - Display label for the background task
+     * @param options.maxTurns - Loose turn bound (defaults to 200, aligned with
+     * Claude Code's fork subagent)
+     * @param abortSignal - Optional signal to abort the fork
+     * @returns Promise that resolves to the background task ID
+     */
+    async forkSubagent(prompt, options, abortSignal) {
+        return this.aiManager.runForkSubagent(prompt, options, abortSignal);
+    }
     /**
      * Send a message to the AI agent with optional images
      *

package/dist/managers/aiManager.d.ts

@@ -40,6 +40,8 @@ export declare class AIManager {
     private modelOverride?;
     private _onCwdChange?;
     private originalWorkdir;
+    /** Pending cwd-recovery notice (set when getWorkdir() auto-recovers), consumed by tools */
+    private pendingCwdRecovery;
     private consecutiveCompactionFailures;
     private readonly maxTurns?;
     /** Tracks file mtime/hash at read time for staleness detection on Edit/Write */
@@ -77,6 +79,16 @@ export declare class AIManager {
     getAutoMemoryEnabled(): boolean;
     getWorktreeBaseRef(): "fresh" | "head";
     getWorkdir(): string;
+    /**
+     * Consume a pending cwd-recovery notice (if any). After the session
+     * workdir was auto-recovered because the previous directory disappeared,
+     * the first tool that calls this surfaces the notice to the model.
+     * Returns null when no recovery is pending.
+     */
+    consumeCwdRecovery(): {
+        from: string;
+        to: string;
+    } | null;
     getOriginalWorkdir(): string;
     /**
      * Update the working directory mid-session (e.g., when entering/exiting a worktree).
@@ -155,6 +167,30 @@ export declare class AIManager {
         deniedToolMessage?: string;
         maxTurns?: number;
     }, abortSignal?: AbortSignal): Promise<ForkLoopResult>;
+    /**
+     * 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).
+     */
+    runForkSubagent(prompt: string, options: {
+        description: string;
+        maxTurns?: number;
+    }, abortSignal?: AbortSignal): Promise<string>;
     /**
      * Parse a fork tool call's JSON arguments, recovering truncated JSON the
      * same way the main loop does. Unparseable arguments fall back to `{}` and

package/dist/managers/aiManager.js

@@ -1,14 +1,18 @@
 import * as aiService from "../services/aiService.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { supportsVision } from "../utils/modelCapabilities.js";
-import { parseTaskNotificationXml } from "../utils/notificationXml.js";
+import { parseTaskNotificationXml, taskNotificationToXml, } from "../utils/notificationXml.js";
 import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
 import { estimateTokens } from "../utils/tokenEstimate.js";
 import { getTaskReminderTurnCounts, maybeInjectTaskReminder, TASK_REMINDER_CONFIG, } from "../utils/taskReminder.js";
-import { existsSync } from "node:fs";
+import { createWriteStream, existsSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 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";
@@ -60,6 +64,8 @@ export class AIManager {
         this.turnGeneration = 0; // Guards against concurrent sendAIMessage turns
         this.abortController = null;
         this.toolAbortController = null;
+        /** Pending cwd-recovery notice (set when getWorkdir() auto-recovers), consumed by tools */
+        this.pendingCwdRecovery = null;
         this.consecutiveCompactionFailures = 0;
         /** Tracks file mtime/hash at read time for staleness detection on Edit/Write */
         this.readFileState = new Map();
@@ -151,7 +157,45 @@ export class AIManager {
         return this.configurationService.resolveWorktreeBaseRef();
     }
     getWorkdir() {
-        return this.container.get("Workdir") ?? process.cwd();
+        const workdir = this.container.get("Workdir") ?? process.cwd();
+        if (existsSync(workdir)) {
+            return workdir;
+        }
+        // The stored workdir no longer exists — e.g. the current worktree
+        // directory was removed manually with `git worktree remove` outside
+        // wave's exit flow. Node spawn() chdirs to `cwd` before spawning, so
+        // every tool that spawns a subprocess (Bash, Grep, background tasks)
+        // would fail with ENOENT and cripple the session. Recover to the
+        // original workdir (main repo) so the session keeps working.
+        if (!existsSync(this.originalWorkdir)) {
+            // No valid fallback — keep the stale value (sessions started in a
+            // directory that was deleted since cannot recover to anything real).
+            return workdir;
+        }
+        this.pendingCwdRecovery = { from: workdir, to: this.originalWorkdir };
+        // If the removed directory was this session's worktree, drop the stale
+        // worktree session state so ExitWorktree no-ops and EnterWorktree can
+        // start a fresh session.
+        const worktreeSession = this.getWorktreeSession();
+        if (worktreeSession &&
+            path.resolve(worktreeSession.worktreePath) === path.resolve(workdir)) {
+            this.setWorktreeSession(null);
+        }
+        logger.warn(`Working directory ${workdir} no longer exists; recovered session workdir to ${this.originalWorkdir}`);
+        this.container.register("Workdir", this.originalWorkdir);
+        this._onCwdChange?.(this.originalWorkdir);
+        return this.originalWorkdir;
+    }
+    /**
+     * Consume a pending cwd-recovery notice (if any). After the session
+     * workdir was auto-recovered because the previous directory disappeared,
+     * the first tool that calls this surfaces the notice to the model.
+     * Returns null when no recovery is pending.
+     */
+    consumeCwdRecovery() {
+        const recovery = this.pendingCwdRecovery;
+        this.pendingCwdRecovery = null;
+        return recovery;
     }
     getOriginalWorkdir() {
         return this.originalWorkdir;
@@ -628,6 +672,179 @@ 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.
+        (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?.();
+            }
+        })();
+        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
@@ -1348,9 +1565,15 @@ ${question}`;
                 await this.messageManager.saveSession();
                 // Clear temporary rules
                 this.permissionManager?.clearTemporaryRules();
-                // Clear abort controllers
-                this.abortController = null;
-                this.toolAbortController = null;
+                // Clear abort controllers (only if we still own them — a concurrent
+                // turn may have already registered its own controller, and clearing
+                // it would orphan that turn and make it uninterruptible)
+                if (this.abortController === abortController) {
+                    this.abortController = null;
+                }
+                if (this.toolAbortController === toolAbortController) {
+                    this.toolAbortController = null;
+                }
                 // Execute Stop/SubagentStop hooks only if the operation was not aborted
                 const isCurrentlyAborted = abortController.signal.aborted || toolAbortController.signal.aborted;
                 if (!isCurrentlyAborted) {
@@ -1373,11 +1596,19 @@ ${question}`;
                     }
                 }
                 // Inject pending notifications from background tasks (after Stop hooks,
-                // aligned with Claude Code which fires Stop hooks unconditionally)
+                // aligned with Claude Code which fires Stop hooks unconditionally).
+                // Skip injection when this turn was aborted: folding a pending
+                // notification in would restart the loop and resurrect the aborted
+                // turn — if a concurrent sendMessage is already running (e.g. the
+                // queue's "send now" button), it would spawn a second, orphaned,
+                // uninterruptible agent loop. The notification stays queued for the
+                // next turn.
                 const messageQueue = this.container.has("MessageQueue")
                     ? this.container.get("MessageQueue")
                     : undefined;
-                if (messageQueue && messageQueue.hasNotifications()) {
+                if (messageQueue &&
+                    messageQueue.hasNotifications() &&
+                    !isCurrentlyAborted) {
                     const notifications = messageQueue.drainNotifications();
                     for (const notification of notifications) {
                         const block = parseTaskNotificationXml(notification);
@@ -1388,6 +1619,7 @@ ${question}`;
                                 status: block.status,
                                 summary: block.summary,
                                 outputFile: block.outputFile,
+                                result: block.result,
                             });
                         }
                     }

package/dist/managers/messageManager.d.ts

@@ -13,13 +13,11 @@ export interface MessageManagerCallbacks {
     onAssistantContentUpdated?: (params: {
         messageId: string;
         chunk: string;
-        accumulated: string;
         stage: "streaming" | "end";
     }) => void;
     onAssistantReasoningUpdated?: (params: {
         messageId: string;
         chunk: string;
-        accumulated: string;
         stage: "streaming" | "end";
     }) => void;
     onToolBlockUpdated?: (params: ToolBlockUpdateCallbackParams) => void;
@@ -180,7 +178,7 @@ export declare class MessageManager {
     /**
      * Update the current assistant message content during streaming
      * This method updates the last assistant message's content without creating a new message
-     * FR-001: Tracks and provides both chunk (new content) and accumulated (total content)
+     * FR-001: Tracks and provides chunk (new content since last update)
      */
     updateCurrentMessageContent(newAccumulatedContent: string): void;
     /**

package/dist/managers/messageManager.js

@@ -366,6 +366,16 @@ export class MessageManager {
     async compactMessagesAndUpdateSession(compactedContent, usage) {
         // Get last 2 API rounds to preserve (structurally safe boundary)
         const lastThreeMessages = getLastApiRounds(this.messages, 2);
+        // The turn that triggered compaction has already finished streaming, so
+        // finalize any still-'streaming' text/reasoning blocks on the preserved
+        // last assistant message. Otherwise hosts that pull a full snapshot after
+        // compaction (or the loop's own finalizeStreamingBlocks, which no-ops once
+        // a plan-mode reminder is appended) would keep showing the streaming dot.
+        const lastPreserved = lastThreeMessages[lastThreeMessages.length - 1];
+        if (lastPreserved && lastPreserved.role === "assistant") {
+            this.finalizeStreamingBlock(lastPreserved, "text");
+            this.finalizeStreamingBlock(lastPreserved, "reasoning");
+        }
         // Create compacted message
         const compactMessage = {
             id: generateMessageId(),
@@ -526,7 +536,6 @@ export class MessageManager {
         const callbackParams = {
             messageId: lastMessage.id,
             chunk: "",
-            accumulated: block.content,
             stage: "end",
         };
         if (type === "text") {
@@ -540,7 +549,7 @@ export class MessageManager {
     /**
      * Update the current assistant message content during streaming
      * This method updates the last assistant message's content without creating a new message
-     * FR-001: Tracks and provides both chunk (new content) and accumulated (total content)
+     * FR-001: Tracks and provides chunk (new content since last update)
      */
     updateCurrentMessageContent(newAccumulatedContent) {
         if (this.messages.length === 0)
@@ -573,11 +582,10 @@ export class MessageManager {
                 stage: "streaming",
             });
         }
-        // FR-001: Trigger callbacks with chunk and accumulated content
+        // FR-001: Trigger callbacks with chunk delta and stage
         this.callbacks.onAssistantContentUpdated?.({
             messageId: lastMessage.id,
             chunk,
-            accumulated: newAccumulatedContent,
             stage: "streaming",
         });
         // Note: Subagent-specific callbacks are now handled by SubagentManager
@@ -620,11 +628,10 @@ export class MessageManager {
                 startTime: Date.now(),
             });
         }
-        // Trigger callbacks with chunk and accumulated reasoning content
+        // Trigger callbacks with chunk delta and stage
         this.callbacks.onAssistantReasoningUpdated?.({
             messageId: lastMessage.id,
             chunk,
-            accumulated: newAccumulatedReasoning,
             stage: "streaming",
         });
     }

package/dist/managers/slashCommandManager.js

@@ -14,6 +14,34 @@ export class SlashCommandManager {
     }
     initialize() {
         this.loadCustomCommands();
+        // Builtin /subtask: manual fork subagent (aligned with Claude Code's
+        // /subtask — inherits the parent's full context, runs in the background,
+        // result returns to the main conversation via a task notification).
+        this.registerCommand({
+            id: "subtask",
+            name: "subtask",
+            description: "Start a fork subagent with the current conversation context in the background",
+            handler: async (args, signal) => {
+                const taskDescription = args?.trim();
+                if (!taskDescription) {
+                    this.messageManager.addErrorBlock("Usage: /subtask <task description>");
+                    return;
+                }
+                try {
+                    // The fork snapshots its context synchronously on entry, so the
+                    // transcript echo below never duplicates the prompt inside the fork.
+                    await this.aiManager.runForkSubagent(taskDescription, { description: taskDescription }, signal);
+                    this.messageManager.addUserMessage({
+                        content: `/subtask ${taskDescription}`,
+                    });
+                }
+                catch (error) {
+                    this.aiManager.setIsLoading(false);
+                    logger?.error("Failed to execute /subtask:", error);
+                    this.messageManager.addErrorBlock(`Failed to execute /subtask: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+        });
         // Listen for skill refreshes and update skill commands
         const skillManager = this.container.get("SkillManager");
         if (skillManager) {

package/dist/managers/subagentManager.d.ts

@@ -19,7 +19,6 @@ export interface SubagentManagerCallbacks {
         subagentId: string;
         messageId: string;
         chunk: string;
-        accumulated: string;
         stage: "streaming" | "end";
     }) => void;
     /** Triggered during subagent reasoning streaming updates */
@@ -27,7 +26,6 @@ export interface SubagentManagerCallbacks {
         subagentId: string;
         messageId: string;
         chunk: string;
-        accumulated: string;
         stage: "streaming" | "end";
     }) => void;
     /** Triggered when subagent tool block is updated */

package/dist/telemetry/instrumentation.d.ts

@@ -5,7 +5,7 @@
  * and graceful shutdown for Wave's OpenTelemetry integration.
  */
 import type { TelemetryConfig } from "../types/telemetry.js";
-import type { SpanExporter, ReadableSpan } from "@opentelemetry/sdk-trace-node";
+import type { SpanExporter, ReadableSpan } from "@opentelemetry/sdk-trace-base";
 import type { LogRecordExporter, ReadableLogRecord } from "@opentelemetry/sdk-logs";
 /**
  * Resolve the full TelemetryConfig from env vars + settings.json.