attocode 0.2.2 → 0.2.4

package/dist/src/integrations/swarm/swarm-orchestrator.js

@@ -16,34 +16,113 @@
  * - State persistence and resume
  * - Orchestrator decision logging
  */
-import { createSmartDecomposer, parseDecompositionResponse } from '../smart-decomposer.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createSmartDecomposer, parseDecompositionResponse, validateDecomposition } from '../smart-decomposer.js';
 import { createResultSynthesizer } from '../result-synthesizer.js';
-import { taskResultToAgentOutput, DEFAULT_SWARM_CONFIG, SUBTASK_TO_CAPABILITY } from './types.js';
+import { taskResultToAgentOutput, DEFAULT_SWARM_CONFIG, getTaskTypeConfig } from './types.js';
 import { createSwarmTaskQueue } from './task-queue.js';
 import { createSwarmBudgetPool } from './swarm-budget.js';
 import { createSwarmWorkerPool } from './worker-pool.js';
-import { evaluateWorkerOutput } from './swarm-quality-gate.js';
+import { evaluateWorkerOutput, runPreFlightChecks, checkArtifacts, checkArtifactsEnhanced, runConcreteChecks } from './swarm-quality-gate.js';
 import { ModelHealthTracker, selectAlternativeModel } from './model-selector.js';
 import { SwarmStateStore } from './swarm-state-store.js';
+import { createSharedContextState } from '../../shared/shared-context-state.js';
+import { createSharedEconomicsState } from '../../shared/shared-economics-state.js';
+import { createSharedContextEngine } from '../../shared/context-engine.js';
+import { classifySwarmFailure } from './failure-classifier.js';
 // ─── Hollow Completion Detection ──────────────────────────────────────────
 /**
- * V10: Minimal hollow completion detection — let the quality gate judge everything else.
- * Only catches truly empty completions: zero tool calls AND trivial output (<50 chars).
- * No task-type lists, no closure report checks, no hardcoded thresholds beyond the bare minimum.
+ * V11: Hollow completion detection — catches empty completions AND "success" with failure language.
+ * Zero tool calls AND trivial output is always hollow.
+ * Additionally, success=true but output containing failure admissions is also hollow —
+ * this catches workers that report success but actually did no useful work.
  */
-export function isHollowCompletion(spawnResult) {
+const FAILURE_INDICATORS = [
+    'budget exhausted', 'unable to complete', 'could not complete',
+    'ran out of budget', 'no changes were made', 'no files were modified',
+    'no files were created', 'failed to complete', 'before research could begin',
+    'i was unable to', 'i could not', 'unfortunately i',
+];
+const BOILERPLATE_INDICATORS = [
+    'task completed successfully', 'i have completed the task',
+    'the task has been completed', 'done', 'completed', 'finished',
+    'no issues found', 'everything looks good', 'all tasks completed',
+];
+function hasFutureIntentLanguage(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return false;
+    const lower = trimmed.toLowerCase();
+    const completionSignals = /\b(done|completed|finished|created|saved|wrote|implemented|fixed|updated|added)\b/;
+    if (completionSignals.test(lower))
+        return false;
+    const futureIntentPatterns = [
+        /\b(i\s+will|i'll|let me)\s+(create|write|save|update|modify|fix|add|edit|implement|change|run|execute|build|continue)\b/,
+        /\b(i\s+need to|i\s+should|i\s+can)\s+(create|write|update|modify|fix|add|edit|implement|continue)\b/,
+        /\b(next step|remaining work|still need|to be done)\b/,
+        /\b(i am going to|i'm going to)\b/,
+    ];
+    return futureIntentPatterns.some(p => p.test(lower));
+}
+function repoLooksUnscaffolded(baseDir) {
+    try {
+        const packageJson = path.join(baseDir, 'package.json');
+        const srcDir = path.join(baseDir, 'src');
+        if (!fs.existsSync(packageJson) && !fs.existsSync(srcDir)) {
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+export function isHollowCompletion(spawnResult, taskType, swarmConfig) {
     // Timeout uses toolCalls === -1, not hollow
-    if (spawnResult.metrics.toolCalls === -1)
+    if ((spawnResult.metrics.toolCalls ?? 0) === -1)
         return false;
-    // Only catch truly empty completions: zero tools AND trivial output
-    return spawnResult.metrics.toolCalls === 0
-        && (spawnResult.output?.trim().length ?? 0) < 50;
+    const toolCalls = spawnResult.metrics.toolCalls ?? 0;
+    // Truly empty completions: zero tools AND trivial output
+    // P4: Higher threshold (120 chars) + configurable via SwarmConfig
+    const hollowThreshold = swarmConfig?.hollowOutputThreshold ?? 120;
+    if (toolCalls === 0
+        && (spawnResult.output?.trim().length ?? 0) < hollowThreshold) {
+        return true;
+    }
+    // P4: Boilerplate detection — zero tools AND short output that's just boilerplate
+    if (toolCalls === 0 && (spawnResult.output?.trim().length ?? 0) < 300) {
+        const outputLower = (spawnResult.output ?? '').toLowerCase().trim();
+        if (BOILERPLATE_INDICATORS.some(b => outputLower.includes(b))) {
+            return true;
+        }
+    }
+    // "Success" that admits failure: worker claims success but output contains failure language
+    if (spawnResult.success) {
+        const outputLower = (spawnResult.output ?? '').toLowerCase();
+        if (FAILURE_INDICATORS.some(f => outputLower.includes(f))) {
+            return true;
+        }
+    }
+    // V7: Use configurable requiresToolCalls from TaskTypeConfig.
+    // For action-oriented tasks (implement/test/refactor/etc), zero tool calls is ALWAYS hollow.
+    if (taskType) {
+        const typeConfig = getTaskTypeConfig(taskType, swarmConfig);
+        if (typeConfig.requiresToolCalls && toolCalls === 0) {
+            return true;
+        }
+    }
+    return false;
 }
 // ─── Orchestrator ──────────────────────────────────────────────────────────
 export class SwarmOrchestrator {
     config;
     provider;
     blackboard;
+    // Phase 3.1+3.2: Shared state for cross-worker learning
+    sharedContextState;
+    sharedEconomicsState;
+    sharedContextEngine;
     taskQueue;
     budgetPool;
     workerPool;
@@ -61,10 +140,15 @@ export class SwarmOrchestrator {
     retries = 0;
     startTime = 0;
     modelUsage = new Map();
+    // Orchestrator's own LLM usage (separate from worker usage)
+    orchestratorTokens = 0;
+    orchestratorCost = 0;
+    orchestratorCalls = 0;
     // V2: Planning, review, verification, health, persistence
     plan;
     waveReviews = [];
     verificationResult;
+    artifactInventory;
     orchestratorDecisions = [];
     healthTracker;
     stateStore;
@@ -75,25 +159,96 @@ export class SwarmOrchestrator {
     static CIRCUIT_BREAKER_WINDOW_MS = 30_000;
     static CIRCUIT_BREAKER_THRESHOLD = 3;
     static CIRCUIT_BREAKER_PAUSE_MS = 15_000;
-    // Quality gate circuit breaker: disable quality gates after too many consecutive rejections
-    consecutiveQualityRejections = 0;
-    qualityGateDisabled = false;
-    static QUALITY_CIRCUIT_BREAKER_THRESHOLD = 8;
+    // P3: Per-model quality gate circuit breaker (replaces global circuit breaker)
+    perModelQualityRejections = new Map();
+    qualityGateDisabledModels = new Set();
+    static QUALITY_CIRCUIT_BREAKER_THRESHOLD = 5;
+    // Hollow completion streak: early termination when single-model swarm produces only hollows
+    hollowStreak = 0;
+    static HOLLOW_STREAK_THRESHOLD = 3;
+    // V7: Global dispatch + hollow ratio tracking for multi-model termination
+    totalDispatches = 0;
+    totalHollows = 0;
+    // Hollow ratio warning (fired once, then suppressed to avoid log spam)
+    hollowRatioWarned = false;
+    // P7: Adaptive dispatch stagger — increases on rate limits, decreases on success
+    adaptiveStaggerMs = 0; // Initialized from config in constructor
+    // F25: Consecutive timeout tracking per task — early-fail after limit
+    taskTimeoutCounts = new Map();
+    // Original prompt for re-planning on resume
+    originalPrompt = '';
+    // Mid-swarm re-planning: only once per swarm execution
+    hasReplanned = false;
     constructor(config, provider, agentRegistry, spawnAgentFn, blackboard) {
         this.config = { ...DEFAULT_SWARM_CONFIG, ...config };
         this.provider = provider;
         this.blackboard = blackboard;
         this.spawnAgentFn = spawnAgentFn;
         this.healthTracker = new ModelHealthTracker();
+        this.adaptiveStaggerMs = this.getStaggerMs();
+        // Phase 3.1+3.2: Shared context & economics for cross-worker learning
+        this.sharedContextState = createSharedContextState({
+            staticPrefix: 'You are a swarm worker agent.',
+            maxFailures: 100,
+            maxReferences: 200,
+        });
+        this.sharedEconomicsState = createSharedEconomicsState({
+            globalDoomLoopThreshold: 10,
+        });
+        this.sharedContextEngine = createSharedContextEngine(this.sharedContextState, {
+            maxFailuresInPrompt: 5,
+            includeInsights: true,
+        });
         this.taskQueue = createSwarmTaskQueue();
         this.budgetPool = createSwarmBudgetPool(this.config);
-        this.workerPool = createSwarmWorkerPool(this.config, agentRegistry, spawnAgentFn, this.budgetPool);
+        this.workerPool = createSwarmWorkerPool(this.config, agentRegistry, spawnAgentFn, this.budgetPool, this.healthTracker, this.sharedContextEngine);
         // Initialize state store if persistence enabled
         if (this.config.enablePersistence) {
             this.stateStore = new SwarmStateStore(this.config.stateDir ?? '.agent/swarm-state', this.config.resumeSessionId);
         }
         // C1: Build LLM decompose function with explicit JSON schema
-        const llmDecompose = async (task, _context) => {
+        const llmDecompose = async (task, context) => {
+            // V7: Dynamically build the allowed type list from built-in + user-defined types
+            const builtinTypes = ['research', 'analysis', 'design', 'implement', 'test', 'refactor', 'review', 'document', 'integrate', 'deploy', 'merge'];
+            const customTypes = Object.keys(this.config.taskTypes ?? {}).filter(t => !builtinTypes.includes(t));
+            const allTypes = [...builtinTypes, ...customTypes];
+            const typeListStr = allTypes.map(t => `"${t}"`).join(' | ');
+            // Build custom type descriptions so the LLM knows when to use them
+            let customTypeSection = '';
+            if (customTypes.length > 0) {
+                const descriptions = customTypes.map(t => {
+                    const cfg = this.config.taskTypes[t];
+                    const parts = [`  - "${t}"`];
+                    if (cfg.capability)
+                        parts.push(`(capability: ${cfg.capability})`);
+                    if (cfg.promptTemplate)
+                        parts.push(`— uses ${cfg.promptTemplate} workflow`);
+                    if (cfg.timeout)
+                        parts.push(`— timeout: ${Math.round(cfg.timeout / 60000)}min`);
+                    return parts.join(' ');
+                }).join('\n');
+                customTypeSection = `\n\nCustom task types available:\n${descriptions}\nUse these when their description matches the subtask's purpose.`;
+            }
+            // Build codebase context section from repo map if available
+            let codebaseSection = '';
+            if (context.repoMap) {
+                const map = context.repoMap;
+                const topFiles = Array.from(map.chunks.values())
+                    .sort((a, b) => b.importance - a.importance)
+                    .slice(0, 30)
+                    .map(c => `  - ${c.filePath} (${c.type}, ${c.tokenCount} tokens, importance: ${c.importance.toFixed(2)})`);
+                codebaseSection = `
+
+CODEBASE STRUCTURE (${map.chunks.size} files, ${map.totalTokens} total tokens):
+Entry points: ${map.entryPoints.slice(0, 5).join(', ')}
+Core modules: ${map.coreModules.slice(0, 5).join(', ')}
+Key files:
+${topFiles.join('\n')}
+
+CRITICAL: Your subtasks MUST reference actual files from this codebase.
+Do NOT invent new project scaffolding or create files that don't relate to the existing codebase.
+Decompose the work based on what ALREADY EXISTS in the project.`;
+            }
             const systemPrompt = `You are a task decomposition expert. Break down the given task into well-defined subtasks with clear dependencies.
 
 CRITICAL: Dependencies MUST use zero-based integer indices referring to other subtasks in the array.
@@ -103,7 +258,7 @@ Respond with valid JSON matching this exact schema:
   "subtasks": [
     {
       "description": "Clear description of what this subtask does",
-      "type": "implement" | "research" | "analysis" | "design" | "test" | "refactor" | "review" | "document" | "integrate" | "deploy" | "merge",
+      "type": ${typeListStr},
       "complexity": 1-10,
       "dependencies": [0, 1],
       "parallelizable": true | false,
@@ -112,7 +267,7 @@ Respond with valid JSON matching this exact schema:
   ],
   "strategy": "sequential" | "parallel" | "hierarchical" | "adaptive" | "pipeline",
   "reasoning": "Brief explanation of why this decomposition was chosen"
-}
+}${customTypeSection}${codebaseSection}
 
 EXAMPLE 1 — Research task (3 parallel research + 1 merge):
 {
@@ -149,11 +304,52 @@ Rules:
                 { role: 'user', content: task },
             ], {
                 model: this.config.orchestratorModel,
-                maxTokens: 4000,
+                maxTokens: 16000,
                 temperature: 0.3,
             });
+            this.trackOrchestratorUsage(response, 'decompose');
             // Use parseDecompositionResponse which handles markdown code blocks and edge cases
-            return parseDecompositionResponse(response.content);
+            const result = parseDecompositionResponse(response.content);
+            // If decomposition returned 0 subtasks, log diagnostics and retry with explicit JSON instruction
+            if (result.subtasks.length === 0) {
+                const snippet = response.content?.slice(0, 500) ?? '(empty response)';
+                const parseError = result.parseError ?? 'unknown';
+                this.errors.push({
+                    phase: 'decomposition',
+                    message: `LLM returned no subtasks. Parse error: ${parseError}. Response preview: ${snippet}`,
+                    recovered: true,
+                });
+                this.emit({
+                    type: 'swarm.orchestrator.decision',
+                    decision: {
+                        timestamp: Date.now(),
+                        phase: 'decomposition',
+                        decision: `Empty decomposition — retrying with explicit JSON instruction`,
+                        reasoning: `Parse error: ${parseError}. Response preview (first 500 chars): ${snippet}`,
+                    },
+                });
+                // Retry with explicit JSON instruction — don't include previous truncated response (wastes input tokens)
+                const retryResponse = await this.provider.chat([
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: `${task}\n\nIMPORTANT: Your previous attempt was truncated or could not be parsed (${parseError}). Return ONLY a raw JSON object with NO markdown formatting, NO explanation text, NO code fences. The JSON must have a "subtasks" array with at least 2 entries matching the schema above. Keep subtask descriptions concise to avoid truncation.` },
+                ], {
+                    model: this.config.orchestratorModel,
+                    maxTokens: 16000,
+                    temperature: 0.2,
+                });
+                this.trackOrchestratorUsage(retryResponse, 'decompose-retry');
+                const retryResult = parseDecompositionResponse(retryResponse.content);
+                if (retryResult.subtasks.length === 0) {
+                    const retrySnippet = retryResponse.content?.slice(0, 500) ?? '(empty response)';
+                    this.errors.push({
+                        phase: 'decomposition',
+                        message: `Retry also returned no subtasks. Response preview: ${retrySnippet}`,
+                        recovered: false,
+                    });
+                }
+                return retryResult;
+            }
+            return result;
         };
         // Configure decomposer for swarm use
         const decomposer = createSmartDecomposer({
@@ -171,6 +367,18 @@ Rules:
     getBudgetPool() {
         return this.budgetPool;
     }
+    /** Get shared context state for cross-worker failure learning. */
+    getSharedContextState() {
+        return this.sharedContextState;
+    }
+    /** Get shared economics state for cross-worker doom loop aggregation. */
+    getSharedEconomicsState() {
+        return this.sharedEconomicsState;
+    }
+    /** Get shared context engine for cross-worker failure learning. */
+    getSharedContextEngine() {
+        return this.sharedContextEngine;
+    }
     /**
      * Subscribe to swarm events.
      */
@@ -190,11 +398,38 @@ Rules:
             try {
                 listener(event);
             }
-            catch {
-                // Don't let listener errors break the orchestrator
+            catch (err) {
+                // Don't let listener errors break the orchestrator, but log for debugging
+                const msg = err instanceof Error ? err.message : String(err);
+                if (process.env.DEBUG) {
+                    console.error(`[SwarmOrchestrator] Listener error on ${event.type}: ${msg}`);
+                }
             }
         }
     }
+    /**
+     * Track token usage from an orchestrator LLM call.
+     */
+    trackOrchestratorUsage(response, purpose) {
+        if (!response.usage)
+            return;
+        // Handle both raw API fields (total_tokens, prompt_tokens, completion_tokens)
+        // and ChatResponse fields (inputTokens, outputTokens)
+        const input = response.usage.prompt_tokens ?? response.usage.inputTokens ?? 0;
+        const output = response.usage.completion_tokens ?? response.usage.outputTokens ?? 0;
+        const tokens = response.usage.total_tokens ?? (input + output);
+        const cost = response.usage.cost ?? tokens * 0.000015; // ~$15/M tokens average for orchestrator models
+        this.orchestratorTokens += tokens;
+        this.orchestratorCost += cost;
+        this.orchestratorCalls++;
+        this.emit({
+            type: 'swarm.orchestrator.llm',
+            model: this.config.orchestratorModel,
+            purpose,
+            tokens,
+            cost,
+        });
+    }
     /**
      * Execute the full swarm pipeline for a task.
      *
@@ -211,6 +446,7 @@ Rules:
      */
     async execute(task) {
         this.startTime = Date.now();
+        this.originalPrompt = task;
         try {
             // V2: Check for resume
             if (this.config.resumeSessionId && this.stateStore) {
@@ -219,15 +455,102 @@ Rules:
             // Phase 1: Decompose
             this.currentPhase = 'decomposing';
             this.emit({ type: 'swarm.phase.progress', phase: 'decomposing', message: 'Decomposing task into subtasks...' });
-            const decomposition = await this.decompose(task);
-            if (!decomposition) {
+            const decomposeOutcome = await this.decompose(task);
+            if (!decomposeOutcome.result) {
                 this.currentPhase = 'failed';
-                return this.buildErrorResult('Decomposition failed — task may be too simple for swarm mode');
+                return this.buildErrorResult(`Decomposition failed: ${decomposeOutcome.failureReason}`);
+            }
+            let decomposition = decomposeOutcome.result;
+            // If repository is mostly empty, force a scaffold-first dependency chain
+            // so implementation tasks don't immediately fail on missing files.
+            if (repoLooksUnscaffolded(this.config.facts?.workingDirectory ?? process.cwd())) {
+                const scaffoldTask = decomposition.subtasks.find(st => /\b(scaffold|bootstrap|initialize|setup|set up|project scaffold)\b/i.test(st.description));
+                if (scaffoldTask) {
+                    for (const subtask of decomposition.subtasks) {
+                        if (subtask.id === scaffoldTask.id)
+                            continue;
+                        if (!subtask.dependencies.includes(scaffoldTask.id)) {
+                            subtask.dependencies.push(scaffoldTask.id);
+                        }
+                    }
+                    this.logDecision('scaffold-first', `Repo appears unscaffolded; enforcing scaffold task ${scaffoldTask.id} as prerequisite`, '');
+                }
+            }
+            // F5: Validate decomposition — check for cycles, invalid deps, granularity
+            const validation = validateDecomposition(decomposition);
+            if (validation.warnings.length > 0) {
+                this.logDecision('decomposition-validation', `Warnings: ${validation.warnings.join('; ')}`, '');
+            }
+            if (!validation.valid) {
+                this.logDecision('decomposition-validation', `Invalid decomposition: ${validation.issues.join('; ')}`, 'Retrying...');
+                // Retry decomposition once with feedback
+                const retryOutcome = await this.decompose(`${task}\n\nIMPORTANT: Previous decomposition was invalid: ${validation.issues.join('. ')}. Fix these issues.`);
+                if (!retryOutcome.result) {
+                    this.currentPhase = 'failed';
+                    return this.buildErrorResult(`Decomposition validation failed: ${validation.issues.join('; ')}`);
+                }
+                decomposition = retryOutcome.result;
+                const retryValidation = validateDecomposition(decomposition);
+                if (!retryValidation.valid) {
+                    this.logDecision('decomposition-validation', `Retry still invalid: ${retryValidation.issues.join('; ')}`, 'Proceeding anyway');
+                }
             }
             // Phase 2: Schedule into waves
             this.currentPhase = 'scheduling';
             this.emit({ type: 'swarm.phase.progress', phase: 'scheduling', message: `Scheduling ${decomposition.subtasks.length} subtasks into waves...` });
             this.taskQueue.loadFromDecomposition(decomposition, this.config);
+            // F3: Dynamic orchestrator reserve scaling based on subtask count.
+            // More subtasks = more quality gate calls, synthesis work, and review overhead.
+            // Formula: max(configured ratio, 5% per subtask), capped at 40%.
+            const subtaskCount = decomposition.subtasks.length;
+            const dynamicReserveRatio = Math.min(0.40, Math.max(this.config.orchestratorReserveRatio, subtaskCount * 0.05));
+            if (dynamicReserveRatio > this.config.orchestratorReserveRatio) {
+                this.logDecision('budget-scaling', `Scaled orchestrator reserve from ${(this.config.orchestratorReserveRatio * 100).toFixed(0)}% to ${(dynamicReserveRatio * 100).toFixed(0)}% for ${subtaskCount} subtasks`, '');
+            }
+            // Foundation task detection: tasks that are the sole dependency of 3+ downstream
+            // tasks are critical — if they fail, the entire swarm cascade-skips.
+            // Give them extra retries and timeout scaling.
+            this.detectFoundationTasks();
+            // D3/F1: Probe model capability before dispatch (default: true)
+            if (this.config.probeModels !== false) {
+                await this.probeModelCapability();
+                // F15/F23: Handle all-models-failed probe scenario
+                // Resolve strategy: explicit probeFailureStrategy > legacy ignoreProbeFailures > default 'warn-and-try'
+                const probeStrategy = this.config.probeFailureStrategy
+                    ?? (this.config.ignoreProbeFailures ? 'warn-and-try' : 'warn-and-try');
+                const uniqueModels = [...new Set(this.config.workers.map(w => w.model))];
+                const healthyModels = this.healthTracker.getHealthy(uniqueModels);
+                if (healthyModels.length === 0 && uniqueModels.length > 0) {
+                    if (probeStrategy === 'abort') {
+                        // Hard abort — no tasks dispatched
+                        const reason = `All ${uniqueModels.length} worker model(s) failed capability probes — no model can make tool calls. Aborting swarm to prevent budget waste. Fix model configuration and retry.`;
+                        this.logDecision('probe-abort', reason, `Models tested: ${uniqueModels.join(', ')}`);
+                        this.emit({ type: 'swarm.abort', reason });
+                        this.skipRemainingTasks(reason);
+                        const totalTasks = this.taskQueue.getStats().total;
+                        const abortStats = {
+                            completedTasks: 0, failedTasks: 0, skippedTasks: totalTasks,
+                            totalTasks, totalWaves: 0, totalTokens: 0, totalCost: 0,
+                            totalDurationMs: Date.now() - this.startTime,
+                            qualityRejections: 0, retries: 0,
+                            modelUsage: new Map(),
+                        };
+                        this.emit({ type: 'swarm.complete', stats: abortStats, errors: this.errors });
+                        return {
+                            success: false, summary: reason,
+                            tasks: this.taskQueue.getAllTasks(), stats: abortStats, errors: this.errors,
+                        };
+                    }
+                    else {
+                        // F23: warn-and-try — log warning, reset health, let real tasks prove capability
+                        this.logDecision('probe-warning', `All ${uniqueModels.length} model(s) failed probe — continuing anyway (strategy: warn-and-try)`, 'Will abort after first real task failure if model cannot use tools');
+                        // Reset health so dispatch doesn't skip all models
+                        for (const model of uniqueModels) {
+                            this.healthTracker.recordSuccess(model, 0);
+                        }
+                    }
+                }
+            }
             // Emit skip events when tasks are cascade-skipped due to dependency failures
             this.taskQueue.setOnCascadeSkip((skippedTaskId, reason) => {
                 this.emit({ type: 'swarm.task.skipped', taskId: skippedTaskId, reason });
@@ -262,9 +585,14 @@ Rules:
             // Phase 3: Execute waves (planning runs concurrently)
             this.currentPhase = 'executing';
             await this.executeWaves();
+            // V10: Final rescue pass — attempt to recover cascade-skipped tasks with lenient mode
+            if (!this.cancelled)
+                await this.finalRescuePass();
             // Ensure planning completed before verification/synthesis
             if (planPromise)
                 await planPromise;
+            // Post-wave artifact audit: scan filesystem for files created by workers
+            this.artifactInventory = this.buildArtifactInventory();
             // V2: Phase 3.5: Verify integration
             if (this.config.enableVerification && this.plan?.integrationTestPlan) {
                 this.currentPhase = 'verifying';
@@ -280,10 +608,20 @@ Rules:
             const executionStats = this.buildStats();
             // V2: Final checkpoint
             this.checkpoint('final');
-            this.emit({ type: 'swarm.complete', stats: executionStats, errors: this.errors });
+            const hasArtifacts = (this.artifactInventory?.totalFiles ?? 0) > 0;
+            this.emit({ type: 'swarm.complete', stats: executionStats, errors: this.errors, artifactInventory: this.artifactInventory });
+            // Success requires completing at least 70% of tasks (not just > 0)
+            const completionRatio = executionStats.totalTasks > 0
+                ? executionStats.completedTasks / executionStats.totalTasks
+                : 0;
+            const isSuccess = completionRatio >= 0.7;
+            const isPartialSuccess = !isSuccess && executionStats.completedTasks > 0;
             return {
-                success: executionStats.completedTasks > 0,
+                success: isSuccess,
+                partialSuccess: isPartialSuccess || (!executionStats.completedTasks && hasArtifacts),
+                partialFailure: executionStats.failedTasks > 0,
                 synthesisResult: synthesisResult ?? undefined,
+                artifactInventory: this.artifactInventory,
                 summary: this.buildSummary(executionStats),
                 tasks: this.taskQueue.getAllTasks(),
                 stats: executionStats,
@@ -310,33 +648,234 @@ Rules:
      */
     async decompose(task) {
         try {
-            const result = await this._decomposer.decompose(task);
+            const repoMap = this.config.codebaseContext?.getRepoMap() ?? undefined;
+            const result = await this._decomposer.decompose(task, {
+                repoMap,
+            });
             if (result.subtasks.length < 2) {
-                // Too simple for swarm mode
-                return null;
+                const reason = result.subtasks.length === 0
+                    ? `Decomposition produced 0 subtasks (model: ${this.config.orchestratorModel}).`
+                    : `Decomposition produced only ${result.subtasks.length} subtask — too few for swarm mode.`;
+                this.logDecision('decomposition', `Insufficient subtasks: ${result.subtasks.length}`, reason);
+                try {
+                    const lastResortResult = await this.lastResortDecompose(task);
+                    if (lastResortResult && lastResortResult.subtasks.length >= 2) {
+                        this.logDecision('decomposition', `Last-resort decomposition succeeded: ${lastResortResult.subtasks.length} subtasks`, 'Recovered from insufficient primary decomposition');
+                        return { result: lastResortResult };
+                    }
+                }
+                catch (error) {
+                    this.logDecision('decomposition', 'Last-resort decomposition failed after insufficient primary decomposition', error.message);
+                }
+                const fallback = this.buildEmergencyDecomposition(task, reason);
+                this.emit({
+                    type: 'swarm.phase.progress',
+                    phase: 'decomposing',
+                    message: `Using emergency decomposition fallback (${this.classifyDecompositionFailure(reason)})`,
+                });
+                this.logDecision('decomposition', `Using emergency scaffold decomposition: ${fallback.subtasks.length} subtasks`, 'Swarm will continue with deterministic fallback tasks');
+                return { result: fallback };
             }
-            // Reject heuristic fallback — the generic 3-task chain is worse than aborting
+            // Non-LLM result means decomposer fell back to heuristic mode.
+            // Prefer a simplified LLM decomposition, but continue with heuristic fallback when needed.
             if (!result.metadata.llmAssisted) {
-                this.logDecision('decomposition', 'Rejected heuristic fallback DAG', 'LLM decomposition failed after retries. Heuristic DAG is not useful.');
-                return null;
+                this.logDecision('decomposition', 'Heuristic decomposition detected — attempting last-resort simplified LLM decomposition', `Model: ${this.config.orchestratorModel}`);
+                try {
+                    const lastResortResult = await this.lastResortDecompose(task);
+                    if (lastResortResult && lastResortResult.subtasks.length >= 2) {
+                        this.logDecision('decomposition', `Last-resort decomposition succeeded: ${lastResortResult.subtasks.length} subtasks`, 'Simplified prompt worked');
+                        return { result: lastResortResult };
+                    }
+                }
+                catch (error) {
+                    this.logDecision('decomposition', 'Last-resort decomposition also failed', error.message);
+                }
+                this.logDecision('decomposition', `Continuing with heuristic decomposition: ${result.subtasks.length} subtasks`, 'Fallback is acceptable; do not abort swarm');
+                this.emit({
+                    type: 'swarm.phase.progress',
+                    phase: 'decomposing',
+                    message: `Continuing with heuristic decomposition (${this.classifyDecompositionFailure('heuristic fallback')})`,
+                });
+                return { result };
             }
             // Flat-DAG detection: warn when all tasks land in wave 0 with no dependencies
             const hasAnyDependency = result.subtasks.some(s => s.dependencies.length > 0);
             if (!hasAnyDependency && result.subtasks.length >= 3) {
                 this.logDecision('decomposition', `Flat DAG: ${result.subtasks.length} tasks, zero dependencies`, 'All tasks will execute in wave 0 without ordering');
             }
-            return result;
+            return { result };
         }
         catch (error) {
+            const message = error.message;
             this.errors.push({
                 phase: 'decomposition',
-                message: error.message,
-                recovered: false,
+                message,
+                recovered: true,
             });
-            this.emit({ type: 'swarm.error', error: error.message, phase: 'decomposition' });
-            return null;
+            const fallback = this.buildEmergencyDecomposition(task, `Decomposition threw an error: ${message}`);
+            this.emit({
+                type: 'swarm.phase.progress',
+                phase: 'decomposing',
+                message: `Decomposition fallback due to ${this.classifyDecompositionFailure(message)}`,
+            });
+            this.logDecision('decomposition', `Decomposition threw error; using emergency scaffold decomposition (${fallback.subtasks.length} subtasks)`, message);
+            return { result: fallback };
         }
     }
+    classifyDecompositionFailure(message) {
+        const m = message.toLowerCase();
+        if (m.includes('429') || m.includes('too many requests') || m.includes('rate limit')) {
+            return 'rate_limit';
+        }
+        if (m.includes('402') || m.includes('spend limit') || m.includes('key limit exceeded') || m.includes('insufficient credits')) {
+            return 'provider_budget_limit';
+        }
+        if (m.includes('parse') || m.includes('json') || m.includes('subtasks')) {
+            return 'parse_failure';
+        }
+        if (m.includes('invalid') || m.includes('validation')) {
+            return 'validation_failure';
+        }
+        return 'other';
+    }
+    /**
+     * Deterministic decomposition fallback when all LLM decomposition paths fail.
+     * Keeps swarm mode alive with visible scaffolding tasks instead of aborting.
+     */
+    buildEmergencyDecomposition(task, reason) {
+        const normalizer = createSmartDecomposer({ detectConflicts: true });
+        const taskLabel = task.trim().slice(0, 140) || 'requested task';
+        const repoMap = this.config.codebaseContext?.getRepoMap();
+        const topFiles = repoMap
+            ? Array.from(repoMap.chunks.values())
+                .sort((a, b) => b.importance - a.importance)
+                .slice(0, 10)
+                .map(c => c.filePath)
+            : [];
+        const subtasks = [
+            {
+                id: 'task-fb-0',
+                description: `Scaffold implementation plan and identify target files for: ${taskLabel}`,
+                status: 'ready',
+                dependencies: [],
+                complexity: 2,
+                type: 'design',
+                parallelizable: true,
+                relevantFiles: topFiles.slice(0, 5),
+            },
+            {
+                id: 'task-fb-1',
+                description: `Implement core code changes for: ${taskLabel}`,
+                status: 'blocked',
+                dependencies: ['task-fb-0'],
+                complexity: 5,
+                type: 'implement',
+                parallelizable: false,
+                relevantFiles: topFiles.slice(0, 8),
+            },
+            {
+                id: 'task-fb-2',
+                description: `Add or update tests and run validation for: ${taskLabel}`,
+                status: 'blocked',
+                dependencies: ['task-fb-1'],
+                complexity: 3,
+                type: 'test',
+                parallelizable: false,
+                relevantFiles: topFiles.slice(0, 8),
+            },
+            {
+                id: 'task-fb-3',
+                description: `Integrate results and produce final summary for: ${taskLabel}`,
+                status: 'blocked',
+                dependencies: ['task-fb-1', 'task-fb-2'],
+                complexity: 2,
+                type: 'integrate',
+                parallelizable: false,
+                relevantFiles: topFiles.slice(0, 5),
+            },
+        ];
+        const dependencyGraph = normalizer.buildDependencyGraph(subtasks);
+        const conflicts = normalizer.detectConflicts(subtasks);
+        return {
+            originalTask: task,
+            subtasks,
+            dependencyGraph,
+            conflicts,
+            strategy: 'adaptive',
+            totalComplexity: subtasks.reduce((sum, s) => sum + s.complexity, 0),
+            totalEstimatedTokens: subtasks.length * 4000,
+            metadata: {
+                decomposedAt: new Date(),
+                codebaseAware: !!repoMap,
+                llmAssisted: false,
+            },
+        };
+    }
+    /**
+     * Last-resort decomposition: radically simplified prompt that even weak models can handle.
+     * Uses shorter context, no examples, minimal schema, and lower maxTokens to avoid truncation.
+     */
+    async lastResortDecompose(task) {
+        // Include codebase grounding if repo map is available
+        let codebaseHint = '';
+        const repoMap = this.config.codebaseContext?.getRepoMap();
+        if (repoMap) {
+            const topFiles = Array.from(repoMap.chunks.values())
+                .sort((a, b) => b.importance - a.importance)
+                .slice(0, 10)
+                .map(c => c.filePath);
+            codebaseHint = `\nKey project files: ${topFiles.join(', ')}\nReference actual files in subtask descriptions.`;
+        }
+        const simplifiedPrompt = `Break this task into 2-6 subtasks. Return ONLY raw JSON, no markdown.
+
+{"subtasks":[{"description":"...","type":"implement","complexity":3,"dependencies":[],"parallelizable":true,"relevantFiles":["src/..."]}],"strategy":"adaptive","reasoning":"..."}
+
+Rules:
+- dependencies: integer indices (e.g. [0] means depends on first subtask)
+- type: one of research/implement/test/design/refactor/integrate/merge
+- At least 2 subtasks${codebaseHint}`;
+        const response = await this.provider.chat([
+            { role: 'system', content: simplifiedPrompt },
+            { role: 'user', content: task },
+        ], {
+            model: this.config.orchestratorModel,
+            maxTokens: 4096, // Short — avoids truncation
+            temperature: 0.1, // Very deterministic
+        });
+        this.trackOrchestratorUsage(response, 'decompose-last-resort');
+        const parsed = parseDecompositionResponse(response.content);
+        if (parsed.subtasks.length < 2)
+            return null;
+        // Build a proper SmartDecompositionResult from the parsed LLM output
+        const decomposer = createSmartDecomposer({ detectConflicts: true });
+        const subtasks = parsed.subtasks.map((s, index) => ({
+            id: `task-lr-${index}`,
+            description: s.description,
+            status: (s.dependencies.length > 0 ? 'blocked' : 'ready'),
+            dependencies: s.dependencies.map((d) => `task-lr-${d}`),
+            complexity: s.complexity,
+            type: s.type,
+            parallelizable: s.parallelizable,
+            relevantFiles: s.relevantFiles,
+            suggestedRole: s.suggestedRole,
+        }));
+        const dependencyGraph = decomposer.buildDependencyGraph(subtasks);
+        const conflicts = decomposer.detectConflicts(subtasks);
+        return {
+            originalTask: task,
+            subtasks,
+            dependencyGraph,
+            conflicts,
+            strategy: parsed.strategy,
+            totalComplexity: subtasks.reduce((sum, t) => sum + t.complexity, 0),
+            totalEstimatedTokens: subtasks.length * 5000,
+            metadata: {
+                decomposedAt: new Date(),
+                codebaseAware: false,
+                llmAssisted: true, // This IS LLM-assisted, just simplified
+            },
+        };
+    }
     // ─── V2: Planning Phase ───────────────────────────────────────────────
     /**
      * Create acceptance criteria and integration test plan.
@@ -383,6 +922,7 @@ Respond with valid JSON:
                 maxTokens: 3000,
                 temperature: 0.3,
             });
+            this.trackOrchestratorUsage(response, 'plan');
             const parsed = this.parseJSON(response.content);
             if (parsed) {
                 this.plan = {
@@ -454,6 +994,7 @@ Respond with valid JSON:
                 },
                 { role: 'user', content: `Review these wave ${waveIndex + 1} outputs:\n\n${taskSummaries}` },
             ], { model: reviewModel, maxTokens: 2000, temperature: 0.3 });
+            this.trackOrchestratorUsage(response, 'review');
             const parsed = this.parseJSON(response.content);
             if (!parsed)
                 return null;
@@ -578,6 +1119,7 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                     },
                     { role: 'user', content: `Original task: ${task}\n\nFailed verifications:\n${failedSteps}` },
                 ], { model: this.config.plannerModel ?? this.config.orchestratorModel, maxTokens: 1500, temperature: 0.3 });
+                this.trackOrchestratorUsage(response, 'verification-fixup');
                 const parsed = this.parseJSON(response.content);
                 if (parsed?.fixups && parsed.fixups.length > 0) {
                     const fixupTasks = parsed.fixups.map((f, i) => ({
@@ -628,6 +1170,8 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         this.logDecision('resume', `Resuming from wave ${checkpoint.currentWave}`, `Session: ${checkpoint.sessionId}`);
         this.emit({ type: 'swarm.state.resume', sessionId: checkpoint.sessionId, fromWave: checkpoint.currentWave });
         // Restore state
+        if (checkpoint.originalPrompt)
+            this.originalPrompt = checkpoint.originalPrompt;
         if (checkpoint.plan)
             this.plan = checkpoint.plan;
         if (checkpoint.modelHealth.length > 0)
@@ -638,6 +1182,13 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         this.totalCost = checkpoint.stats.totalCost;
         this.qualityRejections = checkpoint.stats.qualityRejections;
         this.retries = checkpoint.stats.retries;
+        // Restore shared context & economics state from checkpoint
+        if (checkpoint.sharedContext) {
+            this.sharedContextState.restoreFrom(checkpoint.sharedContext);
+        }
+        if (checkpoint.sharedEconomics) {
+            this.sharedEconomicsState.restoreFrom(checkpoint.sharedEconomics);
+        }
         // Restore task queue
         this.taskQueue.restoreFromCheckpoint({
             taskStates: checkpoint.taskStates,
@@ -645,21 +1196,63 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
             currentWave: checkpoint.currentWave,
         });
         // Reset orphaned dispatched tasks — their workers died with the previous process
-        let resetCount = 0;
+        const resetIds = this.taskQueue.reconcileStaleDispatched({
+            staleAfterMs: 0,
+            activeTaskIds: new Set(),
+        });
+        const resetCount = resetIds.length;
+        for (const taskId of resetIds) {
+            const task = this.taskQueue.getTask(taskId);
+            if (!task)
+                continue;
+            // Preserve at least 1 retry attempt
+            task.attempts = Math.min(task.attempts, Math.max(0, this.config.workerRetries - 1));
+        }
+        if (resetCount > 0) {
+            this.logDecision('resume', `Reset ${resetCount} orphaned dispatched tasks to ready`, 'Workers died with previous process');
+        }
+        // Reset skipped tasks whose dependencies are now satisfied
+        let unskippedCount = 0;
+        for (const task of this.taskQueue.getAllTasks()) {
+            if (task.status === 'skipped') {
+                const deps = task.dependencies.map(id => this.taskQueue.getTask(id));
+                const allDepsSatisfied = deps.every(d => d && (d.status === 'completed' || d.status === 'decomposed'));
+                if (allDepsSatisfied) {
+                    task.status = 'ready';
+                    task.attempts = 0;
+                    task.rescueContext = 'Recovered on resume — dependencies now satisfied';
+                    unskippedCount++;
+                }
+            }
+        }
+        // Also reset failed tasks that have retry budget
         for (const task of this.taskQueue.getAllTasks()) {
-            if (task.status === 'dispatched') {
+            if (task.status === 'failed') {
                 task.status = 'ready';
-                // Preserve at least 1 retry attempt
                 task.attempts = Math.min(task.attempts, Math.max(0, this.config.workerRetries - 1));
-                resetCount++;
+                unskippedCount++;
             }
         }
-        if (resetCount > 0) {
-            this.logDecision('resume', `Reset ${resetCount} orphaned dispatched tasks to ready`, 'Workers died with previous process');
+        if (unskippedCount > 0) {
+            this.logDecision('resume', `Recovered ${unskippedCount} skipped/failed tasks`, 'Fresh retry on resume');
+        }
+        // If many tasks are still stuck after un-skip, trigger re-plan
+        const resumeStats = this.taskQueue.getStats();
+        const stuckCount = resumeStats.failed + resumeStats.skipped;
+        const totalAttempted = resumeStats.completed + stuckCount;
+        if (totalAttempted > 0 && stuckCount / totalAttempted > 0.4) {
+            this.logDecision('resume-replan', `${stuckCount}/${totalAttempted} tasks still stuck after resume — triggering re-plan`, '');
+            this.hasReplanned = false; // Allow re-plan on resume
+            await this.midSwarmReplan();
         }
         // Continue from where we left off
         this.currentPhase = 'executing';
         await this.executeWaves();
+        // V10: Final rescue pass — attempt to recover cascade-skipped tasks with lenient mode
+        if (!this.cancelled)
+            await this.finalRescuePass();
+        // Post-wave artifact audit
+        this.artifactInventory = this.buildArtifactInventory();
         // Continue with verification and synthesis as normal
         if (this.config.enableVerification && this.plan?.integrationTestPlan) {
             this.currentPhase = 'verifying';
@@ -673,10 +1266,20 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         this.currentPhase = 'completed';
         const executionStats = this.buildStats();
         this.checkpoint('final');
-        this.emit({ type: 'swarm.complete', stats: executionStats, errors: this.errors });
+        const hasArtifacts = (this.artifactInventory?.totalFiles ?? 0) > 0;
+        this.emit({ type: 'swarm.complete', stats: executionStats, errors: this.errors, artifactInventory: this.artifactInventory });
+        // Success requires completing at least 70% of tasks (not just > 0)
+        const completionRatio = executionStats.totalTasks > 0
+            ? executionStats.completedTasks / executionStats.totalTasks
+            : 0;
+        const isSuccess = completionRatio >= 0.7;
+        const isPartialSuccess = !isSuccess && executionStats.completedTasks > 0;
         return {
-            success: executionStats.completedTasks > 0,
+            success: isSuccess,
+            partialSuccess: isPartialSuccess || (!executionStats.completedTasks && hasArtifacts),
+            partialFailure: executionStats.failedTasks > 0,
             synthesisResult: synthesisResult ?? undefined,
+            artifactInventory: this.artifactInventory,
             summary: this.buildSummary(executionStats),
             tasks: this.taskQueue.getAllTasks(),
             stats: executionStats,
@@ -690,9 +1293,25 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
     async executeWaves() {
         let waveIndex = this.taskQueue.getCurrentWave();
         const totalWaves = this.taskQueue.getTotalWaves();
+        const dispatchLeaseStaleMs = this.config.dispatchLeaseStaleMs ?? 5 * 60 * 1000;
         while (waveIndex < totalWaves && !this.cancelled) {
+            const activeTaskIds = new Set(this.workerPool.getActiveWorkerStatus().map(w => w.taskId));
+            const recovered = this.taskQueue.reconcileStaleDispatched({
+                staleAfterMs: dispatchLeaseStaleMs,
+                activeTaskIds,
+            });
+            if (recovered.length > 0) {
+                this.logDecision('lease-recovery', `Recovered ${recovered.length} stale dispatched task(s)`, recovered.join(', '));
+            }
             const readyTasks = this.taskQueue.getReadyTasks();
             const queueStats = this.taskQueue.getStats();
+            // F18: Skip empty waves — if no tasks are ready and none are running,
+            // remaining tasks are all blocked/failed/skipped. Break instead of
+            // running useless review cycles.
+            if (readyTasks.length === 0 && queueStats.running === 0 && queueStats.ready === 0) {
+                this.logDecision('wave-skip', `Skipping waves ${waveIndex + 1}-${totalWaves}: no dispatchable tasks remain`, `Stats: ${queueStats.completed} completed, ${queueStats.failed} failed, ${queueStats.skipped} skipped`);
+                break;
+            }
             this.emit({
                 type: 'swarm.wave.start',
                 wave: waveIndex + 1,
@@ -734,6 +1353,8 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                             previousFeedback: 'All tasks in this batch failed. Try a fundamentally different approach — the previous strategy did not work.',
                             previousScore: 0,
                             attempt: task.attempts,
+                            previousModel: task.assignedModel,
+                            swarmProgress: this.getSwarmProgressSummary(),
                         };
                     }
                     this.logDecision('wave-recovery', `Re-queued ${failedWaveTasks.length} tasks with adapted retry context`, 'Budget allows retry');
@@ -741,21 +1362,46 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                     await this.executeWave(failedWaveTasks.map(t => this.taskQueue.getTask(t.id)).filter(t => t.status === 'ready'));
                 }
             }
+            // F5: Adaptive re-decomposition — if < 50% of wave tasks succeeded,
+            // the decomposition may be structurally flawed. Log for observability.
+            // (Full re-decomposition of remaining work would require re-architecting the queue,
+            // so we log the signal and let wave retry + fixup handle recovery.)
+            const waveTotal = waveCompleted + waveFailed + waveSkipped;
+            const waveSuccessRate = waveTotal > 0 ? waveCompleted / waveTotal : 0;
+            if (waveSuccessRate < 0.5 && waveTotal >= 2) {
+                this.logDecision('decomposition-quality', `Wave ${waveIndex + 1} success rate ${(waveSuccessRate * 100).toFixed(0)}% (${waveCompleted}/${waveTotal})`, 'Low success rate may indicate decomposition quality issues');
+            }
             // V2: Review wave outputs
             const review = await this.reviewWave(waveIndex);
             if (review && review.fixupTasks.length > 0) {
                 // Execute fix-up tasks immediately
                 await this.executeWave(review.fixupTasks);
             }
+            // Rescue cascade-skipped tasks that can still run
+            // (after wave review + fixup, some skipped tasks may now be viable)
+            const rescued = this.rescueCascadeSkipped();
+            if (rescued.length > 0) {
+                this.logDecision('cascade-rescue', `Rescued ${rescued.length} cascade-skipped tasks after wave ${waveIndex + 1}`, rescued.map(t => t.id).join(', '));
+                await this.executeWave(rescued);
+            }
             // Reset quality circuit breaker at wave boundary — each wave gets a fresh chance.
             // Within a wave, rejections accumulate properly so the breaker can trip.
             // Between waves, we reset so each wave gets a fresh quality evaluation window.
             // (The within-wave reset at quality-gate-passed is kept — that's correct.)
-            if (this.qualityGateDisabled) {
-                this.qualityGateDisabled = false;
-                this.consecutiveQualityRejections = 0;
-                this.logDecision('quality-circuit-breaker', `Re-enabled quality gates at wave ${waveIndex + 1} boundary`, 'Each wave gets a fresh quality evaluation window');
+            if (this.qualityGateDisabledModels.size > 0) {
+                this.qualityGateDisabledModels.clear();
+                this.perModelQualityRejections.clear();
+                this.logDecision('quality-circuit-breaker', `Re-enabled quality gates for all models at wave ${waveIndex + 1} boundary`, 'Each wave gets a fresh quality evaluation window');
             }
+            // F3: Log budget reallocation after wave completion.
+            // SharedBudgetPool already returns unused tokens via release(), but we log it
+            // for observability so operators can see how budget flows between waves.
+            const budgetStats = this.budgetPool.getStats();
+            this.logDecision('budget-reallocation', `After wave ${waveIndex + 1}: ${budgetStats.tokensRemaining} tokens remaining (${(budgetStats.utilization * 100).toFixed(0)}% utilized)`, '');
+            this.budgetPool.reallocateUnused(budgetStats.tokensRemaining);
+            // F21: Mid-swarm situational assessment — evaluate success rate and budget health,
+            // optionally triage low-priority tasks to conserve budget for critical path.
+            await this.assessAndAdapt(waveIndex);
             // V2: Checkpoint after each wave
             this.checkpoint(`wave-${waveIndex}`);
             // Advance to next wave
@@ -783,7 +1429,7 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
             taskIndex++;
             // Stagger dispatches to avoid rate limit storms
             if (taskIndex < tasks.length && this.workerPool.availableSlots > 0) {
-                await new Promise(resolve => setTimeout(resolve, this.config.dispatchStaggerMs ?? 500));
+                await new Promise(resolve => setTimeout(resolve, this.getStaggerMs()));
             }
         }
         // Process completions and dispatch more tasks as slots open
@@ -804,7 +1450,7 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                     await this.dispatchTask(task);
                     // Stagger dispatches to avoid rate limit storms
                     if (taskIndex + 1 < tasks.length && this.workerPool.availableSlots > 0) {
-                        await new Promise(resolve => setTimeout(resolve, this.config.dispatchStaggerMs ?? 500));
+                        await new Promise(resolve => setTimeout(resolve, this.getStaggerMs()));
                     }
                 }
                 taskIndex++;
@@ -819,11 +1465,38 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                     await this.dispatchTask(moreReady[i]);
                     // Stagger dispatches to avoid rate limit storms
                     if (i + 1 < moreReady.length && this.workerPool.availableSlots > 0) {
-                        await new Promise(resolve => setTimeout(resolve, this.config.dispatchStaggerMs ?? 500));
+                        await new Promise(resolve => setTimeout(resolve, this.getStaggerMs()));
                     }
                 }
             }
         }
+        // F20: Re-dispatch pass — after all workers finish, budget may have been freed
+        // by completed tasks. Try to dispatch any still-ready tasks (e.g., those paused
+        // by budget exhaustion earlier).
+        if (!this.cancelled && this.budgetPool.hasCapacity()) {
+            const stillReady = this.taskQueue.getAllReadyTasks()
+                .filter(t => !this.workerPool.getActiveWorkerStatus().some(w => w.taskId === t.id));
+            if (stillReady.length > 0) {
+                this.logDecision('budget-redispatch', `Budget freed after wave — re-dispatching ${stillReady.length} ready task(s)`, `Budget: ${JSON.stringify(this.budgetPool.getStats())}`);
+                for (const task of stillReady) {
+                    if (this.workerPool.availableSlots <= 0 || !this.budgetPool.hasCapacity())
+                        break;
+                    await this.dispatchTask(task);
+                    if (this.workerPool.availableSlots > 0) {
+                        await new Promise(resolve => setTimeout(resolve, this.getStaggerMs()));
+                    }
+                }
+                // Wait for these re-dispatched tasks to complete
+                while (this.workerPool.activeCount > 0 && !this.cancelled) {
+                    const completed = await this.workerPool.waitForAny();
+                    if (!completed)
+                        break;
+                    await this.handleTaskCompletion(completed.taskId, completed.result, completed.startedAt);
+                    this.emitBudgetUpdate();
+                    this.emitStatusUpdate();
+                }
+            }
+        }
     }
     /**
      * Dispatch a single task to a worker.
@@ -833,45 +1506,111 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         const worker = this.workerPool.selectWorker(task);
         if (!worker) {
             // M2: Emit error and mark task failed instead of silently returning
-            this.taskQueue.markFailed(task.id, 0);
+            // V10: Try resilience recovery if task had previous attempts (prior worker may have produced artifacts)
+            this.logDecision('no-worker', `${task.id}: no worker for type ${task.type}`, '');
+            if (task.attempts > 0) {
+                const syntheticTaskResult = { success: false, output: '', tokensUsed: 0, costUsed: 0, durationMs: 0, model: 'none' };
+                const syntheticSpawn = { success: false, output: '', metrics: { tokens: 0, duration: 0, toolCalls: 0 } };
+                if (await this.tryResilienceRecovery(task, task.id, syntheticTaskResult, syntheticSpawn)) {
+                    return;
+                }
+            }
+            this.taskQueue.markFailedWithoutCascade(task.id, 0);
+            this.taskQueue.triggerCascadeSkip(task.id);
             this.emit({
                 type: 'swarm.task.failed',
                 taskId: task.id,
                 error: `No worker available for task type: ${task.type}`,
-                attempt: 0,
+                attempt: task.attempts,
                 maxAttempts: 0,
                 willRetry: false,
+                failureMode: 'error',
             });
             return;
         }
         try {
-            this.taskQueue.markDispatched(task.id, worker.model);
+            // Pre-dispatch auto-split for critical-path bottlenecks
+            if (this.shouldAutoSplit(task)) {
+                try {
+                    const splitResult = await this.judgeSplit(task);
+                    if (splitResult.shouldSplit && splitResult.subtasks) {
+                        task.status = 'dispatched'; // Required for replaceWithSubtasks
+                        this.taskQueue.replaceWithSubtasks(task.id, splitResult.subtasks);
+                        this.emit({
+                            type: 'swarm.task.resilience',
+                            taskId: task.id,
+                            strategy: 'auto-split',
+                            succeeded: true,
+                            reason: `Pre-dispatch split into ${splitResult.subtasks.length} parallel subtasks`,
+                            artifactsFound: 0,
+                            toolCalls: 0,
+                        });
+                        return; // Subtasks now in queue, will be dispatched this wave
+                    }
+                }
+                catch (err) {
+                    this.logDecision('auto-split', `${task.id}: split judge failed — ${err.message}`, '');
+                    // Fall through to normal dispatch
+                }
+            }
+            this.totalDispatches++;
+            const dispatchedModel = task.assignedModel ?? worker.model;
+            this.taskQueue.markDispatched(task.id, dispatchedModel);
+            if (task.assignedModel && task.assignedModel !== worker.model) {
+                this.logDecision('failover', `Dispatching ${task.id} with failover model ${task.assignedModel} (worker default: ${worker.model})`, 'Retry model override is active');
+            }
             // Pass the pre-selected worker to avoid double-selection in dispatch()
             await this.workerPool.dispatch(task, worker);
             this.emit({
                 type: 'swarm.task.dispatched',
                 taskId: task.id,
                 description: task.description,
-                model: worker.model,
+                model: dispatchedModel,
                 workerName: worker.name,
+                toolCount: worker.allowedTools?.length ?? -1, // -1 = all tools
+                tools: worker.allowedTools,
+                retryContext: task.retryContext,
+                fromModel: task.retryContext ? task.retryContext.previousModel : undefined,
+                attempts: task.attempts,
             });
         }
         catch (error) {
+            const errorMsg = error.message;
+            // F20: Budget exhaustion is NOT a task failure — the task is fine, we just ran out of money.
+            // Reset status to ready so it can be picked up if budget becomes available
+            // (e.g., after tokens are released from completing tasks).
+            if (errorMsg.includes('Budget pool exhausted')) {
+                task.status = 'ready';
+                this.logDecision('budget-pause', `Cannot dispatch ${task.id}: budget exhausted — task kept ready for potential re-dispatch`, `Budget stats: ${JSON.stringify(this.budgetPool.getStats())}`);
+                return;
+            }
             this.errors.push({
                 taskId: task.id,
                 phase: 'dispatch',
-                message: error.message,
+                message: errorMsg,
                 recovered: false,
             });
+            this.logDecision('dispatch-error', `${task.id}: dispatch failed: ${errorMsg.slice(0, 100)}`, `attempts: ${task.attempts}`);
+            // V10: Try resilience recovery if task had previous attempts (prior worker may have produced artifacts)
+            if (task.attempts > 0) {
+                const syntheticTaskResult = { success: false, output: '', tokensUsed: 0, costUsed: 0, durationMs: 0, model: 'none' };
+                const syntheticSpawn = { success: false, output: '', metrics: { tokens: 0, duration: 0, toolCalls: 0 } };
+                if (await this.tryResilienceRecovery(task, task.id, syntheticTaskResult, syntheticSpawn)) {
+                    this.errors[this.errors.length - 1].recovered = true;
+                    return;
+                }
+            }
+            this.taskQueue.markFailedWithoutCascade(task.id, 0);
+            this.taskQueue.triggerCascadeSkip(task.id);
             this.emit({
                 type: 'swarm.task.failed',
                 taskId: task.id,
-                error: error.message,
+                error: errorMsg,
                 attempt: task.attempts,
                 maxAttempts: 1 + this.config.workerRetries,
                 willRetry: false,
+                failureMode: 'error',
             });
-            this.taskQueue.markFailed(task.id, 0);
         }
     }
     /**
@@ -881,9 +1620,36 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         const task = this.taskQueue.getTask(taskId);
         if (!task)
             return;
-        // Guard: task was cascade-skipped while its worker was running — ignore the result
-        if (task.status === 'skipped' || task.status === 'failed')
+        // Guard: task was terminally resolved while its worker was running — ignore the result
+        // F4: But NOT if pendingCascadeSkip — those results are evaluated below
+        if ((task.status === 'skipped' || task.status === 'failed') && !task.pendingCascadeSkip)
             return;
+        // V7: Global dispatch cap — prevent any single task from burning budget.
+        // Try resilience recovery (micro-decompose, degraded acceptance) before hard-failing.
+        const maxDispatches = this.config.maxDispatchesPerTask ?? 5;
+        if (task.attempts >= maxDispatches) {
+            const durationMs = Date.now() - startedAt;
+            const taskResult = this.workerPool.toTaskResult(spawnResult, task, durationMs);
+            this.totalTokens += taskResult.tokensUsed;
+            this.totalCost += taskResult.costUsed;
+            // Try resilience recovery before hard fail
+            if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                return;
+            }
+            this.taskQueue.markFailedWithoutCascade(taskId, 0);
+            this.taskQueue.triggerCascadeSkip(taskId);
+            this.emit({
+                type: 'swarm.task.failed',
+                taskId,
+                error: `Dispatch cap reached (${maxDispatches} attempts)`,
+                attempt: task.attempts,
+                maxAttempts: maxDispatches,
+                willRetry: false,
+                failureMode: task.failureMode,
+            });
+            this.logDecision('dispatch-cap', `${taskId}: hard cap reached (${task.attempts}/${maxDispatches})`, 'No more retries — resilience recovery also failed');
+            return;
+        }
         const durationMs = Date.now() - startedAt;
         const taskResult = this.workerPool.toTaskResult(spawnResult, task, durationMs);
         // Track model usage
@@ -895,21 +1661,101 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         this.modelUsage.set(model, usage);
         this.totalTokens += taskResult.tokensUsed;
         this.totalCost += taskResult.costUsed;
+        // Log per-worker budget utilization for orchestrator visibility
+        if (taskResult.budgetUtilization) {
+            this.logDecision('budget-utilization', `${taskId}: token ${taskResult.budgetUtilization.tokenPercent}%, iter ${taskResult.budgetUtilization.iterationPercent}%`, `model=${model}, tokens=${taskResult.tokensUsed}, duration=${durationMs}ms`);
+        }
+        // V10: Emit per-attempt event for full decision traceability
+        this.emit({
+            type: 'swarm.task.attempt',
+            taskId,
+            attempt: task.attempts,
+            model,
+            success: spawnResult.success,
+            durationMs,
+            toolCalls: spawnResult.metrics.toolCalls ?? 0,
+            failureMode: !spawnResult.success ? task.failureMode : undefined,
+            qualityScore: taskResult.qualityScore,
+            output: taskResult.output.slice(0, 500),
+        });
         if (!spawnResult.success) {
             // V2: Record model health
-            const errorMsg = spawnResult.output.toLowerCase();
-            const is429 = errorMsg.includes('429') || errorMsg.includes('rate');
-            const is402 = errorMsg.includes('402') || errorMsg.includes('spend limit');
-            const errorType = is429 ? '429' : is402 ? '402' : 'error';
+            const failure = classifySwarmFailure(spawnResult.output, spawnResult.metrics.toolCalls);
+            const { failureClass, retryable, errorType, failureMode, reason } = failure;
+            const isTimeout = failureMode === 'timeout';
+            const isRateLimited = failureClass === 'rate_limited';
+            const isSpendLimit = failureClass === 'provider_spend_limit';
+            const isNonRetryable = !retryable;
             this.healthTracker.recordFailure(model, errorType);
             this.emit({ type: 'swarm.model.health', record: { model, ...this.getModelHealthSummary(model) } });
-            // Feed circuit breaker
-            if (is429 || is402) {
+            // P6: Tag failure mode for cascade threshold awareness
+            task.failureMode = failureMode;
+            // Feed circuit breaker only for retryable rate limiting
+            if (isRateLimited) {
                 this.recordRateLimit();
             }
-            // V2: Model failover on rate limits
-            if ((is429 || is402) && this.config.enableModelFailover) {
-                const capability = SUBTASK_TO_CAPABILITY[task.type] ?? 'code';
+            // F25a: Consecutive timeout tracking — early-fail after N consecutive timeouts
+            if (isTimeout) {
+                const count = (this.taskTimeoutCounts.get(taskId) ?? 0) + 1;
+                this.taskTimeoutCounts.set(taskId, count);
+                const timeoutLimit = this.config.consecutiveTimeoutLimit ?? 3;
+                this.logDecision('timeout-tracking', `${taskId}: consecutive timeout ${count}/${timeoutLimit}`, '');
+                if (count >= timeoutLimit) {
+                    // F25b: Try model failover before giving up
+                    let failoverSucceeded = false;
+                    if (this.config.enableModelFailover) {
+                        const capability = getTaskTypeConfig(task.type, this.config).capability ?? 'code';
+                        const alternative = selectAlternativeModel(this.config.workers, model, capability, this.healthTracker);
+                        if (alternative) {
+                            this.emit({
+                                type: 'swarm.model.failover',
+                                taskId,
+                                fromModel: model,
+                                toModel: alternative.model,
+                                reason: 'consecutive-timeouts',
+                            });
+                            task.assignedModel = alternative.model;
+                            this.taskTimeoutCounts.set(taskId, 0); // Reset counter for new model
+                            this.logDecision('failover', `Timeout failover ${taskId}: ${model} → ${alternative.model}`, `${count} consecutive timeouts`);
+                            failoverSucceeded = true;
+                        }
+                    }
+                    if (!failoverSucceeded) {
+                        // No alternative model — try resilience recovery before hard fail.
+                        // Timeouts often produce artifacts (worker WAS working, just ran out of time).
+                        task.failureMode = 'timeout';
+                        const taskResult = this.workerPool.toTaskResult(spawnResult, task, Date.now() - startedAt);
+                        if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                            this.taskTimeoutCounts.delete(taskId);
+                            return;
+                        }
+                        this.taskQueue.markFailedWithoutCascade(taskId, 0);
+                        this.taskQueue.triggerCascadeSkip(taskId);
+                        this.emit({
+                            type: 'swarm.task.failed',
+                            taskId,
+                            error: `${count} consecutive timeouts — no alternative model available`,
+                            attempt: task.attempts,
+                            maxAttempts: maxDispatches,
+                            willRetry: false,
+                            failureMode: 'timeout',
+                            failureClass: 'timeout',
+                            retrySuppressed: true,
+                            retryReason: 'Consecutive timeout limit reached with no alternative model',
+                        });
+                        this.logDecision('timeout-early-fail', `${taskId}: ${count} consecutive timeouts, no alt model — resilience recovery also failed`, '');
+                        this.taskTimeoutCounts.delete(taskId);
+                        return;
+                    }
+                }
+            }
+            else {
+                // Non-timeout failure — reset the counter
+                this.taskTimeoutCounts.delete(taskId);
+            }
+            // V2: Model failover on retryable rate limits
+            if (isRateLimited && this.config.enableModelFailover) {
+                const capability = getTaskTypeConfig(task.type, this.config).capability ?? 'code';
                 const alternative = selectAlternativeModel(this.config.workers, model, capability, this.healthTracker);
                 if (alternative) {
                     this.emit({
@@ -924,32 +1770,61 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                 }
             }
             // V5/V7: Store error context so retry gets different prompt
-            if (!(is429 || is402)) {
+            if (!(isRateLimited || isSpendLimit)) {
                 // V7: Timeout-specific feedback — the worker WAS working, just ran out of time
-                const isTimeout = spawnResult.metrics.toolCalls === -1;
                 const timeoutSeconds = isTimeout ? Math.round(durationMs / 1000) : 0;
                 task.retryContext = {
                     previousFeedback: isTimeout
                         ? `Previous attempt timed out after ${timeoutSeconds}s. You must complete this task more efficiently — work faster, use fewer tool calls, and produce your result sooner.`
-                        : spawnResult.output.slice(0, 500),
+                        : spawnResult.output.slice(0, 2000),
                     previousScore: 0,
                     attempt: task.attempts,
+                    previousModel: model,
+                    previousFiles: taskResult.filesModified,
+                    swarmProgress: this.getSwarmProgressSummary(),
                 };
+                // Phase 3.1: Report failure to shared context engine for cross-worker learning
+                this.sharedContextEngine.reportFailure(taskId, {
+                    action: task.description.slice(0, 200),
+                    error: spawnResult.output.slice(0, 500),
+                });
+            }
+            // V7: Reset hollow streak on non-hollow failure (error is not a hollow completion)
+            this.hollowStreak = 0;
+            // Worker failed — use higher retry limit for rate limit errors.
+            // V7: Fixup tasks get capped retries, foundation tasks get +1.
+            const baseRetries = this.getEffectiveRetries(task);
+            const retryLimit = isNonRetryable
+                ? 0
+                : isRateLimited
+                    ? Math.min(this.config.rateLimitRetries ?? 3, baseRetries + 1)
+                    : baseRetries;
+            const canRetry = this.taskQueue.markFailedWithoutCascade(taskId, retryLimit);
+            if (isNonRetryable) {
+                this.logDecision('retry-suppressed', `${taskId}: ${failureClass}`, reason);
             }
-            // Worker failed — use higher retry limit for rate limit errors
-            const retryLimit = (is429 || is402)
-                ? (this.config.rateLimitRetries ?? 3)
-                : this.config.workerRetries;
-            const canRetry = this.taskQueue.markFailed(taskId, retryLimit);
             if (canRetry) {
                 this.retries++;
                 // Non-blocking cooldown: set retryAfter timestamp instead of blocking
-                if (is429 || is402) {
+                if (isRateLimited) {
                     const baseDelay = this.config.retryBaseDelayMs ?? 5000;
                     const cooldownMs = Math.min(baseDelay * Math.pow(2, task.attempts - 1), 30000);
                     this.taskQueue.setRetryAfter(taskId, cooldownMs);
+                    this.logDecision('rate-limit-cooldown', `${taskId}: ${errorType} cooldown ${cooldownMs}ms, model ${model}`, '');
                 }
             }
+            else if (!isRateLimited) {
+                // Resilience recovery for non-rate-limit errors (micro-decompose + degraded acceptance)
+                if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                    return;
+                }
+                // Recovery failed — NOW trigger cascade
+                this.taskQueue.triggerCascadeSkip(taskId);
+            }
+            else {
+                // Rate-limit exhaustion — trigger cascade
+                this.taskQueue.triggerCascadeSkip(taskId);
+            }
             this.emit({
                 type: 'swarm.task.failed',
                 taskId,
@@ -957,23 +1832,51 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                 attempt: task.attempts,
                 maxAttempts: 1 + this.config.workerRetries,
                 willRetry: canRetry,
+                toolCalls: spawnResult.metrics.toolCalls,
+                failoverModel: task.assignedModel !== model ? task.assignedModel : undefined,
+                failureMode: task.failureMode,
+                failureClass,
+                retrySuppressed: isNonRetryable,
+                retryReason: reason,
             });
             return;
         }
         // V6: Hollow completion detection — workers that "succeed" without doing any work
         // Must check BEFORE recording success, otherwise hollow completions inflate health scores
-        if (isHollowCompletion(spawnResult)) {
-            // Record health failure so hollow-prone models accumulate failure records
-            // and eventually trigger failover via selectAlternativeModel
-            this.healthTracker.recordFailure(model, 'error');
+        if (isHollowCompletion(spawnResult, task.type, this.config)) {
+            // F4: Hollow result + pendingCascadeSkip — honor the skip immediately, no retry
+            if (task.pendingCascadeSkip) {
+                task.pendingCascadeSkip = undefined;
+                task.status = 'skipped';
+                this.totalHollows++;
+                this.logDecision('cascade-skip', `${taskId}: pending cascade skip honored (hollow completion)`, '');
+                this.emit({ type: 'swarm.task.skipped', taskId, reason: 'cascade skip honored — hollow completion' });
+                return;
+            }
+            // P6: Tag failure mode for cascade threshold awareness
+            task.failureMode = 'hollow';
+            // Record hollow completion so hollow-prone models accumulate hollow-specific records
+            // and get deprioritized by the model selector (also records generic failure internally)
+            this.healthTracker.recordHollow(model);
+            const admitsFailure = spawnResult.success && FAILURE_INDICATORS.some(f => (spawnResult.output ?? '').toLowerCase().includes(f));
             task.retryContext = {
-                previousFeedback: 'Previous attempt produced no meaningful output. Try again with a concrete approach.',
+                previousFeedback: admitsFailure
+                    ? 'Previous attempt reported success but admitted failure (e.g., "budget exhausted", "unable to complete"). You MUST execute tool calls and produce concrete output this time.'
+                    : 'Previous attempt produced no meaningful output. Try again with a concrete approach.',
                 previousScore: 1,
                 attempt: task.attempts,
+                previousModel: model,
+                previousFiles: taskResult.filesModified,
+                swarmProgress: this.getSwarmProgressSummary(),
             };
+            // Phase 3.1: Report hollow completion to shared context engine
+            this.sharedContextEngine.reportFailure(taskId, {
+                action: task.description.slice(0, 200),
+                error: 'Hollow completion: worker produced no meaningful output',
+            });
             // Model failover for hollow completions — same pattern as quality failover
             if (this.config.enableModelFailover) {
-                const capability = SUBTASK_TO_CAPABILITY[task.type] ?? 'code';
+                const capability = getTaskTypeConfig(task.type, this.config).capability ?? 'code';
                 const alternative = selectAlternativeModel(this.config.workers, model, capability, this.healthTracker);
                 if (alternative) {
                     this.emit({
@@ -987,9 +1890,19 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                     this.logDecision('failover', `Hollow failover ${taskId}: ${model} → ${alternative.model}`, 'Model produced hollow completion');
                 }
             }
-            const canRetry = this.taskQueue.markFailed(taskId, this.config.workerRetries);
-            if (canRetry)
+            const hollowRetries = this.getEffectiveRetries(task);
+            const canRetry = this.taskQueue.markFailedWithoutCascade(taskId, hollowRetries);
+            if (canRetry) {
                 this.retries++;
+            }
+            else {
+                // Retries exhausted — try shared resilience recovery (micro-decompose, degraded acceptance)
+                if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                    return;
+                }
+                // Recovery failed — NOW trigger cascade
+                this.taskQueue.triggerCascadeSkip(taskId);
+            }
             this.emit({
                 type: 'swarm.task.failed',
                 taskId,
@@ -997,21 +1910,83 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                 attempt: task.attempts,
                 maxAttempts: 1 + this.config.workerRetries,
                 willRetry: canRetry,
+                toolCalls: spawnResult.metrics.toolCalls,
+                failoverModel: task.assignedModel !== model ? task.assignedModel : undefined,
+                failureMode: 'hollow',
             });
-            this.logDecision('hollow-completion', `${taskId}: worker completed with 0 tool calls`, 'Marking as failed for retry');
+            this.hollowStreak++;
+            this.totalHollows++;
+            this.logDecision('hollow-completion', `${taskId}: worker completed with 0 tool calls (streak: ${this.hollowStreak}, total hollows: ${this.totalHollows}/${this.totalDispatches})`, canRetry ? 'Marking as failed for retry' : 'Retries exhausted — hard fail');
+            // B2: Hollow streak handling — only terminate if enableHollowTermination is explicitly on
+            if (this.hollowStreak >= SwarmOrchestrator.HOLLOW_STREAK_THRESHOLD) {
+                const uniqueModels = new Set(this.config.workers.map(w => w.model));
+                const singleModel = uniqueModels.size === 1;
+                const onlyModel = [...uniqueModels][0];
+                const modelUnhealthy = singleModel && !this.healthTracker.getAllRecords().find(r => r.model === onlyModel)?.healthy;
+                if (singleModel && modelUnhealthy) {
+                    if (this.config.enableHollowTermination) {
+                        this.logDecision('early-termination', `Terminating swarm: ${this.hollowStreak} consecutive hollow completions on sole model ${onlyModel}`, 'Single-model swarm with unhealthy model — enableHollowTermination is on');
+                        this.skipRemainingTasks(`Single-model hollow streak (${this.hollowStreak}x on ${onlyModel})`);
+                    }
+                    else {
+                        this.logDecision('stall-mode', `${this.hollowStreak} consecutive hollows on sole model ${onlyModel} — entering stall mode`, 'Will attempt model failover or simplified retry on next dispatch');
+                        // Reset streak to allow more attempts with adjusted strategy
+                        this.hollowStreak = 0;
+                    }
+                }
+            }
+            // V7: Multi-model hollow ratio — warn but don't terminate unless opt-in
+            const minDispatches = this.config.hollowTerminationMinDispatches ?? 8;
+            const threshold = this.config.hollowTerminationRatio ?? 0.55;
+            if (this.totalDispatches >= minDispatches) {
+                const ratio = this.totalHollows / this.totalDispatches;
+                if (ratio > threshold) {
+                    if (this.config.enableHollowTermination) {
+                        this.logDecision('early-termination', `Terminating swarm: hollow ratio ${(ratio * 100).toFixed(0)}% (${this.totalHollows}/${this.totalDispatches})`, `Exceeds threshold ${(threshold * 100).toFixed(0)}% after ${minDispatches}+ dispatches — enableHollowTermination is on`);
+                        this.skipRemainingTasks(`Hollow ratio ${(ratio * 100).toFixed(0)}% — models cannot execute tasks`);
+                    }
+                    else if (!this.hollowRatioWarned) {
+                        this.hollowRatioWarned = true;
+                        this.logDecision('stall-warning', `Hollow ratio ${(ratio * 100).toFixed(0)}% (${this.totalHollows}/${this.totalDispatches})`, 'High hollow rate but continuing — tasks may still recover via resilience');
+                    }
+                }
+            }
             return;
         }
+        // F4: Task had pendingCascadeSkip but produced non-hollow results.
+        // Run pre-flight checks — if the output is good, accept it instead of skipping.
+        if (task.pendingCascadeSkip) {
+            const cachedReport = checkArtifacts(task);
+            const preFlight = runPreFlightChecks(task, taskResult, this.config, cachedReport);
+            if (preFlight && !preFlight.passed) {
+                // Output is garbage — honor the cascade skip
+                task.pendingCascadeSkip = undefined;
+                task.status = 'skipped';
+                this.logDecision('cascade-skip', `${taskId}: pending cascade skip honored (pre-flight failed: ${preFlight.feedback})`, '');
+                this.emit({ type: 'swarm.task.skipped', taskId, reason: `cascade skip honored — output failed pre-flight: ${preFlight.feedback}` });
+                return;
+            }
+            // Output is good — clear the flag and accept the result
+            task.pendingCascadeSkip = undefined;
+            task.status = 'dispatched'; // Reset so markCompleted works
+            this.logDecision('cascade-skip', `${taskId}: pending cascade skip overridden — worker produced valid output`, '');
+        }
         // Record model health on success (only for non-hollow completions)
         this.healthTracker.recordSuccess(model, durationMs);
+        this.decreaseStagger(); // P7: Speed up on success
         // Run quality gate if enabled — skip under API pressure, skip if circuit breaker tripped,
         // and let the final attempt through without quality gate (so tasks produce *something*)
+        // Foundation tasks get +1 retry to reduce cascade failure risk.
+        const effectiveRetries = this.getEffectiveRetries(task);
         const recentRLCount = this.recentRateLimits.filter(t => t > Date.now() - 30_000).length;
-        const isLastAttempt = task.attempts >= (this.config.workerRetries + 1);
+        const isLastAttempt = task.attempts >= (effectiveRetries + 1);
         const shouldRunQualityGate = this.config.qualityGates
-            && !this.qualityGateDisabled
+            && !this.qualityGateDisabledModels.has(model)
             && !isLastAttempt
             && Date.now() >= this.circuitBreakerUntil
             && recentRLCount < 2;
+        // C1: Pre-compute artifact report once — shared by quality gate and pre-flight checks
+        const cachedArtifactReport = checkArtifacts(task);
         if (shouldRunQualityGate) {
             // V3: Judge role handles quality gates
             const judgeModel = this.config.hierarchy?.judge?.model
@@ -1021,57 +1996,336 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                 persona: this.config.hierarchy?.judge?.persona,
             };
             this.emit({ type: 'swarm.role.action', role: 'judge', action: 'quality-gate', model: judgeModel, taskId });
-            const quality = await evaluateWorkerOutput(this.provider, judgeModel, task, taskResult, judgeConfig, this.config.qualityThreshold ?? 3);
+            // Extract file artifacts from worker output for quality gate visibility.
+            // When workers create files via write_file/edit_file, the judge needs to see
+            // the actual content — not just the worker's text claims about what was created.
+            const fileArtifacts = this.extractFileArtifacts(task, taskResult);
+            // Foundation tasks get a relaxed quality threshold (threshold - 1, min 2)
+            // to reduce the chance of cascade-skipping the entire swarm.
+            const baseThreshold = this.config.qualityThreshold ?? 3;
+            const qualityThreshold = task.isFoundation ? Math.max(2, baseThreshold - 1) : baseThreshold;
+            const quality = await evaluateWorkerOutput(this.provider, judgeModel, task, taskResult, judgeConfig, qualityThreshold, (resp, purpose) => this.trackOrchestratorUsage(resp, purpose), fileArtifacts, this.config, cachedArtifactReport);
             taskResult.qualityScore = quality.score;
             taskResult.qualityFeedback = quality.feedback;
-            if (!quality.passed) {
-                this.qualityRejections++;
-                this.consecutiveQualityRejections++;
-                // Quality circuit breaker: disable gates after too many consecutive rejections
-                if (this.consecutiveQualityRejections >= SwarmOrchestrator.QUALITY_CIRCUIT_BREAKER_THRESHOLD) {
-                    this.qualityGateDisabled = true;
-                    this.logDecision('quality-circuit-breaker', `Disabled quality gates after ${this.consecutiveQualityRejections} consecutive rejections`, 'Workers cannot meet quality threshold — letting remaining tasks through');
+            // F11: Foundation tasks that barely pass the relaxed threshold get concrete validation.
+            // A 2/5 foundation task with truncated output will cascade-poison all dependents.
+            if (quality.passed && task.isFoundation && quality.score <= baseThreshold - 1) {
+                const concreteResult = runConcreteChecks(task, taskResult);
+                if (!concreteResult.passed) {
+                    quality.passed = false;
+                    quality.feedback += ` [F11: foundation task barely passed (${quality.score}/${baseThreshold}) but concrete validation failed: ${concreteResult.issues.join('; ')}]`;
+                    this.logDecision('foundation-concrete-gate', `${taskId}: foundation task scored ${quality.score} (relaxed threshold ${qualityThreshold}) but concrete checks failed — rejecting`, concreteResult.issues.join('; '));
                 }
-                // V5: Attach feedback so retry prompt includes it
-                task.retryContext = {
-                    previousFeedback: quality.feedback,
-                    previousScore: quality.score,
-                    attempt: task.attempts,
-                };
-                // V5: Model failover on severe quality rejection — but NOT on artifact auto-fails
-                if (quality.score <= 1 && this.config.enableModelFailover && !quality.artifactAutoFail) {
-                    const capability = SUBTASK_TO_CAPABILITY[task.type] ?? 'code';
-                    const alternative = selectAlternativeModel(this.config.workers, model, capability, this.healthTracker);
-                    if (alternative) {
+            }
+            if (!quality.passed) {
+                // F7: Gate error fallback — when LLM judge fails, use concrete validation
+                // If concrete checks pass, tentatively accept the result instead of rejecting.
+                if (quality.gateError && (this.config.enableConcreteValidation !== false)) {
+                    const concreteResult = runConcreteChecks(task, taskResult);
+                    if (concreteResult.passed) {
+                        // Concrete validation passed — tentatively accept despite gate error
+                        this.logDecision('gate-error-fallback', `${taskId}: gate error but concrete checks passed — tentatively accepting`, quality.gateErrorMessage ?? 'unknown');
+                        taskResult.qualityScore = quality.score;
+                        taskResult.qualityFeedback = `${quality.feedback} [concrete validation passed — tentative accept]`;
+                        // Fall through to success path (don't return)
+                    }
+                    else {
+                        // Both gate and concrete failed — reject
+                        this.logDecision('gate-error-fallback', `${taskId}: gate error AND concrete checks failed — rejecting`, `Concrete issues: ${concreteResult.issues.join('; ')}`);
+                        // Fall through to normal rejection below
+                    }
+                    // If concrete passed, skip the rejection path
+                    if (concreteResult.passed) {
+                        this.perModelQualityRejections.delete(model);
+                        // Jump to success path below
+                    }
+                    else {
+                        // Proceed with normal rejection
+                        this.qualityRejections++;
+                        task.failureMode = 'quality';
+                        this.healthTracker.recordQualityRejection(model, quality.score);
+                        this.emit({ type: 'swarm.model.health', record: { model, ...this.getModelHealthSummary(model) } });
+                        this.hollowStreak = 0;
+                        task.retryContext = {
+                            previousFeedback: `Gate error + concrete validation failed: ${concreteResult.issues.join('; ')}`,
+                            previousScore: quality.score,
+                            attempt: task.attempts,
+                            previousModel: model,
+                            previousFiles: taskResult.filesModified,
+                            swarmProgress: this.getSwarmProgressSummary(),
+                        };
+                        const canRetry = this.taskQueue.markFailedWithoutCascade(taskId, effectiveRetries);
+                        if (canRetry) {
+                            this.retries++;
+                        }
+                        else {
+                            // Retries exhausted — try resilience recovery before cascade-skip
+                            if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                                return;
+                            }
+                            // Recovery failed — NOW trigger cascade
+                            this.taskQueue.triggerCascadeSkip(taskId);
+                        }
                         this.emit({
-                            type: 'swarm.model.failover',
+                            type: 'swarm.quality.rejected',
                             taskId,
-                            fromModel: model,
-                            toModel: alternative.model,
-                            reason: `quality-score-${quality.score}`,
+                            score: quality.score,
+                            feedback: quality.feedback,
+                            artifactCount: fileArtifacts.length,
+                            outputLength: taskResult.output.length,
+                            preFlightReject: false,
+                            filesOnDisk: checkArtifactsEnhanced(task, taskResult).files.filter(f => f.exists && f.sizeBytes > 0).length,
                         });
-                        task.assignedModel = alternative.model;
-                        this.logDecision('failover', `Quality failover ${taskId}: ${model} → ${alternative.model}`, `Score ${quality.score}/5`);
+                        return;
                     }
                 }
-                const canRetry = this.taskQueue.markFailed(taskId, this.config.workerRetries);
+                else if (!quality.gateError) {
+                    // Normal quality rejection (LLM judge rejected, no gate error)
+                    this.qualityRejections++;
+                    // P6: Tag failure mode for cascade threshold awareness
+                    task.failureMode = 'quality';
+                    // P1: Quality rejections update model health — undo premature recordSuccess
+                    this.healthTracker.recordQualityRejection(model, quality.score);
+                    this.emit({ type: 'swarm.model.health', record: { model, ...this.getModelHealthSummary(model) } });
+                    // V7: Quality rejection is NOT hollow — worker did work, just poorly
+                    this.hollowStreak = 0;
+                    // F7: Per-model circuit breaker → "pre-flight only mode" instead of fully disabling gates.
+                    // After threshold rejections, skip LLM judge but keep pre-flight mandatory.
+                    if (!quality.preFlightReject) {
+                        const modelRejections = (this.perModelQualityRejections.get(model) ?? 0) + 1;
+                        this.perModelQualityRejections.set(model, modelRejections);
+                        if (modelRejections >= SwarmOrchestrator.QUALITY_CIRCUIT_BREAKER_THRESHOLD) {
+                            this.qualityGateDisabledModels.add(model);
+                            this.logDecision('quality-circuit-breaker', `Switched model ${model} to pre-flight-only mode after ${modelRejections} rejections`, 'Skipping LLM judge but keeping pre-flight checks mandatory');
+                        }
+                    }
+                    // V5: Attach feedback so retry prompt includes it
+                    task.retryContext = {
+                        previousFeedback: quality.feedback,
+                        previousScore: quality.score,
+                        attempt: task.attempts,
+                        previousModel: model,
+                        previousFiles: taskResult.filesModified,
+                        swarmProgress: this.getSwarmProgressSummary(),
+                    };
+                    // Phase 3.1: Report quality rejection to shared context engine
+                    this.sharedContextEngine.reportFailure(taskId, {
+                        action: task.description.slice(0, 200),
+                        error: `Quality gate rejection (score ${quality.score}): ${quality.feedback.slice(0, 300)}`,
+                    });
+                    // V5: Model failover on quality rejection — but NOT on artifact auto-fails
+                    // P1: Widened from score<=1 to score<threshold so failover triggers on any rejection
+                    if (quality.score < qualityThreshold && this.config.enableModelFailover && !quality.artifactAutoFail) {
+                        const capability = getTaskTypeConfig(task.type, this.config).capability ?? 'code';
+                        const alternative = selectAlternativeModel(this.config.workers, model, capability, this.healthTracker);
+                        if (alternative) {
+                            this.emit({
+                                type: 'swarm.model.failover',
+                                taskId,
+                                fromModel: model,
+                                toModel: alternative.model,
+                                reason: `quality-score-${quality.score}`,
+                            });
+                            task.assignedModel = alternative.model;
+                            this.logDecision('failover', `Quality failover ${taskId}: ${model} → ${alternative.model}`, `Score ${quality.score}/5`);
+                        }
+                    }
+                    const canRetry = this.taskQueue.markFailedWithoutCascade(taskId, effectiveRetries);
+                    if (canRetry) {
+                        this.retries++;
+                    }
+                    else {
+                        // Retries exhausted — try resilience recovery before cascade-skip
+                        if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                            return;
+                        }
+                        // Recovery failed — NOW trigger cascade
+                        this.taskQueue.triggerCascadeSkip(taskId);
+                    }
+                    // M1: Only emit quality.rejected (not duplicate task.failed)
+                    this.emit({
+                        type: 'swarm.quality.rejected',
+                        taskId,
+                        score: quality.score,
+                        feedback: quality.feedback,
+                        artifactCount: fileArtifacts.length,
+                        outputLength: taskResult.output.length,
+                        preFlightReject: quality.preFlightReject,
+                        filesOnDisk: checkArtifactsEnhanced(task, taskResult).files.filter(f => f.exists && f.sizeBytes > 0).length,
+                    });
+                    return;
+                }
+                else {
+                    // gateError=true but concrete validation disabled — reject
+                    this.qualityRejections++;
+                    task.failureMode = 'quality';
+                    this.hollowStreak = 0;
+                    task.retryContext = {
+                        previousFeedback: quality.feedback,
+                        previousScore: quality.score,
+                        attempt: task.attempts,
+                        previousModel: model,
+                        previousFiles: taskResult.filesModified,
+                        swarmProgress: this.getSwarmProgressSummary(),
+                    };
+                    const canRetry = this.taskQueue.markFailedWithoutCascade(taskId, effectiveRetries);
+                    if (canRetry) {
+                        this.retries++;
+                    }
+                    else {
+                        // Retries exhausted — try resilience recovery before cascade-skip
+                        if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                            return;
+                        }
+                        // Recovery failed — NOW trigger cascade
+                        this.taskQueue.triggerCascadeSkip(taskId);
+                    }
+                    this.emit({
+                        type: 'swarm.quality.rejected',
+                        taskId,
+                        score: quality.score,
+                        feedback: quality.feedback,
+                        artifactCount: fileArtifacts.length,
+                        outputLength: taskResult.output.length,
+                        preFlightReject: false,
+                        filesOnDisk: checkArtifactsEnhanced(task, taskResult).files.filter(f => f.exists && f.sizeBytes > 0).length,
+                    });
+                    return;
+                }
+            }
+            // Quality passed — reset per-model rejection counter
+            this.perModelQualityRejections.delete(model);
+        }
+        // F7: When quality gate was skipped (last attempt, pre-flight-only mode, API pressure),
+        // still run pre-flight + concrete checks so obviously broken outputs don't slip through.
+        // C1: Use cached artifact report to avoid double filesystem scan.
+        if (!shouldRunQualityGate && this.config.qualityGates) {
+            const preFlight = runPreFlightChecks(task, taskResult, this.config, cachedArtifactReport);
+            if (preFlight && !preFlight.passed) {
+                taskResult.qualityScore = preFlight.score;
+                taskResult.qualityFeedback = preFlight.feedback;
+                this.qualityRejections++;
+                const canRetry = this.taskQueue.markFailedWithoutCascade(taskId, effectiveRetries);
                 if (canRetry) {
                     this.retries++;
                 }
-                // M1: Only emit quality.rejected (not duplicate task.failed)
+                else {
+                    // Retries exhausted — try resilience recovery before cascade-skip
+                    this.logDecision('preflight-reject', `${taskId}: pre-flight failed: ${preFlight.feedback}`, '');
+                    if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                        return;
+                    }
+                    // Recovery failed — NOW trigger cascade
+                    this.taskQueue.triggerCascadeSkip(taskId);
+                }
                 this.emit({
                     type: 'swarm.quality.rejected',
                     taskId,
-                    score: quality.score,
-                    feedback: quality.feedback,
+                    score: preFlight.score,
+                    feedback: preFlight.feedback,
+                    artifactCount: 0,
+                    outputLength: taskResult.output.length,
+                    preFlightReject: true,
                 });
                 return;
             }
-            // Quality passed — reset consecutive rejection counter
-            this.consecutiveQualityRejections = 0;
+            // F2: Run concrete validation when pre-flight passes but gate was skipped
+            if (this.config.enableConcreteValidation !== false) {
+                const concreteResult = runConcreteChecks(task, taskResult);
+                if (!concreteResult.passed) {
+                    taskResult.qualityScore = 2;
+                    taskResult.qualityFeedback = `Concrete validation failed: ${concreteResult.issues.join('; ')}`;
+                    this.qualityRejections++;
+                    const canRetry = this.taskQueue.markFailedWithoutCascade(taskId, effectiveRetries);
+                    if (canRetry) {
+                        this.retries++;
+                    }
+                    else {
+                        // Retries exhausted — try resilience recovery before cascade-skip
+                        this.logDecision('concrete-reject', `${taskId}: concrete validation failed: ${concreteResult.issues.join('; ')}`, '');
+                        if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                            return;
+                        }
+                        // Recovery failed — NOW trigger cascade
+                        this.taskQueue.triggerCascadeSkip(taskId);
+                    }
+                    this.emit({
+                        type: 'swarm.quality.rejected',
+                        taskId,
+                        score: 2,
+                        feedback: taskResult.qualityFeedback,
+                        artifactCount: 0,
+                        outputLength: taskResult.output.length,
+                        preFlightReject: false,
+                    });
+                    return;
+                }
+            }
+        }
+        // Final completion guard: block "narrative success" for action tasks.
+        const completionGuard = this.config.completionGuard ?? {};
+        const rejectFutureIntentOutputs = completionGuard.rejectFutureIntentOutputs ?? true;
+        const requireConcreteArtifactsForActionTasks = completionGuard.requireConcreteArtifactsForActionTasks ?? true;
+        const typeConfig = getTaskTypeConfig(task.type, this.config);
+        const artifactReport = checkArtifactsEnhanced(task, taskResult);
+        const filesOnDisk = artifactReport.files.filter(f => f.exists && f.sizeBytes > 0).length;
+        const hasConcreteArtifacts = filesOnDisk > 0 || (taskResult.filesModified?.length ?? 0) > 0;
+        const isActionTask = !!typeConfig.requiresToolCalls;
+        if (rejectFutureIntentOutputs && hasFutureIntentLanguage(taskResult.output ?? '')) {
+            taskResult.qualityScore = 1;
+            taskResult.qualityFeedback = 'Completion rejected: output indicates pending, unexecuted work';
+            const canRetry = this.taskQueue.markFailedWithoutCascade(taskId, effectiveRetries);
+            if (canRetry) {
+                this.retries++;
+            }
+            else {
+                if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                    return;
+                }
+                this.taskQueue.triggerCascadeSkip(taskId);
+            }
+            this.emit({
+                type: 'swarm.quality.rejected',
+                taskId,
+                score: 1,
+                feedback: taskResult.qualityFeedback,
+                artifactCount: filesOnDisk,
+                outputLength: taskResult.output.length,
+                preFlightReject: true,
+                filesOnDisk,
+            });
+            return;
+        }
+        if (requireConcreteArtifactsForActionTasks && isActionTask && !hasConcreteArtifacts) {
+            taskResult.qualityScore = 1;
+            taskResult.qualityFeedback = 'Completion rejected: action task produced no concrete artifacts';
+            const canRetry = this.taskQueue.markFailedWithoutCascade(taskId, effectiveRetries);
+            if (canRetry) {
+                this.retries++;
+            }
+            else {
+                if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
+                    return;
+                }
+                this.taskQueue.triggerCascadeSkip(taskId);
+            }
+            this.emit({
+                type: 'swarm.quality.rejected',
+                taskId,
+                score: 1,
+                feedback: taskResult.qualityFeedback,
+                artifactCount: filesOnDisk,
+                outputLength: taskResult.output.length,
+                preFlightReject: true,
+                filesOnDisk,
+            });
+            return;
         }
         // Task passed — mark completed
         this.taskQueue.markCompleted(taskId, taskResult);
+        this.hollowStreak = 0;
+        // F25: Clear timeout counter on success
+        this.taskTimeoutCounts.delete(taskId);
         // H6: Post findings to blackboard with error handling
         if (this.blackboard && taskResult.findings) {
             try {
@@ -1117,7 +2371,7 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         const tasks = this.taskQueue.getAllTasks();
         const outputs = tasks
             .filter(t => t.status === 'completed')
-            .map(t => taskResultToAgentOutput(t))
+            .map(t => taskResultToAgentOutput(t, this.config))
             .filter((o) => o !== null);
         if (outputs.length === 0)
             return null;
@@ -1147,11 +2401,17 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
             activeWorkers: this.workerPool.getActiveWorkerStatus(),
             queue: stats,
             budget: {
-                tokensUsed: this.totalTokens,
+                tokensUsed: this.totalTokens + this.orchestratorTokens,
                 tokensTotal: this.config.totalBudget,
-                costUsed: this.totalCost,
+                costUsed: this.totalCost + this.orchestratorCost,
                 costTotal: this.config.maxCost,
             },
+            orchestrator: {
+                tokens: this.orchestratorTokens,
+                cost: this.orchestratorCost,
+                calls: this.orchestratorCalls,
+                model: this.config.orchestratorModel,
+            },
         };
     }
     /**
@@ -1163,6 +2423,69 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         this.currentPhase = 'failed';
         await this.workerPool.cancelAll();
     }
+    // ─── D3: Model Capability Probing ─────────────────────────────────────
+    /**
+     * D3/F23: Probe each unique model to verify it can make tool calls.
+     * Models that fail the probe are marked unhealthy so they're skipped in dispatch.
+     *
+     * F23 fix: Uses chatWithTools() with actual tool definitions instead of
+     * plain chat() which never included tools in the API request.
+     */
+    async probeModelCapability() {
+        const uniqueModels = new Set(this.config.workers.map(w => w.model));
+        this.emit({ type: 'swarm.phase.progress', phase: 'scheduling', message: `Probing ${uniqueModels.size} model(s) for tool-calling capability...` });
+        // F23: Check if provider supports native tool calling
+        const supportsTools = 'chatWithTools' in this.provider
+            && typeof this.provider.chatWithTools === 'function';
+        if (!supportsTools) {
+            // Provider doesn't support chatWithTools — skip probe entirely.
+            // Workers will rely on text-based tool parsing fallback.
+            this.logDecision('model-probe', 'Provider does not support chatWithTools — skipping probe', '');
+            return;
+        }
+        const providerWithTools = this.provider;
+        const probeTools = [{
+                type: 'function',
+                function: {
+                    name: 'read_file',
+                    description: 'Read a file from disk',
+                    parameters: {
+                        type: 'object',
+                        properties: { path: { type: 'string', description: 'File path' } },
+                        required: ['path'],
+                    },
+                },
+            }];
+        // F24: Configurable probe timeout — generous default for slow models/connections
+        const probeTimeout = this.config.probeTimeoutMs ?? 60_000;
+        for (const model of uniqueModels) {
+            try {
+                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Probe timeout (${probeTimeout}ms)`)), probeTimeout));
+                const response = await Promise.race([
+                    providerWithTools.chatWithTools([
+                        { role: 'system', content: 'You are a test probe. Call the read_file tool with path "package.json".' },
+                        { role: 'user', content: 'Read package.json.' },
+                    ], { model, maxTokens: 200, temperature: 0, tools: probeTools, tool_choice: 'required' }),
+                    timeoutPromise,
+                ]);
+                const hasToolCall = (response.toolCalls?.length ?? 0) > 0;
+                if (!hasToolCall) {
+                    // F19: Directly mark unhealthy — probe failure is definitive evidence
+                    this.healthTracker.markUnhealthy(model);
+                    this.logDecision('model-probe', `Model ${model} failed probe (no tool calls)`, 'Marked unhealthy');
+                }
+                else {
+                    this.healthTracker.recordSuccess(model, 0);
+                    this.logDecision('model-probe', `Model ${model} passed probe`, '');
+                }
+            }
+            catch {
+                // F19: Directly mark unhealthy on probe error (includes timeout)
+                this.healthTracker.markUnhealthy(model);
+                this.logDecision('model-probe', `Model ${model} probe errored`, 'Marked unhealthy');
+            }
+        }
+    }
     // ─── Circuit Breaker ────────────────────────────────────────────────
     /**
      * Record a rate limit hit and check if the circuit breaker should trip.
@@ -1170,6 +2493,7 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
     recordRateLimit() {
         const now = Date.now();
         this.recentRateLimits.push(now);
+        this.increaseStagger(); // P7: Back off on rate limits
         // Prune entries older than the window
         const cutoff = now - SwarmOrchestrator.CIRCUIT_BREAKER_WINDOW_MS;
         this.recentRateLimits = this.recentRateLimits.filter(t => t > cutoff);
@@ -1197,6 +2521,19 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         }
         return false;
     }
+    // ─── P7: Adaptive Stagger ────────────────────────────────────────────
+    /** P7: Get current stagger delay (adapts based on rate limit / success signals). */
+    getStaggerMs() {
+        return this.adaptiveStaggerMs;
+    }
+    /** P7: Increase stagger on rate limit (×1.5, capped at 10s). */
+    increaseStagger() {
+        this.adaptiveStaggerMs = Math.min(this.adaptiveStaggerMs * 1.5, 10_000);
+    }
+    /** P7: Decrease stagger on success (×0.9, floor at 200ms). */
+    decreaseStagger() {
+        this.adaptiveStaggerMs = Math.max(this.adaptiveStaggerMs * 0.9, 200);
+    }
     // ─── V2: Decision Logging ─────────────────────────────────────────────
     logDecision(phase, decision, reasoning) {
         const entry = {
@@ -1223,14 +2560,17 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                 waves: queueState.waves,
                 currentWave: queueState.currentWave,
                 stats: {
-                    totalTokens: this.totalTokens,
-                    totalCost: this.totalCost,
+                    totalTokens: this.totalTokens + this.orchestratorTokens,
+                    totalCost: this.totalCost + this.orchestratorCost,
                     qualityRejections: this.qualityRejections,
                     retries: this.retries,
                 },
                 modelHealth: this.healthTracker.getAllRecords(),
                 decisions: this.orchestratorDecisions,
                 errors: this.errors,
+                originalPrompt: this.originalPrompt,
+                sharedContext: this.sharedContextState.toJSON(),
+                sharedEconomics: this.sharedEconomicsState.toJSON(),
             });
             this.emit({
                 type: 'swarm.state.checkpoint',
@@ -1250,9 +2590,9 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
     emitBudgetUpdate() {
         this.emit({
             type: 'swarm.budget.update',
-            tokensUsed: this.totalTokens,
+            tokensUsed: this.totalTokens + this.orchestratorTokens,
             tokensTotal: this.config.totalBudget,
-            costUsed: this.totalCost,
+            costUsed: this.totalCost + this.orchestratorCost,
             costTotal: this.config.maxCost,
         });
     }
@@ -1267,8 +2607,8 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
             failedTasks: queueStats.failed,
             skippedTasks: queueStats.skipped,
             totalWaves: this.taskQueue.getTotalWaves(),
-            totalTokens: this.totalTokens,
-            totalCost: this.totalCost,
+            totalTokens: this.totalTokens + this.orchestratorTokens,
+            totalCost: this.totalCost + this.orchestratorCost,
             totalDurationMs: Date.now() - this.startTime,
             qualityRejections: this.qualityRejections,
             retries: this.retries,
@@ -1293,6 +2633,16 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         if (this.verificationResult) {
             parts.push(`  Verification: ${this.verificationResult.passed ? 'PASSED' : 'FAILED'}`);
         }
+        // Artifact inventory: show what files actually exist on disk regardless of task status
+        if (this.artifactInventory && this.artifactInventory.totalFiles > 0) {
+            parts.push(`  Files on disk: ${this.artifactInventory.totalFiles} files (${(this.artifactInventory.totalBytes / 1024).toFixed(1)}KB)`);
+            for (const f of this.artifactInventory.files.slice(0, 15)) {
+                parts.push(`    ${f.path}: ${f.sizeBytes}B`);
+            }
+            if (this.artifactInventory.files.length > 15) {
+                parts.push(`    ... and ${this.artifactInventory.files.length - 15} more`);
+            }
+        }
         return parts.join('\n');
     }
     buildErrorResult(message) {
@@ -1319,6 +2669,703 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
             return null;
         }
     }
+    /**
+     * Detect foundation tasks: tasks that are a dependency of 2+ downstream tasks.
+     * These are critical single-points-of-failure — mark them for extra resilience.
+     */
+    detectFoundationTasks() {
+        const allTasks = this.taskQueue.getAllTasks();
+        const dependentCounts = new Map();
+        for (const task of allTasks) {
+            for (const depId of task.dependencies) {
+                dependentCounts.set(depId, (dependentCounts.get(depId) ?? 0) + 1);
+            }
+        }
+        for (const task of allTasks) {
+            const dependentCount = dependentCounts.get(task.id) ?? 0;
+            if (dependentCount >= 2) {
+                task.isFoundation = true;
+                this.logDecision('scheduling', `Foundation task: ${task.id} (${dependentCount} dependents)`, 'Extra retries and relaxed quality threshold applied');
+            }
+        }
+    }
+    /**
+     * Extract file artifacts from a worker's output for quality gate visibility.
+     * Reads actual file content from disk so the judge can verify real work,
+     * not just text claims about what was created.
+     */
+    extractFileArtifacts(task, taskResult) {
+        const artifacts = [];
+        const seen = new Set();
+        // Collect file paths from multiple sources
+        const candidatePaths = [];
+        // 1. filesModified from structured closure report
+        if (taskResult.filesModified) {
+            candidatePaths.push(...taskResult.filesModified);
+        }
+        // 2. targetFiles from task definition
+        if (task.targetFiles) {
+            candidatePaths.push(...task.targetFiles);
+        }
+        // 3. Extract file paths mentioned in worker output (e.g., "Created src/foo.ts")
+        const filePathPattern = /(?:created|wrote|modified|edited|updated)\s+["`']?([^\s"`',]+\.\w+)/gi;
+        let match;
+        while ((match = filePathPattern.exec(taskResult.output)) !== null) {
+            candidatePaths.push(match[1]);
+        }
+        // Resolve against the target project directory, not CWD
+        const baseDir = this.config.facts?.workingDirectory ?? process.cwd();
+        // Read previews from disk
+        for (const filePath of candidatePaths) {
+            if (seen.has(filePath))
+                continue;
+            seen.add(filePath);
+            try {
+                const resolved = path.resolve(baseDir, filePath);
+                if (fs.existsSync(resolved)) {
+                    const content = fs.readFileSync(resolved, 'utf-8');
+                    if (content.length > 0) {
+                        artifacts.push({ path: filePath, preview: content.slice(0, 2000) });
+                    }
+                }
+            }
+            catch {
+                // Skip unreadable files
+            }
+            // Limit to 10 files to keep prompt size reasonable
+            if (artifacts.length >= 10)
+                break;
+        }
+        return artifacts;
+    }
+    /**
+     * Build an inventory of filesystem artifacts produced during swarm execution.
+     * Scans all tasks' targetFiles and readFiles to check what actually exists on disk.
+     * This reveals work done by workers even when tasks "failed" (timeout, quality gate, etc.).
+     */
+    buildArtifactInventory() {
+        const allFiles = new Set();
+        for (const task of this.taskQueue.getAllTasks()) {
+            for (const f of (task.targetFiles ?? []))
+                allFiles.add(f);
+            for (const f of (task.readFiles ?? []))
+                allFiles.add(f);
+        }
+        const baseDir = this.config.facts?.workingDirectory ?? process.cwd();
+        const artifacts = [];
+        for (const filePath of allFiles) {
+            try {
+                const resolved = path.resolve(baseDir, filePath);
+                if (fs.existsSync(resolved)) {
+                    const stats = fs.statSync(resolved);
+                    if (stats.isFile() && stats.size > 0) {
+                        artifacts.push({ path: filePath, sizeBytes: stats.size, exists: true });
+                    }
+                }
+            }
+            catch { /* skip unreadable files */ }
+        }
+        return {
+            files: artifacts,
+            totalFiles: artifacts.length,
+            totalBytes: artifacts.reduce((s, a) => s + a.sizeBytes, 0),
+        };
+    }
+    /**
+     * Skip all remaining pending/ready tasks (used for early termination).
+     */
+    skipRemainingTasks(reason) {
+        for (const task of this.taskQueue.getAllTasks()) {
+            if (task.status === 'pending' || task.status === 'ready') {
+                task.status = 'skipped';
+                this.emit({ type: 'swarm.task.skipped', taskId: task.id, reason });
+            }
+        }
+    }
+    /**
+     * F21: Mid-swarm situational assessment after each wave.
+     * Evaluates success rate and budget health, triages low-priority tasks when budget is tight.
+     * Also detects stalled progress and triggers mid-swarm re-planning.
+     */
+    async assessAndAdapt(waveIndex) {
+        const stats = this.taskQueue.getStats();
+        const budgetStats = this.budgetPool.getStats();
+        // 1. Calculate success rate for this swarm run
+        const successRate = stats.completed / Math.max(1, stats.completed + stats.failed + stats.skipped);
+        // 2. Budget efficiency: tokens spent per completed task
+        const tokensPerTask = stats.completed > 0
+            ? (this.totalTokens / stats.completed)
+            : Infinity;
+        // 3. Remaining budget vs remaining tasks
+        const remainingTasks = stats.total - stats.completed - stats.failed - stats.skipped;
+        const estimatedTokensNeeded = remainingTasks * tokensPerTask;
+        const budgetSufficient = budgetStats.tokensRemaining > estimatedTokensNeeded * 0.5;
+        // Log the assessment for observability
+        this.logDecision('mid-swarm-assessment', `After wave ${waveIndex + 1}: ${stats.completed}/${stats.total} completed (${(successRate * 100).toFixed(0)}%), ` +
+            `${remainingTasks} remaining, ${budgetStats.tokensRemaining} tokens left`, budgetSufficient ? 'Budget looks sufficient' : 'Budget may be insufficient for remaining tasks');
+        // 4. If budget is tight, prioritize: skip low-value remaining tasks
+        // Only triage if we have actual data (at least one completion to estimate from)
+        if (!budgetSufficient && remainingTasks > 1 && stats.completed > 0) {
+            // Prefer pausing over skipping: if workers are still running, wait for budget release
+            const runningCount = stats.running ?? 0;
+            if (runningCount > 0) {
+                this.logDecision('budget-wait', 'Budget tight but workers still running — waiting for budget release', `${runningCount} workers active, ${budgetStats.tokensRemaining} tokens remaining`);
+                return;
+            }
+            const expendableTasks = this.findExpendableTasks();
+            // Hard cap: never skip more than 20% of remaining tasks in one triage pass
+            const maxSkips = Math.max(1, Math.floor(remainingTasks * 0.2));
+            if (expendableTasks.length > 0) {
+                let currentEstimate = estimatedTokensNeeded;
+                let skipped = 0;
+                for (const task of expendableTasks) {
+                    if (skipped >= maxSkips)
+                        break;
+                    // Stop trimming once we're within budget
+                    if (currentEstimate * 0.7 <= budgetStats.tokensRemaining)
+                        break;
+                    task.status = 'skipped';
+                    skipped++;
+                    this.emit({ type: 'swarm.task.skipped', taskId: task.id,
+                        reason: 'Budget conservation: skipping low-priority task to protect critical path' });
+                    this.logDecision('budget-triage', `Skipping ${task.id} (${task.type}, complexity ${task.complexity}) to conserve budget`, `${remainingTasks} tasks remain, ${budgetStats.tokensRemaining} tokens`);
+                    currentEstimate -= tokensPerTask;
+                }
+            }
+        }
+        // 5. Stall detection: if progress ratio is too low, trigger re-plan
+        const attemptedTasks = stats.completed + stats.failed + stats.skipped;
+        if (attemptedTasks >= 5) {
+            const progressRatio = stats.completed / Math.max(1, attemptedTasks);
+            if (progressRatio < 0.4) {
+                this.logDecision('stall-detected', `Progress stalled: ${stats.completed}/${attemptedTasks} tasks succeeded (${(progressRatio * 100).toFixed(0)}%)`, 'Triggering mid-swarm re-plan');
+                this.emit({
+                    type: 'swarm.stall',
+                    progressRatio,
+                    attempted: attemptedTasks,
+                    completed: stats.completed,
+                });
+                await this.midSwarmReplan();
+            }
+        }
+    }
+    /**
+     * F21: Find expendable tasks — leaf tasks (no dependents) with lowest complexity.
+     * These are the safest to skip when budget is tight.
+     * Only tasks with complexity <= 2 are considered expendable.
+     */
+    findExpendableTasks() {
+        const allTasks = this.taskQueue.getAllTasks();
+        // Build reverse dependency map: which tasks depend on each task?
+        const dependentCounts = new Map();
+        for (const task of allTasks) {
+            for (const depId of task.dependencies) {
+                dependentCounts.set(depId, (dependentCounts.get(depId) ?? 0) + 1);
+            }
+        }
+        // Expendable = pending/ready, never attempted, no dependents, not foundation,
+        // complexity <= 2 (simple leaf tasks only), lowest complexity first
+        return allTasks
+            .filter(t => (t.status === 'pending' || t.status === 'ready') &&
+            t.attempts === 0 &&
+            !t.isFoundation &&
+            (t.complexity ?? 5) <= 2 &&
+            (dependentCounts.get(t.id) ?? 0) === 0)
+            .sort((a, b) => (a.complexity ?? 5) - (b.complexity ?? 5));
+    }
+    /**
+     * Mid-swarm re-planning: when progress stalls, ask LLM to re-plan remaining work.
+     * Creates simpler replacement tasks for stuck/failed work, building on what's already done.
+     * Only triggers once per swarm execution to avoid infinite re-planning loops.
+     */
+    async midSwarmReplan() {
+        if (this.hasReplanned)
+            return;
+        this.hasReplanned = true;
+        const allTasks = this.taskQueue.getAllTasks();
+        const completed = allTasks.filter(t => t.status === 'completed' || t.status === 'decomposed');
+        const stuck = allTasks.filter(t => t.status === 'failed' || t.status === 'skipped');
+        if (stuck.length === 0)
+            return;
+        const completedSummary = completed.map(t => `- ${t.description} [${t.type}] → completed${t.degraded ? ' (degraded)' : ''}`).join('\n') || '(none)';
+        const stuckSummary = stuck.map(t => `- ${t.description} [${t.type}] → ${t.status} (${t.failureMode ?? 'unknown'})`).join('\n');
+        const artifactInventory = this.buildArtifactInventory();
+        const artifactSummary = artifactInventory.files.map(f => `- ${f.path} (${f.sizeBytes}B)`).join('\n') || '(none)';
+        const replanPrompt = `The swarm is stalled. Here's the situation:
+
+COMPLETED WORK:
+${completedSummary}
+
+FILES ON DISK:
+${artifactSummary}
+
+STUCK TASKS (failed or skipped):
+${stuckSummary}
+
+Re-plan the remaining work. Create new subtasks that:
+1. Build on what's already completed (don't redo work)
+2. Are more focused in scope (but assign realistic complexity for the work involved — don't underestimate)
+3. Can succeed independently (minimize dependencies)
+
+Return JSON: { "subtasks": [{ "description": "...", "type": "implement|test|research|review|document|refactor", "complexity": 1-5, "dependencies": [], "relevantFiles": [] }] }
+Return ONLY the JSON object, no other text.`;
+        try {
+            const response = await this.provider.chat([{ role: 'user', content: replanPrompt }]);
+            this.trackOrchestratorUsage(response, 'mid-swarm-replan');
+            const content = response.content ?? '';
+            const jsonMatch = content.match(/\{[\s\S]*"subtasks"[\s\S]*\}/);
+            if (!jsonMatch) {
+                this.logDecision('replan-failed', 'LLM produced no parseable re-plan JSON', content.slice(0, 200));
+                return;
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            if (!parsed.subtasks || parsed.subtasks.length === 0) {
+                this.logDecision('replan-failed', 'LLM produced empty subtask list', '');
+                return;
+            }
+            // Add new tasks from re-plan into current wave
+            const newTasks = this.taskQueue.addReplanTasks(parsed.subtasks, this.taskQueue.getCurrentWave());
+            this.logDecision('replan-success', `Re-planned ${stuck.length} stuck tasks into ${newTasks.length} new tasks`, newTasks.map(t => t.description).join('; '));
+            this.emit({
+                type: 'swarm.replan',
+                stuckCount: stuck.length,
+                newTaskCount: newTasks.length,
+            });
+            this.emit({
+                type: 'swarm.orchestrator.decision',
+                decision: {
+                    timestamp: Date.now(),
+                    phase: 'replan',
+                    decision: `Re-planned ${stuck.length} stuck tasks into ${newTasks.length} new tasks`,
+                    reasoning: newTasks.map(t => `${t.id}: ${t.description}`).join('; '),
+                },
+            });
+        }
+        catch (error) {
+            this.logDecision('replan-failed', `Re-plan LLM call failed: ${error.message}`, '');
+        }
+    }
+    /**
+     * Rescue cascade-skipped tasks that can still run.
+     * After cascade-skip fires, assess whether skipped tasks can still be attempted:
+     * - If all OTHER dependencies completed and the failed dep's artifacts exist on disk → un-skip
+     * - If the task has no strict data dependency on the failed task (different file targets) → un-skip with warning
+     */
+    rescueCascadeSkipped(lenient = false) {
+        const skippedTasks = this.taskQueue.getSkippedTasks();
+        const rescued = [];
+        for (const task of skippedTasks) {
+            if (task.dependencies.length === 0)
+                continue;
+            let completedDeps = 0;
+            let failedDepsWithArtifacts = 0;
+            let failedDepsWithoutArtifacts = 0;
+            let skippedDepsBlockedBySkipped = 0;
+            let totalDeps = 0;
+            const failedDepDescriptions = [];
+            for (const depId of task.dependencies) {
+                const dep = this.taskQueue.getTask(depId);
+                if (!dep)
+                    continue;
+                totalDeps++;
+                if (dep.status === 'completed' || dep.status === 'decomposed') {
+                    completedDeps++;
+                }
+                else if (dep.status === 'failed' || dep.status === 'skipped') {
+                    // V10: In lenient mode, use checkArtifactsEnhanced for broader detection
+                    const artifactReport = lenient ? checkArtifactsEnhanced(dep) : checkArtifacts(dep);
+                    if (artifactReport && artifactReport.files.filter(f => f.exists && f.sizeBytes > 0).length > 0) {
+                        failedDepsWithArtifacts++;
+                        failedDepDescriptions.push(`${dep.description} (failed but ${artifactReport.files.filter(f => f.exists && f.sizeBytes > 0).length} artifacts exist)`);
+                    }
+                    else {
+                        // Check if this dep's target files exist on disk (may have been created by earlier attempt)
+                        const targetFiles = dep.targetFiles ?? [];
+                        const existingFiles = targetFiles.filter(f => {
+                            try {
+                                const resolved = path.resolve(this.config.facts?.workingDirectory ?? process.cwd(), f);
+                                return fs.statSync(resolved).size > 0;
+                            }
+                            catch {
+                                return false;
+                            }
+                        });
+                        if (existingFiles.length > 0) {
+                            failedDepsWithArtifacts++;
+                            failedDepDescriptions.push(`${dep.description} (failed but ${existingFiles.length}/${targetFiles.length} target files exist)`);
+                        }
+                        else {
+                            // Check if skipped task's targets don't overlap with the failed dep's targets
+                            const taskTargets = new Set(task.targetFiles ?? []);
+                            const depTargets = new Set(dep.targetFiles ?? []);
+                            const hasOverlap = [...taskTargets].some(f => depTargets.has(f));
+                            if (!hasOverlap && taskTargets.size > 0) {
+                                // Different file targets — task probably doesn't need the failed dep's output
+                                failedDepsWithArtifacts++;
+                                failedDepDescriptions.push(`${dep.description} (failed, no file overlap — likely independent)`);
+                            }
+                            else if (lenient && dep.status === 'skipped') {
+                                // V10: In lenient mode, count skipped-by-skipped deps separately
+                                // (transitive cascade — the dep itself was a victim, not truly broken)
+                                skippedDepsBlockedBySkipped++;
+                                failedDepDescriptions.push(`${dep.description} (skipped — transitive cascade victim)`);
+                            }
+                            else {
+                                failedDepsWithoutArtifacts++;
+                            }
+                        }
+                    }
+                }
+            }
+            // Rescue condition:
+            // Normal: all failed deps have artifacts or are independent, AND at least some deps completed
+            // Lenient: tolerate up to 1 truly-missing dep, and count transitive cascade victims as recoverable
+            const effectiveWithout = failedDepsWithoutArtifacts;
+            const maxMissing = lenient ? 1 : 0;
+            const hasEnoughContext = lenient ? (completedDeps + failedDepsWithArtifacts + skippedDepsBlockedBySkipped > 0) : (completedDeps > 0);
+            if (totalDeps > 0 && effectiveWithout <= maxMissing && hasEnoughContext) {
+                const rescueContext = `Rescued from cascade-skip${lenient ? ' (lenient)' : ''}: ${completedDeps}/${totalDeps} deps completed, ` +
+                    `${failedDepsWithArtifacts} failed deps have artifacts${skippedDepsBlockedBySkipped > 0 ? `, ${skippedDepsBlockedBySkipped} transitive cascade victims` : ''}. ${failedDepDescriptions.join('; ')}`;
+                this.taskQueue.rescueTask(task.id, rescueContext);
+                rescued.push(task);
+                this.logDecision('cascade-rescue', `${task.id}: rescued from cascade-skip${lenient ? ' (lenient)' : ''}`, rescueContext);
+            }
+        }
+        return rescued;
+    }
+    /**
+     * Final rescue pass — runs after executeWaves() finishes.
+     * Uses lenient mode to rescue cascade-skipped tasks that have partial context.
+     * Re-dispatches rescued tasks in a final wave.
+     */
+    async finalRescuePass() {
+        const skipped = this.taskQueue.getSkippedTasks();
+        if (skipped.length === 0)
+            return;
+        this.logDecision('final-rescue', `${skipped.length} skipped tasks — running final rescue pass`, '');
+        const rescued = this.rescueCascadeSkipped(true); // lenient=true
+        if (rescued.length > 0) {
+            this.logDecision('final-rescue', `Rescued ${rescued.length} tasks`, rescued.map(t => t.id).join(', '));
+            await this.executeWave(rescued);
+        }
+    }
+    /**
+     * Try resilience recovery strategies before hard-failing a task.
+     * Called from dispatch-cap, timeout, hollow, and error paths to avoid bypassing resilience.
+     *
+     * Strategies (in order):
+     * 1. Micro-decomposition — break complex failing tasks into subtasks
+     * 2. Degraded acceptance — accept partial work if artifacts exist on disk
+     *
+     * Returns true if recovery succeeded (caller should return), false if hard-fail should proceed.
+     */
+    async tryResilienceRecovery(task, taskId, taskResult, spawnResult) {
+        // Strategy 1: Micro-decompose complex tasks into smaller subtasks
+        // V10: Lowered threshold from >= 6 to >= 4 so moderately complex tasks can be recovered
+        if ((task.complexity ?? 0) >= 4 && task.attempts >= 2 && this.budgetPool.hasCapacity()) {
+            const subtasks = await this.microDecompose(task);
+            if (subtasks && subtasks.length >= 2) {
+                // Reset task status so replaceWithSubtasks can mark it as decomposed
+                task.status = 'dispatched';
+                this.taskQueue.replaceWithSubtasks(taskId, subtasks);
+                this.logDecision('micro-decompose', `${taskId}: decomposed into ${subtasks.length} subtasks after ${task.attempts} failures`, subtasks.map(s => `${s.id}: ${s.description.slice(0, 60)}`).join('; '));
+                this.emit({
+                    type: 'swarm.task.failed',
+                    taskId,
+                    error: `Micro-decomposed into ${subtasks.length} subtasks`,
+                    attempt: task.attempts,
+                    maxAttempts: this.config.maxDispatchesPerTask ?? 5,
+                    willRetry: false,
+                    toolCalls: spawnResult.metrics.toolCalls,
+                    failureMode: task.failureMode,
+                });
+                this.emit({
+                    type: 'swarm.task.resilience',
+                    taskId,
+                    strategy: 'micro-decompose',
+                    succeeded: true,
+                    reason: `Decomposed into ${subtasks.length} subtasks after ${task.attempts} failures`,
+                    artifactsFound: 0,
+                    toolCalls: spawnResult.metrics.toolCalls ?? 0,
+                });
+                return true;
+            }
+            // Micro-decompose was attempted but didn't produce usable subtasks
+            if ((task.complexity ?? 0) < 4) {
+                this.logDecision('resilience-skip', `${taskId}: skipped micro-decompose — complexity ${task.complexity} < 4`, '');
+            }
+        }
+        // Strategy 2: Degraded acceptance — check if any attempt produced files on disk.
+        // V10: Use checkArtifactsEnhanced for broader detection (filesModified, closureReport, output)
+        const artifactReport = checkArtifactsEnhanced(task, taskResult);
+        const existingArtifacts = artifactReport.files.filter(f => f.exists && f.sizeBytes > 0);
+        const hasArtifacts = existingArtifacts.length > 0;
+        // V10: Fix timeout detection — toolCalls=-1 means timeout (worker WAS working)
+        const toolCalls = spawnResult.metrics.toolCalls ?? 0;
+        const hadToolCalls = toolCalls > 0 || toolCalls === -1
+            || (taskResult.filesModified && taskResult.filesModified.length > 0);
+        const isNarrativeOnly = hasFutureIntentLanguage(taskResult.output ?? '');
+        const typeConfig = getTaskTypeConfig(task.type, this.config);
+        const actionTaskNeedsArtifacts = (this.config.completionGuard?.requireConcreteArtifactsForActionTasks ?? true)
+            && !!typeConfig.requiresToolCalls;
+        const allowDegradedWithoutArtifacts = !actionTaskNeedsArtifacts && hadToolCalls && !isNarrativeOnly;
+        if (hasArtifacts || allowDegradedWithoutArtifacts) {
+            // Accept with degraded flag — prevents cascade-skip of dependents
+            taskResult.success = true;
+            taskResult.degraded = true;
+            taskResult.qualityScore = 2; // Capped at low quality
+            taskResult.qualityFeedback = 'Degraded acceptance: retries exhausted but filesystem artifacts exist';
+            task.degraded = true;
+            // Reset status so markCompleted works (markFailed may have set it to 'failed')
+            task.status = 'dispatched';
+            this.taskQueue.markCompleted(taskId, taskResult);
+            this.hollowStreak = 0;
+            this.logDecision('degraded-acceptance', `${taskId}: accepted as degraded — ${existingArtifacts.length} artifacts on disk, ${toolCalls} tool calls`, 'Prevents cascade-skip of dependent tasks');
+            this.emit({
+                type: 'swarm.task.completed',
+                taskId,
+                success: true,
+                tokensUsed: taskResult.tokensUsed,
+                costUsed: taskResult.costUsed,
+                durationMs: taskResult.durationMs,
+                qualityScore: 2,
+                qualityFeedback: 'Degraded acceptance',
+                output: taskResult.output,
+                toolCalls: spawnResult.metrics.toolCalls,
+            });
+            this.emit({
+                type: 'swarm.task.resilience',
+                taskId,
+                strategy: 'degraded-acceptance',
+                succeeded: true,
+                reason: `${existingArtifacts.length} artifacts on disk, ${toolCalls} tool calls`,
+                artifactsFound: existingArtifacts.length,
+                toolCalls,
+            });
+            return true;
+        }
+        // Both strategies failed — log exhaustion for traceability
+        this.logDecision('resilience-exhausted', `${taskId}: no recovery — artifacts: ${existingArtifacts.length}, toolCalls: ${toolCalls}, filesModified: ${taskResult.filesModified?.length ?? 0}`, '');
+        this.emit({
+            type: 'swarm.task.resilience',
+            taskId,
+            strategy: 'none',
+            succeeded: false,
+            reason: `No artifacts found, toolCalls=${toolCalls}, filesModified=${taskResult.filesModified?.length ?? 0}`,
+            artifactsFound: existingArtifacts.length,
+            toolCalls,
+        });
+        return false;
+    }
+    /**
+     * Micro-decompose a complex task into 2-3 smaller subtasks using the LLM.
+     * Called when a complex task (complexity >= 6) fails 2+ times with the same failure mode.
+     * Returns null if decomposition doesn't make sense or LLM can't produce valid subtasks.
+     */
+    async microDecompose(task) {
+        if ((task.complexity ?? 0) < 4)
+            return null;
+        try {
+            const prompt = `Task "${task.description}" failed ${task.attempts} times on model ${task.assignedModel ?? 'unknown'}.
+The task has complexity ${task.complexity}/10 and type "${task.type}".
+${task.targetFiles?.length ? `Target files: ${task.targetFiles.join(', ')}` : ''}
+
+Break this task into 2-3 smaller, independent subtasks that each handle a portion of the work.
+Each subtask MUST be simpler (complexity <= ${Math.ceil(task.complexity / 2)}).
+Each subtask should be self-contained and produce concrete file changes.
+
+Return JSON ONLY (no markdown, no explanation):
+{
+  "subtasks": [
+    { "description": "...", "type": "${task.type}", "targetFiles": ["..."], "complexity": <number> }
+  ]
+}`;
+            const response = await this.provider.chat([
+                { role: 'system', content: 'You are a task decomposition assistant. Return only valid JSON.' },
+                { role: 'user', content: prompt },
+            ], {
+                model: this.config.orchestratorModel,
+                maxTokens: 2000,
+                temperature: 0.3,
+            });
+            this.trackOrchestratorUsage(response, 'micro-decompose');
+            // Parse response — handle markdown code blocks
+            let jsonStr = response.content.trim();
+            const codeBlockMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+            if (codeBlockMatch)
+                jsonStr = codeBlockMatch[1].trim();
+            const parsed = JSON.parse(jsonStr);
+            if (!parsed.subtasks || !Array.isArray(parsed.subtasks) || parsed.subtasks.length < 2) {
+                return null;
+            }
+            const subtasks = parsed.subtasks.map((sub, idx) => ({
+                id: `${task.id}-sub${idx + 1}`,
+                description: sub.description,
+                type: sub.type ?? task.type,
+                dependencies: [], // Will be set by replaceWithSubtasks
+                status: 'ready',
+                complexity: Math.min(sub.complexity ?? Math.ceil(task.complexity / 2), task.complexity - 1),
+                wave: task.wave,
+                targetFiles: sub.targetFiles ?? [],
+                readFiles: task.readFiles,
+                attempts: 0,
+            }));
+            return subtasks;
+        }
+        catch (error) {
+            this.logDecision('micro-decompose', `${task.id}: micro-decomposition failed — ${error.message}`, 'Falling through to normal failure path');
+            return null;
+        }
+    }
+    // ─── Pre-Dispatch Auto-Split ──────────────────────────────────────────────
+    /**
+     * Heuristic pre-filter: should this task be considered for auto-split?
+     * Cheap check — no LLM call. Returns true if all conditions are met.
+     */
+    shouldAutoSplit(task) {
+        const cfg = this.config.autoSplit;
+        if (cfg?.enabled === false)
+            return false;
+        const floor = cfg?.complexityFloor ?? 6;
+        const splittable = cfg?.splittableTypes ?? ['implement', 'refactor', 'test'];
+        // Only first attempts — retries use micro-decompose
+        if (task.attempts > 0)
+            return false;
+        // Complexity check
+        if ((task.complexity ?? 0) < floor)
+            return false;
+        // Type check
+        if (!splittable.includes(task.type))
+            return false;
+        // Must be on critical path (foundation task)
+        if (!task.isFoundation)
+            return false;
+        // Budget capacity check
+        if (!this.budgetPool.hasCapacity())
+            return false;
+        return true;
+    }
+    /**
+     * LLM judge call: ask the orchestrator model whether and how to split a task.
+     * Returns { shouldSplit: false } or { shouldSplit: true, subtasks: [...] }.
+     */
+    async judgeSplit(task) {
+        const maxSubs = this.config.autoSplit?.maxSubtasks ?? 4;
+        const prompt = `You are evaluating whether a task should be split into parallel subtasks before dispatch.
+
+TASK: "${task.description}"
+TYPE: ${task.type}
+COMPLEXITY: ${task.complexity}/10
+TARGET FILES: ${task.targetFiles?.join(', ') || 'none specified'}
+DOWNSTREAM DEPENDENTS: This is a foundation task — other tasks are waiting on it.
+
+Should this task be split into 2-${maxSubs} parallel subtasks that different workers can execute simultaneously?
+
+SPLIT if:
+- The task involves multiple independent pieces of work (e.g., different files, different functions, different concerns)
+- Parallel execution would meaningfully reduce wall-clock time
+- The subtasks can produce useful output independently
+
+DO NOT SPLIT if:
+- The work is conceptually atomic (one function, one algorithm, tightly coupled logic)
+- The subtasks would need to coordinate on the same files/functions
+- Splitting would add more overhead than it saves
+
+Return JSON ONLY:
+{
+  "shouldSplit": true/false,
+  "reason": "brief explanation",
+  "subtasks": [
+    { "description": "...", "type": "${task.type}", "targetFiles": ["..."], "complexity": <number 1-10> }
+  ]
+}
+If shouldSplit is false, omit subtasks.`;
+        const response = await this.provider.chat([
+            { role: 'system', content: 'You are a task planning judge. Return only valid JSON.' },
+            { role: 'user', content: prompt },
+        ], {
+            model: this.config.orchestratorModel,
+            maxTokens: 1500,
+            temperature: 0.2,
+        });
+        this.trackOrchestratorUsage(response, 'auto-split-judge');
+        // Parse response — reuse markdown code block stripping from microDecompose
+        let jsonStr = response.content.trim();
+        const codeBlockMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (codeBlockMatch)
+            jsonStr = codeBlockMatch[1].trim();
+        const parsed = JSON.parse(jsonStr);
+        if (!parsed.shouldSplit) {
+            this.logDecision('auto-split', `${task.id}: judge says no split — ${parsed.reason}`, '');
+            return { shouldSplit: false };
+        }
+        if (!parsed.subtasks || !Array.isArray(parsed.subtasks) || parsed.subtasks.length < 2) {
+            return { shouldSplit: false };
+        }
+        // Build SwarmTask[] from judge output (same pattern as microDecompose)
+        const subtasks = parsed.subtasks.slice(0, maxSubs).map((sub, idx) => ({
+            id: `${task.id}-split${idx + 1}`,
+            description: sub.description,
+            type: sub.type ?? task.type,
+            dependencies: [],
+            status: 'ready',
+            complexity: Math.max(3, Math.min(sub.complexity ?? Math.ceil(task.complexity / 2), task.complexity - 1)),
+            wave: task.wave,
+            targetFiles: sub.targetFiles ?? [],
+            readFiles: task.readFiles,
+            attempts: 0,
+            rescueContext: `Auto-split from ${task.id} (original complexity ${task.complexity})`,
+        }));
+        this.logDecision('auto-split', `${task.id}: split into ${subtasks.length} subtasks — ${parsed.reason}`, subtasks.map(s => `${s.id}: ${s.description.slice(0, 60)}`).join('; '));
+        return { shouldSplit: true, subtasks };
+    }
+    /**
+     * V7: Compute effective retry limit for a task.
+     * F10: Fixup tasks get max 2 retries (3 attempts total) — one full model-failover cycle.
+     * Foundation tasks get +1 retry to reduce cascade failure risk.
+     */
+    getEffectiveRetries(task) {
+        const isFixup = 'fixesTaskId' in task;
+        if (isFixup)
+            return 2; // Fixup tasks: 2 retries max (3 attempts total)
+        return task.isFoundation ? this.config.workerRetries + 1 : this.config.workerRetries;
+    }
+    /**
+     * F22: Build a brief summary of swarm progress for retry context.
+     * Helps retrying workers understand what the swarm has already accomplished.
+     */
+    getSwarmProgressSummary() {
+        const allTasks = this.taskQueue.getAllTasks();
+        const completed = allTasks.filter(t => t.status === 'completed');
+        if (completed.length === 0)
+            return '';
+        const lines = [];
+        for (const task of completed) {
+            const score = task.result?.qualityScore ? ` (${task.result.qualityScore}/5)` : '';
+            lines.push(`- ${task.id}: ${task.description.slice(0, 80)}${score}`);
+        }
+        // Collect files created by completed tasks
+        const files = new Set();
+        const baseDir = this.config.facts?.workingDirectory ?? process.cwd();
+        for (const task of completed) {
+            for (const f of (task.result?.filesModified ?? []))
+                files.add(f);
+            for (const f of (task.targetFiles ?? [])) {
+                try {
+                    const resolved = path.resolve(baseDir, f);
+                    if (fs.existsSync(resolved))
+                        files.add(f);
+                }
+                catch { /* skip */ }
+            }
+        }
+        const parts = [`The following tasks have completed successfully:\n${lines.join('\n')}`];
+        if (files.size > 0) {
+            parts.push(`Files already created/modified: ${[...files].slice(0, 20).join(', ')}`);
+            parts.push('You can build on these existing files.');
+        }
+        return parts.join('\n');
+    }
     /** Get a model health summary for emitting events. */
     getModelHealthSummary(model) {
         const records = this.healthTracker.getAllRecords();