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

package/src/bot/ai-client.ts

@@ -67,7 +67,23 @@ export function extractCliJsonResult(raw: string): string {
   return trimmed;
 }
 
-export async function callCliAsync(provider: string, prompt: string, model?: string, systemPrompt?: string, cliBinPath?: string): Promise<string> {
+/** Callback for streaming conversation events to the EventLog. */
+export type StreamEventCallback = (event: { type: string; timestamp: number; data?: Record<string, unknown> }) => void;
+
+/**
+ * Set/clear the global stream event callback. Called by the runner before/after
+ * workflow execution so all callAI call sites automatically emit conversation events.
+ * Same pattern as __fw_ai_usage_callback__.
+ */
+export function setStreamEventCallback(cb: StreamEventCallback | undefined): void {
+  (globalThis as Record<string, unknown>).__fw_stream_event_callback__ = cb;
+}
+
+function getStreamEventCallback(): StreamEventCallback | undefined {
+  return (globalThis as Record<string, unknown>).__fw_stream_event_callback__ as StreamEventCallback | undefined;
+}
+
+export async function callCliAsync(provider: string, prompt: string, model?: string, systemPrompt?: string, cliBinPath?: string, onStreamEvent?: StreamEventCallback): Promise<string> {
   if (provider === 'copilot-cli') {
     return callCli(provider, prompt, model);
   }
@@ -75,19 +91,21 @@ export async function callCliAsync(provider: string, prompt: string, model?: str
     throw new Error(`Unknown CLI provider: ${provider}`);
   }
 
-  // Flags matching the platform's proven CLI integration:
-  // --verbose + --output-format stream-json + --include-partial-messages for incremental streaming
-  // --json-schema for structured JSON output enforcement
-  // --dangerously-skip-permissions to prevent permission prompt hangs
+  // Use explicit callback or fall back to global (set by runner)
+  const emitStreamEvent = onStreamEvent ?? getStreamEventCallback();
+
+  // Use centralized CLI config — enforces --tools "" and --strict-mcp-config
+  const { getCliBaseArgs } = await import('@synergenius/flow-weaver/agent');
   const args = [
-    '-p', '--verbose',
-    '--output-format', 'stream-json',
-    '--include-partial-messages',
-    '--json-schema', PLAN_JSON_SCHEMA,
-    '--dangerously-skip-permissions',
+    ...getCliBaseArgs({
+      model,
+      systemPrompt,
+      outputFormat: 'stream-json',
+      includePartialMessages: true,
+      jsonSchema: PLAN_JSON_SCHEMA,
+    }),
+    '--verbose',
   ];
-  if (model) args.push('--model', model);
-  if (systemPrompt) args.push('--system-prompt', systemPrompt);
 
   const bin = cliBinPath || 'claude';
   const child = spawn(bin, args, {
@@ -130,28 +148,62 @@ export async function callCliAsync(provider: string, prompt: string, model?: str
             inThinkingBlock = true;
             process.stderr.write('\x1b[90m  thinking...\x1b[0m');
           }
-          // Incremental thinking — dim text, no emoji per token
+          // Incremental thinking — emit to stream
           else if (event.type === 'content_block_delta' && event.delta?.type === 'thinking_delta' && event.delta?.thinking) {
-            // Don't stream every thinking token — just show we're thinking
+            emitStreamEvent?.({ type: 'thinking_delta', timestamp: Date.now(), data: { text: event.delta.thinking } });
+          }
+          // Thinking block end
+          else if (event.type === 'content_block_stop' && inThinkingBlock) {
+            process.stderr.write('\n');
+            inThinkingBlock = false;
+            emitStreamEvent?.({ type: 'thinking_done', timestamp: Date.now() });
           }
           // Text block start
           else if (event.type === 'content_block_start' && event.content_block?.type === 'text') {
             if (inThinkingBlock) {
               process.stderr.write('\n');
               inThinkingBlock = false;
+              emitStreamEvent?.({ type: 'thinking_done', timestamp: Date.now() });
             }
           }
-          // Incremental text — stream to stderr (chatbot-like output)
+          // Tool use block start
+          else if (event.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+            emitStreamEvent?.({ type: 'tool_use_start', timestamp: Date.now(), data: {
+              id: event.content_block.id, name: event.content_block.name,
+            }});
+          }
+          // Incremental text — stream to stderr + emit to stream
           else if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta' && event.delta?.text) {
             hasStreamedText = true;
             process.stderr.write(`\x1b[36m${event.delta.text}\x1b[0m`);
+            emitStreamEvent?.({ type: 'text_delta', timestamp: Date.now(), data: { text: event.delta.text } });
+          }
+          // Tool result — from partial messages showing tool execution results
+          else if (event.type === 'content_block_start' && event.content_block?.type === 'tool_result') {
+            emitStreamEvent?.({ type: 'tool_result', timestamp: Date.now(), data: {
+              id: event.content_block.tool_use_id,
+              result: typeof event.content_block.content === 'string'
+                ? event.content_block.content
+                : JSON.stringify(event.content_block.content ?? ''),
+              isError: event.content_block.is_error ?? false,
+            }});
+          }
+          // Subagent tool events — --include-partial-messages may emit these
+          else if (event.type === 'tool_use' || event.type === 'tool_start') {
+            emitStreamEvent?.({ type: 'tool_use_start', timestamp: Date.now(), data: {
+              id: event.id ?? event.tool_use_id, name: event.name ?? event.tool_name ?? 'tool',
+            }});
+          }
+          else if (event.type === 'tool_result') {
+            emitStreamEvent?.({ type: 'tool_result', timestamp: Date.now(), data: {
+              id: event.tool_use_id ?? event.id,
+              result: typeof event.content === 'string' ? event.content : JSON.stringify(event.content ?? ''),
+              isError: event.is_error ?? false,
+            }});
           }
           // Block boundary — newline
           else if (event.type === 'content_block_stop') {
-            if (inThinkingBlock) {
-              process.stderr.write('\n');
-              inThinkingBlock = false;
-            }
+            // handled above for thinking blocks
           }
           // Result event — contains structured_output with --json-schema
           else if (event.type === 'result') {
@@ -398,6 +450,7 @@ export async function callAI(
   systemPrompt: string,
   userPrompt: string,
   defaultMaxTokens = 4096,
+  onStreamEvent?: StreamEventCallback,
 ): Promise<string> {
   if (pInfo.type === 'platform') {
     return callPlatform(systemPrompt, userPrompt, pInfo.model, pInfo.maxTokens ?? defaultMaxTokens);
@@ -414,7 +467,7 @@ export async function callAI(
   // Async-only path: uses spawn() so Ctrl+C can kill child processes.
   // Also uses --output-format json + --json-schema to enforce JSON output
   // (eliminates hallucination entirely — no retry needed).
-  return callCliAsync(pInfo.type, userPrompt, pInfo.model, systemPrompt, pInfo.cliBinPath);
+  return callCliAsync(pInfo.type, userPrompt, pInfo.model, systemPrompt, pInfo.cliBinPath, onStreamEvent);
 }
 
 /**
@@ -456,7 +509,10 @@ export async function callAIWithMessages(
   const systemMsg = messages.find(m => m.role === 'system');
   const userMsg = [...messages].reverse().find(m => m.role === 'user');
   const systemPrompt = systemMsg?.content ?? '';
-  const userPrompt = typeof userMsg?.content === 'string' ? userMsg.content : JSON.stringify(userMsg?.content ?? '');
+  const rawContent = userMsg?.content;
+  const userPrompt = typeof rawContent === 'string' ? rawContent
+    : rawContent != null ? JSON.stringify(rawContent)
+    : '';
   return callAIWithTools(pInfo, systemPrompt, userPrompt, tools, defaultMaxTokens);
 }
 

package/src/bot/assistant-tools.ts

@@ -115,13 +115,13 @@ export function createAssistantExecutor(projectDir: string, steeringEngine?: imp
         }
         case 'queue_retry': {
           const store = mgr.getTaskStore(String(args.bot));
-          const tasks = await store.list({ status: 'cancelled' });
+          const tasks = await store.list({ status: ['cancelled', 'done'] });
           let count = 0;
           for (const t of tasks) {
-            await store.update(t.id, { status: 'open' });
+            await store.retry(t.id);
             count++;
           }
-          return { result: `Reset ${count} cancelled task(s) to open.`, isError: false };
+          return { result: `Reset ${count} terminal task(s) to open.`, isError: false };
         }
 
         // Flow-weaver tools

package/src/bot/audit-logger.ts

@@ -1,46 +1,74 @@
 import type { AuditEventType, AuditEventCallback } from './types.js';
 import { AuditStore } from './audit-store.js';
 
-let store: AuditStore | null = null;
-let currentRunId: string | null = null;
-let onEvent: AuditEventCallback | undefined;
+// ---------------------------------------------------------------------------
+// State stored on globalThis to survive dual module instances.
+//
+// When the pack is symlinked (benchmarks, dev), Node.js may load
+// audit-logger.js from two different paths, creating separate module
+// instances with separate module-level variables. The runner calls
+// initAuditLogger on instance A, but plan-task calls auditEmit on
+// instance B — which has currentRunId=null, silently dropping events.
+//
+// Using globalThis ensures both instances share the same state.
+// ---------------------------------------------------------------------------
+
+const GLOBAL_KEY = '__fw_audit_logger__';
+
+interface AuditState {
+  store: AuditStore | null;
+  currentRunId: string | null;
+  onEvent: AuditEventCallback | undefined;
+}
+
+function getState(): AuditState {
+  let state = (globalThis as Record<string, unknown>)[GLOBAL_KEY] as AuditState | undefined;
+  if (!state) {
+    state = { store: null, currentRunId: null, onEvent: undefined };
+    (globalThis as Record<string, unknown>)[GLOBAL_KEY] = state;
+  }
+  return state;
+}
 
 export function initAuditLogger(runId: string, callback?: AuditEventCallback): void {
+  const state = getState();
   try {
-    store = new AuditStore();
+    state.store = new AuditStore();
   } catch (err) {
     if (process.env.WEAVER_VERBOSE) process.stderr.write(`[weaver] audit store init failed: ${err}\n`);
-    store = null;
+    state.store = null;
   }
-  currentRunId = runId;
-  onEvent = callback;
+  state.currentRunId = runId;
+  state.onEvent = callback;
 }
 
 export function auditEmit(type: AuditEventType, data?: Record<string, unknown>): void {
-  if (!currentRunId) return;
+  const state = getState();
+  if (!state.currentRunId) return;
 
   const event = {
     type,
     timestamp: new Date().toISOString(),
-    runId: currentRunId,
+    runId: state.currentRunId,
     data,
   };
 
   try {
-    store?.emit(event);
+    state.store?.emit(event);
   } catch (err) {
     if (process.env.WEAVER_VERBOSE) process.stderr.write(`[weaver] audit emit failed: ${err}\n`);
   }
 
   try {
-    onEvent?.(event);
+    state.onEvent?.(event);
   } catch (err) {
     if (process.env.WEAVER_VERBOSE) process.stderr.write(`[weaver] audit callback failed: ${err}\n`);
   }
 }
 
 export function teardownAuditLogger(): void {
-  store = null;
-  currentRunId = null;
-  onEvent = undefined;
+  const state = getState();
+  state.store = null;
+  state.currentRunId = null;
+  state.onEvent = undefined;
 }

package/src/bot/audit-trail.ts

@@ -0,0 +1,211 @@
+/**
+ * Audit Trail Assembler — reads .weaver/ event files and produces
+ * a single structured object: the complete story of a swarm session.
+ *
+ * Usage:
+ *   import { assembleAuditTrail } from './audit-trail.js';
+ *   const trail = assembleAuditTrail('/path/to/project');
+ *   fs.writeFileSync('.weaver/audit-trail.json', JSON.stringify(trail, null, 2));
+ *
+ * The trail includes:
+ * - Session metadata (provider, budgets, pack version)
+ * - All tasks with final state and acceptance results
+ * - Per-run event logs (full prompts, full responses, tool calls)
+ * - All swarm events (decisions, claims, releases)
+ * - Everything merged and sorted by timestamp
+ *
+ * Streaming noise (thinking_delta, text_delta) is filtered out —
+ * the full thinking/content is already in the audit:ai-response event.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface AuditEvent {
+  type: string;
+  timestamp: number;
+  data: Record<string, unknown>;
+  source?: string; // 'swarm' | runId
+}
+
+export interface AuditRun {
+  runId: string;
+  events: AuditEvent[];
+}
+
+export interface AuditTask {
+  id: string;
+  title: string;
+  description: string;
+  status: string;
+  assignedProfile?: string;
+  dependsOn: string[];
+  tokensUsed: number;
+  costUsed: number;
+  runs: number;
+  acceptance?: {
+    met: boolean;
+    results: Array<{ name: string; pass: boolean; detail?: string }>;
+  };
+}
+
+export interface AuditSession {
+  packVersion?: string;
+  status?: string;
+  maxConcurrent?: number;
+  totalCost?: number;
+  totalTokensUsed?: number;
+  tasksCompleted?: number;
+  budgets?: Record<string, unknown>;
+}
+
+export interface AuditTrail {
+  assembledAt: string;
+  projectDir: string;
+  session: AuditSession;
+  tasks: AuditTask[];
+  runs: AuditRun[];
+  events: AuditEvent[]; // all events merged and sorted by timestamp
+}
+
+// Streaming noise — these are redundant because full content is
+// captured in audit:ai-response. Filtering them keeps the trail readable.
+const NOISE_TYPES = new Set([
+  'thinking_delta',
+  'text_delta',
+  'thinking_done',
+  'cost-update', // per-second cost updates — final cost is in swarm/task state
+]);
+
+// ---------------------------------------------------------------------------
+// Assembler
+// ---------------------------------------------------------------------------
+
+export function assembleAuditTrail(projectDir: string): AuditTrail {
+  const weaverDir = path.join(projectDir, '.weaver');
+
+  if (!fs.existsSync(weaverDir)) {
+    return emptyTrail(projectDir);
+  }
+
+  // 1. Read session metadata
+  const session = readSession(weaverDir);
+
+  // 2. Read tasks
+  const tasks = readTasks(weaverDir);
+
+  // 3. Read swarm events
+  const swarmEvents = readNdjsonSafe(path.join(weaverDir, 'swarm-events.ndjson'))
+    .map(e => ({ ...e, source: 'swarm' } as AuditEvent));
+
+  // 4. Read per-run event files
+  const runs: AuditRun[] = [];
+  const runEvents: AuditEvent[] = [];
+
+  const files = fs.readdirSync(weaverDir).filter(f => f.startsWith('events-') && f.endsWith('.ndjson'));
+  for (const file of files.sort()) {
+    const runId = file.replace('events-', '').replace('.ndjson', '');
+    const raw = readNdjsonSafe(path.join(weaverDir, file));
+    const filtered = raw.filter(e => !NOISE_TYPES.has(e.type));
+    const events = filtered.map(e => ({ ...e, source: runId } as AuditEvent));
+    runs.push({ runId, events });
+    runEvents.push(...events);
+  }
+
+  // 5. Merge all events sorted by timestamp
+  const allEvents = [...swarmEvents, ...runEvents].sort((a, b) => a.timestamp - b.timestamp);
+
+  return {
+    assembledAt: new Date().toISOString(),
+    projectDir,
+    session,
+    tasks,
+    runs,
+    events: allEvents,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function emptyTrail(projectDir: string): AuditTrail {
+  return {
+    assembledAt: new Date().toISOString(),
+    projectDir,
+    session: {},
+    tasks: [],
+    runs: [],
+    events: [],
+  };
+}
+
+function readSession(weaverDir: string): AuditSession {
+  const swarmPath = path.join(weaverDir, 'swarm.json');
+  if (!fs.existsSync(swarmPath)) return {};
+  try {
+    const raw = JSON.parse(fs.readFileSync(swarmPath, 'utf-8'));
+    return {
+      packVersion: raw.packVersion,
+      status: raw.status,
+      maxConcurrent: raw.maxConcurrent,
+      totalCost: raw.totalCost,
+      totalTokensUsed: raw.totalTokensUsed,
+      tasksCompleted: raw.tasksCompleted,
+      budgets: raw.budgets,
+    };
+  } catch {
+    return {};
+  }
+}
+
+function readTasks(weaverDir: string): AuditTask[] {
+  const tasksPath = path.join(weaverDir, 'tasks.json');
+  if (!fs.existsSync(tasksPath)) return [];
+  try {
+    const raw = JSON.parse(fs.readFileSync(tasksPath, 'utf-8'));
+    if (!Array.isArray(raw)) return [];
+    return raw.map((t: Record<string, unknown>) => ({
+      id: t.id as string,
+      title: t.title as string,
+      description: (t.description as string) ?? '',
+      status: t.status as string,
+      assignedProfile: t.assignedProfile as string | undefined,
+      dependsOn: (t.dependsOn as string[]) ?? [],
+      tokensUsed: (t.tokensUsed as number) ?? 0,
+      costUsed: (t.costUsed as number) ?? 0,
+      runs: ((t.context as Record<string, unknown>)?.runHistory as unknown[])?.length ?? 0,
+      acceptance: t.lastAcceptanceCheck as AuditTask['acceptance'],
+    }));
+  } catch {
+    return [];
+  }
+}
+
+function readNdjsonSafe(filePath: string): AuditEvent[] {
+  if (!fs.existsSync(filePath)) return [];
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const events: AuditEvent[] = [];
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        events.push({
+          type: parsed.type ?? 'unknown',
+          timestamp: parsed.timestamp ?? 0,
+          data: parsed.data ?? parsed,
+        });
+      } catch {
+        // Skip malformed lines
+      }
+    }
+    return events;
+  } catch {
+    return [];
+  }
+}

package/src/bot/behavior-defaults.ts

@@ -224,6 +224,7 @@ export function buildDefaultBehavior(
 export function adjustBehaviorForComplexity(
   behavior: ProfileBehavior,
   complexity: 'trivial' | 'simple' | 'moderate' | 'complex' | undefined,
+  profileRole?: string,
 ): ProfileBehavior {
   if (!complexity || complexity === 'moderate') {
     return behavior;
@@ -233,8 +234,12 @@ export function adjustBehaviorForComplexity(
   const adjusted: ProfileBehavior = JSON.parse(JSON.stringify(behavior));
 
   if (complexity === 'complex') {
-    // Complex: upgrade to powerful tier for plan phase (the critical thinking step)
-    if (adjusted.phases['plan']?.tier) adjusted.phases['plan'].tier = 'powerful';
+    // Complex: upgrade to powerful tier for plan phase (the critical thinking step).
+    // Exception: orchestrator profile caps at standard — decomposition is
+    // pattern matching (break into subtasks), not deep reasoning. Using Opus
+    // for orchestration burns 30%+ of budget on a single decomposition call.
+    const planTier = profileRole === 'orchestrator' ? 'standard' : 'powerful';
+    if (adjusted.phases['plan']?.tier) adjusted.phases['plan'].tier = planTier as ModelTier;
   } else if (complexity === 'trivial') {
     // Trivial: fast tier everywhere, skip review, 1 attempt, no evidence
     for (const phase of Object.values(adjusted.phases)) {