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

package/src/node-types/plan-task.ts

@@ -1,9 +1,16 @@
 import type { WeaverContext, StepLogEntry } from '../bot/types.js';
-import { callPlatformWithMessages, callCapabilityTriage } from '../bot/ai-client.js';
-import type { AiTool, AiCallResult, ChatMessage } from '../bot/ai-client.js';
+import { callCapabilityTriage } from '../bot/ai-client.js';
+import type { AiTool } 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, BOT_TOOLS, resolveToolsForTask } from '../bot/tool-registry.js';
+import { createWeaverExecutor, WEAVER_TOOLS } from '../bot/weaver-tools.js';
+import {
+  runAgentLoop,
+  stripMcpToolPrefix,
+  type ToolEvent,
+  type StreamEvent,
+} from '@synergenius/flow-weaver/agent';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import * as nodePath from 'node:path';
@@ -19,7 +26,7 @@ try {
 // ---------------------------------------------------------------------------
 
 /** All known tool schemas, keyed by operation name. */
-const TOOL_SCHEMAS: Record<string, AiTool> = {
+export const TOOL_SCHEMAS: Record<string, AiTool> = {
   read_file: {
     name: 'read_file',
     description: 'Read a file and return its content',
@@ -88,6 +95,55 @@ const TOOL_SCHEMAS: Record<string, AiTool> = {
     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',
@@ -95,7 +151,38 @@ const TOOL_SCHEMAS: Record<string, AiTool> = {
   },
 };
 
-/** Build tool definitions from capability-granted operation names. */
+// ---------------------------------------------------------------------------
+// Classification utility (exported for tests)
+// ---------------------------------------------------------------------------
+
+export function classifyToolRejection(toolName: string): { code: 'MISSING_SCHEMA' | 'NOT_GRANTED' | 'HALLUCINATED'; detail: string } {
+  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: string[]): AiTool[] {
   const tools: AiTool[] = [];
   const seen = new Set<string>();
@@ -104,10 +191,14 @@ function buildToolDefinitions(grantedTools: string[]): AiTool[] {
     if (seen.has(name)) continue;
     seen.add(name);
     const schema = TOOL_SCHEMAS[name];
-    if (schema) tools.push(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);
   }
@@ -116,49 +207,20 @@ function buildToolDefinitions(grantedTools: string[]): AiTool[] {
 }
 
 // ---------------------------------------------------------------------------
-// Safety limits
+// Main entry point
 // ---------------------------------------------------------------------------
 
-const MAX_TOOL_CALLS = 30;
-const AGENT_TIMEOUT_MS = 180_000; // 3 minutes
+const AGENT_TIMEOUT_MS = 10 * 60 * 1000; // 10 min
 
-// ---------------------------------------------------------------------------
-// Agent Loop — replaces Plan Task + Execute & Validate
-// ---------------------------------------------------------------------------
-
-/**
- * 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: boolean,
   ctx: string,
+  execute: boolean,
   modelOverride?: string,
-): Promise<{
-  onSuccess: boolean; onFailure: boolean;
-  ctx: string;
-}> {
+): Promise<{ onSuccess: boolean; onFailure: boolean; ctx: string }> {
   const context = JSON.parse(ctx) as WeaverContext;
   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) };
   }
 
@@ -166,299 +228,195 @@ export async function weaverPlanTask(
     ? { ...env.providerInfo, model: modelOverride }
     : env.providerInfo;
   const { projectDir } = env;
+  const task = context.taskJson ? JSON.parse(context.taskJson) : { instruction: '', mode: 'create' };
 
-  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: string[] = 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);
+  // -----------------------------------------------------------------------
+  // 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));
 
-  // Build system prompt from capabilities
   let systemPrompt: string;
+  let tools: AiTool[];
   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: AiTool[];
-  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 as any).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: string[] = ['\n\n--- RETRY CONTEXT (run ' + (runCount + 1) + ') ---'];
-    const summaries: Array<{ outcome?: string; filesModified?: string[]; summary?: string; error?: string }> = 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: Record<string, string> = {};
-  if (task.id) symbolicIdMap['@self'] = task.id;
-  if (task.parentId) symbolicIdMap['@parent'] = task.parentId;
+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 as unknown as { stats?: { bridgeActive: boolean; bridgeConfigPath?: string; toolUseFiltered: number; toolResultPassthrough: number; textToolCallDetected: number; streamCalls: number; setHandlersCalls: number } }).stats;
+  auditEmit('bridge-created', {
+    providerType: pInfo.type,
+    providerClass: provider.constructor?.name ?? 'unknown',
+    bridgeActive: providerStats?.bridgeActive ?? false,
+    bridgeConfigPath: providerStats?.bridgeConfigPath ?? null,
+  });
+  const executor = createWeaverExecutor(projectDir);
 
-  // State tracking
+  const filesCreated: string[] = [];
   const filesModified: string[] = [];
   const stepLog: StepLogEntry[] = [];
   let toolCallCount = 0;
-  const deadline = Date.now() + AGENT_TIMEOUT_MS;
 
-  // Messages array for multi-turn conversation
-  const messages: ChatMessage[] = [
-    { role: 'system', content: systemPrompt },
-    { role: 'user', content: userPrompt },
-  ];
+  const onToolEvent = (event: ToolEvent) => {
+    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,
+        tool: name,
+        args: JSON.stringify(event.args ?? {}).slice(0, 1000),
+      });
+    }
+    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,
+      });
 
-  // 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');
+      // Track file changes
+      if (!event.isError && event.args?.file) {
+        if (name === 'write_file') filesCreated.push(event.args.file as string);
+        if (name === 'patch_file') filesModified.push(event.args.file as string);
+      }
+    }
+  };
+
+  const onStreamEvent = (event: StreamEvent) => {
+    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: systemPrompt.slice(0, 2000),
-    userPrompt: userPrompt.slice(0, 2000),
-    tools: tools.map(t => t.name),
+    systemPrompt,
+    userPrompt,
+    tools,
+    capabilities: selectedCaps.map(c => c.name),
+    model: pInfo.model,
+    providerType: pInfo.type,
   });
 
   try {
-    // Agent loop
-    let done = false;
-    while (!done && toolCallCount < MAX_TOOL_CALLS && Date.now() < deadline) {
-      const result: AiCallResult = await callPlatformWithMessages(messages, tools, pInfo.model, pInfo.maxTokens ?? 8192);
-
-      auditEmit('ai-response', {
-        turn: toolCallCount,
-        content: result.content?.slice(0, 2000) ?? null,
-        thinking: (result as any).thinking?.slice(0, 2000) ?? null,
-        toolCallCount: result.toolCalls?.length ?? 0,
-        toolNames: result.toolCalls?.map(tc => tc.name) ?? [],
-      });
-
-      // 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 as Record<string, string>).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: string;
-        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: unknown) {
-          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,
-        });
-      }
-    }
+    const result = await runAgentLoop(
+      provider,
+      loopTools,
+      executor,
+      [{ role: 'user', content: userPrompt }],
+      {
+        systemPrompt: { prefix: systemPrompt, suffix: '' },
+        maxIterations: 30,
+        onToolEvent,
+        onStreamEvent,
+      },
+    );
 
-    // Deduplicate files
-    const uniqueFiles = [...new Set(filesModified)];
+    const usage = result.usage;
+    const uniqueCreated = [...new Set(filesCreated)];
+    const uniqueModified = [...new Set(filesModified)];
 
-    // Store results in context (compatible with exec-validate-retry output format)
     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 as unknown as { stats?: typeof providerStats }).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: unknown) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -466,7 +424,7 @@ Rules:
 
     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;
 

package/src/node-types/review-result.ts

@@ -233,11 +233,12 @@ async function createReviewProvider(
 
   if (type === 'claude-cli') {
     const key = projectDir ?? process.cwd();
-    const session = getOrCreateCliSession(`${key}:reviewer`, {
-      binPath: 'claude',
+    const { getCliSessionConfig } = await import('@synergenius/flow-weaver/agent');
+    const session = getOrCreateCliSession(`${key}:reviewer`, getCliSessionConfig({
       cwd: key,
       model: pInfo.model ?? 'claude-sonnet-4-6',
-    });
+      appendSystemPrompt: 'You are a Weaver reviewer bot. Evaluate task results using only the provided tools.',
+    }));
     return new CliReviewProvider(session);
   }
 
@@ -250,11 +251,12 @@ async function createReviewProvider(
       });
     }
     const key = projectDir ?? process.cwd();
-    const session = getOrCreateCliSession(`${key}:reviewer`, {
-      binPath: 'claude',
+    const { getCliSessionConfig } = await import('@synergenius/flow-weaver/agent');
+    const session = getOrCreateCliSession(`${key}:reviewer`, getCliSessionConfig({
       cwd: key,
       model: pInfo.model ?? 'claude-sonnet-4-6',
-    });
+      appendSystemPrompt: 'You are a Weaver reviewer bot. Evaluate task results using only the provided tools.',
+    }));
     return new CliReviewProvider(session);
   }