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

package/src/bot/assistant-tools.ts

@@ -22,7 +22,7 @@ function getManager(): BotManager {
   return manager;
 }
 
-export function createAssistantExecutor(projectDir: string): ToolExecutor {
+export function createAssistantExecutor(projectDir: string, steeringEngine?: import('./steering-engine.js').SteeringEngine): ToolExecutor {
   const mgr = getManager();
 
   return async (name: string, args: Record<string, unknown>) => {
@@ -38,7 +38,7 @@ export function createAssistantExecutor(projectDir: string): ToolExecutor {
             deadline: args.deadline as string | undefined,
             branch: args.branch as string | undefined,
           });
-          return { result: JSON.stringify(bot), isError: false };
+          return { result: `Bot "${botName}" started (pid ${bot.pid}). Add tasks with queue_add or check status with bot_status.`, isError: false };
         }
         case 'bot_list': {
           const bots = mgr.list();
@@ -65,7 +65,7 @@ export function createAssistantExecutor(projectDir: string): ToolExecutor {
           if (failedTasks.length > 0) {
             result += `\nFailed tasks:\n`;
             for (const t of failedTasks) {
-              result += `  - ${t.instruction.slice(0, 80)}\n`;
+              result += `  - ${t.instruction.slice(0, 120)}\n`;
             }
           }
           return { result, isError: false };
@@ -95,7 +95,7 @@ export function createAssistantExecutor(projectDir: string): ToolExecutor {
             targets: args.targets as string[] | undefined,
             priority: 0,
           });
-          if (duplicate) return { result: `Task already queued (${id}).`, isError: false };
+          if (duplicate) return { result: `Skipped: similar task already exists (${id}).`, isError: false };
           return { result: `Added task ${id} to "${args.bot}" queue.`, isError: false };
         }
         case 'queue_add_batch': {
@@ -113,7 +113,7 @@ export function createAssistantExecutor(projectDir: string): ToolExecutor {
           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)}`);
+          const lines = tasks.map(t => `[${t.status}] ${t.instruction.slice(0, 120)}`);
           return { result: lines.join('\n'), isError: false };
         }
         case 'queue_retry': {
@@ -172,8 +172,9 @@ export function createAssistantExecutor(projectDir: string): ToolExecutor {
         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 blockedPattern = isBlockedCommand(cmd);
+          if (blockedPattern) {
+            return { result: `Blocked: command matches disallowed pattern "${blockedPattern}".`, isError: true };
           }
           const output = execFileSync('sh', ['-c', cmd], {
             encoding: 'utf-8', cwd: projectDir, timeout: 30_000, stdio: ['pipe', 'pipe', 'pipe'],
@@ -181,6 +182,86 @@ export function createAssistantExecutor(projectDir: string): ToolExecutor {
           return { result: output.trim().slice(0, 5000) || '(no output)', isError: false };
         }
 
+        case 'write_file': {
+          const filePath = path.isAbsolute(String(args.file)) ? String(args.file) : path.resolve(projectDir, String(args.file));
+          // Safety: must be within project directory
+          if (!filePath.startsWith(projectDir)) {
+            steeringEngine?.recordEvent('file_write_blocked');
+            return { result: 'Blocked: cannot write files outside project directory.', isError: true };
+          }
+          const content = String(args.content);
+          if (!content.trim()) {
+            steeringEngine?.recordEvent('file_write_blocked');
+            return { result: 'Blocked: cannot write empty file.', isError: true };
+          }
+          // Check shrink protection for existing files
+          if (fs.existsSync(filePath)) {
+            const existing = fs.readFileSync(filePath, 'utf-8');
+            if (existing.length > 0 && content.length < existing.length * 0.5) {
+              steeringEngine?.recordEvent('file_write_blocked');
+              return { result: `Blocked: write would shrink file by more than 50% (${existing.length} -> ${content.length} chars).`, isError: true };
+            }
+          }
+          const dir = path.dirname(filePath);
+          if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+          fs.writeFileSync(filePath, content, 'utf-8');
+          steeringEngine?.recordEvent('file_write');
+          return { result: `Wrote ${content.length} chars to ${path.relative(projectDir, filePath)}`, isError: false };
+        }
+        case 'patch_file': {
+          const filePath = path.isAbsolute(String(args.file)) ? String(args.file) : path.resolve(projectDir, String(args.file));
+          if (!filePath.startsWith(projectDir)) {
+            return { result: 'Blocked: cannot patch files outside project directory.', isError: true };
+          }
+          if (!fs.existsSync(filePath)) {
+            return { result: `File not found: ${args.file}`, isError: true };
+          }
+          let content = fs.readFileSync(filePath, 'utf-8');
+          const patches = args.patches as Array<{ find: string; replace: string }>;
+          let applied = 0;
+          for (const p of patches) {
+            if (content.includes(p.find)) {
+              content = content.replace(p.find, p.replace);
+              applied++;
+            }
+          }
+          if (applied === 0) {
+            steeringEngine?.recordEvent('file_patch_blocked');
+            return { result: `No patches matched in ${args.file}. Check exact strings.`, isError: true };
+          }
+          fs.writeFileSync(filePath, content, 'utf-8');
+          steeringEngine?.recordEvent('file_patch');
+          return { result: `Applied ${applied}/${patches.length} patches to ${path.relative(projectDir, filePath)}`, isError: false };
+        }
+        case 'tsc_check': {
+          try {
+            const output = execFileSync('npx', ['tsc', '--noEmit'], {
+              encoding: 'utf-8', cwd: projectDir, timeout: 60_000, stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            steeringEngine?.recordEvent('build_pass');
+            return { result: output.trim() || 'TypeScript check passed — no errors.', isError: false };
+          } catch (tscErr: any) {
+            steeringEngine?.recordEvent('build_fail');
+            const msg = tscErr instanceof Error ? tscErr.message : String(tscErr);
+            return { result: msg.length > 500 ? msg.slice(0, 497) + '...' : msg, isError: true };
+          }
+        }
+        case 'run_tests': {
+          const testArgs = ['vitest', 'run'];
+          if (args.pattern) testArgs.push(String(args.pattern));
+          try {
+            const output = execFileSync('npx', testArgs, {
+              encoding: 'utf-8', cwd: projectDir, timeout: 120_000, stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            steeringEngine?.recordEvent('test_pass');
+            return { result: output.trim().slice(-3000) || 'Tests completed.', isError: false };
+          } catch (testErr: any) {
+            steeringEngine?.recordEvent('test_fail');
+            const msg = testErr instanceof Error ? testErr.message : String(testErr);
+            return { result: msg.length > 3000 ? msg.slice(-3000) : msg, isError: true };
+          }
+        }
+
         // Conversation management
         case 'conversation_list': {
           const { ConversationStore } = await import('./conversation-store.js');
@@ -200,7 +281,7 @@ export function createAssistantExecutor(projectDir: string): ToolExecutor {
           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));
+          await cStore.delete(String(args.id));
           return { result: `Deleted conversation "${args.id}" (${existing.title || 'untitled'}).`, isError: false };
         }
         case 'conversation_summary': {
@@ -307,12 +388,213 @@ export function createAssistantExecutor(projectDir: string): ToolExecutor {
           return { result: entries.map(e => `${e.key}: ${e.value}`).join('\n'), isError: false };
         }
 
+        // Overseer tools
+        case 'project_health': {
+          const { ProjectModelStore } = await import('./project-model.js');
+          const pms = new ProjectModelStore(projectDir);
+          const model = await pms.getOrBuild();
+          const lines: string[] = [
+            `Overall health: ${model.health.overall}/100`,
+            '',
+          ];
+          if (model.health.workflows.length > 0) {
+            lines.push('Workflows:');
+            for (const w of model.health.workflows) {
+              lines.push(`  ${w.file}: ${w.score}/100 (${w.totalRuns} runs, ${Math.round(w.successRate * 100)}% success, trend: ${w.trend})`);
+            }
+            lines.push('');
+          }
+          if (model.bots.length > 0) {
+            lines.push('Bots:');
+            for (const b of model.bots) {
+              lines.push(`  ${b.name}: ${b.ejected ? 'ejected' : 'pack'} (${b.totalTasksRun} tasks, ${Math.round(b.successRate * 100)}% success)`);
+            }
+            lines.push('');
+          }
+          if (model.failurePatterns.length > 0) {
+            lines.push('Failure patterns:');
+            for (const p of model.failurePatterns.slice(0, 5)) {
+              lines.push(`  ${p.pattern} (${p.occurrences}x, ${p.transient ? 'transient' : 'persistent'})`);
+            }
+            lines.push('');
+          }
+          lines.push(`Cost (7d): $${model.cost.last7Days.toFixed(2)} (trend: ${model.cost.trend})`);
+          lines.push(`Trust: phase ${model.trust.phase} (score ${model.trust.score})`);
+          return { result: lines.join('\n'), isError: false };
+        }
+
+        case 'project_insights': {
+          const { ProjectModelStore } = await import('./project-model.js');
+          const { InsightEngine } = await import('./insight-engine.js');
+          const pms = new ProjectModelStore(projectDir);
+          const model = await pms.getOrBuild();
+          const engine = new InsightEngine();
+          const insights = engine.analyze(model);
+          const limit = (args.limit as number) ?? 5;
+          if (insights.length === 0) return { result: 'No actionable insights right now. Keep running workflows to build up data.', isError: false };
+          const lines = insights.slice(0, limit).map(i =>
+            `[${i.severity}] ${i.title} (confidence: ${Math.round(i.confidence * 100)}%)\n  ${i.description}${i.suggestion ? `\n  Suggestion: ${i.suggestion}` : ''}`
+          );
+          return { result: lines.join('\n\n'), isError: false };
+        }
+
+        case 'evolution_status': {
+          const { ProjectModelStore } = await import('./project-model.js');
+          const pms = new ProjectModelStore(projectDir);
+          const model = await pms.getOrBuild();
+          const evo = model.evolution;
+          if (evo.totalCycles === 0) return { result: 'No genesis cycles recorded yet. Use /genesis or genesis_propose to start evolving bot workflows.', isError: false };
+          const lines = [
+            `Total cycles: ${evo.totalCycles} (${Math.round(evo.successRate * 100)}% success rate)`,
+            '',
+            'Operation effectiveness:',
+            ...Object.entries(evo.byOperationType).map(([op, stats]) =>
+              `  ${op}: ${Math.round(stats.effectiveness * 100)}% effective (${stats.applied}/${stats.proposed} applied)`
+            ),
+            '',
+            'Recent cycles:',
+            ...evo.recentCycles.slice(-5).map(c =>
+              `  ${c.id} [${c.outcome}] ${c.proposal?.summary ?? 'no proposal'}`
+            ),
+          ];
+          return { result: lines.join('\n'), isError: false };
+        }
+
+        case 'improve_status': {
+          const summaryDir = path.join(os.homedir(), '.weaver', 'improve');
+          if (!fs.existsSync(summaryDir)) return { result: 'No improve runs found. Start one with: weaver improve', isError: false };
+          const files = fs.readdirSync(summaryDir).filter(f => f.endsWith('.json')).sort().reverse();
+          if (files.length === 0) return { result: 'No improve runs found.', isError: false };
+          const latest = JSON.parse(fs.readFileSync(path.join(summaryDir, files[0]!), 'utf-8'));
+          const duration = Math.round((new Date(latest.finishedAt).getTime() - new Date(latest.startedAt).getTime()) / 1000);
+          const lines: string[] = [
+            `Improve Run: ${latest.reason}`,
+            `Branch: ${latest.branch}`,
+            `Duration: ${duration}s`,
+            `Successes: ${latest.successes}  Failures: ${latest.failures}  Skips: ${latest.skips}`,
+            '',
+          ];
+          for (const cy of latest.cycles) {
+            const icon = cy.outcome === 'success' ? '✓' : cy.outcome === 'failure' ? '✗' : '○';
+            lines.push(`${icon} Cycle ${cy.cycle}: [${cy.outcome}] ${cy.description.slice(0, 70)}`);
+            if (cy.commitHash) lines.push(`  Commit: ${cy.commitHash}`);
+          }
+          // Check if worktree is active (run in progress)
+          try {
+            const worktrees = execFileSync('git', ['worktree', 'list'], { encoding: 'utf-8', cwd: projectDir });
+            if (worktrees.includes('weaver-improve')) {
+              lines.push('', 'LIVE: improve worktree active — run in progress');
+            }
+          } catch { /* git not available */ }
+          return { result: lines.join('\n'), isError: false };
+        }
+
+        case 'genesis_propose': {
+          const { ProjectModelStore } = await import('./project-model.js');
+          const pms = new ProjectModelStore(projectDir);
+          const model = await pms.getOrBuild();
+
+          // Check if genesis config exists, create default if not
+          const genesisDir = path.join(projectDir, '.genesis');
+          const configPath = path.join(genesisDir, 'config.json');
+          if (!fs.existsSync(configPath)) {
+            fs.mkdirSync(genesisDir, { recursive: true });
+            const defaultConfig = {
+              intent: args.focus ? String(args.focus) : 'Improve bot workflow reliability and efficiency',
+              focus: args.focus ? [String(args.focus)] : [],
+              constraints: [],
+              approvalThreshold: 'MINOR',
+              budgetPerCycle: (args.budget as number) ?? 3,
+              stabilize: false,
+              targetWorkflow: '',
+              maxCyclesPerRun: 1,
+            };
+
+            // Find bot workflow — check ejected first, then pack
+            const botName = String(args.bot ?? 'weaver-bot');
+            const ejectedPath = path.join(projectDir, '.fw', 'bots', botName, 'weaver-bot.ts');
+            const packPath = path.resolve(projectDir, 'node_modules', '@synergenius', 'flow-weaver-pack-weaver', 'src', 'workflows', 'weaver-bot.ts');
+
+            if (fs.existsSync(ejectedPath)) {
+              defaultConfig.targetWorkflow = ejectedPath;
+            } else if (fs.existsSync(packPath)) {
+              // Auto-eject: copy from pack to project
+              const ejectDir = path.join(projectDir, '.fw', 'bots', botName);
+              fs.mkdirSync(ejectDir, { recursive: true });
+              fs.copyFileSync(packPath, path.join(ejectDir, 'weaver-bot.ts'));
+              defaultConfig.targetWorkflow = path.join(ejectDir, 'weaver-bot.ts');
+              // Also copy node types needed
+            } else {
+              return { result: `Could not find bot workflow for "${botName}". Ensure the weaver pack is installed.`, isError: true };
+            }
+
+            fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2), 'utf-8');
+          }
+
+          // Build insight context
+          let insightSummary = '';
+          try {
+            const { getGenesisInsightContext } = await import('./genesis-prompt-context.js');
+            insightSummary = await getGenesisInsightContext(projectDir);
+          } catch { /* insights not available */ }
+
+          // Build proposal summary from model data
+          const lines: string[] = ['Genesis Proposal Context:', ''];
+          lines.push(`Project health: ${model.health.overall}/100`);
+          lines.push(`Trust phase: ${model.trust.phase}`);
+          if (model.failurePatterns.length > 0) {
+            lines.push('');
+            lines.push('Key failure patterns:');
+            for (const p of model.failurePatterns.slice(0, 3)) {
+              lines.push(`  - ${p.pattern} (${p.occurrences}x, ${p.transient ? 'transient' : 'persistent'})`);
+            }
+          }
+          if (model.bots.length > 0) {
+            lines.push('');
+            lines.push('Bot performance:');
+            for (const b of model.bots) {
+              lines.push(`  - ${b.name}: ${Math.round(b.successRate * 100)}% success (${b.totalTasksRun} tasks, ${b.ejected ? 'ejected' : 'pack'})`);
+            }
+          }
+          if (insightSummary) {
+            lines.push('');
+            lines.push(insightSummary);
+          }
+          lines.push('');
+          lines.push('To generate and apply a full proposal, run: flow-weaver weaver genesis');
+          lines.push('Or use genesis_apply after reviewing this context.');
+
+          return { result: lines.join('\n'), isError: false };
+        }
+
+        case 'genesis_apply': {
+          const proposalId = String(args.proposal_id);
+
+          // Run genesis via CLI
+          try {
+            const output = execFileSync('npx', ['flow-weaver', 'weaver', 'genesis', '--max-cycles', '1'], {
+              encoding: 'utf-8', cwd: projectDir, timeout: 120_000, stdio: ['pipe', 'pipe', 'pipe'],
+            });
+
+            // Invalidate project model cache
+            try {
+              const { ProjectModelStore } = await import('./project-model.js');
+              new ProjectModelStore(projectDir).invalidate();
+            } catch { /* non-fatal */ }
+
+            return { result: output.trim() || 'Genesis cycle completed.', isError: false };
+          } catch (err: any) {
+            return { result: `Genesis cycle failed: ${(err.message ?? '').slice(0, 500)}`, isError: true };
+          }
+        }
+
         default:
           return { result: `Unknown tool: ${name}`, isError: true };
       }
     } catch (err: unknown) {
+      steeringEngine?.recordEvent('tool_error');
       const msg = err instanceof Error ? err.message : String(err);
-      return { result: msg.slice(0, 500), isError: true };
+      return { result: msg.length > 500 ? msg.slice(0, 497) + '...' : msg, isError: true };
     }
   };
 }

package/src/bot/bot-agent-channel.ts

@@ -72,6 +72,7 @@ export class BotAgentChannel {
     if (this.provider.decideWithTools) {
       return this.provider.decideWithTools({ ...agentRequest, tools });
     }
+    console.warn('[BotAgentChannel] Provider does not support decideWithTools — falling back to decide (tool results will be dropped)');
     const result = await this.provider.decide(agentRequest);
     return { result };
   }
@@ -85,6 +86,7 @@ export class BotAgentChannel {
       yield* this.provider.stream(agentRequest);
       return;
     }
+    console.warn('[BotAgentChannel] Provider does not support stream — falling back to decide (response will be non-streaming)');
     const result = await this.provider.decide(agentRequest);
     yield { type: 'text', text: JSON.stringify(result) };
     yield { type: 'done' };

package/src/bot/bot-manager.ts

@@ -32,7 +32,7 @@ export interface SpawnOpts {
 const BOTS_DIR = path.join(os.homedir(), '.weaver', 'bots');
 
 export class BotManager {
-  private bots = new Map<string, { meta: ManagedBot; process: ChildProcess }>();
+  private bots = new Map<string, { meta: ManagedBot; process: ChildProcess | null }>();
 
   constructor() {
     // Ensure base dir exists
@@ -42,21 +42,33 @@ export class BotManager {
     const cleanup = () => this.cleanup();
     process.on('exit', cleanup);
     process.on('SIGTERM', cleanup);
+    process.on('SIGINT', cleanup);
   }
 
   spawn(name: string, opts: SpawnOpts): ManagedBot {
     if (this.bots.has(name)) {
-      throw new Error(`Bot "${name}" already exists. Stop it first or use a different name.`);
+      throw new Error(`Bot "${name}" already exists. Use bot_stop("${name}") first, or choose a different name.`);
     }
 
     const botDir = path.join(BOTS_DIR, name);
     fs.mkdirSync(botDir, { recursive: true });
 
     // Create git branch if specified (keeps main clean for overnight runs)
+    // WARNING: checkout -B mutates the user's working directory. Prefer git worktree
+    // for isolation when the project supports it.
     if (opts.branch) {
       try {
-        execFileSync('git', ['checkout', '-B', opts.branch], { cwd: opts.projectDir, encoding: 'utf-8', stdio: 'pipe' });
-      } catch { /* branch may already exist */ }
+        // Try worktree first for isolation (does not mutate the user's working dir)
+        const worktreePath = path.join(botDir, 'worktree');
+        execFileSync('git', ['worktree', 'add', '-B', opts.branch, worktreePath], { cwd: opts.projectDir, encoding: 'utf-8', stdio: 'pipe' });
+        opts.projectDir = worktreePath;
+      } catch {
+        // Worktree unavailable or failed — fall back to checkout but warn
+        process.stderr.write(`[weaver] WARNING: "git checkout -B ${opts.branch}" will switch the working directory in ${opts.projectDir}. Use git worktree for isolation.\n`);
+        try {
+          execFileSync('git', ['checkout', '-B', opts.branch], { cwd: opts.projectDir, encoding: 'utf-8', stdio: 'pipe' });
+        } catch { /* branch may already exist */ }
+      }
     }
 
     const logPath = path.join(botDir, 'output.log');
@@ -83,12 +95,19 @@ export class BotManager {
       WEAVER_STEERING_DIR: botDir,
     };
 
-    const child = spawn(cmd, args, {
-      cwd: opts.projectDir,
-      env,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      detached: false,
-    });
+    let child: ChildProcess;
+    try {
+      child = spawn(cmd, args, {
+        cwd: opts.projectDir,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: false,
+      });
+    } catch (err) {
+      // Clean up logStream on spawn failure to prevent fd leak
+      logStream.destroy();
+      throw err;
+    }
 
     // Capture output to log file
     child.stdout?.pipe(logStream);
@@ -135,7 +154,7 @@ export class BotManager {
   }
 
   get(name: string): ManagedBot | null {
-    const bot = this.bots.get(name);
+    const bot = this.resolve(name);
     if (!bot) return null;
     // Health check on access
     if (bot.meta.status === 'running' && !this.isAlive(bot.meta)) {
@@ -154,13 +173,13 @@ export class BotManager {
   }
 
   getQueue(name: string): TaskQueue {
-    const bot = this.bots.get(name);
+    const bot = this.resolve(name);
     if (!bot) throw new Error(`Bot "${name}" not found.`);
     return new TaskQueue(bot.meta.botDir);
   }
 
   getSteering(name: string): SteeringController {
-    const bot = this.bots.get(name);
+    const bot = this.resolve(name);
     if (!bot) throw new Error(`Bot "${name}" not found.`);
     return new SteeringController(bot.meta.botDir);
   }
@@ -178,26 +197,30 @@ export class BotManager {
   }
 
   stop(name: string): void {
-    const bot = this.bots.get(name);
+    const bot = this.resolve(name);
     if (!bot) throw new Error(`Bot "${name}" not found.`);
-    // Send SIGTERM for graceful shutdown
-    if (bot.process.pid && !bot.process.killed) {
-      bot.process.kill('SIGTERM');
-    }
+    this.sendSignal(bot, 'SIGTERM');
     bot.meta.status = 'stopped';
   }
 
   kill(name: string): void {
-    const bot = this.bots.get(name);
+    const bot = this.resolve(name);
     if (!bot) throw new Error(`Bot "${name}" not found.`);
-    if (bot.process.pid && !bot.process.killed) {
-      bot.process.kill('SIGKILL');
-    }
+    this.sendSignal(bot, 'SIGKILL');
     bot.meta.status = 'stopped';
   }
 
+  /** Send a signal to a bot, using the process handle if available, otherwise the PID from meta. */
+  private sendSignal(bot: { meta: ManagedBot; process: ChildProcess | null }, signal: NodeJS.Signals): void {
+    if (bot.process?.pid && !bot.process.killed) {
+      bot.process.kill(signal);
+    } else if (bot.meta.pid > 0) {
+      try { process.kill(bot.meta.pid, signal); } catch { /* process already gone */ }
+    }
+  }
+
   logs(name: string, lines = 50): string {
-    const bot = this.bots.get(name);
+    const bot = this.resolve(name);
     if (!bot) throw new Error(`Bot "${name}" not found.`);
     const logPath = path.join(bot.meta.botDir, 'output.log');
     if (!fs.existsSync(logPath)) return '(no logs yet)';
@@ -208,7 +231,7 @@ export class BotManager {
 
   cleanup(): void {
     for (const [, bot] of this.bots) {
-      if (bot.process.pid && !bot.process.killed) {
+      if (bot.process?.pid && !bot.process.killed) {
         try { bot.process.kill('SIGTERM'); } catch (err) {
           if (process.env.WEAVER_VERBOSE) process.stderr.write(`[weaver] SIGTERM failed for bot: ${err}\n`);
         }
@@ -216,6 +239,16 @@ export class BotManager {
     }
   }
 
+  /** Look up a bot by name, lazily discovering bots from disk if not in memory. */
+  private resolve(name: string): { meta: ManagedBot; process: ChildProcess | null } | undefined {
+    let bot = this.bots.get(name);
+    if (!bot) {
+      this.discoverExistingBots();
+      bot = this.bots.get(name);
+    }
+    return bot;
+  }
+
   /** Discover bots from disk that were spawned by a previous assistant session. */
   private discoverExistingBots(): void {
     if (!fs.existsSync(BOTS_DIR)) return;
@@ -235,7 +268,7 @@ export class BotManager {
           }
         }
         // Store without a process handle (can only steer via file, not kill directly)
-        this.bots.set(name, { meta, process: null as unknown as ChildProcess });
+        this.bots.set(name, { meta, process: null });
       } catch { /* corrupt meta */ }
     }
   }
@@ -277,15 +310,23 @@ function wrapWithSleepInhibitor(command: string, args: string[]): { cmd: string;
 export function sendDesktopNotification(title: string, message: string): void {
   try {
     switch (process.platform) {
-      case 'darwin':
-        execFileSync('osascript', ['-e', `display notification "${message}" with title "${title}"`], { stdio: 'ignore' });
+      case 'darwin': {
+        // Escape backslashes and double-quotes for AppleScript string literals
+        const safeTitle = title.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        const safeMessage = message.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        execFileSync('osascript', ['-e', `display notification "${safeMessage}" with title "${safeTitle}"`], { stdio: 'ignore' });
         break;
+      }
       case 'linux':
         execFileSync('notify-send', [title, message], { stdio: 'ignore' });
         break;
-      case 'win32':
-        execFileSync('powershell', ['-Command', `[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('${message}','${title}')`], { stdio: 'ignore' });
+      case 'win32': {
+        // Escape single-quotes for PowerShell single-quoted strings (double them)
+        const psTitle = title.replace(/'/g, "''");
+        const psMessage = message.replace(/'/g, "''");
+        execFileSync('powershell', ['-Command', `[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('${psMessage}','${psTitle}')`], { stdio: 'ignore' });
         break;
+      }
     }
   } catch {
     // Non-fatal — notification is best-effort