wave-agent-sdk 1.0.0 → 1.0.2

package/dist/services/autoMemoryService.js

@@ -3,6 +3,14 @@ import * as fs from "node:fs/promises";
 import { logger } from "../utils/globalLogger.js";
 import { isPathInside } from "../utils/pathSafety.js";
 import { buildAutoMemoryExtractionPrompt } from "../prompts/autoMemoryExtraction.js";
+import { READ_ONLY_COMMANDS, splitBashCommand, hasWriteRedirections, hasCommandSubstitution, hasProcessSubstitution, hasSedInPlace, isDangerousFind, } from "../utils/bashParser.js";
+/**
+ * Message fed back to the extraction fork when the model requests a tool
+ * outside the allowed set (Bash rm, MCP tools, Agent, out-of-dir writes...).
+ */
+const DENIED_TOOL_MESSAGE = "This tool call was denied during auto-memory extraction. Available tools: " +
+    "Read, Grep, Glob, read-only Bash commands, and Write/Edit inside the " +
+    "memory directory only.";
 /**
  * Service responsible for managing the auto-memory background agent lifecycle.
  * Extracts and updates persistent project-level memory from conversation history.
@@ -12,12 +20,14 @@ export class AutoMemoryService {
         this.container = container;
         this.lastMemoryMessageId = null;
         this.turnsSinceLastExtraction = 0;
+        this.extractionInProgress = false;
+        this.pendingExtraction = null;
     }
     get messageManager() {
         return this.container.get("MessageManager");
     }
-    get forkedAgentManager() {
-        return this.container.get("ForkedAgentManager");
+    get aiManager() {
+        return this.container.get("AIManager");
     }
     get memoryService() {
         return this.container.get("MemoryService");
@@ -54,7 +64,12 @@ export class AutoMemoryService {
         const recentMessages = messages.slice(startIndex);
         const hasManualMemoryWrite = recentMessages.some((m) => m.role === "assistant" &&
             m.blocks.some((b) => {
-                if (b.type === "tool" && (b.name === "Write" || b.name === "Edit")) {
+                if (b.type === "tool" &&
+                    (b.name === "Write" || b.name === "Edit") &&
+                    // Only a successful manual write counts as a manual update. A
+                    // denied/failed write didn't touch memory, so the extraction fork
+                    // must still run or the information is lost.
+                    b.success !== false) {
                     try {
                         const params = b.parameters ? JSON.parse(b.parameters) : null;
                         const filePath = params?.file_path || params?.path;
@@ -77,20 +92,51 @@ export class AutoMemoryService {
             this.turnsSinceLastExtraction = 0;
             return;
         }
-        // 3. Trigger background extraction using a forked subagent
-        try {
-            await this.runExtraction(workdir, messages);
-            this.lastMemoryMessageId = messages[messages.length - 1].id || null;
-            this.turnsSinceLastExtraction = 0;
-        }
-        catch (error) {
-            logger.error("Auto-memory extraction failed to trigger:", error);
+        // 3. Concurrency guard: if an extraction is already in flight, skip this
+        // turn. turnsSinceLastExtraction is intentionally NOT reset so the next
+        // eligible turn retriggers the extraction.
+        if (this.extractionInProgress) {
+            logger.debug("Skipping auto-memory extraction: another extraction is still in progress.");
+            return;
         }
+        // 4. Trigger the perfect-fork extraction fire-and-forget. The message
+        // snapshot and new-message count are computed now; lastMemoryMessageId
+        // advances at trigger time so the next extraction starts from a later
+        // window even while this one runs.
+        const lastExtractedIndex = this.lastMemoryMessageId
+            ? messages.findIndex((m) => m.id === this.lastMemoryMessageId)
+            : -1;
+        const newMessageCount = lastExtractedIndex === -1
+            ? messages.length
+            : messages.length - 1 - lastExtractedIndex;
+        this.turnsSinceLastExtraction = 0;
+        this.lastMemoryMessageId = messages[messages.length - 1].id || null;
+        this.extractionInProgress = true;
+        const extraction = this.runExtraction(workdir, messages, newMessageCount)
+            .catch((error) => {
+            logger.error("Auto-memory extraction failed:", error);
+        })
+            .finally(() => {
+            this.extractionInProgress = false;
+            this.pendingExtraction = null;
+        });
+        this.pendingExtraction = extraction;
+    }
+    /**
+     * Wait for an in-flight extraction to settle. Called from Agent.dispose so
+     * the process doesn't exit while the extraction fork is mid-flight.
+     */
+    async drain() {
+        await this.pendingExtraction;
     }
     /**
-     * Initialize and execute the background extraction subagent.
+     * Initialize and execute the extraction in a perfect fork: same system
+     * prompt, tools, model, and message prefix as the main conversation, so the
+     * prompt cache is reused. A tool gate confines the fork to read-only
+     * inspection and memory-directory writes. Runs in-process; callers treat it
+     * as fire-and-forget.
      */
-    async runExtraction(workdir, messages) {
+    async runExtraction(workdir, messages, newMessageCount) {
         const memoryDir = this.memoryService.getAutoMemoryDirectory(workdir);
         // Ensure memory directory exists before starting
         await this.memoryService.ensureAutoMemoryDirectory(workdir);
@@ -106,30 +152,72 @@ export class AutoMemoryService {
         catch {
             // Ignore if directory doesn't exist yet
         }
-        // Calculate how many new messages to analyze
-        let newMessageCount = messages.length;
-        if (this.lastMemoryMessageId) {
-            const lastIndex = messages.findIndex((m) => m.id === this.lastMemoryMessageId);
-            if (lastIndex !== -1) {
-                newMessageCount = messages.length - 1 - lastIndex;
-            }
-        }
         const prompt = buildAutoMemoryExtractionPrompt(newMessageCount, existingMemoriesManifest);
-        // Execute the forked agent in background (fire-and-forget, decoupled from BackgroundTaskManager)
-        await this.forkedAgentManager.forkAndExecute("general-purpose", messages, {
-            description: "Auto-memory extraction background agent",
-            allowedTools: [
-                "Read",
-                "Glob",
-                "Grep",
-                `Write(${memoryDir}/**/*)`,
-                `Edit(${memoryDir}/**/*)`,
-                `Bash(rm ${memoryDir}/**/*)`,
-            ],
-            model: "fastModel", // Use fast model for background tasks to reduce latency and cost
-            permissionModeOverride: "dontAsk", // Auto-deny out-of-scope writes without prompting user
+        await this.aiManager.runAutoMemoryFork(messages, `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`, {
             maxTurns: 5, // Limit turns to prevent verification rabbit-holes
-        }, `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`);
-        logger.debug("Auto-memory extraction started in background.");
+            canUseTool: (name, args) => this.isAllowedForkTool(name, args, memoryDir, workdir),
+            deniedToolMessage: DENIED_TOOL_MESSAGE,
+        });
+        logger.debug("Auto-memory extraction completed.");
+    }
+    /**
+     * Tool gate for the extraction fork: Read/Grep/Glob are always allowed;
+     * Write/Edit only when the target path is inside the memory directory; Bash
+     * only for read-only commands (aligned with the permission manager's
+     * read-only bash classification). Everything else — Bash rm, MCP tools,
+     * Agent, out-of-dir writes — is denied.
+     */
+    isAllowedForkTool(name, args, memoryDir, workdir) {
+        if (name === "Read" || name === "Grep" || name === "Glob") {
+            return true;
+        }
+        if (name === "Write" || name === "Edit") {
+            const filePath = args.file_path ?? args.path;
+            if (typeof filePath !== "string" || !filePath)
+                return false;
+            const absolutePath = path.isAbsolute(filePath)
+                ? filePath
+                : path.resolve(workdir, filePath);
+            return isPathInside(absolutePath, memoryDir);
+        }
+        if (name === "Bash") {
+            const command = typeof args.command === "string" ? args.command : "";
+            return this.isReadOnlyBashCommand(command);
+        }
+        return false;
+    }
+    /**
+     * A bash command is read-only when every part is a READ_ONLY_COMMANDS entry
+     * without write redirections, command/process substitution, sed -i, or
+     * dangerous find flags. Mirrors PermissionManager.isAutoAllowedPart.
+     */
+    isReadOnlyBashCommand(command) {
+        if (!command.trim())
+            return false;
+        if (hasWriteRedirections(command))
+            return false;
+        if (hasCommandSubstitution(command))
+            return false;
+        if (hasProcessSubstitution(command))
+            return false;
+        if (hasSedInPlace(command))
+            return false;
+        const parts = splitBashCommand(command);
+        if (parts.length === 0)
+            return false;
+        return parts.every((part) => {
+            const trimmed = part.trim();
+            if (!trimmed)
+                return true;
+            const commandMatch = trimmed.match(/^(\w+)(\s+.*)?$/);
+            if (!commandMatch)
+                return false;
+            const cmd = commandMatch[1];
+            if (!READ_ONLY_COMMANDS.includes(cmd))
+                return false;
+            if (cmd === "find" && isDangerousFind(part))
+                return false;
+            return true;
+        });
     }
 }

package/dist/services/configurationService.js

@@ -488,14 +488,27 @@ export class ConfigurationService {
         if (fastModelSource && fastModelSource.options) {
             baseConfig.fastModelOptions = fastModelSource.options;
         }
+        // Resolve fast-model disable-thinking params from models[fastModel].disableThinkingOptions
+        const fastModelDisableThinking = fastModelSource && fastModelSource.disableThinkingOptions
+            ? fastModelSource.disableThinkingOptions
+            : undefined;
+        if (fastModelDisableThinking) {
+            baseConfig.disableThinkingOptions = fastModelDisableThinking;
+        }
         // Merge model-specific settings from configuration
         const modelSpecificConfig = resolvedAgentModel &&
             this.currentConfiguration?.models?.[resolvedAgentModel];
         if (modelSpecificConfig) {
-            return {
+            const resolved = {
                 ...baseConfig,
                 ...modelSpecificConfig,
             };
+            // Re-apply after the spread so the agent model's own
+            // disableThinkingOptions cannot clobber the fast-model value.
+            if (fastModelDisableThinking) {
+                resolved.disableThinkingOptions = fastModelDisableThinking;
+            }
+            return resolved;
         }
         return baseConfig;
     }

package/dist/services/session.d.ts

@@ -139,6 +139,19 @@ export declare function cleanupExpiredSessionsFromJsonl(workdir: string): Promis
  * Clean up empty project directories in the session directory
  */
 export declare function cleanupEmptyProjectDirectories(): Promise<void>;
+/**
+ * Clean up "ghost" session files that contain only meta messages
+ * (isMeta: true) — e.g. sessions where a SessionStart hook injected a
+ * system-reminder but no real user/assistant message was ever sent.
+ *
+ * Such sessions are no longer created thanks to lazy materialization in
+ * saveSession(); this one-time sweep removes files that predate that change
+ * so they stop showing up as "0 tokens / No content" entries in the resume
+ * list.
+ *
+ * @returns Promise that resolves to the number of files deleted
+ */
+export declare function cleanupMetaOnlySessions(): Promise<number>;
 /**
  * Check if a session exists in JSONL storage (new approach)
  *

package/dist/services/session.js

@@ -481,6 +481,70 @@ export async function cleanupEmptyProjectDirectories() {
         // Ignore errors if base directory doesn't exist or can't be accessed
     }
 }
+/**
+ * Clean up "ghost" session files that contain only meta messages
+ * (isMeta: true) — e.g. sessions where a SessionStart hook injected a
+ * system-reminder but no real user/assistant message was ever sent.
+ *
+ * Such sessions are no longer created thanks to lazy materialization in
+ * saveSession(); this one-time sweep removes files that predate that change
+ * so they stop showing up as "0 tokens / No content" entries in the resume
+ * list.
+ *
+ * @returns Promise that resolves to the number of files deleted
+ */
+export async function cleanupMetaOnlySessions() {
+    // Do not perform cleanup operations in test environment
+    if (process.env.NODE_ENV === "test") {
+        return 0;
+    }
+    let deletedCount = 0;
+    try {
+        const projectDirs = await fs.readdir(SESSION_DIR);
+        for (const projectDirName of projectDirs) {
+            const projectPath = join(SESSION_DIR, projectDirName);
+            try {
+                const stat = await fs.stat(projectPath);
+                if (!stat.isDirectory()) {
+                    continue;
+                }
+                const files = await fs.readdir(projectPath);
+                for (const file of files) {
+                    if (!file.endsWith(".jsonl")) {
+                        continue;
+                    }
+                    const filePath = join(projectPath, file);
+                    try {
+                        // Fast path: a file whose last message is not meta contains a
+                        // real message, so it can never be meta-only.
+                        const jsonlHandler = new JsonlHandler();
+                        const lastMessage = await jsonlHandler.getLastMessage(filePath);
+                        if (!lastMessage?.isMeta) {
+                            continue;
+                        }
+                        const messages = await jsonlHandler.read(filePath);
+                        if (messages.length > 0 && messages.every((m) => m.isMeta)) {
+                            await fs.unlink(filePath);
+                            deletedCount++;
+                        }
+                    }
+                    catch {
+                        // Skip corrupted or unreadable files
+                        continue;
+                    }
+                }
+            }
+            catch {
+                // Skip directories we can't access
+                continue;
+            }
+        }
+    }
+    catch {
+        // Ignore errors if base directory doesn't exist or can't be accessed
+    }
+    return deletedCount;
+}
 /**
  * Check if a session exists in JSONL storage (new approach)
  *

package/dist/types/agent.d.ts

@@ -98,6 +98,4 @@ export interface AgentCallbacks extends MessageManagerCallbacks, BackgroundTaskM
     onCommandRunningChange?: (running: boolean) => void;
     onWorkdirChange?: (newCwd: string) => void;
     onQueuedMessagesChange?: (messages: QueuedMessage[]) => void;
-    onGoalStateChange?: (active: boolean, condition?: string, elapsed?: string) => void;
-    onGoalEvaluating?: (evaluating: boolean) => void;
 }

package/dist/types/config.d.ts

@@ -29,4 +29,11 @@ export interface ModelConfig {
     options?: Record<string, unknown>;
     /** Fast model generation params (resolved from models[fastModel].options) */
     fastModelOptions?: Record<string, unknown>;
+    /**
+     * Fast-model-only disable-thinking params passed through verbatim
+     * (e.g. `{ thinking: { type: "disabled" } }`). Applied only in fast-model
+     * scenarios (webFetch content processing, `model: fastModel` subagents),
+     * never in the agent loop. `{}` clears the default.
+     */
+    disableThinkingOptions?: Record<string, unknown>;
 }

package/dist/types/core.d.ts

@@ -22,7 +22,7 @@ export interface Usage {
     completion_tokens: number;
     total_tokens: number;
     model?: string;
-    operation_type?: "agent" | "compact" | "goal_evaluation";
+    operation_type?: "agent" | "compact";
     cache_read_input_tokens?: number;
     cache_creation_input_tokens?: number;
     cache_creation?: {

package/dist/utils/containerSetup.js

@@ -16,7 +16,6 @@ import { SlashCommandManager } from "../managers/slashCommandManager.js";
 import { PluginManager } from "../managers/pluginManager.js";
 import { BangManager } from "../managers/bangManager.js";
 import { CronManager } from "../managers/cronManager.js";
-import { GoalManager } from "../managers/goalManager.js";
 import { WorkflowManager } from "../managers/workflowManager.js";
 import { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
 import { ReversionManager } from "../managers/reversionManager.js";
@@ -24,6 +23,7 @@ import { SubagentManager } from "../managers/subagentManager.js";
 import { ForkedAgentManager } from "../managers/forkedAgentManager.js";
 import { LiveConfigManager } from "../managers/liveConfigManager.js";
 import { ReversionService } from "../services/reversionService.js";
+import { cleanupMetaOnlySessions } from "../services/session.js";
 import { MemoryService } from "../services/memory.js";
 import { AutoMemoryService } from "../services/autoMemoryService.js";
 import { USER_MEMORY_FILE } from "./constants.js";
@@ -144,6 +144,17 @@ export function setupAgentContainer(setupOptions) {
     reversionService.cleanupOldSessions(30).catch((error) => {
         logger.error("Failed to cleanup old file history:", error);
     });
+    // Remove pre-existing meta-only session files (SessionStart hook context
+    // with no real messages) that were persisted before lazy materialization.
+    cleanupMetaOnlySessions()
+        .then((count) => {
+        if (count > 0) {
+            logger.debug(`Removed ${count} meta-only session file(s)`);
+        }
+    })
+        .catch((error) => {
+        logger.error("Failed to cleanup meta-only session files:", error);
+    });
     const reversionManager = new ReversionManager(container);
     container.register("ReversionManager", reversionManager);
     const canUseToolWithPermissionRequest = options.canUseTool
@@ -255,8 +266,6 @@ export function setupAgentContainer(setupOptions) {
     const cronManager = new CronManager(container, messageManager.getSessionId());
     container.register("CronManager", cronManager);
     cronManager.start();
-    const goalManager = new GoalManager(container);
-    container.register("GoalManager", goalManager);
     const workflowManager = new WorkflowManager(container);
     container.register("WorkflowManager", workflowManager);
     return container;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",

package/src/agent.ts

@@ -8,7 +8,6 @@ import { McpManager } from "./managers/mcpManager.js";
 import { LspManager } from "./managers/lspManager.js";
 import { BangManager } from "./managers/bangManager.js";
 import { CronManager } from "./managers/cronManager.js";
-import { GoalManager } from "./managers/goalManager.js";
 import { BackgroundTaskManager } from "./managers/backgroundTaskManager.js";
 import { MessageQueue, type QueuedMessage } from "./managers/messageQueue.js";
 import { SlashCommandManager } from "./managers/slashCommandManager.js";
@@ -38,9 +37,6 @@ import { LiveConfigManager } from "./managers/liveConfigManager.js";
 import { configValidator } from "./utils/configValidator.js";
 import { SkillManager } from "./managers/skillManager.js";
 import { TaskManager } from "./services/taskManager.js";
-import { btw } from "./services/aiService.js";
-import { convertMessagesForAPI } from "./utils/convertMessagesForAPI.js";
-import { supportsVision } from "./utils/modelCapabilities.js";
 import type { WorktreeSession } from "./utils/worktreeSession.js";
 import { parseTaskNotificationXml } from "./utils/notificationXml.js";
 import { InitializationService } from "./services/initializationService.js";
@@ -73,7 +69,6 @@ export class Agent {
   private pluginManager: PluginManager; // Add plugin manager instance
   private skillManager: SkillManager; // Add skill manager instance
   private cronManager: CronManager; // Add cron manager instance
-  private goalManager: GoalManager; // Add goal manager instance
   private hookManager: HookManager; // Add hooks manager instance
   private reversionManager: ReversionManager;
   private messageQueue: MessageQueue; // Unified queue for messages, bang commands, and notifications
@@ -208,7 +203,6 @@ export class Agent {
     this.pluginManager = this.container.get("PluginManager")!;
     this.bangManager = this.container.get("BangManager")!;
     this.cronManager = this.container.get("CronManager")!;
-    this.goalManager = this.container.get("GoalManager")!;
     this.messageQueue = this.container.get("MessageQueue")!;
 
     // Wire up CWD change callback from AIManager to sync Agent's workdir
@@ -238,16 +232,6 @@ export class Agent {
     if (options.permissionMode) {
       this.setPermissionMode(options.permissionMode);
     }
-
-    // Wire up goal state change callback
-    this.goalManager.setOnGoalStateChange((active, condition, elapsed) => {
-      this.options.callbacks?.onGoalStateChange?.(active, condition, elapsed);
-    });
-
-    // Wire up goal evaluating callback
-    this.goalManager.setOnGoalEvaluating((evaluating) => {
-      this.options.callbacks?.onGoalEvaluating?.(evaluating);
-    });
   }
 
   // Public getter methods
@@ -340,16 +324,6 @@ export class Agent {
       .filter((m) => m.type !== "notification");
   }
 
-  /** Get goal status string */
-  public get goalStatus(): string {
-    return this.goalManager.getStatusString();
-  }
-
-  /** Check if a goal is active */
-  public get isGoalActive(): boolean {
-    return this.goalManager.isGoalActive();
-  }
-
   /**
    * Remove a queued message by index
    * @param index - The index of the message to remove
@@ -707,10 +681,15 @@ export class Agent {
   }
 
   public async clearMessages(): Promise<void> {
-    this.aiManager.abortAIMessage();
+    // Aligned with webview (ChatApp handleClearChat): /clear is ignored
+    // while the agent is running, instead of aborting the AI mid-turn
+    // (which used to inject a late "Request was aborted" error into the
+    // newly cleared session).
+    if (this.aiManager.isLoading) {
+      return;
+    }
 
-    // Clear any active goal
-    this.goalManager.clearGoal();
+    this.aiManager.abortAIMessage();
 
     // Capture old session info before clearing
     const oldSessionId = this.messageManager.getSessionId();
@@ -772,6 +751,12 @@ export class Agent {
    * @param customInstructions - Optional custom instructions for compaction
    */
   public async compact(customInstructions?: string): Promise<void> {
+    // Aligned with webview: /compact is ignored while the agent is running,
+    // instead of aborting the AI mid-turn before compacting.
+    if (this.aiManager.isLoading) {
+      return;
+    }
+
     this.aiManager.abortAIMessage();
 
     await this.aiManager.compactConversation({
@@ -781,75 +766,6 @@ export class Agent {
     await this.messageManager.saveSession();
   }
 
-  /**
-   * Set an autonomous goal for the session
-   * @param condition - The goal condition to achieve
-   */
-  public async setGoal(condition: string): Promise<void> {
-    // Check plan mode
-    if (this.getPermissionMode() === "plan") {
-      this.messageManager.addUserMessage({
-        content:
-          "<system-reminder>Cannot set a goal in plan mode. Exit plan mode first.</system-reminder>",
-        isMeta: true,
-      });
-      return;
-    }
-
-    this.goalManager.setGoal(condition);
-    this.messageManager.addUserMessage({
-      content: `<system-reminder>Goal set: ${condition}. The agent will work autonomously until this goal is achieved.</system-reminder>`,
-      isMeta: true,
-    });
-    // Add the goal as a user directive to start working
-    this.messageManager.addUserMessage({
-      content: condition,
-    });
-    this.aiManager.sendAIMessage();
-
-    await this.messageManager.saveSession();
-  }
-
-  /**
-   * Clear the current autonomous goal
-   */
-  public async clearGoal(): Promise<void> {
-    if (this.goalManager.isGoalActive()) {
-      this.goalManager.clearGoal();
-      this.messageManager.addUserMessage({
-        content: "<system-reminder>Goal cleared.</system-reminder>",
-        isMeta: true,
-      });
-    } else {
-      this.messageManager.addUserMessage({
-        content: "<system-reminder>No active goal to clear.</system-reminder>",
-        isMeta: true,
-      });
-    }
-
-    await this.messageManager.saveSession();
-  }
-
-  /**
-   * Show the current goal status
-   */
-  public async showGoalStatus(): Promise<void> {
-    if (this.goalManager.isGoalActive()) {
-      this.messageManager.addUserMessage({
-        content: `<system-reminder>${this.goalManager.getStatusString()}</system-reminder>`,
-        isMeta: true,
-      });
-    } else {
-      this.messageManager.addUserMessage({
-        content:
-          "<system-reminder>No active goal. Use /goal <condition> to set one.</system-reminder>",
-        isMeta: true,
-      });
-    }
-
-    await this.messageManager.saveSession();
-  }
-
   /** Unified interrupt method, interrupts both AI messages and command execution */
   public abortMessage(): void {
     // Guard: prevent tryDispatch (triggered by abortAIMessage → setIsLoading(false))
@@ -994,6 +910,21 @@ export class Agent {
     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 {
+      const autoMemoryService =
+        this.container.get<
+          import("./services/autoMemoryService.js").AutoMemoryService
+        >("AutoMemoryService");
+      if (autoMemoryService) {
+        await autoMemoryService.drain();
+      }
+    } catch (error) {
+      this.logger?.warn(
+        `Auto-memory extraction drain failed: ${(error as Error).message}`,
+      );
+    }
     // Cleanup skill manager
     await this.skillManager.destroy();
     // Cleanup live configuration reload
@@ -1018,21 +949,30 @@ export class Agent {
   }
 
   /**
-   * Ask a side question without tool use
+   * Ask a side question without interrupting the main agent.
+   *
+   * Runs a single-turn fork of the conversation that reuses the main loop's
+   * system prompt, tools, and memory injection (prompt-cache friendly) and
+   * never executes tools. The abort signal lets the UI cancel a pending
+   * question (loading dismiss); aborts propagate as thrown errors.
+   *
    * @param question - The side question to ask
+   * @param abortSignal - Optional signal to abort the pending request
    * @returns Promise that resolves to the AI's answer
    */
-  public async askBtw(question: string): Promise<string> {
-    const messages = convertMessagesForAPI(this.messageManager.getMessages(), {
-      supportsVision: supportsVision(this.getModelConfig().capabilities),
-    });
-    const result = await btw({
-      gatewayConfig: this.getGatewayConfig(),
-      modelConfig: this.getModelConfig(),
-      messages,
+  public async askBtw(
+    question: string,
+    abortSignal?: AbortSignal,
+    onContent?: (content: string) => void,
+    onReasoning?: (content: string) => void,
+  ): Promise<string> {
+    const result = await this.aiManager.runBtwFork(
       question,
-    });
-    return result.content;
+      abortSignal,
+      onContent,
+      onReasoning,
+    );
+    return result.content ?? result.error ?? "No response received";
   }
 
   /**
@@ -1066,7 +1006,7 @@ export class Agent {
     images?: Array<{ path: string; mimeType: string }>,
   ): Promise<void> {
     // If the agent is busy, enqueue the message — unless it's an immediate
-    // slash command (e.g., /goal clear, /clear, /compact) that should execute
+    // slash command (e.g., /clear, /compact) that should execute
     // right away even while AI is processing
     if (this.aiManager.isLoading || this.isCommandRunning) {
       const trimmed = content.trim();