attocode 0.2.3 → 0.2.4

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

@@ -27,6 +27,10 @@ import { createSwarmWorkerPool } from './worker-pool.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 ──────────────────────────────────────────
 /**
  * V11: Hollow completion detection — catches empty completions AND "success" with failure language.
@@ -45,6 +49,35 @@ const BOILERPLATE_INDICATORS = [
     '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 ?? 0) === -1)
@@ -86,6 +119,10 @@ export class SwarmOrchestrator {
     config;
     provider;
     blackboard;
+    // Phase 3.1+3.2: Shared state for cross-worker learning
+    sharedContextState;
+    sharedEconomicsState;
+    sharedContextEngine;
     taskQueue;
     budgetPool;
     workerPool;
@@ -149,15 +186,28 @@ export class SwarmOrchestrator {
         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.healthTracker);
+        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));
@@ -179,6 +229,26 @@ export class SwarmOrchestrator {
                 }).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.
@@ -197,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}
+}${customTypeSection}${codebaseSection}
 
 EXAMPLE 1 — Research task (3 parallel research + 1 merge):
 {
@@ -234,12 +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({
@@ -257,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.
      */
@@ -276,8 +398,12 @@ 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}`);
+                }
             }
         }
     }
@@ -287,8 +413,12 @@ Rules:
     trackOrchestratorUsage(response, purpose) {
         if (!response.usage)
             return;
-        const tokens = response.usage.total_tokens ?? ((response.usage.prompt_tokens ?? 0) + (response.usage.completion_tokens ?? 0));
-        const cost = tokens * 0.000015; // ~$15/M tokens average for orchestrator models
+        // 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++;
@@ -325,10 +455,26 @@ Rules:
             // Phase 1: Decompose
             this.currentPhase = 'decomposing';
             this.emit({ type: 'swarm.phase.progress', phase: 'decomposing', message: 'Decomposing task into subtasks...' });
-            let 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);
@@ -338,11 +484,12 @@ Rules:
             if (!validation.valid) {
                 this.logDecision('decomposition-validation', `Invalid decomposition: ${validation.issues.join('; ')}`, 'Retrying...');
                 // Retry decomposition once with feedback
-                decomposition = await this.decompose(`${task}\n\nIMPORTANT: Previous decomposition was invalid: ${validation.issues.join('. ')}. Fix these issues.`);
-                if (!decomposition) {
+                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');
@@ -463,9 +610,15 @@ Rules:
             this.checkpoint('final');
             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,
-                partialSuccess: !executionStats.completedTasks && hasArtifacts,
+                success: isSuccess,
+                partialSuccess: isPartialSuccess || (!executionStats.completedTasks && hasArtifacts),
                 partialFailure: executionStats.failedTasks > 0,
                 synthesisResult: synthesisResult ?? undefined,
                 artifactInventory: this.artifactInventory,
@@ -495,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.
@@ -828,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,
@@ -835,14 +1196,17 @@ 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;
-        for (const task of this.taskQueue.getAllTasks()) {
-            if (task.status === 'dispatched') {
-                task.status = 'ready';
-                // Preserve at least 1 retry attempt
-                task.attempts = Math.min(task.attempts, Math.max(0, this.config.workerRetries - 1));
-                resetCount++;
-            }
+        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');
@@ -904,9 +1268,15 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         this.checkpoint('final');
         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,
-            partialSuccess: !executionStats.completedTasks && hasArtifacts,
+            success: isSuccess,
+            partialSuccess: isPartialSuccess || (!executionStats.completedTasks && hasArtifacts),
             partialFailure: executionStats.failedTasks > 0,
             synthesisResult: synthesisResult ?? undefined,
             artifactInventory: this.artifactInventory,
@@ -923,7 +1293,16 @@ 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,
@@ -1282,6 +1661,10 @@ 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',
@@ -1297,18 +1680,18 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
         });
         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 isTimeout = spawnResult.metrics.toolCalls === -1;
-            // F25: Use 'timeout' errorType for timeouts (was 'error')
-            const errorType = is429 ? '429' : is402 ? '402' : isTimeout ? 'timeout' : '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) } });
             // P6: Tag failure mode for cascade threshold awareness
-            task.failureMode = (is429 || is402) ? 'rate-limit' : (spawnResult.metrics.toolCalls === -1 ? 'timeout' : 'error');
-            // Feed circuit breaker
-            if (is429 || is402) {
+            task.failureMode = failureMode;
+            // Feed circuit breaker only for retryable rate limiting
+            if (isRateLimited) {
                 this.recordRateLimit();
             }
             // F25a: Consecutive timeout tracking — early-fail after N consecutive timeouts
@@ -1356,6 +1739,9 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                             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);
@@ -1367,8 +1753,8 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                 // Non-timeout failure — reset the counter
                 this.taskTimeoutCounts.delete(taskId);
             }
-            // V2: Model failover on rate limits
-            if ((is429 || is402) && this.config.enableModelFailover) {
+            // 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) {
@@ -1384,7 +1770,7 @@ 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 timeoutSeconds = isTimeout ? Math.round(durationMs / 1000) : 0;
                 task.retryContext = {
@@ -1397,27 +1783,37 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                     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 = (is429 || is402)
-                ? Math.min(this.config.rateLimitRetries ?? 3, baseRetries + 1)
-                : baseRetries;
+            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);
+            }
             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 (!(is429 || is402)) {
+            else if (!isRateLimited) {
                 // Resilience recovery for non-rate-limit errors (micro-decompose + degraded acceptance)
                 if (await this.tryResilienceRecovery(task, taskId, taskResult, spawnResult)) {
                     return;
@@ -1439,6 +1835,9 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                 toolCalls: spawnResult.metrics.toolCalls,
                 failoverModel: task.assignedModel !== model ? task.assignedModel : undefined,
                 failureMode: task.failureMode,
+                failureClass,
+                retrySuppressed: isNonRetryable,
+                retryReason: reason,
             });
             return;
         }
@@ -1470,6 +1869,11 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                 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 = getTaskTypeConfig(task.type, this.config).capability ?? 'code';
@@ -1704,6 +2108,11 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                         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) {
@@ -1853,6 +2262,65 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                 }
             }
         }
+        // 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;
@@ -2101,6 +2569,8 @@ Respond with JSON: { "fixups": [{ "description": "what to fix", "type": "impleme
                 decisions: this.orchestratorDecisions,
                 errors: this.errors,
                 originalPrompt: this.originalPrompt,
+                sharedContext: this.sharedContextState.toJSON(),
+                sharedEconomics: this.sharedEconomicsState.toJSON(),
             });
             this.emit({
                 type: 'swarm.state.checkpoint',
@@ -2634,7 +3104,12 @@ Return ONLY the JSON object, no other text.`;
         const toolCalls = spawnResult.metrics.toolCalls ?? 0;
         const hadToolCalls = toolCalls > 0 || toolCalls === -1
             || (taskResult.filesModified && taskResult.filesModified.length > 0);
-        if (hasArtifacts || hadToolCalls) {
+        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;