@synergenius/flow-weaver-pack-weaver 0.9.199 → 0.9.201

package/dist/node-types/plan-task.d.ts

@@ -1,20 +1,11 @@
-/**
- * Agent loop: sends task + tools to the AI, executes tool calls iteratively
- * until the AI signals completion or a safety limit is reached.
- *
- * Replaces the old Plan Task → Execute & Validate two-phase workflow.
- *
- * @flowWeaver nodeType
- * @label Agent Loop
- * @icon psychology
- * @color blue
- * @input ctx [order:0] - Weaver context (JSON)
- * @input [modelOverride] [order:1] - Model ID override from profile behavior
- * @output ctx [order:0] - Weaver context with results (JSON)
- * @output onSuccess [order:-2] - On Success
- * @output onFailure [order:-1] [hidden] - On Failure
- */
-export declare function weaverPlanTask(execute: boolean, ctx: string, modelOverride?: string): Promise<{
+import type { AiTool } from '../bot/ai-client.js';
+/** All known tool schemas, keyed by operation name. */
+export declare const TOOL_SCHEMAS: Record<string, AiTool>;
+export declare function classifyToolRejection(toolName: string): {
+    code: 'MISSING_SCHEMA' | 'NOT_GRANTED' | 'HALLUCINATED';
+    detail: string;
+};
+export declare function weaverPlanTask(ctx: string, execute: boolean, modelOverride?: string): Promise<{
     onSuccess: boolean;
     onFailure: boolean;
     ctx: string;

package/dist/node-types/plan-task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan-task.d.ts","sourceRoot":"","sources":["../../src/node-types/plan-task.ts"],"names":[],"mappings":"AAgIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,EACX,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC;IACT,SAAS,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IACvC,GAAG,EAAE,MAAM,CAAC;CACb,CAAC,CAmUD"}
+{"version":3,"file":"plan-task.d.ts","sourceRoot":"","sources":["../../src/node-types/plan-task.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAyBlD,uDAAuD;AACvD,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA2H/C,CAAC;AAMF,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,gBAAgB,GAAG,aAAa,GAAG,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAsBnI;AAmCD,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,EAChB,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAsNlE"}

package/dist/node-types/plan-task.js

@@ -1,7 +1,8 @@
-import { callPlatformWithMessages, callCapabilityTriage } from '../bot/ai-client.js';
 import { auditEmit } from '../bot/audit-logger.js';
-import { executeStep } from '../bot/step-executor.js';
 import { getCapabilitiesByNames, BUILT_IN_CAPABILITIES, PROFILE_CAPABILITIES } from '../bot/capability-registry.js';
+import { ALL_TOOLS } from '../bot/tool-registry.js';
+import { createWeaverExecutor, WEAVER_TOOLS } from '../bot/weaver-tools.js';
+import { runAgentLoop, stripMcpToolPrefix, } from '@synergenius/flow-weaver/agent';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import * as nodePath from 'node:path';
@@ -15,7 +16,7 @@ catch { }
 // Tool definitions — built dynamically from capability-granted operations
 // ---------------------------------------------------------------------------
 /** All known tool schemas, keyed by operation name. */
-const TOOL_SCHEMAS = {
+export const TOOL_SCHEMAS = {
     read_file: {
         name: 'read_file',
         description: 'Read a file and return its content',
@@ -84,13 +85,89 @@ const TOOL_SCHEMAS = {
         description: 'Validate a Flow Weaver workflow file',
         parameters: { type: 'object', properties: { file: { type: 'string' } }, required: ['file'] },
     },
+    tsc_check: {
+        name: 'tsc_check',
+        description: 'Run TypeScript compiler check (npx tsc --noEmit). Returns errors if any.',
+        parameters: { type: 'object', properties: {}, required: [] },
+    },
+    run_tests: {
+        name: 'run_tests',
+        description: 'Run project tests (npx vitest run). Returns structured results with pass/fail counts.',
+        parameters: { type: 'object', properties: { pattern: { type: 'string', description: 'Test file pattern (optional)' } } },
+    },
+    learn: {
+        name: 'learn',
+        description: 'Store a fact for future tasks. Key should be descriptive.',
+        parameters: { type: 'object', properties: { key: { type: 'string' }, value: { type: 'string' } }, required: ['key', 'value'] },
+    },
+    web_fetch: {
+        name: 'web_fetch',
+        description: 'Fetch HTTP content from a URL. Returns text body (max 10KB).',
+        parameters: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] },
+    },
+    task_list: {
+        name: 'task_list',
+        description: 'List tasks in the swarm task pool. Optionally filter by status.',
+        parameters: { type: 'object', properties: { status: { type: 'string', description: 'Filter: pending, in-progress, done, failed' } } },
+    },
+    task_get: {
+        name: 'task_get',
+        description: 'Get full details of a specific task by ID.',
+        parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] },
+    },
+    task_update: {
+        name: 'task_update',
+        description: 'Update a task — add notes, change files list, or update description.',
+        parameters: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                notes: { type: 'string' },
+                files: { type: 'array', items: { type: 'string' } },
+                description: { type: 'string' },
+            },
+            required: ['id'],
+        },
+    },
+    ask_user: {
+        name: 'ask_user',
+        description: 'Ask the user a question and wait for response.',
+        parameters: { type: 'object', properties: { question: { type: 'string' } }, required: ['question'] },
+    },
     respond: {
         name: 'respond',
         description: 'Send a text response to the user',
         parameters: { type: 'object', properties: { response: { type: 'string' } }, required: ['response'] },
     },
 };
-/** Build tool definitions from capability-granted operation names. */
+// ---------------------------------------------------------------------------
+// Classification utility (exported for tests)
+// ---------------------------------------------------------------------------
+export function classifyToolRejection(toolName) {
+    const normalized = stripMcpToolPrefix(toolName);
+    const allToolNames = new Set(ALL_TOOLS.map(t => t.name));
+    const hasRegistry = allToolNames.has(normalized);
+    const hasSchema = !!TOOL_SCHEMAS[normalized];
+    if (hasRegistry && !hasSchema) {
+        return {
+            code: 'MISSING_SCHEMA',
+            detail: `Tool '${normalized}' exists in tool-registry but has no TOOL_SCHEMAS entry in plan-task. The model sees it in the prompt but cannot call it. Add it to TOOL_SCHEMAS.`,
+        };
+    }
+    if (hasRegistry && hasSchema) {
+        return {
+            code: 'NOT_GRANTED',
+            detail: `Tool '${normalized}' exists and has a schema but was not granted for this task's mode/capabilities. Check resolveToolsForTask and capability config.`,
+        };
+    }
+    return {
+        code: 'HALLUCINATED',
+        detail: `Tool '${normalized}' does not exist in tool-registry. The model invented a tool name.`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Prompt building helpers
+// ---------------------------------------------------------------------------
 function buildToolDefinitions(grantedTools) {
     const tools = [];
     const seen = new Set();
@@ -99,317 +176,201 @@ function buildToolDefinitions(grantedTools) {
             continue;
         seen.add(name);
         const schema = TOOL_SCHEMAS[name];
-        if (schema)
+        if (schema) {
             tools.push(schema);
+        }
+        else {
+            console.error(`\x1b[33m  ⚠ Tool '${name}' granted by capabilities but has no TOOL_SCHEMAS entry — model cannot call it\x1b[0m`);
+            auditEmit('tool-schema-missing', { tool: name, grantedTools });
+        }
     }
-    // Always include 'done' so the AI can signal completion
     if (!seen.has('done')) {
         tools.push(TOOL_SCHEMAS.done);
     }
     return tools;
 }
 // ---------------------------------------------------------------------------
-// Safety limits
-// ---------------------------------------------------------------------------
-const MAX_TOOL_CALLS = 30;
-const AGENT_TIMEOUT_MS = 180_000; // 3 minutes
-// ---------------------------------------------------------------------------
-// Agent Loop — replaces Plan Task + Execute & Validate
+// Main entry point
 // ---------------------------------------------------------------------------
-/**
- * Agent loop: sends task + tools to the AI, executes tool calls iteratively
- * until the AI signals completion or a safety limit is reached.
- *
- * Replaces the old Plan Task → Execute & Validate two-phase workflow.
- *
- * @flowWeaver nodeType
- * @label Agent Loop
- * @icon psychology
- * @color blue
- * @input ctx [order:0] - Weaver context (JSON)
- * @input [modelOverride] [order:1] - Model ID override from profile behavior
- * @output ctx [order:0] - Weaver context with results (JSON)
- * @output onSuccess [order:-2] - On Success
- * @output onFailure [order:-1] [hidden] - On Failure
- */
-export async function weaverPlanTask(execute, ctx, modelOverride) {
+const AGENT_TIMEOUT_MS = 10 * 60 * 1000; // 10 min
+export async function weaverPlanTask(ctx, execute, modelOverride) {
     const context = JSON.parse(ctx);
     const { env } = context;
     if (!execute) {
-        context.planJson = '{"steps":[],"summary":"dry run"}';
-        context.resultJson = JSON.stringify({ success: true, toolCallCount: 0 });
-        context.filesModified = '[]';
-        context.stepLogJson = '[]';
-        context.allValid = true;
         return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
     }
     const pInfo = modelOverride
         ? { ...env.providerInfo, model: modelOverride }
         : env.providerInfo;
     const { projectDir } = env;
-    if (!context.taskJson) {
-        context.planJson = JSON.stringify({ steps: [], summary: 'Agent loop failed: missing taskJson' });
-        context.resultJson = JSON.stringify({ success: false, error: 'missing taskJson' });
-        context.filesModified = '[]';
-        context.stepLogJson = '[]';
-        context.allValid = false;
-        return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
-    }
-    const task = JSON.parse(context.taskJson);
-    // Resolve available capabilities: profile pool > behavior config > all defaults
-    const behavior = context.behaviorJson ? JSON.parse(context.behaviorJson) : undefined;
-    const profilePool = task.assignedProfile ? PROFILE_CAPABILITIES[task.assignedProfile] : undefined;
-    const availableCapNames = profilePool ?? behavior?.capabilities ?? BUILT_IN_CAPABILITIES.map(c => c.name);
-    const availableCaps = getCapabilitiesByNames(availableCapNames);
-    // Capability triage: only run when using the default (all) pool.
-    // Profile pools are already scoped — triage would just add latency + cost.
-    let selectedCaps = availableCaps;
-    if (!profilePool) {
-        const triageResult = await callCapabilityTriage(pInfo, task.instruction, availableCaps);
-        if (triageResult) {
-            selectedCaps = getCapabilitiesByNames(triageResult);
-        }
-    }
+    const task = context.taskJson ? JSON.parse(context.taskJson) : { instruction: '', mode: 'create' };
+    // -----------------------------------------------------------------------
     // Build system prompt from capabilities
+    // -----------------------------------------------------------------------
+    const selectedCaps = (() => {
+        const profilePool = task.assignedProfile ? PROFILE_CAPABILITIES[task.assignedProfile] : undefined;
+        if (profilePool) {
+            return getCapabilitiesByNames(profilePool);
+        }
+        // Fallback: triage
+        try {
+            return getCapabilitiesByNames(['core', 'file-ops', 'shell', 'context']);
+        }
+        catch {
+            return BUILT_IN_CAPABILITIES.slice(0, 4);
+        }
+    })();
+    const selectedCapNames = new Set(selectedCaps.map(c => c.name));
     let systemPrompt;
+    let tools;
     try {
         const mod = await import('../bot/system-prompt.js');
+        const mod2 = await import('../bot/system-prompt.js');
         const basePrompt = mod.buildPromptFromCapabilities(selectedCaps);
-        const selectedCapNames = new Set(selectedCaps.map(c => c.name));
         const contextBundle = selectedCapNames.has('context') ? context.contextBundle : undefined;
         const botPrompt = mod.buildBotSystemPrompt(contextBundle, undefined, context.env?.projectDir);
         systemPrompt = basePrompt + '\n\n' + botPrompt;
-    }
-    catch (err) {
-        if (process.env.WEAVER_VERBOSE)
-            console.error('[agent-loop] system prompt build failed:', err);
-        systemPrompt = 'You are Weaver, an AI workflow bot. Use the provided tools to complete tasks.';
-    }
-    // Build tool definitions from capability-granted operations
-    let tools;
-    try {
-        const mod2 = await import('../bot/system-prompt.js');
         const grantedTools = mod2.collectToolsFromCapabilities(selectedCaps);
         tools = buildToolDefinitions(grantedTools);
     }
     catch (err) {
         console.warn('[plan-task] capability resolution failed, using worker defaults:', err);
-        // Fallback: worker tools only — NO task_create (that's orchestrator-only)
         tools = buildToolDefinitions(['read_file', 'write_file', 'patch_file', 'run_shell', 'list_files']);
+        systemPrompt = 'You are Weaver. Execute tasks by calling tools.';
     }
-    // Build initial user prompt
-    // Only mention task_create if the tool is actually available (orchestrator only)
+    // Build user prompt
     const hasTaskCreate = tools.some(t => t.name === 'task_create');
-    let userPrompt = `Task: ${task.instruction}\nMode: ${task.mode ?? 'create'}\n${task.id && hasTaskCreate ? `Your Task ID is ${task.id}. Use parentId: "@self" in task_create to create subtasks under this task.` : ''}\n${task.targets ? 'Targets: ' + task.targets.join(', ') : ''}
+    const maxConcurrent = context.maxConcurrent ?? 2;
+    let userPrompt = `Task: ${task.instruction}\nMode: ${task.mode ?? 'create'}\n${task.id && hasTaskCreate ? `Your Task ID is ${task.id}. Use parentId: "@self" in task_create to create subtasks under this task.\nWorkers available: ${maxConcurrent} (plan task grouping to maximize parallel utilization)` : ''}\n${task.targets ? 'Targets: ' + task.targets.join(', ') : ''}
+
+${context.contextBundle || ''}
 
 Execute this task step by step using the available tools.
 When you are done, call the "done" tool with a summary of what you accomplished.
 Rules:
 1. Read files before modifying them (use read_file to get exact content for patches).
 2. Use patch_file for modifications, write_file only for new files.
-3. Verify your work by running tests or tsc when appropriate.`;
-    // Append retry context when this is a convergent re-run (runHistory has prior entries)
-    const runCount = task.runHistory?.length ?? 0;
-    if (runCount > 0) {
-        const retryParts = ['\n\n--- RETRY CONTEXT (run ' + (runCount + 1) + ') ---'];
-        const summaries = task.runHistory ?? [];
-        const lastSummary = summaries.length > 0 ? summaries[summaries.length - 1] : undefined;
-        if (lastSummary?.error) {
-            retryParts.push('Previous attempt failed with error: ' + lastSummary.error);
-        }
-        if (lastSummary) {
-            if (lastSummary.outcome)
-                retryParts.push('Last outcome: ' + lastSummary.outcome);
-            if (lastSummary.summary)
-                retryParts.push('Last summary: ' + lastSummary.summary);
-            if (lastSummary.filesModified && lastSummary.filesModified.length > 0) {
-                retryParts.push('Files already created/modified: ' + lastSummary.filesModified.join(', '));
-            }
-        }
-        retryParts.push('Do NOT recreate files that already exist. Read them first and continue from where the previous attempt left off.');
-        retryParts.push('---');
-        userPrompt += retryParts.join('\n');
-    }
-    // Seed symbolic ID map for task references
-    const symbolicIdMap = {};
-    if (task.id)
-        symbolicIdMap['@self'] = task.id;
-    if (task.parentId)
-        symbolicIdMap['@parent'] = task.parentId;
-    // State tracking
+3. Verify your work by running tests or tsc when appropriate.`.trim();
+    // -----------------------------------------------------------------------
+    // Create provider + executor, run via runAgentLoop
+    // -----------------------------------------------------------------------
+    const { createProvider } = await import('./agent-execute.js');
+    const provider = await createProvider(pInfo, projectDir);
+    const providerStats = provider.stats;
+    auditEmit('bridge-created', {
+        providerType: pInfo.type,
+        providerClass: provider.constructor?.name ?? 'unknown',
+        bridgeActive: providerStats?.bridgeActive ?? false,
+        bridgeConfigPath: providerStats?.bridgeConfigPath ?? null,
+    });
+    const executor = createWeaverExecutor(projectDir);
+    const filesCreated = [];
     const filesModified = [];
     const stepLog = [];
     let toolCallCount = 0;
-    const deadline = Date.now() + AGENT_TIMEOUT_MS;
-    // Messages array for multi-turn conversation
-    const messages = [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-    // Build allowed tool name set for validation (always includes 'done' and 'complete')
-    const allowedToolNames = new Set(tools.map(t => t.name));
-    allowedToolNames.add('done');
-    allowedToolNames.add('complete');
-    auditEmit('run-start', { task: task.instruction, mode: 'agent-loop', packVersion: PACK_VERSION, profile: task.assignedProfile });
-    auditEmit('ai-request', {
-        systemPrompt: systemPrompt.slice(0, 2000),
-        userPrompt: userPrompt.slice(0, 2000),
-        tools: tools.map(t => t.name),
-    });
-    try {
-        // Agent loop
-        let done = false;
-        while (!done && toolCallCount < MAX_TOOL_CALLS && Date.now() < deadline) {
-            const result = await callPlatformWithMessages(messages, tools, pInfo.model, pInfo.maxTokens ?? 8192);
-            auditEmit('ai-response', {
+    const onToolEvent = (event) => {
+        if (event.type === 'tool_call_start') {
+            toolCallCount++;
+            const name = stripMcpToolPrefix(event.name);
+            console.log(`\x1b[32m  + ${toolCallCount}: ${name}\x1b[0m`);
+            auditEmit('tool-call', {
                 turn: toolCallCount,
-                content: result.content?.slice(0, 2000) ?? null,
-                thinking: result.thinking?.slice(0, 2000) ?? null,
-                toolCallCount: result.toolCalls?.length ?? 0,
-                toolNames: result.toolCalls?.map(tc => tc.name) ?? [],
+                tool: name,
+                args: JSON.stringify(event.args ?? {}).slice(0, 1000),
             });
-            // If AI returns text with no tool calls, we're done
-            if (!result.toolCalls || result.toolCalls.length === 0) {
-                if (result.content) {
-                    console.log(`\x1b[36m→ Agent: ${result.content.slice(0, 200)}\x1b[0m`);
-                }
-                done = true;
-                break;
-            }
-            // Process each tool call
-            for (const tc of result.toolCalls) {
-                if (toolCallCount >= MAX_TOOL_CALLS || Date.now() >= deadline) {
-                    done = true;
-                    break;
-                }
-                toolCallCount++;
-                const toolName = tc.name;
-                const toolArgs = tc.arguments;
-                auditEmit('tool-call', {
-                    turn: toolCallCount,
-                    tool: toolName,
-                    args: JSON.stringify(toolArgs).slice(0, 1000),
-                });
-                // Check for done signal
-                if (toolName === 'done' || toolName === 'complete') {
-                    console.log(`\x1b[36m→ Agent done: ${toolArgs.summary ?? 'completed'}\x1b[0m`);
-                    // Execute through step-executor for consistent handling
-                    try {
-                        const stepResult = await executeStep({ operation: toolName, args: toolArgs }, projectDir, symbolicIdMap);
-                        stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'ok', detail: stepResult.output ?? 'done' });
-                    }
-                    catch {
-                        stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'ok', detail: 'done' });
-                    }
-                    auditEmit('tool-result', { turn: toolCallCount, tool: 'done', status: 'ok', output: 'completed' });
-                    // Add assistant message with tool use and tool result to messages
-                    messages.push({
-                        role: 'assistant',
-                        content: result.content || undefined,
-                        tool_use: { id: tc.id, name: toolName, input: toolArgs },
-                    });
-                    messages.push({
-                        role: 'user',
-                        tool_use_id: tc.id,
-                        content: 'Task completed.',
-                    });
-                    done = true;
-                    break;
-                }
-                // Validate tool name against allowed list to prevent hallucinated tool execution
-                if (!allowedToolNames.has(toolName)) {
-                    const available = [...allowedToolNames].sort().join(', ');
-                    const toolOutput = `Unknown tool: ${toolName}. Available tools: ${available}`;
-                    stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'error', detail: toolOutput });
-                    console.error(`\x1b[31m  x ${toolCallCount}: ${toolName}: hallucinated tool\x1b[0m`);
-                    auditEmit('tool-result', {
-                        turn: toolCallCount,
-                        tool: toolName,
-                        status: 'rejected',
-                        output: toolOutput.slice(0, 500),
-                    });
-                    messages.push({
-                        role: 'assistant',
-                        content: result.content || undefined,
-                        tool_use: { id: tc.id, name: toolName, input: toolArgs },
-                    });
-                    messages.push({
-                        role: 'user',
-                        tool_use_id: tc.id,
-                        content: toolOutput,
-                    });
-                    continue;
-                }
-                // Execute the tool via step-executor
-                let toolOutput;
-                try {
-                    const stepResult = await executeStep({ operation: toolName, args: toolArgs }, projectDir, symbolicIdMap);
-                    // Track files modified — only from write/patch operations, not reads/listings
-                    const isWriteOp = toolName === 'write_file' || toolName === 'patch_file' || toolName === 'create_workflow' || toolName === 'modify_source' || toolName === 'implement_node';
-                    if (isWriteOp && stepResult.file)
-                        filesModified.push(stepResult.file);
-                    // Build output for AI
-                    if (stepResult.blocked) {
-                        toolOutput = `BLOCKED: ${stepResult.blockReason}`;
-                        stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'blocked', detail: stepResult.blockReason });
-                    }
-                    else {
-                        toolOutput = stepResult.output ?? 'OK';
-                        stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'ok', detail: toolName });
-                    }
-                    console.log(`\x1b[32m  + ${toolCallCount}: ${toolName}\x1b[0m`);
-                    auditEmit('tool-result', {
-                        turn: toolCallCount,
-                        tool: toolName,
-                        status: stepResult.blocked ? 'blocked' : 'ok',
-                        output: toolOutput.slice(0, 1000),
-                    });
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    toolOutput = `ERROR: ${msg}`;
-                    stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'error', detail: msg });
-                    console.error(`\x1b[31m  x ${toolCallCount}: ${toolName}: ${msg}\x1b[0m`);
-                    auditEmit('tool-result', {
-                        turn: toolCallCount,
-                        tool: toolName,
-                        status: 'error',
-                        output: msg.slice(0, 1000),
-                    });
-                }
-                // Append assistant tool_use + tool result to messages for next iteration
-                messages.push({
-                    role: 'assistant',
-                    content: result.content || undefined,
-                    tool_use: { id: tc.id, name: toolName, input: toolArgs },
-                });
-                messages.push({
-                    role: 'user',
-                    tool_use_id: tc.id,
-                    content: toolOutput,
-                });
+        }
+        if (event.type === 'tool_call_result') {
+            const name = stripMcpToolPrefix(event.name);
+            auditEmit('tool-result', { tool: name, isError: event.isError, result: (event.result ?? '').slice(0, 500) });
+            stepLog.push({
+                step: `${toolCallCount}:${name}`,
+                status: event.isError ? 'error' : 'ok',
+                detail: event.isError ? (event.result ?? '').slice(0, 200) : name,
+            });
+            // Track file changes
+            if (!event.isError && event.args?.file) {
+                if (name === 'write_file')
+                    filesCreated.push(event.args.file);
+                if (name === 'patch_file')
+                    filesModified.push(event.args.file);
             }
         }
-        // Deduplicate files
-        const uniqueFiles = [...new Set(filesModified)];
-        // Store results in context (compatible with exec-validate-retry output format)
+    };
+    const onStreamEvent = (event) => {
+        if (event.type === 'text_delta') {
+            process.stderr.write(`\x1b[36m${event.text}\x1b[0m`);
+        }
+        if (event.type === 'thinking_delta') {
+            process.stderr.write('\x1b[90m  thinking...\x1b[0m');
+        }
+    };
+    // Convert WEAVER_TOOLS to ToolDefinition format for runAgentLoop
+    const grantedToolNames = new Set(tools.map(t => t.name));
+    grantedToolNames.add('done');
+    grantedToolNames.add('complete');
+    const loopTools = WEAVER_TOOLS.filter(t => grantedToolNames.has(t.name));
+    auditEmit('run-start', { task: task.instruction, mode: 'agent-loop', packVersion: PACK_VERSION, profile: task.assignedProfile });
+    auditEmit('ai-request', {
+        systemPrompt,
+        userPrompt,
+        tools,
+        capabilities: selectedCaps.map(c => c.name),
+        model: pInfo.model,
+        providerType: pInfo.type,
+    });
+    try {
+        const result = await runAgentLoop(provider, loopTools, executor, [{ role: 'user', content: userPrompt }], {
+            systemPrompt: { prefix: systemPrompt, suffix: '' },
+            maxIterations: 30,
+            onToolEvent,
+            onStreamEvent,
+        });
+        const usage = result.usage;
+        const uniqueCreated = [...new Set(filesCreated)];
+        const uniqueModified = [...new Set(filesModified)];
         context.resultJson = JSON.stringify({
             success: true,
             toolCallCount,
-            filesModified: uniqueFiles,
+            filesCreated: uniqueCreated,
+            filesModified: uniqueModified,
             stepsCompleted: toolCallCount,
             stepsTotal: toolCallCount,
         });
         context.planJson = JSON.stringify({ steps: [], summary: `Agent loop: ${toolCallCount} tool calls` });
-        context.filesModified = JSON.stringify(uniqueFiles);
+        context.filesModified = JSON.stringify([...uniqueCreated, ...uniqueModified]);
         context.stepLogJson = JSON.stringify(stepLog);
         context.allValid = true;
+        // Re-read provider stats after loop (they accumulate during streaming)
+        const finalStats = provider.stats;
         auditEmit('run-complete', {
             success: true,
             toolCalls: toolCallCount,
-            filesModified: uniqueFiles.length,
+            filesCreated: uniqueCreated.length,
+            filesModified: uniqueModified.length,
+            usage,
+            bridge: finalStats ? {
+                active: finalStats.bridgeActive,
+                toolUseFiltered: finalStats.toolUseFiltered,
+                toolResultPassthrough: finalStats.toolResultPassthrough,
+                textToolCallDetected: finalStats.textToolCallDetected,
+                streamCalls: finalStats.streamCalls,
+                setHandlersCalls: finalStats.setHandlersCalls,
+            } : undefined,
         });
-        console.log(`\x1b[36m→ Agent loop: ${toolCallCount} tool calls, ${uniqueFiles.length} files modified\x1b[0m`);
+        // Surface bridge issues immediately in console output
+        if (finalStats?.bridgeActive) {
+            if (finalStats.textToolCallDetected > 0) {
+                console.error(`\x1b[31m  ✗ BRIDGE ISSUE: Model output ${finalStats.textToolCallDetected} tool calls as TEXT — MCP tools not connected to CLI session\x1b[0m`);
+            }
+            if (finalStats.toolUseFiltered === 0 && finalStats.toolResultPassthrough === 0) {
+                console.warn(`\x1b[33m  ⚠ Bridge active but zero structured tool events (filtered=0, passthrough=0)\x1b[0m`);
+            }
+            else {
+                console.log(`\x1b[32m  ✓ Bridge: ${finalStats.toolUseFiltered} tool_use filtered, ${finalStats.toolResultPassthrough} tool_result passed through\x1b[0m`);
+            }
+        }
+        const costStr = usage.costUsd > 0 ? ` | $${usage.costUsd.toFixed(4)}` : '';
+        console.log(`\x1b[36m→ Agent loop: ${toolCallCount} tool calls, ${uniqueCreated.length + uniqueModified.length} files changed${costStr}\x1b[0m`);
         return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
     }
     catch (err) {
@@ -417,7 +378,7 @@ Rules:
         console.error(`\x1b[31m→ Agent loop failed: ${msg}\x1b[0m`);
         context.resultJson = JSON.stringify({ success: false, error: msg });
         context.planJson = JSON.stringify({ steps: [], summary: `Agent loop failed: ${msg}` });
-        context.filesModified = JSON.stringify([...new Set(filesModified)]);
+        context.filesModified = JSON.stringify([...new Set([...filesCreated, ...filesModified])]);
         context.stepLogJson = JSON.stringify(stepLog);
         context.allValid = false;
         return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };