wave-agent-sdk 1.0.0 → 1.0.1

package/dist/managers/subagentManager.js

@@ -538,18 +538,21 @@ export class SubagentManager {
     createSubagentCallbacks(subagentId) {
         return {
             onUserMessageAdded: (params) => {
+                this.refreshSubagentState(subagentId);
                 // Forward user message events to parent via SubagentManager callbacks
                 if (this.callbacks?.onSubagentUserMessageAdded) {
                     this.callbacks.onSubagentUserMessageAdded(subagentId, params);
                 }
             },
             onAssistantMessageAdded: (messageId) => {
+                this.refreshSubagentState(subagentId);
                 // Forward assistant message events to parent via SubagentManager callbacks
                 if (this.callbacks?.onSubagentAssistantMessageAdded) {
                     this.callbacks.onSubagentAssistantMessageAdded(subagentId, messageId);
                 }
             },
             onAssistantContentUpdated: (params) => {
+                this.refreshSubagentState(subagentId);
                 // Forward assistant content updates to parent via SubagentManager callbacks
                 if (this.callbacks?.onSubagentAssistantContentUpdated) {
                     this.callbacks.onSubagentAssistantContentUpdated({
@@ -559,6 +562,7 @@ export class SubagentManager {
                 }
             },
             onAssistantReasoningUpdated: (params) => {
+                this.refreshSubagentState(subagentId);
                 // Forward assistant reasoning updates to parent via SubagentManager callbacks
                 if (this.callbacks?.onSubagentAssistantReasoningUpdated) {
                     this.callbacks.onSubagentAssistantReasoningUpdated({
@@ -568,6 +572,7 @@ export class SubagentManager {
                 }
             },
             onToolBlockUpdated: (params) => {
+                this.refreshSubagentState(subagentId);
                 const instance = this.instances.get(subagentId);
                 if (instance) {
                     // Log tool execution to file only when finalized
@@ -582,28 +587,6 @@ export class SubagentManager {
                     this.callbacks.onSubagentToolBlockUpdated(subagentId, params);
                 }
             },
-            // These callbacks will be handled by the parent agent
-            onMessagesChange: (messages) => {
-                const instance = this.instances.get(subagentId);
-                if (instance) {
-                    instance.messages = messages;
-                    // Compute usedTools from messages (last 2 tool blocks)
-                    const toolBlocks = messages.flatMap((m) => m.blocks?.filter((b) => b.type === "tool") ?? []);
-                    const last2 = toolBlocks.slice(-2);
-                    instance.usedTools = last2.map((tb) => ({
-                        name: tb.name ?? "",
-                        parameters: tb.parameters ?? "",
-                        compactParams: tb.compactParams,
-                        stage: tb.stage,
-                    }));
-                    // Trigger the onUpdate callback if provided
-                    instance.onUpdate?.();
-                    // Forward subagent message changes to parent via callbacks
-                    if (this.callbacks?.onSubagentMessagesChange) {
-                        this.callbacks.onSubagentMessagesChange(subagentId, messages);
-                    }
-                }
-            },
             onLatestTotalTokensChange: (tokens) => {
                 const instance = this.instances.get(subagentId);
                 if (instance) {
@@ -616,6 +599,7 @@ export class SubagentManager {
                 }
             },
             onErrorBlockAdded: (error) => {
+                this.refreshSubagentState(subagentId);
                 const instance = this.instances.get(subagentId);
                 if (instance?.logStream) {
                     instance.logStream.write(`[${new Date().toISOString()}] Error: ${error}\n`);
@@ -623,4 +607,31 @@ export class SubagentManager {
             },
         };
     }
+    /**
+     * Pull the latest messages from the subagent instance's MessageManager and
+     * refresh the instance's cached messages, usedTools, onUpdate and the
+     * onSubagentMessagesChange forwarding. Triggered by incremental callbacks.
+     */
+    refreshSubagentState(subagentId) {
+        const instance = this.instances.get(subagentId);
+        if (!instance)
+            return;
+        const messages = instance.messageManager.getMessages();
+        instance.messages = messages;
+        // Compute usedTools from messages (last 2 tool blocks)
+        const toolBlocks = messages.flatMap((m) => m.blocks?.filter((b) => b.type === "tool") ?? []);
+        const last2 = toolBlocks.slice(-2);
+        instance.usedTools = last2.map((tb) => ({
+            name: tb.name ?? "",
+            parameters: tb.parameters ?? "",
+            compactParams: tb.compactParams,
+            stage: tb.stage,
+        }));
+        // Trigger the onUpdate callback if provided
+        instance.onUpdate?.();
+        // Forward subagent message changes to parent via callbacks
+        if (this.callbacks?.onSubagentMessagesChange) {
+            this.callbacks.onSubagentMessagesChange(subagentId, messages);
+        }
+    }
 }

package/dist/prompts/index.d.ts

@@ -34,7 +34,6 @@ export declare function getCompactPrompt(customInstructions?: string): string;
  */
 export declare function formatCompactSummary(summary: string): string;
 export declare const WEB_CONTENT_SYSTEM_PROMPT = "You are a helpful assistant that extracts information from web content. The content is provided in Markdown format.";
-export declare const BTW_SYSTEM_PROMPT = "You are a helpful assistant. Answer the user's side question based on the conversation history. \nDo NOT say things like \"Let me try...\", \"I'll now...\", \"Let me check...\", or promise to take any action. \nIf you don't know the answer, say so - do not offer to look it up or investigate. \nSimply answer the question with the information you have.";
 export declare function buildSystemPrompt(basePrompt: string | undefined, tools: ToolPlugin[], options?: {
     workdir?: string;
     originalWorkdir?: string;

package/dist/prompts/index.js

@@ -285,10 +285,6 @@ export function formatCompactSummary(summary) {
     return formattedSummary.trim();
 }
 export const WEB_CONTENT_SYSTEM_PROMPT = `You are a helpful assistant that extracts information from web content. The content is provided in Markdown format.`;
-export const BTW_SYSTEM_PROMPT = `You are a helpful assistant. Answer the user's side question based on the conversation history. 
-Do NOT say things like "Let me try...", "I'll now...", "Let me check...", or promise to take any action. 
-If you don't know the answer, say so - do not offer to look it up or investigate. 
-Simply answer the question with the information you have.`;
 export function buildSystemPrompt(basePrompt, tools, options = {}) {
     // --- Static block (cacheable) ---
     let staticText = basePrompt || DEFAULT_SYSTEM_PROMPT;

package/dist/services/aiService.d.ts

@@ -34,6 +34,7 @@ export interface CallAgentOptions {
         stage?: "start" | "streaming" | "running" | "end";
     }) => void;
     onReasoningUpdate?: (content: string) => void;
+    disableThinkingOptions?: Record<string, unknown>;
 }
 export interface CallAgentResult {
     content?: string;
@@ -62,37 +63,3 @@ export interface ProcessWebContentResult {
     };
 }
 export declare function processWebContent(options: ProcessWebContentOptions): Promise<ProcessWebContentResult>;
-export interface BtwOptions {
-    gatewayConfig: GatewayConfig;
-    modelConfig: ModelConfig;
-    messages: ChatCompletionMessageParam[];
-    question: string;
-    abortSignal?: AbortSignal;
-    model?: string;
-}
-export interface BtwResult {
-    content: string;
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-}
-export declare function btw(options: BtwOptions): Promise<BtwResult>;
-export interface EvaluateGoalOptions {
-    gatewayConfig: GatewayConfig;
-    modelConfig: ModelConfig;
-    model: string;
-    goalCondition: string;
-    messages: ChatCompletionMessageParam[];
-    abortSignal?: AbortSignal;
-}
-export interface EvaluateGoalResult {
-    content: string;
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-}
-export declare function evaluateGoal(options: EvaluateGoalOptions): Promise<EvaluateGoalResult>;

package/dist/services/aiService.js

@@ -7,8 +7,7 @@ import { supportsPromptCaching } from "../utils/modelCapabilities.js";
 import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
-import { WEB_CONTENT_SYSTEM_PROMPT, BTW_SYSTEM_PROMPT, } from "../prompts/index.js";
-import { GOAL_EVALUATION_SYSTEM_PROMPT } from "../constants/goalPrompts.js";
+import { WEB_CONTENT_SYSTEM_PROMPT, } from "../prompts/index.js";
 // Global rate limiter state for 1 QPS
 let nextAllowedTime = 0;
 const MIN_INTERVAL = 1000; // 1 second for 1 QPS
@@ -66,6 +65,15 @@ function getModelConfig(modelName, baseConfig = {}) {
     }
     return config;
 }
+/**
+ * Effective disable-thinking params for a model config. No default: these
+ * params are only sent when the user explicitly configures
+ * `models[X].disableThinkingOptions` (an empty object clears them), so a
+ * gateway that doesn't understand the params is never hit with them.
+ */
+function effectiveDisableThinkingOptions(modelConfig) {
+    return modelConfig.disableThinkingOptions;
+}
 function validateModelConfig(modelConfig) {
     if (!modelConfig.model) {
         throw new ConfigurationError(CONFIG_ERRORS.MISSING_MODEL, "model", {
@@ -81,7 +89,7 @@ function validateModelConfig(modelConfig) {
     }
 }
 export async function callAgent(options) {
-    const { gatewayConfig, modelConfig, messages, abortSignal, workdir, tools, model, systemPrompt, onContentUpdate, onToolUpdate, onReasoningUpdate, } = options;
+    const { gatewayConfig, modelConfig, messages, abortSignal, workdir, tools, model, systemPrompt, onContentUpdate, onToolUpdate, onReasoningUpdate, disableThinkingOptions, } = options;
     // Validate model config at call time
     validateModelConfig(modelConfig);
     // Apply global 1 QPS rate limit
@@ -147,6 +155,7 @@ export async function callAgent(options) {
         const openaiModelConfig = getModelConfig(model || modelConfig.model, {
             max_tokens: resolvedMaxTokens,
             ...(modelConfig.options || {}),
+            ...(disableThinkingOptions ?? {}),
         });
         // Determine if streaming is needed
         const isStreaming = options.stream === true ||
@@ -509,10 +518,16 @@ export async function processWebContent(options) {
     const activeExtraParams = options.model
         ? modelConfig.fastModelOptions || {}
         : modelConfig.options || {};
+    // Disable-thinking params only apply to the fast-model override path;
+    // the agent-model path is untouched.
+    const disableThinking = options.model
+        ? effectiveDisableThinkingOptions(modelConfig)
+        : undefined;
     const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
         temperature: 0.1,
         max_tokens: 4096,
         ...activeExtraParams,
+        ...(disableThinking || {}),
     });
     try {
         const response = await openai.chat.completions.create({
@@ -555,130 +570,3 @@ export async function processWebContent(options) {
         throw error;
     }
 }
-export async function btw(options) {
-    const { gatewayConfig, modelConfig, messages, question, abortSignal } = options;
-    // Validate model config at call time
-    validateModelConfig(modelConfig);
-    // Apply global 1 QPS rate limit
-    if (process.env.NODE_ENV !== "test" ||
-        modelConfig.model === "rate-limit-test") {
-        await acquireSlot(abortSignal);
-    }
-    // Create OpenAI client with injected configuration
-    const openai = new OpenAIClient({
-        apiKey: gatewayConfig.apiKey,
-        baseURL: gatewayConfig.baseURL,
-        defaultHeaders: gatewayConfig.defaultHeaders,
-        fetchOptions: gatewayConfig.fetchOptions,
-        fetch: gatewayConfig.fetch,
-    });
-    const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
-        temperature: 0.1,
-        max_tokens: 4096,
-        ...(modelConfig.options || {}),
-    });
-    try {
-        const response = await openai.chat.completions.create({
-            ...openaiModelConfig,
-            messages: [
-                {
-                    role: "system",
-                    content: BTW_SYSTEM_PROMPT,
-                },
-                ...messages,
-                {
-                    role: "user",
-                    content: question,
-                },
-            ],
-        }, {
-            signal: abortSignal,
-        });
-        const result = response.choices[0]?.message?.content?.trim();
-        if (!result) {
-            throw new Error("Failed to process side question: Empty response from AI");
-        }
-        const usage = response.usage
-            ? {
-                prompt_tokens: response.usage.prompt_tokens,
-                completion_tokens: response.usage.completion_tokens,
-                total_tokens: response.usage.total_tokens,
-            }
-            : undefined;
-        return {
-            content: result,
-            usage,
-        };
-    }
-    catch (error) {
-        if (error.name === "AbortError") {
-            logger.info("Side question request was aborted");
-            throw new Error("Side question request was aborted");
-        }
-        logger.error("Failed to process side question:", error);
-        throw error;
-    }
-}
-export async function evaluateGoal(options) {
-    const { gatewayConfig, modelConfig, model, goalCondition, messages, abortSignal, } = options;
-    // Create OpenAI client with injected configuration (no rate limiter — bypasses 1 QPS)
-    const openai = new OpenAIClient({
-        apiKey: gatewayConfig.apiKey,
-        baseURL: gatewayConfig.baseURL,
-        defaultHeaders: gatewayConfig.defaultHeaders,
-        fetchOptions: gatewayConfig.fetchOptions,
-        fetch: gatewayConfig.fetch,
-    });
-    const openaiModelConfig = getModelConfig(model, {
-        temperature: 0,
-        max_tokens: 200,
-        ...(modelConfig.fastModelOptions || {}),
-    });
-    // Strip images from messages to reduce token usage (same as compact)
-    const cleanedMessages = messages.map((msg) => {
-        if (Array.isArray(msg.content)) {
-            const textParts = msg.content.filter((part) => part.type === "text");
-            const text = textParts.map((p) => p.text).join("\n");
-            return { ...msg, content: text || "(empty message)" };
-        }
-        return msg;
-    });
-    try {
-        const response = await openai.chat.completions.create({
-            ...openaiModelConfig,
-            messages: [
-                {
-                    role: "system",
-                    content: GOAL_EVALUATION_SYSTEM_PROMPT,
-                },
-                ...cleanedMessages,
-                {
-                    role: "user",
-                    content: `Goal condition: ${goalCondition}\n\nHas this goal been achieved based on the conversation above?`,
-                },
-            ],
-        }, {
-            signal: abortSignal,
-        });
-        const result = response.choices[0]?.message?.content?.trim();
-        if (!result) {
-            throw new Error("Goal evaluation returned empty response");
-        }
-        const usage = response.usage
-            ? {
-                prompt_tokens: response.usage.prompt_tokens,
-                completion_tokens: response.usage.completion_tokens,
-                total_tokens: response.usage.total_tokens,
-            }
-            : undefined;
-        return { content: result, usage };
-    }
-    catch (error) {
-        if (error.name === "AbortError") {
-            logger.info("Goal evaluation was aborted");
-            throw new Error("Goal evaluation was aborted");
-        }
-        logger.error("Goal evaluation failed:", error);
-        throw error;
-    }
-}

package/dist/services/autoMemoryService.d.ts

@@ -7,9 +7,11 @@ export declare class AutoMemoryService {
     private container;
     private lastMemoryMessageId;
     private turnsSinceLastExtraction;
+    private extractionInProgress;
+    private pendingExtraction;
     constructor(container: Container);
     private get messageManager();
-    private get forkedAgentManager();
+    private get aiManager();
     private get memoryService();
     private get configurationService();
     /**
@@ -17,7 +19,30 @@ export declare class AutoMemoryService {
      */
     onTurnEnd(workdir: string): Promise<void>;
     /**
-     * Initialize and execute the background extraction subagent.
+     * 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.
+     */
+    drain(): Promise<void>;
+    /**
+     * 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.
      */
     private runExtraction;
+    /**
+     * 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.
+     */
+    private isAllowedForkTool;
+    /**
+     * 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.
+     */
+    private isReadOnlyBashCommand;
 }

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)
  *