@synergenius/flow-weaver-pack-weaver 0.9.62 → 0.9.78

package/src/bot/task-prompt-builder.ts

@@ -18,6 +18,7 @@
  */
 
 import type { Task, RunSummary } from './task-types.js';
+import type { ProfilePreferences } from './profile-types.js';
 
 const MAX_CONTEXT_TOKENS = 4000;
 const CHARS_PER_TOKEN = 4; // rough estimate
@@ -28,16 +29,17 @@ export function buildTaskPrompt(
   task: Task,
   parentTask?: Task | null,
   siblingTasks?: Task[],
+  preferences?: ProfilePreferences,
 ): string {
   // Build the full (un-truncated) prompt first
-  const prompt = buildFull(task, parentTask, siblingTasks);
+  const prompt = buildFull(task, parentTask, siblingTasks, preferences);
 
   if (prompt.length <= MAX_CONTEXT_CHARS) {
     return prompt;
   }
 
   // Over budget — apply truncation cascade progressively
-  return truncatePrompt(task, parentTask, siblingTasks);
+  return truncatePrompt(task, parentTask, siblingTasks, preferences);
 }
 
 // ---------------------------------------------------------------------------
@@ -48,6 +50,7 @@ function buildFull(
   task: Task,
   parentTask?: Task | null,
   siblingTasks?: Task[],
+  preferences?: ProfilePreferences,
 ): string {
   const sections: string[] = [];
 
@@ -88,6 +91,11 @@ function buildFull(
     sections.push(`### Last Error\n${task.context.lastError}`);
   }
 
+  // Execution preferences
+  if (preferences) {
+    sections.push(buildPreferencesSection(preferences));
+  }
+
   // Parent context
   if (parentTask) {
     sections.push(buildParentSection(parentTask, siblingTasks));
@@ -104,6 +112,7 @@ function truncatePrompt(
   task: Task,
   parentTask?: Task | null,
   siblingTasks?: Task[],
+  preferences?: ProfilePreferences,
 ): string {
   // Level 1: All summaries condensed to one-liners
   let result = buildWithTruncation(task, parentTask, siblingTasks, {
@@ -111,7 +120,7 @@ function truncatePrompt(
     filesFromRecentRunsOnly: false,
     parentTitleOnly: false,
     notesCapped: false,
-  });
+  }, preferences);
   if (result.length <= MAX_CONTEXT_CHARS) return result;
 
   // Level 2: File list → only files from last 2 runs
@@ -120,7 +129,7 @@ function truncatePrompt(
     filesFromRecentRunsOnly: true,
     parentTitleOnly: false,
     notesCapped: false,
-  });
+  }, preferences);
   if (result.length <= MAX_CONTEXT_CHARS) return result;
 
   // Level 3: Parent context → title only
@@ -129,7 +138,7 @@ function truncatePrompt(
     filesFromRecentRunsOnly: true,
     parentTitleOnly: true,
     notesCapped: false,
-  });
+  }, preferences);
   if (result.length <= MAX_CONTEXT_CHARS) return result;
 
   // Level 4: Notes → first 500 chars
@@ -138,7 +147,7 @@ function truncatePrompt(
     filesFromRecentRunsOnly: true,
     parentTitleOnly: true,
     notesCapped: true,
-  });
+  }, preferences);
 
   // Hard-truncate if still over (shouldn't happen with reasonable data)
   if (result.length > MAX_CONTEXT_CHARS) {
@@ -160,6 +169,7 @@ function buildWithTruncation(
   parentTask: Task | null | undefined,
   siblingTasks: Task[] | undefined,
   flags: TruncationFlags,
+  preferences?: ProfilePreferences,
 ): string {
   const sections: string[] = [];
 
@@ -215,6 +225,11 @@ function buildWithTruncation(
     sections.push(`### Last Error\n${errorText}`);
   }
 
+  // Execution preferences
+  if (preferences) {
+    sections.push(buildPreferencesSection(preferences));
+  }
+
   // Parent context
   if (parentTask) {
     if (flags.parentTitleOnly) {
@@ -264,6 +279,22 @@ function buildParentSection(
   return section;
 }
 
+function buildPreferencesSection(preferences: ProfilePreferences): string {
+  const lines = ['## Execution Preferences'];
+  lines.push(`Cost strategy: ${preferences.costStrategy}`);
+  if (preferences.maxCostPerRun !== undefined) {
+    lines.push(`Max cost per run: $${preferences.maxCostPerRun.toFixed(2)}`);
+  }
+  if (preferences.maxCostPerTask !== undefined) {
+    lines.push(`Max cost per task: $${preferences.maxCostPerTask.toFixed(2)}`);
+  }
+  if (preferences.instructions) {
+    lines.push(`Instructions: ${preferences.instructions}`);
+  }
+  lines.push(`Approval required: ${preferences.requireApproval ? 'yes' : 'no'}`);
+  return lines.join('\n');
+}
+
 function statusIcon(status: string): string {
   switch (status) {
     case 'done':

package/src/bot/task-store.ts

@@ -2,7 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as crypto from 'node:crypto';
 import { AsyncMutex } from './async-mutex.js';
-import type { Task, TaskFilter, CreateTaskInput, RunSummary, TaskStatus } from './task-types.js';
+import type { Task, TaskFilter, CreateTaskInput, RunSummary } from './task-types.js';
 
 /** Don't re-queue tasks completed/failed within this window (ms). */
 const DEDUP_WINDOW_MS = 3_600_000; // 1 hour
@@ -43,8 +43,8 @@ export class TaskStore {
           isParent: true,
           parentId: input.parentId,
           dependsOn: input.dependsOn ?? [],
-          assignedBots: input.assignedBots ?? [],
           currentBotId: undefined,
+        currentRunId: undefined,
           context: { files: [], notes: '', runSummaries: [] },
           runs: [],
           attempt: 0,
@@ -54,6 +54,8 @@ export class TaskStore {
           tokensUsed: 0,
           costUsed: 0,
           timeoutMs: input.timeoutMs,
+          complexity: input.complexity,
+          assignedProfile: input.assignedProfile,
           createdBy: input.createdBy ?? 'user',
           createdAt: now,
           updatedAt: now,
@@ -80,8 +82,8 @@ export class TaskStore {
             isParent: false,
             parentId: parentId,
             dependsOn: resolvedDeps,
-            assignedBots: sub.assignedBots ?? input.assignedBots ?? [],
             currentBotId: undefined,
+        currentRunId: undefined,
             context: { files: [], notes: '', runSummaries: [] },
             runs: [],
             attempt: 0,
@@ -90,6 +92,8 @@ export class TaskStore {
             budgetCost: input.budgetCost,
             tokensUsed: 0,
             costUsed: 0,
+            complexity: sub.complexity ?? input.complexity,
+            assignedProfile: sub.assignedProfile ?? input.assignedProfile,
             createdBy: input.createdBy ?? 'user',
             createdAt: now,
             updatedAt: now,
@@ -116,8 +120,8 @@ export class TaskStore {
         isParent: false,
         parentId: input.parentId,
         dependsOn: input.dependsOn ?? [],
-        assignedBots: input.assignedBots ?? [],
         currentBotId: undefined,
+        currentRunId: undefined,
         context: { files: [], notes: '', runSummaries: [] },
         runs: [],
         attempt: 0,
@@ -127,6 +131,8 @@ export class TaskStore {
         tokensUsed: 0,
         costUsed: 0,
         timeoutMs: input.timeoutMs,
+        complexity: input.complexity,
+        assignedProfile: input.assignedProfile,
         createdBy: input.createdBy ?? 'user',
         createdAt: now,
         updatedAt: now,
@@ -159,11 +165,6 @@ export class TaskStore {
         if (filter.botId !== undefined) {
           tasks = tasks.filter(t => t.currentBotId === filter.botId);
         }
-        if (filter.assignedBots !== undefined && filter.assignedBots.length > 0) {
-          tasks = tasks.filter(t =>
-            t.assignedBots.length === 0 || t.assignedBots.some(b => filter.assignedBots!.includes(b)),
-          );
-        }
         if (filter.limit !== undefined && filter.limit > 0) {
           tasks = tasks.slice(0, filter.limit);
         }
@@ -221,57 +222,31 @@ export class TaskStore {
   }
 
   // ---------------------------------------------------------------------------
-  // Atomic claim
+  // Push-based assignment (orchestrator)
   // ---------------------------------------------------------------------------
 
-  async claimNext(botId: string): Promise<Task | null> {
+  async assignToInstance(taskId: string, instanceId: string, profileId: string): Promise<Task> {
     return this.mutex.runExclusive(async () => {
       const tasks = this._readAll();
+      const idx = tasks.findIndex(t => t.id === taskId);
+      if (idx === -1) throw new Error(`Task not found: ${taskId}`);
 
-      // Build a set of done task IDs for dependency checks
-      const doneIds = new Set(tasks.filter(t => t.status === 'done').map(t => t.id));
-
-      // Find eligible tasks
-      const eligible = tasks.filter(t => {
-        // Must be pending, or failed with retries left
-        if (t.status === 'pending') { /* ok */ }
-        else if (t.status === 'failed' && t.attempt < t.maxAttempts) { /* ok */ }
-        else return false;
-
-        // Skip parent tasks
-        if (t.isParent) return false;
-
-        // Check assigned bots
-        if (t.assignedBots.length > 0 && !t.assignedBots.includes(botId)) return false;
-
-        // Check dependencies — all must be done
-        if (t.dependsOn.length > 0 && !t.dependsOn.every(depId => doneIds.has(depId))) return false;
-
-        // Check per-task budget (tokens)
-        if (t.budgetTokens !== undefined && t.tokensUsed >= t.budgetTokens) return false;
-
-        // Check per-task budget (cost)
-        if (t.budgetCost !== undefined && t.costUsed >= t.budgetCost) return false;
-
-        return true;
-      });
-
-      if (eligible.length === 0) return null;
-
-      // Sort: higher priority first, then older createdAt first
-      eligible.sort((a, b) =>
-        b.priority - a.priority || Date.parse(a.createdAt) - Date.parse(b.createdAt),
-      );
-
-      const target = eligible[0];
-      const idx = tasks.findIndex(t => t.id === target.id);
+      const task = tasks[idx];
+      const assignable =
+        task.status === 'pending' ||
+        (task.status === 'failed' && task.attempt < task.maxAttempts);
+      if (!assignable) {
+        throw new Error(`Task ${taskId} is not assignable (status: ${task.status}, attempt: ${task.attempt}/${task.maxAttempts})`);
+      }
 
-      tasks[idx].status = 'in-progress';
-      tasks[idx].currentBotId = botId;
-      tasks[idx].updatedAt = new Date().toISOString();
+      task.status = 'in-progress';
+      task.currentBotId = instanceId;
+      task.assignedProfile = profileId;
+      task.updatedAt = new Date().toISOString();
 
+      tasks[idx] = task;
       this._writeAll(tasks);
-      return tasks[idx];
+      return task;
     });
   }
 
@@ -303,6 +278,7 @@ export class TaskStore {
       task.attempt += 1;
       task.status = status;
       task.currentBotId = undefined;
+      task.currentRunId = undefined;
       task.updatedAt = new Date().toISOString();
 
       if (status === 'done') {
@@ -408,43 +384,6 @@ export class TaskStore {
     return null;
   }
 
-  // ---------------------------------------------------------------------------
-  // Legacy migration
-  // ---------------------------------------------------------------------------
-
-  /**
-   * Migrate legacy TaskQueue entries to Task entities.
-   * Called once on first load. Renames legacy files after migration.
-   */
-  async migrate(): Promise<void> {
-    const legacyQueuePath = path.join(this.projectDir, '.weaver', 'task-queue.ndjson');
-    const legacySessionPath = path.join(this.projectDir, '.weaver', 'session.json');
-
-    // Migrate task queue
-    if (fs.existsSync(legacyQueuePath)) {
-      const lines = fs.readFileSync(legacyQueuePath, 'utf-8').split('\n').filter(Boolean);
-      for (const line of lines) {
-        try {
-          const entry = JSON.parse(line);
-          if (entry.status === 'pending') {
-            await this.create({
-              title: entry.instruction,
-              description: entry.instruction,
-              priority: entry.priority ?? 0,
-              createdBy: 'user',
-            });
-          }
-        } catch { /* skip corrupt lines */ }
-      }
-      fs.renameSync(legacyQueuePath, legacyQueuePath + '.migrated');
-    }
-
-    // Discard legacy session
-    if (fs.existsSync(legacySessionPath)) {
-      fs.renameSync(legacySessionPath, legacySessionPath + '.migrated');
-    }
-  }
-
   // ---------------------------------------------------------------------------
   // File I/O — atomic write via temp + rename
   // ---------------------------------------------------------------------------

package/src/bot/task-types.ts

@@ -37,8 +37,8 @@ export interface Task {
   dependsOn: string[];
 
   // Assignment
-  assignedBots: string[];
   currentBotId?: string;
+  currentRunId?: string;
 
   // Context
   context: TaskContext;
@@ -57,6 +57,11 @@ export interface Task {
   // Timeout
   timeoutMs?: number;
 
+  // Orchestrator routing
+  assignedProfile?: string;                    // profile ID assigned by orchestrator
+  routingReason?: string;                      // why this profile was chosen
+  complexity?: 'trivial' | 'simple' | 'moderate' | 'complex';  // task complexity estimate
+
   // Metadata
   createdBy: 'user' | 'ai';
   createdAt: string;
@@ -68,14 +73,12 @@ export interface TaskFilter {
   status?: TaskStatus | TaskStatus[];
   parentId?: string;
   botId?: string;
-  assignedBots?: string[];
   limit?: number;
 }
 
 export interface CreateTaskInput {
   title: string;
   description: string;
-  assignedBots?: string[];
   priority?: number;
   parentId?: string;
   dependsOn?: string[];
@@ -84,11 +87,14 @@ export interface CreateTaskInput {
   timeoutMs?: number;
   maxAttempts?: number;
   createdBy?: 'user' | 'ai';
+  complexity?: 'trivial' | 'simple' | 'moderate' | 'complex';
+  assignedProfile?: string;
   subtasks?: Array<{
     title: string;
     description?: string;
-    assignedBots?: string[];
     dependsOn?: string[];
     priority?: number;
+    complexity?: 'trivial' | 'simple' | 'moderate' | 'complex';
+    assignedProfile?: string;
   }>;
 }

package/src/cli-handlers.ts

@@ -1447,11 +1447,10 @@ export async function handleSession(opts: ParsedArgs): Promise<void> {
   const filesInUse = new Set<string>();
 
   const processTask = async (task: { id: string; title: string; description: string; context: { files: string[] } }) => {
-    // Map to legacy format for workflow runner
-    const legacyTask = { id: task.id, instruction: task.title, targets: task.context.files };
+    const taskPayload = { id: task.id, instruction: task.title, description: task.description, targets: task.context.files };
     try {
       const result = await runWorkflow(workflowPath, {
-        params: { projectDir, taskJson: JSON.stringify(legacyTask) },
+        params: { projectDir, taskJson: JSON.stringify(taskPayload) },
         verbose: opts.verbose,
         dryRun: opts.dryRun,
         config,

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

@@ -1,34 +1,51 @@
-## Weaver Bot
+## Weaver Bot (Swarm)
 
-The Weaver bot is an autonomous AI agent that creates and modifies Flow Weaver workflows from natural language instructions.
+The Weaver bot is an autonomous AI agent that creates and modifies Flow Weaver workflows. Tasks are executed via the swarm orchestrator, which routes work to the best available bot profile.
 
-### Running the bot
+### Running tasks
 
-Use `fw_weaver_bot` with a task description:
-- `task`: Natural language instruction (required)
-- `mode`: `create` (new workflow), `modify` (edit existing), `read` (analyze), `batch` (multiple tasks)
-- `targets`: File paths for modify/read mode
-- `autoApprove`: Skip the approval gate (default: true in studio)
+Use `fw_weaver_task_create` to submit work:
+- `title`: Short task title (required)
+- `description`: Detailed instructions
+- `assignedProfile`: Target a specific bot profile
+- `complexity`: trivial, simple, moderate, complex
+- `subtasks`: Inline subtask definitions with dependency chaining
+
+Then start the swarm with `fw_weaver_swarm_start` to begin execution.
 
 ### Execution flow
 
-1. **Receive task** — parses instruction and determines mode
-2. **Build context** — gathers project state, templates, and relevant files
-3. **Plan** — AI generates a step-by-step execution plan
-4. **Approval gate** — plan shown for review (skipped if autoApprove)
-5. **Execute + validate + retry** — runs steps, validates output, retries on errors (up to 3 attempts)
+1. **Create task** — `fw_weaver_task_create` adds task to the pool
+2. **Orchestrator routes** — matches task to best bot profile via fast-path cascade (exact-match, capability-match, single-eligible, ai-routed, round-robin)
+3. **Build context** — gathers project state, templates, and relevant files
+4. **Plan** — AI generates a step-by-step execution plan
+5. **Execute + validate + retry** — runs steps, validates output, retries on errors (up to maxAttempts)
 6. **Git ops** — commits changes if successful
-7. **Report** — returns summary with outcome
+7. **Report** — task marked done/failed with run summary
 
 ### Steering a running bot
 
-Use `fw_weaver_steer` to control execution:
+Use `fw_weaver_steer` with a `botId` to control execution:
 - `pause` — pause at next safe point
 - `resume` — continue after pause
 - `cancel` — abort execution
-- `redirect` — change task mid-execution
-- `queue` — add a follow-up task
 
 ### Checking status
 
-Use `fw_weaver_status` to see the current bot session state, active task, and completion count.
+- `fw_weaver_status` — quick swarm summary (active bots, tasks completed, budget)
+- `fw_weaver_swarm_status` — full swarm state with per-instance details
+- `fw_weaver_swarm_events` — live event stream
+- `fw_weaver_orchestrator_status` — routing decisions, stats, active instances
+
+### Profiles
+
+Use `fw_weaver_profile_create` to create specialized bot profiles. Each profile defines:
+
+- **capabilities** — free-form list of `{ name, description }` objects describing what the profile can do. Names are arbitrary strings (e.g. `code-generation`, `testing`, `deployment`). The orchestrator uses the description text to match tasks to profiles.
+- **preferences** — intent-based settings that control profile behavior:
+  - `costStrategy` — `"economy"` (minimize cost), `"balanced"` (default), or `"quality"` (maximize quality regardless of cost)
+  - `requireApproval` — whether tasks routed to this profile need human approval before execution
+  - `instructions` — optional free-text instructions appended to the bot's system prompt
+- **scaling** — `minInstances` and `maxInstances` control how many concurrent bots can run this profile
+
+The orchestrator routes tasks to profiles based on `assignedProfile` or by matching task intent against profile capabilities.

package/src/docs/weaver-config.md

@@ -4,6 +4,17 @@ The weaver bot runs workflows, executes tasks from natural language, and evolves
 
 The bot has deep knowledge of the full flow-weaver ecosystem: annotation grammar, CLI tools, node patterns, error diagnosis, and the genesis protocol (loaded dynamically from `@synergenius/flow-weaver/doc-metadata`).
 
+## Execution models
+
+Weaver supports two execution models:
+
+- **Single-run mode** — execute one workflow or natural-language task end-to-end via `flow-weaver weaver run` or `flow-weaver weaver bot`. Good for one-off tasks, CI pipelines, and simple automations.
+- **Swarm/task model** — create tasks, define bot profiles with capabilities, and let the orchestrator route work to the best available bot instance. Multiple bots can run concurrently with budget controls and automatic retries.
+
+The `.weaver.json` config applies to both models. Provider settings, approval gates, and notifications are shared. Swarm-specific settings (profiles, budgets, concurrency) are managed through the swarm control tools or the Studio UI.
+
+> See [weaver-bot-usage.md](weaver-bot-usage.md) for full swarm documentation including profiles, orchestrator routing, and multi-bot workflows.
+
 ## Getting started
 
 Run the bot directly via CLI:
@@ -16,6 +27,15 @@ flow-weaver weaver session
 
 Or scaffold a project via `flow-weaver init` and select the "AI Workflow Runner" use case.
 
+## Profiles and .weaver.json
+
+Bot profiles define specialized bot types with free-form capabilities, intent-based preferences, and scaling limits. Profiles are created via `fw_weaver_profile_create` and stored in the `.weaver/` directory. The `.weaver.json` config provides the base provider and approval settings that profiles inherit unless overridden.
+
+Each profile specifies:
+- **capabilities** — an array of `{ name, description }` objects. Names are free-form strings (e.g. `code-generation`, `testing`, `deployment`). The orchestrator uses descriptions to match tasks to profiles.
+- **preferences** — intent-based settings: `costStrategy` (`economy`, `balanced`, `quality`), `requireApproval` (boolean), and optional `instructions` (free-text appended to the bot system prompt).
+- **scaling** — `minInstances` / `maxInstances` for concurrency control.
+
 ## .weaver.json
 
 Place a `.weaver.json` in your project root to configure the weaver workflow:

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

@@ -1,34 +1,46 @@
-## Task Queue & Steering
+## Task Management & Steering
 
-Weaver supports queuing tasks for background processing and steering running bots in real-time.
+Weaver uses a swarm-based task system for background processing and real-time bot control.
 
-### Task queue
+### Creating tasks
 
-Use `fw_weaver_queue` to manage tasks:
-- `add` — add a task to the queue (requires `task` instruction)
-- `list` — show all queued tasks
-- `clear` — remove all pending tasks
-- `remove` — remove a specific task by ID
+Use `fw_weaver_task_create` to create tasks:
+- `title` — short task title (required)
+- `description` — detailed instructions
+- `priority` — higher number = picked first (default 0)
+- `assignedProfile` — route to a specific bot profile
+- `complexity` — trivial, simple, moderate, complex
+- `subtasks` — inline subtask definitions with `^prev` dependency shorthand
+- `budgetTokens` / `budgetCost` — per-task budget limits
 
-Tasks are stored in NDJSON format and processed sequentially by the bot session.
+### Listing and managing tasks
+
+- `fw_weaver_task_list` — list tasks (filter by status, parentId, botId)
+- `fw_weaver_task_get` — get task details including subtasks
+- `fw_weaver_task_update` — update task fields
+- `fw_weaver_task_cancel` — cancel a pending or running task
+- `fw_weaver_task_retry` — reset a failed task back to pending
 
 ### Steering commands
 
-Use `fw_weaver_steer` to control a running bot:
+Use `fw_weaver_steer` to control a running bot instance:
 - `pause` — pause execution at the next safe point
 - `resume` — continue after a pause
 - `cancel` — abort the current task
-- `redirect` — change the task instruction mid-execution (requires `payload` with new instruction)
-- `queue` — add a follow-up task without interrupting the current one
 
-### Batch mode
+### Swarm control
 
-For multiple related tasks, use `fw_weaver_bot` with `mode: "batch"` to process them in sequence through the same bot session, sharing context between tasks.
+- `fw_weaver_swarm_start` — start the swarm (spawns bot loops that claim and execute tasks)
+- `fw_weaver_swarm_pause` — pause all bot loops
+- `fw_weaver_swarm_stop` — stop the swarm gracefully
+- `fw_weaver_swarm_status` — full swarm state with per-bot details
+- `fw_weaver_swarm_config` — configure max concurrency, budgets, auto-retry
+- `fw_weaver_swarm_events` — stream swarm-level events for live updates
 
 ### Monitoring
 
-Use `fw_weaver_status` to check the current session state:
-- Session phase (idle, planning, executing, validating)
-- Current task instruction
-- Completed task count
-- Error state if any
+Use `fw_weaver_status` to check the current swarm state:
+- Swarm phase (idle, running, paused, stopping)
+- Active/total bot instances
+- Tasks completed/failed
+- Budget usage