@synergenius/flow-weaver-pack-weaver 0.9.159 → 0.9.164

package/src/bot/task-store.ts

@@ -2,9 +2,9 @@ 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 } from './task-types.js';
+import type { Task, TaskFilter, CreateTaskInput, RunProgress } from './task-types.js';
 
-/** Don't re-queue tasks completed/failed within this window (ms). */
+/** Don't re-queue tasks completed within this window (ms). */
 const DEDUP_WINDOW_MS = 3_600_000; // 1 hour
 
 export class TaskStore {
@@ -43,17 +43,11 @@ export class TaskStore {
           isParent: true,
           parentId: input.parentId,
           dependsOn: input.dependsOn ?? [],
-          currentBotId: undefined,
-        currentRunId: undefined,
-          context: { files: [], notes: '', runSummaries: [] },
-          runs: [],
-          attempt: 0,
-          maxAttempts: input.maxAttempts ?? 3,
-          budgetTokens: input.budgetTokens,
+          context: { files: [], notes: '', runHistory: [], stagnationCount: 0 },
           budgetCost: input.budgetCost,
           tokensUsed: 0,
           costUsed: 0,
-          timeoutMs: input.timeoutMs,
+          acceptance: input.acceptance,
           complexity: input.complexity,
           assignedProfile: input.assignedProfile,
           createdBy: input.createdBy ?? 'user',
@@ -82,16 +76,11 @@ export class TaskStore {
             isParent: false,
             parentId: parentId,
             dependsOn: resolvedDeps,
-            currentBotId: undefined,
-        currentRunId: undefined,
-            context: { files: [], notes: '', runSummaries: [] },
-            runs: [],
-            attempt: 0,
-            maxAttempts: input.maxAttempts ?? 3,
-            budgetTokens: input.budgetTokens,
+            context: { files: [], notes: '', runHistory: [], stagnationCount: 0 },
             budgetCost: input.budgetCost,
             tokensUsed: 0,
             costUsed: 0,
+            acceptance: sub.acceptance ?? input.acceptance,
             complexity: sub.complexity ?? input.complexity,
             assignedProfile: sub.assignedProfile ?? input.assignedProfile,
             createdBy: input.createdBy ?? 'user',
@@ -120,17 +109,11 @@ export class TaskStore {
         isParent: false,
         parentId: input.parentId,
         dependsOn: input.dependsOn ?? [],
-        currentBotId: undefined,
-        currentRunId: undefined,
-        context: { files: [], notes: '', runSummaries: [] },
-        runs: [],
-        attempt: 0,
-        maxAttempts: input.maxAttempts ?? 3,
-        budgetTokens: input.budgetTokens,
+        context: { files: [], notes: '', runHistory: [], stagnationCount: 0 },
         budgetCost: input.budgetCost,
         tokensUsed: 0,
         costUsed: 0,
-        timeoutMs: input.timeoutMs,
+        acceptance: input.acceptance,
         complexity: input.complexity,
         assignedProfile: input.assignedProfile,
         createdBy: input.createdBy ?? 'user',
@@ -163,7 +146,7 @@ export class TaskStore {
           tasks = tasks.filter(t => t.parentId === filter.parentId);
         }
         if (filter.botId !== undefined) {
-          tasks = tasks.filter(t => t.currentBotId === filter.botId);
+          tasks = tasks.filter(t => t.assignedProfile === filter.botId);
         }
         if (filter.limit !== undefined && filter.limit > 0) {
           tasks = tasks.slice(0, filter.limit);
@@ -181,27 +164,36 @@ export class TaskStore {
       if (idx === -1) throw new Error(`Task not found: ${id}`);
 
       const task = tasks[idx];
+
+      // Reset stagnation when profile is reassigned (fresh start for new approach)
+      if (patch.assignedProfile && patch.assignedProfile !== task.assignedProfile) {
+        task.context.stagnationCount = 0;
+      }
+
+      // Trigger parent effects when status changes to done or cancelled
+      const statusChanged = patch.status && patch.status !== task.status;
+
       Object.assign(task, patch, { updatedAt: new Date().toISOString() });
       tasks[idx] = task;
+
+      if (statusChanged && (task.status === 'done' || task.status === 'cancelled')) {
+        this._handleDependencyEffects(tasks, task);
+        this._handleParentEffects(tasks, task);
+      }
+
       this._writeAll(tasks);
       return task;
     });
   }
 
-  async updateContext(id: string, runSummary: RunSummary): Promise<Task> {
+  async updateContext(id: string, runProgress: RunProgress): Promise<Task> {
     return this.mutex.runExclusive(async () => {
       const tasks = this._readAll();
       const idx = tasks.findIndex(t => t.id === id);
       if (idx === -1) throw new Error(`Task not found: ${id}`);
 
       const task = tasks[idx];
-      task.context.runSummaries.push(runSummary);
-
-      if (runSummary.outcome === 'failed' || runSummary.outcome === 'error') {
-        task.context.lastError = runSummary.error;
-      } else {
-        task.context.lastError = undefined;
-      }
+      task.context.runHistory.push(runProgress);
 
       task.updatedAt = new Date().toISOString();
       tasks[idx] = task;
@@ -233,14 +225,13 @@ export class TaskStore {
 
       const task = tasks[idx];
       const assignable =
-        (task.status === 'open' || task.status === 'pending') &&
-        task.attempt < task.maxAttempts;
+        task.status === 'open' && !task.context.budgetExhausted;
       if (!assignable) {
-        throw new Error(`Task ${taskId} is not assignable (status: ${task.status}, attempt: ${task.attempt}/${task.maxAttempts})`);
+        throw new Error(`Task ${taskId} is not assignable (status: ${task.status})`);
       }
 
       task.status = 'in-progress';
-      task.currentBotId = instanceId;
+      task.activeRunId = instanceId; // will be replaced with actual runId by swarm controller
       task.assignedProfile = profileId;
       task.updatedAt = new Date().toISOString();
 
@@ -254,7 +245,7 @@ export class TaskStore {
   // Release
   // ---------------------------------------------------------------------------
 
-  async release(taskId: string, status: 'done' | 'failed' | 'open', runSummary: RunSummary): Promise<Task> {
+  async release(taskId: string, status: 'done' | 'open', runProgress: RunProgress): Promise<Task> {
     return this.mutex.runExclusive(async () => {
       const tasks = this._readAll();
       const idx = tasks.findIndex(t => t.id === taskId);
@@ -262,33 +253,59 @@ export class TaskStore {
 
       const task = tasks[idx];
 
-      // Append run summary and track runId
-      task.context.runSummaries.push(runSummary);
-      if (runSummary.runId && !task.runs.includes(runSummary.runId)) {
-        task.runs.push(runSummary.runId);
-      }
-      if (runSummary.outcome === 'failed' || runSummary.outcome === 'error') {
-        task.context.lastError = runSummary.error;
+      // Append run progress
+      task.context.runHistory.push(runProgress);
+
+      // Accumulate usage
+      task.tokensUsed += runProgress.tokensUsed;
+      task.costUsed += runProgress.cost;
+
+      // Update stagnation count
+      const prevRun = task.context.runHistory.length >= 2
+        ? task.context.runHistory[task.context.runHistory.length - 2]
+        : undefined;
+      if (prevRun && 'filesCreated' in prevRun && 'filesModified' in prevRun) {
+        const prevFiles = new Set([...(prevRun.filesCreated as string[]), ...(prevRun.filesModified as string[])]);
+        const newFiles = new Set([...runProgress.filesCreated, ...runProgress.filesModified]);
+        const hasNewFiles = [...newFiles].some(f => !prevFiles.has(f));
+        task.context.stagnationCount = hasNewFiles ? 0 : task.context.stagnationCount + 1;
       } else {
-        task.context.lastError = undefined;
+        task.context.stagnationCount = 0;
       }
 
-      // Accumulate usage
-      task.tokensUsed += runSummary.tokensUsed;
-      task.costUsed += runSummary.cost;
-
-      // Update execution tracking
-      task.attempt += 1;
-      // Tasks don't fail — runs fail. Map 'failed' to 'open' for backward compat.
-      task.status = status === 'failed' ? 'open' : status;
-      task.currentBotId = undefined;
-      task.currentRunId = undefined;
+      // Check budget exhaustion
+      if (task.budgetCost && task.costUsed >= task.budgetCost) {
+        task.context.budgetExhausted = true;
+      }
+
+      // Update status
+      task.status = status;
+      task.activeRunId = undefined;
       task.updatedAt = new Date().toISOString();
 
       if (status === 'done') {
         task.completedAt = new Date().toISOString();
       }
-      // 'open' and 'failed' → task stays open, no completedAt
+
+      // Compact old runs: keep last 5 full, older become audit-only
+      if (task.context.runHistory.length > 5) {
+        const cutoff = task.context.runHistory.length - 5;
+        for (let i = 0; i < cutoff; i++) {
+          const old = task.context.runHistory[i];
+          if ('filesCreated' in old) {
+            task.context.runHistory[i] = {
+              runId: old.runId,
+              botId: old.botId,
+              profileId: old.profileId,
+              outcome: old.outcome,
+              tokensUsed: old.tokensUsed,
+              cost: old.cost,
+              durationMs: old.durationMs,
+              endedAt: old.endedAt,
+            };
+          }
+        }
+      }
 
       tasks[idx] = task;
 
@@ -306,20 +323,21 @@ export class TaskStore {
   // ---------------------------------------------------------------------------
 
   private _handleDependencyEffects(tasks: Task[], changedTask: Task): void {
-    if (changedTask.status === 'done') {
-      // Unblock dependents: set blocked tasks to open if all deps are now done
-      const doneIds = new Set(tasks.filter(t => t.status === 'done').map(t => t.id));
-      for (const t of tasks) {
-        if (t.status === 'blocked' && t.dependsOn.includes(changedTask.id)) {
-          if (t.dependsOn.every(depId => doneIds.has(depId))) {
-            t.status = 'open';
-            t.updatedAt = new Date().toISOString();
-          }
+    if (changedTask.status !== 'done' && changedTask.status !== 'cancelled') return;
+
+    // A dep is resolved when it's done OR cancelled.
+    const resolvedIds = new Set(
+      tasks.filter(t => t.status === 'done' || t.status === 'cancelled').map(t => t.id),
+    );
+
+    for (const t of tasks) {
+      if (t.status === 'open' && t.dependsOn.includes(changedTask.id)) {
+        if (t.dependsOn.every(depId => resolvedIds.has(depId))) {
+          // All deps resolved — bump updatedAt as a "ready" signal for the dispatcher.
+          t.updatedAt = new Date().toISOString();
         }
       }
     }
-    // Tasks don't fail — runs fail. Dependents stay blocked until dep
-    // succeeds (status=done). No terminal 'failed' state to handle.
   }
 
   private _handleParentEffects(tasks: Task[], changedTask: Task): void {
@@ -333,16 +351,21 @@ export class TaskStore {
 
     const subtasks = tasks.filter(t => t.parentId === parent.id);
 
-    // All done => parent done
-    if (subtasks.every(s => s.status === 'done')) {
+    // All subtasks resolved (done or cancelled) => parent resolved
+    const allResolved = subtasks.every(s => s.status === 'done' || s.status === 'cancelled');
+    if (!allResolved) return;
+
+    // If ALL subtasks were cancelled (none done), parent is cancelled too
+    const anyDone = subtasks.some(s => s.status === 'done');
+    if (anyDone) {
       parent.status = 'done';
       parent.completedAt = new Date().toISOString();
-      parent.updatedAt = new Date().toISOString();
-      return;
+    } else {
+      parent.status = 'cancelled';
+      parent.cancelledAt = new Date().toISOString();
+      parent.cancelReason = 'All subtasks cancelled';
     }
-
-    // Tasks don't fail. Parent stays open until all subtasks are done
-    // or user cancels. No terminal 'failed' state for parent.
+    parent.updatedAt = new Date().toISOString();
   }
 
   // ---------------------------------------------------------------------------
@@ -373,9 +396,9 @@ export class TaskStore {
   // ---------------------------------------------------------------------------
 
   private _findDuplicate(tasks: Task[], title: string, description: string): Task | null {
-    // Check open/pending duplicates
+    // Check open duplicates
     const openDup = tasks.find(
-      t => (t.status === 'open' || t.status === 'pending') && t.title === title && t.description === description,
+      t => t.status === 'open' && t.title === title && t.description === description,
     );
     if (openDup) return openDup;
 

package/src/bot/task-types.ts

@@ -1,44 +1,94 @@
 /**
- * Task entity types for the Weaver Swarm.
- * Tasks are first-class entities with hierarchy, context, and budget.
+ * Task entity types for the Convergent Swarm.
+ *
+ * Core principles:
+ * - Tasks never fail. Runs contribute.
+ * - Acceptance criteria are checked by code, not AI.
+ * - Budget is the only hard limit.
  */
 
-export interface RunSummary {
+// ---------------------------------------------------------------------------
+// Run progress — what a single run contributed
+// ---------------------------------------------------------------------------
+
+export type RunOutcomeStatus = 'contributed' | 'completed' | 'stalled' | 'crashed';
+
+export interface RunProgress {
   runId: string;
   botId: string;
-  outcome: 'success' | 'failed' | 'error';
-  summary: string;
-  report?: string;
+  profileId: string;
+  outcome: RunOutcomeStatus;
+  filesCreated: string[];
   filesModified: string[];
-  error?: string;
+  summary: string;
+  remainingWork?: string;
+  blockers?: string[];
+  checks?: Record<string, string>;
+  tokensUsed: number;
+  cost: number;
   durationMs: number;
+  endedAt: string;
+}
+
+export interface CompactedRun {
+  runId: string;
+  botId: string;
+  profileId: string;
+  outcome: RunOutcomeStatus;
   tokensUsed: number;
   cost: number;
+  durationMs: number;
+  endedAt: string;
+}
+
+// ---------------------------------------------------------------------------
+// Acceptance criteria — checked by code, not AI
+// ---------------------------------------------------------------------------
+
+export interface AcceptanceCheck {
+  name: string;
+  command: string;
 }
 
+export interface AcceptanceCriteria {
+  checks: AcceptanceCheck[];
+}
+
+export interface AcceptanceResult {
+  met: boolean;
+  results: Array<{ name: string; pass: boolean; detail?: string }>;
+  checkedAt: string;
+}
+
+// ---------------------------------------------------------------------------
+// Task context
+// ---------------------------------------------------------------------------
+
 export interface TaskContext {
   files: string[];
   notes: string;
-  runSummaries: RunSummary[];
-  lastError?: string;
-  /** Project brief propagated from parent task for cross-task coherence. */
+  runHistory: (RunProgress | CompactedRun)[];
+  stagnationCount: number;
+  budgetExhausted?: boolean;
   projectBrief?: string;
 }
 
-/**
- * Task status. Tasks NEVER go to 'failed' — runs fail, tasks stay open.
- * 'open' replaces 'pending'. A task is open until done or cancelled.
- */
-export type TaskStatus = 'open' | 'pending' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
-// NOTE: 'pending' kept for backward compatibility with existing data.
-// New code should use 'open'. Both are treated as assignable.
+// ---------------------------------------------------------------------------
+// Task status
+// ---------------------------------------------------------------------------
+
+export type TaskStatus = 'open' | 'in-progress' | 'done' | 'cancelled';
+
+// ---------------------------------------------------------------------------
+// Task
+// ---------------------------------------------------------------------------
 
 export interface Task {
   id: string;
   title: string;
   description: string;
   status: TaskStatus;
-  priority: number; // higher = higher priority
+  priority: number;
 
   // Hierarchy
   isParent: boolean;
@@ -46,36 +96,32 @@ export interface Task {
   dependsOn: string[];
 
   // Assignment
-  currentBotId?: string;
-  currentRunId?: string;
+  assignedProfile?: string;
+  activeRunId?: string;
+
+  // Acceptance
+  acceptance?: AcceptanceCriteria;
+  lastAcceptanceCheck?: AcceptanceResult;
 
   // Context
   context: TaskContext;
 
-  // Execution
-  runs: string[];
-  attempt: number;
-  maxAttempts: number;
-
   // Budget
-  budgetTokens?: number;
   budgetCost?: number;
   tokensUsed: number;
   costUsed: number;
 
-  // 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
+  // Routing
+  routingReason?: string;
+  complexity?: 'trivial' | 'simple' | 'moderate' | 'complex';
 
   // Metadata
   createdBy: 'user' | 'ai';
   createdAt: string;
   updatedAt: string;
   completedAt?: string;
+  cancelledAt?: string;
+  cancelReason?: string;
 }
 
 export interface TaskFilter {
@@ -91,13 +137,11 @@ export interface CreateTaskInput {
   priority?: number;
   parentId?: string;
   dependsOn?: string[];
-  budgetTokens?: number;
   budgetCost?: number;
-  timeoutMs?: number;
-  maxAttempts?: number;
   createdBy?: 'user' | 'ai';
   complexity?: 'trivial' | 'simple' | 'moderate' | 'complex';
   assignedProfile?: string;
+  acceptance?: AcceptanceCriteria;
   subtasks?: Array<{
     title: string;
     description?: string;
@@ -105,5 +149,6 @@ export interface CreateTaskInput {
     priority?: number;
     complexity?: 'trivial' | 'simple' | 'moderate' | 'complex';
     assignedProfile?: string;
+    acceptance?: AcceptanceCriteria;
   }>;
 }

package/src/bot/types.ts

@@ -169,6 +169,8 @@ export interface WorkflowResult {
   outcome: string;
   /** Optional markdown report for rich UI display. */
   report?: string;
+  /** Structured run progress JSON from agent-execute (convergent swarm). */
+  runProgressJson?: string;
   functionName?: string;
   executionTime?: number;
   cost?: RunCostSummary;

package/src/bot/weaver-tools.ts

@@ -119,12 +119,23 @@ export function createWeaverExecutor(projectDir: string) {
           }
         }
 
+        // Parse acceptance criteria if provided
+        const rawAcc = args.acceptance as Record<string, unknown> | undefined;
+        const acceptance = rawAcc?.checks ? {
+          checks: (rawAcc.checks as Array<{ name: string; command: string }>).map(c => ({
+            name: String(c.name ?? ''),
+            command: String(c.command ?? ''),
+          })).filter(c => c.name && c.command),
+        } : undefined;
+
         const task = await store.create({
           title,
           description: String(args.description ?? ''),
           priority: (args.priority as number) ?? 0,
           parentId,
           dependsOn: (args.dependsOn as string[]) ?? [],
+          assignedProfile: args.assignedProfile as string | undefined,
+          acceptance,
           createdBy: 'ai',
         });
         // Set files if provided

package/src/cli-handlers.ts

@@ -70,7 +70,6 @@ export interface ParsedArgs {
   confirmFlag?: boolean;
   taskDescription?: string;
   complexity?: string;
-  autoRetry?: boolean;
   // assistant
   assistantNew?: boolean;
   assistantResume?: string;
@@ -341,8 +340,6 @@ export function parseArgs(argv: string[]): ParsedArgs {
     } else if (arg === '--complexity' && i + 1 < args.length) {
       i++;
       result.complexity = args[i];
-    } else if (arg === '--auto-retry') {
-      result.autoRetry = true;
     } else if (arg === '--status' && i + 1 < args.length) {
       i++;
       result.historyOutcome = args[i];
@@ -1443,7 +1440,6 @@ export async function handleSwarm(opts: ParsedArgs): Promise<void> {
         maxConcurrent: opts.maxConcurrent,
         workspaceBudgetTokens: opts.budgetTokens,
         workspaceBudgetCost: opts.budgetCost,
-        autoRetry: opts.autoRetry,
       }, projectDir);
       console.log('\x1b[32m→ Config updated\x1b[0m');
       break;
@@ -1483,7 +1479,7 @@ export async function handleTask(opts: ParsedArgs): Promise<void> {
         return;
       }
       for (const t of tasks) {
-        const icon = t.status === 'done' ? '\x1b[32m✓\x1b[0m' : t.status === 'failed' ? '\x1b[31m✗\x1b[0m' : t.status === 'in-progress' ? '\x1b[36m▸\x1b[0m' : '○';
+        const icon = t.status === 'done' ? '\x1b[32m✓\x1b[0m' : t.status === 'cancelled' ? '\x1b[31m✗\x1b[0m' : t.status === 'in-progress' ? '\x1b[36m▸\x1b[0m' : '○';
         console.log(`  ${icon} ${(t.id ?? '').slice(0, 8)} ${t.title ?? ''} [${t.status ?? ''}] ${t.assignedProfile ? `→ ${t.assignedProfile}` : ''}`);
       }
       break;
@@ -1755,12 +1751,12 @@ export async function handleStatus(opts: ParsedArgs): Promise<void> {
     const pending = tasks.filter((t: { status: string }) => t.status === 'pending').length;
     const running = tasks.filter((t: { status: string }) => t.status === 'in-progress').length;
     const done = tasks.filter((t: { status: string }) => t.status === 'done').length;
-    const failed = tasks.filter((t: { status: string }) => t.status === 'failed').length;
-    console.log(`  Tasks: ${pending} pending, ${running} running, ${done} done, ${failed} failed`);
+    const cancelled = tasks.filter((t: { status: string }) => t.status === 'cancelled').length;
+    console.log(`  Tasks: ${pending} open, ${running} running, ${done} done, ${cancelled} cancelled`);
 
     console.log(`\n  Recent tasks:`);
     for (const t of tasks.slice(0, 5)) {
-      const icon = t.status === 'done' ? '\x1b[32m✓\x1b[0m' : t.status === 'failed' ? '\x1b[31m✗\x1b[0m' : t.status === 'in-progress' ? '\x1b[36m▸\x1b[0m' : '○';
+      const icon = t.status === 'done' ? '\x1b[32m✓\x1b[0m' : t.status === 'cancelled' ? '\x1b[31m✗\x1b[0m' : t.status === 'in-progress' ? '\x1b[36m▸\x1b[0m' : '○';
       console.log(`    ${icon} ${(t.id ?? '').slice(0, 8)} [${t.status}] ${(t.title ?? '').slice(0, 60)}`);
     }
   } else {
@@ -2243,7 +2239,7 @@ export async function handleDoctor(opts: ParsedArgs): Promise<void> {
     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 pending = tasks.filter(t => t.status === 'open').length;
     const inProgress = tasks.filter(t => t.status === 'in-progress').length;
     checks.push({ label: 'Queue', status: 'ok', detail: `${pending} pending, ${inProgress} in-progress` });
   } catch {

package/src/index.ts

@@ -113,6 +113,12 @@ export type {
   TaskFilter,
   CreateTaskInput,
   TaskStatus,
+  RunProgress,
+  RunOutcomeStatus,
+  CompactedRun,
+  AcceptanceCheck,
+  AcceptanceCriteria,
+  AcceptanceResult,
   BotTask,
   BotPlan,
   BotPlanStep,