@synergenius/flow-weaver-pack-weaver 0.9.8 → 0.9.10

package/src/bot/tool-registry.ts

@@ -8,7 +8,7 @@ import type { ToolDefinition } from '@synergenius/flow-weaver/agent';
 
 export interface WeaverTool extends ToolDefinition {
   verboseOutput?: boolean;
-  category: 'bot-management' | 'queue' | 'flow-weaver' | 'project' | 'knowledge' | 'conversation' | 'ci' | 'web';
+  category: 'bot-management' | 'queue' | 'flow-weaver' | 'project' | 'knowledge' | 'conversation' | 'ci' | 'web' | 'overseer';
   contexts: Array<'bot' | 'assistant'>;
 }
 
@@ -290,7 +290,7 @@ export const ALL_TOOLS: WeaverTool[] = [
       required: ['file', 'patches'],
     },
     category: 'project',
-    contexts: ['bot'],
+    contexts: ['bot', 'assistant'],
   },
   {
     name: 'write_file',
@@ -304,7 +304,7 @@ export const ALL_TOOLS: WeaverTool[] = [
       required: ['file', 'content'],
     },
     category: 'project',
-    contexts: ['bot'],
+    contexts: ['bot', 'assistant'],
   },
   {
     name: 'tsc_check',
@@ -312,7 +312,7 @@ export const ALL_TOOLS: WeaverTool[] = [
     inputSchema: { type: 'object', properties: {}, required: [] },
     verboseOutput: true,
     category: 'project',
-    contexts: ['bot'],
+    contexts: ['bot', 'assistant'],
   },
   {
     name: 'run_tests',
@@ -320,7 +320,7 @@ export const ALL_TOOLS: WeaverTool[] = [
     inputSchema: { type: 'object', properties: { pattern: { type: 'string', description: 'Test file pattern (optional)' } }, required: [] },
     verboseOutput: true,
     category: 'project',
-    contexts: ['bot'],
+    contexts: ['bot', 'assistant'],
   },
   {
     name: 'project_list',
@@ -434,6 +434,68 @@ export const ALL_TOOLS: WeaverTool[] = [
     contexts: ['bot', 'assistant'],
   },
 
+  // ── Overseer tools (assistant only) ─────────────────────────────
+  {
+    name: 'project_health',
+    description: 'Get project health: workflow scores, bot performance, failure patterns, cost trends, trust level.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'project_insights',
+    description: 'Get actionable insights: recurring failures, degrading workflows, cost optimizations, evolution opportunities.',
+    inputSchema: {
+      type: 'object',
+      properties: { limit: { type: 'number', description: 'Max insights (default 5)' } },
+      required: [],
+    },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'evolution_status',
+    description: 'Get genesis evolution history: cycle outcomes, operation effectiveness, recent proposals.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'genesis_propose',
+    description: 'Generate a Genesis evolution proposal for a bot workflow based on project insights. Auto-ejects bot if needed.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        bot: { type: 'string', description: 'Bot name (default: weaver-bot)' },
+        focus: { type: 'string', description: 'Optional focus area for the proposal' },
+        budget: { type: 'number', description: 'Cost unit budget (default: from config)' },
+      },
+      required: [],
+    },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'improve_status',
+    description: 'Get status of the current or most recent weaver improve run — cycles, commits, successes, failures.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'genesis_apply',
+    description: 'Apply an approved Genesis proposal to the bot workflow.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        proposal_id: { type: 'string', description: 'Proposal ID from genesis_propose' },
+      },
+      required: ['proposal_id'],
+    },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+
   // ── Bot-only interactive ─────────────────────────────────────────
   {
     name: 'ask_user',

package/src/bot/trust-calculator.ts

@@ -0,0 +1,87 @@
+/**
+ * Trust Calculator — pure function that derives a trust level from the project model.
+ *
+ * Trust phases:
+ *   Phase 1: Insights + suggestions (default)
+ *   Phase 2: Proposals with explanation
+ *   Phase 3: Proposals with visual diff
+ *   Phase 4: Auto-apply COSMETIC changes
+ */
+
+import type { TrustLevel } from './types.js';
+
+interface TrustInput {
+  health: { workflows: Array<{ lastRun: string | null }> };
+  userPreferences: { approvalHistory: Array<{ approved: boolean; impactLevel: string }> };
+  evolution: { totalCycles: number; successRate: number };
+  cost: { last7Days: number };
+  _conversationCount?: number;
+}
+
+export function computeTrustLevel(model: TrustInput): TrustLevel {
+  const conversationCount = model._conversationCount ?? 0;
+  const approvalHistory = model.userPreferences.approvalHistory;
+  const approvalCount = approvalHistory.length;
+  const approvalRate = approvalCount > 0
+    ? approvalHistory.filter(a => a.approved).length / approvalCount
+    : 0;
+  const genesisSuccessRate = model.evolution.totalCycles > 0 ? model.evolution.successRate : 0;
+
+  // Estimate days since first use from earliest workflow run
+  const timestamps: number[] = [];
+  for (const w of model.health.workflows) {
+    if (w.lastRun) timestamps.push(new Date(w.lastRun).getTime());
+  }
+  const earliest = timestamps.length > 0 ? Math.min(...timestamps) : Date.now();
+  const daysSinceFirstUse = Math.max(0, Math.round((Date.now() - earliest) / 86_400_000));
+
+  // COSMETIC-specific approval rate
+  const cosmeticApprovals = approvalHistory.filter(a => a.impactLevel === 'COSMETIC');
+  const cosmeticApprovalRate = cosmeticApprovals.length > 0
+    ? cosmeticApprovals.filter(a => a.approved).length / cosmeticApprovals.length
+    : 0;
+
+  // Weighted score (0-100)
+  const score = Math.round(
+    Math.min(conversationCount / 30, 1) * 25 +
+    approvalRate * 25 +
+    genesisSuccessRate * 25 +
+    Math.min(daysSinceFirstUse / 30, 1) * 25,
+  );
+
+  // Phase thresholds
+  let phase: 1 | 2 | 3 | 4 = 1;
+  if (
+    conversationCount >= 30 &&
+    cosmeticApprovalRate >= 0.85 &&
+    cosmeticApprovals.length >= 3 &&
+    daysSinceFirstUse >= 7
+  ) {
+    phase = 4;
+  } else if (
+    conversationCount >= 15 &&
+    approvalRate >= 0.7 &&
+    approvalCount >= 5 &&
+    model.evolution.totalCycles >= 3 &&
+    genesisSuccessRate >= 0.5
+  ) {
+    phase = 3;
+  } else if (
+    conversationCount >= 5 &&
+    approvalCount >= 3 &&
+    approvalRate >= 0.6
+  ) {
+    phase = 2;
+  }
+
+  return {
+    score,
+    phase,
+    factors: {
+      conversationCount,
+      approvalConsistency: approvalRate,
+      genesisSuccessRate,
+      daysSinceFirstUse,
+    },
+  };
+}

package/src/bot/types.ts

@@ -471,6 +471,108 @@ export interface GenesisFingerprint {
   existingWorkflows: string[];
 }
 
+// --- Project Model (Overseer) ---
+
+export interface WorkflowHealth {
+  file: string;
+  score: number;
+  totalRuns: number;
+  successRate: number;
+  avgDurationMs: number;
+  lastRun: string | null;
+  trend: 'improving' | 'stable' | 'degrading';
+}
+
+export interface FailurePattern {
+  pattern: string;
+  category: string;
+  occurrences: number;
+  lastSeen: string;
+  workflows: string[];
+  transient: boolean;
+}
+
+export interface ApprovalDecision {
+  timestamp: string;
+  proposalSummary: string;
+  impactLevel: string;
+  approved: boolean;
+  reason?: string;
+}
+
+export interface OperationEffectiveness {
+  proposed: number;
+  applied: number;
+  rolledBack: number;
+  effectiveness: number;
+}
+
+export interface TrustLevel {
+  score: number;
+  phase: 1 | 2 | 3 | 4;
+  factors: {
+    conversationCount: number;
+    approvalConsistency: number;
+    genesisSuccessRate: number;
+    daysSinceFirstUse: number;
+  };
+}
+
+export interface BotProfile {
+  name: string;
+  workflowFile: string;
+  ejected: boolean;
+  totalTasksRun: number;
+  successRate: number;
+  avgTaskDurationMs: number;
+  topFailurePatterns: FailurePattern[];
+}
+
+export interface ProjectModel {
+  projectDir: string;
+  builtAt: number;
+  health: {
+    overall: number;
+    workflows: WorkflowHealth[];
+  };
+  bots: BotProfile[];
+  failurePatterns: FailurePattern[];
+  userPreferences: {
+    approvalHistory: ApprovalDecision[];
+    autoApprovePatterns: string[];
+    neverApprovePatterns: string[];
+  };
+  evolution: {
+    totalCycles: number;
+    successRate: number;
+    byOperationType: Record<string, OperationEffectiveness>;
+    recentCycles: GenesisCycleRecord[];
+  };
+  cost: {
+    totalSpent: number;
+    last7Days: number;
+    last30Days: number;
+    trend: 'increasing' | 'stable' | 'decreasing';
+    costPerSuccessfulRun: number;
+    highCostWorkflows: Array<{ workflow: string; avgCost: number }>;
+  };
+  trust: TrustLevel;
+}
+
+export interface Insight {
+  id: string;
+  type: 'failure-pattern' | 'health-trend' | 'cost-optimization' | 'evolution-opportunity' | 'unused-workflow' | 'bot-performance' | 'update-available';
+  confidence: number;
+  severity: 'info' | 'warning' | 'critical';
+  title: string;
+  description: string;
+  evidence: string[];
+  suggestion?: string;
+  genesisCandidate: boolean;
+  targetBot?: string;
+  operationHint?: string;
+}
+
 export interface GenesisCycleRecord {
   id: string;
   timestamp: string;
@@ -483,6 +585,7 @@ export interface GenesisCycleRecord {
   approved: boolean | null;
   error: string | null;
   snapshotFile: string | null;
+  rejectionReason?: string;
 }
 
 export interface GenesisHistory {
@@ -519,6 +622,7 @@ export interface GenesisContext {
   workflowDiffJson?: string;
   approvalRequired?: boolean;
   approved?: boolean;
+  rejectionReason?: string;
   commitResultJson?: string;
   cycleRecordJson?: string;
   workflowDescription?: string;

package/src/bot/update-checker.ts

@@ -0,0 +1,138 @@
+/**
+ * Update Checker — checks npm registry for newer versions of installed packs.
+ * Results are cached for 24 hours to avoid spamming the registry.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { safeJsonParse } from './safe-json.js';
+
+export interface UpdateInfo {
+  packageName: string;
+  currentVersion: string;
+  latestVersion: string;
+  updateAvailable: boolean;
+}
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const CACHE_DIR = path.join(os.homedir(), '.weaver');
+const CACHE_FILE = path.join(CACHE_DIR, 'update-cache.json');
+
+interface CacheEntry {
+  checkedAt: number;
+  updates: UpdateInfo[];
+}
+
+function readCache(): CacheEntry | null {
+  try {
+    if (!fs.existsSync(CACHE_FILE)) return null;
+    const text = fs.readFileSync(CACHE_FILE, 'utf-8');
+    const parsed = safeJsonParse<CacheEntry>(text, 'update-cache');
+    if (!parsed.ok) {
+      console.error(`[weaver] ${parsed.error}`);
+      return null;
+    }
+    if (Date.now() - parsed.value.checkedAt < CACHE_TTL_MS) return parsed.value;
+    return null; // stale
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(entry: CacheEntry): void {
+  try {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(entry, null, 2), 'utf-8');
+  } catch { /* non-fatal */ }
+}
+
+export function compareVersions(a: string, b: string): number {
+  const pa = a.replace(/^v/, '').split('.').map(s => parseInt(s, 10) || 0);
+  const pb = b.replace(/^v/, '').split('.').map(s => parseInt(s, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+async function fetchLatestVersion(packageName: string): Promise<string | null> {
+  try {
+    const encoded = packageName.replace('/', '%2f');
+    const resp = await fetch(`https://registry.npmjs.org/${encoded}/latest`, {
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json() as { version?: string };
+    return data.version ?? null;
+  } catch {
+    return null; // network error, timeout, etc.
+  }
+}
+
+/**
+ * Check for updates on installed packs. Returns cached result if fresh.
+ * Checks: the weaver pack itself, and any flow-weaver-pack-* in node_modules.
+ */
+export async function checkForUpdates(projectDir: string): Promise<UpdateInfo[]> {
+  // Return cached if fresh
+  const cached = readCache();
+  if (cached) return cached.updates;
+
+  const updates: UpdateInfo[] = [];
+
+  // Check the weaver pack itself
+  try {
+    const packPkgPath = path.resolve(projectDir, 'node_modules', '@synergenius', 'flow-weaver-pack-weaver', 'package.json');
+    if (fs.existsSync(packPkgPath)) {
+      const text = fs.readFileSync(packPkgPath, 'utf-8');
+      const parsed = safeJsonParse<{ name: string; version: string }>(text, 'pack-weaver package.json');
+      if (!parsed.ok) {
+        console.error(`[weaver] ${parsed.error}`);
+      } else {
+        const pkg = parsed.value;
+        const current = pkg.version;
+        const latest = await fetchLatestVersion(pkg.name);
+        if (latest && compareVersions(latest, current) > 0) {
+          updates.push({ packageName: pkg.name, currentVersion: current, latestVersion: latest, updateAvailable: true });
+        } else if (latest) {
+          updates.push({ packageName: pkg.name, currentVersion: current, latestVersion: latest, updateAvailable: false });
+        }
+      }
+    }
+  } catch { /* not installed or unreadable */ }
+
+  // Check flow-weaver core
+  try {
+    const corePkgPath = path.resolve(projectDir, 'node_modules', '@synergenius', 'flow-weaver', 'package.json');
+    if (fs.existsSync(corePkgPath)) {
+      const text = fs.readFileSync(corePkgPath, 'utf-8');
+      const parsed = safeJsonParse<{ name: string; version: string }>(text, 'flow-weaver package.json');
+      if (!parsed.ok) {
+        console.error(`[weaver] ${parsed.error}`);
+      } else {
+        const pkg = parsed.value;
+        const current = pkg.version;
+        const latest = await fetchLatestVersion(pkg.name);
+        if (latest && compareVersions(latest, current) > 0) {
+          updates.push({ packageName: pkg.name, currentVersion: current, latestVersion: latest, updateAvailable: true });
+        }
+      }
+    }
+  } catch { /* not installed */ }
+
+  // Cache result
+  writeCache({ checkedAt: Date.now(), updates });
+  return updates;
+}
+
+/**
+ * Format update info as a brief notification string.
+ */
+export function formatUpdateNotification(updates: UpdateInfo[]): string | null {
+  const available = updates.filter(u => u.updateAvailable);
+  if (available.length === 0) return null;
+  const lines = available.map(u => `${u.packageName}: ${u.currentVersion} → ${u.latestVersion}`);
+  return `Updates available:\n${lines.join('\n')}\nRun: npm update`;
+}

package/src/bot/weaver-tools.ts

@@ -41,9 +41,14 @@ export function createWeaverExecutor(projectDir: string) {
         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 };
+        try {
+          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 };
+        } catch (err: unknown) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { result: `Fetch error: ${msg}`, isError: true };
+        }
       }
 
       case 'tsc_check': {
@@ -68,7 +73,8 @@ export function createWeaverExecutor(projectDir: string) {
             const failures = (json.testResults ?? []).filter((t: any) => t.status === 'failed').map((t: any) => t.name).slice(0, 10);
             return { result: JSON.stringify({ passed, failed, total: passed + failed, failures }), isError: failed > 0 };
           } catch {
-            return { result: output.slice(0, 5000), isError: false };
+            // JSON parse failed — output is not structured, flag as error
+            return { result: output.slice(0, 5000), isError: true };
           }
         } catch (err: any) {
           return { result: (err.stdout ?? err.stderr ?? err.message ?? '').slice(0, 5000), isError: true };

package/src/cli-bridge.ts

@@ -4,7 +4,7 @@ import {
   handleCron, handlePipeline, handleDashboard, handleProviders,
   handleEject, handleBot, handleSession, handleSteer, handleQueue,
   handleStatus, handleGenesis, handleAudit, handleInit, handleAssistant,
-  handleExamples, handleDoctor,
+  handleExamples, handleDoctor, handleImprove,
   printHelp,
 } from './cli-handlers.js';
 
@@ -29,6 +29,7 @@ const handlers: Record<string, (opts: ParsedArgs) => Promise<void>> = {
   assistant: handleAssistant,
   examples: handleExamples,
   doctor: handleDoctor,
+  improve: handleImprove,
 };
 
 export { printHelp };

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;
@@ -70,6 +70,14 @@ export interface ParsedArgs {
   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 {
@@ -258,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') {
@@ -272,6 +282,8 @@ export function parseArgs(argv: string[]): ParsedArgs {
       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];
@@ -294,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('-')) {
@@ -1624,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;
   }
@@ -1663,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 });
@@ -1673,6 +1707,36 @@ 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');
@@ -2169,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');