@synergenius/flow-weaver-pack-weaver 0.9.59 → 0.9.77

package/src/bot/ai-router.ts

@@ -0,0 +1,132 @@
+/**
+ * AIRouterImpl — LLM-powered routing for ambiguous profile selection.
+ *
+ * When multiple bot profiles match a task, the orchestrator delegates
+ * to this router to pick the best one.
+ * Uses the project's configured AI provider via the callAI infrastructure.
+ */
+
+import type { AIRouter, AIRouterResult } from './orchestrator.js';
+import type { BotProfile, OrchestratorInput } from './profile-types.js';
+import type { ProviderInfo } from './types.js';
+import { callAI, parseJsonResponse } from './ai-client.js';
+import { resolveProviderConfig, detectProvider } from './agent-provider.js';
+
+type Task = OrchestratorInput['pendingTasks'][number];
+
+// ---------------------------------------------------------------------------
+// Provider resolution — map BotProviderConfig.name to ProviderInfo.type
+// ---------------------------------------------------------------------------
+
+const NAME_TO_TYPE: Record<string, ProviderInfo['type']> = {
+  anthropic: 'anthropic',
+  'claude-cli': 'claude-cli',
+  'copilot-cli': 'copilot-cli',
+  platform: 'platform',
+};
+
+function resolveProviderInfo(projectDir: string): Pick<ProviderInfo, 'type' | 'apiKey' | 'model' | 'maxTokens'> {
+  // Try reading .weaver.json from the project directory
+  let providerInput: string | { name: string; model?: string; maxTokens?: number } = 'auto';
+  try {
+    const fs = require('node:fs');
+    const path = require('node:path');
+    const configPath = path.join(projectDir, '.weaver.json');
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      if (config.provider) providerInput = config.provider;
+    }
+  } catch { /* use auto detection */ }
+
+  const resolved = resolveProviderConfig(providerInput);
+  const type = NAME_TO_TYPE[resolved.name] ?? 'claude-cli';
+
+  return {
+    type,
+    model: resolved.model,
+    maxTokens: resolved.maxTokens,
+    apiKey: type === 'anthropic' ? process.env.ANTHROPIC_API_KEY : undefined,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// AIRouterImpl
+// ---------------------------------------------------------------------------
+
+const SYSTEM_PROMPT =
+  'You are a task routing orchestrator. Given a task and candidate bot profiles, ' +
+  'select the best profile to handle the task. Respond with ONLY valid JSON: ' +
+  '{ "profileId": "...", "reason": "...", "confidence": 0.0-1.0 }';
+
+export class AIRouterImpl implements AIRouter {
+  private projectDir: string;
+
+  constructor(projectDir: string) {
+    this.projectDir = projectDir;
+  }
+
+  async route(task: Task, candidates: BotProfile[]): Promise<AIRouterResult> {
+    const prompt = this._buildPrompt(task, candidates);
+    const providerInfo = resolveProviderInfo(this.projectDir);
+
+    // Use a low max-tokens since this is just a routing decision
+    const response = await callAI(providerInfo, SYSTEM_PROMPT, prompt, 256);
+
+    const result = parseJsonResponse(response) as {
+      profileId?: string;
+      reason?: string;
+      confidence?: number;
+    };
+
+    if (!result.profileId) {
+      throw new Error('AI router returned no profileId');
+    }
+
+    return {
+      profileId: result.profileId,
+      reason: result.reason || 'AI-selected',
+      confidence: typeof result.confidence === 'number' ? result.confidence : 0.5,
+    };
+  }
+
+  /** @internal — exposed for testing */
+  _buildPrompt(task: Task, candidates: BotProfile[]): string {
+    const lines = [
+      `Task: "${task.title}"`,
+      task.description ? `Description: ${task.description}` : '',
+      task.complexity ? `Complexity: ${task.complexity}` : '',
+      '',
+      'Candidate profiles:',
+      ...candidates.map((p) => {
+        const parts = [`- ${p.id} (${p.name}):`];
+        if (p.capabilities.length > 0) {
+          parts.push('  Capabilities:');
+          for (const cap of p.capabilities) {
+            parts.push(`    - ${cap.name}: ${cap.description}`);
+          }
+        }
+        parts.push(`  Cost strategy: ${p.preferences.costStrategy}`);
+        if (p.preferences.instructions) {
+          parts.push(`  Instructions: ${p.preferences.instructions}`);
+        }
+        parts.push(`  maxInstances=${p.maxInstances}`);
+        return parts.join('\n');
+      }),
+    ];
+
+    // Add previous attempt info if available
+    const failures = task.context.runSummaries.filter((r) => r.outcome !== 'success');
+    if (failures.length > 0) {
+      lines.push(
+        '',
+        `Previous attempts: ${task.context.runSummaries.length} (${failures.length} failed)`,
+      );
+      for (const f of failures.slice(-3)) {
+        lines.push(`  - ${f.botId}: ${f.outcome}`);
+      }
+    }
+
+    lines.push('', 'Select the best profile. Respond with JSON only.');
+    return lines.filter(Boolean).join('\n');
+  }
+}

package/src/bot/assistant-tools.ts

@@ -53,19 +53,19 @@ export function createAssistantExecutor(projectDir: string, steeringEngine?: imp
           const botName = String(args.name);
           const bot = mgr.get(botName);
           if (!bot) return { result: `Bot "${botName}" not found.`, isError: true };
-          const queue = mgr.getQueue(botName);
-          const tasks = await queue.list();
+          const store = mgr.getTaskStore(botName);
+          const tasks = await store.list();
           const pending = tasks.filter(t => t.status === 'pending').length;
-          const running = tasks.filter(t => t.status === 'running').length;
-          const completed = tasks.filter(t => t.status === 'completed').length;
+          const inProgress = tasks.filter(t => t.status === 'in-progress').length;
+          const done = tasks.filter(t => t.status === 'done').length;
           const failed = tasks.filter(t => t.status === 'failed').length;
           const failedTasks = tasks.filter(t => t.status === 'failed');
           let result = `Bot "${botName}": ${bot.status}\n`;
-          result += `Tasks: ${completed} completed, ${failed} failed, ${running} running, ${pending} pending\n`;
+          result += `Tasks: ${done} done, ${failed} failed, ${inProgress} in-progress, ${pending} pending\n`;
           if (failedTasks.length > 0) {
             result += `\nFailed tasks:\n`;
             for (const t of failedTasks) {
-              result += `  - ${t.instruction.slice(0, 120)}\n`;
+              result += `  - ${t.title.slice(0, 120)}\n`;
             }
           }
           return { result, isError: false };
@@ -89,36 +89,45 @@ export function createAssistantExecutor(projectDir: string, steeringEngine?: imp
 
         // Queue management
         case 'queue_add': {
-          const queue = mgr.getQueue(String(args.bot));
-          const { id, duplicate } = await queue.add({
-            instruction: String(args.instruction),
-            targets: args.targets as string[] | undefined,
+          const store = mgr.getTaskStore(String(args.bot));
+          const task = await store.create({
+            title: String(args.instruction),
+            description: String(args.instruction),
             priority: 0,
+            createdBy: 'ai',
           });
-          if (duplicate) return { result: `Skipped: similar task already exists (${id}).`, isError: false };
-          return { result: `Added task ${id} to "${args.bot}" queue.`, isError: false };
+          return { result: `Added task ${task.id} to "${args.bot}" queue.`, isError: false };
         }
         case 'queue_add_batch': {
-          const queue = mgr.getQueue(String(args.bot));
+          const store = mgr.getTaskStore(String(args.bot));
           const tasks = args.tasks as Array<{ instruction: string; targets?: string[] }>;
-          let added = 0, skipped = 0;
+          let added = 0;
           for (const t of tasks) {
-            const { duplicate } = await queue.add({ instruction: t.instruction, targets: t.targets, priority: 0 });
-            if (duplicate) skipped++; else added++;
+            await store.create({
+              title: t.instruction,
+              description: t.instruction,
+              priority: 0,
+              createdBy: 'ai',
+            });
+            added++;
           }
-          const msg = skipped > 0 ? `Added ${added} tasks, ${skipped} duplicates skipped.` : `Added ${added} tasks to "${args.bot}" queue.`;
-          return { result: msg, isError: false };
+          return { result: `Added ${added} tasks to "${args.bot}" queue.`, isError: false };
         }
         case 'queue_list': {
-          const queue = mgr.getQueue(String(args.bot));
-          const tasks = await queue.list();
+          const store = mgr.getTaskStore(String(args.bot));
+          const tasks = await store.list();
           if (tasks.length === 0) return { result: 'Queue is empty.', isError: false };
-          const lines = tasks.map(t => `[${t.status}] ${t.instruction.slice(0, 120)}`);
+          const lines = tasks.map(t => `[${t.status}] ${t.title.slice(0, 120)}`);
           return { result: lines.join('\n'), isError: false };
         }
         case 'queue_retry': {
-          const queue = mgr.getQueue(String(args.bot));
-          const count = await queue.retryAll();
+          const store = mgr.getTaskStore(String(args.bot));
+          const tasks = await store.list({ status: 'failed' });
+          let count = 0;
+          for (const t of tasks) {
+            await store.update(t.id, { status: 'pending' });
+            count++;
+          }
           return { result: `Reset ${count} failed task(s) to pending.`, isError: false };
         }
 
@@ -322,12 +331,21 @@ export function createAssistantExecutor(projectDir: string, steeringEngine?: imp
           const projectsDir = path.join(os.homedir(), '.weaver', 'projects');
           if (!fs.existsSync(projectsDir)) return { result: 'No projects found.', isError: false };
           const dirs = fs.readdirSync(projectsDir);
-          // Each dir is a hash — try to find meta or queue files
-          const projects = dirs.map(d => {
-            const queuePath = path.join(projectsDir, d, 'task-queue.ndjson');
-            const exists = fs.existsSync(queuePath);
-            return `${d}: ${exists ? 'has queue' : 'empty'}`;
-          });
+          // Each dir is a project — check for tasks via TaskStore
+          const projects = await Promise.all(dirs.map(async d => {
+            const projPath = path.join(projectsDir, d);
+            try {
+              const { TaskStore } = await import('./task-store.js');
+              const store = new TaskStore(projPath);
+              const tasks = await store.list();
+              const pending = tasks.filter(t => t.status === 'pending').length;
+              const inProgress = tasks.filter(t => t.status === 'in-progress').length;
+              if (tasks.length === 0) return `${d}: empty`;
+              return `${d}: ${tasks.length} tasks (${pending} pending, ${inProgress} in-progress)`;
+            } catch {
+              return `${d}: empty`;
+            }
+          }));
           return { result: projects.join('\n') || 'No projects found.', isError: false };
         }
 

package/src/bot/async-mutex.ts

@@ -0,0 +1,37 @@
+/**
+ * Simple async mutex for serializing access to shared resources
+ * within the same Node.js process. Used by TaskStore to prevent
+ * concurrent bot loops from corrupting task state.
+ */
+export class AsyncMutex {
+  private _queue: Array<() => void> = [];
+  private _locked = false;
+
+  async runExclusive<T>(fn: () => Promise<T>): Promise<T> {
+    await this._acquire();
+    try {
+      return await fn();
+    } finally {
+      this._release();
+    }
+  }
+
+  private _acquire(): Promise<void> {
+    if (!this._locked) {
+      this._locked = true;
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      this._queue.push(resolve);
+    });
+  }
+
+  private _release(): void {
+    const next = this._queue.shift();
+    if (next) {
+      next();
+    } else {
+      this._locked = false;
+    }
+  }
+}

package/src/bot/bot-manager.ts

@@ -8,7 +8,7 @@ import { spawn, execFileSync, type ChildProcess } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-import { TaskQueue } from './task-queue.js';
+import { TaskStore } from './task-store.js';
 import { SteeringController } from './steering.js';
 
 export interface ManagedBot {
@@ -172,10 +172,10 @@ export class BotManager {
     try { process.kill(bot.pid, 0); return true; } catch { return false; }
   }
 
-  getQueue(name: string): TaskQueue {
+  getTaskStore(name: string): TaskStore {
     const bot = this.resolve(name);
     if (!bot) throw new Error(`Bot "${name}" not found.`);
-    return new TaskQueue(bot.meta.botDir);
+    return new TaskStore(bot.meta.botDir);
   }
 
   getSteering(name: string): SteeringController {

package/src/bot/bot-registry.ts

@@ -1,5 +1,5 @@
 /**
- * Bot registry — manages .fw/bots.json in the user's workspace.
+ * Bot registry — manages .weaver/bots.json in the user's workspace.
  * Reads, writes, validates bot registrations.
  */
 import * as fs from 'node:fs';
@@ -19,7 +19,7 @@ export interface BotRegistration {
   ejected?: boolean;
 }
 
-const BOTS_FILE = '.fw/bots.json';
+const BOTS_FILE = '.weaver/bots.json';
 
 export class BotRegistry {
   private _cache: BotRegistration[] | null = null;

package/src/bot/conversation-store.ts

@@ -26,6 +26,7 @@ export interface ConversationRecord {
   createdAt: number;
   lastMessageAt: number;
   botIds: string[];
+  cloudConversationId?: string;
 }
 
 interface StoredMessage {
@@ -221,7 +222,7 @@ export class ConversationStore {
         },
         body: JSON.stringify({
           message: `[Synced from CLI] ${message}`,
-          conversationId: (conversation as any).cloudConversationId,
+          conversationId: conversation.cloudConversationId,
         }),
       }).catch(() => {}); // fire-and-forget
     } catch { /* sync not available */ }

package/src/bot/dashboard.ts

@@ -10,8 +10,7 @@ import type {
 } from './types.js';
 import type { ApprovalResult } from './approvals.js';
 import { SteeringController } from './steering.js';
-import { SessionStore } from './session-state.js';
-import { TaskQueue } from './task-queue.js';
+import { TaskStore } from './task-store.js';
 
 interface RunState {
   workflowFile: string;
@@ -321,15 +320,25 @@ export class DashboardServer {
   }
 
   private handleBotStatus(res: http.ServerResponse): void {
-    const store = new SessionStore();
-    const session = store.load();
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(session ?? { status: 'idle', currentTask: null, completedTasks: 0 }));
+    const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
+    const store = new TaskStore(projectDir);
+    store.list().then(tasks => {
+      const pending = tasks.filter(t => t.status === 'pending').length;
+      const inProgress = tasks.filter(t => t.status === 'in-progress').length;
+      const done = tasks.filter(t => t.status === 'done').length;
+      const failed = tasks.filter(t => t.status === 'failed').length;
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: inProgress > 0 ? 'executing' : 'idle', pending, inProgress, done, failed }));
+    }).catch(() => {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: 'idle', pending: 0, inProgress: 0, done: 0, failed: 0 }));
+    });
   }
 
   private async handleBotQueue(res: http.ServerResponse): Promise<void> {
-    const queue = new TaskQueue();
-    const tasks = await queue.list();
+    const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
+    const store = new TaskStore(projectDir);
+    const tasks = await store.list();
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(tasks));
   }

package/src/bot/improve-loop.ts

@@ -526,9 +526,9 @@ function emptyResult(startedAt: string, branch: string, worktreePath: string, re
 
 // --- Helpers ---
 
-let cachedProvider: unknown = null;
-let cachedTools: unknown[] = [];
-let cachedExecutor: unknown = null;
+let cachedProvider: import('@synergenius/flow-weaver/agent').AgentProvider | null = null;
+let cachedTools: import('@synergenius/flow-weaver/agent').ToolDefinition[] = [];
+let cachedExecutor: import('@synergenius/flow-weaver/agent').ToolExecutor | null = null;
 
 async function runAssistantInDir(worktreeDir: string, message: string, _conversationId: string, steeringEngine?: import('./steering-engine.js').SteeringEngine): Promise<string> {
   const originalCwd = process.cwd();
@@ -562,9 +562,9 @@ async function runAssistantInDir(worktreeDir: string, message: string, _conversa
     const toolCalls: Array<{ name: string; isError: boolean }> = [];
 
     const result = await runAgentLoop(
-      cachedProvider as any,
-      cachedTools as any,
-      cachedExecutor as any,
+      cachedProvider!,
+      cachedTools,
+      cachedExecutor!,
       [{ role: 'user' as const, content: message }],
       {
         maxIterations: 20,

package/src/bot/index.ts

@@ -128,10 +128,8 @@ export { validateFiles } from './file-validator.js';
 // Bot infrastructure
 export { SteeringController } from './steering.js';
 export type { SteeringCommand } from './steering.js';
-export { TaskQueue } from './task-queue.js';
-export type { QueuedTask } from './task-queue.js';
-export { SessionStore } from './session-state.js';
-export type { SessionState } from './session-state.js';
+export { TaskStore } from './task-store.js';
+export type { Task, TaskFilter, CreateTaskInput, TaskStatus } from './task-types.js';
 export { buildBotSystemPrompt } from './system-prompt.js';
 
 // Device bridge handlers

package/src/bot/instance-manager.ts

@@ -0,0 +1,128 @@
+/**
+ * InstanceManager — manages in-memory bot instances (workers) per profile.
+ * Instances represent running workers that don't survive process restart.
+ */
+
+import type { BotProfile, BotInstance } from './profile-types.js';
+
+export class InstanceManager {
+  private instances = new Map<string, BotInstance>();
+
+  /** Spawn a new instance for the given profile. Throws if maxInstances reached. */
+  spawn(profile: BotProfile): BotInstance {
+    const existing = this.listByProfile(profile.id);
+    if (existing.length >= profile.maxInstances) {
+      throw new Error(
+        `Cannot spawn: profile "${profile.id}" already at max instances (${profile.maxInstances})`,
+      );
+    }
+
+    const usedIndices = new Set(existing.map((i) => i.index));
+    let index = 0;
+    while (usedIndices.has(index)) index++;
+
+    const instance: BotInstance = {
+      instanceId: `${profile.id}-${index}`,
+      profileId: profile.id,
+      index,
+      status: 'idle',
+      tokensUsed: 0,
+      cost: 0,
+      tasksCompleted: 0,
+      tasksFailed: 0,
+    };
+
+    this.instances.set(instance.instanceId, instance);
+    return { ...instance };
+  }
+
+  /** Get instance by ID (returns a copy), or null if not found. */
+  get(instanceId: string): BotInstance | null {
+    const inst = this.instances.get(instanceId);
+    return inst ? { ...inst } : null;
+  }
+
+  /** Return copies of all instances. */
+  listAll(): BotInstance[] {
+    return [...this.instances.values()].map((i) => ({ ...i }));
+  }
+
+  /** Return copies of instances belonging to a specific profile. */
+  listByProfile(profileId: string): BotInstance[] {
+    return [...this.instances.values()]
+      .filter((i) => i.profileId === profileId)
+      .map((i) => ({ ...i }));
+  }
+
+  /** Return idle instances for a given profile. */
+  findIdle(profileId: string): BotInstance[] {
+    return [...this.instances.values()]
+      .filter((i) => i.profileId === profileId && i.status === 'idle')
+      .map((i) => ({ ...i }));
+  }
+
+  /** Mark an instance as executing a specific task/run. */
+  markExecuting(instanceId: string, taskId: string, runId: string): void {
+    const inst = this.instances.get(instanceId);
+    if (!inst) throw new Error(`Instance not found: ${instanceId}`);
+    inst.status = 'executing';
+    inst.currentTaskId = taskId;
+    inst.currentRunId = runId;
+    inst.startedAt = new Date().toISOString();
+  }
+
+  /** Mark an instance as idle after task completion/failure. */
+  markIdle(instanceId: string, success: boolean): void {
+    const inst = this.instances.get(instanceId);
+    if (!inst) throw new Error(`Instance not found: ${instanceId}`);
+    inst.status = 'idle';
+    inst.currentTaskId = undefined;
+    inst.currentRunId = undefined;
+    inst.startedAt = undefined;
+    if (success) {
+      inst.tasksCompleted++;
+    } else {
+      inst.tasksFailed++;
+    }
+  }
+
+  /** Record token/cost usage for an instance. */
+  recordUsage(instanceId: string, tokens: number, cost: number): void {
+    const inst = this.instances.get(instanceId);
+    if (!inst) throw new Error(`Instance not found: ${instanceId}`);
+    inst.tokensUsed += tokens;
+    inst.cost += cost;
+  }
+
+  /** Stop and remove an instance. Returns true if it existed. */
+  stop(instanceId: string): boolean {
+    return this.instances.delete(instanceId);
+  }
+
+  /** Stop and remove all instances. */
+  stopAll(): void {
+    this.instances.clear();
+  }
+
+  /** Scale instances for a profile to the target count. Clamps to [0, maxInstances]. */
+  scaleTo(profile: BotProfile, target: number): void {
+    const clamped = Math.max(0, Math.min(target, profile.maxInstances));
+    const current = this.listByProfile(profile.id);
+
+    if (current.length < clamped) {
+      // Spawn more
+      const toSpawn = clamped - current.length;
+      for (let i = 0; i < toSpawn; i++) {
+        this.spawn(profile);
+      }
+    } else if (current.length > clamped) {
+      // Stop idle instances first
+      const idle = current.filter((i) => i.status === 'idle');
+      const toStop = current.length - clamped;
+      const stopped = idle.slice(0, toStop);
+      for (const inst of stopped) {
+        this.stop(inst.instanceId);
+      }
+    }
+  }
+}