@synergenius/flow-weaver-pack-weaver 0.9.14 → 0.9.16

package/src/ai-chat-provider.ts

@@ -0,0 +1,300 @@
+/**
+ * AI Chat Provider for the Weaver pack.
+ *
+ * Thin adapter that bridges Weaver's existing capabilities into the
+ * platform's generic pack AI chat extension system.
+ *
+ * - executeTool() delegates to the same handlers used by MCP tools
+ * - getSystemPromptSections() composes from existing bot infrastructure
+ */
+
+import { runWorkflow } from './bot/runner.js';
+import { RunStore } from './bot/run-store.js';
+import { CostStore } from './bot/cost-store.js';
+import { defaultRegistry, discoverProviders } from './bot/provider-registry.js';
+
+interface AiChatToolContext {
+  workspacePath: string;
+  userId: string;
+}
+
+interface AiChatToolResult {
+  result: string;
+  isError: boolean;
+}
+
+interface AiChatPromptSection {
+  id: string;
+  title: string;
+  content: string;
+  priority: number;
+}
+
+interface AiChatPromptContext {
+  workspacePath: string;
+  conversationId: string;
+  messageCount: number;
+}
+
+// ---------------------------------------------------------------------------
+// Tool handlers — reuse the same logic as MCP tools
+// ---------------------------------------------------------------------------
+
+const toolHandlers: Record<
+  string,
+  (args: Record<string, unknown>, ctx: AiChatToolContext) => Promise<string>
+> = {
+  async fw_weaver_run(args, ctx) {
+    const result = await runWorkflow(args.file as string, {
+      params: args.params as Record<string, unknown> | undefined,
+      verbose: args.verbose as boolean | undefined,
+      dryRun: args.dryRun as boolean | undefined,
+    });
+    return JSON.stringify(result, null, 2);
+  },
+
+  async fw_weaver_history(args) {
+    const store = new RunStore();
+    if (args.id) {
+      const record = store.get(args.id as string);
+      return record ? JSON.stringify(record, null, 2) : `No run found matching "${args.id}"`;
+    }
+    const records = store.list({
+      outcome: args.outcome as 'completed' | 'failed' | 'error' | 'skipped' | undefined,
+      workflowFile: args.workflowFile as string | undefined,
+      limit: (args.limit as number | undefined) ?? 20,
+    });
+    return records.length === 0 ? 'No runs recorded yet.' : JSON.stringify(records, null, 2);
+  },
+
+  async fw_weaver_costs(args) {
+    const store = new CostStore();
+    let sinceTs: number | undefined;
+    if (args.since) {
+      const spec = args.since as string;
+      const match = spec.match(/^(\d+)([dhm])$/);
+      if (match) {
+        const n = parseInt(match[1]!, 10);
+        const unit = match[2];
+        const ms = unit === 'd' ? n * 86_400_000 : unit === 'h' ? n * 3_600_000 : n * 60_000;
+        sinceTs = Date.now() - ms;
+      } else {
+        const ts = new Date(spec).getTime();
+        if (!isNaN(ts)) sinceTs = ts;
+      }
+    }
+    const summary = store.summarize({ since: sinceTs, model: args.model as string | undefined });
+    return JSON.stringify(summary, null, 2);
+  },
+
+  async fw_weaver_providers() {
+    await discoverProviders(defaultRegistry);
+    const providers = defaultRegistry.list();
+    const result = providers.map(({ name, metadata }) => ({
+      name,
+      source: metadata.source,
+      description: metadata.description,
+      requiredEnvVars: metadata.requiredEnvVars,
+      envVarsSet: metadata.requiredEnvVars?.every((v: string) => process.env[v]) ?? false,
+      detectCliCommand: metadata.detectCliCommand,
+    }));
+    return JSON.stringify(result, null, 2);
+  },
+
+  async fw_weaver_bot(args, ctx) {
+    const { fileURLToPath } = await import('node:url');
+    const { existsSync } = await import('node:fs');
+    const task = {
+      instruction: args.task as string,
+      mode: (args.mode as string) ?? 'create',
+      targets: args.targets as string[] | undefined,
+      options: {
+        template: args.template as string | undefined,
+        dryRun: args.dryRun as boolean | undefined,
+        autoApprove: (args.autoApprove as boolean | undefined) ?? true,
+      },
+    };
+    const packRoot = new URL('..', import.meta.url);
+    let workflowPath = fileURLToPath(new URL('src/workflows/weaver-bot.ts', packRoot));
+    if (!existsSync(workflowPath)) {
+      workflowPath = fileURLToPath(new URL('dist/workflows/weaver-bot.js', packRoot));
+    }
+    const result = await runWorkflow(workflowPath, {
+      params: { taskJson: JSON.stringify(task), projectDir: ctx.workspacePath || process.cwd() },
+      dryRun: args.dryRun as boolean | undefined,
+    });
+    return JSON.stringify(result, null, 2);
+  },
+
+  async fw_weaver_steer(args) {
+    const { SteeringController } = await import('./bot/steering.js');
+    const controller = new SteeringController();
+    await controller.write({
+      command: args.command as 'pause' | 'resume' | 'cancel' | 'redirect' | 'queue',
+      payload: args.payload as string | undefined,
+      timestamp: Date.now(),
+    });
+    return `Steering command sent: ${args.command}`;
+  },
+
+  async fw_weaver_queue(args) {
+    const { TaskQueue } = await import('./bot/task-queue.js');
+    const queue = new TaskQueue();
+    switch (args.action) {
+      case 'add': {
+        if (!args.task) return 'Error: task instruction required';
+        const { id, duplicate } = await queue.add({ instruction: args.task as string, priority: 0 });
+        return duplicate ? `Task already queued (${id})` : `Task added: ${id}`;
+      }
+      case 'list':
+        return JSON.stringify(await queue.list(), null, 2);
+      case 'clear': {
+        const count = await queue.clear();
+        return `Cleared ${count} task(s)`;
+      }
+      case 'remove': {
+        if (!args.id) return 'Error: task ID required';
+        const removed = await queue.remove(args.id as string);
+        return removed ? `Removed ${args.id}` : `Not found: ${args.id}`;
+      }
+      default:
+        return `Unknown action: ${args.action}`;
+    }
+  },
+
+  async fw_weaver_status() {
+    const { SessionStore } = await import('./bot/session-state.js');
+    const store = new SessionStore();
+    const state = store.load();
+    return state ? JSON.stringify(state, null, 2) : JSON.stringify({ status: 'no active session' }, null, 2);
+  },
+
+  async fw_weaver_genesis(args, ctx) {
+    const { fileURLToPath } = await import('node:url');
+    const { existsSync } = await import('node:fs');
+    const packRoot = new URL('..', import.meta.url);
+    let workflowPath = fileURLToPath(new URL('src/workflows/genesis-task.ts', packRoot));
+    if (!existsSync(workflowPath)) {
+      workflowPath = fileURLToPath(new URL('dist/workflows/genesis-task.js', packRoot));
+    }
+    const result = await runWorkflow(workflowPath, {
+      params: { projectDir: ctx.workspacePath || process.cwd() },
+      dryRun: args.dryRun as boolean | undefined,
+    });
+    return JSON.stringify(result, null, 2);
+  },
+
+  async fw_weaver_insights(args, ctx) {
+    const { ProjectModelStore } = await import('./bot/project-model.js');
+    const { InsightEngine } = await import('./bot/insight-engine.js');
+    const projectDir = (args.projectDir as string) || ctx.workspacePath;
+    const pms = new ProjectModelStore(projectDir);
+    const model = await pms.getOrBuild();
+    const engine = new InsightEngine();
+    const insights = engine.analyze(model);
+    return 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);
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Provider implementation
+// ---------------------------------------------------------------------------
+
+export default {
+  async executeTool(
+    name: string,
+    args: Record<string, unknown>,
+    context: AiChatToolContext,
+  ): Promise<AiChatToolResult> {
+    const handler = toolHandlers[name];
+    if (!handler) {
+      return { result: `Unknown weaver tool: ${name}`, isError: true };
+    }
+    try {
+      const result = await handler(args, context);
+      return { result, isError: false };
+    } catch (err) {
+      return { result: err instanceof Error ? err.message : String(err), isError: true };
+    }
+  },
+
+  async getSystemPromptSections(
+    context: AiChatPromptContext,
+  ): Promise<AiChatPromptSection[]> {
+    const sections: AiChatPromptSection[] = [];
+
+    // Weaver behavioral instructions
+    try {
+      const { buildBotSystemPrompt } = await import('./bot/system-prompt.js');
+      const prompt = buildBotSystemPrompt();
+      if (prompt) {
+        sections.push({
+          id: 'weaver-identity',
+          title: 'Weaver Behavioral Instructions',
+          content: prompt,
+          priority: 10,
+        });
+      }
+    } catch {
+      // system-prompt module not available — skip
+    }
+
+    // Project intelligence
+    if (context.workspacePath) {
+      try {
+        const { ProjectModelStore } = await import('./bot/project-model.js');
+        const pms = new ProjectModelStore(context.workspacePath);
+        const model = await pms.getOrBuild();
+        if (model && (model.health.workflows.length > 0 || model.bots.length > 0)) {
+          sections.push({
+            id: 'project-intelligence',
+            title: 'Project Intelligence',
+            content: pms.formatSummary(model) +
+              '\n\nBe proactive: mention relevant insights when they relate to what the user is working on.',
+            priority: 20,
+          });
+        }
+      } catch {
+        // ProjectModelStore not available — skip
+      }
+    }
+
+    // Proactive insights
+    if (context.workspacePath) {
+      try {
+        const { InsightEngine } = await import('./bot/insight-engine.js');
+        const engine = new InsightEngine();
+        const { ProjectModelStore } = await import('./bot/project-model.js');
+        const pms = new ProjectModelStore(context.workspacePath);
+        const model = await pms.getOrBuild();
+        if (model) {
+          const insights = engine.analyze(model).slice(0, 3);
+          if (insights.length > 0) {
+            sections.push({
+              id: 'proactive-insights',
+              title: 'Proactive Insights',
+              content: insights.map((i) =>
+                `- [${i.severity}] ${i.title}: ${i.description}`
+              ).join('\n'),
+              priority: 30,
+            });
+          }
+        }
+      } catch {
+        // InsightEngine not available — skip
+      }
+    }
+
+    return sections;
+  },
+};

package/src/docs/weaver-bot-usage.md

@@ -0,0 +1,34 @@
+## Weaver Bot
+
+The Weaver bot is an autonomous AI agent that creates and modifies Flow Weaver workflows from natural language instructions.
+
+### Running the bot
+
+Use `fw_weaver_bot` with a task description:
+- `task`: Natural language instruction (required)
+- `mode`: `create` (new workflow), `modify` (edit existing), `read` (analyze), `batch` (multiple tasks)
+- `targets`: File paths for modify/read mode
+- `autoApprove`: Skip the approval gate (default: true in studio)
+
+### Execution flow
+
+1. **Receive task** — parses instruction and determines mode
+2. **Build context** — gathers project state, templates, and relevant files
+3. **Plan** — AI generates a step-by-step execution plan
+4. **Approval gate** — plan shown for review (skipped if autoApprove)
+5. **Execute + validate + retry** — runs steps, validates output, retries on errors (up to 3 attempts)
+6. **Git ops** — commits changes if successful
+7. **Report** — returns summary with outcome
+
+### Steering a running bot
+
+Use `fw_weaver_steer` to control execution:
+- `pause` — pause at next safe point
+- `resume` — continue after pause
+- `cancel` — abort execution
+- `redirect` — change task mid-execution
+- `queue` — add a follow-up task
+
+### Checking status
+
+Use `fw_weaver_status` to see the current bot session state, active task, and completion count.

package/src/docs/weaver-genesis.md

@@ -0,0 +1,32 @@
+## Genesis Self-Evolution
+
+Genesis is Weaver's self-evolution protocol. It autonomously observes, proposes, applies, and validates changes to workflows.
+
+### Running a Genesis cycle
+
+Use `fw_weaver_genesis` to trigger a single cycle:
+- `projectDir`: Project directory (defaults to workspace)
+- `dryRun`: Preview changes without applying
+
+### How it works
+
+1. **Observe** — scans project for workflows and their health
+2. **Fingerprint** — detects if workflows changed since last cycle (avoids duplicate proposals)
+3. **Stabilize check** — prevents rapid churn (cooldown between cycles)
+4. **Propose** — AI analyzes project state and proposes modifications within a budget
+5. **Validate proposal** — checks proposed changes are safe
+6. **Snapshot** — creates backup before applying
+7. **Apply** — executes proposed operations via `flow-weaver modify`
+8. **Validate result** — compiles and validates the modified workflow
+9. **Threshold check** — decides if changes meet the quality bar
+10. **Approve** — human approval gate (configurable)
+11. **Commit** — git commit with rollback capability
+12. **Escrow** — data safety pipeline for recovery
+
+### Safety features
+
+- Pre-apply snapshots for rollback
+- Escrow recovery from previous cycles
+- Fingerprinting prevents duplicate proposals
+- Threshold checking before committing
+- Budget limits on proposed changes

package/src/docs/weaver-task-queue.md

@@ -0,0 +1,34 @@
+## Task Queue & Steering
+
+Weaver supports queuing tasks for background processing and steering running bots in real-time.
+
+### Task queue
+
+Use `fw_weaver_queue` to manage tasks:
+- `add` — add a task to the queue (requires `task` instruction)
+- `list` — show all queued tasks
+- `clear` — remove all pending tasks
+- `remove` — remove a specific task by ID
+
+Tasks are stored in NDJSON format and processed sequentially by the bot session.
+
+### Steering commands
+
+Use `fw_weaver_steer` to control a running bot:
+- `pause` — pause execution at the next safe point
+- `resume` — continue after a pause
+- `cancel` — abort the current task
+- `redirect` — change the task instruction mid-execution (requires `payload` with new instruction)
+- `queue` — add a follow-up task without interrupting the current one
+
+### Batch mode
+
+For multiple related tasks, use `fw_weaver_bot` with `mode: "batch"` to process them in sequence through the same bot session, sharing context between tasks.
+
+### Monitoring
+
+Use `fw_weaver_status` to check the current session state:
+- Session phase (idle, planning, executing, validating)
+- Current task instruction
+- Completed task count
+- Error state if any

package/src/ui/evolution-panel.tsx

@@ -1,94 +1,179 @@
 /**
- * Weaver Evolution Panel — shows Genesis cycle history and operation effectiveness.
- * Loaded dynamically by the platform's pack UI contributions loader.
+ * Weaver Evolution Panel — shows Genesis cycle history, trust level, improve status.
+ * Fetches data from the connected device via platform relay endpoints.
  */
 
-import React, { useEffect, useState } from 'react';
+import React, { useEffect, useState, useCallback } 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 } }>;
+interface ImproveStatus {
+  running: boolean;
+  lastRun?: {
+    successes: number;
+    failures: number;
+    skips: number;
+    cycles: Array<{ cycle: number; outcome: string; description: string; commitHash?: string }>;
   };
-  trust: { phase: number; score: number };
 }
 
-export function WeaverEvolutionPanel({ projectDir }: { projectDir?: string }) {
-  const [data, setData] = useState<EvolutionData | null>(null);
+interface HealthData {
+  health?: { overall: number };
+  trust?: { phase: number; score: number };
+  cost?: { last7Days: number; trend: string };
+}
+
+interface Device {
+  id: string;
+  name: string;
+  capabilities: string[];
+}
+
+export function WeaverEvolutionPanel() {
+  const [health, setHealth] = useState<HealthData | null>(null);
+  const [improve, setImprove] = useState<ImproveStatus | null>(null);
   const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [deviceId, setDeviceId] = useState<string | null>(null);
+  const [deviceName, setDeviceName] = useState('');
+  const [improving, setImproving] = useState(false);
+
+  const fetchData = useCallback(async () => {
+    try {
+      const devRes = await fetch('/api/devices', { credentials: 'include' });
+      if (!devRes.ok) { setError('Not connected'); setLoading(false); return; }
+      const devices: Device[] = await devRes.json();
+      const device = devices.find(d => d.capabilities?.includes('improve'));
+      if (!device) { setError('No device with improve capability'); setLoading(false); return; }
+      setDeviceId(device.id);
+      setDeviceName(device.name);
+
+      const [healthRes, improveRes] = await Promise.allSettled([
+        fetch(`/api/devices/${device.id}/health`, { credentials: 'include' }),
+        fetch(`/api/devices/${device.id}/improve/status`, { credentials: 'include' }),
+      ]);
+
+      if (healthRes.status === 'fulfilled' && healthRes.value.ok) {
+        setHealth(await healthRes.value.json());
+      }
+      if (improveRes.status === 'fulfilled' && improveRes.value.ok) {
+        const data = await improveRes.value.json();
+        setImprove(data);
+        setImproving(data.running ?? false);
+      }
+      setError(null);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Failed to load');
+    } finally {
+      setLoading(false);
+    }
+  }, []);
 
   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',
+    fetchData();
+    const interval = setInterval(fetchData, 15_000);
+    return () => clearInterval(interval);
+  }, [fetchData]);
+
+  const startImprove = async () => {
+    if (!deviceId) return;
+    setImproving(true);
+    try {
+      await fetch(`/api/devices/${deviceId}/improve`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ maxCycles: 5 }),
+      });
+    } catch { /* ignore */ }
   };
 
+  if (loading) return <div style={{ padding: 16, opacity: 0.5 }}>Loading...</div>;
+  if (error) return (
+    <div style={{ padding: 16 }}>
+      <div style={{ color: '#ef4444', marginBottom: 8 }}>{error}</div>
+      <button onClick={fetchData} style={{ fontSize: 12, color: '#6b7280', background: 'none', border: '1px solid #333', borderRadius: 4, padding: '4px 8px', cursor: 'pointer' }}>Retry</button>
+    </div>
+  );
+
+  const trustPhase = health?.trust?.phase ?? 1;
+  const trustScore = health?.trust?.score ?? 0;
+  const healthScore = health?.health?.overall ?? 0;
+
+  const outcomeIcon: Record<string, string> = { success: '\u2713', failure: '\u2717' };
+  const outcomeColor: Record<string, string> = { success: '#22c55e', failure: '#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 style={{ padding: 16, fontFamily: 'system-ui, sans-serif', fontSize: 13, color: 'var(--color-text-high, #e5e5e5)' }}>
+      <div style={{ fontSize: 10, textTransform: 'uppercase', letterSpacing: '0.05em', opacity: 0.5, marginBottom: 12 }}>
+        {deviceName}
       </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)
+      {/* Trust + Health */}
+      <div style={{ display: 'flex', gap: 16, marginBottom: 16 }}>
+        <div style={{ flex: 1, padding: 12, border: '1px solid rgba(128,128,128,0.2)', borderRadius: 6 }}>
+          <div style={{ fontSize: 20, fontWeight: 700 }}>P{trustPhase}</div>
+          <div style={{ fontSize: 10, opacity: 0.5, textTransform: 'uppercase', marginTop: 2 }}>Trust · {trustScore}/100</div>
+        </div>
+        <div style={{ flex: 1, padding: 12, border: '1px solid rgba(128,128,128,0.2)', borderRadius: 6 }}>
+          <div style={{ fontSize: 20, fontWeight: 700 }}>{healthScore}</div>
+          <div style={{ fontSize: 10, opacity: 0.5, textTransform: 'uppercase', marginTop: 2 }}>Health</div>
         </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>
-          ))}
+      {/* Improve */}
+      <div style={{ marginBottom: 16 }}>
+        <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', marginBottom: 8 }}>
+          <div style={{ fontWeight: 600, fontSize: 11, textTransform: 'uppercase', letterSpacing: '0.04em', opacity: 0.6 }}>
+            Improve
+          </div>
+          <button
+            onClick={startImprove}
+            disabled={improving}
+            style={{
+              fontSize: 11,
+              fontWeight: 500,
+              padding: '3px 10px',
+              borderRadius: 4,
+              border: '1px solid rgba(128,128,128,0.3)',
+              background: improving ? 'rgba(34,197,94,0.1)' : 'transparent',
+              color: improving ? '#22c55e' : 'var(--color-text-medium, #999)',
+              cursor: improving ? 'default' : 'pointer',
+              opacity: improving ? 0.8 : 1,
+            }}
+          >
+            {improving ? 'Running...' : 'Start Improve'}
+          </button>
         </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>
-              )}
+
+        {improve?.lastRun && (
+          <>
+            <div style={{ display: 'flex', gap: 8, marginBottom: 8 }}>
+              <span style={{ color: '#22c55e', fontWeight: 600 }}>{improve.lastRun.successes} committed</span>
+              <span style={{ color: '#ef4444', fontWeight: 600 }}>{improve.lastRun.failures} rolled back</span>
+              {improve.lastRun.skips > 0 && <span style={{ opacity: 0.5 }}>{improve.lastRun.skips} skipped</span>}
             </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>
-      )}
+            {improve.lastRun.cycles.slice(-5).reverse().map(cy => (
+              <div key={cy.cycle} style={{ padding: '4px 0', borderBottom: '1px solid rgba(128,128,128,0.1)', display: 'flex', alignItems: 'flex-start', gap: 6 }}>
+                <span style={{ color: outcomeColor[cy.outcome] ?? '#6b7280', fontWeight: 700, fontSize: 12, width: 14, textAlign: 'center', flexShrink: 0 }}>
+                  {outcomeIcon[cy.outcome] ?? '\u25CB'}
+                </span>
+                <span style={{ flex: 1, opacity: 0.8 }}>{cy.description.slice(0, 80)}</span>
+                {cy.commitHash && <span style={{ fontFamily: 'monospace', fontSize: 10, opacity: 0.4 }}>{cy.commitHash}</span>}
+              </div>
+            ))}
+          </>
+        )}
+
+        {!improve?.lastRun && (
+          <div style={{ opacity: 0.5, textAlign: 'center', padding: 16 }}>
+            No improve runs yet. Click "Start Improve" to begin.
+          </div>
+        )}
+      </div>
+
+      <div style={{ textAlign: 'right' }}>
+        <button onClick={fetchData} style={{ fontSize: 11, color: '#6b7280', background: 'none', border: 'none', cursor: 'pointer' }}>Refresh</button>
+      </div>
     </div>
   );
 }