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

package/src/bot/task-store.ts

@@ -0,0 +1,407 @@
+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';
+
+/** Don't re-queue tasks completed/failed within this window (ms). */
+const DEDUP_WINDOW_MS = 3_600_000; // 1 hour
+
+export class TaskStore {
+  private readonly filePath: string;
+  private readonly mutex = new AsyncMutex();
+
+  constructor(private readonly projectDir: string) {
+    const dir = path.join(projectDir, '.weaver');
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    this.filePath = path.join(dir, 'tasks.json');
+  }
+
+  // ---------------------------------------------------------------------------
+  // CRUD
+  // ---------------------------------------------------------------------------
+
+  async create(input: CreateTaskInput): Promise<Task> {
+    return this.mutex.runExclusive(async () => {
+      const tasks = this._readAll();
+
+      // --- Subtask creation ---
+      if (input.subtasks && input.subtasks.length > 0) {
+        // Check dedup for the parent
+        const existing = this._findDuplicate(tasks, input.title, input.description);
+        if (existing) return existing;
+
+        const parentId = crypto.randomUUID().slice(0, 8);
+        const now = new Date().toISOString();
+
+        const parent: Task = {
+          id: parentId,
+          title: input.title,
+          description: input.description,
+          status: 'pending',
+          priority: input.priority ?? 0,
+          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,
+          budgetCost: input.budgetCost,
+          tokensUsed: 0,
+          costUsed: 0,
+          timeoutMs: input.timeoutMs,
+          complexity: input.complexity,
+          assignedProfile: input.assignedProfile,
+          createdBy: input.createdBy ?? 'user',
+          createdAt: now,
+          updatedAt: now,
+        };
+        tasks.push(parent);
+
+        // Create subtasks with ^prev resolution
+        let prevSubtaskId: string | undefined;
+        for (const sub of input.subtasks) {
+          const subId = crypto.randomUUID().slice(0, 8);
+          const resolvedDeps = (sub.dependsOn ?? [])
+            .map(dep => {
+              if (dep === '^prev') return prevSubtaskId; // undefined if first
+              return dep;
+            })
+            .filter((d): d is string => d !== undefined);
+
+          const subtask: Task = {
+            id: subId,
+            title: sub.title,
+            description: sub.description ?? '',
+            status: 'pending',
+            priority: sub.priority ?? input.priority ?? 0,
+            isParent: false,
+            parentId: parentId,
+            dependsOn: resolvedDeps,
+            currentBotId: undefined,
+        currentRunId: undefined,
+            context: { files: [], notes: '', runSummaries: [] },
+            runs: [],
+            attempt: 0,
+            maxAttempts: input.maxAttempts ?? 3,
+            budgetTokens: input.budgetTokens,
+            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,
+          };
+          tasks.push(subtask);
+          prevSubtaskId = subId;
+        }
+
+        this._writeAll(tasks);
+        return parent;
+      }
+
+      // --- Single task creation ---
+      const existing = this._findDuplicate(tasks, input.title, input.description);
+      if (existing) return existing;
+
+      const now = new Date().toISOString();
+      const task: Task = {
+        id: crypto.randomUUID().slice(0, 8),
+        title: input.title,
+        description: input.description,
+        status: 'pending',
+        priority: input.priority ?? 0,
+        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,
+        budgetCost: input.budgetCost,
+        tokensUsed: 0,
+        costUsed: 0,
+        timeoutMs: input.timeoutMs,
+        complexity: input.complexity,
+        assignedProfile: input.assignedProfile,
+        createdBy: input.createdBy ?? 'user',
+        createdAt: now,
+        updatedAt: now,
+      };
+      tasks.push(task);
+      this._writeAll(tasks);
+      return task;
+    });
+  }
+
+  async get(id: string): Promise<Task | null> {
+    return this.mutex.runExclusive(async () => {
+      const tasks = this._readAll();
+      return tasks.find(t => t.id === id) ?? null;
+    });
+  }
+
+  async list(filter?: TaskFilter): Promise<Task[]> {
+    return this.mutex.runExclusive(async () => {
+      let tasks = this._readAll();
+
+      if (filter) {
+        if (filter.status !== undefined) {
+          const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+          tasks = tasks.filter(t => statuses.includes(t.status));
+        }
+        if (filter.parentId !== undefined) {
+          tasks = tasks.filter(t => t.parentId === filter.parentId);
+        }
+        if (filter.botId !== undefined) {
+          tasks = tasks.filter(t => t.currentBotId === filter.botId);
+        }
+        if (filter.limit !== undefined && filter.limit > 0) {
+          tasks = tasks.slice(0, filter.limit);
+        }
+      }
+
+      return tasks;
+    });
+  }
+
+  async update(id: string, patch: Partial<Task>): 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];
+      Object.assign(task, patch, { updatedAt: new Date().toISOString() });
+      tasks[idx] = task;
+      this._writeAll(tasks);
+      return task;
+    });
+  }
+
+  async updateContext(id: string, runSummary: RunSummary): 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.updatedAt = new Date().toISOString();
+      tasks[idx] = task;
+      this._writeAll(tasks);
+      return task;
+    });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Subtasks
+  // ---------------------------------------------------------------------------
+
+  async getSubtasks(parentId: string): Promise<Task[]> {
+    return this.mutex.runExclusive(async () => {
+      const tasks = this._readAll();
+      return tasks.filter(t => t.parentId === parentId);
+    });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Push-based assignment (orchestrator)
+  // ---------------------------------------------------------------------------
+
+  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}`);
+
+      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})`);
+      }
+
+      task.status = 'in-progress';
+      task.currentBotId = instanceId;
+      task.assignedProfile = profileId;
+      task.updatedAt = new Date().toISOString();
+
+      tasks[idx] = task;
+      this._writeAll(tasks);
+      return task;
+    });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Release
+  // ---------------------------------------------------------------------------
+
+  async release(taskId: string, status: 'done' | 'failed', runSummary: RunSummary): 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}`);
+
+      const task = tasks[idx];
+
+      // Append run summary
+      task.context.runSummaries.push(runSummary);
+      if (runSummary.outcome === 'failed' || runSummary.outcome === 'error') {
+        task.context.lastError = runSummary.error;
+      } else {
+        task.context.lastError = undefined;
+      }
+
+      // Accumulate usage
+      task.tokensUsed += runSummary.tokensUsed;
+      task.costUsed += runSummary.cost;
+
+      // Update execution tracking
+      task.attempt += 1;
+      task.status = status;
+      task.currentBotId = undefined;
+      task.currentRunId = undefined;
+      task.updatedAt = new Date().toISOString();
+
+      if (status === 'done') {
+        task.completedAt = new Date().toISOString();
+      }
+      if (status === 'failed') {
+        task.completedAt = new Date().toISOString();
+      }
+
+      tasks[idx] = task;
+
+      // --- Post-release effects ---
+      this._handleDependencyEffects(tasks, task);
+      this._handleParentEffects(tasks, task);
+
+      this._writeAll(tasks);
+      return task;
+    });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Dependency + parent cascading effects
+  // ---------------------------------------------------------------------------
+
+  private _handleDependencyEffects(tasks: Task[], changedTask: Task): void {
+    if (changedTask.status === 'done') {
+      // Unblock dependents: set blocked tasks to pending 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 = 'pending';
+            t.updatedAt = new Date().toISOString();
+          }
+        }
+      }
+    } else if (changedTask.status === 'failed') {
+      // Check if failure is terminal (no retries left)
+      if (changedTask.attempt >= changedTask.maxAttempts) {
+        // Block dependents
+        for (const t of tasks) {
+          if (t.status === 'pending' && t.dependsOn.includes(changedTask.id)) {
+            t.status = 'blocked';
+            t.updatedAt = new Date().toISOString();
+          }
+        }
+      }
+    }
+  }
+
+  private _handleParentEffects(tasks: Task[], changedTask: Task): void {
+    if (!changedTask.parentId) return;
+
+    const parentIdx = tasks.findIndex(t => t.id === changedTask.parentId);
+    if (parentIdx === -1) return;
+
+    const parent = tasks[parentIdx];
+    if (!parent.isParent) return;
+
+    const subtasks = tasks.filter(t => t.parentId === parent.id);
+
+    // All done => parent done
+    if (subtasks.every(s => s.status === 'done')) {
+      parent.status = 'done';
+      parent.completedAt = new Date().toISOString();
+      parent.updatedAt = new Date().toISOString();
+      return;
+    }
+
+    // Any terminal failure => parent failed
+    const hasTerminalFailure = subtasks.some(
+      s => s.status === 'failed' && s.attempt >= s.maxAttempts,
+    );
+    if (hasTerminalFailure) {
+      parent.status = 'failed';
+      parent.updatedAt = new Date().toISOString();
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Deduplication
+  // ---------------------------------------------------------------------------
+
+  private _findDuplicate(tasks: Task[], title: string, description: string): Task | null {
+    // Check pending duplicates
+    const pendingDup = tasks.find(
+      t => t.status === 'pending' && t.title === title && t.description === description,
+    );
+    if (pendingDup) return pendingDup;
+
+    // Check recently completed/failed (within dedup window)
+    const now = Date.now();
+    const recentDup = tasks.find(
+      t =>
+        (t.status === 'done' || t.status === 'failed') &&
+        t.title === title &&
+        t.description === description &&
+        t.completedAt !== undefined &&
+        now - Date.parse(t.completedAt) < DEDUP_WINDOW_MS,
+    );
+    if (recentDup) return recentDup;
+
+    return null;
+  }
+
+  // ---------------------------------------------------------------------------
+  // File I/O — atomic write via temp + rename
+  // ---------------------------------------------------------------------------
+
+  private _readAll(): Task[] {
+    if (!fs.existsSync(this.filePath)) return [];
+    try {
+      const raw = fs.readFileSync(this.filePath, 'utf-8');
+      const data = JSON.parse(raw);
+      return Array.isArray(data) ? data : [];
+    } catch {
+      return [];
+    }
+  }
+
+  private _writeAll(tasks: Task[]): void {
+    const tmpPath = this.filePath + '.tmp';
+    fs.writeFileSync(tmpPath, JSON.stringify(tasks, null, 2), 'utf-8');
+    fs.renameSync(tmpPath, this.filePath);
+  }
+}

package/src/bot/task-types.ts

@@ -0,0 +1,100 @@
+/**
+ * Task entity types for the Weaver Swarm.
+ * Tasks are first-class entities with hierarchy, context, and budget.
+ */
+
+export interface RunSummary {
+  runId: string;
+  botId: string;
+  outcome: 'success' | 'failed' | 'error';
+  summary: string;
+  filesModified: string[];
+  error?: string;
+  durationMs: number;
+  tokensUsed: number;
+  cost: number;
+}
+
+export interface TaskContext {
+  files: string[];
+  notes: string;
+  runSummaries: RunSummary[];
+  lastError?: string;
+}
+
+export type TaskStatus = 'pending' | 'in-progress' | 'blocked' | 'done' | 'failed' | 'cancelled';
+
+export interface Task {
+  id: string;
+  title: string;
+  description: string;
+  status: TaskStatus;
+  priority: number; // higher = higher priority
+
+  // Hierarchy
+  isParent: boolean;
+  parentId?: string;
+  dependsOn: string[];
+
+  // Assignment
+  currentBotId?: string;
+  currentRunId?: string;
+
+  // 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
+
+  // Metadata
+  createdBy: 'user' | 'ai';
+  createdAt: string;
+  updatedAt: string;
+  completedAt?: string;
+}
+
+export interface TaskFilter {
+  status?: TaskStatus | TaskStatus[];
+  parentId?: string;
+  botId?: string;
+  limit?: number;
+}
+
+export interface CreateTaskInput {
+  title: string;
+  description: string;
+  priority?: number;
+  parentId?: string;
+  dependsOn?: string[];
+  budgetTokens?: number;
+  budgetCost?: number;
+  timeoutMs?: number;
+  maxAttempts?: number;
+  createdBy?: 'user' | 'ai';
+  complexity?: 'trivial' | 'simple' | 'moderate' | 'complex';
+  assignedProfile?: string;
+  subtasks?: Array<{
+    title: string;
+    description?: string;
+    dependsOn?: string[];
+    priority?: number;
+    complexity?: 'trivial' | 'simple' | 'moderate' | 'complex';
+    assignedProfile?: string;
+  }>;
+}

package/src/bot/types.ts

@@ -205,6 +205,10 @@ export interface RunRecord {
   cost?: RunCostSummary;
   /** Lifecycle audit events (plan-created, approval, step-start/complete, etc.). */
   auditTrail?: AuditEvent[];
+  /** Swarm task this run belongs to. */
+  taskId?: string;
+  /** Bot slot that executed this run. */
+  botId?: string;
 }
 
 export interface RunFilter {
@@ -214,6 +218,10 @@ export interface RunFilter {
   since?: string;
   before?: string;
   limit?: number;
+  /** Filter runs belonging to a specific swarm task. */
+  taskId?: string;
+  /** Filter runs executed by a specific bot slot. */
+  botId?: string;
 }
 
 export interface RetentionPolicy {