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

package/src/cli-handlers.ts

@@ -1374,9 +1374,15 @@ export async function handleSession(opts: ParsedArgs): Promise<void> {
 
   // Crash recovery
   if (continuous) {
-    const { TaskQueue } = await import('./bot/task-queue.js');
-    const recoveryQueue = new TaskQueue();
-    const recovered = await recoveryQueue.recoverOrphans();
+    const { TaskStore } = await import('./bot/task-store.js');
+    const recoveryStore = new TaskStore(projectDir);
+    // Recover orphaned in-progress tasks back to pending
+    const inProgressTasks = await recoveryStore.list({ status: 'in-progress' });
+    let recovered = 0;
+    for (const t of inProgressTasks) {
+      await recoveryStore.update(t.id, { status: 'pending' });
+      recovered++;
+    }
     if (recovered > 0) renderer.info(`Recovered ${recovered} orphaned task(s)`);
   }
 
@@ -1419,9 +1425,9 @@ export async function handleSession(opts: ParsedArgs): Promise<void> {
   }
 
   // Continuous mode: loop until deadline/maxTasks/interrupt
-  const { TaskQueue } = await import('./bot/task-queue.js');
+  const { TaskStore } = await import('./bot/task-store.js');
   const { isTransientError, getErrorGuidance } = await import('./bot/error-classifier.js');
-  const queue = new TaskQueue();
+  const taskStore = new TaskStore(projectDir);
   let taskCount = 0;
   let interrupted = false;
   let consecutiveErrors = 0;
@@ -1440,10 +1446,11 @@ export async function handleSession(opts: ParsedArgs): Promise<void> {
   const running = new Map<string, Promise<void>>();
   const filesInUse = new Set<string>();
 
-  const processTask = async (task: { id: string; instruction?: string; targets?: string[] }) => {
+  const processTask = async (task: { id: string; title: string; description: string; context: { files: string[] } }) => {
+    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(task) },
+        params: { projectDir, taskJson: JSON.stringify(taskPayload) },
         verbose: opts.verbose,
         dryRun: opts.dryRun,
         config,
@@ -1460,17 +1467,17 @@ export async function handleSession(opts: ParsedArgs): Promise<void> {
       );
 
       if (isNoOp) {
-        await queue.markNoOp(task.id);
+        await taskStore.update(task.id, { status: 'done' });
         sessionNoOp++;
         consecutiveNoOps++;
         consecutiveErrors = 0;
       } else if (result.success) {
-        await queue.markComplete(task.id);
+        await taskStore.update(task.id, { status: 'done' });
         sessionCompleted++;
         consecutiveErrors = 0;
         consecutiveNoOps = 0;
       } else {
-        await queue.markFailed(task.id, result.summary || result.outcome || 'unknown error');
+        await taskStore.update(task.id, { status: 'failed' });
         sessionFailed++;
         consecutiveErrors++;
         consecutiveNoOps = 0;
@@ -1487,13 +1494,13 @@ export async function handleSession(opts: ParsedArgs): Promise<void> {
       const msg = err instanceof Error ? err.message : String(err);
       const guidance = getErrorGuidance(msg);
       renderer.error(`Task ${task.id.slice(0, 8)} error`, guidance ? `${msg}\n  Hint: ${guidance}` : msg);
-      await queue.markFailed(task.id, msg);
+      await taskStore.update(task.id, { status: 'failed' });
       sessionFailed++;
       if (!isTransientError(err)) {
         consecutiveErrors++;
       }
     } finally {
-      for (const f of task.targets ?? []) filesInUse.delete(f);
+      for (const f of task.context.files) filesInUse.delete(f);
       running.delete(task.id);
     }
   };
@@ -1522,7 +1529,8 @@ export async function handleSession(opts: ParsedArgs): Promise<void> {
       continue;
     }
 
-    const task = await queue.next();
+    const pendingTasks = await taskStore.list({ status: 'pending', limit: 1 });
+    const task = pendingTasks[0] ?? null;
     if (!task) {
       if (running.size > 0) {
         // Tasks still running — wait for one to finish
@@ -1536,22 +1544,26 @@ export async function handleSession(opts: ParsedArgs): Promise<void> {
 
     // Auto-decompose broad tasks into per-file tasks
     const { decomposeTask } = await import('./bot/task-decomposer.js');
-    const { decomposed, tasks: subtasks } = decomposeTask(task, projectDir);
+    const decomposable = { id: task.id, instruction: task.title, targets: task.context.files, priority: task.priority };
+    const { decomposed, tasks: subtasks } = decomposeTask(decomposable, projectDir);
     if (decomposed && subtasks.length > 1) {
       // Replace the broad task with per-file tasks
-      await queue.markComplete(task.id);
-      let decomposedCount = 0;
+      await taskStore.update(task.id, { status: 'done' });
       for (const st of subtasks) {
-        const { duplicate } = await queue.add({ instruction: st.instruction, mode: st.mode as 'modify', targets: st.targets, priority: st.priority ?? 0 });
-        if (!duplicate) decomposedCount++;
+        await taskStore.create({
+          title: st.instruction,
+          description: st.instruction,
+          priority: st.priority ?? 0,
+          createdBy: 'ai',
+        });
       }
       renderer.info(`Decomposed into ${subtasks.length} per-file tasks`);
       continue;
     }
 
     // File conflict check: if task targets overlap with files in use, wait
-    const taskTargets = task.targets ?? [];
-    const hasConflict = taskTargets.some(f => filesInUse.has(f));
+    const taskTargets = task.context.files;
+    const hasConflict = taskTargets.some((f: string) => filesInUse.has(f));
     if (hasConflict && running.size > 0) {
       await Promise.race(running.values());
       continue;
@@ -1559,9 +1571,9 @@ export async function handleSession(opts: ParsedArgs): Promise<void> {
 
     taskCount++;
     if (opts.verbose) process.env.WEAVER_VERBOSE = '1';
-    renderer.taskStart(taskCount, task.instruction ?? task.id);
+    renderer.taskStart(taskCount, task.title ?? task.id);
 
-    await queue.markRunning(task.id);
+    await taskStore.update(task.id, { status: 'in-progress' });
     // Reserve files
     for (const f of taskTargets) filesInUse.add(f);
 
@@ -1784,8 +1796,9 @@ export async function handleSteer(opts: ParsedArgs): Promise<void> {
 }
 
 export async function handleQueue(opts: ParsedArgs): Promise<void> {
-  const { TaskQueue } = await import('./bot/task-queue.js');
-  const queue = new TaskQueue();
+  const { TaskStore } = await import('./bot/task-store.js');
+  const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
+  const store = new TaskStore(projectDir);
 
   const action = opts.botTask;
   if (!action || !['add', 'list', 'clear', 'remove', 'retry'].includes(action)) {
@@ -1800,30 +1813,31 @@ export async function handleQueue(opts: ParsedArgs): Promise<void> {
         console.error('[weaver] Usage: flow-weaver weaver queue add "task instruction"');
         process.exit(1);
       }
-      const { id, duplicate } = await queue.add({ instruction, priority: 0 });
-      if (duplicate) {
-        console.log(`[weaver] Task already queued (${id}).`);
-      } else {
-        console.log(`[weaver] Task added: ${id}`);
-      }
+      const task = await store.create({ title: instruction, description: instruction, priority: 0, createdBy: 'user' });
+      console.log(`[weaver] Task added: ${task.id}`);
       break;
     }
     case 'list': {
-      const tasks = await queue.list();
+      const tasks = await store.list();
       if (opts.historyJson) {
         console.log(JSON.stringify(tasks, null, 2));
       } else if (tasks.length === 0) {
         console.log('No tasks in queue.');
       } else {
-        console.log('ID'.padEnd(10) + 'STATUS'.padEnd(12) + 'PRIORITY'.padEnd(10) + 'INSTRUCTION');
+        console.log('ID'.padEnd(10) + 'STATUS'.padEnd(14) + 'PRIORITY'.padEnd(10) + 'TITLE');
         for (const t of tasks) {
-          console.log(t.id.padEnd(10) + t.status.padEnd(12) + String(t.priority).padEnd(10) + t.instruction.slice(0, 60));
+          console.log(t.id.padEnd(10) + t.status.padEnd(14) + String(t.priority).padEnd(10) + t.title.slice(0, 60));
         }
       }
       break;
     }
     case 'clear': {
-      const count = await queue.clear();
+      const tasks = await store.list();
+      let count = 0;
+      for (const t of tasks) {
+        await store.update(t.id, { status: 'cancelled' });
+        count++;
+      }
       console.log(`Cleared ${count} task(s).`);
       break;
     }
@@ -1833,19 +1847,30 @@ export async function handleQueue(opts: ParsedArgs): Promise<void> {
         console.error('[weaver] Usage: flow-weaver weaver queue remove <id>');
         process.exit(1);
       }
-      const removed = await queue.remove(id);
-      console.log(removed ? `Removed task ${id}.` : `No task found with id "${id}".`);
+      try {
+        await store.update(id, { status: 'cancelled' });
+        console.log(`Cancelled task ${id}.`);
+      } catch {
+        console.log(`No task found with id "${id}".`);
+      }
       break;
     }
     case 'retry': {
       const id = opts.botFile;
       if (id) {
-        // Retry a specific task
-        const retried = await queue.retry(id);
-        console.log(retried ? `Task ${id} reset to pending.` : `No failed/running task found with id "${id}".`);
+        try {
+          await store.update(id, { status: 'pending' });
+          console.log(`Task ${id} reset to pending.`);
+        } catch {
+          console.log(`No task found with id "${id}".`);
+        }
       } else {
-        // Retry all failed tasks
-        const count = await queue.retryAll();
+        const failed = await store.list({ status: 'failed' });
+        let count = 0;
+        for (const t of failed) {
+          await store.update(t.id, { status: 'pending' });
+          count++;
+        }
         console.log(`Reset ${count} failed task(s) to pending.`);
       }
       break;
@@ -1855,15 +1880,16 @@ export async function handleQueue(opts: ParsedArgs): Promise<void> {
 
 export async function handleStatus(opts: ParsedArgs): Promise<void> {
   const store = new RunStore();
-  const { TaskQueue } = await import('./bot/task-queue.js');
-  const queue = new TaskQueue();
+  const { TaskStore } = await import('./bot/task-store.js');
+  const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
+  const taskStore = new TaskStore(projectDir);
 
   const orphans = store.checkOrphans();
   const recentRuns = store.list({ limit: 5 });
-  const tasks = await queue.list();
+  const tasks = await taskStore.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 running = tasks.filter(t => t.status === 'in-progress').length;
+  const completed = tasks.filter(t => t.status === 'done').length;
   const failed = tasks.filter(t => t.status === 'failed').length;
 
   if (opts.historyJson) {
@@ -2367,15 +2393,14 @@ export async function handleDoctor(opts: ParsedArgs): Promise<void> {
 
   // Queue status
   try {
-    const { TaskQueue } = await import('./bot/task-queue.js');
-    process.env.WEAVER_PROJECT_DIR = dir;
-    const queue = new TaskQueue();
-    const tasks = await queue.list();
+    const { TaskStore } = await import('./bot/task-store.js');
+    const taskStore = new TaskStore(dir);
+    const tasks = await taskStore.list();
     const pending = tasks.filter(t => t.status === 'pending').length;
-    const running = tasks.filter(t => t.status === 'running').length;
-    checks.push({ label: 'Queue', status: 'ok', detail: `${pending} pending, ${running} running` });
+    const inProgress = tasks.filter(t => t.status === 'in-progress').length;
+    checks.push({ label: 'Queue', status: 'ok', detail: `${pending} pending, ${inProgress} in-progress` });
   } catch {
-    checks.push({ label: 'Queue', status: 'ok', detail: 'Empty (no queue file)' });
+    checks.push({ label: 'Queue', status: 'ok', detail: 'Empty (no tasks file)' });
   }
 
   // Plan file

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

package/src/index.ts

@@ -104,14 +104,15 @@ export { WebApprovalHandler } from './bot/index.js';
 // Bot infrastructure
 export {
   SteeringController,
-  TaskQueue,
-  SessionStore,
+  TaskStore,
   buildBotSystemPrompt,
 } from './bot/index.js';
 export type {
   SteeringCommand,
-  QueuedTask,
-  SessionState,
+  Task,
+  TaskFilter,
+  CreateTaskInput,
+  TaskStatus,
   BotTask,
   BotPlan,
   BotPlanStep,