@phuetz/code-buddy 1.0.0 → 1.2.0

package/dist/agent/multi-agent/session-tools.js

@@ -368,21 +368,36 @@ export class SessionToolExecutor {
         const limit = this.parseSessionSearchLimit(args.limit);
         const { getSessionStore } = await import('../../persistence/session-store.js');
         const sessions = (await getSessionStore().searchSessions(query)).slice(0, limit);
+        const citations = [];
         const formatted = sessions.map(session => {
             const metadata = session.metadata && typeof session.metadata === 'object'
                 ? session.metadata
                 : {};
+            const messageId = typeof metadata.searchMessageId === 'number' ? metadata.searchMessageId : undefined;
+            const role = typeof metadata.searchRole === 'string' ? metadata.searchRole : undefined;
+            const snippet = typeof metadata.searchSnippet === 'string' ? metadata.searchSnippet : '';
+            const citation = {
+                sessionId: session.id,
+                snippet,
+                label: messageId ? `session:${session.id}#message:${messageId}` : `session:${session.id}`,
+            };
+            if (messageId !== undefined)
+                citation.messageId = messageId;
+            if (role)
+                citation.role = role;
             const match = {
-                snippet: metadata.searchSnippet ?? '',
+                snippet,
+                citation,
             };
-            if (metadata.searchRole)
-                match.role = metadata.searchRole;
+            if (role)
+                match.role = role;
             if (typeof metadata.searchScore === 'number')
                 match.score = metadata.searchScore;
-            if (typeof metadata.searchMessageId === 'number')
-                match.messageId = metadata.searchMessageId;
+            if (messageId !== undefined)
+                match.messageId = messageId;
             if (metadata.parentSessionId)
                 match.parentSessionId = metadata.parentSessionId;
+            citations.push(citation);
             return {
                 id: session.id,
                 name: session.name,
@@ -391,6 +406,7 @@ export class SessionToolExecutor {
                 messageCount: Array.isArray(session.messages) ? session.messages.length : 0,
                 createdAt: session.createdAt.toISOString(),
                 lastAccessedAt: session.lastAccessedAt.toISOString(),
+                citation,
                 match,
             };
         });
@@ -398,6 +414,7 @@ export class SessionToolExecutor {
             query,
             total: formatted.length,
             sessions: formatted,
+            citations,
         };
         return {
             success: true,

package/dist/agent/reasoning/mcts.js

@@ -487,21 +487,35 @@ export class MCTS {
     findBestSolution() {
         if (!this.root)
             return null;
+        // Preferred tier: the best-scoring terminal-typed node (a concrete
+        // `implementation` or an explicit `conclusion`). Fallback tier: the
+        // best-scoring *derived* node of any type — many problems/models yield only
+        // analysis/verification/hypothesis thoughts, and a high-scoring one of those
+        // is still the best answer the search found. Without the fallback, such a
+        // search returns null even when a node scored 1.0. Both tiers exclude pruned
+        // nodes and the root (the problem statement, depth 0 — not a derived solution).
         let best = null;
         let bestScore = -1;
+        let fallback = null;
+        let fallbackScore = -1;
         const traverse = (node) => {
-            if (node.state !== 'pruned' &&
-                (node.type === 'implementation' || node.type === 'conclusion') &&
-                node.score > bestScore) {
-                bestScore = node.score;
-                best = node;
+            if (node.state !== 'pruned' && node.depth > 0) {
+                if ((node.type === 'implementation' || node.type === 'conclusion') &&
+                    node.score > bestScore) {
+                    bestScore = node.score;
+                    best = node;
+                }
+                if (node.score > fallbackScore) {
+                    fallbackScore = node.score;
+                    fallback = node;
+                }
             }
             for (const child of node.children) {
                 traverse(child);
             }
         };
         traverse(this.root);
-        return best;
+        return best ?? fallback;
     }
     /**
      * Get the path from root to a node

package/dist/agent/session-end-flush.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Session-end flush (WS3-T1 — Mémoire & continuité du run).
+ *
+ * When a session ends, persist what the next run needs to not start from
+ * zero:
+ *  1. a short HANDOFF file (`.codebuddy/HANDOFF.md`) — last goal, last
+ *     state, files touched, open risks — written synchronously so it also
+ *     works from process `exit` handlers;
+ *  2. reusable lesson candidates via the existing review-gated
+ *     auto-proposer (PENDING only — a human approves them into lessons.md,
+ *     which the per-turn `<lessons_context>` injection then re-injects on
+ *     future runs);
+ *  3. declarative long-term memory candidates via the review-gated memory
+ *     queue. These do not enter prompt-injected persistent memory until a
+ *     human accepts them.
+ *
+ * Guard-rails: trivial sessions are skipped (no LLM call, no file), and
+ * everything written here passes the privacy lint first (PII/secret spans
+ * are redacted from the handoff; tainted lesson candidates are dropped by
+ * the proposer itself).
+ *
+ * @module agent/session-end-flush
+ */
+import type { CodeBuddyClient } from '../codebuddy/client.js';
+import type { ChatEntry } from './types.js';
+export interface SessionEndFlushInput {
+    chatHistory: ChatEntry[];
+    workDir?: string;
+    /** Reuse the session's LLM client for the lesson proposal (no re-auth). */
+    client?: CodeBuddyClient;
+    sessionId?: string;
+    /** Session start (ms epoch) — used for the duration line of the handoff. */
+    startedAt?: number;
+}
+export interface SessionEndFlushResult {
+    /** Lesson candidates enqueued for review (`buddy lessons` to approve). */
+    proposedLessons: number;
+    /** Declarative memory candidates enqueued for review (`/memory candidates`). */
+    proposedMemories: number;
+    /** Absolute path of the handoff file, when one was (re)written. */
+    handoffPath?: string;
+    openRisks: string[];
+    skipped?: 'disabled' | 'trivial';
+}
+/**
+ * Heuristic open-risk extraction: error-ish tool results, deduped per tool,
+ * newest kept. No LLM involved — deterministic and free.
+ */
+export declare function extractOpenRisks(history: ChatEntry[]): string[];
+/** Files touched through write-ish tool calls, for the handoff. */
+export declare function extractTouchedFiles(history: ChatEntry[]): string[];
+export interface HandoffOptions {
+    sessionId?: string;
+    startedAt?: number;
+    /** Force a write even below the size threshold (used by tests). */
+    force?: boolean;
+}
+/**
+ * Write `.codebuddy/HANDOFF.md` synchronously. Returns the path when
+ * written, undefined when the session didn't warrant one. Idempotent per
+ * history array so the async flush and a process-exit fallback don't both
+ * write.
+ */
+export declare function writeHandoffSync(history: ChatEntry[], workDir?: string, options?: HandoffOptions): string | undefined;
+/**
+ * Run the complete session-end flush. Safe to call from any exit path:
+ * no-ops on trivial sessions, never throws.
+ */
+export declare function runSessionEndFlush(input: SessionEndFlushInput): Promise<SessionEndFlushResult>;
+/** Test hook: reset the per-history idempotence latch. */
+export declare function resetSessionEndFlushState(): void;

package/dist/agent/session-end-flush.js

@@ -0,0 +1,233 @@
+/**
+ * Session-end flush (WS3-T1 — Mémoire & continuité du run).
+ *
+ * When a session ends, persist what the next run needs to not start from
+ * zero:
+ *  1. a short HANDOFF file (`.codebuddy/HANDOFF.md`) — last goal, last
+ *     state, files touched, open risks — written synchronously so it also
+ *     works from process `exit` handlers;
+ *  2. reusable lesson candidates via the existing review-gated
+ *     auto-proposer (PENDING only — a human approves them into lessons.md,
+ *     which the per-turn `<lessons_context>` injection then re-injects on
+ *     future runs);
+ *  3. declarative long-term memory candidates via the review-gated memory
+ *     queue. These do not enter prompt-injected persistent memory until a
+ *     human accepts them.
+ *
+ * Guard-rails: trivial sessions are skipped (no LLM call, no file), and
+ * everything written here passes the privacy lint first (PII/secret spans
+ * are redacted from the handoff; tainted lesson candidates are dropped by
+ * the proposer itself).
+ *
+ * @module agent/session-end-flush
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { isFeatureEnabled } from '../config/feature-flags.js';
+import { redactSecrets } from '../fleet/privacy-lint.js';
+import { logger } from '../utils/logger.js';
+// ============================================================================
+// Gates & heuristics
+// ============================================================================
+/** Below this many assistant turns the session is too trivial to flush. */
+const MIN_ASSISTANT_TURNS = 2;
+/** Handoff is only worth writing past this transcript size (chars) … */
+const HANDOFF_MIN_TRANSCRIPT_CHARS = 8_000;
+/** … unless open risks were detected, which always deserve a handoff. */
+const RISK_PATTERN = /\b(error|failed|failure|exception|denied|timeout|timed out|blocked|fatal|refused)\b/i;
+const MAX_RISKS = 5;
+const SNIPPET_MAX = 240;
+function meaningfulTurns(history) {
+    let assistant = 0;
+    let tools = 0;
+    for (const e of history) {
+        if (e.type === 'assistant' && e.content.trim())
+            assistant++;
+        else if (e.type === 'tool_result')
+            tools++;
+    }
+    return { assistant, tools };
+}
+function firstLine(text) {
+    const line = text.trim().split('\n')[0] ?? '';
+    return line.length > SNIPPET_MAX ? `${line.slice(0, SNIPPET_MAX)}…` : line;
+}
+/**
+ * Heuristic open-risk extraction: error-ish tool results, deduped per tool,
+ * newest kept. No LLM involved — deterministic and free.
+ */
+export function extractOpenRisks(history) {
+    const byKey = new Map();
+    for (const e of history) {
+        if (e.type !== 'tool_result')
+            continue;
+        if (!RISK_PATTERN.test(e.content))
+            continue;
+        const tool = e.toolCall?.function?.name || 'tool';
+        byKey.set(tool, `\`${tool}\`: ${firstLine(redactSecrets(e.content))}`);
+    }
+    return [...byKey.values()].slice(-MAX_RISKS);
+}
+/** Files touched through write-ish tool calls, for the handoff. */
+export function extractTouchedFiles(history) {
+    const WRITE_TOOLS = new Set([
+        'str_replace', 'str_replace_editor', 'create_file', 'write_file',
+        'apply_patch', 'edit_file', 'text_editor',
+    ]);
+    const files = new Set();
+    for (const e of history) {
+        const calls = e.toolCalls ?? (e.toolCall ? [e.toolCall] : []);
+        for (const call of calls) {
+            if (!call?.function?.name || !WRITE_TOOLS.has(call.function.name))
+                continue;
+            try {
+                const args = JSON.parse(call.function.arguments || '{}');
+                const p = args.path ?? args.file_path ?? args.filePath;
+                if (typeof p === 'string' && p.trim())
+                    files.add(p.trim());
+            }
+            catch { /* unparseable args — skip */ }
+        }
+    }
+    return [...files].slice(0, 20);
+}
+// ============================================================================
+// Handoff (sync — usable from process exit handlers)
+// ============================================================================
+let handoffWrittenFor = null;
+/**
+ * Write `.codebuddy/HANDOFF.md` synchronously. Returns the path when
+ * written, undefined when the session didn't warrant one. Idempotent per
+ * history array so the async flush and a process-exit fallback don't both
+ * write.
+ */
+export function writeHandoffSync(history, workDir = process.cwd(), options = {}) {
+    if (handoffWrittenFor === history)
+        return undefined;
+    const { assistant } = meaningfulTurns(history);
+    if (assistant < MIN_ASSISTANT_TURNS)
+        return undefined;
+    const transcriptChars = history.reduce((n, e) => n + e.content.length, 0);
+    const risks = extractOpenRisks(history);
+    if (!options.force && transcriptChars < HANDOFF_MIN_TRANSCRIPT_CHARS && risks.length === 0) {
+        return undefined;
+    }
+    const lastUser = [...history].reverse().find((e) => e.type === 'user' && e.content.trim());
+    const lastAssistant = [...history].reverse().find((e) => e.type === 'assistant' && e.content.trim());
+    const touched = extractTouchedFiles(history);
+    const startedAt = options.startedAt;
+    const durationMin = startedAt ? Math.round((Date.now() - startedAt) / 60_000) : undefined;
+    const lines = [
+        '# Session Handoff',
+        '',
+        `> Auto-generated at session end — latest session wins. Read this before resuming work.`,
+        '',
+        `- Date: ${new Date().toISOString()}`,
+        ...(options.sessionId ? [`- Session: ${options.sessionId}`] : []),
+        ...(durationMin !== undefined ? [`- Durée: ~${durationMin} min`] : []),
+        `- Échanges: ${meaningfulTurns(history).assistant} réponses assistant, ${meaningfulTurns(history).tools} résultats d'outils`,
+        '',
+        '## Dernier objectif (utilisateur)',
+        '',
+        lastUser ? firstLine(redactSecrets(lastUser.content)) : '(aucun message utilisateur)',
+        '',
+        '## Dernier état (assistant)',
+        '',
+        lastAssistant ? redactSecrets(lastAssistant.content).trim().slice(0, 800) : '(aucune réponse)',
+        '',
+    ];
+    if (touched.length > 0) {
+        lines.push('## Fichiers touchés', '', ...touched.map((f) => `- \`${f}\``), '');
+    }
+    lines.push('## Risques ouverts', '');
+    if (risks.length > 0) {
+        lines.push(...risks.map((r) => `- ${r}`));
+    }
+    else {
+        lines.push('- Aucun détecté.');
+    }
+    lines.push('', '## Reprise', '', risks.length > 0
+        ? '- Commencer par lever les risques ouverts ci-dessus.'
+        : '- Continuer le dernier objectif, ou `buddy --continue` pour recharger la session.', '- Leçons en attente de revue : `buddy lessons` (candidats proposés en fin de session).', '- Mémoires en attente de revue : `/memory candidates` puis `/memory accept <id> <reviewer>`.', '');
+    const content = redactSecrets(lines.join('\n'));
+    const dir = path.join(workDir, '.codebuddy');
+    const target = path.join(dir, 'HANDOFF.md');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(target, content, 'utf8');
+        handoffWrittenFor = history;
+        return target;
+    }
+    catch (err) {
+        logger.debug('[session-end-flush] handoff write failed', { err: String(err) });
+        return undefined;
+    }
+}
+// ============================================================================
+// Full async flush (handoff + lesson proposal)
+// ============================================================================
+/**
+ * Run the complete session-end flush. Safe to call from any exit path:
+ * no-ops on trivial sessions, never throws.
+ */
+export async function runSessionEndFlush(input) {
+    const empty = { proposedLessons: 0, proposedMemories: 0, openRisks: [] };
+    try {
+        if (!isFeatureEnabled('SESSION_END_FLUSH')) {
+            return { ...empty, skipped: 'disabled' };
+        }
+        const history = input.chatHistory ?? [];
+        const { assistant } = meaningfulTurns(history);
+        if (assistant < MIN_ASSISTANT_TURNS) {
+            return { ...empty, skipped: 'trivial' };
+        }
+        const workDir = input.workDir ?? process.cwd();
+        const openRisks = extractOpenRisks(history);
+        const handoffPath = writeHandoffSync(history, workDir, {
+            ...(input.sessionId !== undefined ? { sessionId: input.sessionId } : {}),
+            ...(input.startedAt !== undefined ? { startedAt: input.startedAt } : {}),
+        });
+        // Lesson proposal last — it is the only step that may call an LLM, so a
+        // killed process still leaves the handoff behind.
+        let proposedLessons = 0;
+        try {
+            const { proposeLessonsFromSession } = await import('./lesson-auto-proposer.js');
+            const proposed = await proposeLessonsFromSession(history, workDir, input.client);
+            proposedLessons = proposed.length;
+        }
+        catch (err) {
+            logger.debug('[session-end-flush] lesson proposal failed', { err: String(err) });
+        }
+        let proposedMemories = 0;
+        if (process.env.CODEBUDDY_MEMORY_AUTO_PROPOSE !== 'false') {
+            try {
+                const { proposeMemoryCandidatesFromSession } = await import('../memory/memory-auto-proposer.js');
+                const proposed = await proposeMemoryCandidatesFromSession(history, workDir, input.client, input.sessionId);
+                proposedMemories = proposed.length;
+            }
+            catch (err) {
+                logger.debug('[session-end-flush] memory proposal failed', { err: String(err) });
+            }
+        }
+        if (proposedLessons > 0 || proposedMemories > 0 || handoffPath) {
+            logger.info(`[session-end-flush] ${proposedLessons} lesson candidate(s) proposed` +
+                `, ${proposedMemories} memory candidate(s) proposed` +
+                (handoffPath ? `, handoff written to ${path.relative(workDir, handoffPath)}` : ''));
+        }
+        return {
+            proposedLessons,
+            proposedMemories,
+            ...(handoffPath ? { handoffPath } : {}),
+            openRisks,
+        };
+    }
+    catch (err) {
+        logger.debug('[session-end-flush] flush failed', { err: String(err) });
+        return empty;
+    }
+}
+/** Test hook: reset the per-history idempotence latch. */
+export function resetSessionEndFlushState() {
+    handoffWrittenFor = null;
+}
+//# sourceMappingURL=session-end-flush.js.map

package/dist/agent/streaming/streaming-handler.d.ts

@@ -118,6 +118,12 @@ export interface AccumulatedMessage {
     content?: string;
     /** Accumulated tool calls */
     tool_calls?: CodeBuddyToolCall[];
+    /**
+     * The terminal `finish_reason`/`stop_reason` reported by the provider on the
+     * final chunk (`'stop'` | `'length'` | `'tool_calls'` | …). Used by the
+     * executor's in-loop recovery to detect a length-truncated turn.
+     */
+    finishReason?: string | null;
     /** Any additional fields from the API */
     [key: string]: unknown;
 }
@@ -153,6 +159,7 @@ export declare class StreamingHandler {
     private accumulatedMessage;
     private accumulatedRawContent;
     private accumulatedReasoningContent;
+    private accumulatedFinishReason;
     private tokenCounter;
     private lastTokenUpdate;
     private toolCallsYielded;

package/dist/agent/streaming/streaming-handler.js

@@ -42,6 +42,7 @@ export class StreamingHandler {
     accumulatedMessage = {};
     accumulatedRawContent = '';
     accumulatedReasoningContent = '';
+    accumulatedFinishReason = null;
     tokenCounter = null;
     lastTokenUpdate = 0;
     toolCallsYielded = false;
@@ -86,6 +87,11 @@ export class StreamingHandler {
         }
         // Accumulate the message using reducer
         this.accumulatedMessage = reduceStreamChunk(this.accumulatedMessage, chunk);
+        // Capture the terminal finish_reason (present on the final chunk). The last
+        // non-null value wins so a trailing usage-only chunk can't clear it.
+        if (chunk.choices[0].finish_reason) {
+            this.accumulatedFinishReason = chunk.choices[0].finish_reason;
+        }
         // Extract content delta
         const rawContentDelta = chunk.choices[0].delta?.content || '';
         this.accumulatedRawContent += rawContentDelta;
@@ -208,7 +214,7 @@ export class StreamingHandler {
      * @returns The accumulated message with all processed content and tool calls
      */
     getAccumulatedMessage() {
-        return { ...this.accumulatedMessage };
+        return { ...this.accumulatedMessage, finishReason: this.accumulatedFinishReason };
     }
     /**
      * Gets the raw accumulated content before sanitization.
@@ -261,6 +267,7 @@ export class StreamingHandler {
         this.accumulatedMessage = {};
         this.accumulatedRawContent = '';
         this.accumulatedReasoningContent = '';
+        this.accumulatedFinishReason = null;
         this.lastTokenUpdate = 0;
         this.toolCallsYielded = false;
     }

package/dist/agent/tool-executor.js

@@ -97,6 +97,7 @@ const TOOL_CATEGORY_MAP = {
     // Media
     screenshot: 'media',
     camera_snapshot: 'media',
+    camera_analyze: 'media',
     audio: 'media',
     video: 'media',
     ocr: 'media',

package/dist/agent/tool-handler.d.ts

@@ -37,6 +37,11 @@ export interface ToolHandlerDependencies {
     /** Coordinates auto-repair attempts for failed commands */
     repairCoordinator: RepairCoordinator;
 }
+export interface NormalizedHallucinatedToolCall {
+    toolName: string;
+    args: Record<string, unknown>;
+}
+export declare function normalizeHallucinatedLocalToolCall(toolName: string, args: Record<string, unknown>): NormalizedHallucinatedToolCall | null;
 /**
  * ToolHandler manages tool instantiation and execution
  *

package/dist/agent/tool-handler.js

@@ -16,7 +16,7 @@
  * Tool instances are lazy-loaded on first access for optimal startup time.
  */
 import { TextEditorTool, MorphEditorTool, ImageTool, BashTool, } from "../tools/index.js";
-import { getFormalToolRegistry, createTextEditorTools, createBashTools, createLsTools, createSearchTools, createWebTools, createTodoTools, createCronjobTools, createDockerTools, createKubernetesTools, createGitTools, createMiscTools, createBrowserTools, createProcessTools, createVisionTools, createScriptTools, createPlanTools, createKnowledgeTools, createRelationshipIntelligenceTools, createInternetScoutTools, createLeadScoutTools, createBrowserOperatorTools, createMemoryTools, createParallelTools, createAttentionTools, createSkillsInspectionTools, createLessonsTools, createUserModelTools, createAliasTools, createMultimodalTools, createAdvancedTools, createCanvasTools, createLspTools, createMergeConflictTools, createVulnScannerTools, createCodebaseReplaceTools, createAdvisorTools, createFleetTools, createAskUserQuestionTools, createExitPlanModeTools, createGuiTools, createSessionTools, createGitNexusTools, createScreenpipeTools, } from "../tools/registry/index.js";
+import { getFormalToolRegistry, createTextEditorTools, createBashTools, createLsTools, createSearchTools, createWebTools, createTodoTools, createCronjobTools, createDockerTools, createKubernetesTools, createGitTools, createMiscTools, createBrowserTools, createProcessTools, createVisionTools, createScriptTools, createPlanTools, createKnowledgeTools, createRelationshipIntelligenceTools, createInternetScoutTools, createLeadScoutTools, createBrowserOperatorTools, createWindowsTools, createMemoryTools, createParallelTools, createAttentionTools, createSkillsInspectionTools, createLessonsTools, createUserModelTools, createAliasTools, createMultimodalTools, createAdvancedTools, createCanvasTools, createLspTools, createMergeConflictTools, createVulnScannerTools, createCodebaseReplaceTools, createAdvisorTools, createFleetTools, createAskUserQuestionTools, createExitPlanModeTools, createGuiTools, createSessionTools, createGitNexusTools, createScreenpipeTools, } from "../tools/registry/index.js";
 import { getMCPManager } from "../codebuddy/tools.js";
 import { getErrorMessage } from "../errors/index.js";
 import { logger } from "../utils/logger.js";
@@ -44,6 +44,67 @@ const READ_ONLY_FILE_TOOLS = new Set([
     'find_definition',
     'search_multi',
 ]);
+export function normalizeHallucinatedLocalToolCall(toolName, args) {
+    const normalizedName = toolName.toLowerCase().replace(/\s+/g, '');
+    const thoughtToolCallSuffix = normalizedName.match(/^thought_tool_call_\d+(?:_\d+)*\.(bash|create_file|write_file|view_file|read_file)$/)?.[1];
+    if (thoughtToolCallSuffix === 'bash') {
+        const command = firstStringValue(args.command, args.cmd, args.shell_command, args.command_to_execute, args.code);
+        return {
+            toolName: 'bash',
+            args: command ? { ...args, command } : args,
+        };
+    }
+    if (thoughtToolCallSuffix === 'create_file' || thoughtToolCallSuffix === 'write_file') {
+        const path = firstStringValue(args.path, args.file_path, args.target_file, args.filename, args.file);
+        const content = firstStringValue(args.content, args.file_content, args.contents, args.text);
+        return {
+            toolName: 'create_file',
+            args: {
+                ...args,
+                ...(path ? { path } : {}),
+                ...(content !== undefined ? { content } : {}),
+            },
+        };
+    }
+    if (thoughtToolCallSuffix === 'view_file' || thoughtToolCallSuffix === 'read_file') {
+        const path = firstStringValue(args.path, args.file_path, args.target_file, args.filename, args.file);
+        return {
+            toolName: 'view_file',
+            args: path ? { ...args, path } : args,
+        };
+    }
+    if (normalizedName.includes('bash_tool:execute') ||
+        normalizedName.includes('thought-tool:execute_command') ||
+        normalizedName === 'execute_command') {
+        const command = firstStringValue(args.command, args.cmd, args.shell_command, args.command_to_execute, args.code);
+        return {
+            toolName: 'bash',
+            args: command ? { ...args, command } : args,
+        };
+    }
+    if (normalizedName.includes('bash_tool:write_file') ||
+        normalizedName.includes('thought-tool:write_file') ||
+        normalizedName.includes('call:bash_tool:write_file')) {
+        const path = firstStringValue(args.path, args.file_path, args.target_file, args.filename, args.file);
+        const content = firstStringValue(args.content, args.file_content, args.contents, args.text);
+        return {
+            toolName: 'create_file',
+            args: {
+                ...args,
+                ...(path ? { path } : {}),
+                ...(content !== undefined ? { content } : {}),
+            },
+        };
+    }
+    return null;
+}
+function firstStringValue(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value;
+    }
+    return undefined;
+}
 /**
  * ToolHandler manages tool instantiation and execution
  *
@@ -156,6 +217,7 @@ export class ToolHandler {
             ...createInternetScoutTools(),
             ...createLeadScoutTools(),
             ...createBrowserOperatorTools(),
+            ...(process.platform === 'win32' ? createWindowsTools() : []),
             ...createMemoryTools(),
             ...createParallelTools(),
             ...createAttentionTools(),
@@ -244,8 +306,25 @@ export class ToolHandler {
         const startTime = Date.now();
         const hooksManager = getToolHooksManager();
         try {
-            const args = JSON.parse(toolCall.function.arguments);
-            const toolName = toolCall.function.name;
+            let args = JSON.parse(toolCall.function.arguments);
+            let toolName = toolCall.function.name;
+            const normalized = normalizeHallucinatedLocalToolCall(toolName, args);
+            if (normalized) {
+                logger.debug('Normalized hallucinated local tool name', {
+                    from: toolName,
+                    to: normalized.toolName,
+                });
+                toolName = normalized.toolName;
+                args = normalized.args;
+                toolCall = {
+                    ...toolCall,
+                    function: {
+                        ...toolCall.function,
+                        name: toolName,
+                        arguments: JSON.stringify(args),
+                    },
+                };
+            }
             // Create hook context
             let hookContext = {
                 toolName,
@@ -693,6 +772,12 @@ export class ToolHandler {
      */
     async executeBashWithHooks(args, context) {
         const command = args.command;
+        if (typeof command !== 'string' || command.trim() === '') {
+            return {
+                success: false,
+                error: 'bash: missing a non-empty "command" string argument. Put the shell command to run in the "command" field.',
+            };
+        }
         // Execute pre-bash hooks
         try {
             await this.deps.hooksManager.executeHooks("pre-bash", { command });
@@ -754,6 +839,15 @@ export class ToolHandler {
                 const args = JSON.parse(toolCall.function.arguments);
                 const command = args.command;
                 const timeout = args.timeout || 30000;
+                // A weaker model can emit a `bash` call without a `command` (or a
+                // non-string one). Fail with a clear, recoverable message instead of
+                // crashing downstream on `command.trim()` (auto-repair can then re-prompt).
+                if (typeof command !== 'string' || command.trim() === '') {
+                    return {
+                        success: false,
+                        error: 'bash: missing a non-empty "command" string argument. Put the shell command to run in the "command" field.',
+                    };
+                }
                 const gen = this.bash.executeStreaming(command, timeout);
                 let result = await gen.next();
                 while (!result.done) {
@@ -778,8 +872,15 @@ export class ToolHandler {
                     mode: mode,
                 });
                 reasoner.setMode(mode);
+                const problem = args.problem;
+                if (typeof problem !== 'string' || problem.trim() === '') {
+                    return {
+                        success: false,
+                        error: 'reason: missing a non-empty "problem" string argument. Put the problem to reason about in the "problem" field.',
+                    };
+                }
                 const gen = reasoner.solveStreaming({
-                    description: args.problem,
+                    description: problem,
                     context: args.context,
                     constraints: args.constraints,
                 });
@@ -796,6 +897,31 @@ export class ToolHandler {
                 return { success: false, error: `Reasoning error: ${getErrorMessage(error)}` };
             }
         }
+        // generate_document: stream the build phases (prepare → parse → build →
+        // write → verify → done) so the UI shows the steps unfold one by one
+        // instead of a single opaque "Created X" at the end.
+        if (toolName === 'generate_document') {
+            try {
+                const args = JSON.parse(toolCall.function.arguments);
+                const { executeGenerateDocumentStreaming } = await import('../tools/document-generator.js');
+                const gen = executeGenerateDocumentStreaming({
+                    type: args.type,
+                    title: args.title,
+                    content: args.content,
+                    outputPath: args.outputPath ?? args.output_path,
+                    theme: args.theme,
+                });
+                let r = await gen.next();
+                while (!r.done) {
+                    yield r.value;
+                    r = await gen.next();
+                }
+                return r.value ?? { success: false, error: 'Document tool returned no result' };
+            }
+            catch (error) {
+                return { success: false, error: `Document streaming error: ${getErrorMessage(error)}` };
+            }
+        }
         // Fallback: non-streaming execution
         return await this.executeTool(toolCall);
     }