daedalus-cli 3.63.1 → 3.64.0

package/dist/agents/orchestrator.js

@@ -3,35 +3,30 @@ import fs from 'fs';
 import path from 'path';
 import readline from 'readline';
 import { BUILTIN_TOOLS } from '../tools/definitions.js';
-import { getResolvedShellType } from '../tools/builtin/terminal.js';
 import { mcpRegistry } from '../tools/mcp/registry.js';
-import { executeToolCalls } from '../tools/executor.js';
 import { getAgentRole, filterToolsForRole, roleLabel, resolveRoleKey } from './roles.js';
-import { VALID_AGENT_ROLES } from '../tools/builtin/handoff.js';
 import { messageText } from '../types.js';
 import pc from 'picocolors';
 import { DaedalusSpinner } from '../tools/daedalus-spinner.js';
 import { errMessage } from '../utils/errors.js';
-import { parseTextToolCalls } from '../formatting.js';
-import { filterValidTasks, validateTasks, cleanTaskText, cleanPlanOutput, truncateGoal, extractFilePaths, buildDependencyGraph, groupIndependent, planNamesTestFiles, isUnnecessaryConfigTask, extractRequirements, getFrameworkGuidance, orphanedModuleWarning, } from './orchestrator-validation.js';
-import { isDeclaredError, verifyArtifacts, verifyArtifactsThoroughly, checkPlaceholders, fillPlaceholders, buildCleanSummary, isBuildErrorRelated, generateBuildErrorHint, runBuildVerification, attemptRepair, rollbackTaskPatches, verifySpecAssertions, isRealFile, } from './orchestrator-verification.js';
-import { generateSpecContract, loadSpecContract, formatSpecForPromptSafe } from './spec.js';
-import { SigmaMemEngine } from '../session/sigma-mem.js';
-import { getSigmaMemories } from '../session/sqlite.js';
+import { filterValidTasks, validateTasks, cleanTaskText, cleanPlanOutput, truncateGoal, extractFilePaths, buildDependencyGraph, groupIndependent, isUnnecessaryConfigTask, getFrameworkGuidance, } from './orchestrator-validation.js';
+import { runBuildVerification, isRealFile, } from './orchestrator-verification.js';
+import { generateSpecContract } from './spec.js';
 import { maskSecrets } from '../security/secret-detector.js';
-// Simplified placeholder regexes for common auto-fill tokens only
-// Simplified HTML placeholder regex for same tokens inside comments
+import { TaskDelegator } from './task-delegator.js';
 export class Orchestrator {
     router;
     messages;
     toolContext;
-    // Per-task tool context for the currently running sub-agent. allowTestEdits
-    // is derived from the task goal (see runAgent) so a parent goal that merely
-    // mentions "tests" does not disarm the test-suite lock for every sub-agent.
-    subContext;
     sessionManager;
     modelOverride;
-    results = [];
+    taskDelegator;
+    get results() {
+        return this.taskDelegator.results;
+    }
+    set results(val) {
+        this.taskDelegator.results = val;
+    }
     MAX_INITIAL_TASKS = 12;
     MAX_TOTAL_TASKS = 20;
     REPLAN_INTERVAL = 2;
@@ -41,33 +36,14 @@ export class Orchestrator {
         this.toolContext = toolContext;
         this.sessionManager = sessionManager;
         this.modelOverride = modelOverride;
+        this.taskDelegator = new TaskDelegator(this.router, this.toolContext, this.sessionManager, this.modelOverride, undefined, {
+            createPlan: (g, p) => this.createPlan(g, p),
+            parseDelegationTasks: (p, g) => this.parseDelegationTasks(p, g),
+            printTaskList: (t, f) => this.printTaskList(t, f),
+        });
     }
     async retryApiCall(fn, label, maxRetries = 2) {
-        let lastErr;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                return await fn();
-            }
-            catch (err) {
-                lastErr = err instanceof Error ? err : new Error(String(err));
-                const msg = String(lastErr.message || lastErr);
-                // If 400 Bad Request (e.g. model not in catalog) or 413 (payload too large), do not retry
-                if (msg.includes('400') || msg.includes('not in the catalog') || msg.includes('413') || msg.includes('request entity too large')) {
-                    throw lastErr;
-                }
-                if (attempt < maxRetries) {
-                    // Check for explicit 429 backoff retry seconds (e.g. "Retry in 29s")
-                    const rateLimitMatch = msg.match(/Retry in (\d+)s/i);
-                    let delay = Math.min(1000 * Math.pow(2, attempt), 8000);
-                    if (rateLimitMatch && rateLimitMatch[1]) {
-                        delay = (parseInt(rateLimitMatch[1], 10) + 1) * 1000;
-                    }
-                    console.log(pc.yellow(`\n[API Backoff] ${label} failed — ${msg.split('\n')[0]}. Waiting ${Math.round(delay / 1000)}s before retry (attempt ${attempt + 1}/${maxRetries})...`));
-                    await new Promise(r => setTimeout(r, delay));
-                }
-            }
-        }
-        throw lastErr;
+        return this.taskDelegator.getSubAgentRunner().retryApiCall(fn, label, maxRetries);
     }
     async discoverProjectContext() {
         const cwd = this.toolContext.projectRoot || process.cwd();
@@ -78,46 +54,35 @@ export class Orchestrator {
             if (pkg.dependencies) {
                 if (pkg.dependencies.next) {
                     const rawVer = pkg.dependencies.next;
-                    // Strip semver range operators (^, ~, >=, <=, >, <) before parsing
                     const cleaned = rawVer.replace(/^[^0-9]*/, '');
                     const major = parseInt(cleaned.split('.')[0]);
-                    const label = Number.isFinite(major) ? `Next.js ${major} (React, SSR)` : 'Next.js (React, SSR)';
-                    info.push(label);
+                    const isAppRouter = fs.existsSync(path.join(cwd, 'app'));
+                    info.push(`Next.js (v${rawVer}${major >= 13 ? (isAppRouter ? ' App Router' : ' Pages Router') : ''})`);
                 }
                 else if (pkg.dependencies.react) {
-                    info.push('React');
+                    info.push(`React (v${pkg.dependencies.react})`);
                 }
                 if (pkg.dependencies.vue)
-                    info.push('Vue');
-                if (pkg.dependencies.express)
-                    info.push('Express');
-                if (pkg.dependencies['@angular/core'])
-                    info.push('Angular');
-            }
-            if (pkg.devDependencies) {
-                if (pkg.devDependencies.vite)
-                    info.push('Vite');
-                if (pkg.devDependencies.typescript)
-                    info.push('TypeScript');
-                if (pkg.devDependencies.tailwindcss)
+                    info.push(`Vue (v${pkg.dependencies.vue})`);
+                if (pkg.dependencies.svelte)
+                    info.push(`Svelte (v${pkg.dependencies.svelte})`);
+                if (pkg.dependencies.tailwindcss || pkg.devDependencies?.tailwindcss)
                     info.push('Tailwind CSS');
+                if (pkg.dependencies['@prisma/client'] || pkg.devDependencies?.prisma)
+                    info.push('Prisma ORM');
+                if (pkg.dependencies.drizzle || pkg.devDependencies?.['drizzle-orm'])
+                    info.push('Drizzle ORM');
             }
-            const scripts = pkg.scripts ? Object.entries(pkg.scripts).map(([k, v]) => `${k}: ${v}`).join(', ') : 'none';
-            parts.push(`Framework: ${info.join(' | ') || 'unknown'}`);
-            parts.push(`Scripts: ${scripts}`);
+            if (info.length > 0)
+                parts.push(`Framework/Stack: ${info.join(', ')}`);
         }
-        catch { /* not a node project */ }
+        catch { /* no package.json or invalid JSON */ }
         try {
-            const entries = fs.readdirSync(cwd).filter(e => !e.startsWith('.') && e !== 'node_modules' && e !== 'ffmpeg');
-            const dirs = entries.filter(e => fs.statSync(path.join(cwd, e)).isDirectory());
-            const files = entries.filter(e => !fs.statSync(path.join(cwd, e)).isDirectory());
-            if (dirs.length > 0)
-                parts.push(`Directories: ${dirs.join(', ')}`);
-            if (files.length > 0)
-                parts.push(`Key files: ${files.join(', ')}`);
+            const entries = fs.readdirSync(cwd).filter(f => !f.startsWith('.') && f !== 'node_modules' && f !== 'dist');
+            parts.push(`Key directories: ${entries.slice(0, 8).join(', ')}`);
         }
-        catch { /* not readable */ }
-        return parts.length > 0 ? parts.join('\n') : '';
+        catch { /* unreadable directory */ }
+        return parts.join('\n');
     }
     async run(goal) {
         this.results = [];
@@ -138,7 +103,6 @@ export class Orchestrator {
                 return 'Orchestration stopped by user';
             }
             let tasks = this.parseDelegationTasks(plan, goal);
-            // Cap initial tasks — re-plan if the planner gets carried away
             if (tasks.length > this.MAX_INITIAL_TASKS) {
                 console.log(pc.yellow(`\nPlan has ${tasks.length} steps (max ${this.MAX_INITIAL_TASKS}). Asking planner to simplify...`));
                 plan = await this.createPlan(goal, projectContext, `Simplify to at most ${this.MAX_INITIAL_TASKS} focused steps. Merge related steps. Each step must produce real output.`);
@@ -153,7 +117,6 @@ export class Orchestrator {
             if (tasks.length === 0) {
                 return `Orchestration failed: planning produced no executable tasks for goal: ${goal}. The planner returned an empty or unparseable plan (delegate-to lines must name a known agent role, e.g. "delegate to Hephaestus: ...").`;
             }
-            // Pre-Flight Codebase Audit: Check if workspace has pre-existing compilation/build errors
             const preFlight = await runBuildVerification(this.toolContext, 0);
             const isNoInputsErr = preFlight.errorLogs && (preFlight.errorLogs.includes('TS18003') || preFlight.errorLogs.includes('No inputs were found'));
             if (!preFlight.success && preFlight.errorLogs && !isNoInputsErr) {
@@ -191,7 +154,6 @@ export class Orchestrator {
     async resume(goal, planText, tasks, startIndex, previousResults) {
         this.results = [...previousResults];
         const projectContext = await this.discoverProjectContext();
-        // Reset abort signal so resume works after a pause/crash
         Object.defineProperty(this.toolContext.abortSignal, 'aborted', { value: false, writable: true });
         tasks.forEach((t, idx) => {
             if (idx < startIndex) {
@@ -316,7 +278,6 @@ export class Orchestrator {
                     continue;
                 planText = content;
             }
-            // Validate the plan
             const testTasks = this.parseDelegationTasks(planText || `- delegate to ${roleLabel('coder')}: ${goal}`, goal);
             const validationError = validateTasks(testTasks, goal, this.toolContext.projectRoot);
             if (!validationError) {
@@ -365,14 +326,6 @@ export class Orchestrator {
                     return tasks.join('\n');
             }
         }
-        // If explicit target files are listed in the goal, split into file-focused tasks in fallback mode.
-        // Match paths like src/foo.ts, tests/foo.test.ts, public/index.html. Require a real extension and
-        // stop at whitespace/punctuation so "...in src/server.ts." yields "src/server.ts", not "src/server.ts.".
-        // IMPORTANT: references inside constraint phrases ("do not modify src/server.ts", "don't touch
-        // src/server.ts", "without changing src/server.ts", "leave src/server.ts alone", "existing
-        // endpoints in src/server.ts") must NOT become create/update targets — otherwise the planner spawns
-        // a mutation task for a file the user explicitly wants left untouched, which collides with the real
-        // file and confuses the coder. Strip those negative clauses first.
         const constraintRe = /(?:do\s+not\s+modify|don'?t\s+(?:touch|modify|change)|without\s+(?:changing|modifying)|leave\s+\S*\s+alone|existing\s+(?:endpoints?|files?|routes?)\s+(?:in|at)|keep\s+\S*\s+unchanged)[^.;]*?(?:src|tests|public|app|pages)\/[a-zA-Z0-9_\-]+\.[a-zA-Z0-9]+/gi;
         const constraintPaths = new Set((goal.match(constraintRe) || [])
             .map((m) => (m.match(/(?:src|tests|public|app|pages)\/[a-zA-Z0-9_\-]+\.[a-zA-Z0-9]+/) || [])[0])
@@ -421,7 +374,6 @@ export class Orchestrator {
         const running = tasks.filter(t => t.status === 'in_progress').length;
         const failed = tasks.filter(t => t.status === 'failed').length;
         const total = tasks.length;
-        // Only print full task list on initial plan, re-plan, or forced summary
         if (!forceFull && (running > 0 || completed > 0)) {
             const activeTask = tasks.find(t => t.status === 'in_progress');
             const activeText = activeTask ? ` | Active: [${roleLabel(activeTask.role)}] ${activeTask.goal.slice(0, 50)}...` : '';
@@ -461,19 +413,17 @@ export class Orchestrator {
             const isPending = t.status === undefined || t.status === 'pending';
             if (!isPending)
                 continue;
-            // Dependencies satisfied = all dependency goals are completed
             if (t.dependencies && t.dependencies.length > 0) {
                 const allDone = t.dependencies.every(dep => tasks.some(other => other.goal === dep && (other.status === 'completed' || other.status === 'skipped')));
                 if (!allDone)
                     continue;
             }
             batch.push(t);
-            // In auto-approve, gather at most 2 concurrent tasks to prevent API rate-limit storms
             if (process.env.DAEDALUS_AUTO_APPROVE === 'true' && batch.length < 2) {
                 continue;
             }
             else {
-                break; // max 2 concurrent or sequential
+                break;
             }
         }
         return batch;
@@ -483,7 +433,6 @@ export class Orchestrator {
         this.printTaskList(tasks);
         await this.delegateTask(task, tasks, originalGoal, projectContext);
         this.printTaskList(tasks);
-        // Handle task failure with auto-retry in auto-approve mode
         if (task.status === 'failed') {
             console.log(`\n${pc.bold(pc.red('--- Task Failure Checkpoint ---'))}`);
             console.log(`${pc.red('[ERROR] Task failed:')} ${task.role} - ${task.goal}`);
@@ -558,13 +507,11 @@ export class Orchestrator {
     }
     async executePlan(plan, tasks, startIndex = 0, originalGoal, projectContext) {
         let lastReplanCount = 0;
-        // Build dependency graph from file paths
         buildDependencyGraph(tasks);
         for (let i = startIndex; i < tasks.length; /* increment inside */) {
             if (this.toolContext.abortSignal.aborted) {
                 break;
             }
-            // Hard cap — stop adding new tasks past the limit
             if (i >= this.MAX_TOTAL_TASKS && tasks.filter(t => t.status === 'pending').length > 0) {
                 console.log(pc.yellow(`\nReached task limit (${this.MAX_TOTAL_TASKS}). Halting new task generation.`));
                 while (tasks.length > this.MAX_TOTAL_TASKS) {
@@ -577,12 +524,10 @@ export class Orchestrator {
                 break;
             }
             const task = tasks[i];
-            // Skip already completed/skipped tasks
             if (task.status === 'completed' || task.status === 'skipped') {
                 i++;
                 continue;
             }
-            // Skip unnecessary config tasks for file-based routing frameworks
             if (isUnnecessaryConfigTask(task, projectContext)) {
                 console.log(pc.yellow(`\nSkipping task ${i + 1}: Next.js uses file-based routing — no config changes needed`));
                 task.status = 'skipped';
@@ -590,14 +535,11 @@ export class Orchestrator {
                 i++;
                 continue;
             }
-            // Get the next batch of runnable tasks
             const batch = this.getNextBatch(tasks, i);
             if (batch.length === 0) {
-                // Deadlock or no pending tasks — advance past completed/skipped
                 i++;
                 continue;
             }
-            // In auto-approve mode, run independent tasks concurrently
             if (process.env.DAEDALUS_AUTO_APPROVE === 'true') {
                 const groups = groupIndependent(batch);
                 for (const group of groups) {
@@ -605,32 +547,26 @@ export class Orchestrator {
                 }
             }
             else {
-                // Interactive mode: sequential only
                 for (const t of batch) {
                     await this.executeSingleTask(t, tasks, originalGoal, projectContext);
                 }
             }
-            // Advance past all tasks that were just processed (no longer pending)
             while (i < tasks.length && tasks[i].status !== 'pending') {
                 i++;
             }
-            // Save state after completing tasks
             if (this.sessionManager) {
                 this.sessionManager.saveState('orchestrate_task_index', i);
                 this.sessionManager.saveState('orchestrate_results', this.results);
             }
-            // Re-plan checkpoint: after every REPLAN_INTERVAL completed tasks, re-evaluate
             const completedCount = tasks.filter(t => t.status === 'completed').length;
             if (completedCount > 0 && completedCount - lastReplanCount >= this.REPLAN_INTERVAL) {
                 const hasPending = tasks.some(t => t.status === 'pending' || t.status === 'in_progress');
                 if (hasPending && originalGoal) {
                     lastReplanCount = completedCount;
                     await this.replanRemaining(tasks, originalGoal, projectContext);
-                    // Rebuild dependency graph after replan
                     buildDependencyGraph(tasks);
                 }
             }
-            // Interactive checkpoint: ask user before next task
             if (process.env.DAEDALUS_AUTO_APPROVE !== 'true' && i < tasks.length) {
                 const prevTask = tasks[i - 1];
                 if (prevTask && prevTask.status === 'completed') {
@@ -671,11 +607,6 @@ export class Orchestrator {
                 }
             }
         }
-        // Guard against phantom success: if no task was ever delegated/executed
-        // (all skipped, or the plan collapsed to zero runnable tasks), surface a
-        // failure instead of letting run() print "Orchestration Complete" with no
-        // artifacts. Observed in the wild: a fallback plan parsed to tasks but the
-        // execution loop produced nothing, yet the run reported success.
         const executed = tasks.filter(t => t.status === 'completed' || t.status === 'in_progress').length;
         const anyDelegated = (this.results?.length ?? 0) > 0;
         if (executed === 0 && !anyDelegated) {
@@ -699,19 +630,16 @@ export class Orchestrator {
             const paths = extractFilePaths(r.summary);
             return paths;
         });
-        // Save original pending tasks as fallback in case replan fails
         const originalPending = tasks
             .filter(t => t.status === 'pending')
             .map(t => ({ ...t }));
         console.log(pc.cyan(`\n[RE-PLAN] ${pending.length} task(s) remaining. Re-evaluating based on completed work...`));
         const subPlan = await this.createPlan(`Original goal: ${originalGoal}\n\nCompleted so far:\n${summary}\n\nFiles already written: ${completedFiles.length > 0 ? completedFiles.join(', ') : '(none)'}\n\nRemaining:\n${remainingList}\n\nBased on what was completed, re-plan the remaining work. Consolidate and simplify — aim for at most ${this.MAX_INITIAL_TASKS} focused steps. Do NOT repeat tasks that are already done. Do NOT re-create files that already exist. Each remaining step must produce real output that has not been created yet.`, projectContext);
-        // Remove old pending tasks
         for (let i = tasks.length - 1; i >= 0; i--) {
             if (tasks[i].status === 'pending') {
                 tasks.splice(i, 1);
             }
         }
-        // Add new tasks from re-plan, dropping duplicates against completed work
         let newTasks = this.parseDelegationTasks(subPlan, originalGoal);
         newTasks = newTasks.filter(nt => {
             if (done.length === 0 || nt.role !== 'coder')
@@ -719,14 +647,11 @@ export class Orchestrator {
             const newPaths = extractFilePaths(nt.goal).map(p => p.toLowerCase());
             if (newPaths.length === 0)
                 return true;
-            // Only drop task if ALL mentioned files are REAL files on disk (>100 bytes, no placeholder comment shells)
             const root = this.toolContext.projectRoot || process.cwd();
             const allExist = newPaths.every(p => isRealFile(path.resolve(root, p)));
             return !allExist;
         });
-        // Enforce task cap and filter out non-actionable tasks
         newTasks = filterValidTasks(newTasks).slice(0, this.MAX_INITIAL_TASKS);
-        // Fallback: if replan produced no valid tasks, restore original pending tasks
         if (newTasks.length === 0 && originalPending.length > 0) {
             for (const t of originalPending) {
                 t.status = 'pending';
@@ -777,7 +702,6 @@ export class Orchestrator {
                 return 'debugger';
             return 'coder';
         };
-        // Primary: explicit "delegate to" / role-prefixed lines
         for (const line of lines) {
             const trimmedLine = line.trim();
             if (/^\s*tools?\s*used\b/i.test(trimmedLine))
@@ -797,7 +721,6 @@ export class Orchestrator {
                 currentGoal = goalPart.trim();
             }
             else if (currentRole && trimmedLine) {
-                // Only merge continuation lines that look like task detail, not standalone commentary
                 const isCommentary = trimmedLine.length > 60 && /^[A-Z]/.test(trimmedLine) && !/^(and|or|with|using|that|which|to|for|in|on|at)\b/i.test(trimmedLine);
                 if (!isCommentary) {
                     currentGoal += ' ' + trimmedLine;
@@ -807,7 +730,6 @@ export class Orchestrator {
         if (currentRole && currentGoal) {
             pushTask(currentRole, currentGoal, baseCtx, 0);
         }
-        // Fallback: plain numbered/bulleted list without explicit roles
         if (tasks.length === 0) {
             for (const line of lines) {
                 const trimmed = line.trim();
@@ -822,7 +744,6 @@ export class Orchestrator {
                     pushTask(role, body, baseCtx, 0);
                 }
                 else if (trimmed.length > 10) {
-                    // Only accept unformatted lines that contain an action verb
                     const hasActionVerb = /\b(create|write|build|implement|update|add|fix|generate|install|setup|configure|refactor|move|delete|rename)\b/i.test(trimmed);
                     if (hasActionVerb) {
                         pushTask('coder', trimmed, baseCtx, 0);
@@ -831,7 +752,6 @@ export class Orchestrator {
             }
         }
         if (tasks.length === 0) {
-            // Auto-extract multiple file mentions if present in goal (e.g. public/index.html, src/server.ts)
             const fileMatches = Array.from(goal.matchAll(/([A-Za-z0-9_\-/\\]+\.[a-zA-Z0-9]+)/g)).map(m => m[1]);
             const uniqueFiles = Array.from(new Set(fileMatches)).filter(f => !f.endsWith('.md') && !f.endsWith('.json'));
             if (uniqueFiles.length > 1) {
@@ -851,738 +771,14 @@ export class Orchestrator {
         }
         return tasks;
     }
-    findStyleReference(taskGoal) {
-        // Extract target directory from goal
-        let dir = '';
-        const fileMatch = taskGoal.match(/([A-Za-z0-9_\-/\\]+\.[a-zA-Z0-9]+)/);
-        if (fileMatch) {
-            dir = path.dirname(fileMatch[1].replace(/\\/g, '/'));
-        }
-        else {
-            const dirMatch = taskGoal.match(/(?:in|at|to|under|inside)\s+(?:the\s+)?([A-Za-z0-9_\-/\\]{2,})(?:\s+(?:directory|folder|path))?/i);
-            if (dirMatch) {
-                dir = dirMatch[1].replace(/\\/g, '/').replace(/\/+$/, '');
-            }
-        }
-        const checkDirForReference = (searchDir) => {
-            if (!searchDir || !fs.existsSync(searchDir) || searchDir === '.')
-                return null;
-            let entries;
-            try {
-                entries = fs.readdirSync(searchDir);
-            }
-            catch {
-                return null;
-            }
-            const candidates = entries
-                .filter(f => !f.startsWith('.') && !f.includes('.test.') && !f.includes('.spec.') && !f.startsWith('__'))
-                .sort();
-            const target = candidates.find(f => /\.(tsx?|jsx?|vue|svelte)$/i.test(f))
-                || candidates.find(f => /\.(css|scss|less)$/i.test(f))
-                || candidates[0];
-            if (!target)
-                return null;
-            const fullPath = path.join(searchDir, target);
-            if (fs.statSync(fullPath).isDirectory())
-                return null;
-            try {
-                let content = fs.readFileSync(fullPath, 'utf8');
-                const lines = content.split('\n');
-                if (lines.length > 80) {
-                    content = lines.slice(0, 80).join('\n') + '\n... (truncated)';
-                }
-                const isAppRouter = fs.existsSync(path.join(this.toolContext.projectRoot || process.cwd(), 'app'));
-                const antiPatterns = [
-                    /legacyBehavior/,
-                    /^\s*<[A-Za-z]/m,
-                ];
-                if (isAppRouter) {
-                    antiPatterns.push(/import\s+React\s+from\s+['"]react['"]/);
-                }
-                if (antiPatterns.some(re => re.test(content)))
-                    return null;
-                return { fullPath, content };
-            }
-            catch {
-                return null;
-            }
-        };
-        // 1. Try target directory
-        let ref = checkDirForReference(dir);
-        if (ref) {
-            return `\nExisting file in ${dir}/ (use as a style reference for structure and import order only):\n--- ${ref.fullPath} ---\n${ref.content}\n--- end ---`;
-        }
-        // 2. Try parent directory if target directory doesn't have reference
-        if (dir && dir !== '.' && dir !== '') {
-            const parentDir = path.dirname(dir);
-            ref = checkDirForReference(parentDir);
-            if (ref) {
-                return `\nExisting file in sibling/parent ${parentDir}/ (use as a style reference for structure and import order only):\n--- ${ref.fullPath} ---\n${ref.content}\n--- end ---`;
-            }
-        }
-        // 3. Try common directories in the project
-        const commonDirs = ['src/components', 'components', 'src/pages', 'pages', 'app', 'src', 'lib'];
-        for (const commonDir of commonDirs) {
-            const fullCommonDir = path.join(this.toolContext.projectRoot || process.cwd(), commonDir);
-            ref = checkDirForReference(fullCommonDir);
-            if (ref) {
-                return `\nExisting file in ${commonDir}/ (use as a style reference for structure and import order only):\n--- ${ref.fullPath} ---\n${ref.content}\n--- end ---`;
-            }
-        }
-        return null;
-    }
-    discoverDesignTokens() {
-        const cwd = this.toolContext.projectRoot || process.cwd();
-        let tokens = '';
-        // 1. Try to find tailwind config
-        const twConfigs = ['tailwind.config.js', 'tailwind.config.ts', 'tailwind.config.cjs'];
-        for (const configName of twConfigs) {
-            const fullPath = path.join(cwd, configName);
-            if (fs.existsSync(fullPath)) {
-                try {
-                    const content = fs.readFileSync(fullPath, 'utf8');
-                    const themeMatch = content.match(/theme\s*:\s*\{[\s\S]*?\}/);
-                    if (themeMatch) {
-                        tokens += `\nTailwind Theme Configuration (from ${configName}):\n${themeMatch[0]}\n`;
-                    }
-                    else {
-                        const lines = content.split('\n').slice(0, 40).join('\n');
-                        tokens += `\nTailwind Configuration Snippet (from ${configName}):\n${lines}\n`;
-                    }
-                    break;
-                }
-                catch { /* ignore */ }
-            }
-        }
-        // 2. Try to find CSS custom properties in global CSS files
-        const commonCssDirs = ['src', 'app', 'styles', 'src/styles', '.'];
-        const cssFileNames = ['globals.css', 'global.css', 'index.css', 'app.css', 'main.css'];
-        for (const dirName of commonCssDirs) {
-            for (const fileName of cssFileNames) {
-                const fullPath = path.join(cwd, dirName, fileName);
-                if (fs.existsSync(fullPath)) {
-                    try {
-                        const content = fs.readFileSync(fullPath, 'utf8');
-                        const rootMatches = content.match(/:root\s*\{[\s\S]*?\}/g);
-                        if (rootMatches && rootMatches.length > 0) {
-                            tokens += `\nDesign Tokens / CSS Variables (from ${dirName}/${fileName}):\n${rootMatches.join('\n')}\n`;
-                        }
-                        break;
-                    }
-                    catch { /* ignore */ }
-                }
-            }
-            if (tokens)
-                break;
-        }
-        return tokens;
-    }
-    pickMemoryCategory(task) {
-        const goal = task.goal;
-        if (task.role === 'debugger' || /fix|debug|repair|resolve/i.test(goal))
-            return 'fix_resolution';
-        if (task.role === 'reviewer' || /verify|test|review|validate|inspect/i.test(goal))
-            return 'build_rule';
-        if (task.role === 'planner' || /spec|contract|interface/i.test(goal))
-            return 'schema_contract';
-        return 'code_pattern';
-    }
-    getTaskRelatedSigmaIds(db, activeIds, task) {
-        if (activeIds.length === 0)
-            return [];
-        const active = new Set(activeIds);
-        const paths = extractFilePaths(task.goal).map(p => p.toLowerCase());
-        const keywords = task.goal
-            .split(/[^a-zA-Z0-9]+/)
-            .map(k => k.toLowerCase())
-            .filter(k => k.length >= 3);
-        const hasOverlap = (tags) => {
-            for (const tag of tags) {
-                const t = tag.toLowerCase();
-                if (paths.some(p => p.includes(t) || t.includes(p)))
-                    return true;
-                if (keywords.some(k => k.includes(t) || t.includes(k)))
-                    return true;
-            }
-            return false;
-        };
-        const related = new Set();
-        for (const row of getSigmaMemories(db, 0, 200)) {
-            if (!active.has(row.id))
-                continue;
-            let tags = [];
-            try {
-                const parsed = JSON.parse(row.tags);
-                if (Array.isArray(parsed))
-                    tags = parsed.map(String);
-            }
-            catch { /* unparseable tags */ }
-            if (hasOverlap(tags))
-                related.add(row.id);
-        }
-        return activeIds.filter(id => related.has(id));
-    }
     async delegateTask(task, tasks, goal, projectContext) {
-        const role = getAgentRole(task.role);
-        console.log(`\n[SPAWN] Delegating to ${roleLabel(role.name)}: ${task.goal}`);
-        const tools = filterToolsForRole([...BUILTIN_TOOLS, ...mcpRegistry.getToolDefinitions()], task.role);
-        const historyStartIndex = this.toolContext.patchHistory?.length || 0;
-        // Inject user metadata so the agent has real values instead of guessing
-        const currentDate = new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
-        let enrichedContext = `Current date: ${currentDate}\n`;
-        const projectRoot = this.toolContext.projectRoot || this.sessionManager?.projectRoot || process.cwd();
-        const specContract = loadSpecContract(projectRoot);
-        if (specContract) {
-            // Use the staleness-aware formatter: a spec whose referenced files don't exist is a
-            // PLAN, not current code state. Injecting it as authoritative makes the agent report
-            // the spec's intended design as real "findings" (see hallucinated helmet/TODO claims).
-            enrichedContext += `\n${formatSpecForPromptSafe(specContract, projectRoot)}\n`;
-        }
-        // Surface the ACTUAL shell the terminal tool runs in. The static terminal tool
-        // description says "bash syntax", but on Windows the model frequently overrides that
-        // and emits PowerShell/cmd syntax ($null, Select-String, { } blocks) which the bash
-        // (git-bash/MSYS) shell rejects — a retry → circuit-breaker → model-upgrade spiral.
-        // Stating the resolved shell explicitly stops the model from guessing wrong.
-        const shellType = getResolvedShellType();
-        if (shellType === 'bash') {
-            enrichedContext += '\n[SHELL] Terminal commands run in BASH (git-bash/MSYS) on this Windows host. Use bash syntax ONLY — NOT PowerShell/cmd. Specifically: use "$" for variables (never "$null"), avoid "Select-String"/"Where-Object", and never use PowerShell "{ ... }" script blocks. Example: ls -la dir || echo "missing".\n';
-        }
-        else if (shellType === 'powershell') {
-            enrichedContext += '\n[SHELL] Terminal commands run in POWERSHELL. Use PowerShell syntax ($, $null, Select-String are valid). Avoid bash-only constructs like "2>/dev/null" (use "2>$null").\n';
-        }
-        else {
-            enrichedContext += '\n[SHELL] Terminal commands run in CMD (Windows command prompt). Use cmd.exe syntax (not bash, not PowerShell). Use "dir", "2>nul", "if exist".\n';
-        }
-        // Build systemExtra with project context — system prompt is more authoritative than user message
-        const frameworkBlock = projectContext
-            ? `Follow the project framework conventions (e.g., Next.js pages go under pages/, Vue components under components/).\n`
-            : '';
-        // Surface relevant past lessons as context (cap to most-used to save tokens)
-        const lessons = this.sessionManager ? this.sessionManager.getFailureLessons(task.role) : [];
-        const topLesson = lessons.length > 0 ? lessons.sort((a, b) => ((b.used_count || 0) - (a.used_count || 0)))[0] : null;
-        if (topLesson) {
-            enrichedContext += `[LESSON] Previously failed on: "${topLesson.error_snippet}" -> resolution: ${topLesson.resolution} (occurred ${topLesson.used_count}x)\n`;
-        }
-        // Inject an existing file from the target dir as a style reference only for non-trivial tasks
-        const styleRef = this.findStyleReference(task.goal);
-        if (styleRef) {
-            enrichedContext += styleRef;
-        }
-        // Discover and inject design tokens if coder task
-        if (task.role === 'coder') {
-            const designTokens = this.discoverDesignTokens();
-            if (designTokens) {
-                enrichedContext += designTokens;
-            }
-        }
-        // Extract explicit requirements from the task goal only
-        const taskReqs = extractRequirements(task.goal);
-        if (taskReqs.length > 0) {
-            enrichedContext += `\nRequirements:\n${taskReqs.slice(0, 4).map(r => `  - ${r}`).join('\n')}\n`;
-        }
-        // NO FILLER CONTENT — the requirements above must be implemented with real content
-        if (taskReqs.length > 0 && task.role === 'coder') {
-            enrichedContext += `\nCRITICAL: You MUST implement every requirement above with real, specific content. Do NOT use generic filler like "Welcome to our platform", "We provide services", "Learn more about us", or placeholder text. Each requirement needs actual concrete content that a real business would publish.\n`;
-        }
-        // Extract explicit file paths from the goal and inject a concise scope boundary
-        const scopePaths = extractFilePaths(task.goal);
-        if (scopePaths.length > 0) {
-            enrichedContext += `\nSCOPE: only touch ${scopePaths.join(', ')}. Do NOT create a parallel module (e.g. a './foo/index.ts' beside an existing 'src/foo.ts') or expand into an unrelated refactor — if you find broken/duplicate adjacent code, fix the existing file in place.`;
-        }
-        // Warn if the task targets an existing route/module file that nothing imports.
-        // Edits to an orphaned module are silent no-ops at runtime (the app never loads it).
-        const orphanWarn = this.toolContext.projectRoot
-            ? orphanedModuleWarning(task.goal, this.toolContext.projectRoot)
-            : null;
-        if (orphanWarn) {
-            enrichedContext += `\n${orphanWarn}`;
-        }
-        enrichedContext += `\n${frameworkBlock}${task.context}`;
-        const frameworkRules = getFrameworkGuidance(projectContext, this.toolContext.projectRoot);
-        let sigmaMemBlock = '';
-        let activeSigmaMemoryIds = [];
-        const sigmaDb = SigmaMemEngine.resolveProjectMemDb(this.sessionManager, this.toolContext.projectRoot);
-        if (sigmaDb) {
-            const sigmaRes = SigmaMemEngine.getPromptContext(sigmaDb, task.role, 0.60, 5, extractFilePaths(task.goal));
-            sigmaMemBlock = sigmaRes.prompt;
-            activeSigmaMemoryIds = sigmaRes.activeMemoryIds;
-            SigmaMemEngine.markMemoriesUsed(sigmaDb, activeSigmaMemoryIds);
-        }
-        const systemExtra = `Project context:\n${projectContext || '(none discovered)'}${frameworkRules}${sigmaMemBlock}\n`;
-        // Prepend a terse override reminder so the rules land in the user message too,
-        // which some models weight more heavily than the system prompt extension.
-        if (frameworkRules && task.role === 'coder') {
-            enrichedContext = `IMPORTANT: The CODING RULES in your system context are mandatory and override any patterns you observe in style reference files or your training data.\n\n` + enrichedContext;
-        }
-        let result = await this.runAgent(role, task.goal, enrichedContext, tools, systemExtra);
-        // Lightweight ensemble: in ensemble mode, run a second coder at higher temp and pick the best
-        if (process.env.DAEDALUS_ENSEMBLE === 'true' && task.role === 'coder' && !this.toolContext.abortSignal.aborted) {
-            const firstPatches = this.toolContext.patchHistory?.slice(historyStartIndex) || [];
-            const firstCount = firstPatches.length;
-            const secondRole = { ...role, temperature: 0.5 };
-            const secondResult = await this.runAgent(secondRole, task.goal, enrichedContext, tools, systemExtra);
-            const secondPatches = this.toolContext.patchHistory?.slice(historyStartIndex) || [];
-            const secondCount = secondPatches.length;
-            if (secondCount > firstCount) {
-                // Second candidate produced more artifacts — use its result
-                result = secondResult;
-            }
-            else {
-                // First candidate was better — revert second candidate's patches
-                if (this.toolContext.patchHistory) {
-                    this.toolContext.patchHistory.length = historyStartIndex + firstCount;
-                }
-            }
-        }
-        if (this.toolContext.abortSignal.aborted) {
-            this.results.push({
-                role: task.role,
-                goal: task.goal,
-                summary: 'Task aborted by user',
-                success: false,
-            });
-            task.status = 'failed';
-            task.error = 'Task aborted by user';
-            return;
-        }
-        const MAX_TURNS_SIGNAL = 'Agent reached max turns';
-        const PATCH_ABORT_PREFIX = 'Agent aborted: too many patch failures';
-        if (result.startsWith(PATCH_ABORT_PREFIX)) {
-            task.status = 'failed';
-            task.error = result.split('\n')[0];
-            if (task.role === 'coder' || task.role === 'debugger') {
-                await rollbackTaskPatches(this.toolContext, historyStartIndex);
-            }
-            this.results.push({ role: task.role, goal: task.goal, summary: result, success: false });
-            console.log(`[${pc.red('FAILED')}] ${role.name}: ${task.error}`);
-            return;
-        }
-        if (result === MAX_TURNS_SIGNAL) {
-            const partialWork = (this.toolContext.patchHistory?.length ?? 0) > historyStartIndex;
-            const depth = task.splitDepth ?? 0;
-            if (partialWork && depth < 3 && tasks) {
-                console.log(`\n${pc.yellow('Task exceeded turn limit with partial progress.')} Splitting remaining work (depth ${depth + 1})...`);
-                const newPatches = this.toolContext.patchHistory?.slice(historyStartIndex) || [];
-                const filesDone = [...new Set(newPatches.map(p => p.filePath).filter(Boolean))];
-                task.status = 'completed';
-                this.results.push({
-                    role: task.role,
-                    goal: task.goal,
-                    summary: 'Partially completed — splitting remaining work into sub-tasks',
-                    success: true,
-                });
-                const doneCtx = filesDone.length > 0 ? `\nPartially completed files: ${filesDone.join(', ')}` : '';
-                const subPlan = await this.createPlan(`Continue the remaining work for: ${task.goal}${doneCtx}\nThe previous agent only got partial work done before hitting the turn limit. Break this into smaller, focused steps.`, projectContext);
-                const subTasks = this.parseDelegationTasks(subPlan, goal || task.goal);
-                const currentIndex = (tasks || []).indexOf(task);
-                const doneBeforeSplit = (tasks || []).filter((t, idx) => t.status === 'completed' && idx < currentIndex);
-                const deduped = subTasks.filter(st => {
-                    if (doneBeforeSplit.length === 0 || st.role !== 'coder')
-                        return true;
-                    const newPaths = extractFilePaths(st.goal).map(p => p.toLowerCase());
-                    if (newPaths.length === 0)
-                        return true;
-                    return !doneBeforeSplit.some(d => {
-                        if (d.role !== 'coder')
-                            return false;
-                        const donePaths = extractFilePaths(d.goal).map(p => p.toLowerCase());
-                        return donePaths.some(dp => newPaths.includes(dp));
-                    });
-                });
-                const inheritCtx = filesDone.length > 0
-                    ? `Original goal: ${task.goal}\nProject root: ${this.toolContext.projectRoot || process.cwd()}\n\nIMPORTANT — Files that were partially created and MUST be completed or replaced:\n${filesDone.map(f => `  - ${f}`).join('\n')}\n\nThe previous agent left these files incomplete before hitting the turn limit. You MUST read each file, then either complete it with a proper implementation or replace it entirely. Check the existing project structure first — use read_file on existing files to understand what's already there before creating new ones.`
-                    : `Original goal: ${task.goal}\nProject root: ${this.toolContext.projectRoot || process.cwd()}\n\nCheck the existing project structure first — use read_file on existing files to understand what's already there before creating new ones.`;
-                for (const st of deduped) {
-                    st.status = 'pending';
-                    st.splitDepth = depth + 1;
-                    st.context = `${inheritCtx}\n\n${st.context}`;
-                    tasks.push(st);
-                }
-                this.printTaskList(tasks);
-                return;
-            }
-            task.status = 'failed';
-            task.error = partialWork
-                ? `Task still too large after ${depth} splits — manual review needed`
-                : 'Task too large and no work completed';
-            if (task.role === 'coder' || task.role === 'debugger') {
-                await rollbackTaskPatches(this.toolContext, historyStartIndex);
-            }
-            this.results.push({
-                role: task.role,
-                goal: task.goal,
-                summary: task.error,
-                success: false,
-            });
-            return;
-        }
-        let verified = await verifyArtifacts(this.toolContext, task.role, task.goal, result, historyStartIndex);
-        let evidence = '';
-        let placeholderSites = [];
-        let checkLogs = '';
-        if (verified) {
-            placeholderSites = await checkPlaceholders(this.toolContext, historyStartIndex);
-            if (placeholderSites.length > 0) {
-                console.log(pc.yellow(`\nFound ${placeholderSites.length} placeholder(s) in written files`));
-                // Auto-fill trivial placeholders like [Year], [Your Name]
-                const filled = await fillPlaceholders(this.toolContext, historyStartIndex);
-                if (filled > 0) {
-                    console.log(pc.green(`  Auto-filled ${filled} trivial placeholder(s) (year, name, etc.)`));
-                }
-                // Re-check for remaining (structural) placeholders
-                placeholderSites = await checkPlaceholders(this.toolContext, historyStartIndex);
-                if (placeholderSites.length === 0) {
-                    verified = true;
-                }
-                else {
-                    verified = false;
-                }
-            }
-        }
-        if (verified && (task.role === 'coder' || task.role === 'debugger') && (this.toolContext.patchHistory?.length ?? 0) > historyStartIndex) {
-            const checkResult = await runBuildVerification(this.toolContext, historyStartIndex);
-            if (!checkResult.success) {
-                const modifiedFiles = this.toolContext.patchHistory.slice(historyStartIndex).map(p => p.filePath);
-                const isRelated = isBuildErrorRelated(checkResult.errorLogs || '', modifiedFiles, this.toolContext.projectRoot);
-                if (isRelated) {
-                    verified = false;
-                    checkLogs = (checkResult.errorLogs || 'Build check failed') + generateBuildErrorHint(checkResult.errorLogs || '');
-                }
-                else {
-                    console.log(pc.yellow(`\n[VERIFY] Build check failed, but errors appear to be in unrelated files. Ignoring build failure for this task.`));
-                }
-            }
-            if (verified) {
-                const specResult = await verifySpecAssertions(this.toolContext.projectRoot || process.cwd());
-                if (!specResult.success) {
-                    console.log(pc.yellow(`\n[SpecFirst] Spec contract assertion check failed!`));
-                    verified = false;
-                    checkLogs = (specResult.errorLogs || 'Spec contract check failed');
-                }
-            }
-        }
-        if (!verified) {
-            let repairCtx = task.context;
-            if (placeholderSites.length > 0) {
-                const siteList = placeholderSites.map(s => `  - ${s}`).join('\n');
-                repairCtx += `\n\nPrevious attempt contained placeholders instead of real content:\n${siteList}\n\nYou MUST replace ALL placeholders with real content. Never output placeholder text like [Year], [Your Name], etc. Use actual values.`;
-            }
-            if (checkLogs) {
-                repairCtx += `\n\nPrevious attempt failed build/compilation verification. The check failed with the following error output:\n\`\`\`\n${checkLogs}\n\`\`\`\nPlease fix the build/compilation errors listed above.`;
-            }
-            const repaired = await attemptRepair({ toolContext: this.toolContext, runAgent: (role, goal, context, tools) => this.runAgent(role, goal, context, tools) }, task, {
-                summary: result,
-            }, repairCtx, historyStartIndex);
-            result = repaired.summary;
-            verified = repaired.success;
-            evidence = repaired.evidence || '';
-            if (verified) {
-                const stillPlaceholders = await checkPlaceholders(this.toolContext, historyStartIndex);
-                if (stillPlaceholders.length > 0) {
-                    // Try auto-fill one more time after repair
-                    const filled = await fillPlaceholders(this.toolContext, historyStartIndex);
-                    if (filled > 0)
-                        console.log(pc.green(`  Auto-filled ${filled} remaining trivial placeholder(s)`));
-                    const remain = await checkPlaceholders(this.toolContext, historyStartIndex);
-                    if (remain.length > 0) {
-                        verified = false;
-                        evidence = `Placeholders remain: ${remain.join('; ')}`;
-                    }
-                }
-            }
-        }
-        const resultForCheck = result.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
-        const success = verified && !isDeclaredError(resultForCheck) && verifyArtifactsThoroughly(this.toolContext, task.role, task.goal, resultForCheck, historyStartIndex);
-        if (success) {
-            const clean = buildCleanSummary(this.toolContext, task, result, historyStartIndex);
-            if (clean)
-                result = clean;
-            if (this.sessionManager?.projectMemDb) {
-                const related = this.getTaskRelatedSigmaIds(this.sessionManager.projectMemDb, activeSigmaMemoryIds, task);
-                SigmaMemEngine.rewardSuccessfulPass(this.sessionManager.projectMemDb, related.length > 0 ? related : activeSigmaMemoryIds);
-                SigmaMemEngine.recordVerifiedKnowledge(this.sessionManager.projectMemDb, {
-                    agentRole: task.role,
-                    category: this.pickMemoryCategory(task),
-                    tags: extractFilePaths(task.goal),
-                    summary: cleanTaskText(task.goal),
-                    content: result.slice(0, 300),
-                });
-            }
-        }
-        task.status = success ? 'completed' : 'failed';
-        if (!success) {
-            task.error = resultForCheck.split('\n')[0] || result.split('\n')[0] || 'Unknown failure';
-            if (this.sessionManager?.projectMemDb) {
-                const related = this.getTaskRelatedSigmaIds(this.sessionManager.projectMemDb, activeSigmaMemoryIds, task);
-                if (related.length > 0) {
-                    SigmaMemEngine.penalizeFailedAttempt(this.sessionManager.projectMemDb, related, task.error?.slice(0, 280));
-                }
-            }
-            // Rollback patches made during this task to keep codebase clean
-            if (task.role === 'coder' || task.role === 'debugger') {
-                await rollbackTaskPatches(this.toolContext, historyStartIndex);
-            }
-            // Log failure as a lesson for self-improvement
-            if (this.sessionManager) {
-                try {
-                    this.sessionManager.saveFailureLesson({
-                        task_role: task.role,
-                        goal_keywords: task.goal.split(' ').slice(0, 5).join(' '),
-                        error_snippet: task.error.slice(0, 200),
-                        resolution: 'Pending — retry may succeed with different approach',
-                    });
-                }
-                catch { /* session not available */ }
-            }
-        }
-        this.results.push({
-            role: task.role,
-            goal: task.goal,
-            summary: result,
-            success,
-            ...(evidence ? { evidence } : {}),
-        });
-        if (success) {
-            console.log(`[${pc.green('OK')}] ${role.name} completed`);
-        }
-        else {
-            console.log(`[${pc.red('FAILED')}] ${role.name}: ${task.error || 'verification failed'}`);
-        }
-        // Post-task review if task touched files — now BLOCKING for coder tasks
-        if (success && this.sessionManager && task.role !== 'reviewer') {
-            try {
-                const reviewerRole = getAgentRole('reviewer');
-                if (reviewerRole && !reviewerRole.canDelegate) {
-                    const touchedFiles = (this.toolContext.patchHistory || [])
-                        .filter((h) => h.filePath)
-                        .map((h) => h.filePath);
-                    const fileList = touchedFiles.length > 0
-                        ? `\nFILES_TOUCHED: ${touchedFiles.join(', ')}`
-                        : '';
-                    const truncatedResult = result.length > 6000 ? result.slice(0, 6000) + '\n...[result truncated for review]' : result;
-                    const reviewContext = `TASK: ${task.goal}\n\nAgent result:\n${truncatedResult}${fileList}\n\nReview the files that were touched for this task. Use git_diff or list files modified recently. Check for syntax errors, correctness, and project health.`;
-                    const reviewTools = filterToolsForRole([...BUILTIN_TOOLS, ...mcpRegistry.getToolDefinitions()], 'reviewer');
-                    const review = await this.runAgent(reviewerRole, `Review files from task: ${task.goal}`, reviewContext, reviewTools);
-                    // Parse reviewer verdict
-                    const statusMatch = review.match(/STATUS:\s*(PASS|NEEDS_FIX|STOP)/i);
-                    const verdict = statusMatch?.[1]?.toUpperCase() || 'PASS';
-                    // BLOCKING: if reviewer found issues on a coder task, trigger a repair pass
-                    if ((verdict === 'NEEDS_FIX' || verdict === 'STOP') && (task.role === 'coder' || task.role === 'debugger')) {
-                        console.log(pc.yellow(`\n[REVIEWER] Found issues — triggering repair pass...`));
-                        const findingsMatch = review.match(/FINDINGS:([\s\S]*?)(?:RECOMMENDATION:|$)/i);
-                        const findings = findingsMatch?.[1]?.trim() || review;
-                        const repairGoal = `Fix the following reviewer findings in the files you just wrote for task: "${task.goal}"\n\nFINDINGS:\n${findings}\n\nApply targeted fixes only. Do not change unrelated code.`;
-                        const coderRole = getAgentRole('coder');
-                        if (coderRole) {
-                            const repairTools = filterToolsForRole([...BUILTIN_TOOLS, ...mcpRegistry.getToolDefinitions()], 'coder');
-                            await this.runAgent(coderRole, repairGoal, reviewContext, repairTools);
-                            console.log(pc.green(`[REPAIR] Repair pass complete.`));
-                        }
-                    }
-                    // Update project status from review
-                    try {
-                        const buildStatus = /build.*pass|no errors|pass/i.test(review) ? 'passing' : 'needs_attention';
-                        this.sessionManager.saveProjectStatus({
-                            build_status: buildStatus,
-                            test_status: /test.*pass|no failures/i.test(review) ? 'passing' : 'unknown',
-                            key_concerns: review.split('\n').filter(l => /ERROR|FAIL|STOP|needs_fix/i.test(l)).slice(0, 3).join('; '),
-                            last_reviewed_at: Date.now(),
-                        });
-                    }
-                    catch { /* status save failed, non-critical */ }
-                }
-            }
-            catch { /* review failed, non-critical */ }
-        }
+        return this.taskDelegator.delegateTask(task, tasks, goal, projectContext);
     }
     async runAgent(role, goal, context, tools, systemExtra) {
-        const currentDateStr = new Date().toLocaleString();
-        // Build the system prompt for a given active role. Reused when a
-        // handoff_task mutates subContext.agentRole mid-run so the new role's
-        // system prompt and tool set actually take effect on subsequent turns.
-        const buildSystemPrompt = (activeRole) => {
-            let prompt = `${activeRole.systemPrompt}\n\n## CURRENT TIME\nThe current date and local time is: ${currentDateStr}.\n`;
-            const projectRoot = this.toolContext.projectRoot || this.sessionManager?.projectRoot;
-            if (projectRoot) {
-                const filesToCheck = ['CLAUDE.md', '.cursorrules', '.daedalusrules', 'DAEDALUS.md'];
-                let rules = '';
-                for (const file of filesToCheck) {
-                    const fullPath = path.join(projectRoot, file);
-                    if (fs.existsSync(fullPath)) {
-                        try {
-                            const content = fs.readFileSync(fullPath, 'utf8').trim();
-                            if (content) {
-                                rules += `\n### Rules from ${file}:\n${content}\n`;
-                            }
-                        }
-                        catch {
-                            // Ignore unreadable rule file
-                        }
-                    }
-                }
-                if (rules) {
-                    prompt += `\n## PROJECT-SPECIFIC GUIDELINES\n${rules}`;
-                }
-            }
-            if (systemExtra) {
-                prompt += `\n${systemExtra}\n`;
-            }
-            const cv = this.subContext?.contextVariables;
-            if (cv && Object.keys(cv).length > 0) {
-                prompt += `\n## SHARED CONTEXT VARIABLES\nThe following state bag is shared across turns and handoffs. Honor it in your work:\n${JSON.stringify(cv, null, 2)}`;
-            }
-            return prompt;
-        };
-        // Mutable active role — a handoff_task call can transfer control to another role.
-        let currentRole = role;
-        const dynamicSystemPrompt = buildSystemPrompt(currentRole);
-        const messages = [
-            { role: 'system', content: dynamicSystemPrompt },
-            { role: 'user', content: `${context}\n\nTask: ${goal}` },
-        ];
-        // Derive test-suite write permission from THIS task's goal, not the parent
-        // autopilot goal. The planner must EXPLICITLY name a test file as a
-        // deliverable for this task (spec contract) — a goal that merely mentions
-        // "tests" must not disarm the lock (that is how an empty test file slipped
-        // through on an autonomous run). Live user approval (testApprovalGranted)
-        // still wins for the session.
-        const taskTestIntent = planNamesTestFiles(goal);
-        this.subContext = {
-            ...this.toolContext,
-            allowTestEdits: this.toolContext.testApprovalGranted ? true : taskTestIntent,
-        };
-        // Re-filter the tool set for the (possibly handoff-switched) active role,
-        // preserving any extra tools the caller passed in (e.g. MCP definitions).
-        let activeTools = filterToolsForRole(tools, currentRole.name);
-        let turns = 0;
-        let maxTurns = currentRole.maxTurns ?? 10;
-        const patchFailures = new Map();
-        const taskStartHistoryLength = this.toolContext.patchHistory?.length || 0;
-        let idleReadTurn = -1;
-        while (turns < maxTurns) {
-            if (this.toolContext.abortSignal.aborted) {
-                return 'Agent execution aborted by user';
-            }
-            const agentSpinner = new DaedalusSpinner({ text: `${roleLabel(currentRole.name)} running (turn ${turns + 1})`, color: (s) => pc.cyan(s) });
-            agentSpinner.start();
-            let completion;
-            const isLastTurn = turns === maxTurns - 1;
-            const currentTools = isLastTurn ? undefined : (activeTools.length > 0 ? activeTools : undefined);
-            const currentToolChoice = isLastTurn ? undefined : ((currentRole.name === 'coder' || currentRole.name === 'debugger') && turns === 0 ? 'required' : 'auto');
-            try {
-                completion = await this.retryApiCall(() => this.router.chat.completions.create({
-                    model: this.modelOverride || 'auto',
-                    complexity: this.modelOverride ? undefined : 'complex',
-                    messages,
-                    temperature: currentRole.temperature ?? 0.1,
-                    tools: currentTools,
-                    tool_choice: currentToolChoice,
-                }), `${currentRole.name} API call`);
-            }
-            finally {
-                agentSpinner.stop();
-            }
-            if (!completion || !completion.choices || completion.choices.length === 0) {
-                return 'Agent completed without response';
-            }
-            const message = completion.choices[0].message;
-            messages.push(message);
-            let effectiveToolCalls = message.tool_calls || [];
-            if (!effectiveToolCalls.length && message.content) {
-                const parsed = parseTextToolCalls(messageText(message.content));
-                if (parsed.length > 0) {
-                    effectiveToolCalls = parsed;
-                }
-            }
-            if (effectiveToolCalls.length > 0) {
-                const results = await executeToolCalls(effectiveToolCalls.map((tc) => ({
-                    id: tc.id,
-                    type: 'function',
-                    function: { name: tc.function.name, arguments: tc.function.arguments },
-                })), this.subContext);
-                // Dynamic handoff: handoff_task mutated subContext.agentRole. If it
-                // switched to a different valid role, re-role this runAgent instance so
-                // subsequent turns run with the new agent's system prompt + tool set.
-                const switchedRole = this.subContext?.agentRole;
-                if (switchedRole && switchedRole !== currentRole.name && VALID_AGENT_ROLES.includes(switchedRole)) {
-                    const nextRole = getAgentRole(switchedRole);
-                    currentRole = nextRole;
-                    maxTurns = currentRole.maxTurns ?? 10;
-                    // Re-filter from the FULL tool set (not the caller-filtered `tools` param,
-                    // which is scoped to the original role) so the new role gains its own tools.
-                    activeTools = filterToolsForRole([...BUILTIN_TOOLS, ...mcpRegistry.getToolDefinitions()], currentRole.name);
-                    messages[0] = { role: 'system', content: buildSystemPrompt(currentRole) };
-                    console.log(pc.magenta(`\n[HANDOFF] ${switchedRole} agent took over the execution turn`));
-                }
-                // Track patch failures per file to break retry spirals
-                let hadPatchFailure = false;
-                let patchFailureFile;
-                for (const result of results) {
-                    if (/patch.*Syntax error introduced|error TS\d+/.test(result.content || '')) {
-                        hadPatchFailure = true;
-                        const fileMatch = (result.content || '').match(/src\/([^\s(]+)/);
-                        patchFailureFile = fileMatch ? fileMatch[1] : undefined;
-                    }
-                }
-                if (hadPatchFailure && patchFailureFile) {
-                    const prev = patchFailures.get(patchFailureFile) || 0;
-                    patchFailures.set(patchFailureFile, prev + 1);
-                    if (prev + 1 >= 3) {
-                        return `Agent aborted: too many patch failures on ${patchFailureFile}.\nLast error from patch tool: ${results.find(r => /patch.*Syntax error/.test(r.content || ''))?.content || 'unknown'}\nFix the TypeScript error in that file before retrying.`;
-                    }
-                }
-                else if (!hadPatchFailure) {
-                    for (const [file] of Array.from(patchFailures)) {
-                        patchFailures.set(file, 0);
-                    }
-                }
-                for (const result of results) {
-                    let rawContent = typeof result.content === 'string' ? result.content : JSON.stringify(result.content);
-                    if (!result.success && result.error) {
-                        rawContent = `${rawContent}\n\n[Tool Error] ${result.error}`;
-                    }
-                    const cappedContent = rawContent.length > 8000
-                        ? rawContent.slice(0, 8000) + '\n...[content truncated to prevent oversized request]'
-                        : rawContent;
-                    messages.push({
-                        role: 'tool',
-                        content: maskSecrets(cappedContent),
-                        tool_call_id: result.toolCallId,
-                    });
-                }
-                // Early-exit: after artifacts exist, if agent spends 2+ turns on read-only tools, it's done
-                const hasArtifacts = this.toolContext.patchHistory && this.toolContext.patchHistory.length > taskStartHistoryLength;
-                const hasArtifactTool = effectiveToolCalls.some((tc) => /^(write_file|patch|terminal)$/i.test(tc.function.name));
-                if (hasArtifacts && hasArtifactTool) {
-                    idleReadTurn = -1;
-                }
-                else if (hasArtifacts && !hasArtifactTool) {
-                    if (idleReadTurn === -1)
-                        idleReadTurn = turns;
-                    else if (turns - idleReadTurn >= 3) {
-                        return 'Agent completed';
-                    }
-                }
-                turns++;
-                continue;
-            }
-            // No tool calls on this turn
-            const responseText = messageText(message.content);
-            // If tools were provided but the model refused to use them, give it a firm nudge
-            if (tools.length > 0 && turns === 0 && /sorry|can'?t|cannot|don'?t have|not (able|capable)|lack(|ing) (the )?(necessary |required )?(tools|capabilities)|unable|apologize/i.test(responseText)) {
-                messages.push({
-                    role: 'user',
-                    content: 'You have tools available to complete this task. Use read_file, write_file, search_files, terminal, and other tools as needed. Do not apologize or refuse — just use the tools to accomplish the task.',
-                });
-                turns++;
-                continue;
-            }
-            return responseText || 'Agent completed without response';
-        }
-        return `Agent reached max turns${this.toolContext.maxTurnsCause ? ` (cause: ${this.toolContext.maxTurnsCause})` : ''}`;
+        return this.taskDelegator.getSubAgentRunner().runAgent(role, goal, context, tools, systemExtra);
     }
     async executeOpenAIToolCalls(toolCalls) {
-        return executeToolCalls(toolCalls, this.subContext ?? this.toolContext);
+        return this.taskDelegator.getSubAgentRunner().executeOpenAIToolCalls(toolCalls);
     }
     synthesize(goal) {
         if (this.toolContext.abortSignal.aborted) {