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

package/src/node-types/agent-execute.ts

@@ -5,8 +5,10 @@ import {
   getOrCreateCliSession,
   killAllCliSessions,
   joinSplitPrompt,
+  createMcpBridge,
   type AgentProvider,
   type AgentMessage,
+  type McpBridge,
   type ToolDefinition,
   type StreamEvent,
   type StreamOptions,
@@ -20,12 +22,21 @@ import { withRetry, getErrorGuidance } from '../bot/error-classifier.js';
 import { CostTracker } from '../bot/cost-tracker.js';
 import { PostTurnHookRunner, CostCheckpointHook, ProgressReportHook } from '../bot/post-turn-hooks.js';
 
-// Clean up persistent sessions on process exit
+// Track MCP bridges for cleanup alongside CLI sessions
+const activeBridges: McpBridge[] = [];
+
+// Clean up persistent sessions and MCP bridges on process exit
 let cleanupRegistered = false;
 function registerCleanup(): void {
   if (cleanupRegistered) return;
   cleanupRegistered = true;
-  const cleanup = () => { try { killAllCliSessions(); } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] session cleanup failed:', err); } };
+  const cleanup = () => {
+    try { killAllCliSessions(); } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] session cleanup failed:', err); }
+    for (const bridge of activeBridges) {
+      try { bridge.cleanup(); } catch { /* non-fatal */ }
+    }
+    activeBridges.length = 0;
+  };
   process.on('exit', cleanup);
   process.on('SIGTERM', cleanup);
   process.on('SIGINT', cleanup);
@@ -37,13 +48,42 @@ function registerCleanup(): void {
  * we only forward the latest user/tool messages since the session
  * maintains its own conversation state.
  */
+/** Events emitted by the CLI when the model calls a tool — filtered when MCP bridge handles execution. */
+const TOOL_USE_EVENT_TYPES = new Set(['tool_use_start', 'tool_use_delta', 'tool_use_end']);
+
+/** Cumulative stats from CliSessionProvider — read by callers for audit/observability. */
+export interface CliSessionProviderStats {
+  bridgeActive: boolean;
+  bridgeConfigPath: string | undefined;
+  toolUseFiltered: number;
+  toolResultPassthrough: number;
+  textToolCallDetected: number;
+  streamCalls: number;
+  setHandlersCalls: number;
+}
+
 class CliSessionProvider implements AgentProvider {
   private sentCount = 0;
+  private _stats: CliSessionProviderStats;
 
   constructor(
     private session: { ready: boolean; spawn: () => Promise<void>; send: (msg: string, systemPrompt?: string) => AsyncGenerator<StreamEvent> },
     readonly model: string = 'claude-sonnet-4-6',
-  ) {}
+    private bridge?: McpBridge,
+  ) {
+    this._stats = {
+      bridgeActive: !!bridge,
+      bridgeConfigPath: bridge?.configPath,
+      toolUseFiltered: 0,
+      toolResultPassthrough: 0,
+      textToolCallDetected: 0,
+      streamCalls: 0,
+      setHandlersCalls: 0,
+    };
+  }
+
+  /** Observable stats — read after runAgentLoop to audit bridge behavior. */
+  get stats(): Readonly<CliSessionProviderStats> { return this._stats; }
 
   async *stream(
     messages: AgentMessage[],
@@ -51,6 +91,14 @@ class CliSessionProvider implements AgentProvider {
     options?: StreamOptions,
   ): AsyncGenerator<StreamEvent> {
     if (!this.session.ready) await this.session.spawn();
+    this._stats.streamCalls++;
+
+    // When MCP bridge is present, update its handlers so tool execution and
+    // onToolEvent callbacks use this request's executor/callback.
+    if (this.bridge && options?.executor) {
+      this.bridge.setHandlers(options.executor, options.onToolEvent);
+      this._stats.setHandlersCalls++;
+    }
 
     // Only send new messages (session has history of previous ones)
     const newMessages = messages.slice(this.sentCount);
@@ -78,6 +126,26 @@ class CliSessionProvider implements AgentProvider {
       ((model: string, usage: { inputTokens: number; outputTokens: number }) => void) | undefined;
 
     for await (const event of this.session.send(prompt, systemPromptStr)) {
+      // When MCP bridge is active, the bridge already executed tools and fired
+      // onToolEvent. Filter tool_use_* events so runAgentLoop doesn't re-execute.
+      // tool_result events pass through — the loop counts them without executing.
+      if (this.bridge && TOOL_USE_EVENT_TYPES.has(event.type)) {
+        this._stats.toolUseFiltered++;
+        continue;
+      }
+
+      if (event.type === 'tool_result') {
+        this._stats.toolResultPassthrough++;
+      }
+
+      // Detect model outputting tool calls as text (MCP not connected)
+      if (event.type === 'text_delta') {
+        const text = (event as { text?: string }).text ?? '';
+        if (text.includes('<tool_call>') || text.includes('**Tool Call') || text.includes('<function_calls>')) {
+          this._stats.textToolCallDetected++;
+        }
+      }
+
       if (event.type === 'usage' && usageCb) {
         usageCb(this.model, {
           inputTokens: event.promptTokens,
@@ -274,10 +342,13 @@ export async function weaverAgentExecute(
     );
 
     const usage = result.usage;
-    const estimatedCost = CostTracker.estimateCost(model, {
-      inputTokens: usage.promptTokens,
-      outputTokens: usage.completionTokens,
-    });
+    // Use real cost from CLI if available, fall back to estimate
+    const estimatedCost = usage.costUsd > 0
+      ? usage.costUsd
+      : CostTracker.estimateCost(model, {
+          inputTokens: usage.promptTokens,
+          outputTokens: usage.completionTokens,
+        });
 
     const uniqueCreated = [...new Set(filesCreated)];
     const uniqueModified = [...new Set(filesModified)];
@@ -397,7 +468,7 @@ export async function weaverAgentExecute(
 /**
  * Create an AgentProvider from pack-weaver's ProviderInfo.
  */
-async function createProvider(
+export async function createProvider(
   pInfo: { type: string; apiKey?: string; model?: string; maxTokens?: number },
   projectDir?: string,
 ): Promise<AgentProvider> {
@@ -433,7 +504,7 @@ async function createProvider(
 
   // Claude CLI — use persistent session for warm start
   if (type === 'claude-cli') {
-    return createSessionProvider(pInfo.model, projectDir);
+    return await createSessionProvider(pInfo.model, projectDir);
   }
 
   // Auto mode: try platform login, then Anthropic API key, then Claude CLI
@@ -459,7 +530,7 @@ async function createProvider(
       });
     }
     // No API key — use Claude CLI with persistent session
-    return createSessionProvider(pInfo.model, projectDir);
+    return await createSessionProvider(pInfo.model, projectDir);
   }
 
   throw new Error(
@@ -467,13 +538,28 @@ async function createProvider(
   );
 }
 
-function createSessionProvider(model?: string, projectDir?: string): CliSessionProvider {
+async function createSessionProvider(model?: string, projectDir?: string): Promise<CliSessionProvider> {
   registerCleanup();
   const key = projectDir ?? process.cwd();
-  const session = getOrCreateCliSession(key, {
-    binPath: 'claude',
+  const resolvedModel = model ?? 'claude-sonnet-4-6';
+
+  // Create MCP bridge so the CLI session has pack tools (read_file, write_file,
+  // run_shell, etc.) registered. The bridge uses a placeholder executor that is
+  // swapped per-request via setHandlers() in CliSessionProvider.stream().
+  const executor = createWeaverExecutor(key);
+  const bridge = await createMcpBridge(WEAVER_TOOLS, executor);
+  activeBridges.push(bridge);
+
+  // NOTE: auditEmit from this module is unreliable under symlinks (dual module
+  // instance — currentRunId may be null). Observability is handled by the caller
+  // (plan-task.ts / agent-execute node) via provider.stats after runAgentLoop.
+
+  const { getCliSessionConfig } = await import('@synergenius/flow-weaver/agent');
+  const session = getOrCreateCliSession(key, getCliSessionConfig({
     cwd: key,
-    model: model ?? 'claude-sonnet-4-6',
-  });
-  return new CliSessionProvider(session, model ?? 'claude-sonnet-4-6');
+    model: resolvedModel,
+    mcpConfigPath: bridge.configPath,
+    appendSystemPrompt: 'You are Weaver, an AI workflow bot. Use the provided tools to complete tasks. Never attempt to use built-in tools.',
+  }));
+  return new CliSessionProvider(session, resolvedModel, bridge);
 }

package/src/node-types/bot-report.ts

@@ -120,12 +120,33 @@ export async function weaverBotReport(
 
   const summary = parts.join(' | ');
 
-  // Mark queue task as completed or failed via TaskStore
+  // Mark queue task as completed or failed via TaskStore.
+  // Ensures task is in-progress before releasing (assigns if needed).
   if (task.queueId && context.env?.projectDir) {
     try {
       const store = new TaskStore(context.env.projectDir);
-      await store.update(task.queueId, { status: success ? 'done' : 'open' });
-      console.log(`\x1b[36m→ Queue task ${task.queueId}: ${success ? 'done' : 'open'}\x1b[0m`);
+      const current = await store.get(task.queueId);
+      if (current && current.status === 'open') {
+        // Standalone mode: task was never assigned. Assign first.
+        await store.assignToInstance(task.queueId, `standalone-${Date.now()}`, 'default');
+      }
+      if (current && (current.status === 'in-progress' || current.status === 'open')) {
+        const releaseStatus = success ? 'done' as const : 'open' as const;
+        await store.release(task.queueId, releaseStatus, {
+          runId: `report-${Date.now()}`,
+          botId: 'standalone',
+          profileId: 'default',
+          outcome: success ? 'completed' : 'stalled',
+          filesCreated: [],
+          filesModified: files,
+          summary: summary,
+          tokensUsed: 0,
+          cost: 0,
+          durationMs: 0,
+          endedAt: new Date().toISOString(),
+        });
+        console.log(`\x1b[36m→ Queue task ${task.queueId}: ${releaseStatus}\x1b[0m`);
+      }
     } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[bot-report] queue update failed:', err); }
   }