@synergenius/flow-weaver-pack-weaver 0.9.0 → 0.9.4

package/src/bot/assistant-core.ts

@@ -0,0 +1,312 @@
+/**
+ * Assistant Core — provider-agnostic conversational loop.
+ * The user types, the assistant responds with text and tool calls.
+ * UI-agnostic: terminal is one frontend, platform AI chat is another.
+ *
+ * Supports two provider modes:
+ * - CLI provider: tools handled internally via MCP bridge (tool_result events)
+ * - API provider: tools collected and executed manually (tool_use_start/end events)
+ */
+
+import * as readline from 'node:readline';
+import {
+  runAgentLoop,
+  type AgentProvider,
+  type AgentMessage,
+  type ToolDefinition,
+  type ToolExecutor,
+  type StreamEvent,
+} from '@synergenius/flow-weaver/agent';
+import { c } from './ansi.js';
+import { VERBOSE_TOOL_NAMES } from './tool-registry.js';
+import { generateToolPromptSection, generateVerboseToolList } from './tool-registry.js';
+import { CHARS_PER_TOKEN } from './safety.js';
+
+export interface AssistantOptions {
+  provider: AgentProvider;
+  tools: ToolDefinition[];
+  executor: ToolExecutor;
+  projectDir: string;
+  systemPrompt?: string;
+  /** Override for testing — provide messages instead of reading stdin */
+  inputMessages?: string[];
+  /** Resume a specific conversation by ID */
+  resumeId?: string;
+  /** Always start a fresh conversation */
+  newConversation?: boolean;
+}
+
+const DEFAULT_SYSTEM_PROMPT = `You are Weaver Assistant — a director-level AI that manages bot workers and the flow-weaver ecosystem.
+
+You help users with the following tools (grouped by category):
+
+${generateToolPromptSection()}
+USE TOOLS to fulfill requests. Don't describe what you'd do — actually do it.
+When the user asks to "start a bot", call bot_spawn.
+When they ask for status, call bot_list or bot_status.
+When they ask to add tasks, call queue_add or queue_add_batch.
+
+Be concise. Show results, not explanations.
+The user is a senior engineer — don't over-explain.
+
+CRITICAL: You are running in a terminal. Do NOT use markdown formatting.
+- No **bold**, no _italic_, no \`backticks\`, no tables with |pipes|
+- No emoji (✅, 🔴, etc.)
+- Use plain text with indentation for structure
+- Use UPPERCASE or quotes for emphasis instead of markdown
+- For lists, use simple dashes: - item
+- For key-value pairs, use: key: value (one per line)
+- Keep output scannable and clean
+
+IMPORTANT: Some tool results are displayed DIRECTLY to the user in the terminal.
+These tools show FULL output — the user already sees everything:
+  ${generateVerboseToolList()}
+For these: do NOT repeat, summarize, or reformat the output. Just add a brief comment if needed.
+Never re-type ASCII art, diagrams, or large text blocks that were already printed.
+
+Other tools show only a short preview.
+For those: you may summarize or explain the result as needed.`;
+
+
+export async function runAssistant(opts: AssistantOptions): Promise<void> {
+  const { provider, tools, executor, projectDir } = opts;
+
+  // Build system prompt — include project plan if it exists
+  let systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+  try {
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const planPath = path.resolve(projectDir, '.weaver-plan.md');
+    if (fs.existsSync(planPath)) {
+      const plan = fs.readFileSync(planPath, 'utf-8').trim();
+      systemPrompt += '\n\n## Project Plan & Vision\n\nAll bots you spawn and tasks you queue MUST align with this plan.\n\n' + plan;
+    }
+  } catch { /* plan not available */ }
+
+  const out = (s: string) => process.stderr.write(s);
+
+  // Persistent conversation store
+  const { ConversationStore } = await import('./conversation-store.js');
+  const store = new ConversationStore();
+
+  // Resolve conversation: resume, new, or auto
+  let conversation: { id: string; title: string; messageCount: number };
+  const history: AgentMessage[] = [];
+
+  if (opts.resumeId) {
+    const existing = store.get(opts.resumeId);
+    if (!existing) {
+      out(`  ${c.red('Conversation not found:')} ${opts.resumeId}\n`);
+      return;
+    }
+    conversation = existing;
+    history.push(...store.loadMessages(existing.id));
+    compressHistory(history);
+  } else if (opts.newConversation) {
+    conversation = store.create(projectDir);
+  } else {
+    // Auto-resume most recent if within 1 hour, else create new
+    const recent = store.getMostRecent();
+    if (recent && Date.now() - recent.lastMessageAt < 3600_000) {
+      conversation = recent;
+      history.push(...store.loadMessages(recent.id));
+      compressHistory(history);
+    } else {
+      conversation = store.create(projectDir);
+    }
+  }
+
+  // Welcome
+  out(`\n  ${c.bold('weaver assistant')}\n`);
+  out(`  ${c.dim(`Project: ${projectDir}`)}\n`);
+  if (conversation.title) {
+    out(`  ${c.dim(`Resuming: "${conversation.title}" (${conversation.messageCount} messages)`)}\n`);
+  } else {
+    out(`  ${c.dim(`Conversation: ${conversation.id}`)}\n`);
+  }
+  out(`  ${c.dim('Type your request. Ctrl+C to exit.')}\n\n`);
+
+  // Input source
+  const rl = opts.inputMessages
+    ? null
+    : readline.createInterface({ input: process.stdin, output: process.stderr, prompt: `${c.cyan('❯')} ` });
+
+  const getNextInput = opts.inputMessages
+    ? (() => {
+        let i = 0;
+        return (): Promise<string | null> => Promise.resolve(opts.inputMessages![i++] ?? null);
+      })()
+    : (): Promise<string | null> => new Promise<string | null>((resolve) => {
+        rl!.prompt();
+        rl!.once('line', (line) => resolve(line.trim() || null));
+        rl!.once('close', () => resolve(null));
+      });
+
+  const onStreamEvent = (event: StreamEvent) => {
+    if (event.type === 'text_delta') {
+      out(event.text);
+    } else if (event.type === 'thinking_delta') {
+      out(c.dim(event.text));
+    }
+  };
+
+  const onToolEvent = (event: { type: string; name: string; args?: Record<string, unknown>; result?: string; isError?: boolean }) => {
+    if (event.type === 'tool_call_start') {
+      const preview = toolPreview(event.name, event.args ?? {});
+      out(`\n  ${c.cyan('◆')} ${event.name}${preview ? c.dim(`(${preview})`) : ''}\n`);
+    }
+    if (event.type === 'tool_call_result') {
+      const icon = event.isError ? c.red('✗') : c.dim('→');
+      const raw = event.result ?? '';
+      // Show full output for diagram/describe/docs tools; truncate others
+      const isVerboseTool = VERBOSE_TOOL_NAMES.has(event.name);
+      if (isVerboseTool && raw.length > 150) {
+        out(`  ${icon}\n${raw}\n`);
+      } else {
+        const result = raw.replace(/\n/g, ' ').slice(0, 200);
+        out(`  ${icon} ${result}\n`);
+      }
+    }
+  };
+
+  // Main conversation loop
+  while (true) {
+    const input = await getNextInput();
+    if (input === null) break;
+    if (!input.trim()) continue;
+
+    out('\n');
+
+    // Add user message to history
+    history.push({ role: 'user', content: input });
+
+    try {
+      const result = await runAgentLoop(
+        provider,
+        tools,
+        executor,
+        history, // full conversation history
+        {
+          systemPrompt,
+          maxIterations: 20,
+          onStreamEvent,
+          onToolEvent,
+        },
+      );
+
+      // Collect new messages from the agent loop
+      const newMessages: AgentMessage[] = [];
+      if (result.messages.length > history.length) {
+        for (let i = history.length; i < result.messages.length; i++) {
+          history.push(result.messages[i]);
+          newMessages.push(result.messages[i]);
+        }
+      }
+
+      // Persist to disk
+      const tokensUsed = result.usage.promptTokens + result.usage.completionTokens;
+      store.appendMessages(conversation.id, [{ role: 'user', content: input }, ...newMessages]);
+      store.updateAfterTurn(conversation.id, [{ role: 'user', content: input }, ...newMessages], tokensUsed);
+
+      // Auto-title from first assistant response
+      if (!conversation.title) {
+        const firstAssistant = newMessages.find(m => m.role === 'assistant');
+        if (firstAssistant && typeof firstAssistant.content === 'string') {
+          const title = firstAssistant.content.split('\n')[0].slice(0, 80).trim();
+          if (title) {
+            conversation.title = title;
+            store.setTitle(conversation.id, title);
+          }
+        }
+      }
+
+      // Token-aware compression
+      compressHistory(history);
+
+      if (!result.success && result.summary) {
+        out(`\n  ${c.red(result.summary)}\n`);
+      }
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      out(`\n  ${c.red('Error:')} ${msg}\n`);
+    }
+
+    out('\n');
+  }
+
+  rl?.close();
+  out(`\n  ${c.dim('Goodbye.')}\n\n`);
+}
+
+function toolPreview(name: string, args: Record<string, unknown>): string {
+  if (args.name) return String(args.name);
+  if (args.bot) return String(args.bot);
+  if (args.file) return String(args.file).split('/').pop() ?? '';
+  if (args.path) return String(args.path).split('/').pop() ?? '';
+  if (args.instruction) return String(args.instruction).slice(0, 40);
+  if (args.command) return String(args.command).slice(0, 40);
+  return '';
+}
+
+// --- Token-aware history compression ---
+
+// Budget: leave room for system prompt (~2k) + tools (~3k) + response (~4k)
+const MAX_HISTORY_TOKENS = 80_000;
+// When compressing, truncate tool results to this size
+const COMPRESSED_TOOL_RESULT_SIZE = 200;
+
+function estimateTokens(msg: AgentMessage): number {
+  const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+  return Math.ceil(content.length / CHARS_PER_TOKEN);
+}
+
+function totalTokens(history: AgentMessage[]): number {
+  return history.reduce((sum, m) => sum + estimateTokens(m), 0);
+}
+
+/**
+ * Compress conversation history to stay within token budget.
+ * Strategy (progressive, stops as soon as under budget):
+ * 1. Truncate long tool results to 200 chars (keep tool call structure)
+ * 2. Summarize old tool results to just "[tool_name: ok/error]"
+ * 3. Drop oldest turns (keep most recent 10 turns)
+ */
+function compressHistory(history: AgentMessage[]): void {
+  if (totalTokens(history) <= MAX_HISTORY_TOKENS) return;
+
+  // Phase 1: Truncate tool results older than last 6 messages
+  const cutoff = Math.max(0, history.length - 6);
+  for (let i = 0; i < cutoff; i++) {
+    const msg = history[i];
+    if (msg.role === 'tool' && typeof msg.content === 'string' && msg.content.length > COMPRESSED_TOOL_RESULT_SIZE) {
+      msg.content = msg.content.slice(0, COMPRESSED_TOOL_RESULT_SIZE) + '... (truncated)';
+    }
+  }
+  if (totalTokens(history) <= MAX_HISTORY_TOKENS) return;
+
+  // Phase 2: Summarize all tool results older than last 10 messages
+  const summaryCutoff = Math.max(0, history.length - 10);
+  for (let i = 0; i < summaryCutoff; i++) {
+    const msg = history[i];
+    if (msg.role === 'tool' && typeof msg.content === 'string') {
+      const isError = msg.content.toLowerCase().includes('error') || msg.content.toLowerCase().includes('not found');
+      msg.content = isError ? '(error — details truncated)' : '(ok — details truncated)';
+    }
+    // Also truncate long assistant messages
+    if (msg.role === 'assistant' && typeof msg.content === 'string' && msg.content.length > 500) {
+      msg.content = msg.content.slice(0, 500) + '... (truncated)';
+    }
+  }
+  if (totalTokens(history) <= MAX_HISTORY_TOKENS) return;
+
+  // Phase 3: Drop oldest turns, keep last 10 messages
+  const keep = 10;
+  if (history.length > keep) {
+    // Insert a summary of what was dropped
+    const dropped = history.length - keep;
+    history.splice(0, dropped, {
+      role: 'user',
+      content: `(${dropped} earlier messages compressed. Key context: this is an ongoing assistant session managing bots and workflows.)`,
+    });
+  }
+}

package/src/bot/assistant-tools.ts

@@ -0,0 +1,318 @@
+/**
+ * Assistant tool definitions and executor.
+ * These are the tools the AI assistant uses to manage bots,
+ * queues, and the flow-weaver ecosystem.
+ */
+
+import type { ToolDefinition, ToolExecutor } from '@synergenius/flow-weaver/agent';
+import { BotManager } from './bot-manager.js';
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { ASSISTANT_TOOLS } from './tool-registry.js';
+import { isBlockedCommand, isBlockedUrl } from './safety.js';
+
+export { ASSISTANT_TOOLS };
+
+// Shared bot manager instance
+let manager: BotManager | null = null;
+function getManager(): BotManager {
+  if (!manager) manager = new BotManager();
+  return manager;
+}
+
+export function createAssistantExecutor(projectDir: string): ToolExecutor {
+  const mgr = getManager();
+
+  return async (name: string, args: Record<string, unknown>) => {
+    try {
+      switch (name) {
+        // Bot management
+        case 'bot_spawn': {
+          const botName = String(args.name ?? `bot-${Date.now()}`);
+          const dir = String(args.project_dir ?? projectDir);
+          const bot = mgr.spawn(botName, {
+            projectDir: dir,
+            parallel: args.parallel as number | undefined,
+            deadline: args.deadline as string | undefined,
+            branch: args.branch as string | undefined,
+          });
+          return { result: JSON.stringify(bot), isError: false };
+        }
+        case 'bot_list': {
+          const bots = mgr.list();
+          if (bots.length === 0) return { result: 'No bots running.', isError: false };
+          const lines = bots.map(b => {
+            const uptime = Math.round((Date.now() - b.startedAt) / 1000);
+            return `${b.name}: ${b.status} (pid ${b.pid}, ${uptime}s uptime)`;
+          });
+          return { result: lines.join('\n'), isError: false };
+        }
+        case 'bot_status': {
+          const botName = String(args.name);
+          const bot = mgr.get(botName);
+          if (!bot) return { result: `Bot "${botName}" not found.`, isError: true };
+          const queue = mgr.getQueue(botName);
+          const tasks = await queue.list();
+          const pending = tasks.filter(t => t.status === 'pending').length;
+          const running = tasks.filter(t => t.status === 'running').length;
+          const completed = tasks.filter(t => t.status === 'completed').length;
+          const failed = tasks.filter(t => t.status === 'failed').length;
+          const failedTasks = tasks.filter(t => t.status === 'failed');
+          let result = `Bot "${botName}": ${bot.status}\n`;
+          result += `Tasks: ${completed} completed, ${failed} failed, ${running} running, ${pending} pending\n`;
+          if (failedTasks.length > 0) {
+            result += `\nFailed tasks:\n`;
+            for (const t of failedTasks) {
+              result += `  - ${t.instruction.slice(0, 80)}\n`;
+            }
+          }
+          return { result, isError: false };
+        }
+        case 'bot_pause': {
+          await mgr.steer(String(args.name), 'pause');
+          return { result: `Paused bot "${args.name}".`, isError: false };
+        }
+        case 'bot_resume': {
+          await mgr.steer(String(args.name), 'resume');
+          return { result: `Resumed bot "${args.name}".`, isError: false };
+        }
+        case 'bot_stop': {
+          mgr.stop(String(args.name));
+          return { result: `Stopping bot "${args.name}" (will finish current task).`, isError: false };
+        }
+        case 'bot_logs': {
+          const logs = mgr.logs(String(args.name), (args.lines as number) ?? 30);
+          return { result: logs || '(no output yet)', isError: false };
+        }
+
+        // Queue management
+        case 'queue_add': {
+          const queue = mgr.getQueue(String(args.bot));
+          const { id, duplicate } = await queue.add({
+            instruction: String(args.instruction),
+            targets: args.targets as string[] | undefined,
+            priority: 0,
+          });
+          if (duplicate) return { result: `Task already queued (${id}).`, isError: false };
+          return { result: `Added task ${id} to "${args.bot}" queue.`, isError: false };
+        }
+        case 'queue_add_batch': {
+          const queue = mgr.getQueue(String(args.bot));
+          const tasks = args.tasks as Array<{ instruction: string; targets?: string[] }>;
+          let added = 0, skipped = 0;
+          for (const t of tasks) {
+            const { duplicate } = await queue.add({ instruction: t.instruction, targets: t.targets, priority: 0 });
+            if (duplicate) skipped++; else added++;
+          }
+          const msg = skipped > 0 ? `Added ${added} tasks, ${skipped} duplicates skipped.` : `Added ${added} tasks to "${args.bot}" queue.`;
+          return { result: msg, isError: false };
+        }
+        case 'queue_list': {
+          const queue = mgr.getQueue(String(args.bot));
+          const tasks = await queue.list();
+          if (tasks.length === 0) return { result: 'Queue is empty.', isError: false };
+          const lines = tasks.map(t => `[${t.status}] ${t.instruction.slice(0, 70)}`);
+          return { result: lines.join('\n'), isError: false };
+        }
+        case 'queue_retry': {
+          const queue = mgr.getQueue(String(args.bot));
+          const count = await queue.retryAll();
+          return { result: `Reset ${count} failed task(s) to pending.`, isError: false };
+        }
+
+        // Flow-weaver tools
+        case 'fw_validate': {
+          const output = execFileSync('npx', ['flow-weaver', 'validate', String(args.path)], {
+            encoding: 'utf-8', cwd: projectDir, timeout: 30_000, stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          return { result: output.trim() || 'Validation complete.', isError: false };
+        }
+        case 'fw_diagram': {
+          const output = execFileSync('npx', ['flow-weaver', 'diagram', String(args.file), '--format', 'ascii-compact'], {
+            encoding: 'utf-8', cwd: projectDir, timeout: 15_000, stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          return { result: output.trim(), isError: false };
+        }
+        case 'fw_describe': {
+          const output = execFileSync('npx', ['flow-weaver', 'describe', String(args.file)], {
+            encoding: 'utf-8', cwd: projectDir, timeout: 15_000, stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          return { result: output.trim(), isError: false };
+        }
+        case 'fw_docs': {
+          const output = execFileSync('npx', ['flow-weaver', 'docs', String(args.topic), '--compact'], {
+            encoding: 'utf-8', cwd: projectDir, timeout: 15_000, stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          return { result: output.trim().slice(0, 5000), isError: false };
+        }
+
+        // Project tools
+        case 'read_file': {
+          const filePath = path.isAbsolute(String(args.file)) ? String(args.file) : path.resolve(projectDir, String(args.file));
+          const stat = fs.statSync(filePath);
+          if (stat.isDirectory()) {
+            const entries = fs.readdirSync(filePath).slice(0, 100);
+            return { result: `Directory listing (${entries.length} entries):\n${entries.join('\n')}`, isError: false };
+          }
+          if (stat.size > 1_048_576) return { result: 'File too large (>1MB).', isError: true };
+          return { result: fs.readFileSync(filePath, 'utf-8'), isError: false };
+        }
+        case 'list_files': {
+          const dir = path.isAbsolute(String(args.directory)) ? String(args.directory) : path.resolve(projectDir, String(args.directory));
+          if (!fs.existsSync(dir)) return { result: `Directory not found: ${dir}`, isError: true };
+          let entries = fs.readdirSync(dir, { recursive: false }) as string[];
+          if (args.pattern) {
+            const re = new RegExp(String(args.pattern));
+            entries = entries.filter(e => re.test(e));
+          }
+          return { result: entries.slice(0, 200).join('\n') || '(empty)', isError: false };
+        }
+        case 'run_shell': {
+          const cmd = String(args.command);
+          // Safety: block destructive commands
+          if (isBlockedCommand(cmd)) {
+            return { result: `Blocked: "${cmd}" is not allowed.`, isError: true };
+          }
+          const output = execFileSync('sh', ['-c', cmd], {
+            encoding: 'utf-8', cwd: projectDir, timeout: 30_000, stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          return { result: output.trim().slice(0, 5000) || '(no output)', isError: false };
+        }
+
+        // Conversation management
+        case 'conversation_list': {
+          const { ConversationStore } = await import('./conversation-store.js');
+          const cStore = new ConversationStore();
+          const convos = cStore.list();
+          if (convos.length === 0) return { result: 'No saved conversations.', isError: false };
+          const lines = convos.map(cv => {
+            const ago = Math.round((Date.now() - cv.lastMessageAt) / 60_000);
+            const agoStr = ago < 60 ? `${ago}m ago` : ago < 1440 ? `${Math.round(ago / 60)}h ago` : `${Math.round(ago / 1440)}d ago`;
+            const title = cv.title || '(untitled)';
+            return `${cv.id}  "${title}"  ${cv.messageCount} msgs  ${agoStr}`;
+          });
+          return { result: `Conversations (${convos.length}):\n${lines.join('\n')}`, isError: false };
+        }
+        case 'conversation_delete': {
+          const { ConversationStore } = await import('./conversation-store.js');
+          const cStore = new ConversationStore();
+          const existing = cStore.get(String(args.id));
+          if (!existing) return { result: `Conversation "${args.id}" not found.`, isError: true };
+          cStore.delete(String(args.id));
+          return { result: `Deleted conversation "${args.id}" (${existing.title || 'untitled'}).`, isError: false };
+        }
+        case 'conversation_summary': {
+          const { ConversationStore } = await import('./conversation-store.js');
+          const cStore = new ConversationStore();
+          const recent = cStore.getMostRecent();
+          if (!recent) return { result: 'No active conversation.', isError: false };
+          const elapsed = Math.round((Date.now() - recent.createdAt) / 60_000);
+          return {
+            result: `Current conversation: ${recent.id}\n  Title: ${recent.title || '(untitled)'}\n  Messages: ${recent.messageCount}\n  Tokens: ${recent.totalTokens}\n  Bots: ${recent.botIds.length > 0 ? recent.botIds.join(', ') : 'none'}\n  Duration: ${elapsed}m`,
+            isError: false,
+          };
+        }
+
+        case 'web_fetch': {
+          const url = String(args.url);
+          if (isBlockedUrl(url)) {
+            return { result: 'Blocked: cannot fetch internal/localhost URLs.', isError: true };
+          }
+          const resp = await fetch(url, { method: (args.method as string) ?? 'GET', signal: AbortSignal.timeout(15_000) });
+          const text = await resp.text();
+          return { result: text.slice(0, 10_000), isError: !resp.ok };
+        }
+
+        case 'github_status': {
+          const ghArgs = args.pr
+            ? ['pr', 'checks', String(args.pr), '--json', 'name,state,conclusion']
+            : ['run', 'list', '--branch', String(args.branch ?? ''), '--json', 'status,conclusion,name,headBranch', '--limit', '5'];
+          try {
+            const output = execFileSync('gh', ghArgs, { encoding: 'utf-8', cwd: projectDir, timeout: 15_000, stdio: ['pipe', 'pipe', 'pipe'] });
+            return { result: output.trim(), isError: false };
+          } catch (err: any) {
+            return { result: `gh CLI error: ${(err.message ?? '').slice(0, 300)}`, isError: true };
+          }
+        }
+
+        case 'project_list': {
+          const projectsDir = path.join(os.homedir(), '.weaver', 'projects');
+          if (!fs.existsSync(projectsDir)) return { result: 'No projects found.', isError: false };
+          const dirs = fs.readdirSync(projectsDir);
+          // Each dir is a hash — try to find meta or queue files
+          const projects = dirs.map(d => {
+            const queuePath = path.join(projectsDir, d, 'task-queue.ndjson');
+            const exists = fs.existsSync(queuePath);
+            return `${d}: ${exists ? 'has queue' : 'empty'}`;
+          });
+          return { result: projects.join('\n') || 'No projects found.', isError: false };
+        }
+
+        case 'project_context': {
+          const dir = String(args.directory);
+          const parts: string[] = [];
+          const pkgPath = path.join(dir, 'package.json');
+          if (fs.existsSync(pkgPath)) {
+            try {
+              const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+              parts.push(`Package: ${pkg.name}@${pkg.version}`);
+              parts.push(`Description: ${pkg.description ?? 'none'}`);
+            } catch { parts.push('package.json: parse error'); }
+          }
+          const planPath = path.join(dir, '.weaver-plan.md');
+          if (fs.existsSync(planPath)) {
+            parts.push(`Plan:\n${fs.readFileSync(planPath, 'utf-8').slice(0, 2000)}`);
+          }
+          const configPath = path.join(dir, '.weaver.json');
+          if (fs.existsSync(configPath)) {
+            parts.push(`Weaver config: ${fs.readFileSync(configPath, 'utf-8').trim()}`);
+          }
+          return { result: parts.join('\n') || `No context found in ${dir}`, isError: false };
+        }
+
+        case 'fw_diagram_mermaid': {
+          try {
+            // Try mermaid format first, fall back to text
+            let output: string;
+            try {
+              output = execFileSync('npx', ['flow-weaver', 'diagram', String(args.file), '--format', 'mermaid'], {
+                encoding: 'utf-8', cwd: projectDir, timeout: 15_000, stdio: ['pipe', 'pipe', 'pipe'],
+              }).trim();
+            } catch {
+              output = execFileSync('npx', ['flow-weaver', 'diagram', String(args.file)], {
+                encoding: 'utf-8', cwd: projectDir, timeout: 15_000, stdio: ['pipe', 'pipe', 'pipe'],
+              }).trim();
+            }
+            return { result: output, isError: false };
+          } catch (err: any) {
+            return { result: (err.message ?? '').slice(0, 500), isError: true };
+          }
+        }
+
+        case 'knowledge_list': {
+          const { KnowledgeStore } = await import('./knowledge-store.js');
+          const kStore = new KnowledgeStore(projectDir);
+          const entries = kStore.list();
+          if (entries.length === 0) return { result: 'No stored knowledge.', isError: false };
+          return { result: entries.map(e => `${e.key}: ${e.value}`).join('\n'), isError: false };
+        }
+
+        case 'knowledge_search': {
+          const { KnowledgeStore } = await import('./knowledge-store.js');
+          const kStore = new KnowledgeStore(projectDir);
+          const entries = kStore.recall(String(args.query));
+          if (entries.length === 0) return { result: 'No matching knowledge found.', isError: false };
+          return { result: entries.map(e => `${e.key}: ${e.value}`).join('\n'), isError: false };
+        }
+
+        default:
+          return { result: `Unknown tool: ${name}`, isError: true };
+      }
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { result: msg.slice(0, 500), isError: true };
+    }
+  };
+}

package/src/bot/audit-logger.ts

@@ -8,7 +8,8 @@ let onEvent: AuditEventCallback | undefined;
 export function initAuditLogger(runId: string, callback?: AuditEventCallback): void {
   try {
     store = new AuditStore();
-  } catch {
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) process.stderr.write(`[weaver] audit store init failed: ${err}\n`);
     store = null;
   }
   currentRunId = runId;
@@ -27,14 +28,14 @@ export function auditEmit(type: AuditEventType, data?: Record<string, unknown>):
 
   try {
     store?.emit(event);
-  } catch {
-    // non-fatal
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) process.stderr.write(`[weaver] audit emit failed: ${err}\n`);
   }
 
   try {
     onEvent?.(event);
-  } catch {
-    // non-fatal
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) process.stderr.write(`[weaver] audit callback failed: ${err}\n`);
   }
 }