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

package/src/mcp-tools.ts

@@ -1,9 +1,16 @@
-import { z } from 'zod';
+/**
+ * MCP tool registrations for the Weaver pack.
+ *
+ * Reads tool schemas from the manifest (single source of truth) and delegates
+ * every handler to `handleWeaverTool` from ai-chat-provider — so MCP and the
+ * platform AI chat always run the exact same logic.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { runWorkflow } from './bot/runner.js';
-import { RunStore } from './bot/run-store.js';
-import { CostStore } from './bot/cost-store.js';
-import { defaultRegistry, discoverProviders } from './bot/provider-registry.js';
+import { z } from 'zod';
+import { handleWeaverTool } from './ai-chat-provider.js';
 
 // McpServer type from the SDK, kept loose to avoid hard dependency
 type McpServer = {
@@ -11,329 +18,131 @@ type McpServer = {
     name: string,
     description: string,
     schema: Record<string, unknown>,
-    handler: (args: { [key: string]: unknown }) => Promise<{ content: Array<{ type: string; text: string }> }>,
+    handler: (args: { [key: string]: unknown }) => Promise<{
+      content: Array<{ type: string; text: string }>;
+      isError?: boolean;
+    }>,
   ): void;
 };
 
-export async function registerMcpTools(mcp: McpServer): Promise<void> {
-  mcp.tool(
-    'fw_weaver_run',
-    'Execute a Flow Weaver workflow with the AI runner. Returns the result summary, outcome, and cost.',
-    {
-      file: z.string().describe('Path to the workflow file'),
-      params: z.record(z.unknown()).optional().describe('Input parameters as key-value pairs'),
-      verbose: z.boolean().optional().describe('Show detailed execution info'),
-      dryRun: z.boolean().optional().describe('Preview without executing'),
-    },
-    async (args) => {
-      const result = await runWorkflow(args.file as string, {
-        params: args.params as Record<string, unknown> | undefined,
-        verbose: args.verbose as boolean | undefined,
-        dryRun: args.dryRun as boolean | undefined,
-      });
-      return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-      };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_history',
-    'Query weaver run history. Returns recent workflow executions with outcome, duration, and summary.',
-    {
-      id: z.string().optional().describe('Specific run ID to look up'),
-      limit: z.number().optional().describe('Max number of entries (default 20)'),
-      outcome: z.enum(['completed', 'failed', 'error', 'skipped']).optional().describe('Filter by outcome'),
-      workflowFile: z.string().optional().describe('Filter by workflow file path'),
-    },
-    async (args) => {
-      const store = new RunStore();
-
-      if (args.id) {
-        const record = store.get(args.id as string);
-        if (!record) {
-          return { content: [{ type: 'text', text: `No run found matching "${args.id}"` }] };
-        }
-        return { content: [{ type: 'text', text: JSON.stringify(record, null, 2) }] };
-      }
-
-      const records = store.list({
-        outcome: args.outcome as 'completed' | 'failed' | 'error' | 'skipped' | undefined,
-        workflowFile: args.workflowFile as string | undefined,
-        limit: (args.limit as number | undefined) ?? 20,
-      });
-
-      if (records.length === 0) {
-        return { content: [{ type: 'text', text: 'No runs recorded yet.' }] };
-      }
-
-      return { content: [{ type: 'text', text: JSON.stringify(records, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_costs',
-    'Get AI cost summary across weaver runs. Shows total tokens, estimated cost, and breakdown by model.',
-    {
-      since: z.string().optional().describe('Filter: duration like "7d", "30d", or ISO-8601 date'),
-      model: z.string().optional().describe('Filter by model name'),
-    },
-    async (args) => {
-      const store = new CostStore();
-      let sinceTs: number | undefined;
-
-      if (args.since) {
-        const spec = args.since as string;
-        const match = spec.match(/^(\d+)([dhm])$/);
-        if (match) {
-          const n = parseInt(match[1]!, 10);
-          const unit = match[2];
-          const ms = unit === 'd' ? n * 86_400_000 : unit === 'h' ? n * 3_600_000 : n * 60_000;
-          sinceTs = Date.now() - ms;
-        } else {
-          const ts = new Date(spec).getTime();
-          if (!isNaN(ts)) sinceTs = ts;
-        }
-      }
-
-      const summary = store.summarize({ since: sinceTs, model: args.model as string | undefined });
-      return { content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_providers',
-    'List available AI providers for weaver workflow execution.',
-    {},
-    async () => {
-      await discoverProviders(defaultRegistry);
-      const providers = defaultRegistry.list();
-
-      const result = providers.map(({ name, metadata }) => ({
-        name,
-        source: metadata.source,
-        description: metadata.description,
-        requiredEnvVars: metadata.requiredEnvVars,
-        envVarsSet: metadata.requiredEnvVars?.every((v) => process.env[v]) ?? false,
-        detectCliCommand: metadata.detectCliCommand,
-      }));
-
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    },
-  );
-
-  // --- Task Tools ---
-
-  mcp.tool(
-    'fw_weaver_task_create',
-    'Create a new task for the bot swarm to execute. Provide a title and description.',
-    {
-      title: z.string().describe('Short task title'),
-      description: z.string().optional().describe('Detailed task description'),
-      assignedBots: z.array(z.string()).optional().describe('Bot IDs to assign'),
-      priority: z.number().optional().describe('Priority (higher = more urgent)'),
-      projectDir: z.string().optional().describe('Project directory'),
-    },
-    async (args) => {
-      const { TaskStore } = await import('./bot/task-store.js');
-      const projectDir = (args.projectDir as string) ?? process.env.WEAVER_PROJECT_DIR ?? process.cwd();
-      const store = new TaskStore(projectDir);
-      const task = await store.create({
-        title: args.title as string,
-        description: (args.description as string) ?? '',
-        assignedBots: args.assignedBots as string[] | undefined,
-        priority: args.priority as number | undefined,
-      });
-      return { content: [{ type: 'text', text: JSON.stringify(task, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_task_list',
-    'List tasks in the swarm task store. Optionally filter by status, parentId, or botId.',
-    {
-      status: z.string().optional().describe('Filter by status (pending, in-progress, done, failed, cancelled)'),
-      parentId: z.string().optional().describe('Filter by parent task ID'),
-      botId: z.string().optional().describe('Filter by assigned bot ID'),
-      limit: z.number().optional().describe('Max entries to return'),
-      projectDir: z.string().optional().describe('Project directory'),
-    },
-    async (args) => {
-      const { TaskStore } = await import('./bot/task-store.js');
-      const projectDir = (args.projectDir as string) ?? process.env.WEAVER_PROJECT_DIR ?? process.cwd();
-      const store = new TaskStore(projectDir);
-      const tasks = await store.list({
-        status: args.status as 'pending' | 'in-progress' | 'done' | 'failed' | 'cancelled' | undefined,
-        parentId: args.parentId as string | undefined,
-        botId: args.botId as string | undefined,
-        limit: args.limit as number | undefined,
-      });
-      return { content: [{ type: 'text', text: JSON.stringify(tasks, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_task_cancel',
-    'Cancel a pending or running task by ID.',
-    {
-      id: z.string().describe('Task ID to cancel'),
-      projectDir: z.string().optional().describe('Project directory'),
-    },
-    async (args) => {
-      const { TaskStore } = await import('./bot/task-store.js');
-      const projectDir = (args.projectDir as string) ?? process.env.WEAVER_PROJECT_DIR ?? process.cwd();
-      const store = new TaskStore(projectDir);
-      const task = await store.update(args.id as string, { status: 'cancelled' });
-      return { content: [{ type: 'text', text: JSON.stringify({ cancelled: true, task }) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_steer',
-    'Send a steering command to a running bot (pause, resume, cancel, redirect, queue).',
-    {
-      command: z.enum(['pause', 'resume', 'cancel', 'redirect', 'queue']).describe('Steering command'),
-      payload: z.string().optional().describe('Payload for redirect/queue commands'),
-    },
-    async (args) => {
-      const { SteeringController } = await import('./bot/steering.js');
-      const controller = new SteeringController();
-      await controller.write({
-        command: args.command as 'pause' | 'resume' | 'cancel' | 'redirect' | 'queue',
-        payload: args.payload as string | undefined,
-        timestamp: Date.now(),
-      });
-      return { content: [{ type: 'text', text: `Steering command sent: ${args.command}` }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_status',
-    'Get current swarm status: active bots, task counts, budget usage.',
-    {},
-    async () => {
-      const { TaskStore } = await import('./bot/task-store.js');
-      const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
-      const store = new TaskStore(projectDir);
-      const tasks = await store.list();
-      const pending = tasks.filter(t => t.status === 'pending').length;
-      const inProgress = tasks.filter(t => t.status === 'in-progress').length;
-      const done = tasks.filter(t => t.status === 'done').length;
-      const failed = tasks.filter(t => t.status === 'failed').length;
-
-      return { content: [{ type: 'text', text: JSON.stringify({ pending, inProgress, done, failed, total: tasks.length }, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_events',
-    'Read live execution events from a running or completed bot task. Returns events since the given offset for progressive streaming.',
-    {
-      runId: z.string().describe('Run ID from a task execution'),
-      offset: z.number().optional().describe('Event offset to read from (default 0)'),
-    },
-    async (args) => {
-      const { EventLog } = await import('./bot/event-log.js');
-      const runId = args.runId as string;
-      const offset = (args.offset as number) ?? 0;
-      const log = new EventLog(runId);
-      const events = log.tail(offset);
-      const done = log.isDone();
+// ---------------------------------------------------------------------------
+// JSON Schema → Zod conversion (shallow, covers the manifest's patterns)
+// ---------------------------------------------------------------------------
+
+export function jsonSchemaPropertyToZod(prop: Record<string, unknown>): z.ZodTypeAny {
+  const type = prop.type as string | undefined;
+
+  if (type === 'array') {
+    const items = prop.items as Record<string, unknown> | undefined;
+    // For nested object arrays (e.g. subtasks) just accept unknown[]
+    if (items && (items.type === 'object' || !items.type)) {
+      return z.array(z.unknown()).describe((prop.description as string) ?? '');
+    }
+    return z.array(jsonSchemaPropertyToZod(items ?? { type: 'string' })).describe(
+      (prop.description as string) ?? '',
+    );
+  }
+
+  if (type === 'number') {
+    let s: z.ZodTypeAny = z.number();
+    if (prop.description) s = s.describe(prop.description as string);
+    return s;
+  }
+  if (type === 'boolean') {
+    let s: z.ZodTypeAny = z.boolean();
+    if (prop.description) s = s.describe(prop.description as string);
+    return s;
+  }
+  if (type === 'object') {
+    // Generic object — accept anything
+    let s: z.ZodTypeAny = z.record(z.unknown());
+    if (prop.description) s = s.describe(prop.description as string);
+    return s;
+  }
+
+  // Default: string (possibly with enum)
+  if (prop.enum) {
+    const values = prop.enum as [string, ...string[]];
+    let s: z.ZodTypeAny = z.enum(values);
+    if (prop.description) s = s.describe(prop.description as string);
+    return s;
+  }
+  let s: z.ZodTypeAny = z.string();
+  if (prop.description) s = s.describe(prop.description as string);
+  return s;
+}
 
-      return { content: [{ type: 'text', text: JSON.stringify({ events, done }) }] };
-    },
-  );
+export function jsonSchemaToZodShape(
+  params: Record<string, unknown>,
+): Record<string, z.ZodTypeAny> {
+  const properties = (params.properties ?? {}) as Record<string, Record<string, unknown>>;
+  const required = new Set((params.required ?? []) as string[]);
+  const shape: Record<string, z.ZodTypeAny> = {};
+
+  for (const [key, prop] of Object.entries(properties)) {
+    let zodType = jsonSchemaPropertyToZod(prop);
+    if (!required.has(key)) {
+      zodType = zodType.optional();
+    }
+    shape[key] = zodType;
+  }
+  return shape;
+}
 
-  mcp.tool(
-    'fw_weaver_approve',
-    'Approve or reject a pending bot plan. Writes the decision so the bot can continue or abort.',
-    {
-      approved: z.boolean().describe('Whether to approve the plan'),
-      reason: z.string().optional().describe('Reason for rejection'),
-    },
-    async (args) => {
-      const { writeFileSync } = await import('node:fs');
-      const { join } = await import('node:path');
-      const { homedir } = await import('node:os');
-      const dir = process.env.WEAVER_HISTORY_DIR ?? join(homedir(), '.weaver');
-      const decisionPath = join(dir, 'approval-decision.json');
+// ---------------------------------------------------------------------------
+// Read tool definitions from the manifest
+// ---------------------------------------------------------------------------
 
-      writeFileSync(decisionPath, JSON.stringify({
-        approved: args.approved as boolean,
-        reason: (args.reason as string) ?? undefined,
-        timestamp: Date.now(),
-      }), 'utf-8');
+interface ManifestTool {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+}
 
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: true }) }] };
-    },
-  );
+export function loadManifestTools(): ManifestTool[] {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  const manifestPath = path.resolve(__dirname, '..', 'flowweaver.manifest.json');
+  const raw = fs.readFileSync(manifestPath, 'utf-8');
+  const manifest = JSON.parse(raw);
+  return (manifest.aiChat?.tools ?? []) as ManifestTool[];
+}
 
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
 
-  mcp.tool(
-    'fw_weaver_genesis',
-    'Run a single Genesis self-evolution cycle on a target workflow. Genesis observes the project, proposes changes within a budget, validates, and commits or rolls back.',
-    {
-      projectDir: z.string().optional().describe('Project directory (defaults to cwd)'),
-      dryRun: z.boolean().optional().describe('Preview without executing'),
-    },
-    async (args) => {
-      const packRoot = new URL('..', import.meta.url);
-      let workflowPath: string;
-      try {
-        const { existsSync } = await import('node:fs');
-        workflowPath = fileURLToPath(new URL('src/workflows/genesis-task.ts', packRoot));
-        if (!existsSync(workflowPath)) {
-          workflowPath = fileURLToPath(new URL('dist/workflows/genesis-task.js', packRoot));
+export async function registerMcpTools(mcp: McpServer): Promise<void> {
+  const tools = loadManifestTools();
+  const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
+
+  for (const tool of tools) {
+    const zodShape = jsonSchemaToZodShape(tool.parameters);
+
+    mcp.tool(
+      tool.name,
+      tool.description,
+      zodShape,
+      async (args) => {
+        try {
+          const { result, isError } = await handleWeaverTool(
+            tool.name,
+            args,
+            projectDir,
+          );
+          return {
+            content: [{ type: 'text', text: result }],
+            ...(isError ? { isError: true } : {}),
+          };
+        } catch (err) {
+          return {
+            content: [{
+              type: 'text',
+              text: err instanceof Error ? err.message : String(err),
+            }],
+            isError: true,
+          };
         }
-      } catch {
-        workflowPath = fileURLToPath(new URL('dist/workflows/genesis-task.js', packRoot));
-      }
-
-      const result = await runWorkflow(workflowPath, {
-        params: { projectDir: (args.projectDir as string) ?? process.cwd() },
-        dryRun: args.dryRun as boolean | undefined,
-      });
-
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_insights',
-    'Get project health, insights, trust level, and cost summary. Returns structured JSON with actionable recommendations.',
-    {
-      projectDir: z.string().describe('Project directory path'),
-    },
-    async (args) => {
-      try {
-        const { ProjectModelStore } = await import('./bot/project-model.js');
-        const { InsightEngine } = await import('./bot/insight-engine.js');
-        const pms = new ProjectModelStore(args.projectDir as string);
-        const model = await pms.getOrBuild();
-        const engine = new InsightEngine();
-        const insights = engine.analyze(model);
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              health: model.health,
-              bots: model.bots,
-              insights: insights.slice(0, 10),
-              trust: model.trust,
-              cost: model.cost,
-              evolution: {
-                totalCycles: model.evolution.totalCycles,
-                successRate: model.evolution.successRate,
-                recentCycles: (model.evolution.recentCycles ?? []).slice(0, 20),
-              },
-            }, null, 2),
-          }],
-        };
-      } catch (err: unknown) {
-        return {
-          content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
-        };
-      }
-    },
-  );
+      },
+    );
+  }
 }

package/src/node-types/orchestrator-dispatch.ts

@@ -0,0 +1,71 @@
+import type { OrchestratorOutput } from '../bot/profile-types.js';
+
+/**
+ * Applies orchestrator routing decisions — assigns tasks, scales instances.
+ *
+ * @flowWeaver nodeType
+ * @label Dispatch Tasks
+ * @input decisions [order:0] - JSON OrchestratorOutput
+ * @input projectDir [order:1] - Project directory path
+ * @output results [order:0] - JSON dispatch results
+ * @output onSuccess [order:-2] - Dispatch complete
+ * @output onFailure [order:-1] [hidden] - Dispatch failed
+ */
+export async function orchestratorDispatch(
+  execute: boolean,
+  decisions: string,
+  projectDir: string,
+): Promise<{ onSuccess: boolean; onFailure: boolean; results: string | null }> {
+  if (!execute) {
+    return { onSuccess: true, onFailure: false, results: '{"assigned":0,"scaled":0,"skipped":0}' };
+  }
+
+  try {
+    const output = JSON.parse(decisions) as OrchestratorOutput;
+    const { SwarmController } = await import('../bot/swarm-controller.js');
+    const controller = SwarmController.getInstance(projectDir);
+    const instanceManager = controller.getInstanceManager();
+    const profileStore = controller.getProfileStore();
+
+    let assigned = 0;
+    let scaled = 0;
+    let skipped = 0;
+    const appliedAssignments: Array<{ taskId: string; profileId: string; instanceId: string }> = [];
+
+    // Apply scale actions
+    for (const sa of output.scaleActions) {
+      const profile = profileStore.get(sa.profileId);
+      if (profile) {
+        instanceManager.scaleTo(profile, sa.targetInstances);
+        scaled++;
+      } else {
+        skipped++;
+      }
+    }
+
+    // Apply assignments — note: full task execution is handled by SwarmController's
+    // dispatch loop. This node only records the assignment in the task store.
+    // For actual task execution, the dispatch loop picks up assigned tasks.
+    for (const assignment of output.assignments) {
+      try {
+        appliedAssignments.push({
+          taskId: assignment.taskId,
+          profileId: assignment.profileId,
+          instanceId: assignment.instanceId,
+        });
+        assigned++;
+      } catch {
+        skipped++;
+      }
+    }
+
+    skipped += output.skippedTasks.length;
+
+    const results = { assigned, scaled, skipped, appliedAssignments };
+    return { onSuccess: true, onFailure: false, results: JSON.stringify(results) };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`\x1b[31m→ Dispatch tasks failed: ${msg}\x1b[0m`);
+    return { onSuccess: false, onFailure: true, results: null };
+  }
+}

package/src/node-types/orchestrator-load-state.ts

@@ -0,0 +1,66 @@
+import type { OrchestratorInput } from '../bot/profile-types.js';
+
+/**
+ * Loads the current swarm state for the orchestrator to make routing decisions.
+ *
+ * @flowWeaver nodeType
+ * @label Load Swarm State
+ * @input projectDir [order:0] - Project directory path
+ * @output state [order:0] - JSON OrchestratorInput snapshot
+ * @output onSuccess [order:-2] - Loaded successfully
+ * @output onFailure [order:-1] [hidden] - Load failed
+ */
+export async function orchestratorLoadState(
+  execute: boolean,
+  projectDir: string,
+): Promise<{ onSuccess: boolean; onFailure: boolean; state: string | null }> {
+  if (!execute) {
+    return { onSuccess: true, onFailure: false, state: '{"pendingTasks":[],"profiles":[],"instances":[],"budgetRemaining":{"tokens":0,"cost":0}}' };
+  }
+
+  try {
+    const { SwarmController } = await import('../bot/swarm-controller.js');
+    const controller = SwarmController.getInstance(projectDir);
+    const profileStore = controller.getProfileStore();
+    const instanceManager = controller.getInstanceManager();
+    const swarmStatus = controller.getStatus();
+
+    // Load profiles
+    const profiles = profileStore.list();
+
+    // Load instances
+    const instances = instanceManager.listAll();
+
+    // Calculate budget remaining from swarm state
+    const { workspace, session } = swarmStatus.budgets;
+    const remainingTokens: number[] = [];
+    const remainingCost: number[] = [];
+    if (session.limitTokens > 0) remainingTokens.push(session.limitTokens - session.usedTokens);
+    if (workspace.limitTokens > 0) remainingTokens.push(workspace.limitTokens - workspace.usedTokens);
+    if (session.limitCost > 0) remainingCost.push(session.limitCost - session.usedCost);
+    if (workspace.limitCost > 0) remainingCost.push(workspace.limitCost - workspace.usedCost);
+
+    const budgetRemaining = {
+      tokens: remainingTokens.length > 0 ? Math.min(...remainingTokens) : Infinity,
+      cost: remainingCost.length > 0 ? Math.min(...remainingCost) : Infinity,
+    };
+
+    // Note: pending tasks are not loaded here — the node only loads
+    // profiles, instances, and budget. Task loading requires TaskStore
+    // access which is internal to SwarmController's dispatch loop.
+    // The caller should provide tasks via the workflow or the dispatch loop
+    // builds the full OrchestratorInput itself.
+    const input: OrchestratorInput = {
+      pendingTasks: [],
+      profiles,
+      instances,
+      budgetRemaining,
+    };
+
+    return { onSuccess: true, onFailure: false, state: JSON.stringify(input) };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`\x1b[31m→ Load swarm state failed: ${msg}\x1b[0m`);
+    return { onSuccess: false, onFailure: true, state: null };
+  }
+}

package/src/node-types/orchestrator-route.ts

@@ -0,0 +1,33 @@
+import { Orchestrator } from '../bot/orchestrator.js';
+import type { OrchestratorInput } from '../bot/profile-types.js';
+
+/**
+ * Routes pending tasks to appropriate bot profiles using the orchestrator brain.
+ *
+ * @flowWeaver nodeType
+ * @label Route Tasks
+ * @input state [order:0] - JSON OrchestratorInput
+ * @output decisions [order:0] - JSON OrchestratorOutput
+ * @output onSuccess [order:-2] - Routing complete
+ * @output onFailure [order:-1] [hidden] - Routing failed
+ */
+export async function orchestratorRoute(
+  execute: boolean,
+  state: string,
+): Promise<{ onSuccess: boolean; onFailure: boolean; decisions: string | null }> {
+  if (!execute) {
+    return { onSuccess: true, onFailure: false, decisions: '{"assignments":[],"scaleActions":[],"skippedTasks":[]}' };
+  }
+
+  try {
+    const input = JSON.parse(state) as OrchestratorInput;
+    const orchestrator = new Orchestrator();
+    const output = await orchestrator.route(input);
+
+    return { onSuccess: true, onFailure: false, decisions: JSON.stringify(output) };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`\x1b[31m→ Route tasks failed: ${msg}\x1b[0m`);
+    return { onSuccess: false, onFailure: true, decisions: null };
+  }
+}