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

package/src/bot/ai-client.ts

@@ -307,6 +307,48 @@ export async function callPlatformWithTools(
   };
 }
 
+// ---------------------------------------------------------------------------
+// Multi-turn message types for agent loop
+// ---------------------------------------------------------------------------
+
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content?: string | null;
+  /** For assistant messages with tool_use */
+  tool_use?: { id: string; name: string; input: Record<string, unknown> };
+  /** For tool result messages */
+  tool_use_id?: string;
+  /** For user messages containing tool results */
+  tool_results?: Array<{ tool_use_id: string; content: string }>;
+}
+
+/**
+ * Call the platform AI proxy with a full message history and tool definitions.
+ * Supports multi-turn conversations for agent loops.
+ * The AI can return text AND/OR structured tool calls.
+ */
+export async function callPlatformWithMessages(
+  messages: ChatMessage[],
+  tools: AiTool[],
+  model?: string,
+  maxTokens?: number,
+): Promise<AiCallResult> {
+  const provider = (globalThis as any).__fw_llm_provider__;
+  if (!provider) throw new Error('Platform AI provider not available');
+  const timeoutPromise = new Promise<never>((_, reject) =>
+    setTimeout(() => reject(new Error('AI call timeout (120s)')), AI_CALL_TIMEOUT_MS),
+  );
+  const response = await Promise.race([
+    provider.chat(messages, { model, maxTokens, tools }),
+    timeoutPromise,
+  ]);
+  reportUsage(response, model);
+  return {
+    content: response.content ?? '',
+    toolCalls: (response.toolCalls ?? []) as AiToolCall[],
+  };
+}
+
 /**
  * Unified AI call that dispatches to the right backend based on provider type.
  */
@@ -354,6 +396,29 @@ export async function callAIWithTools(
   return { content: text, toolCalls: [] };
 }
 
+/**
+ * Multi-turn AI call with full message history and tool definitions.
+ * For platform providers, uses the multi-turn callPlatformWithMessages.
+ * For other providers, falls back to single-turn callAIWithTools using the
+ * last user message (multi-turn not supported).
+ */
+export async function callAIWithMessages(
+  pInfo: Pick<ProviderInfo, 'type' | 'apiKey' | 'model' | 'maxTokens'>,
+  messages: ChatMessage[],
+  tools: AiTool[],
+  defaultMaxTokens = 4096,
+): Promise<AiCallResult> {
+  if (pInfo.type === 'platform') {
+    return callPlatformWithMessages(messages, tools, pInfo.model, pInfo.maxTokens ?? defaultMaxTokens);
+  }
+  // Fallback: extract system + last user message for single-turn call
+  const systemMsg = messages.find(m => m.role === 'system');
+  const userMsg = [...messages].reverse().find(m => m.role === 'user');
+  const systemPrompt = systemMsg?.content ?? '';
+  const userPrompt = typeof userMsg?.content === 'string' ? userMsg.content : JSON.stringify(userMsg?.content ?? '');
+  return callAIWithTools(pInfo, systemPrompt, userPrompt, tools, defaultMaxTokens);
+}
+
 export function parseJsonResponse(text: string): Record<string, unknown> {
   let cleaned = text.trim();
   if (cleaned.startsWith('```')) {

package/src/bot/behavior-defaults.ts

@@ -217,14 +217,17 @@ export function adjustBehaviorForComplexity(
   behavior: ProfileBehavior,
   complexity: 'trivial' | 'simple' | 'moderate' | 'complex' | undefined,
 ): ProfileBehavior {
-  if (!complexity || complexity === 'moderate' || complexity === 'complex') {
+  if (!complexity || complexity === 'moderate') {
     return behavior;
   }
 
   // Deep clone to avoid mutation
   const adjusted: ProfileBehavior = JSON.parse(JSON.stringify(behavior));
 
-  if (complexity === 'trivial') {
+  if (complexity === 'complex') {
+    // Complex: upgrade to powerful tier for plan phase (the critical thinking step)
+    if (adjusted.phases['plan']?.tier) adjusted.phases['plan'].tier = 'powerful';
+  } else if (complexity === 'trivial') {
     // Trivial: fast tier everywhere, skip review, 1 attempt, no evidence
     for (const phase of Object.values(adjusted.phases)) {
       if (phase.tier) phase.tier = 'fast';

package/src/bot/capability-registry.ts

@@ -48,35 +48,28 @@ const CAP_ROLE_ORCHESTRATOR: CapabilityDefinition = {
 You DECOMPOSE and ASSIGN. You never write code or create files directly.
 
 Your job:
-1. Analyze the objective and understand the project scope
-2. Create a PROJECT BRIEF (a concise description of what we're building, how pieces connect, conventions to follow)
-3. Break the objective into focused subtasks using task_create. The prompt contains "Task ID: <id>" — use that exact ID value as parentId in every task_create call so subtasks appear as children.
-4. ALWAYS set assignedProfile on every subtask to one of these three:
-   - "developer" → code writing, file creation, implementation
-   - "reviewer" → code review, quality checks, security audit
-   - "ops" → project setup, dependencies, config, infrastructure
-   NEVER set assignedProfile to "orchestrator". You are the orchestrator — assigning to yourself creates an infinite loop. Only "developer", "reviewer", or "ops".
-5. Set dependencies so tasks execute in the right order
-   Use the EXACT title of a previous subtask as the dependsOn value. The system resolves titles to real task IDs at execution time. Example: dependsOn: ["Setup: Initialize project structure"]
-6. Include the project brief in every subtask's description
-
-CRITICAL: You do NOT have write_file, patch_file, or run_shell. You cannot execute code — only plan and delegate to developer/reviewer/ops.
-
-### Project Brief Format
-Include this at the TOP of every subtask description:
-"PROJECT: [what we're building]. STRUCTURE: [file layout]. CONVENTIONS: [naming, patterns, exports]."
+1. Analyze the objective
+2. Break it into focused subtasks via task_create. Set parentId to "@self" on every subtask.
+3. ALWAYS set assignedProfile: "developer", "reviewer", or "ops".
+   NEVER set assignedProfile to "orchestrator" — assigning to yourself creates an infinite loop.
+4. Use the EXACT title of a previous subtask as dependsOn. The system resolves titles to real task IDs.
+5. Include a project brief in every subtask: "PROJECT: [what]. FILES: [exact paths from workspace root]. CONVENTIONS: [patterns]."
+
+CRITICAL: You do NOT have write_file, patch_file, or run_shell. Only plan and delegate.
+
+### Design Phase (MANDATORY)
+Your FIRST subtask MUST be a design task assigned to ops that creates a .design.md file in the project root. This is the single source of truth. It must contain:
+- Module map, TypeScript interfaces (copy-paste ready), export contracts (function signatures)
+- Dependency graph, conventions (naming, error handling, patterns)
+Every subsequent developer task MUST read .design.md before writing code.
 
 ### Subtask Quality
-Each subtask must be:
-- Focused (one file or one concern)
-- Self-contained (has enough context to execute independently)
-- Properly routed (assignedProfile is set)
-- Ordered (dependsOn reflects real dependencies)
+Each subtask: focused (one concern), self-contained, properly routed, ordered by dependsOn.
 
 ### Example
-For a task with Task ID "abc123":
-{ operation: "task_create", args: { title: "Setup project", parentId: "abc123", assignedProfile: "ops", dependsOn: [] } }
-{ operation: "task_create", args: { title: "Write code", parentId: "abc123", assignedProfile: "developer", dependsOn: ["Setup project"] } }`,
+{ operation: "task_create", args: { title: "Design: Create project contract", parentId: "@self", assignedProfile: "ops", complexity: "complex", description: "Create todo-app/.design.md with module map, TypeScript interfaces, export contracts.", dependsOn: [] } }
+{ operation: "task_create", args: { title: "Setup project", parentId: "@self", assignedProfile: "ops", dependsOn: ["Design: Create project contract"] } }
+{ operation: "task_create", args: { title: "Write code", parentId: "@self", assignedProfile: "developer", dependsOn: ["Setup project"] } }`,
 };
 
 const CAP_ROLE_DEVELOPER: CapabilityDefinition = {
@@ -86,17 +79,28 @@ const CAP_ROLE_DEVELOPER: CapabilityDefinition = {
 You WRITE CODE. Execute the task directly using write_file, patch_file, and run_shell.
 
 Your job:
-1. Read the task description (including the project brief)
-2. Create a plan with CONCRETE file operations (write_file, patch_file, run_shell)
-3. Execute every step — produce actual files on disk
-4. Verify your work compiles and is correct
+1. Read .design.md in the project root to understand interfaces and contracts
+2. Read files created by previous tasks (your dependencies are done — their files are on disk)
+3. Write code that MATCHES the contracts in .design.md exactly — same types, same function signatures, same exports
+4. Verify your imports resolve to real exports in existing files
 
 You do NOT have task_create. You cannot create subtasks or delegate.
 If the task seems too large, do your best — the orchestrator already decomposed it for you.
 
+### File Paths
+All paths in write_file/patch_file are RELATIVE TO THE WORKSPACE ROOT. If the task says "inside todo-app/", your paths MUST start with todo-app/ (e.g., todo-app/src/cli.ts, NOT src/cli.ts).
+
+### Code Quality
+- Write COMPLETE, WORKING code. No TODOs, no placeholders, no empty function bodies, no "// implement later".
+- Every function must be fully implemented with real logic.
+- Use proper TypeScript types. Use strict mode patterns.
+- Export everything that other files will import.
+- Handle edge cases (empty input, file not found, invalid args).
+- Use ESM-compatible patterns: import.meta.url instead of __dirname, import.meta.filename instead of __filename. Use fileURLToPath(import.meta.url) for path resolution.
+
 ### Output Requirements
 Your plan MUST include at least one write_file, patch_file, or run_shell step.
-A plan with only "respond" steps is a FAILURE — you must produce artifacts.`,
+A plan with only read_file, list_files, or respond steps is a FAILURE — you must produce artifacts.`,
 };
 
 const CAP_ROLE_REVIEWER: CapabilityDefinition = {
@@ -122,10 +126,19 @@ const CAP_ROLE_OPS: CapabilityDefinition = {
 You SET UP infrastructure — package.json, tsconfig.json, directory structure, dependencies.
 
 Your job:
-1. Initialize project structure (create config files, directories)
-2. Install dependencies with run_shell
-3. Ensure the project builds and tests can run
+1. Create the project directory first: run_shell with mkdir -p <project>/src
+2. Write config files (package.json, tsconfig.json) using write_file
+3. Install dependencies with run_shell (npm install)
+4. Ensure the project structure is ready for developers
 
+### File Paths
+All paths are RELATIVE TO THE WORKSPACE ROOT. If the project is in a subfolder (e.g., todo-app/), ALL your paths must include that prefix: todo-app/package.json, todo-app/tsconfig.json, todo-app/src/.
+
+### Design Tasks
+When the task is a Design task, create a .design.md file with detailed TypeScript interfaces, module exports, and dependency graph. This file must contain copy-paste ready interface definitions that developers will implement exactly.
+
+### Output Requirements
+Your plan MUST include write_file and/or run_shell steps that create real files.
 You do NOT have task_create. You execute infrastructure tasks directly.`,
 };
 

package/src/bot/file-validator.ts

@@ -1,3 +1,6 @@
+import { execFile } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { checkDesignQuality, type DesignReport } from './design-checker.js';
 import { fwValidate } from './fw-api.js';
 
@@ -17,6 +20,18 @@ export async function validateFiles(
 
   for (const file of files) {
     if (!file.endsWith('.ts')) continue;
+
+    // Only run FW validation on files that contain @flowWeaver annotations.
+    // Plain TypeScript files (like server.ts) should not be FW-validated.
+    const absFile = path.isAbsolute(file) ? file : path.resolve(projectDir, file);
+    let hasFwAnnotation = false;
+    try {
+      const content = fs.readFileSync(absFile, 'utf-8');
+      hasFwAnnotation = content.includes('@flowWeaver') || content.includes('@flow-weaver');
+    } catch { /* file read failed — skip FW validation */ }
+
+    if (!hasFwAnnotation) continue;
+
     try {
       const { valid, errors, warnings, ast } = await fwValidate(file);
 
@@ -39,3 +54,85 @@ export async function validateFiles(
 
   return results;
 }
+
+export interface TscValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+/**
+ * Find the tsc binary: prefer the project's own node_modules/.bin/tsc,
+ * then walk up parent directories, then fall back to a bare 'tsc' (PATH lookup).
+ */
+function findTscBin(projectDir: string): string | null {
+  let dir = projectDir;
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const candidate = path.join(dir, 'node_modules', '.bin', 'tsc');
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null; // caller will try bare 'tsc'
+}
+
+// Strip ANSI escape codes from tsc output
+function stripAnsi(str: string): string {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+export async function validateTypeScript(
+  projectDir: string,
+  opts?: { timeoutMs?: number },
+): Promise<TscValidationResult> {
+  const timeoutMs = opts?.timeoutMs ?? 30_000;
+
+  // Check for tsconfig.json
+  const tsconfigPath = path.join(projectDir, 'tsconfig.json');
+  if (!fs.existsSync(tsconfigPath)) {
+    return { valid: true, errors: [] };
+  }
+
+  const tscBin = findTscBin(projectDir) ?? 'tsc';
+
+  return new Promise<TscValidationResult>((resolve) => {
+    try {
+      const child = execFile(
+        tscBin,
+        ['--noEmit', '--pretty', 'false'],
+        { cwd: projectDir, timeout: timeoutMs, env: { ...process.env } },
+        (error, stdout, stderr) => {
+          if (!error) {
+            return resolve({ valid: true, errors: [] });
+          }
+
+          // If the process was killed (timeout) or spawn failed, graceful fallback
+          if (error.killed || (error as NodeJS.ErrnoException).code === 'ENOENT') {
+            return resolve({ valid: true, errors: [] });
+          }
+
+          // tsc exits with code 2 on type errors; parse stdout for error lines
+          const output = stripAnsi((stdout || '') + (stderr || ''));
+          const lines = output.split('\n').filter((l) => l.trim().length > 0);
+          if (lines.length === 0) {
+            return resolve({ valid: true, errors: [] });
+          }
+
+          // Strip absolute projectDir prefix so errors use relative paths
+          const cleaned = lines.map(l => l.replaceAll(projectDir + '/', ''));
+          return resolve({ valid: false, errors: cleaned });
+        },
+      );
+
+      // Extra safety: if the child can't even spawn
+      child.on('error', () => {
+        resolve({ valid: true, errors: [] });
+      });
+    } catch {
+      // execFile itself threw (e.g. bad args) — graceful fallback
+      resolve({ valid: true, errors: [] });
+    }
+  });
+}

package/src/bot/instance-manager.ts

@@ -1,6 +1,10 @@
 /**
- * InstanceManager — manages in-memory bot instances (workers) per profile.
- * Instances represent running workers that don't survive process restart.
+ * InstanceManager — manages a dynamic pool of generic worker slots.
+ *
+ * Workers are profile-agnostic: any worker can run any profile's task.
+ * The profile is loaded per-task at execution time, not per-worker.
+ *
+ * Worker naming: `worker-0`, `worker-1`, ... (no per-profile instances).
  */
 
 import type { BotProfile, BotInstance } from './profile-types.js';
@@ -8,7 +12,61 @@ import type { BotProfile, BotInstance } from './profile-types.js';
 export class InstanceManager {
   private instances = new Map<string, BotInstance>();
 
-  /** Spawn a new instance for the given profile. Throws if maxInstances reached. */
+  // -----------------------------------------------------------------------
+  // Worker pool API (new)
+  // -----------------------------------------------------------------------
+
+  /** Spawn a single generic worker slot at the given index. */
+  spawnWorker(index: number): BotInstance {
+    const instanceId = `worker-${index}`;
+    if (this.instances.has(instanceId)) {
+      throw new Error(`Worker already exists: ${instanceId}`);
+    }
+
+    const instance: BotInstance = {
+      instanceId,
+      profileId: '',  // No profile until a task is assigned
+      index,
+      status: 'idle',
+      tokensUsed: 0,
+      cost: 0,
+      tasksCompleted: 0,
+      tasksFailed: 0,
+    };
+
+    this.instances.set(instanceId, instance);
+    return { ...instance };
+  }
+
+  /** Spawn a pool of N generic workers (worker-0 through worker-N-1). */
+  spawnPool(size: number): BotInstance[] {
+    const spawned: BotInstance[] = [];
+    for (let i = 0; i < size; i++) {
+      spawned.push(this.spawnWorker(i));
+    }
+    return spawned;
+  }
+
+  /** Find any idle worker (profile-agnostic). Returns a copy or null. */
+  findIdleWorker(): BotInstance | null {
+    for (const inst of this.instances.values()) {
+      if (inst.status === 'idle') return { ...inst };
+    }
+    return null;
+  }
+
+  /** Return all idle workers. */
+  findIdleWorkers(): BotInstance[] {
+    return [...this.instances.values()]
+      .filter((i) => i.status === 'idle')
+      .map((i) => ({ ...i }));
+  }
+
+  // -----------------------------------------------------------------------
+  // Legacy per-profile API (kept for backward compat, used by tests)
+  // -----------------------------------------------------------------------
+
+  /** @deprecated Use spawnWorker/spawnPool instead. Spawn a profile-bound instance. */
   spawn(profile: BotProfile): BotInstance {
     const existing = this.listByProfile(profile.id);
     if (existing.length >= profile.maxInstances) {
@@ -36,6 +94,10 @@ export class InstanceManager {
     return { ...instance };
   }
 
+  // -----------------------------------------------------------------------
+  // Shared API
+  // -----------------------------------------------------------------------
+
   /** Get instance by ID (returns a copy), or null if not found. */
   get(instanceId: string): BotInstance | null {
     const inst = this.instances.get(instanceId);
@@ -61,17 +123,23 @@ export class InstanceManager {
       .map((i) => ({ ...i }));
   }
 
-  /** Mark an instance as executing a specific task/run. */
-  markExecuting(instanceId: string, taskId: string, runId: string): void {
+  /**
+   * Mark a worker as executing a specific task/run.
+   * @param profileId — the profile being loaded for this task execution.
+   */
+  markExecuting(instanceId: string, taskId: string, runId: string, profileId?: string): void {
     const inst = this.instances.get(instanceId);
     if (!inst) throw new Error(`Instance not found: ${instanceId}`);
     inst.status = 'executing';
     inst.currentTaskId = taskId;
     inst.currentRunId = runId;
     inst.startedAt = new Date().toISOString();
+    if (profileId !== undefined) {
+      inst.profileId = profileId;
+    }
   }
 
-  /** Mark an instance as idle after task completion/failure. */
+  /** Mark a worker as idle after task completion/failure. Clears profile association. */
   markIdle(instanceId: string, success: boolean): void {
     const inst = this.instances.get(instanceId);
     if (!inst) throw new Error(`Instance not found: ${instanceId}`);
@@ -79,6 +147,8 @@ export class InstanceManager {
     inst.currentTaskId = undefined;
     inst.currentRunId = undefined;
     inst.startedAt = undefined;
+    // Clear profile — worker is generic again
+    inst.profileId = '';
     if (success) {
       inst.tasksCompleted++;
     } else {
@@ -104,7 +174,7 @@ export class InstanceManager {
     this.instances.clear();
   }
 
-  /** Scale instances for a profile to the target count. Clamps to [0, maxInstances]. */
+  /** @deprecated No longer needed in pool model. Kept for backward compat. */
   scaleTo(profile: BotProfile, target: number): void {
     const clamped = Math.max(0, Math.min(target, profile.maxInstances));
     const current = this.listByProfile(profile.id);