@kognai/orchestrator-core 0.1.1 → 0.1.3

package/dist/lib/engine-orchestrator.js

@@ -0,0 +1,1491 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orchestrator = void 0;
+/**
+ * engine-orchestrator.ts — the Orchestrator runtime loop extracted from orchestrate-engine.ts
+ * (TICKET-231 engine split 5). The core agent-orchestration class: spawns the leadership +
+ * coding agents, runs the sprint loop, dual-supervisor review, CTO/CEO cycle, reporting.
+ * Pulls primitives from the engine-primitives leaf and the agent classes/CodingAgent/loaders
+ * directly; the 5 engine-resident glue helpers come back from './orchestrate-engine' via a
+ * runtime-safe circular import (the class uses them at call-time, not module-load).
+ */
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const mc_client_1 = require("./mc-client");
+const chomsky_runner_1 = require("./chomsky-runner");
+const cto_approval_gate_1 = require("./cto-approval-gate");
+const wallet_state_1 = require("./wallet-state");
+const brainx_swarm_bridge_1 = require("./brainx-swarm-bridge");
+const event_bus_publisher_1 = require("./event-bus-publisher");
+const aar_middleware_1 = require("./aar-middleware");
+const skill_crystalliser_1 = require("./skill-crystalliser");
+const trust_score_updater_1 = require("./trust-score-updater");
+const code_asset_crystalliser_1 = require("./code-asset-crystalliser");
+const monotask_state_machine_1 = require("./monotask-state-machine");
+const code_failure_logger_1 = require("./code-failure-logger");
+const token_budget_validator_1 = require("./token-budget-validator");
+const decomposer_feedback_1 = require("./decomposer-feedback");
+const phantom_workspace_1 = require("./omel/phantom-workspace");
+const wipe_witness_1 = require("./omel/wipe-witness");
+const human_brake_1 = require("./omel/human-brake");
+const perm_judge_1 = require("./perm-judge");
+const orchestrator_tap_1 = require("./ksl/orchestrator-tap");
+const engine_primitives_1 = require("./engine-primitives");
+const engine_agents_1 = require("./engine-agents");
+const engine_coding_agent_1 = require("./engine-coding-agent");
+const engine_loaders_1 = require("./engine-loaders");
+const orchestrate_engine_1 = require("./orchestrate-engine");
+class Orchestrator {
+    spawnGate;
+    ceo;
+    cto;
+    supervisor;
+    supervisor2;
+    agents = new Map();
+    tasks = [];
+    stats = { tasksExecuted: 0, approved: 0, rejected: 0, totalTokens: 0, conflicts: 0, escalations: 0 };
+    // Per-task structured run records — written to swarm run report at end of sprint
+    taskRuns = [];
+    /**
+     * Persist a single task's status back to the on-disk sprint file.
+     *
+     * Sprint-1547 fix: previously, task statuses were only written at end-of-run
+     * (line ~3055). Any exception, OOM, or SIGKILL between an approval and the
+     * end-of-run write dropped the approval — the sprint file still said
+     * 'pending', the sprint-runner cron repicked the same sprint, and the same
+     * task ran again. Sprint-1545 looped 30+ times overnight from this.
+     *
+     * Read-modify-write so concurrent edits to OTHER tasks (e.g. another
+     * Claude session) survive — we only overwrite this task's slot.
+     *
+     * Failure must NOT block the next task. Logged and swallowed.
+     */
+    persistTaskStatus(task) {
+        const sprintFile = process.argv[2] || 'sprints/current.json';
+        try {
+            if (!(0, fs_1.existsSync)(sprintFile))
+                return;
+            const sprintRaw = JSON.parse((0, fs_1.readFileSync)(sprintFile, 'utf-8'));
+            const arr = Array.isArray(sprintRaw.tasks) ? sprintRaw.tasks : null;
+            if (!arr)
+                return;
+            const idx = arr.findIndex((t) => t && t.id === task.id);
+            if (idx < 0)
+                return;
+            arr[idx] = { ...arr[idx], status: task.status };
+            // sprint-1566 F0/F0c: also persist rejected_reason when set (replaced-by-split, over-budget)
+            if (task.rejected_reason)
+                arr[idx].rejected_reason = task.rejected_reason;
+            // CTO-006 telemetry-blackout hotfix (2026-05-29, Slice A of TICKET-135):
+            // persist attempt_count + score + grade + rejection_reason. Without
+            // these, the .swarm-state file showed only {status, attempt_count: 1}
+            // even after 3 attempts, and every CTO retrospective marked score=? +
+            // attempts=?. 10 consecutive zero-ship sprints diagnosed as "we can't
+            // root-cause because telemetry is dark." This wires the orchestrator's
+            // in-memory fields → ACTIVE → .swarm-state via sprint-runner's sync.
+            if (task.attempt_count != null)
+                arr[idx].attempt_count = task.attempt_count;
+            if (task.score != null)
+                arr[idx].score = task.score;
+            if (task.grade != null)
+                arr[idx].grade = task.grade;
+            if (task.rejection_reason != null)
+                arr[idx].rejection_reason = task.rejection_reason;
+            // TICKET-094 FIX: atomic write via temp+rename. Plain writeFileSync was
+            // vulnerable to concurrent-reader-sees-empty-file races AND interleaved-
+            // writer truncation. The disk-state revert that stranded sprint-1588 +
+            // sprint-1589 in all-pending despite "Synced N updates" was almost
+            // certainly the orchestrator + sprint-runner.ts sync racing on the
+            // same file at sprint end. Tmp+rename is atomic on POSIX — readers see
+            // either old or new, never half.
+            const tmp = `${sprintFile}.tmp.${process.pid}.${Date.now()}`;
+            (0, fs_1.writeFileSync)(tmp, JSON.stringify(sprintRaw, null, 2));
+            require('fs').renameSync(tmp, sprintFile);
+        }
+        catch (e) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  [persist] Failed to update ${task.id} status: ${(e?.message || '').substring(0, 100)}`);
+        }
+    }
+    /** sprint-1566 F0/F0d: inject decomposer-split sub-tasks into the active
+     *  sprint file as new pending tasks. Sprint-runner picks them up on the next
+     *  cron tick. The original task stays in the file with status='replaced-by-split'.
+     *
+     *  Founder fix 2026-05-27: ALSO push to this.tasks (in-memory). The sprint-end
+     *  writeFileSync at line 4088 dumps this.tasks back to ACTIVE, overwriting
+     *  whatever we wrote to disk here. Without the in-memory push, injected
+     *  sub-tasks were silently wiped at sprint-end and the persistence fix
+     *  in sprint-runner.ts saw nothing to forward to the source sprint file.
+     *  This is the root cause of the 0-ship pattern in sprint-1596/1597. */
+    injectSplitTasks(original, splits, rationale) {
+        const sprintFile = process.argv[2] || 'sprints/current.json';
+        if (!(0, fs_1.existsSync)(sprintFile))
+            return;
+        const sprintRaw = JSON.parse((0, fs_1.readFileSync)(sprintFile, 'utf-8'));
+        if (!Array.isArray(sprintRaw.tasks))
+            return;
+        const existingIds = new Set(sprintRaw.tasks.map((t) => t?.id));
+        let injected = 0;
+        for (const s of splits) {
+            if (existingIds.has(s.id))
+                continue; // idempotent: already split before
+            const newTask = {
+                ...s,
+                attempt_count: 0,
+                parent_task_id: original.id,
+                split_rationale: rationale,
+                injected_at: new Date().toISOString(),
+            };
+            sprintRaw.tasks.push(newTask);
+            // Also push to in-memory — survives the sprint-end ACTIVE rewrite.
+            this.tasks.push(newTask);
+            injected++;
+        }
+        if (injected > 0)
+            (0, fs_1.writeFileSync)(sprintFile, JSON.stringify(sprintRaw, null, 2));
+        (0, engine_primitives_1.log)(engine_primitives_1.c.green, `    [inject] Added ${injected} split sub-tasks to ${sprintFile} (in-memory + on-disk)`);
+    }
+    // TICKET-225: optional template-supplied spawn governance gate, threaded
+    // from runOrchestrator(config) down to AgentCreator. Undefined = no gate.
+    constructor(spawnGate) {
+        this.spawnGate = spawnGate;
+        (0, engine_primitives_1.log)(engine_primitives_1.c.bold, '\n╔══════════════════════════════════════════════════════════╗');
+        (0, engine_primitives_1.log)(engine_primitives_1.c.bold, '║   Kognai Swarm Orchestrator v2.17 — V17 Architecture     ║');
+        (0, engine_primitives_1.log)(engine_primitives_1.c.bold, '║   Local-first · ClawRouter cloud · DeepSeek reviews      ║');
+        (0, engine_primitives_1.log)(engine_primitives_1.c.bold, '╚══════════════════════════════════════════════════════════╝\n');
+        // Leadership layer (CEO = Claude via Anthropic; Sup1 = DeepSeek/Sonnet;
+        // Sup2 = Haiku with DeepSeek fallback. Both supervisors were originally
+        // Sonnet + Codex — see file-header history note.)
+        this.ceo = new engine_agents_1.CEOAgent();
+        this.supervisor = new engine_agents_1.SupervisorAgent();
+        this.supervisor2 = new engine_agents_1.Supervisor2Agent();
+        // Technology layer (MiniMax)
+        this.cto = new engine_agents_1.CTOAgent();
+        // Execution layer — dynamically load all coding agents from agents/ directory
+        const skipAgents = ['ceo', 'supervisor', 'skills', 'cto', 'cmo'];
+        const agentDirs = (0, fs_1.existsSync)('./agents') ? (0, fs_1.readdirSync)('./agents').filter(d => {
+            if (skipAgents.includes(d))
+                return false;
+            return (0, fs_1.existsSync)(`./agents/${d}/prompt.md`);
+        }) : [];
+        // Constitutional preamble — injected into every agent's system prompt
+        const constitutionalPreamble = (0, engine_loaders_1.loadConstitutionalPreamble)();
+        if (constitutionalPreamble) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.green, '  ⚖️  Constitutional preamble loaded — will bind all agents');
+        }
+        for (const name of agentDirs) {
+            const promptPath = `./agents/${name}/prompt.md`;
+            const rawPrompt = (0, fs_1.readFileSync)(promptPath, 'utf-8');
+            const prompt = constitutionalPreamble + rawPrompt;
+            this.agents.set(name, new engine_coding_agent_1.CodingAgent(name, prompt));
+            (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `+ Loaded ${name} agent (MiniMax M2.5)`);
+        }
+        // Agent count: CEO + Sup1 + Sup2 (all 3 Anthropic-bound, with provider routing happening per-call)
+        // + 1 CMO (qwen3:4b local) + 1 CTO (MiniMax) + N coders (MiniMax)
+        const totalAgents = 3 + 1 + 1 + this.agents.size;
+        (0, engine_primitives_1.log)(engine_primitives_1.c.green, `\n✓ ${totalAgents} agents loaded (3 Anthropic-bound leadership + 1 CMO qwen3:4b + ${1 + this.agents.size} MiniMax)\n`);
+    }
+    loadTasks() {
+        const sprintFile = process.argv[2] || 'sprints/current.json';
+        if (!(0, fs_1.existsSync)(sprintFile)) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.red, `Sprint file not found: ${sprintFile}`);
+            process.exit(1);
+        }
+        const sprint = JSON.parse((0, fs_1.readFileSync)(sprintFile, 'utf-8'));
+        this.tasks = sprint.tasks || [];
+        const _sprintId = sprintFile.replace(/.*\//, '').replace('.json', '');
+        // Normalize deliverables: CEO planner may emit flat string[] instead of {code,tests,docs}
+        for (const task of this.tasks) {
+            const d = task.deliverables;
+            if (!d) {
+                // Sprint JSON may omit deliverables — default from task_target
+                const target = task.task_target;
+                task.deliverables = { code: target ? [target] : [], tests: [], docs: [] };
+            }
+            else if (Array.isArray(d)) {
+                task.deliverables = {
+                    code: d.filter((f) => f.indexOf("test") === -1 && f.indexOf("spec") === -1 && f.slice(-3) !== ".md"),
+                    tests: d.filter((f) => f.indexOf("test") !== -1 || f.indexOf("spec") !== -1),
+                    docs: d.filter((f) => f.slice(-3) === ".md"),
+                };
+            }
+            // Normalize description → context: sprint JSON files may use either field name
+            if (!task.context && task.description) {
+                task.context = task.description;
+            }
+            // Ensure context is always a string (never undefined)
+            if (!task.context)
+                task.context = `${task.id}: ${task.title || task.type}`;
+            // Normalize priority: sprint JSON may omit it
+            if (!task.priority)
+                task.priority = 'medium';
+            // Fix: task_target used as file path (e.g., 'scripts/lib/foo.ts') must be cleared
+            // so it doesn't confuse the routing switch which expects: local|cloud-code|cloud-exec|cloud-post
+            const VALID_ROUTING_TARGETS = ['local', 'cloud-code', 'cloud-exec', 'cloud-post'];
+            if (task.task_target && !VALID_ROUTING_TARGETS.includes(task.task_target)) {
+                delete task.task_target; // file path already captured in deliverables.code
+            }
+            // Stamp sprint_id — avoids 'unknown' in logs/routing/YYYY-MM-DD.jsonl
+            if (!task.sprint_id)
+                task.sprint_id = _sprintId;
+        }
+        // Reset stale in_progress tasks back to pending
+        for (const task of this.tasks) {
+            if (task.status === 'in_progress' || task.status === 'review') {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Resetting stale task ${task.id} (${task.status} -> pending)`);
+                task.status = 'pending';
+            }
+        }
+        (0, engine_primitives_1.log)(engine_primitives_1.c.blue, `Loaded ${this.tasks.length} tasks from ${sprintFile}`);
+    }
+    // ===== Truncation Detection =====
+    isTruncationRejection(review) {
+        const truncationKeywords = [
+            'truncat', 'incomplete', 'cut off', 'cuts off', 'ends abruptly',
+            'missing implementation', 'missing the actual', 'file is incomplete',
+            'cuts off mid', 'missing core functionality', 'missing the entire',
+        ];
+        const text = (review.summary + ' ' +
+            (review.issues || []).map(i => i.description).join(' ')).toLowerCase();
+        return truncationKeywords.some(kw => text.includes(kw));
+    }
+    // ===== CTO Task Decomposition (for truncation-prone tasks) =====
+    async ctoDecomposeTask(task) {
+        (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `\n[cto-decompose] 🔧 CTO splitting ${task.id} into smaller sub-tasks...`);
+        const allDeliverables = [
+            ...(task.deliverables.code || []),
+            ...(task.deliverables.tests || []),
+        ];
+        const userPrompt = `A task keeps failing because MiniMax M2.5 truncates output when generating multiple files.
+
+## Failed Task
+- ID: ${task.id}
+- Agent: ${task.agent}
+- Context: ${task.context.substring(0, 1500)}
+- Deliverable files: ${allDeliverables.join(', ')}
+
+## Problem
+MiniMax M2.5 has a ~4500 token output limit per call. When a task has ${allDeliverables.length} files, each file gets less space and code gets truncated.
+
+## Your Job
+Split this task into smaller sub-tasks. Each sub-task must have at most 1 code file + 1 test file (2 files max).
+
+## Rules
+1. Types/interfaces files FIRST (other files depend on them)
+2. Barrel/index export files LAST (they import from everything else)
+3. Each sub-task must be self-contained (agent can generate it without seeing other sub-task results)
+4. Include enough context in each sub-task for the agent to know what to generate
+5. Maximum 5 sub-tasks
+
+## Output Format
+Return a JSON array of sub-task specs:
+[
+  {
+    "sub_id": "${task.id}-A",
+    "context": "Full task context for this sub-task including what types/interfaces to define",
+    "code": ["path/to/file.ts"],
+    "tests": ["path/to/file.test.ts"]
+  }
+]
+
+ONLY output the JSON array. No markdown, no explanation.`;
+        try {
+            const response = await (0, engine_primitives_1.callLLM)('clawrouter', 'deepseek/deepseek-chat', this.cto['systemPrompt'] || '', userPrompt, 120000, 'cto', 'fallback_task_decomposer');
+            let content = response.choices?.[0]?.message?.content || '';
+            content = content.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+            const jsonMatch = content.match(/\[[\s\S]*\]/);
+            if (!jsonMatch) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, '  CTO decomposition returned no JSON, falling back to mechanical split');
+                return this.fallbackDecompose(task);
+            }
+            const specs = JSON.parse(jsonMatch[0]);
+            if (!Array.isArray(specs) || specs.length < 2) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, '  CTO returned <2 sub-tasks, falling back to mechanical split');
+                return this.fallbackDecompose(task);
+            }
+            // Convert specs to AgentTask objects
+            const subtasks = specs.slice(0, 5).map((spec, i) => ({
+                id: spec.sub_id || `${task.id}-${String.fromCharCode(65 + i)}`,
+                agent: task.agent,
+                type: task.type,
+                priority: task.priority,
+                dependencies: i > 0 ? [specs[i - 1].sub_id || `${task.id}-${String.fromCharCode(64 + i)}`] : [],
+                context: spec.context,
+                deliverables: {
+                    code: spec.code || [],
+                    tests: spec.tests || [],
+                },
+                status: 'pending',
+            }));
+            (0, engine_primitives_1.log)(engine_primitives_1.c.green, `  ✓ CTO decomposed ${task.id} into ${subtasks.length} sub-tasks:`);
+            for (const st of subtasks) {
+                const files = [...(st.deliverables.code || []), ...(st.deliverables.tests || [])];
+                (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `    ${st.id}: ${files.join(', ')}`);
+            }
+            return subtasks;
+        }
+        catch (error) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  CTO decomposition failed: ${error.message}, using fallback`);
+            return this.fallbackDecompose(task);
+        }
+    }
+    // ===== Fallback: Mechanical file-based split =====
+    fallbackDecompose(task) {
+        const codeFiles = task.deliverables.code || [];
+        const testFiles = task.deliverables.tests || [];
+        (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  [fallback] Mechanically splitting ${task.id} by file...`);
+        const subtasks = [];
+        for (let i = 0; i < codeFiles.length; i++) {
+            const code = codeFiles[i];
+            // Find matching test file
+            const baseName = code.replace(/\.ts$/, '').split('/').pop() || '';
+            const matchingTest = testFiles.find(t => t.includes(baseName) && (t.includes('.test.') || t.includes('.spec.')));
+            subtasks.push({
+                id: `${task.id}-${String.fromCharCode(65 + i)}`,
+                agent: task.agent,
+                type: task.type,
+                priority: task.priority,
+                dependencies: i > 0 ? [`${task.id}-${String.fromCharCode(64 + i)}`] : [],
+                context: `${task.context}\n\n## SUB-TASK: Generate ONLY the file "${code}"${matchingTest ? ` and its test "${matchingTest}"` : ''}.\nThis is part of a larger task that was split to avoid truncation. Focus on this file only. Make it complete and self-contained.`,
+                deliverables: {
+                    code: [code],
+                    tests: matchingTest ? [matchingTest] : [],
+                },
+                status: 'pending',
+            });
+        }
+        // Handle orphan test files (tests without matching code file)
+        const usedTests = subtasks.flatMap(st => st.deliverables.tests || []);
+        const orphanTests = testFiles.filter(t => !usedTests.includes(t));
+        if (orphanTests.length > 0) {
+            subtasks.push({
+                id: `${task.id}-${String.fromCharCode(65 + codeFiles.length)}`,
+                agent: task.agent,
+                type: task.type,
+                priority: task.priority,
+                dependencies: subtasks.length > 0 ? [subtasks[subtasks.length - 1].id] : [],
+                context: `${task.context}\n\n## SUB-TASK: Generate ONLY the test file(s): ${orphanTests.join(', ')}.\nAll source code files have already been generated. Write tests that import from the existing source files.`,
+                deliverables: {
+                    code: [],
+                    tests: orphanTests,
+                },
+                status: 'pending',
+            });
+        }
+        (0, engine_primitives_1.log)(engine_primitives_1.c.green, `  ✓ Fallback split ${task.id} into ${subtasks.length} sub-tasks`);
+        return subtasks;
+    }
+    // ===== Sub-task executor (limited retries, no recursive decomposition) =====
+    async executeSubTask(subtask, maxRetries) {
+        // Sprint 1309: default to 'coder' when subtask.agent is not set
+        const subAgentName = subtask.agent || 'coder';
+        const agent = this.agents.get(subAgentName);
+        if (!agent) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.red, `  Agent not found for sub-task: ${subAgentName}`);
+            return false;
+        }
+        let lastReview;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.blue, `\n  [sub-task] ${subtask.id} | Attempt: ${attempt}/${maxRetries}`);
+            this.stats.tasksExecuted++;
+            // AMD-08: depth=1 (sub-agent chain)
+            if (!monotask_state_machine_1.MonotaskSM.claim(subtask.agent, subtask.id, 1)) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  [monotask] ${subtask.agent} unavailable — skipping sub-task attempt ${attempt}`);
+                continue;
+            }
+            monotask_state_machine_1.MonotaskSM.start(subtask.agent, subtask.id);
+            const subStart = Date.now();
+            const result = await agent.execute(subtask, lastReview);
+            if (result.files.length === 0) {
+                const dels = [...(subtask.deliverables?.code || []), ...(subtask.deliverables?.tests || []), ...(subtask.deliverables?.docs || [])];
+                const reasons = subtask._failureReasons || [];
+                const inferred = reasons.length ? reasons.join('; ') : (dels.length === 0 ? 'empty-deliverables' : 'unknown');
+                (0, engine_primitives_1.log)(engine_primitives_1.c.red, `  ✗ No files produced for sub-task ${subtask.id} [model=${result.model || 'n/a'}, deliverables=${dels.length}, reason=${inferred}]`);
+                monotask_state_machine_1.MonotaskSM.release(subtask.agent, subtask.id, `no files: ${inferred.slice(0, 60)}`);
+                return false;
+            }
+            // Dual supervisor review
+            const [review1, review2] = await Promise.all([
+                this.supervisor.reviewTask(subtask, result.files),
+                this.supervisor2.reviewTask(subtask, result.files),
+            ]);
+            const dualResult = await (0, engine_agents_1.reconcileSupervisorReviews)(review1, review2, subtask, this.ceo);
+            const review = dualResult.finalReview;
+            if (!dualResult.consensus)
+                this.stats.conflicts++;
+            if (dualResult.escalatedToCEO)
+                this.stats.escalations++;
+            lastReview = review;
+            // TICKET-214: instrument SUB-TASK attempts. The MAIN task loop already taps KSL +
+            // records reputation, but the split sub-task loop did neither — so split sprints
+            // went unrecorded in KSL and their rejections were never filed. Tap + score every
+            // attempt here too. Best-effort, non-fatal.
+            (0, orchestrate_engine_1.recordAgentScore)(subtask.agent, review.score);
+            try {
+                const _sid = (0, orchestrate_engine_1.resolveActiveSprintId)();
+                (0, orchestrator_tap_1.tapAttempt)({
+                    sprint_id: _sid, task_id: subtask.id, attempt, agent: subtask.agent,
+                    model: result.model || 'unknown',
+                    prompt: String(subtask.context || subtask.title || subtask.id),
+                    reply: (result.files || []).map((f) => f.content || '').join('\n').slice(0, 20000),
+                    duration_ms: Date.now() - subStart,
+                });
+            }
+            catch { /* non-fatal */ }
+            if (review.verdict === 'APPROVED') {
+                this.stats.approved++;
+                monotask_state_machine_1.MonotaskSM.complete(subtask.agent, subtask.id);
+                (0, engine_primitives_1.log)(engine_primitives_1.c.green, `  ✓ Sub-task ${subtask.id} APPROVED on attempt ${attempt} (${review.score}/100)`);
+                return true;
+            }
+            this.stats.rejected++;
+            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  ↻ Sub-task ${subtask.id} REJECTED on attempt ${attempt} (${review.score}/100)`);
+            try {
+                (0, code_failure_logger_1.logCodeFailure)({ taskId: subtask.id, sprintId: (0, orchestrate_engine_1.resolveActiveSprintId)(), agentId: (0, orchestrate_engine_1.resolveAgentDid)(subtask.agent), attemptNum: attempt, score: review.score || 0, model: result.model || 'unknown', rejectionReason: review.summary || 'sub-task rejected', issues: review.issues || [], failType: 'supervisor_rejected' });
+            }
+            catch { /* non-fatal */ }
+            (0, engine_primitives_1.safeResetLastCommit)(subtask.id, subtask.agent, subtask.type, '    ');
+            monotask_state_machine_1.MonotaskSM.release(subtask.agent, subtask.id, `rejected attempt ${attempt}`);
+        }
+        (0, engine_primitives_1.log)(engine_primitives_1.c.red, `  ✗ Sub-task ${subtask.id} FAILED after ${maxRetries} attempts`);
+        return false;
+    }
+    // ===== Main task executor with CTO auto-decomposition =====
+    async executeTask(task) {
+        // Sprint 1309: default to 'coder' when task.agent is not set (queue-prescribed sprints omit agent field)
+        const agentName = task.agent || 'coder';
+        const agent = this.agents.get(agentName);
+        if (!agent) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.red, `Agent not found: ${agentName}`);
+            task.status = 'rejected';
+            this.persistTaskStatus(task);
+            // Record failure in taskRuns
+            this.taskRuns.push({
+                task_id: task.id, title: task.title || task.id, type: task.type,
+                task_target: task.task_target || 'cloud-code',
+                status: 'rejected', attempts: 0, model_used: '', provider: '',
+                tokens_total: 0, duration_seconds: 0, files_written: [],
+                review: null, error: `Agent not found: ${agentName}`, rejection_reason: 'Agent not found',
+            });
+            return;
+        }
+        // Sprint 706: BrainX — inject memories before task execution
+        try {
+            if (this._brainxBridge) {
+                const injection = await this._brainxBridge.injectMemories(task.agent);
+                if (injection.memory_count > 0)
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  [BrainX] Injected ${injection.memory_count} memories for ${task.agent}`);
+            }
+        }
+        catch { /* BrainX injection is non-blocking */ }
+        const taskRunStart = Date.now();
+        const taskRun = {
+            task_id: task.id,
+            title: task.title || task.id,
+            type: task.type,
+            task_target: task.task_target || 'cloud-code',
+            status: 'pending',
+            attempts: 0,
+            model_used: '',
+            provider: '',
+            tokens_total: 0,
+            duration_seconds: 0,
+            files_written: [],
+            review: null,
+            error: null,
+            rejection_reason: null,
+        };
+        // sprint-1566 F0b: aligned with sprint-runner's PER_TASK_LIFETIME_MAX_ATTEMPTS=5.
+        // Was 10 (single-line const hidden under a misleading comment claiming it had
+        // already been lowered — it hadn't). At 10 retries × ~14K tokens/attempt
+        // (MiniMax + dual review) a single stuck task could burn ~140K tokens before
+        // the lifetime gate had a chance to look at it on the next run.
+        const MAX_RETRIES = parseInt(process.env.MAX_RETRIES_PER_RUN || '3', 10);
+        const TRUNCATION_THRESHOLD = 1;
+        // sprint-1566 F0c: per-task token budget. Caps cumulative tokens spent on
+        // one task across its retries so a single task can't eat the daily wallet.
+        // Raised 2026-05-27 from 25K → 50K: sprint-1590 lost 3 of 6 tasks because
+        // first-attempt token spend (30-62K) routinely exceeded the 25K cap,
+        // killing retries before supervisor rejection feedback could be applied.
+        // 50K = ~$0.10 worst-case at DeepSeek pricing for first attempt + 1 retry.
+        // TICKET-209 (2026-05-29): bumped 100k → 200k. With EDIT-MODE now the
+        // default for modify tasks, 200k is more headroom than legitimate work
+        // needs — but covers the long-tail of large create tasks (multi-section
+        // spec docs, full-module rewrites) without forcing escalation.
+        const PER_TASK_TOKEN_BUDGET = parseInt(process.env.PER_TASK_TOKEN_BUDGET || '200000', 10);
+        let taskTokensSpent = 0;
+        let truncationCount = 0;
+        let lastReview;
+        // OMEL AMD-13: Create isolated tmpdir for this task (cleaned up in finally)
+        const phantomCtx = phantom_workspace_1.phantomWorkspace.create(task.id);
+        try {
+            // CTO-20260528-002 (2026-05-27): one-file-per-call enforcement.
+            // The store_page incident in v12r+1 was a multi-file task that nobody
+            // pre-screened. Atomic tasks are easier to review, retry, and roll back.
+            // If a task targets >1 source file, force a per-file split up front —
+            // routeToDecomposer's Strategy A handles this deterministically.
+            {
+                const codeFiles = task.deliverables?.code?.filter((f) => !/__tests__|\.test\./.test(f)) || [];
+                const editFiles = task.deliverables?.edits || [];
+                const sourceFileCount = codeFiles.length + editFiles.length;
+                if (sourceFileCount > 1 && task.agent === 'coder') {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  [Atomicity] PRE-FLIGHT REJECT: ${task.id} targets ${sourceFileCount} source files (one-file-per-call policy)`);
+                    const route = (0, decomposer_feedback_1.routeToDecomposer)({
+                        original_task_id: task.id,
+                        rejection_signal: 'needs_resplit',
+                        suggested_splits: [...codeFiles, ...editFiles],
+                        learnings_ref: 'docs/learnings.md §1',
+                        original_task: task,
+                    });
+                    if ('task_split' in route) {
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `  [Atomicity] split into ${route.task_split.length} per-file sub-tasks`);
+                        try {
+                            this.injectSplitTasks(task, route.task_split, route.rationale);
+                        }
+                        catch (e) {
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.red, `    Inject failed: ${e.message?.slice(0, 120)}`);
+                        }
+                        task.status = 'replaced-by-split';
+                        task.rejected_reason = `Replaced by ${route.task_split.length} per-file sub-tasks (one-file-per-call policy)`;
+                        this.persistTaskStatus(task);
+                        taskRun.status = 'replaced-by-split';
+                        taskRun.rejection_reason = 'Atomicity pre-flight: multi-file task';
+                        taskRun.duration_seconds = Math.round((Date.now() - taskRunStart) / 1000);
+                        this.taskRuns.push(taskRun);
+                        phantom_workspace_1.phantomWorkspace.cleanup(phantomCtx);
+                        return;
+                    }
+                    // Unsplittable multi-file (e.g. zero deliverables resolved) → fall through
+                    // to the token validator so we don't hard-block tasks the decomposer can't
+                    // disambiguate. Logged for founder review.
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  [Atomicity] decomposer could not split — proceeding (founder review): ${route.reason}`);
+                }
+            }
+            // sprint-1566 F0: pre-flight token-budget validator. If the task's output
+            // is predicted to exceed the MiniMax truncation point (~4500 tokens),
+            // route to decomposer-feedback for a structural re-split BEFORE any LLM
+            // is dispatched. Stops the truncation cascade at the source.
+            const validation = (0, token_budget_validator_1.validateTask)(task);
+            if (!validation.ok) {
+                // Discriminated-union narrow via Extract — boolean discriminator alone
+                // isn't reliably narrowing under our tsconfig + alias-imported types.
+                const rej = validation;
+                (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  [TokenBudget] PRE-FLIGHT REJECT: ${task.id} — est ${rej.estimated_tokens} tokens > threshold`);
+                (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `    Reason: ${rej.reason}`);
+                (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `    Suggested split: ${rej.suggested_split.join(', ')}`);
+                const route = (0, decomposer_feedback_1.routeToDecomposer)({
+                    original_task_id: task.id,
+                    rejection_signal: 'needs_resplit',
+                    original_estimate_tokens: rej.estimated_tokens,
+                    suggested_splits: rej.suggested_split,
+                    learnings_ref: 'docs/learnings.md §1',
+                    original_task: task,
+                });
+                if ('task_split' in route) {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `  [DecomposerFeedback] split into ${route.task_split.length} sub-tasks via ${route.strategy}`);
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `    ${route.rationale}`);
+                    // Inject splits as new pending tasks so they get picked up next run.
+                    // Persist to the active sprint file so sprint-runner sees them.
+                    try {
+                        this.injectSplitTasks(task, route.task_split, route.rationale);
+                    }
+                    catch (e) {
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.red, `    Inject failed: ${e.message?.slice(0, 120)}`);
+                    }
+                    task.status = 'replaced-by-split';
+                    task.rejected_reason = `Replaced by ${route.task_split.length} per-${route.strategy === 'per_file' ? 'file' : 'part'} sub-tasks (pre-flight budget gate)`;
+                    this.persistTaskStatus(task);
+                    taskRun.status = 'replaced-by-split';
+                    taskRun.rejection_reason = `Token-budget pre-flight: ${rej.reason}`;
+                    taskRun.duration_seconds = Math.round((Date.now() - taskRunStart) / 1000);
+                    this.taskRuns.push(taskRun);
+                    phantom_workspace_1.phantomWorkspace.cleanup(phantomCtx);
+                    return;
+                }
+                else {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.red, `  [DecomposerFeedback] cannot split → escalate to founder: ${route.reason}`);
+                    task.status = 'rejected';
+                    task.rejected_reason = route.reason;
+                    this.persistTaskStatus(task);
+                    taskRun.status = 'rejected';
+                    taskRun.error = route.reason;
+                    taskRun.rejection_reason = 'Token-budget pre-flight + unsplittable';
+                    taskRun.duration_seconds = Math.round((Date.now() - taskRunStart) / 1000);
+                    this.taskRuns.push(taskRun);
+                    phantom_workspace_1.phantomWorkspace.cleanup(phantomCtx);
+                    return;
+                }
+            }
+            for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                // CTO-006 telemetry-blackout hotfix (2026-05-29, Slice A of TICKET-135):
+                // record attempt_count on the task so it propagates via persistTaskStatus
+                // → ACTIVE → .swarm-state → CTO's retrospective. Without this, every
+                // post-mortem said attempt_count=? after 3 attempts. 10 zero-ship
+                // sprints diagnosed by the CTO as "we can't root-cause because
+                // telemetry is dark."
+                task.attempt_count = attempt;
+                // Reset per-attempt flags so the escalation pact only fires when THIS
+                // attempt's execution actually tripped integrity/truncation, not stale
+                // state from a prior attempt.
+                delete task._integrityFailed;
+                // sprint-1566 F0c: per-task token budget check at start of each attempt
+                if (taskTokensSpent >= PER_TASK_TOKEN_BUDGET) {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.red, `  [TokenBudget] PER-TASK BUDGET EXCEEDED: ${task.id} spent ${taskTokensSpent} > ${PER_TASK_TOKEN_BUDGET} tokens — aborting retries`);
+                    task.status = 'rejected';
+                    task.rejected_reason = `Per-task budget exceeded: ${taskTokensSpent} > ${PER_TASK_TOKEN_BUDGET} tokens after ${attempt - 1} attempts`;
+                    taskRun.status = 'rejected';
+                    taskRun.error = `Per-task token budget exceeded (${taskTokensSpent}/${PER_TASK_TOKEN_BUDGET})`;
+                    taskRun.rejection_reason = 'Per-task budget exceeded';
+                    // Route to decomposer for over-budget too — same as truncation
+                    try {
+                        const route = (0, decomposer_feedback_1.routeToDecomposer)({
+                            original_task_id: task.id,
+                            rejection_signal: 'over_budget',
+                            original_estimate_tokens: taskTokensSpent,
+                            suggested_splits: [],
+                            learnings_ref: 'docs/learnings.md §1',
+                            original_task: task,
+                        });
+                        if ('task_split' in route) {
+                            this.injectSplitTasks(task, route.task_split, route.rationale);
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `  [DecomposerFeedback] over-budget → ${route.task_split.length} sub-tasks injected for next run`);
+                        }
+                        else {
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  [DecomposerFeedback] over-budget unsplittable: ${route.reason}`);
+                        }
+                    }
+                    catch (e) {
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.red, `    Inject failed: ${e.message?.slice(0, 120)}`);
+                    }
+                    break;
+                }
+                (0, engine_primitives_1.log)(engine_primitives_1.c.blue, `\n${'='.repeat(60)}`);
+                (0, engine_primitives_1.log)(engine_primitives_1.c.blue, `Task: ${task.id} | Agent: ${task.agent} | Attempt: ${attempt}/${MAX_RETRIES}`);
+                (0, engine_primitives_1.log)(engine_primitives_1.c.blue, `${'='.repeat(60)}`);
+                // AMD-26 KSL: snapshot per-attempt context for the tap.
+                let kslSprintId = (process.argv[2] || 'sprints/current.json').replace(/.*\//, '').replace('.json', '');
+                // sprint-runner passes logs/sprint-runner-active.json — read the real sprint_id from its contents.
+                if (kslSprintId === 'sprint-runner-active') {
+                    try {
+                        kslSprintId = JSON.parse((0, fs_1.readFileSync)(process.argv[2], 'utf-8')).sprint_id || kslSprintId;
+                    }
+                    catch { /* fall back to path-derived */ }
+                }
+                const kslAttemptStart = Date.now();
+                const kslPrompt = String(task.context || task.title || task.id);
+                task.status = 'in_progress';
+                if (attempt === 1) {
+                    const _sprintId = kslSprintId;
+                    (0, event_bus_publisher_1.publishTaskStarted)(task.agent, _sprintId, task.id, task.title || task.id).catch(() => { });
+                }
+                this.stats.tasksExecuted++;
+                taskRun.attempts = attempt;
+                // AMD-08: IDLE → RESERVED → ACTIVE (per attempt)
+                if (!monotask_state_machine_1.MonotaskSM.claim(task.agent, task.id)) {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  [monotask] ${task.agent} unavailable — skipping attempt ${attempt}`);
+                    continue;
+                }
+                monotask_state_machine_1.MonotaskSM.start(task.agent, task.id);
+                // OMEL AMD-13: WipeWitness — capture file state before agent writes
+                const preTokens = new Map();
+                for (const f of (task.deliverables?.code || [])) {
+                    if ((0, fs_1.existsSync)(f))
+                        preTokens.set(f, wipe_witness_1.wipeWitness.beforeWrite(f, task.agent));
+                }
+                // OMEL AMD-13: HumanBrake — require approval for bulk_overwrite on high-risk files
+                if (task.type === 'modify' && (task.deliverables?.code || []).length > 0) {
+                    const firstFile = (task.deliverables?.code || [])[0] || '';
+                    if (human_brake_1.humanBrake.isHighRisk('bulk_overwrite', { filePath: firstFile })) {
+                        const approval = await human_brake_1.humanBrake.requireApproval('bulk_overwrite');
+                        if (!approval.approved) {
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  [HumanBrake] SKIPPED: ${task.id} — ${approval.reason || 'not approved'}`);
+                            task.status = 'skipped';
+                            monotask_state_machine_1.MonotaskSM.release(task.agent, task.id, `human brake: ${approval.reason || 'not approved'}`);
+                            break; // exit attempt loop — task will not execute
+                        }
+                    }
+                }
+                // Execute with rejection feedback if retrying
+                const tokensBefore = engine_primitives_1._globalTokensThisRun;
+                let result;
+                // Chomsky gate — evaluate + rewrite (max 2×) + log all evals (Sprint 1513)
+                if (task.context) {
+                    try {
+                        const chomskyRun = await (0, chomsky_runner_1.runChomskyGate)(task.context, agentName);
+                        if (chomskyRun.rewrites > 0) {
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `  [Chomsky] ${chomskyRun.rewrites}× rewrite — score ${chomskyRun.initialScore}→${chomskyRun.finalScore}/10`);
+                            task.context = chomskyRun.finalPrompt;
+                        }
+                        else if (!chomskyRun.passed) {
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  [Chomsky] score ${chomskyRun.finalScore}/10 — pass-through (max rewrites reached)`);
+                        }
+                    }
+                    catch { /* gate is non-blocking — fail open */ }
+                }
+                try {
+                    result = await agent.execute(task, lastReview);
+                }
+                catch (execErr) {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.red, `  ✗ Execution error: ${execErr.message?.substring(0, 200)}`);
+                    monotask_state_machine_1.MonotaskSM.release(task.agent, task.id, `exec error: ${execErr.message?.substring(0, 80)}`);
+                    if (attempt < MAX_RETRIES) {
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Retrying after execution error (attempt ${attempt}/${MAX_RETRIES})...`);
+                        continue;
+                    }
+                    throw execErr; // exhausted retries
+                }
+                // OMEL AMD-13: WipeWitness — compare after write, emit shrink alert if > 50% loss
+                for (const f of result.files) {
+                    const tok = preTokens.get(f);
+                    if (tok)
+                        wipe_witness_1.wipeWitness.afterWrite(tok, (0, fs_1.existsSync)(f) ? (0, fs_1.statSync)(f).size : 0);
+                }
+                const deltaTokens = engine_primitives_1._globalTokensThisRun - tokensBefore;
+                taskRun.tokens_total += deltaTokens;
+                taskTokensSpent += deltaTokens; // sprint-1566 F0c: per-task budget tracking
+                taskRun.model_used = result.model || taskRun.model_used;
+                if (result.files.length === 0) {
+                    // 2026-05-27 diagnostic patch: structured "no files produced" rejection.
+                    // Captures (a) declared deliverable count, (b) model used, (c) failure
+                    // reasons collected during execute() (e.g. edit-mode-empty:foo.ts:380lines,
+                    // truncated, empty-edit-array). Replaces an opaque single-line log that
+                    // gave the founder no idea why the swarm was no-oping.
+                    const dels = [...(task.deliverables?.code || []), ...(task.deliverables?.tests || []), ...(task.deliverables?.docs || [])];
+                    const reasons = task._failureReasons || [];
+                    const inferred = reasons.length ? reasons.join('; ') : (dels.length === 0 ? 'empty-deliverables' : 'unknown');
+                    const structured = `No files produced [model=${result.model || 'n/a'}, type=${task.type}, deliverables=${dels.length}, reason=${inferred}]`;
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.red, `  ✗ ${structured}`);
+                    monotask_state_machine_1.MonotaskSM.release(task.agent, task.id, `no files: ${inferred.slice(0, 60)}`);
+                    task.status = 'rejected';
+                    this.persistTaskStatus(task);
+                    taskRun.status = 'rejected';
+                    taskRun.error = structured;
+                    taskRun.rejection_reason = structured;
+                    taskRun.failure_mode = inferred;
+                    taskRun.duration_seconds = Math.round((Date.now() - taskRunStart) / 1000);
+                    this.taskRuns.push(taskRun);
+                    return;
+                }
+                // B.10: Local QA gate — fast PASS/FAIL before expensive cloud supervisor
+                const qaFileContents = result.files.map(f => ({ path: f, content: (0, fs_1.existsSync)(f) ? (0, fs_1.readFileSync)(f, 'utf-8') : '' }));
+                const qaResult = await (0, engine_primitives_1.localQAGate)(task, qaFileContents);
+                if (!qaResult.pass) {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  [QA-gate] FAIL — ${qaResult.reason}`);
+                    this.stats.rejected++;
+                    task.status = 'rejected'; // will be reset on retry
+                    (0, engine_primitives_1.safeResetLastCommit)(task.id, task.agent, task.type, '  ');
+                    (0, code_failure_logger_1.logCodeFailure)({ taskId: task.id, sprintId: (0, orchestrate_engine_1.resolveActiveSprintId)(), agentId: (0, orchestrate_engine_1.resolveAgentDid)(task.agent), attemptNum: attempt, score: 0, model: taskRun.model_used || result?.model || task.model || 'unknown', rejectionReason: qaResult.reason, issues: [], failType: 'qa_gate' });
+                    monotask_state_machine_1.MonotaskSM.release(task.agent, task.id, `QA gate: ${qaResult.reason}`);
+                    if (attempt < MAX_RETRIES) {
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, '  QA gate failed — retrying without supervisor...');
+                        continue;
+                    }
+                    taskRun.status = 'rejected';
+                    taskRun.rejection_reason = `QA gate: ${qaResult.reason}`;
+                    taskRun.duration_seconds = Math.round((Date.now() - taskRunStart) / 1000);
+                    this.taskRuns.push(taskRun);
+                    return;
+                }
+                (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  [QA-gate] PASS — ${qaResult.reason}`);
+                // Dual Supervisor review (DeepSeek/ClawRouter + Haiku in parallel)
+                task.status = 'review';
+                const [review1, review2] = await Promise.all([
+                    this.supervisor.reviewTask(task, result.files),
+                    this.supervisor2.reviewTask(task, result.files),
+                ]);
+                const dualResult = await (0, engine_agents_1.reconcileSupervisorReviews)(review1, review2, task, this.ceo);
+                const review = dualResult.finalReview;
+                if (!dualResult.consensus)
+                    this.stats.conflicts++;
+                if (dualResult.escalatedToCEO)
+                    this.stats.escalations++;
+                lastReview = review;
+                task.output = { files: result.files, commit: '', model: result.model, review };
+                // CTO-006 telemetry-blackout hotfix (2026-05-29, Slice A of TICKET-135):
+                // record score + grade + rejection_reason on the task so they propagate
+                // via persistTaskStatus. Without this, every post-mortem said "score=?".
+                task.score = review?.score;
+                task.grade = review?.grade;
+                task.rejection_reason = review?.verdict !== 'APPROVED' ? (review?.summary?.slice(0, 240) ?? null) : null;
+                if (review.verdict === 'APPROVED') {
+                    task.status = 'done';
+                    this.persistTaskStatus(task); // sprint-1547: persist before any post-approval work that could exit early
+                    this.stats.approved++;
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.green, `\n✓ Task ${task.id} APPROVED on attempt ${attempt} (${review.score}/100)`);
+                    const _sprintIdApproved = (process.argv[2] || 'sprints/current.json').replace(/.*\//, '').replace('.json', '');
+                    (0, event_bus_publisher_1.publishTaskCompleted)(task.agent, _sprintIdApproved, task.id, task.title || task.id, 0).catch(() => { });
+                    aar_middleware_1.AARMiddleware.generateAndLog({ agentId: task.agent, taskId: task.id, sprintId: _sprintIdApproved, skillId: task.skill_id || task.type || 'code-generation', outcomeScore: review.score, actionSummary: (task.title || task.id).substring(0, 140), status: 'success' }).catch(() => { });
+                    // AMD-20: PRM Judge — constitutional reward signal for approved tasks
+                    (0, perm_judge_1.scoreTask)({ task_id: task.id, agent_id: task.agent, sprint_id: _sprintIdApproved, task_title: task.title || task.id, output_summary: review.summary || '', status: 'done' }).catch(() => { });
+                    (0, trust_score_updater_1.updateTrustScore)(task.agent, 'approved', review.score); // Sprint 703: Dynamic trust update
+                    // Sprint 706: BrainX — store success memory
+                    try {
+                        if (this._brainxBridge)
+                            await this._brainxBridge.storeTaskMemory({ agent_id: task.agent, task_id: task.id, task_title: task.title || task.id, outcome: 'success', score: review.score, summary: (task.title || task.id).substring(0, 200), files_modified: result.files || [] });
+                    }
+                    catch { /* non-blocking */ }
+                    (0, skill_crystalliser_1.crystalliseSkill)({ agentId: task.agent, taskId: task.id, sprintId: _sprintIdApproved, taskTitle: task.title || task.id, taskType: task.type || 'feature', model: task.model || 'qwen3:14b', taskTarget: task.task_target || 'local', score: review.score, approachSummary: (task.title || task.id).substring(0, 200), keyPatterns: review.strengths || [], antiPatterns: [] });
+                    (0, code_asset_crystalliser_1.crystalliseCodeAsset)({ agentId: task.agent, sprintId: _sprintIdApproved, taskId: task.id, taskTitle: task.title || task.id, files: result.files, supervisorScore: review.score, origin: 'kognai-core' });
+                    monotask_state_machine_1.MonotaskSM.complete(task.agent, task.id);
+                    taskRun.status = 'done';
+                    taskRun.files_written = result.files;
+                    taskRun.review = {
+                        verdict: review.verdict,
+                        score: review.score,
+                        grade: review.grade,
+                        score_rationale: review.score_rationale,
+                        strengths: review.strengths,
+                    };
+                    // SCORE protocol hook (founder rule 2026-05-27): every supervisor
+                    // grade against a spawned-citizen agent feeds the citizen's reputation
+                    // via the ACP rubric. Founding agents (CEO/sup/sherlock/etc.) aren't
+                    // in the citizens registry yet so they're skipped here — backfill TBD.
+                    try {
+                        (0, engine_primitives_1.recordScoreForCitizen)(task.agent, _sprintIdApproved, task.id, review.grade, 'approved-path');
+                    }
+                    catch (e) {
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  [SCORE] skip: ${(e?.message || '').slice(0, 100)}`);
+                    }
+                    taskRun.duration_seconds = Math.round((Date.now() - taskRunStart) / 1000);
+                    this.taskRuns.push(taskRun);
+                    (0, orchestrator_tap_1.tapAttempt)({
+                        sprint_id: kslSprintId, task_id: task.id, attempt, agent: task.agent,
+                        model: result.model || taskRun.model_used || 'unknown',
+                        prompt: kslPrompt,
+                        reply: `[approved score ${review.score}/100] files: ${result.files.join(', ')}\n\n${review.summary || ''}`,
+                        tools_used: [], errors: [], cost_usd: 0,
+                        duration_ms: Date.now() - kslAttemptStart,
+                    });
+                    return;
+                }
+                // Rejected — check for truncation pattern
+                this.stats.rejected++;
+                taskRun.review = {
+                    verdict: review.verdict,
+                    score: review.score,
+                    grade: review.grade,
+                    score_rationale: review.score_rationale,
+                    issues: review.issues,
+                    summary: review.summary,
+                };
+                // SCORE hook (rejected path) — record a negative-grade evaluation against
+                // the citizen so reputation actually moves on bad work.
+                try {
+                    const _sid = (process.argv[2] || 'sprints/current.json').replace(/.*\//, '').replace('.json', '');
+                    (0, engine_primitives_1.recordScoreForCitizen)(task.agent, _sid, task.id, review.grade, 'rejected-path');
+                }
+                catch (e) {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  [SCORE] skip: ${(e?.message || '').slice(0, 100)}`);
+                }
+                if (this.isTruncationRejection(review)) {
+                    truncationCount++;
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `\n↻ Task ${task.id} REJECTED on attempt ${attempt} (${review.score}/100) [TRUNCATION ${truncationCount}/${TRUNCATION_THRESHOLD}]`);
+                    // 2026-05-28 model-escalation pact: deterministic CTO/CEO sign-off via
+                    // policy. If DeepSeek truncated this task once, the NEXT retry routes
+                    // through ClawRouter → claude-sonnet-4.6. Cost ceiling ~$0.10 per
+                    // escalation at typical token volumes — well under the daily wallet.
+                    // Cleared in CodingAgent.execute after consumption.
+                    task._escalateNext = 'TRUNCATION';
+                }
+                else if (task._integrityFailed) {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `\n↻ Task ${task.id} REJECTED on attempt ${attempt} (${review.score}/100) [INTEGRITY-FAILED]`);
+                    // Same pact: destructive-rewrite (file shrank past integrity threshold)
+                    // signals the cheap model can't hold the file's contract — upgrade.
+                    task._escalateNext = 'INTEGRITY_FAILED';
+                }
+                else if ((review?.score ?? 100) < 30 &&
+                    attempt < MAX_RETRIES &&
+                    ((task.deliverables?.code || []).some((f) => /\.(md|mdx)$/i.test(f))
+                        || ['research', 'spec', 'docs'].includes((task.type || '').toLowerCase()))) {
+                    // 2026-05-28 pact expansion: low-score spec/docs rejections also escalate.
+                    // sprint-1613 failure mode: DeepSeek hit a ~3-5k output ceiling on a
+                    // 300-line spec request and gave up at one section, then the same
+                    // capacity ceiling re-trapped 5 sub-task retries. Truncation/integrity
+                    // checks didn't catch it (the file was complete, just not the SPEC).
+                    // Catch low-score (<30) markdown/spec rejections explicitly so the
+                    // next retry hits Sonnet instead of redo-on-the-same-cheap-model.
+                    // Guarded by attempt < MAX_RETRIES so we don't waste the flag on the
+                    // final attempt where there's no retry to consume it.
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `\n↻ Task ${task.id} REJECTED on attempt ${attempt} (${review.score}/100) [LOW-SCORE-SPEC]`);
+                    task._escalateNext = 'LOW_SCORE_SPEC';
+                }
+                else {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `\n↻ Task ${task.id} REJECTED on attempt ${attempt} (${review.score}/100)`);
+                }
+                (0, engine_primitives_1.safeResetLastCommit)(task.id, task.agent, task.type, '  ');
+                (0, code_failure_logger_1.logCodeFailure)({ taskId: task.id, sprintId: (0, orchestrate_engine_1.resolveActiveSprintId)(), agentId: (0, orchestrate_engine_1.resolveAgentDid)(task.agent), attemptNum: attempt, score: review?.score || 0, model: taskRun.model_used || result?.model || task.model || 'unknown', rejectionReason: review?.summary || 'supervisor rejected', issues: review?.issues || [], failType: 'supervisor_rejected' });
+                // Sprint 701: AAR logging on REJECTION path (governance remediation)
+                const _sprintIdRejected = (process.argv[2] || 'sprints/current.json').replace(/.*\//, '').replace('.json', '');
+                aar_middleware_1.AARMiddleware.generateAndLog({ agentId: task.agent, taskId: task.id, sprintId: _sprintIdRejected, skillId: task.skill_id || task.type || 'code-generation', outcomeScore: review?.score || 0, actionSummary: `REJECTED: ${(task.title || task.id).substring(0, 120)} (attempt ${attempt})`, status: 'rejected' }).catch(() => { });
+                (0, trust_score_updater_1.updateTrustScore)(task.agent, 'rejected', review?.score || 0); // Sprint 703: Dynamic trust update
+                // Sprint 706: BrainX — store failure memory
+                try {
+                    if (this._brainxBridge)
+                        await this._brainxBridge.storeTaskMemory({ agent_id: task.agent, task_id: task.id, task_title: task.title || task.id, outcome: 'failure', score: review?.score || 0, summary: `REJECTED: ${(task.title || task.id).substring(0, 180)}`, files_modified: [] });
+                }
+                catch { /* non-blocking */ }
+                monotask_state_machine_1.MonotaskSM.release(task.agent, task.id, `rejected attempt ${attempt}`);
+                (0, orchestrator_tap_1.tapAttempt)({
+                    sprint_id: kslSprintId, task_id: task.id, attempt, agent: task.agent,
+                    model: taskRun.model_used || result?.model || task.model || 'unknown',
+                    prompt: kslPrompt,
+                    reply: `[rejected score ${review?.score || 0}/100] ${review?.summary || 'supervisor rejected'}`,
+                    tools_used: [],
+                    errors: [{ kind: 'supervisor_rejected', message: review?.summary || 'supervisor rejected' }],
+                    cost_usd: 0,
+                    duration_ms: Date.now() - kslAttemptStart,
+                });
+                // CTO AUTO-DECOMPOSE: After N consecutive truncation rejections, split the task
+                if (truncationCount >= TRUNCATION_THRESHOLD) {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `\n🔧 TRUNCATION THRESHOLD REACHED — CTO decomposing ${task.id}...`);
+                    const subtasks = await this.ctoDecomposeTask(task);
+                    if (subtasks.length > 1) {
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `  Executing ${subtasks.length} sub-tasks sequentially...`);
+                        let allPassed = true;
+                        for (const subtask of subtasks) {
+                            // Check sub-task dependencies
+                            const subDeps = subtask.dependencies || [];
+                            const unmetSubDeps = subDeps.filter(d => {
+                                const depSt = subtasks.find(s => s.id === d);
+                                return depSt && depSt.status !== 'done';
+                            });
+                            if (unmetSubDeps.length > 0) {
+                                (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Skipping sub-task ${subtask.id}: unmet deps [${unmetSubDeps.join(', ')}]`);
+                                allPassed = false;
+                                continue;
+                            }
+                            const passed = await this.executeSubTask(subtask, 5);
+                            if (passed) {
+                                subtask.status = 'done';
+                            }
+                            else {
+                                allPassed = false;
+                                subtask.status = 'rejected';
+                                (0, engine_primitives_1.log)(engine_primitives_1.c.red, `  Sub-task ${subtask.id} failed — stopping decomposition chain`);
+                                break;
+                            }
+                        }
+                        if (allPassed) {
+                            task.status = 'done';
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.green, `\n✓ Task ${task.id} COMPLETED via CTO decomposition (${subtasks.length} sub-tasks)`);
+                            taskRun.status = 'done';
+                            taskRun.files_written = subtasks.flatMap(st => st.deliverables.code || []);
+                        }
+                        else {
+                            task.status = 'rejected';
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.red, `\n✗ Task ${task.id} FAILED even after CTO decomposition`);
+                            taskRun.status = 'rejected';
+                            taskRun.rejection_reason = review.summary;
+                        }
+                        this.persistTaskStatus(task);
+                        taskRun.duration_seconds = Math.round((Date.now() - taskRunStart) / 1000);
+                        this.taskRuns.push(taskRun);
+                        return;
+                    }
+                    // If decomposition returned <=1 task, continue with normal retry loop
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, '  Decomposition produced ≤1 sub-task, continuing normal retries...');
+                    truncationCount = 0; // Reset to avoid re-triggering
+                }
+                if (attempt < MAX_RETRIES) {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Retrying with rejection feedback...`);
+                }
+            }
+            task.status = 'rejected';
+            this.persistTaskStatus(task);
+            (0, engine_primitives_1.log)(engine_primitives_1.c.red, `\n✗ Task ${task.id} FAILED after ${MAX_RETRIES} attempts`);
+            const _sprintIdFailed = (process.argv[2] || 'sprints/current.json').replace(/.*\//, '').replace('.json', '');
+            (0, event_bus_publisher_1.publishTaskFailed)(task.agent, _sprintIdFailed, task.id, task.title || task.id, lastReview?.summary || `Failed after ${MAX_RETRIES} attempts`).catch(() => { });
+            taskRun.status = 'rejected';
+            taskRun.rejection_reason = lastReview?.summary || `Failed after ${MAX_RETRIES} attempts`;
+            taskRun.duration_seconds = Math.round((Date.now() - taskRunStart) / 1000);
+            this.taskRuns.push(taskRun);
+        }
+        finally {
+            // OMEL AMD-13: Always wipe the phantom tmpdir on task exit (success or failure)
+            phantom_workspace_1.phantomWorkspace.cleanup(phantomCtx);
+        }
+    }
+    async run() {
+        const startTime = Date.now();
+        const sprintStartTime = new Date().toISOString();
+        let gitHeadBefore = 'unknown';
+        try {
+            gitHeadBefore = (0, child_process_1.execSync)('git rev-parse --short HEAD', { timeout: 5000 }).toString().trim();
+        }
+        catch { /* ok */ }
+        (0, engine_primitives_1.log)(engine_primitives_1.c.bold, '\n🚀 Starting orchestration run...\n');
+        if (engine_primitives_1.SOVEREIGN_MODE)
+            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, '  ⚡ SOVEREIGN MODE — all inference local ($0 cost floor)');
+        (0, wallet_state_1.logWalletStatus)();
+        // Mission Control — connect and register this sprint run
+        const mc = (0, mc_client_1.createMCClient)('sprint-orchestrator', 'worker');
+        let mcConnected = false;
+        try {
+            await mc.connect();
+            mcConnected = true;
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '  [MC] Connected to Mission Control');
+        }
+        catch {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '  [MC] Mission Control unavailable — running without telemetry');
+        }
+        // 1. Load tasks
+        this.loadTasks();
+        // 069-06: emit sprint started event
+        const _evtSprintId = (process.argv[2] || 'sprints/current.json').replace(/.*\//, '').replace('.json', '');
+        // Sprint 706: BrainX swarm bridge — create at sprint start
+        let brainxBridge = null;
+        try {
+            const agentIds = Array.from(new Set(this.tasks.map(t => t.agent)));
+            brainxBridge = (0, brainx_swarm_bridge_1.createSwarmBridge)(`swarm-${Date.now()}`, _evtSprintId, agentIds);
+            this._brainxBridge = brainxBridge;
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  [BrainX] Bridge created for ${agentIds.length} agents`);
+        }
+        catch (e) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  [BrainX] Bridge creation skipped: ${e.message}`);
+        }
+        (0, event_bus_publisher_1.publishSprintStarted)(_evtSprintId, this.tasks.filter(t => t.status === 'pending').length).catch(() => { });
+        if (this.tasks.length === 0) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, 'No tasks to execute');
+            if (mcConnected)
+                await mc.disconnect().catch(() => { });
+            return;
+        }
+        // ── CTO APPROVAL GATE — Exec Protocol §17 ──────────────────────────────
+        // Every autonomous sprint must be approved by the CTO agent before execution.
+        // Human-submitted sprints (source: 'human') are auto-approved.
+        // Prevents the swarm from inventing its own work outside the execution plan.
+        {
+            const sprintFile = process.argv[2] || 'sprints/current.json';
+            const sprintRaw = JSON.parse((0, fs_1.readFileSync)(sprintFile, 'utf-8'));
+            const sprintSource = sprintRaw.source || (sprintRaw.swarm === 'NOT USED' ? 'human' : 'autonomous_loop');
+            const proposal = {
+                sprint_id: _evtSprintId,
+                title: sprintRaw.name || sprintRaw.title || _evtSprintId,
+                description: sprintRaw.goal || sprintRaw.description || '',
+                tasks: this.tasks.map(t => `${t.id}: ${t.title || t.context || t.type}`),
+                estimated_complexity: sprintRaw.estimated_complexity || 'medium',
+                source: sprintSource,
+                // Sprint 1457 BUGFIX: pass Rule 3 contract fields from sprint JSON to CTO gate
+                inputs: sprintRaw.inputs,
+                outputs: sprintRaw.outputs,
+                success_criteria: sprintRaw.success_criteria,
+            };
+            (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, `\n--- CTO Approval Gate ---`);
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  Sprint: ${proposal.sprint_id} — "${proposal.title}"`);
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  Source: ${proposal.source} (${proposal.tasks.length} tasks)`);
+            const ctoResult = await (0, cto_approval_gate_1.requestCTOApproval)(proposal, process.cwd(), 'kognai');
+            if (!ctoResult.approved) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.red, `  ✘ CTO REJECTED: ${ctoResult.reason}`);
+                (0, engine_primitives_1.log)(engine_primitives_1.c.red, `    Plan reference: ${ctoResult.plan_reference}`);
+                (0, engine_primitives_1.log)(engine_primitives_1.c.red, `    Confidence: ${ctoResult.cto_confidence}%`);
+                (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Sprint ${_evtSprintId} will NOT execute. Saving rejection to sprint file.`);
+                // Write rejection to sprint file so the loop doesn't retry
+                try {
+                    sprintRaw.cto_gate = {
+                        approved: false,
+                        reason: ctoResult.reason,
+                        plan_reference: ctoResult.plan_reference,
+                        confidence: ctoResult.cto_confidence,
+                        timestamp: ctoResult.timestamp,
+                    };
+                    (0, fs_1.writeFileSync)(sprintFile, JSON.stringify(sprintRaw, null, 2));
+                }
+                catch { /* non-critical */ }
+                if (mcConnected)
+                    await mc.disconnect().catch(() => { });
+                return;
+            }
+            (0, engine_primitives_1.log)(engine_primitives_1.c.green, `  ✓ CTO APPROVED: ${ctoResult.reason}`);
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `    Plan reference: ${ctoResult.plan_reference} (confidence: ${ctoResult.cto_confidence}%)`);
+        }
+        // ── End CTO Gate ────────────────────────────────────────────────────────
+        // 2. CEO initial assessment (B.14: once per sprint, not once per conflict)
+        (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, '\n--- Phase 1: CEO Initial Assessment ---');
+        await this.ceo.reviewSprintProgress(this.tasks);
+        const _ceoIntentDone = true; // flag for Phase 5: only re-run if ≥2 rejected
+        // 3. Execute coding tasks with review loop
+        (0, engine_primitives_1.log)(engine_primitives_1.c.blue, '\n--- Phase 2: Sprint Execution ---');
+        // Auto-cascade: if a task is rejected, immediately mark all downstream dependents as skipped
+        // This prevents tasks from being stuck as 'pending' forever across retries
+        let cascaded = true;
+        while (cascaded) {
+            cascaded = false;
+            for (const task of this.tasks) {
+                if (task.status !== 'pending')
+                    continue;
+                const deps = task.dependencies || [];
+                const blockedBy = deps.filter(d => {
+                    const depTask = this.tasks.find(t => t.id === d);
+                    return depTask && (depTask.status === 'rejected' || depTask.status === 'skipped');
+                });
+                if (blockedBy.length > 0) {
+                    task.status = 'skipped';
+                    task.skippedReason = `Blocked by: ${blockedBy.join(', ')}`;
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Auto-skipped ${task.id}: blocked by rejected/skipped deps [${blockedBy.join(', ')}]`);
+                    cascaded = true;
+                }
+            }
+        }
+        // B.16: Wave-based parallel fan-out
+        // Each wave = all tasks whose dependencies are satisfied and that don't share output files.
+        // Serialized only when deliverable paths overlap (file conflict detection).
+        const remaining = this.tasks.filter(t => t.status === 'pending');
+        while (remaining.length > 0) {
+            // Find tasks whose dependencies are all done/skipped
+            const ready = remaining.filter(task => {
+                const deps = task.dependencies || [];
+                return deps.every(d => {
+                    const dep = this.tasks.find(t => t.id === d);
+                    return !dep || dep.status === 'done' || dep.status === 'skipped';
+                });
+            });
+            if (ready.length === 0)
+                break; // dependency deadlock — bail
+            // File conflict detection: build wave without overlapping deliverables
+            const filesInWave = new Set();
+            const wave = [];
+            for (const task of ready) {
+                const taskFiles = [
+                    ...(task.deliverables?.code || []),
+                    ...(task.deliverables?.tests || []),
+                    ...(task.deliverables?.docs || []),
+                ];
+                const hasConflict = taskFiles.some(f => filesInWave.has(f));
+                if (!hasConflict) {
+                    wave.push(task);
+                    taskFiles.forEach(f => filesInWave.add(f));
+                }
+                // conflicting tasks stay in remaining for next wave
+            }
+            if (wave.length === 0)
+                wave.push(ready[0]); // break deadlock: force one task
+            // B.16: Split wave by task_target — local tasks serialized (Ollama can only run one at a time),
+            // cloud tasks run concurrently. Prevents Ollama queue timeout on parallel fan-out.
+            const localWave = wave.filter(t => t.task_target === 'local');
+            const cloudWave = wave.filter(t => t.task_target !== 'local');
+            // B.16-RL: Cloud concurrency cap — prevents burning the Claude 5h token budget.
+            // Default: 1 (serial). Override: MAX_CLOUD_CONCURRENCY env var.
+            const MAX_CLOUD_CONCURRENCY = parseInt(process.env.MAX_CLOUD_CONCURRENCY ?? '1', 10);
+            if (cloudWave.length > 1 && MAX_CLOUD_CONCURRENCY > 1) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.blue, `  [B.16] Parallel fan-out: ${cloudWave.length} cloud tasks (cap: ${MAX_CLOUD_CONCURRENCY})`);
+            }
+            else if (cloudWave.length > 1) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.blue, `  [B.16-RL] Serial cloud execution: ${cloudWave.length} tasks (MAX_CLOUD_CONCURRENCY=1)`);
+            }
+            if (localWave.length > 1) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.blue, `  [B.16] Sequential execution: ${localWave.length} local tasks (Ollama serialized)`);
+            }
+            else if (localWave.length === 1 && cloudWave.length === 0) {
+                // single task, no label needed
+            }
+            // Execute cloud tasks in batches of MAX_CLOUD_CONCURRENCY
+            for (let i = 0; i < cloudWave.length; i += MAX_CLOUD_CONCURRENCY) {
+                const batch = cloudWave.slice(i, i + MAX_CLOUD_CONCURRENCY);
+                await Promise.all(batch.map(t => this.executeTask(t)));
+            }
+            for (const t of localWave) {
+                await this.executeTask(t);
+            }
+            // Remove executed tasks from remaining
+            for (const t of wave) {
+                const idx = remaining.indexOf(t);
+                if (idx >= 0)
+                    remaining.splice(idx, 1);
+            }
+            // Cascade rejections
+            cascaded = true;
+            while (cascaded) {
+                cascaded = false;
+                for (const t of this.tasks) {
+                    if (t.status !== 'pending')
+                        continue;
+                    const tDeps = t.dependencies || [];
+                    const tBlocked = tDeps.filter(d => {
+                        const depTask = this.tasks.find(x => x.id === d);
+                        return depTask && (depTask.status === 'rejected' || depTask.status === 'skipped');
+                    });
+                    if (tBlocked.length > 0) {
+                        t.status = 'skipped';
+                        t.skippedReason = `Blocked by: ${tBlocked.join(', ')}`;
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Auto-skipped ${t.id}: blocked by deps [${tBlocked.join(', ')}]`);
+                        cascaded = true;
+                    }
+                }
+            }
+            // Remove newly-skipped/rejected from remaining
+            for (let i = remaining.length - 1; i >= 0; i--) {
+                if (remaining[i].status === 'skipped' || remaining[i].status === 'rejected') {
+                    remaining.splice(i, 1);
+                }
+            }
+        }
+        // 4. CTO data-driven analysis + CMO reports
+        (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, '\n--- Phase 3: CTO Data-Driven Analysis + CMO Reports ---');
+        let ctoReport = { summary: '', proposals: [], metrics_reviewed: [] };
+        let ctoDecisions = '';
+        let cmoReports = '';
+        try {
+            ctoReport = await this.cto.analyze();
+            // Load CMO reports (produced independently by Manus AI runner)
+            cmoReports = (0, engine_loaders_1.loadCMOReports)();
+            if (cmoReports) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, '  CMO reports found — will include in CEO review');
+            }
+            else {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '  No CMO reports available yet');
+            }
+            // Load CTO tech-watch reports (produced independently by run-cto-techwatch.ts)
+            const ctoTechWatch = (0, engine_loaders_1.loadCTOTechWatchReports)();
+            if (ctoTechWatch) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, '  CTO tech-watch reports found — will include in CEO review');
+                cmoReports = cmoReports ? cmoReports + '\n\n' + ctoTechWatch : ctoTechWatch;
+            }
+            else {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '  No CTO tech-watch reports available yet');
+            }
+            // Load Grok intelligence feed (Grok AI monitors X/Twitter for OpenClaw news)
+            const grokFeed = (0, engine_loaders_1.loadGrokFeed)();
+            if (grokFeed) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, '  Grok intelligence feed found — will include in CEO review');
+                cmoReports = cmoReports ? cmoReports + '\n\n' + grokFeed : grokFeed;
+            }
+            else {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '  No Grok feed reports available');
+            }
+            // Load Owner Directives (highest priority — always included)
+            const ownerDirectives = (0, engine_loaders_1.loadOwnerDirectives)();
+            if (ownerDirectives) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, "  Owner directives found — will include in CEO review (highest priority)");
+                cmoReports = ownerDirectives + (cmoReports ? "\n\n" + cmoReports : "");
+            }
+            // 5. CEO reviews CTO proposals + CMO reports
+            if (ctoReport.proposals.length > 0 || cmoReports) {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, '\n--- Phase 4: CEO Reviews CTO Proposals + CMO Reports ---');
+                ctoDecisions = await this.ceo.reviewCTOProposals(ctoReport);
+                // Persist CEO decisions for CTO feedback loop + approved proposals tracking
+                (0, orchestrate_engine_1.persistCEODecisions)(ctoDecisions, ctoReport);
+                // Handle approved new_agent proposals
+                const agentCreator = new engine_agents_1.AgentCreator(this.spawnGate);
+                for (const proposal of ctoReport.proposals) {
+                    if (proposal.category === 'new_agent' && proposal.agent_spec) {
+                        // Check if CEO approved this specific proposal
+                        if (ctoDecisions.includes(proposal.id) && ctoDecisions.toUpperCase().includes('APPROVED')) {
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.green, `\n  🤖 CEO approved new agent: ${proposal.agent_spec.name}`);
+                            agentCreator.createAgent(proposal.agent_spec);
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.green, `  Agent will be loaded on next orchestrator run.`);
+                        }
+                        else {
+                            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  CEO did not approve agent: ${proposal.agent_spec.name}`);
+                        }
+                    }
+                }
+            }
+            else {
+                (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, '  No proposals from CTO — stack is current and optimized');
+                ctoDecisions = 'No proposals to review.';
+            }
+        }
+        catch (error) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  CTO/CEO review cycle skipped: ${error.message}`);
+            ctoDecisions = 'CTO analysis was not performed this run.';
+        }
+        // 6. CEO final assessment — B.14: only runs if ≥2 tasks rejected (skips if sprint went well)
+        const rejectedCount = this.tasks.filter(t => t.status === 'rejected').length;
+        (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, '\n--- Phase 5: CEO Final Assessment ---');
+        if (rejectedCount >= 2) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, `  ${rejectedCount} tasks rejected — CEO reviewing...`);
+            await this.ceo.reviewSprintProgress(this.tasks);
+        }
+        else {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  Only ${rejectedCount} rejected — skipping CEO reassessment (sprint OK)`);
+        }
+        (0, wallet_state_1.logWalletStatus)(); // Print wallet burn after sprint execution
+        // 069-06: emit budget events if thresholds crossed
+        try {
+            const _ws = (0, wallet_state_1.getWalletState)();
+            if (_ws.burnPct >= 95)
+                (0, event_bus_publisher_1.publishBudgetFreeze)(_evtSprintId, _ws.burnPct).catch(() => { });
+            else if (_ws.burnPct >= 80)
+                (0, event_bus_publisher_1.publishBudgetWarning)(_evtSprintId, _ws.burnPct, _ws.spentThisMonth, _ws.monthlyBudget).catch(() => { });
+        }
+        catch { /* wallet state unavailable */ }
+        // 6b. CTO autonomous post-sprint analysis (runs after EVERY sprint)
+        (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, '\n--- Phase 5b: CTO Post-Sprint Analysis (Autonomous) ---');
+        let postSprintReport = '';
+        try {
+            postSprintReport = await this.cto.postSprintAnalysis(this.tasks, this.stats);
+            (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, '  Post-sprint analysis saved to reports/cto/');
+            // Extract proposals from post-sprint analysis and feed into CEO review
+            const jsonMatch = postSprintReport.match(/```json\s*([\s\S]*?)```/);
+            if (jsonMatch) {
+                try {
+                    const parsed = JSON.parse(jsonMatch[1].trim());
+                    const postSprintProposals = parsed.proposals || [];
+                    if (postSprintProposals.length > 0) {
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `  Found ${postSprintProposals.length} proposals — sending to CEO for autonomous review`);
+                        // Build CTOReport for CEO review
+                        const postSprintCTOReport = {
+                            summary: parsed.summary || 'Post-sprint analysis proposals',
+                            proposals: postSprintProposals.map((p) => ({
+                                id: p.id,
+                                title: p.title,
+                                category: p.category,
+                                description: p.description,
+                                estimated_impact: p.estimated_impact || '',
+                                risk_level: p.risk_level || 'medium',
+                                implementation_steps: p.implementation_steps || [],
+                            })),
+                            metrics_reviewed: ['sprint_results', 'failure_patterns', 'trend_analysis'],
+                        };
+                        // Phase 5c: CEO autonomously reviews post-sprint proposals
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, '\n--- Phase 5c: CEO Reviews Post-Sprint Proposals (Autonomous) ---');
+                        const postSprintDecisions = await this.ceo.reviewCTOProposals(postSprintCTOReport);
+                        // Persist CEO decisions + update approved-proposals tracker
+                        (0, orchestrate_engine_1.persistCEODecisions)(postSprintDecisions, postSprintCTOReport);
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, '  CEO post-sprint proposal review complete');
+                    }
+                    else {
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, '  No proposals in post-sprint analysis');
+                    }
+                }
+                catch (parseErr) {
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Could not parse post-sprint proposals JSON: ${parseErr.message}`);
+                }
+            }
+        }
+        catch (error) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Post-sprint analysis skipped: ${error.message}`);
+        }
+        // 7. CEO generates daily report
+        (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, '\n--- Phase 6: Daily Report Generation ---');
+        const ctoReportStr = `Summary: ${ctoReport.summary}\nProposals: ${ctoReport.proposals.length}\n${ctoReport.proposals.map(p => `- [${p.category}] ${p.title} (${p.risk_level})`).join('\n')}`;
+        const grokSection = (0, engine_loaders_1.loadGrokFeed)();
+        const cmoSection = cmoReports
+            ? '\n\n## CMO Activity (Manus AI)\n' + cmoReports.substring(0, 2000)
+            : '\n\nCMO: No reports available this cycle.';
+        const grokForReport = grokSection ? '\n\n## Grok Intelligence Feed\nGrok AI reports available — included in CTO/CEO analysis.' : '\n\nGrok: No feed reports this cycle.';
+        const postSprintSection = postSprintReport ? '\n\n## CTO Post-Sprint Analysis\n' + postSprintReport.substring(0, 2000) : '';
+        await this.ceo.generateDailyReport(this.tasks, this.stats, ctoReportStr + cmoSection + grokForReport + postSprintSection, ctoDecisions);
+        // 8. Save updated sprint state
+        const sprintFile = process.argv[2] || 'sprints/current.json';
+        (0, fs_1.writeFileSync)(sprintFile, JSON.stringify({ tasks: this.tasks }, null, 2));
+        (0, engine_primitives_1.log)(engine_primitives_1.c.green, `\nSprint state saved to ${sprintFile}`);
+        // Sprint 706: BrainX — close bridge at sprint end
+        try {
+            if (brainxBridge)
+                await brainxBridge.close();
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '  [BrainX] Bridge closed');
+        }
+        catch { /* non-blocking */ }
+        // 069-06: emit sprint completed event
+        const completedCount = this.tasks.filter(t => t.status === 'done').length;
+        (0, event_bus_publisher_1.publishSprintCompleted)(_evtSprintId, this.tasks.length, completedCount).catch(() => { });
+        // 8b. Sync global token count into stats
+        this.stats.totalTokens = engine_primitives_1._globalTokensThisRun;
+        // 8c. Generate structured swarm run report
+        try {
+            (0, fs_1.mkdirSync)('reports/swarm-runs', { recursive: true });
+            (0, fs_1.mkdirSync)('logs/swarm-runs', { recursive: true });
+            let gitHeadAfter = 'unknown';
+            let gitBranch = 'unknown';
+            try {
+                gitHeadAfter = (0, child_process_1.execSync)('git rev-parse --short HEAD', { timeout: 5000 }).toString().trim();
+                gitBranch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { timeout: 5000 }).toString().trim();
+            }
+            catch { /* ok */ }
+            // sprint-1566 F0e + F3: read from the real per-call aggregator (filled
+            // by recordModelCall after every callLLM) instead of the prior pattern
+            // that read taskRun.model_used (always 'unknown') and used a stale 5-row
+            // pricing dict. modelUsage now has provider/calls/input/output/tokens/
+            // cost_usd per model with real per-call cost from llm-cost-table.
+            const modelUsage = (0, engine_primitives_1.getModelsUsedReport)();
+            const totalCostUsd = (0, engine_primitives_1.getTotalCostUsd)();
+            const runReport = {
+                schema_version: '2.0.0', // CTO-20260528-001: bumped when capturing grade + score_rationale per-task
+                run_id: (0, crypto_1.randomUUID)(),
+                project: 'kognai',
+                sprint_file: sprintFile,
+                started_at: sprintStartTime,
+                finished_at: new Date().toISOString(),
+                duration_seconds: Math.round((Date.now() - startTime) / 1000),
+                git_branch: gitBranch,
+                git_head_before: gitHeadBefore,
+                git_head_after: gitHeadAfter,
+                sovereign_mode: engine_primitives_1.SOVEREIGN_MODE,
+                summary: {
+                    total_tasks: this.tasks.length,
+                    done: this.tasks.filter(t => t.status === 'done').length,
+                    rejected: this.tasks.filter(t => t.status === 'rejected').length,
+                    skipped: this.tasks.filter(t => t.status === 'skipped').length,
+                    approval_rate: +(this.stats.approved / Math.max(this.stats.tasksExecuted, 1)).toFixed(2),
+                    total_tokens: this.stats.totalTokens,
+                    supervisor_conflicts: this.stats.conflicts,
+                    ceo_escalations: this.stats.escalations,
+                },
+                models_used: modelUsage,
+                total_cost_usd: +totalCostUsd.toFixed(4),
+                tasks: this.taskRuns,
+            };
+            // 1. Timestamped individual report (never overwritten)
+            const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+            const reportPath = `reports/swarm-runs/${ts}.json`;
+            (0, fs_1.writeFileSync)(reportPath, JSON.stringify(runReport, null, 2));
+            // 2. Latest pointer (for quick dashboard access)
+            (0, fs_1.writeFileSync)('reports/swarm-runs/latest-run.json', JSON.stringify(runReport, null, 2));
+            // 3. Daily aggregate (accumulates ALL runs for the day)
+            const today = new Date().toISOString().slice(0, 10);
+            const dailyPath = `reports/swarm-runs/daily-${today}.json`;
+            let dailyRuns = [];
+            try {
+                dailyRuns = JSON.parse((0, fs_1.readFileSync)(dailyPath, 'utf-8'));
+            }
+            catch { /* first run today */ }
+            dailyRuns.push(runReport);
+            (0, fs_1.writeFileSync)(dailyPath, JSON.stringify(dailyRuns, null, 2));
+            (0, engine_primitives_1.log)(engine_primitives_1.c.green, `\n📊 Swarm run report: ${reportPath}`);
+            (0, engine_primitives_1.log)(engine_primitives_1.c.green, `   Daily aggregate: ${dailyPath} (${dailyRuns.length} run(s) today)`);
+            (0, engine_primitives_1.log)(engine_primitives_1.c.green, `   Tokens: ${this.stats.totalTokens.toLocaleString()} | Est. cost: $${totalCostUsd.toFixed(4)}`);
+            // 8d. Daily cost digest — persist ClawRouter spend summary (§17.5)
+            try {
+                const digest = (0, engine_primitives_1.getDailyCostDigest)();
+                const digestPath = `logs/clawrouter/digest-${today}.json`;
+                (0, fs_1.writeFileSync)(digestPath, JSON.stringify(digest, null, 2));
+                (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `   💰 Cost digest: $${digest.total_usd.toFixed(4)} across ${digest.call_count} calls (saved ${digest.tokens_saved_by_qcg} tokens via QCG)`);
+            }
+            catch { /* non-critical */ }
+        }
+        catch (err) {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  [WARN] Swarm run report failed: ${err.message}`);
+        }
+        // 9. Post-sprint: PM2 reload backend + smoke test
+        await (0, orchestrate_engine_1.postSprintSmokeTest)();
+        // Final summary
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        (0, engine_primitives_1.log)(engine_primitives_1.c.bold, '\n╔══════════════════════════════════════════════════════════╗');
+        (0, engine_primitives_1.log)(engine_primitives_1.c.bold, '║   Orchestration Complete                                  ║');
+        (0, engine_primitives_1.log)(engine_primitives_1.c.bold, '╚══════════════════════════════════════════════════════════╝');
+        (0, engine_primitives_1.log)(engine_primitives_1.c.green, `  Tasks executed: ${this.stats.tasksExecuted}`);
+        (0, engine_primitives_1.log)(engine_primitives_1.c.green, `  Approved: ${this.stats.approved}`);
+        (0, engine_primitives_1.log)(engine_primitives_1.c.red, `  Rejected: ${this.stats.rejected}`);
+        (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Supervisor conflicts: ${this.stats.conflicts}`);
+        (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, `  CEO escalations: ${this.stats.escalations}`);
+        (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, `  CTO proposals: ${ctoReport.proposals.length}`);
+        (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, `  CMO reports: ${cmoReports ? 'loaded' : 'none'}`);
+        (0, engine_primitives_1.log)(engine_primitives_1.c.blue, `  Total time: ${elapsed}s`);
+        (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  Pipeline: CEO → MiniMax code → Dual review (DeepSeek + Haiku) → CEO resolves conflicts → CTO → CMO/Grok → Post-sprint analysis → Daily report`);
+        // Mission Control — report final stats and disconnect
+        if (mcConnected) {
+            try {
+                if (this.stats.totalTokens > 0) {
+                    await mc.reportTokens('MiniMax-M2.5', this.stats.totalTokens, 0, 'sprint_run');
+                }
+                await mc.disconnect();
+                (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  [MC] Sprint reported: ${this.stats.approved} approved / ${this.stats.rejected} rejected / ${this.stats.totalTokens} tokens`);
+            }
+            catch { /* non-critical */ }
+        }
+    }
+}
+exports.Orchestrator = Orchestrator;
+// ===== Post-sprint smoke test =====
+// <<<EXTRACT-END-orchestrator