@synergenius/flow-weaver-pack-weaver 0.9.152 → 0.9.154

package/src/bot/swarm-controller.ts

@@ -1,9 +1,10 @@
 /**
  * SwarmController — multi-bot orchestrator for the Weaver Swarm.
  *
- * Uses a centralized orchestrator dispatch loop instead of per-bot pull loops.
- * The Orchestrator routes pending tasks to the best available bot instance,
- * the InstanceManager handles scaling, and the ProfileStore persists profiles.
+ * Uses a dynamic worker pool: N generic worker slots (controlled by maxConcurrent).
+ * Any worker can run any profile's task. The profile is loaded per-task, not per-slot.
+ *
+ * Worker naming: `worker-0`, `worker-1`, `worker-2` (no per-profile instances).
  *
  * Singleton per workspace via `SwarmController.getInstance(projectDir)`.
  */
@@ -42,7 +43,7 @@ export interface SwarmState {
   status: 'idle' | 'running' | 'paused' | 'stopping';
   startedAt?: string;
 
-  /** Active bot instances managed by InstanceManager. */
+  /** Active worker slots (generic pool). Keyed by instanceId (worker-0, worker-1, ...). */
   instances: Record<string, BotInstance>;
   maxConcurrent: number;
 
@@ -105,7 +106,7 @@ export class SwarmController {
   private dispatchAbort: AbortController | null = null;
   /** Promise for the dispatch loop (resolved when the loop exits). */
   private dispatchLoopPromise: Promise<void> | null = null;
-  /** Promises for currently executing tasks (instanceId -> Promise). */
+  /** Promises for currently executing tasks (workerId -> Promise). */
   private executionPromises = new Map<string, Promise<void>>();
   /** Track which promises have settled (resolved or rejected). */
   private settledPromises = new Set<string>();
@@ -189,23 +190,11 @@ export class SwarmController {
       if (bot) this.profileBotMap.set(profile.id, bot);
     }
 
-    // Stop any existing instances
+    // Stop any existing workers
     this.instanceManager.stopAll();
 
-    // Spawn initial instances per profile (up to maxConcurrent total)
-    let totalSpawned = 0;
-    for (const profile of profiles) {
-      if (totalSpawned >= this.state.maxConcurrent) break;
-
-      // Spawn at least minInstances, or 1 if minInstances is 0
-      const toSpawn = Math.max(profile.minInstances, 1);
-      const clamped = Math.min(toSpawn, this.state.maxConcurrent - totalSpawned);
-
-      for (let i = 0; i < clamped; i++) {
-        this.instanceManager.spawn(profile);
-        totalSpawned++;
-      }
-    }
+    // Spawn generic worker pool based on maxConcurrent
+    this.instanceManager.spawnPool(this.state.maxConcurrent);
 
     // Populate state fields
     this._syncInstancesState();
@@ -259,7 +248,7 @@ export class SwarmController {
     const execPromises = Array.from(this.executionPromises.values());
     await Promise.allSettled(execPromises);
 
-    // Stop all instances
+    // Stop all workers
     this.instanceManager.stopAll();
 
     // Update state
@@ -277,7 +266,7 @@ export class SwarmController {
   }
 
   getStatus(): SwarmState {
-    // Sync instances from InstanceManager before returning
+    // Sync workers from InstanceManager before returning
     this._syncInstancesState();
     return { ...this.state, instances: { ...this.state.instances } };
   }
@@ -298,11 +287,11 @@ export class SwarmController {
   // -----------------------------------------------------------------------
 
   async recover(): Promise<void> {
-    // Reset all instances to idle
-    const allInstances = this.instanceManager.listAll();
-    for (const inst of allInstances) {
-      if (inst.status === 'executing') {
-        this.instanceManager.markIdle(inst.instanceId, false);
+    // Reset all workers to idle
+    const allWorkers = this.instanceManager.listAll();
+    for (const w of allWorkers) {
+      if (w.status === 'executing') {
+        this.instanceManager.markIdle(w.instanceId, false);
       }
     }
 
@@ -332,11 +321,11 @@ export class SwarmController {
   // Token/cost recording
   // -----------------------------------------------------------------------
 
-  recordTokenUsage(instanceId: string, _taskId: string, tokensUsed: number, cost: number): void {
-    // Update instance in InstanceManager
+  recordTokenUsage(workerId: string, _taskId: string, tokensUsed: number, cost: number): void {
+    // Update worker in InstanceManager
     try {
-      this.instanceManager.recordUsage(instanceId, tokensUsed, cost);
-    } catch { /* instance may not exist if stopped */ }
+      this.instanceManager.recordUsage(workerId, tokensUsed, cost);
+    } catch { /* worker may not exist if stopped */ }
 
     // Update session budgets
     this.state.budgets.session.usedTokens += tokensUsed;
@@ -355,7 +344,7 @@ export class SwarmController {
     this.eventLog.emit({
       type: 'budget-updated',
       timestamp: Date.now(),
-      data: { botId: instanceId, tokensUsed, cost },
+      data: { botId: workerId, tokensUsed, cost },
     });
   }
 
@@ -423,10 +412,10 @@ export class SwarmController {
         break;
       }
 
-      // Check instance-level steering
-      const allInstances = this.instanceManager.listAll();
-      for (const inst of allInstances) {
-        await this._checkSteering(inst.instanceId);
+      // Check worker-level steering
+      const allWorkers = this.instanceManager.listAll();
+      for (const w of allWorkers) {
+        await this._checkSteering(w.instanceId);
       }
 
       // Route unassigned tasks: top-level → orchestrator, subtasks → developer (fallback)
@@ -478,7 +467,7 @@ export class SwarmController {
 
       // Build orchestrator input
       const profiles = this.profileStore.list();
-      const instances = this.instanceManager.listAll();
+      const workers = this.instanceManager.listAll();
       const { workspace, session } = this.state.budgets;
 
       const budgetRemaining = {
@@ -502,11 +491,11 @@ export class SwarmController {
           },
         })),
         profiles,
-        instances,
+        instances: workers,
         budgetRemaining,
       };
 
-      // Route via orchestrator (node functions called directly to avoid circular import)
+      // Route via orchestrator
       const output = await this.orchestrator.route(input);
 
       // Log routing decisions to event log for dashboard visibility
@@ -518,20 +507,14 @@ export class SwarmController {
         });
       }
 
-      // Apply scale actions
-      for (const sa of output.scaleActions) {
-        const profile = profiles.find((p) => p.id === sa.profileId);
-        if (profile) {
-          this.instanceManager.scaleTo(profile, sa.targetInstances);
-        }
-      }
+      // No scale actions in pool model — pool size is fixed at maxConcurrent
 
       // Build file conflict map: which files are being modified by currently executing tasks
       const activeFiles = new Map<string, string>(); // filepath → taskId
-      for (const [instId] of this.executionPromises) {
-        const inst = this.instanceManager.listAll().find(i => i.instanceId === instId);
-        if (inst?.currentTaskId) {
-          const runningTask = await this.taskStore.get(inst.currentTaskId);
+      for (const [workerId] of this.executionPromises) {
+        const w = this.instanceManager.listAll().find(i => i.instanceId === workerId);
+        if (w?.currentTaskId) {
+          const runningTask = await this.taskStore.get(w.currentTaskId);
           if (runningTask?.context.files) {
             for (const f of runningTask.context.files) {
               activeFiles.set(f, runningTask.id);
@@ -564,9 +547,9 @@ export class SwarmController {
           // Assign task in TaskStore
           await this.taskStore.assignToInstance(assignment.taskId, assignment.instanceId, assignment.profileId);
 
-          // Mark instance as executing and store runId on task for live streaming
+          // Mark worker as executing with the task's profileId
           const runId = RunStore.newId();
-          this.instanceManager.markExecuting(assignment.instanceId, assignment.taskId, runId);
+          this.instanceManager.markExecuting(assignment.instanceId, assignment.taskId, runId, assignment.profileId);
           await this.taskStore.update(assignment.taskId, { currentRunId: runId });
 
           // Sync state for dashboard
@@ -581,10 +564,10 @@ export class SwarmController {
 
           // Spawn execution (non-blocking).
           // Track settlement so the cleanup loop can remove finished promises.
-          const instanceIdForClosure = assignment.instanceId;
+          const workerIdForClosure = assignment.instanceId;
           const execPromise = this._executeTask(assignment.instanceId, assignment.taskId, runId, bot, profile)
             .catch(() => { /* errors handled inside _executeTask */ })
-            .finally(() => { this.settledPromises.add(instanceIdForClosure); });
+            .finally(() => { this.settledPromises.add(workerIdForClosure); });
           this.executionPromises.set(assignment.instanceId, execPromise);
         } catch {
           // Assignment failed (task may have been grabbed by another cycle) — skip
@@ -605,10 +588,10 @@ export class SwarmController {
       // Clean up completed execution promises.
       // Use a status-tracking wrapper instead of Promise.race with an
       // immediately-resolved promise (which always returns 'pending').
-      for (const [instanceId] of this.executionPromises) {
-        if (this.settledPromises.has(instanceId)) {
-          this.executionPromises.delete(instanceId);
-          this.settledPromises.delete(instanceId);
+      for (const [workerId] of this.executionPromises) {
+        if (this.settledPromises.has(workerId)) {
+          this.executionPromises.delete(workerId);
+          this.settledPromises.delete(workerId);
         }
       }
 
@@ -634,7 +617,7 @@ export class SwarmController {
   // -----------------------------------------------------------------------
 
   private async _executeTask(
-    instanceId: string,
+    workerId: string,
     taskId: string,
     runId: string,
     bot: BotRegistration,
@@ -655,10 +638,15 @@ export class SwarmController {
       // Wrap in the JSON envelope that receive-task and downstream nodes expect.
       // autoApprove: true because the user consented by starting the swarm.
       const taskJson = JSON.stringify({
+        id: task.id,
+        parentId: task.parentId,
         instruction: prompt,
         mode: task.context.files.length > 0 ? 'modify' : 'create',
         targets: task.context.files.length > 0 ? task.context.files : undefined,
         options: { autoApprove: true },
+        attempt: task.attempt,
+        lastError: task.context.lastError,
+        runSummaries: task.context.runSummaries,
       });
 
       // Build behavior config from profile preferences, adjusted for task complexity.
@@ -683,7 +671,7 @@ export class SwarmController {
         runWorkflow(workflowPath, {
           runId,
           taskId,
-          botId: instanceId,
+          botId: workerId,
           config: { provider: 'auto' },
           params: { taskJson, projectDir: this.projectDir, behaviorJson },
           eventLog: runEventLog,
@@ -708,9 +696,10 @@ export class SwarmController {
 
     const runSummary: RunSummary = {
       runId,
-      botId: instanceId,
+      botId: workerId,
       outcome: result.success ? 'success' : 'failed',
       summary: result.summary || (result.success ? 'Completed' : 'Failed'),
+      report: result.report,
       filesModified: [],
       error: result.success ? undefined : (result.summary || 'Unknown error'),
       durationMs,
@@ -723,7 +712,7 @@ export class SwarmController {
     await this.taskStore.release(taskId, releaseStatus, runSummary);
 
     // Record token usage
-    this.recordTokenUsage(instanceId, taskId, tokensUsed, costUsed);
+    this.recordTokenUsage(workerId, taskId, tokensUsed, costUsed);
 
     // Update stats
     if (result.success) {
@@ -732,16 +721,16 @@ export class SwarmController {
       this.state.tasksFailed += 1;
     }
 
-    // Mark instance as idle
+    // Mark worker as idle (clears profile association)
     try {
-      this.instanceManager.markIdle(instanceId, result.success);
-    } catch { /* instance may have been stopped */ }
+      this.instanceManager.markIdle(workerId, result.success);
+    } catch { /* worker may have been stopped */ }
 
     // Emit swarm-level task event
     this.eventLog.emit({
       type: result.success ? 'task-done' : 'task-failed',
       timestamp: Date.now(),
-      data: { botId: instanceId, taskId, outcome: runSummary.outcome },
+      data: { botId: workerId, taskId, outcome: runSummary.outcome },
     });
 
     // Emit hierarchy-scoped event so sibling tasks can see what happened
@@ -755,7 +744,7 @@ export class SwarmController {
           data: {
             summary: runSummary.summary,
             filesModified: runSummary.filesModified,
-            botId: instanceId,
+            botId: workerId,
             attempt: task.attempt,
           },
         });
@@ -802,8 +791,8 @@ export class SwarmController {
   // Steering
   // -----------------------------------------------------------------------
 
-  private async _checkSteering(instanceId: string): Promise<void> {
-    const steerPath = path.join(this.weaverDir, `steer-${instanceId}.json`);
+  private async _checkSteering(workerId: string): Promise<void> {
+    const steerPath = path.join(this.weaverDir, `steer-${workerId}.json`);
     try {
       if (!fs.existsSync(steerPath)) return;
       const raw = fs.readFileSync(steerPath, 'utf-8');
@@ -812,28 +801,28 @@ export class SwarmController {
 
       switch (command.command) {
         case 'pause':
-          this.eventLog.emit({ type: 'bot-paused', timestamp: Date.now(), data: { botId: instanceId } });
+          this.eventLog.emit({ type: 'bot-paused', timestamp: Date.now(), data: { botId: workerId } });
           break;
         case 'resume':
           break;
         case 'cancel':
-          this.instanceManager.stop(instanceId);
+          this.instanceManager.stop(workerId);
           break;
       }
     } catch { /* steer file read error — skip */ }
   }
 
   // -----------------------------------------------------------------------
-  // State sync — instances field
+  // State sync — instances field (workers mapped to instances for API compat)
   // -----------------------------------------------------------------------
 
   private _syncInstancesState(): void {
-    const allInstances = this.instanceManager.listAll();
+    const allWorkers = this.instanceManager.listAll();
 
-    // Build instances record
+    // Build instances record from worker pool
     this.state.instances = {};
-    for (const inst of allInstances) {
-      this.state.instances[inst.instanceId] = inst;
+    for (const w of allWorkers) {
+      this.state.instances[w.instanceId] = w;
     }
   }
 

package/src/bot/system-prompt.ts

@@ -208,6 +208,8 @@ USE TOOLS to complete tasks. Do NOT describe what you would do — actually do i
 
 ### Knowledge tools
 - learn(key, value), recall(query)
+- When you discover project facts (test runner, build tool, conventions, common patterns), use learn() to persist them for future runs
+- Previous knowledge is auto-loaded into your context — avoid re-discovering what's already known
 
 ### Web & interaction tools
 - web_fetch(url), ask_user(question)

package/src/bot/task-types.ts

@@ -8,6 +8,7 @@ export interface RunSummary {
   botId: string;
   outcome: 'success' | 'failed' | 'error';
   summary: string;
+  report?: string;
   filesModified: string[];
   error?: string;
   durationMs: number;

package/src/bot/weaver-tools.ts

@@ -30,9 +30,15 @@ const OPERATION_MAP: Record<string, string> = {
  */
 export function createWeaverExecutor(projectDir: string) {
   return async (
-    name: string,
+    rawName: string,
     args: Record<string, unknown>,
   ): Promise<{ result: string; isError: boolean }> => {
+    // Strip MCP server prefix from tool names.
+    // The Claude CLI registers MCP tools as `mcp__<server>__<tool>` and the
+    // API streams back tool_use events with the prefixed name. The agent loop
+    // passes this name to the executor, but our switch cases use unprefixed names.
+    const name = rawName.replace(/^mcp__[a-zA-Z0-9_-]+__/, '');
+
     // Handle new tools that bypass step-executor
     switch (name) {
       case 'web_fetch': {
@@ -179,6 +185,13 @@ export function createWeaverExecutor(projectDir: string) {
         break;
     }
 
+    // Ignore Claude Code built-in tools that leak through when disallowed list is incomplete.
+    // These are no-ops — the bot should use the MCP bridge tools instead.
+    const IGNORED_BUILTINS = new Set(['TodoWrite', 'TodoRead', 'Agent', 'WebFetch', 'WebSearch', 'MultiTool', 'Skill']);
+    if (IGNORED_BUILTINS.has(name) || IGNORED_BUILTINS.has(rawName)) {
+      return { result: `Tool "${name}" is not available. Use the provided tools instead.`, isError: true };
+    }
+
     // Existing step-executor-based tools
     const operation = OPERATION_MAP[name];
     if (!operation) {

package/src/node-types/agent-execute.ts

@@ -153,8 +153,8 @@ export async function weaverAgentExecute(
   }
 
   const taskPrompt = task.instruction.startsWith('## Task:')
-    ? `${task.instruction}\n\nProject directory: ${projectDir}`
-    : `Task: ${task.instruction}\nProject directory: ${projectDir}\n${task.targets ? 'Target files: ' + task.targets.join(', ') : ''}`;
+    ? `${task.instruction}`
+    : `Task: ${task.instruction}\n${task.targets ? 'Target files: ' + task.targets.join(', ') : ''}`;
 
   // Create renderer — single source of all terminal output
   const { TerminalRenderer } = await import('../bot/terminal-renderer.js');

package/src/node-types/bot-report.ts

@@ -27,7 +27,10 @@ export async function weaverBotReport(
   abortCtx?: string,
   failCtx?: string,
 ): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string; report: string; reportJson: string }> {
-  const ctxStr = mainCtx ?? readCtx ?? abortCtx ?? failCtx;
+  // Pick the first ctx with meaningful content (not just '{}').
+  // An empty merge result '{}' must not shadow a real ctx from failCtx/abortCtx.
+  const candidates = [mainCtx, readCtx, abortCtx, failCtx];
+  const ctxStr = candidates.find(c => c != null && c !== '{}' && c.length > 2) ?? candidates.find(c => c != null);
 
   if (!execute) {
     const reportObj = { task: {}, path: 'unknown', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
@@ -96,7 +99,7 @@ export async function weaverBotReport(
     } catch { /* ignore parse errors */ }
   }
 
-  const success = result?.success !== false && pathName !== 'abort' && reviewPassed;
+  const success = result?.success !== false && pathName !== 'abort' && pathName !== 'failed' && context.allValid !== false && reviewPassed;
 
   if (result) {
     parts.push(`Outcome: ${result.outcome ?? (success ? 'completed' : 'failed')}`);

package/src/node-types/build-context.ts

@@ -45,6 +45,17 @@ export function weaverBuildContext(ctx: string): { ctx: string } {
     }
   } catch { /* non-fatal — memory is best-effort */ }
 
+  // Auto-recall learned knowledge from previous bot runs
+  try {
+    const { KnowledgeStore } = require('../bot/knowledge-store.js') as typeof import('../bot/knowledge-store.js');
+    const knowledge = new KnowledgeStore(projectDir);
+    const entries = knowledge.list();
+    if (entries.length > 0) {
+      const knowledgeLines = entries.map((e: { key: string; value: string }) => `- **${e.key}**: ${e.value}`);
+      sections.push(`## Learned Knowledge\n\nFacts discovered by previous runs — use these instead of re-discovering:\n${knowledgeLines.join('\n')}`);
+    }
+  } catch { /* non-fatal — knowledge recall is best-effort */ }
+
   // Include sibling context from hierarchy events (previous task completions in same hierarchy)
   try {
     const parsedTask = JSON.parse(context.taskJson!) as { parentId?: string };
@@ -92,10 +103,11 @@ function buildModifyContext(projectDir: string, targets: string[]): string[] {
   const includedFiles = new Set<string>();
   for (const target of targets) {
     const filePath = path.isAbsolute(target) ? target : path.resolve(projectDir, target);
+    const displayTarget = path.isAbsolute(target) ? path.relative(projectDir, target) : target;
     try {
       if (!fs.existsSync(filePath)) continue;
       const source = fs.readFileSync(filePath, 'utf-8');
-      sections.push(`## Target: ${target}\n\n\`\`\`typescript\n${source}\n\`\`\``);
+      sections.push(`## Target: ${displayTarget}\n\n\`\`\`typescript\n${source}\n\`\`\``);
       includedFiles.add(filePath);
 
       // Extract import paths to find referenced node type files