@synergenius/flow-weaver-pack-weaver 0.9.199 → 0.9.201

package/src/bot/swarm-controller.ts

@@ -234,6 +234,36 @@ export class SwarmController {
       this.frozenPromptPrefix = null;
     }
 
+    // Pre-flight validation — catch tool pipeline config bugs before spending money
+    try {
+      const { runPreflight, runBridgePreflight, formatPreflightResult } = await import('./preflight.js');
+
+      // Static checks (schemas, handlers, modes)
+      const preflight = runPreflight();
+      if (!preflight.passed) {
+        const report = formatPreflightResult(preflight);
+        console.error(report);
+        this.eventLog.emit({ type: 'swarm-preflight-failed', timestamp: Date.now(), data: { errors: preflight.errors } });
+        throw new Error(`Swarm preflight failed: ${preflight.errors.length} error(s). Fix before starting.`);
+      }
+
+      // Runtime check (MCP bridge connectivity)
+      const bridgePreflight = await runBridgePreflight();
+      const totalChecks = preflight.checks.length + bridgePreflight.checks.length;
+      if (!bridgePreflight.passed) {
+        const report = formatPreflightResult(bridgePreflight);
+        console.error(report);
+        this.eventLog.emit({ type: 'swarm-preflight-failed', timestamp: Date.now(), data: { errors: bridgePreflight.errors } });
+        throw new Error(`Swarm preflight failed: MCP bridge connectivity check failed. ${bridgePreflight.errors.map(e => e.message).join('; ')}`);
+      }
+
+      console.log(`\x1b[32m[swarm-preflight] ✓ Tool pipeline validated (${totalChecks} checks passed)\x1b[0m`);
+    } catch (err: unknown) {
+      if (err instanceof Error && err.message.startsWith('Swarm preflight failed')) throw err;
+      // Non-fatal: preflight import failure shouldn't block swarm
+      if (process.env.WEAVER_VERBOSE) console.warn('[swarm] preflight check skipped:', err);
+    }
+
     console.log(`\x1b[36m[swarm] started (pack-weaver v${PACK_VERSION})\x1b[0m`);
     this.eventLog.emit({ type: 'swarm-started', timestamp: Date.now(), data: { packVersion: PACK_VERSION } });
 
@@ -295,6 +325,14 @@ export class SwarmController {
     this.settledPromises.clear();
 
     this.eventLog.emit({ type: 'swarm-stopped', timestamp: Date.now() });
+
+    // Assemble complete audit trail — one file with the full story
+    try {
+      const { assembleAuditTrail } = await import('./audit-trail.js');
+      const trail = assembleAuditTrail(this.projectDir);
+      const trailPath = path.join(this.projectDir, '.weaver', 'audit-trail.json');
+      fs.writeFileSync(trailPath, JSON.stringify(trail, null, 2));
+    } catch { /* non-fatal */ }
   }
 
   getStatus(): SwarmState {
@@ -344,6 +382,20 @@ export class SwarmController {
   // Token/cost recording
   // -----------------------------------------------------------------------
 
+  /** Read provider from .weaver.json, fall back to 'auto'. */
+  private _resolveProvider(): string {
+    try {
+      const configPath = path.join(this.projectDir, '.weaver.json');
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        if (config.provider && typeof config.provider === 'string') {
+          return config.provider;
+        }
+      }
+    } catch { /* malformed config — fall back */ }
+    return 'auto';
+  }
+
   private _buildBasicRunProgress(
     runId: string, workerId: string, profileId: string,
     result: { success?: boolean; summary?: string },
@@ -353,8 +405,9 @@ export class SwarmController {
     let outcome: 'completed' | 'contributed' | 'stalled' | 'crashed';
     if (result.success) {
       outcome = 'completed';
-    } else if (tokensUsed === 0 && durationMs < 10_000) {
-      // Ran for less than 10s with no AI tokens — something failed before work started
+    } else if (tokensUsed === 0) {
+      // Zero tokens consumed — AI call either failed immediately or timed out.
+      // Always stalled regardless of duration (a 600s timeout with 0 tokens is not "contributed").
       outcome = 'stalled';
     } else {
       outcome = 'contributed';
@@ -375,27 +428,40 @@ export class SwarmController {
     };
   }
 
-  private async _checkAcceptance(task: Task): Promise<import('./task-types.js').AcceptanceResult> {
-    const criteria = task.acceptance;
-    if (!criteria || !criteria.checks.length) {
+  private async _checkAcceptance(task: Task, profileId?: string): Promise<import('./task-types.js').AcceptanceResult> {
+    // Merge task-specific checks with capability-level checks
+    const { mergeAcceptanceChecks } = await import('./acceptance-merge.js');
+    const { getCapabilityAcceptanceChecks } = await import('./capability-registry.js');
+
+    const taskChecks = task.acceptance?.checks ?? [];
+    const capChecks = profileId ? getCapabilityAcceptanceChecks(profileId) : [];
+    const allChecks = mergeAcceptanceChecks(taskChecks, capChecks, this.projectDir);
+
+    if (allChecks.length === 0) {
       return { met: true, results: [], checkedAt: new Date().toISOString() };
     }
 
     const { execSync } = await import('node:child_process');
     const results: Array<{ name: string; pass: boolean; detail?: string }> = [];
 
-    for (const check of criteria.checks) {
+    for (const check of allChecks) {
       try {
-        execSync(check.command, {
+        const stdout = execSync(check.command, {
           cwd: this.projectDir,
           encoding: 'utf-8',
           timeout: 60_000,
           stdio: ['pipe', 'pipe', 'pipe'],
         });
-        results.push({ name: check.name, pass: true });
+        console.log(`\x1b[32m  ✓ ${check.name}\x1b[0m`);
+        results.push({ name: check.name, pass: true, detail: stdout?.trim() || undefined });
       } catch (err: unknown) {
-        const e = err as { stdout?: string; stderr?: string; message?: string };
-        const detail = (e.stdout ?? e.stderr ?? e.message ?? '').slice(0, 500);
+        const e = err as { stdout?: string; stderr?: string; message?: string; status?: number };
+        const stdout = e.stdout ?? '';
+        const stderr = e.stderr ?? '';
+        const detail = `exit ${e.status ?? '?'}\nstdout: ${stdout}\nstderr: ${stderr}`;
+        console.log(`\x1b[31m  ✗ ${check.name} (exit ${e.status ?? '?'})\x1b[0m`);
+        if (stdout.trim()) console.log(`    stdout: ${stdout.trim().slice(0, 300)}`);
+        if (stderr.trim()) console.log(`    stderr: ${stderr.trim().slice(0, 300)}`);
         results.push({ name: check.name, pass: false, detail });
       }
     }
@@ -689,7 +755,7 @@ export class SwarmController {
           this.eventLog.emit({
             type: 'orchestrator-decision',
             timestamp: Date.now(),
-            data: { taskId: d.taskId, profileId: d.assignedProfileId, instanceId: d.assignedInstanceId, method: d.method, reason: d.reason },
+            data: { taskId: d.taskId, taskTitle: d.taskTitle, assignedProfileId: d.assignedProfileId, assignedInstanceId: d.assignedInstanceId, method: d.method, reason: d.reason, confidence: d.confidence },
           });
         }
       }
@@ -886,24 +952,34 @@ export class SwarmController {
       // Trivial tasks get cheaper models and fewer retries; complex tasks are unchanged.
       const baseBehavior: ProfileBehavior = profile.preferences.behavior
         ?? buildDefaultBehavior(profile.preferences.costStrategy, undefined, profile.id);
-      const behavior = adjustBehaviorForComplexity(baseBehavior, task.complexity);
+      const behavior = adjustBehaviorForComplexity(baseBehavior, task.complexity, profile.id);
       const behaviorJson = JSON.stringify(behavior);
 
       // Create per-run event log in the workspace .weaver directory
       // (must match the path used by fw_weaver_events in ai-chat-provider)
       const runEventLog = new EventLog(runId, path.join(this.projectDir, '.weaver'));
 
-      // Execute workflow — resolve relative filePath against project dir
-      const workflowPath = path.isAbsolute(bot.filePath)
+      // Execute workflow — resolve relative filePath against project dir.
+      // Fallback: if not found (e.g., npm install pruned pack symlinks),
+      // resolve from the pack's own root since we always know where our files are.
+      let workflowPath = path.isAbsolute(bot.filePath)
         ? bot.filePath
         : path.resolve(this.projectDir, bot.filePath);
+      if (!fs.existsSync(workflowPath)) {
+        const packRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+        const stripped = bot.filePath.replace(/^node_modules\/@synergenius\/flow-weaver-pack-weaver\//, '');
+        const fallback = path.resolve(packRoot, stripped);
+        if (fs.existsSync(fallback)) {
+          workflowPath = fallback;
+        }
+      }
       // No swarm-level timeout race — the AI call timeout (10min) in the worker
       // is the only boundary. This prevents orphaned runs from timeout races.
       result = await runWorkflow(workflowPath, {
         runId,
         taskId,
         botId: workerId,
-        config: { provider: 'auto' },
+        config: { provider: this._resolveProvider() },
         params: {
           taskJson,
           projectDir: this.projectDir,
@@ -967,12 +1043,10 @@ export class SwarmController {
     let releaseStatus: 'done' | 'open' = 'open';
 
     if (result.success) {
-      if (!task?.acceptance) {
-        releaseStatus = 'done';
-      } else {
+      // Always run acceptance — capability checks may exist even if task has no checks
+      {
         try {
-          // Run deterministic acceptance check
-          const acceptResult = await this._checkAcceptance(task);
+          const acceptResult = await this._checkAcceptance(task!, profile.id);
           if (acceptResult.met) {
             releaseStatus = 'done';
           }

package/src/bot/task-create-handler.ts

@@ -0,0 +1,164 @@
+/**
+ * Shared task_create handler — single source of truth for creating tasks.
+ *
+ * Used by both step-executor (plan-task agent loop) and weaver-tools (MCP bridge).
+ * Handles @self resolution, dedup, acceptance parsing, validation.
+ */
+
+import type { CreateTaskInput } from './task-types.js';
+import { TaskStore } from './task-store.js';
+
+export interface TaskCreateArgs {
+  title?: string;
+  description?: string;
+  parentId?: string;
+  assignedProfile?: string;
+  complexity?: string;
+  priority?: number;
+  dependsOn?: string[];
+  acceptance?: { checks?: Array<{ name: string; command: string }> };
+  files?: string[];
+}
+
+export interface TaskCreateResult {
+  output: string;
+  blocked?: boolean;
+  blockReason?: string;
+  taskId?: string;
+}
+
+/**
+ * Create a task with full validation, @self resolution, and dedup.
+ *
+ * @param args - The task_create arguments from the AI model
+ * @param projectDir - Workspace directory
+ * @param symbolicIdMap - Optional map for resolving symbolic IDs (step-executor path)
+ */
+export async function handleTaskCreate(
+  args: TaskCreateArgs,
+  projectDir: string,
+  symbolicIdMap?: Record<string, string>,
+): Promise<TaskCreateResult> {
+  const title = String(args.title ?? '');
+  if (!title.trim()) {
+    return { output: '', blocked: true, blockReason: 'task_create requires a "title" argument.' };
+  }
+
+  const store = new TaskStore(projectDir);
+
+  // Validate assignedProfile
+  const rawProfile = args.assignedProfile;
+  let assignedProfile: string | undefined;
+  if (rawProfile !== undefined && rawProfile !== null) {
+    if (typeof rawProfile !== 'string' || !rawProfile.trim()) {
+      return { output: '', blocked: true, blockReason: 'task_create: assignedProfile must be a non-empty string.' };
+    }
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(rawProfile)) {
+      return { output: '', blocked: true, blockReason: `task_create: assignedProfile "${rawProfile}" is not a valid slug.` };
+    }
+    assignedProfile = rawProfile;
+  }
+
+  // Validate complexity
+  const VALID_COMPLEXITIES = new Set(['trivial', 'simple', 'moderate', 'complex']);
+  const rawComplexity = args.complexity;
+  const complexity: 'trivial' | 'simple' | 'moderate' | 'complex' =
+    rawComplexity && VALID_COMPLEXITIES.has(rawComplexity)
+      ? (rawComplexity as 'trivial' | 'simple' | 'moderate' | 'complex')
+      : 'simple';
+
+  // Validate priority
+  const rawPriority = Number(args.priority);
+  const priority = Number.isFinite(rawPriority) ? rawPriority : 0;
+
+  // Resolve parentId — handle @self symbolic reference
+  let parentId: string | undefined;
+  const rawParentId = args.parentId;
+  if (rawParentId) {
+    if (rawParentId === '@self') {
+      // Try symbolicIdMap first (step-executor path), then fallback to store lookup
+      const fromMap = symbolicIdMap?.['@self'];
+      if (fromMap) {
+        parentId = fromMap;
+      } else {
+        // MCP bridge path — no symbolicIdMap, resolve from task store
+        const all = await store.list();
+        const inProgress = all.find(t => t.status === 'in-progress' && t.assignedProfile === 'orchestrator');
+        if (inProgress) {
+          parentId = inProgress.id;
+        }
+      }
+    } else {
+      // Resolve through symbolicIdMap or use as-is
+      parentId = symbolicIdMap?.[rawParentId] ?? rawParentId;
+    }
+
+    // Validate parent exists
+    if (parentId) {
+      const parentTask = await store.get(parentId);
+      if (!parentTask) {
+        return { output: '', blocked: true, blockReason: `task_create: parentId "${rawParentId}" does not match any existing task.` };
+      }
+    }
+  }
+
+  // Idempotent: skip if a task with the same title+parent already exists
+  if (parentId) {
+    const all = await store.list();
+    const existing = all.find(
+      t => t.parentId === parentId && t.title.toLowerCase() === title.toLowerCase(),
+    );
+    if (existing) {
+      if (symbolicIdMap) {
+        symbolicIdMap[title] = existing.id;
+      }
+      return { output: `Task "${title}" already exists (${existing.id}), skipped duplicate.`, taskId: existing.id };
+    }
+  }
+
+  // Resolve symbolic IDs in dependsOn
+  const rawDeps = args.dependsOn ?? [];
+  const resolvedDeps = symbolicIdMap
+    ? rawDeps.map(dep => symbolicIdMap[dep] ?? dep)
+    : rawDeps;
+
+  // Parse acceptance criteria
+  const rawAcceptance = args.acceptance;
+  const acceptance = rawAcceptance?.checks ? {
+    checks: rawAcceptance.checks.map(c => ({
+      name: String(c.name ?? ''),
+      command: String(c.command ?? ''),
+    })).filter(c => c.name && c.command),
+  } : undefined;
+
+  const input: CreateTaskInput = {
+    title,
+    description: String(args.description ?? title),
+    complexity,
+    priority,
+    parentId,
+    dependsOn: resolvedDeps,
+    assignedProfile,
+    acceptance,
+    createdBy: 'ai',
+  };
+
+  const task = await store.create(input);
+
+  // Track in symbolicIdMap for subsequent task_create calls
+  if (symbolicIdMap) {
+    symbolicIdMap[title] = task.id;
+  }
+
+  // Set files if provided
+  if (args.files && Array.isArray(args.files)) {
+    await store.update(task.id, {
+      context: { ...task.context, files: args.files as string[] },
+    });
+  }
+
+  return {
+    output: JSON.stringify({ id: task.id, title: task.title, status: task.status }),
+    taskId: task.id,
+  };
+}

package/src/bot/task-store.ts

@@ -165,6 +165,54 @@ export class TaskStore {
 
       const task = tasks[idx];
 
+      // Guard: never reopen a done or cancelled task via a generic update.
+      // Only release() and explicit retry should change terminal status.
+      const isTerminal = task.status === 'done' || task.status === 'cancelled';
+      if (isTerminal && patch.status && patch.status !== task.status) {
+        delete patch.status;
+      }
+
+      // Guard: update() cannot set status to 'done' — must go through release()
+      if (patch.status === 'done') {
+        throw new Error(
+          `Cannot transition task ${id} to done via update() — use release() instead`,
+        );
+      }
+
+      // Guard: completedAt consistency — only done tasks may have completedAt.
+      // Cannot set it on non-done tasks, cannot strip it from done tasks.
+      if (patch.completedAt !== undefined) {
+        if (task.status !== 'done') {
+          delete patch.completedAt;
+        }
+      }
+      if (isTerminal && task.status === 'done' && 'completedAt' in patch && !patch.completedAt) {
+        delete patch.completedAt;
+      }
+
+      // Deep-merge context: patch.context is merged INTO task.context,
+      // never replaces it wholesale. This prevents accidental loss of
+      // runHistory, budgetExhausted, stagnationCount, etc.
+      if (patch.context) {
+        const patchCtx = patch.context;
+
+        // Guard: budgetExhausted is one-way — once set, cannot be cleared
+        if (task.context.budgetExhausted === true && patchCtx.budgetExhausted === false) {
+          patchCtx.budgetExhausted = true;
+        }
+
+        // Guard: runHistory is append-only — cannot replace with a shorter array
+        if (patchCtx.runHistory) {
+          if (patchCtx.runHistory.length < task.context.runHistory.length) {
+            patchCtx.runHistory = task.context.runHistory;
+          }
+        }
+
+        // Merge into existing context instead of replacing
+        Object.assign(task.context, patchCtx);
+        delete patch.context;
+      }
+
       // Reset stagnation when profile is reassigned (fresh start for new approach)
       if (patch.assignedProfile && patch.assignedProfile !== task.assignedProfile) {
         task.context.stagnationCount = 0;
@@ -253,6 +301,13 @@ export class TaskStore {
 
       const task = tasks[idx];
 
+      // Guard: only in-progress tasks can be released
+      if (task.status !== 'in-progress') {
+        throw new Error(
+          `Task ${taskId} is not in-progress (status: ${task.status}) — cannot release`,
+        );
+      }
+
       // Append run progress
       task.context.runHistory.push(runProgress);
 
@@ -318,6 +373,34 @@ export class TaskStore {
     });
   }
 
+  // ---------------------------------------------------------------------------
+  // Retry — explicit reopen of a terminal task
+  // ---------------------------------------------------------------------------
+
+  async retry(taskId: 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];
+      if (task.status !== 'done' && task.status !== 'cancelled') {
+        throw new Error(`Task ${taskId} is not in a terminal state (status: ${task.status}) — cannot retry`);
+      }
+
+      task.status = 'open';
+      task.activeRunId = undefined;
+      task.completedAt = undefined;
+      task.cancelledAt = undefined;
+      task.cancelReason = undefined;
+      task.updatedAt = new Date().toISOString();
+
+      tasks[idx] = task;
+      this._writeAll(tasks);
+      return task;
+    });
+  }
+
   // ---------------------------------------------------------------------------
   // Dependency + parent cascading effects
   // ---------------------------------------------------------------------------

package/src/bot/types.ts

@@ -709,7 +709,10 @@ export type AuditEventType =
   | 'step-start' | 'step-complete' | 'validation-run'
   | 'fix-attempt' | 'git-operation' | 'notification-sent'
   | 'run-complete'
-  | 'ai-request' | 'ai-response' | 'tool-call' | 'tool-result';
+  | 'ai-request' | 'ai-response' | 'tool-call' | 'tool-result'
+  | 'tool-rejected' | 'tool-schema-missing'
+  | 'bridge-created' | 'bridge-sethandlers' | 'bridge-tool-filtered' | 'bridge-tool-passthrough'
+  | 'bridge-preflight-ok' | 'bridge-preflight-fail';
 
 export interface AuditEvent {
   type: AuditEventType;

package/src/bot/weaver-tools.ts

@@ -8,7 +8,7 @@
 
 import { execFileSync } from 'node:child_process';
 import { executeStep } from './step-executor.js';
-import type { ToolDefinition } from '@synergenius/flow-weaver/agent';
+import { stripMcpToolPrefix, type ToolDefinition } from '@synergenius/flow-weaver/agent';
 import { BOT_TOOLS as WEAVER_TOOLS } from './tool-registry.js';
 import { isBlockedUrl } from './safety.js';
 
@@ -37,7 +37,7 @@ export function createWeaverExecutor(projectDir: string) {
     // 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_-]+__/, '');
+    const name = stripMcpToolPrefix(rawName);
 
     // Handle new tools that bypass step-executor
     switch (name) {
@@ -102,50 +102,12 @@ export function createWeaverExecutor(projectDir: string) {
       }
 
       case 'task_create': {
-        const { TaskStore } = await import('./task-store.js');
-        const store = new TaskStore(projectDir);
-        const title = String(args.title);
-        const parentId = args.parentId as string | undefined;
-
-        // Idempotent: skip if a task with the same title+parent already exists.
-        // Prevents orchestrator retries from creating duplicate subtasks.
-        if (parentId) {
-          const all = await store.list();
-          const existing = all.find(
-            t => t.parentId === parentId && t.title.toLowerCase() === title.toLowerCase(),
-          );
-          if (existing) {
-            return { result: JSON.stringify({ id: existing.id, title: existing.title, status: existing.status, skipped: true }), isError: false };
-          }
-        }
-
-        // 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,
-          complexity: args.complexity as 'trivial' | 'simple' | 'moderate' | 'complex' | undefined,
-          acceptance,
-          createdBy: 'ai',
-        });
-        // Set files if provided
-        if (args.files && Array.isArray(args.files)) {
-          await store.update(task.id, {
-            context: { ...task.context, files: args.files as string[] },
-          });
+        const { handleTaskCreate } = await import('./task-create-handler.js');
+        const result = await handleTaskCreate(args as any, projectDir);
+        if (result.blocked) {
+          return { result: result.blockReason ?? 'Blocked', isError: true };
         }
-        return { result: JSON.stringify({ id: task.id, title: task.title, status: task.status }), isError: false };
+        return { result: result.output, isError: false };
       }
 
       case 'task_list': {