@synergenius/flow-weaver-pack-weaver 0.9.152 → 0.9.154

package/src/bot/orchestrator.ts

@@ -1,8 +1,12 @@
 /**
- * Orchestrator — the routing brain that decides which tasks go to which bot instances.
+ * Orchestrator — the routing brain that decides which tasks go to which workers.
  *
- * Pure routing logic: no side-effects beyond decision logging.
- * Fast-path cascade: exact-match → single-eligible → ai-routed → round-robin.
+ * In the worker pool model, workers are generic slots. The orchestrator:
+ * 1. Finds the profile for each task (via assignedProfile).
+ * 2. Assigns the task to any idle worker.
+ *
+ * Simplified cascade: exact-match profile → any idle worker.
+ * No more per-profile instance matching or scale-up actions.
  */
 
 import type {
@@ -15,7 +19,6 @@ import type {
 
 type Task = OrchestratorInput['pendingTasks'][number];
 type Assignment = OrchestratorOutput['assignments'][number];
-type ScaleAction = OrchestratorOutput['scaleActions'][number];
 
 // ---------------------------------------------------------------------------
 // AI Router types
@@ -50,11 +53,10 @@ export class Orchestrator {
 
   async route(input: OrchestratorInput): Promise<OrchestratorOutput> {
     const assignments: Assignment[] = [];
-    const scaleActions: ScaleAction[] = [];
     const skippedTasks: OrchestratorOutput['skippedTasks'] = [];
 
-    // Track instances claimed during this routing cycle to avoid double-assignment.
-    const claimedInstanceIds = new Set<string>();
+    // Track workers claimed during this routing cycle to avoid double-assignment.
+    const claimedWorkerIds = new Set<string>();
 
     // Sort tasks by priority DESC (higher number = higher priority).
     const sorted = [...input.pendingTasks].sort((a, b) => b.priority - a.priority);
@@ -66,50 +68,43 @@ export class Orchestrator {
         continue;
       }
 
-      const eligible = this._findEligible(task, input.profiles);
-
-      if (eligible.length === 0) {
+      // Resolve profile for this task (includes routing method)
+      const resolution = await this._resolveProfile(task, input.profiles);
+      if (!resolution) {
         skippedTasks.push({ taskId: task.id, reason: 'no-eligible-profile' });
         continue;
       }
 
-      const result = await this._selectInstance(task, eligible, input.instances, claimedInstanceIds);
-
-      if (result) {
-        claimedInstanceIds.add(result.instanceId);
-        assignments.push({
-          taskId: task.id,
-          profileId: result.profileId,
-          instanceId: result.instanceId,
-          reason: result.reason,
-          method: result.method,
-          confidence: result.confidence,
-        });
-        this._recordDecision(task, result, eligible);
-      } else {
-        // No idle instance available — request scale-up if possible.
-        const scaleProfile = eligible[0];
-        const currentCount = input.instances.filter(
-          (i) => i.profileId === scaleProfile.id,
-        ).length;
-
-        if (currentCount < scaleProfile.maxInstances) {
-          // Only add one scale-up action per profile.
-          if (!scaleActions.some((sa) => sa.profileId === scaleProfile.id)) {
-            scaleActions.push({
-              profileId: scaleProfile.id,
-              action: 'scale-up',
-              targetInstances: currentCount + 1,
-              reason: `idle instances exhausted for profile ${scaleProfile.id}`,
-            });
-          }
-        }
-
-        skippedTasks.push({ taskId: task.id, reason: 'no-idle-instance' });
+      // Find any idle worker
+      const idleWorker = this._findIdleWorker(input.instances, claimedWorkerIds);
+      if (!idleWorker) {
+        skippedTasks.push({ taskId: task.id, reason: 'no-idle-worker' });
+        continue;
       }
+
+      claimedWorkerIds.add(idleWorker.instanceId);
+
+      const reason = `${resolution.method}: ${resolution.profileId} → ${idleWorker.instanceId}`;
+      assignments.push({
+        taskId: task.id,
+        profileId: resolution.profileId,
+        instanceId: idleWorker.instanceId,
+        reason,
+        method: resolution.method,
+        confidence: resolution.confidence,
+      });
+
+      this._recordDecision(task, {
+        profileId: resolution.profileId,
+        instanceId: idleWorker.instanceId,
+        method: resolution.method,
+        reason,
+        confidence: resolution.confidence,
+      }, input.profiles.filter(p => p.id === resolution.profileId));
     }
 
-    return { assignments, scaleActions, skippedTasks };
+    // No scale actions in pool model — pool size is fixed at maxConcurrent
+    return { assignments, scaleActions: [], skippedTasks };
   }
 
   getDecisionLog(limit?: number): OrchestratorDecision[] {
@@ -126,106 +121,48 @@ export class Orchestrator {
   // Internal
   // ---------------------------------------------------------------------------
 
-  /** Find profiles eligible for a task. */
-  private _findEligible(task: Task, profiles: BotProfile[]): BotProfile[] {
+  /** Resolve which profileId should handle this task, including routing method. */
+  private async _resolveProfile(
+    task: Task,
+    profiles: BotProfile[],
+  ): Promise<{ profileId: string; method: OrchestratorDecision['method']; confidence?: number } | null> {
+    // Exact match: task has assignedProfile
     if (task.assignedProfile) {
-      const match = profiles.filter(p => p.id === task.assignedProfile);
-      if (match.length > 0) return match;
-      // Assigned profile doesn't exist — return empty to skip this task
-      // rather than falling through to all profiles (silent mis-routing).
+      const match = profiles.find(p => p.id === task.assignedProfile);
+      if (match) return { profileId: match.id, method: 'exact-match' };
       console.warn(
         `[orchestrator] Task "${task.id}" assigned to profile "${task.assignedProfile}" which does not exist — skipping`,
       );
-      return [];
+      return null;
     }
-    return profiles;
-  }
 
-  /** Select the best instance for a task from eligible profiles. */
-  private async _selectInstance(
-    task: Task,
-    eligible: BotProfile[],
-    instances: BotInstance[],
-    claimed: Set<string>,
-  ): Promise<{ profileId: string; instanceId: string; method: OrchestratorDecision['method']; reason: string; confidence?: number } | null> {
-    // Determine routing method
-    let method = this._routingMethod(task, eligible);
-
-    if (eligible.length === 1) {
-      const profile = eligible[0];
-      const idle = instances.find(
-        (i) => i.profileId === profile.id && i.status === 'idle' && !claimed.has(i.instanceId),
-      );
-      if (!idle) return null;
-      return {
-        profileId: profile.id,
-        instanceId: idle.instanceId,
-        method,
-        reason: `${method}: ${profile.id}`,
-      };
+    // Single eligible profile
+    if (profiles.length === 1) {
+      return { profileId: profiles[0].id, method: 'single-eligible' };
     }
 
-    // AI routing: when multiple eligible profiles and AI router is provided
-    if (this._aiRouter && eligible.length > 1) {
+    // Multiple eligible profiles — try AI routing
+    if (this._aiRouter && profiles.length > 1) {
       try {
-        const aiResult = await this._aiRouter.route(task, eligible);
-        const aiProfile = eligible.find((p) => p.id === aiResult.profileId);
+        const aiResult = await this._aiRouter.route(task, profiles);
+        const aiProfile = profiles.find(p => p.id === aiResult.profileId);
         if (aiProfile) {
-          const idle = instances.find(
-            (i) => i.profileId === aiProfile.id && i.status === 'idle' && !claimed.has(i.instanceId),
-          );
-          if (idle) {
-            return {
-              profileId: aiProfile.id,
-              instanceId: idle.instanceId,
-              method: 'ai-routed',
-              reason: `ai-routed: ${aiProfile.id} — ${aiResult.reason}`,
-              confidence: aiResult.confidence,
-            };
-          }
-          // AI chose a profile but no idle instance — fall through to round-robin
+          return { profileId: aiProfile.id, method: 'ai-routed', confidence: aiResult.confidence };
         }
-        // AI returned unknown profile — fall through to round-robin
       } catch {
         // AI call failed — fall through to round-robin
       }
     }
 
-    // Round-robin: pick profile with most idle instances
-    method = 'round-robin';
-    let bestProfile: BotProfile | null = null;
-    let bestIdleCount = -1;
-    let bestInstance: BotInstance | null = null;
-
-    for (const profile of eligible) {
-      const idleInstances = instances.filter(
-        (i) => i.profileId === profile.id && i.status === 'idle' && !claimed.has(i.instanceId),
-      );
-      if (idleInstances.length > bestIdleCount) {
-        bestIdleCount = idleInstances.length;
-        bestProfile = profile;
-        bestInstance = idleInstances[0] ?? null;
-      }
-    }
-
-    if (!bestProfile || !bestInstance) return null;
-
-    return {
-      profileId: bestProfile.id,
-      instanceId: bestInstance.instanceId,
-      method,
-      reason: `${method}: ${bestProfile.id}`,
-    };
+    // Fallback: round-robin (first profile)
+    return profiles.length > 0 ? { profileId: profiles[0].id, method: 'round-robin' } : null;
   }
 
-  /** Determine which routing method was used. */
-  private _routingMethod(
-    task: Task,
-    eligible: BotProfile[],
-  ): OrchestratorDecision['method'] {
-    if (task.assignedProfile) return 'exact-match';
-    if (eligible.length === 1) return 'single-eligible';
-    return 'round-robin';
+  /** Find any idle worker that hasn't been claimed this cycle. */
+  private _findIdleWorker(instances: BotInstance[], claimed: Set<string>): BotInstance | null {
+    return instances.find(
+      (i) => i.status === 'idle' && !claimed.has(i.instanceId),
+    ) ?? null;
   }
 
   /** Record a decision in the log. */

package/src/bot/runner.ts

@@ -84,7 +84,7 @@ function parseConfigFile(configPath: string): WeaverConfig {
   }
 }
 
-function buildSummary(result: unknown): string {
+export function buildSummary(result: unknown): string {
   if (!result || typeof result !== 'object') return String(result);
 
   const r = result as Record<string, unknown>;
@@ -101,6 +101,120 @@ function buildSummary(result: unknown): string {
   return parts.length > 0 ? parts.join(', ') : 'completed';
 }
 
+/**
+ * Build a markdown report from the workflow result's ctx field.
+ * Extracted for testability — same logic used inside runWorkflow.
+ */
+export function buildReport(
+  result: Record<string, unknown> | null,
+  success: boolean,
+  stepLog?: import('./types.js').StepLogEntry[],
+): string | undefined {
+  try {
+    const ctxStr = result?.ctx as string | undefined;
+    if (!ctxStr) return undefined;
+    const ctx = JSON.parse(ctxStr);
+    const md: string[] = [];
+    md.push(`## ${success ? 'Task Completed' : 'Task Failed'}`);
+    md.push('');
+
+    // Steps
+    if (stepLog && stepLog.length > 0) {
+      md.push('### Steps');
+      md.push('');
+      for (const s of stepLog) {
+        const icon = s.status === 'ok' ? '**ok**' : s.status === 'error' ? '**error**' : '**blocked**';
+        md.push(`- ${s.step} (${icon})${s.detail ? `: ${s.detail}` : ''}`);
+      }
+      md.push('');
+    }
+
+    // Files
+    const files: string[] = ctx.filesModified ? JSON.parse(ctx.filesModified) : [];
+    if (files.length > 0) {
+      md.push('### Files Modified');
+      md.push('');
+      for (const f of files) md.push(`- \`${f}\``);
+      md.push('');
+    }
+
+    // Review
+    if (ctx.reviewJson) {
+      const review = JSON.parse(ctx.reviewJson) as Record<string, string>;
+      if (review.intent || review.execution || review.result || review.completeness) {
+        md.push('### Review');
+        md.push('');
+        for (const key of ['intent', 'execution', 'result', 'completeness']) {
+          if (review[key]) md.push(`- **${key}:** ${review[key]}`);
+        }
+        if (review.reason) md.push(`\n${review.reason}`);
+        md.push('');
+      }
+    }
+
+    return md.length > 2 ? md.join('\n') : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Extract stepLog and plan from the result's ctx field.
+ * Extracted for testability — same logic used inside runWorkflow.
+ */
+export function extractCtxData(result: Record<string, unknown> | null): {
+  stepLog?: import('./types.js').StepLogEntry[];
+  plan?: { summary: string; steps: Array<{ id: string; operation: string; description: string; args?: Record<string, unknown> }> };
+} {
+  try {
+    const ctxStr = result?.ctx as string | undefined;
+    if (!ctxStr) return {};
+    const ctx = JSON.parse(ctxStr);
+    let stepLog: import('./types.js').StepLogEntry[] | undefined;
+    let plan: { summary: string; steps: Array<{ id: string; operation: string; description: string; args?: Record<string, unknown> }> } | undefined;
+
+    if (ctx.stepLogJson) stepLog = JSON.parse(ctx.stepLogJson);
+    if (ctx.planJson) {
+      const parsed = JSON.parse(ctx.planJson);
+      if (parsed?.steps) {
+        plan = {
+          summary: parsed.summary ?? '',
+          steps: (parsed.steps as Array<Record<string, unknown>>).map((s) => ({
+            id: String(s.id ?? ''),
+            operation: String(s.operation ?? ''),
+            description: String(s.description ?? ''),
+            ...(s.args ? { args: s.args as Record<string, unknown> } : {}),
+          })),
+        };
+      }
+    }
+    return { stepLog, plan };
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Fallback: extract report from trace outputs (bot-report node's "Markdown report" port).
+ */
+export function extractReportFromTrace(
+  trace: Array<{ type: string; outputs?: unknown[] }>,
+): string | undefined {
+  for (const te of trace) {
+    if (te.type === 'node-complete' && te.outputs) {
+      for (const o of te.outputs) {
+        if (typeof o === 'object' && o && 'portLabel' in o) {
+          const po = o as { portLabel: string; value: unknown };
+          if (po.portLabel === 'Markdown report' && typeof po.value === 'string' && po.value.length > 0) {
+            return po.value;
+          }
+        }
+      }
+    }
+  }
+  return undefined;
+}
+
 export async function runWorkflow(
   filePath: string,
   options?: {
@@ -272,7 +386,7 @@ export async function runWorkflow(
           }
         }
       }
-      for (const inst of parseResult?.workflow?.instances ?? []) {
+      for (const inst of (parseResult?.workflows?.[0]?.instances ?? parseResult?.workflow?.instances ?? [])) {
         const label = inst.config?.label ?? nodeLabels.get(inst.nodeType);
         if (label) nodeLabels.set(inst.id, label);
         // Inherit visual meta from node type to instance
@@ -415,77 +529,17 @@ export async function runWorkflow(
     }
 
     // Extract stepLog and plan from WeaverContext if available
-    let stepLog: import('./types.js').StepLogEntry[] | undefined;
-    let plan: RunRecord['plan'] | undefined;
-    try {
-      const ctxStr = result?.ctx as string | undefined;
-      if (ctxStr) {
-        const ctx = JSON.parse(ctxStr);
-        if (ctx.stepLogJson) stepLog = JSON.parse(ctx.stepLogJson);
-        if (ctx.planJson) {
-          const parsed = JSON.parse(ctx.planJson);
-          if (parsed?.steps) {
-            plan = {
-              summary: parsed.summary ?? '',
-              steps: (parsed.steps as Array<Record<string, unknown>>).map((s) => ({
-                id: String(s.id ?? ''),
-                operation: String(s.operation ?? ''),
-                description: String(s.description ?? ''),
-                ...(s.args ? { args: s.args as Record<string, unknown> } : {}),
-              })),
-            };
-          }
-        }
-      }
-    } catch { /* extraction is best-effort */ }
+    const { stepLog, plan } = extractCtxData(result);
 
     // Build markdown report from the extracted context data
-    let report: string | undefined;
-    try {
-      const ctxStr = result?.ctx as string | undefined;
-      if (ctxStr) {
-        const ctx = JSON.parse(ctxStr);
-        const md: string[] = [];
-        md.push(`## ${success ? 'Task Completed' : 'Task Failed'}`);
-        md.push('');
-
-        // Steps
-        if (stepLog && stepLog.length > 0) {
-          md.push('### Steps');
-          md.push('');
-          for (const s of stepLog) {
-            const icon = s.status === 'ok' ? '**ok**' : s.status === 'error' ? '**error**' : '**blocked**';
-            md.push(`- ${s.step} (${icon})${s.detail ? `: ${s.detail}` : ''}`);
-          }
-          md.push('');
-        }
-
-        // Files
-        const files: string[] = ctx.filesModified ? JSON.parse(ctx.filesModified) : [];
-        if (files.length > 0) {
-          md.push('### Files Modified');
-          md.push('');
-          for (const f of files) md.push(`- \`${f}\``);
-          md.push('');
-        }
-
-        // Review
-        if (ctx.reviewJson) {
-          const review = JSON.parse(ctx.reviewJson) as Record<string, string>;
-          if (review.intent || review.execution || review.result || review.completeness) {
-            md.push('### Review');
-            md.push('');
-            for (const key of ['intent', 'execution', 'result', 'completeness']) {
-              if (review[key]) md.push(`- **${key}:** ${review[key]}`);
-            }
-            if (review.reason) md.push(`\n${review.reason}`);
-            md.push('');
-          }
-        }
+    let report = buildReport(result, success, stepLog);
 
-        if (md.length > 2) report = md.join('\n');
-      }
-    } catch { /* report generation is best-effort */ }
+    // Fallback: extract report from the bot-report node's trace output.
+    // The FW compiled workflow doesn't wire bot-report's report port to END,
+    // so result.report is undefined. But the trace captured all node outputs.
+    if (!report) {
+      report = extractReportFromTrace(collectedTrace);
+    }
 
     await notifier({
       type: 'workflow-complete',

package/src/bot/step-executor.ts

@@ -189,6 +189,8 @@ export async function executeStep(
       }
       assertSafePath(file, projectDir);
       const filePath = path.resolve(projectDir, file);
+      // Use the relative path for reporting — never leak absolute server paths
+      const relPath = path.relative(projectDir, filePath);
       const rawContent = args.content ?? args.body ?? '';
       if (typeof rawContent !== 'string') {
         return { blocked: true, blockReason: `${step.operation}: "content" must be a string, got ${typeof rawContent}.` };
@@ -197,14 +199,14 @@ export async function executeStep(
 
       const guard = checkWriteSafety(filePath, content);
       if (!guard.allowed) {
-        return { file: filePath, blocked: true, blockReason: guard.reason };
+        return { file: relPath, blocked: true, blockReason: guard.reason };
       }
 
       fs.mkdirSync(path.dirname(filePath), { recursive: true });
       const existed = fs.existsSync(filePath);
       fs.writeFileSync(filePath, content, 'utf-8');
       filesWrittenThisPlan++;
-      return { file: filePath, created: !existed };
+      return { file: relPath, created: !existed };
     }
 
     // -----------------------------------------------------------------
@@ -216,6 +218,7 @@ export async function executeStep(
       }
       assertSafePath(file, projectDir);
       const filePath = path.resolve(projectDir, file);
+      const relPath = path.relative(projectDir, filePath);
 
       if (!fs.existsSync(filePath)) {
         return { blocked: true, blockReason: `File not found: ${file}` };
@@ -263,7 +266,7 @@ export async function executeStep(
 
       if (applied === 0) {
         return {
-          file: filePath,
+          file: relPath,
           output: `No patches applied. Search strings not found: ${notFound.join('; ')}`,
         };
       }
@@ -274,7 +277,7 @@ export async function executeStep(
       if (originalSize > SHRINK_GUARD_MIN_SIZE && newSize < originalSize * MAX_SHRINK_RATIO) {
         const shrinkPct = Math.round((1 - newSize / originalSize) * 100);
         return {
-          file: filePath,
+          file: relPath,
           blocked: true,
           blockReason:
             `Refusing to patch ${path.basename(filePath)}: result (${newSize}B) ` +
@@ -288,7 +291,7 @@ export async function executeStep(
 
       const summary = `Applied ${applied}/${patches.length} patches` +
         (notFound.length ? `. Not found: ${notFound.join('; ')}` : '');
-      return { file: filePath, output: summary };
+      return { file: relPath, output: summary };
     }
 
     // -----------------------------------------------------------------
@@ -300,6 +303,7 @@ export async function executeStep(
       }
       assertSafePath(file, projectDir);
       const filePath = path.resolve(projectDir, file);
+      const relPath = path.relative(projectDir, filePath);
       if (!fs.existsSync(filePath)) {
         return { output: `File not found: ${file}` };
       }
@@ -313,9 +317,9 @@ export async function executeStep(
           return { output: `File too large to read (${stat.size} bytes, max ${MAX_READ_SIZE}). Use run_shell with head/tail instead.` };
         }
         const content = fs.readFileSync(filePath, 'utf-8');
-        return { file: filePath, output: content };
+        return { file: relPath, output: content };
       } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = (err instanceof Error ? err.message : String(err)).replaceAll(projectDir + '/', '');
         return { output: `Error reading file "${file}": ${msg}` };
       }
     }
@@ -356,8 +360,9 @@ export async function executeStep(
         const stdout = (execErr.stdout ?? '').trim();
         const stderr = (execErr.stderr ?? '').trim();
         const combined = [stdout, stderr].filter(Boolean).join('\n');
+        const raw = combined || (err instanceof Error ? err.message : String(err));
         return {
-          output: combined || (err instanceof Error ? err.message : String(err)),
+          output: raw.replaceAll(projectDir + '/', ''),
         };
       }
     }
@@ -379,7 +384,7 @@ export async function executeStep(
       try {
         entries = fs.readdirSync(targetDir, { recursive: true, encoding: 'utf-8' }) as string[];
       } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = (err instanceof Error ? err.message : String(err)).replaceAll(projectDir + '/', '');
         return { output: `Error listing directory "${dir}": ${msg}` };
       }
       let files = entries
@@ -456,6 +461,22 @@ export async function executeStep(
         parentId = resolved;
       }
 
+      // Idempotent: if a task with the same title and parentId already exists, return it
+      // instead of creating a duplicate. This prevents retry loops from producing duplicates.
+      if (parentId) {
+        const existing = (await store.list()).find(
+          t => t.parentId === parentId && t.title.toLowerCase() === title.toLowerCase(),
+        );
+        if (existing) {
+          if (symbolicIdMap) {
+            const symbolicKey = (args.symbolicId as string) ?? (args.id as string);
+            if (symbolicKey) symbolicIdMap[symbolicKey] = existing.id;
+            symbolicIdMap[title] = existing.id;
+          }
+          return { output: `Task "${title}" already exists (${existing.id}), skipped duplicate.` };
+        }
+      }
+
       // Resolve symbolic IDs in dependsOn through the map
       const rawDeps = (args.dependsOn as string[]) ?? [];
       const resolvedDeps = symbolicIdMap