@synergenius/flow-weaver-pack-weaver 0.9.7 → 0.9.9

package/src/cli-handlers.ts

@@ -14,7 +14,7 @@ import type { ExecutionEvent, WeaverConfig, RunRecord, RunOutcome, RunCostSummar
 import { AuditStore } from './bot/audit-store.js';
 
 export interface ParsedArgs {
-  command: 'run' | 'history' | 'costs' | 'providers' | 'watch' | 'cron' | 'pipeline' | 'dashboard' | 'eject' | 'bot' | 'session' | 'steer' | 'queue' | 'status' | 'genesis' | 'audit' | 'init' | 'assistant' | 'examples' | 'doctor';
+  command: 'run' | 'history' | 'costs' | 'providers' | 'watch' | 'cron' | 'pipeline' | 'dashboard' | 'eject' | 'bot' | 'session' | 'steer' | 'queue' | 'status' | 'genesis' | 'audit' | 'init' | 'assistant' | 'examples' | 'doctor' | 'improve';
   file?: string;
   verbose: boolean;
   dryRun: boolean;
@@ -69,6 +69,15 @@ export interface ParsedArgs {
   assistantList?: boolean;
   assistantDelete?: string;
   assistantWatch?: string;
+  assistantMessage?: string;
+  assistantDebug?: boolean;
+  assistantDebugMessages?: string[];
+  // improve
+  improveMaxCycles?: number;
+  improveMaxFailures?: number;
+  improveProtected?: string[];
+  improveTestCmd?: string;
+  improveBuildCmd?: string;
 }
 
 export function parseArgs(argv: string[]): ParsedArgs {
@@ -257,6 +266,8 @@ export function parseArgs(argv: string[]): ParsedArgs {
       }
     } else if (arg === 'genesis') {
       result.command = 'genesis';
+    } else if (arg === 'improve') {
+      result.command = 'improve';
     } else if (arg === 'init') {
       result.command = 'init';
     } else if (arg === '--init') {
@@ -266,8 +277,13 @@ export function parseArgs(argv: string[]): ParsedArgs {
     } else if (arg === '--watch-dir' && i + 1 < args.length) {
       i++;
       result.assistantWatch = args[i];
+    } else if ((arg === '-m' || arg === '--message') && i + 1 < args.length) {
+      i++;
+      result.assistantMessage = args[i];
     } else if (arg === '--new') {
       result.assistantNew = true;
+    } else if (arg === '--debug') {
+      result.assistantDebug = true;
     } else if (arg === '--resume' && i + 1 < args.length) {
       i++;
       result.assistantResume = args[i];
@@ -290,6 +306,21 @@ export function parseArgs(argv: string[]): ParsedArgs {
     } else if (arg === '--project-dir' && i + 1 < args.length) {
       i++;
       result.file = args[i];
+    } else if (arg === '--max-cycles' && i + 1 < args.length) {
+      i++;
+      result.improveMaxCycles = parseInt(args[i]!, 10) || undefined;
+    } else if (arg === '--max-failures' && i + 1 < args.length) {
+      i++;
+      result.improveMaxFailures = parseInt(args[i]!, 10) || undefined;
+    } else if (arg === '--protected' && i + 1 < args.length) {
+      i++;
+      result.improveProtected = args[i]!.split(',').map(s => s.trim());
+    } else if (arg === '--test-cmd' && i + 1 < args.length) {
+      i++;
+      result.improveTestCmd = args[i];
+    } else if (arg === '--build-cmd' && i + 1 < args.length) {
+      i++;
+      result.improveBuildCmd = args[i];
     } else if (arg === 'run') {
       // skip, next arg is the file
     } else if (!arg.startsWith('-')) {
@@ -1620,7 +1651,7 @@ export async function handleAssistant(opts: ParsedArgs): Promise<void> {
   if (opts.assistantDelete) {
     const { ConversationStore } = await import('./bot/conversation-store.js');
     const store = new ConversationStore();
-    store.delete(opts.assistantDelete);
+    await store.delete(opts.assistantDelete);
     console.log(`  Deleted conversation ${opts.assistantDelete}`);
     return;
   }
@@ -1659,7 +1690,14 @@ export async function handleAssistant(opts: ParsedArgs): Promise<void> {
     }) as import('@synergenius/flow-weaver/agent').AgentProvider;
   } else if (providerType === 'anthropic' || (providerType === 'auto' && process.env.ANTHROPIC_API_KEY)) {
     const apiKey = process.env.ANTHROPIC_API_KEY ?? (typeof providerSetting === 'object' ? (providerSetting as { apiKey?: string }).apiKey : undefined);
-    if (!apiKey) { console.error('ANTHROPIC_API_KEY required for anthropic provider'); process.exit(1); }
+    if (!apiKey) {
+      console.error('\n  No API key found.\n');
+      console.error('  Set one of:');
+      console.error('    export ANTHROPIC_API_KEY=sk-...');
+      console.error('    fw login                          (platform credentials)');
+      console.error('    flow-weaver weaver init            (auto-detect provider)\n');
+      process.exit(1);
+    }
     provider = createAnthropicProvider({ apiKey, model: typeof providerSetting === 'object' ? providerSetting.model : undefined });
   } else {
     provider = createClaudeCliProvider({ model: typeof providerSetting === 'object' ? providerSetting.model : undefined });
@@ -1669,6 +1707,51 @@ export async function handleAssistant(opts: ParsedArgs): Promise<void> {
   const { runAssistant } = await import('./bot/assistant-core.js');
   const executor = createAssistantExecutor(projectDir);
 
+  // Debug mode: pass messages as inputMessages, enable structured output
+  // Must be checked BEFORE single-message mode since both use -m flag
+  if (opts.assistantDebug) {
+    const messages = opts.assistantMessage ? [opts.assistantMessage] : [];
+    // Read additional messages from stdin if not a TTY
+    if (!process.stdin.isTTY) {
+      const chunks: string[] = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === 'string' ? chunk : chunk.toString());
+      }
+      const stdinMessages = chunks.join('').trim().split('\n').filter(Boolean);
+      messages.push(...stdinMessages);
+    }
+    if (messages.length === 0) {
+      console.error('Debug mode requires messages via -m "msg" or stdin (one per line)');
+      process.exit(1);
+    }
+    await runAssistant({
+      provider,
+      tools: ASSISTANT_TOOLS,
+      executor,
+      projectDir,
+      inputMessages: messages,
+      resumeId: opts.assistantResume,
+      newConversation: !opts.assistantResume,
+      debug: true,
+    });
+    return;
+  }
+
+  // Single message mode: -m "message" — run one message, print result, exit
+  if (opts.assistantMessage) {
+    const { runAgentLoop } = await import('@synergenius/flow-weaver/agent');
+    const result = await runAgentLoop(provider, ASSISTANT_TOOLS, executor, [{ role: 'user', content: opts.assistantMessage }], {
+      maxIterations: 20,
+      onStreamEvent: (e) => { if (e.type === 'text_delta') process.stdout.write(e.text); },
+      onToolEvent: (e) => {
+        if (e.type === 'tool_call_start') process.stderr.write(`\n  ◆ ${e.name}\n`);
+        if (e.type === 'tool_call_result') process.stderr.write(`  → ${(e.result ?? '').replace(/\n/g, ' ').slice(0, 200)}\n`);
+      },
+    });
+    process.stdout.write('\n');
+    process.exit(result.success ? 0 : 1);
+  }
+
   await runAssistant({
     provider,
     tools: ASSISTANT_TOOLS,
@@ -1965,6 +2048,9 @@ const COMMAND_HELP: Record<string, string> = {
   eject:     'eject [--workflow bot|genesis]  Export managed workflows',
   audit:     'audit [runId] [--limit N]      View audit log',
   assistant: 'assistant                       AI-powered assistant for managing bots and workflows',
+  examples:  'examples                       Show example tasks and commands',
+  doctor:    'doctor                         Validate setup and check connectivity',
+  status:    'status                         Get bot session status',
 };
 
 export function printHelp(command?: string): void {
@@ -1975,26 +2061,50 @@ export function printHelp(command?: string): void {
   }
 
   console.log(`
-Weaver — AI-powered workflow automation for Flow Weaver
-
-Usage: flow-weaver weaver <command> [options]
-
-Commands:
-  ${Object.values(COMMAND_HELP).join('\n  ')}
-
-Global options:
-  -h, --help          Show help
-  -v, --verbose       Show detailed output
-  -n, --dry-run       Preview without executing
-  --quiet             Suppress output
-  -p, --params <json> Input parameters as JSON
-  -c, --config <path> Path to .weaver.json config
-  --approval <mode>   Override approval mode (auto|prompt|web|timeout-auto)
-
-Quick start:
-  flow-weaver weaver init                              # create .weaver.json
-  flow-weaver weaver providers                         # check available AI providers
-  flow-weaver weaver bot "Create a hello world workflow"  # create your first workflow
+  Weaver — AI-powered workflow automation for Flow Weaver
+
+  Usage: flow-weaver weaver <command> [options]
+
+  Get started:
+    assistant                AI assistant for managing bots and workflows
+    bot <task>               Create or modify a workflow from a task
+    init                     Create .weaver.json config
+    doctor                   Validate setup and check connectivity
+
+  Workflows:
+    run <file>               Execute a workflow with AI agent channel
+    watch <file>             Re-run on file changes
+    genesis [--init]         Self-evolution cycle on a workflow
+
+  Management:
+    session                  Start continuous task queue processing
+    queue <cmd> [task]       Manage task queue (add, list, clear, remove)
+    status                   Get bot session status
+    steer <cmd>              Control a running session (pause, resume, cancel)
+
+  Info:
+    history [id]             Show execution history
+    costs [--since 7d]       Show AI token usage and costs
+    audit [runId]            View audit log
+    examples                 Show example tasks and commands
+    providers                List available AI providers
+
+  Advanced:
+    pipeline <config.json>   Run multi-stage pipeline
+    cron <schedule> <file>   Schedule workflow execution
+    dashboard [file]         Start live execution dashboard
+    eject [--workflow name]  Export managed workflows
+
+  Options:
+    -h, --help               Show help
+    -v, --verbose            Show detailed output
+    -c, --config <path>      Path to .weaver.json config
+    --approval <mode>        Approval mode (auto|prompt|web|timeout-auto)
+
+  Quick start:
+    flow-weaver weaver init
+    flow-weaver weaver bot "Create a hello world workflow"
+    flow-weaver weaver assistant
 `);
 }
 
@@ -2123,16 +2233,27 @@ export async function handleInit(opts: ParsedArgs): Promise<void> {
   console.log(`    provider: ${provider}`);
   console.log('    approval: auto');
   console.log('');
-  console.log('  Try it now:');
-  console.log('    \x1b[36mweaver bot "Create a hello world workflow"\x1b[0m');
-  console.log('    \x1b[36mweaver assistant\x1b[0m');
+  console.log('  \x1b[1mNext step:\x1b[0m');
+  console.log('    \x1b[36mweaver assistant\x1b[0m              \x1b[2m# start your AI companion\x1b[0m');
   console.log('');
-  console.log('  Learn more:');
-  console.log('    weaver examples         \x1b[2m# see what weaver can do\x1b[0m');
-  console.log('    weaver doctor           \x1b[2m# validate your setup\x1b[0m');
+  console.log('  The assistant will read your project and help you create');
+  console.log('  your first workflow. Just tell it what you want to build.');
   console.log('');
 }
 
+export async function handleImprove(opts: ParsedArgs): Promise<void> {
+  const projectDir = opts.file ? path.resolve(opts.file) : process.cwd();
+  const { runImproveLoop, DEFAULT_PROTECTED } = await import('./bot/improve-loop.js');
+  await runImproveLoop({
+    maxCycles: opts.improveMaxCycles ?? 0,
+    maxConsecutiveFailures: opts.improveMaxFailures ?? 5,
+    protectedPatterns: opts.improveProtected ?? DEFAULT_PROTECTED,
+    testCommand: opts.improveTestCmd ?? 'npx vitest run',
+    buildCommand: opts.improveBuildCmd,
+    projectDir,
+  });
+}
+
 export async function handleExamples(_opts: ParsedArgs): Promise<void> {
   console.log('');
   console.log('  \x1b[1mWeaver Examples\x1b[0m');

package/src/handlers/on-execution-completed.ts

@@ -0,0 +1,30 @@
+/**
+ * Platform event handler: invalidates project model cache when executions complete.
+ * Registered in flowweaver.manifest.json as an event subscription.
+ */
+
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+export async function onExecutionCompleted(event: {
+  deploymentId?: string;
+  wsPath?: string;
+  status?: string;
+  executionTimeMs?: number;
+}): Promise<void> {
+  const projectDir = event.wsPath;
+  if (!projectDir) return;
+
+  // Invalidate project model cache directly (same logic as ProjectModelStore.invalidate)
+  try {
+    const hash8 = crypto.createHash('sha256').update(projectDir).digest('hex').slice(0, 8);
+    const modelPath = path.join(os.homedir(), '.weaver', 'projects', hash8, 'model.json');
+    if (fs.existsSync(modelPath)) {
+      fs.unlinkSync(modelPath);
+    }
+  } catch {
+    // Non-fatal — cache will be rebuilt on next access
+  }
+}

package/src/mcp-tools.ts

@@ -271,4 +271,42 @@ export async function registerMcpTools(mcp: McpServer): Promise<void> {
       return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     },
   );
+
+  mcp.tool(
+    'fw_weaver_insights',
+    'Get project health, insights, trust level, and cost summary. Returns structured JSON with actionable recommendations.',
+    {
+      projectDir: z.string().describe('Project directory path'),
+    },
+    async (args) => {
+      try {
+        const { ProjectModelStore } = await import('./bot/project-model.js');
+        const { InsightEngine } = await import('./bot/insight-engine.js');
+        const pms = new ProjectModelStore(args.projectDir as string);
+        const model = await pms.getOrBuild();
+        const engine = new InsightEngine();
+        const insights = engine.analyze(model);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              health: model.health,
+              bots: model.bots,
+              insights: insights.slice(0, 10),
+              trust: model.trust,
+              cost: model.cost,
+              evolution: {
+                totalCycles: model.evolution.totalCycles,
+                successRate: model.evolution.successRate,
+              },
+            }, null, 2),
+          }],
+        };
+      } catch (err: unknown) {
+        return {
+          content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+        };
+      }
+    },
+  );
 }

package/src/node-types/genesis-approve.ts

@@ -66,8 +66,33 @@ export async function genesisApprove(
     return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
   }
 
-  // Non-auto modes reject in non-interactive context
-  console.log('\x1b[33m→ Rejected (approval required, non-auto mode)\x1b[0m');
-  context.approved = false;
+  // Non-auto modes: try interactive approval, fall back to reject
+  let approved = false;
+  let rejectionReason = 'Non-interactive environment';
+
+  if (approvalMode === 'prompt') {
+    try {
+      const readline = await import('node:readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise<string>(resolve => {
+        rl.question('\x1b[33m? Approve this proposal? (y/N/reason): \x1b[0m', resolve);
+      });
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === 'y' || trimmed === 'yes') {
+        approved = true;
+      } else {
+        rejectionReason = trimmed && trimmed !== 'n' && trimmed !== 'no' ? answer.trim() : 'User rejected';
+      }
+    } catch {
+      // Non-interactive — fall through to reject
+    }
+  }
+
+  context.approved = approved;
+  context.rejectionReason = approved ? undefined : rejectionReason;
+  console.log(approved
+    ? '\x1b[32m→ Approved by user\x1b[0m'
+    : `\x1b[33m→ Rejected: ${rejectionReason}\x1b[0m`);
   return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
 }

package/src/node-types/genesis-observe.ts

@@ -46,22 +46,28 @@ export async function genesisObserve(
 
   try {
     const files: Record<string, string> = {};
-    const dirsToScan = [projectDir];
-    const srcDir = path.join(projectDir, 'src');
-    if (fs.existsSync(srcDir) && fs.statSync(srcDir).isDirectory()) dirsToScan.push(srcDir);
+    const fileContents: Record<string, string> = {};
+    const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', 'coverage', '.next', '.turbo']);
 
-    for (const dir of dirsToScan) {
+    function walkDir(dir: string): void {
       const entries = fs.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        if (entry.isFile() && entry.name.endsWith('.ts')) {
+        if (entry.isDirectory()) {
+          if (!SKIP_DIRS.has(entry.name)) {
+            walkDir(path.join(dir, entry.name));
+          }
+        } else if (entry.isFile() && entry.name.endsWith('.ts')) {
           const filePath = path.join(dir, entry.name);
           const relPath = path.relative(projectDir, filePath);
           const content = fs.readFileSync(filePath, 'utf-8');
+          fileContents[relPath] = content;
           files[relPath] = crypto.createHash('sha256').update(content).digest('hex');
         }
       }
     }
 
+    walkDir(projectDir);
+
     let packageJson: Record<string, unknown> | null = null;
     const pkgPath = path.join(projectDir, 'package.json');
     if (fs.existsSync(pkgPath)) {
@@ -83,17 +89,20 @@ export async function genesisObserve(
     }
 
     const existingWorkflows: string[] = [];
-    for (const [relPath, _hash] of Object.entries(files)) {
-      const filePath = path.join(projectDir, relPath);
-      const content = fs.readFileSync(filePath, 'utf-8');
+    for (const [relPath, content] of Object.entries(fileContents)) {
       if (content.includes('@flowWeaver workflow')) {
         existingWorkflows.push(relPath);
       }
     }
 
-    const targetPath = path.resolve(projectDir, config.targetWorkflow);
-    const targetContent = fs.readFileSync(targetPath, 'utf-8');
-    const workflowHash = crypto.createHash('sha256').update(targetContent).digest('hex');
+    let workflowHash = '';
+    let targetPath = '';
+    if (config.targetWorkflow) {
+      targetPath = path.resolve(projectDir, config.targetWorkflow);
+      const targetRelPath = path.relative(projectDir, targetPath);
+      const targetContent = fileContents[targetRelPath] ?? fs.readFileSync(targetPath, 'utf-8');
+      workflowHash = crypto.createHash('sha256').update(targetContent).digest('hex');
+    }
 
     const fingerprint: GenesisFingerprint = {
       timestamp: new Date().toISOString(),
@@ -108,7 +117,9 @@ export async function genesisObserve(
     console.log(`\x1b[36m→ Fingerprint: ${Object.keys(files).length} files, ${existingWorkflows.length} workflows\x1b[0m`);
 
     context.fingerprintJson = JSON.stringify(fingerprint);
-    context.workflowDescription = await getWorkflowDescription(targetPath);
+    if (targetPath) {
+      context.workflowDescription = await getWorkflowDescription(targetPath);
+    }
 
     return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
   } catch (err: unknown) {

package/src/node-types/genesis-propose.ts

@@ -40,10 +40,18 @@ export async function genesisPropose(
     graceRemaining: context.escrowGraceRemaining ?? 0,
   });
 
+  // Inject project intelligence
+  let insightContext = '';
+  try {
+    const { getGenesisInsightContext } = await import('../bot/genesis-prompt-context.js');
+    insightContext = await getGenesisInsightContext(env.projectDir);
+  } catch { /* insights not available */ }
+
   const userPrompt = [
     '## Current Workflow Structure',
     context.workflowDescription || '(no description available)',
     '',
+    ...(insightContext ? [insightContext, ''] : []),
     '## Project Diff Since Last Cycle',
     JSON.stringify(diff, null, 2),
     '',

package/src/node-types/genesis-update-history.ts

@@ -60,6 +60,18 @@ export function genesisUpdateHistory(ctx: string): { ctx: string } {
     if (fingerprint) {
       store.saveFingerprint(fingerprint);
     }
+
+    // Invalidate project model cache so next access rebuilds with fresh data
+    try {
+      // Use sync require-like approach: delete the cached model.json directly
+      const crypto = require('node:crypto') as typeof import('node:crypto');
+      const fsMod = require('node:fs') as typeof import('node:fs');
+      const pathMod = require('node:path') as typeof import('node:path');
+      const osMod = require('node:os') as typeof import('node:os');
+      const hash8 = crypto.createHash('sha256').update(env.projectDir).digest('hex').slice(0, 8);
+      const modelPath = pathMod.join(osMod.homedir(), '.weaver', 'projects', hash8, 'model.json');
+      if (fsMod.existsSync(modelPath)) fsMod.unlinkSync(modelPath);
+    } catch { /* project model not available */ }
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\x1b[31m→ Failed to save history: ${msg}\x1b[0m`);

package/src/ui/evolution-panel.tsx

@@ -0,0 +1,96 @@
+/**
+ * Weaver Evolution Panel — shows Genesis cycle history and operation effectiveness.
+ * Loaded dynamically by the platform's pack UI contributions loader.
+ */
+
+import React, { useEffect, useState } from 'react';
+
+interface EvolutionData {
+  evolution: {
+    totalCycles: number;
+    successRate: number;
+    byOperationType: Record<string, { proposed: number; applied: number; effectiveness: number }>;
+    recentCycles: Array<{ id: string; outcome: string; proposal?: { summary: string; impactLevel: string } }>;
+  };
+  trust: { phase: number; score: number };
+}
+
+export function WeaverEvolutionPanel({ projectDir }: { projectDir?: string }) {
+  const [data, setData] = useState<EvolutionData | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!projectDir) return;
+    fetch(`/api/mcp/fw_weaver_insights?projectDir=${encodeURIComponent(projectDir)}`)
+      .then(r => r.json())
+      .then(setData)
+      .catch(e => setError(e.message));
+  }, [projectDir]);
+
+  if (error) return <div style={{ padding: 16, color: '#ef4444' }}>Error: {error}</div>;
+  if (!data) return <div style={{ padding: 16, opacity: 0.5 }}>Loading evolution data...</div>;
+
+  const { evolution, trust } = data;
+  const outcomeColor: Record<string, string> = {
+    applied: '#22c55e',
+    'rolled-back': '#ef4444',
+    rejected: '#f59e0b',
+    'no-change': '#6b7280',
+    error: '#ef4444',
+  };
+
+  return (
+    <div style={{ padding: 16, fontFamily: 'system-ui, sans-serif', fontSize: 13 }}>
+      <div style={{ marginBottom: 16 }}>
+        <div style={{ fontWeight: 600, marginBottom: 4 }}>Trust Level</div>
+        <div style={{ display: 'flex', alignItems: 'baseline', gap: 8 }}>
+          <span style={{ fontSize: 20, fontWeight: 700 }}>Phase {trust.phase}</span>
+          <span style={{ opacity: 0.5 }}>Score: {trust.score}/100</span>
+        </div>
+      </div>
+
+      <div style={{ marginBottom: 16 }}>
+        <div style={{ fontWeight: 600, marginBottom: 4 }}>
+          Genesis Cycles: {evolution.totalCycles} ({evolution.totalCycles > 0 ? Math.round(evolution.successRate * 100) : 0}% success)
+        </div>
+      </div>
+
+      {Object.keys(evolution.byOperationType).length > 0 && (
+        <div style={{ marginBottom: 16 }}>
+          <div style={{ fontWeight: 600, marginBottom: 4 }}>Operation Effectiveness</div>
+          {Object.entries(evolution.byOperationType).map(([op, stats]) => (
+            <div key={op} style={{ padding: '2px 0', display: 'flex', justifyContent: 'space-between' }}>
+              <span>{op}</span>
+              <span style={{ opacity: 0.7 }}>{Math.round(stats.effectiveness * 100)}% ({stats.applied}/{stats.proposed})</span>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {evolution.recentCycles.length > 0 && (
+        <div>
+          <div style={{ fontWeight: 600, marginBottom: 4 }}>Recent Cycles</div>
+          {evolution.recentCycles.slice(-5).reverse().map((cycle) => (
+            <div key={cycle.id} style={{ padding: '4px 0', borderBottom: '1px solid rgba(128,128,128,0.1)' }}>
+              <span style={{ color: outcomeColor[cycle.outcome] ?? '#6b7280', fontWeight: 600, marginRight: 8 }}>
+                {cycle.outcome}
+              </span>
+              <span style={{ opacity: 0.7 }}>{cycle.id}</span>
+              {cycle.proposal && (
+                <div style={{ opacity: 0.6, paddingLeft: 8 }}>{cycle.proposal.summary}</div>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+
+      {evolution.totalCycles === 0 && (
+        <div style={{ opacity: 0.5, textAlign: 'center', padding: 20 }}>
+          No genesis cycles yet. Use /genesis in the assistant to start evolving bot workflows.
+        </div>
+      )}
+    </div>
+  );
+}
+
+export default WeaverEvolutionPanel;

package/src/ui/insights-widget.tsx

@@ -0,0 +1,77 @@
+/**
+ * Weaver Insights Dashboard Widget — shows project health, insights, and cost summary.
+ * Loaded dynamically by the platform's pack UI contributions loader.
+ */
+
+import React, { useEffect, useState } from 'react';
+
+interface InsightsData {
+  health: { overall: number; workflows: Array<{ file: string; score: number; trend: string }> };
+  bots: Array<{ name: string; ejected: boolean; successRate: number; totalTasksRun: number }>;
+  insights: Array<{ severity: string; title: string; description: string; confidence: number }>;
+  cost: { last7Days: number; trend: string };
+  trust: { phase: number; score: number };
+}
+
+export function WeaverInsightsWidget({ projectDir }: { projectDir?: string }) {
+  const [data, setData] = useState<InsightsData | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!projectDir) return;
+    fetch(`/api/mcp/fw_weaver_insights?projectDir=${encodeURIComponent(projectDir)}`)
+      .then(r => r.json())
+      .then(setData)
+      .catch(e => setError(e.message));
+  }, [projectDir]);
+
+  if (error) return <div style={{ padding: 16, color: '#ef4444' }}>Error: {error}</div>;
+  if (!data) return <div style={{ padding: 16, opacity: 0.5 }}>Loading insights...</div>;
+
+  const severityColor: Record<string, string> = {
+    critical: '#ef4444',
+    warning: '#f59e0b',
+    info: '#6b7280',
+  };
+
+  return (
+    <div style={{ padding: 16, fontFamily: 'system-ui, sans-serif', fontSize: 13 }}>
+      <div style={{ display: 'flex', alignItems: 'baseline', gap: 12, marginBottom: 12 }}>
+        <span style={{ fontSize: 28, fontWeight: 700 }}>{data.health.overall}</span>
+        <span style={{ opacity: 0.6 }}>/100 health</span>
+        <span style={{ marginLeft: 'auto', opacity: 0.5 }}>
+          Phase {data.trust.phase} · ${data.cost.last7Days.toFixed(2)}/7d ({data.cost.trend})
+        </span>
+      </div>
+
+      {data.insights.length > 0 && (
+        <div style={{ marginBottom: 12 }}>
+          <div style={{ fontWeight: 600, marginBottom: 6 }}>Insights</div>
+          {data.insights.slice(0, 3).map((insight, i) => (
+            <div key={i} style={{ padding: '4px 0', borderBottom: '1px solid rgba(128,128,128,0.1)' }}>
+              <span style={{ color: severityColor[insight.severity] ?? '#6b7280', fontWeight: 600, marginRight: 8 }}>
+                {insight.severity.toUpperCase()}
+              </span>
+              <span>{insight.title}</span>
+              <span style={{ opacity: 0.5, marginLeft: 8 }}>{Math.round(insight.confidence * 100)}%</span>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {data.bots.length > 0 && (
+        <div>
+          <div style={{ fontWeight: 600, marginBottom: 6 }}>Bots</div>
+          {data.bots.map((bot, i) => (
+            <div key={i} style={{ padding: '2px 0' }}>
+              {bot.name}: {Math.round(bot.successRate * 100)}% success ({bot.totalTasksRun} tasks)
+              {bot.ejected && <span style={{ opacity: 0.5 }}> · ejected</span>}
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+
+export default WeaverInsightsWidget;