@kognai/orchestrator-core 0.1.1 → 0.1.3

package/dist/lib/engine-helpers.d.ts

@@ -0,0 +1,10 @@
+import type { AgentTask, CTOReport } from './engine-primitives';
+export declare function persistCEODecisions(ctoDecisions: string, ctoReport: CTOReport): void;
+export declare function resolveActiveSprintId(): string;
+export declare function resolveAgentDid(role: string | undefined): string;
+export declare function recordAgentScore(agentId: string, score: number): void;
+export declare function assessTaskComplexity(task: AgentTask, deliverables: string[]): Promise<{
+    provider: 'anthropic' | 'ollama' | 'clawrouter';
+    model: string;
+    routingReason: string;
+}>;

package/dist/lib/engine-helpers.js

@@ -0,0 +1,319 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistCEODecisions = persistCEODecisions;
+exports.resolveActiveSprintId = resolveActiveSprintId;
+exports.resolveAgentDid = resolveAgentDid;
+exports.recordAgentScore = recordAgentScore;
+exports.assessTaskComplexity = assessTaskComplexity;
+/**
+ * engine-helpers.ts — engine support helpers extracted from orchestrate-engine.ts
+ * (TICKET-231 engine split 6). Task-complexity routing (assessTaskComplexity + isAuthoringTask),
+ * CEO-decision persistence, active-sprint-id + agent-DID resolution, and per-agent score recording.
+ * A near-leaf: imports primitives from the engine-primitives leaf + sibling ./modules, never back
+ * from orchestrate-engine. orchestrate-engine re-exports these for engine-orchestrator /
+ * engine-coding-agent, whose imports stay unchanged.
+ */
+const fs_1 = require("fs");
+const ollama_client_1 = require("./ollama-client"); // availability check only — calls go through ClawRouter v2.0
+const clawrouter_client_1 = require("./clawrouter-client");
+const local_model_router_1 = require("./local-model-router");
+const citizenship_1 = require("./citizenship");
+const did_resolver_registry_1 = require("./did-resolver-registry");
+const model_router_1 = require("./model-router");
+const wallet_state_1 = require("./wallet-state");
+const engine_primitives_1 = require("./engine-primitives");
+function persistCEODecisions(ctoDecisions, ctoReport) {
+    const today = new Date().toISOString().split('T')[0];
+    // 1. Save raw CEO feedback to ceo-feedback directory
+    const feedbackDir = './reports/cto/ceo-feedback';
+    (0, fs_1.mkdirSync)(feedbackDir, { recursive: true });
+    try {
+        // Parse decisions from CEO response
+        const jsonMatch = ctoDecisions.match(/\[[\s\S]*\]/);
+        const decisions = jsonMatch ? JSON.parse(jsonMatch[0]) : [];
+        (0, fs_1.writeFileSync)(`${feedbackDir}/${today}.json`, JSON.stringify({ date: today, decisions }, null, 2));
+        (0, engine_primitives_1.log)(engine_primitives_1.c.green, `  ✓ CEO feedback saved: ${feedbackDir}/${today}.json`);
+        // 2. Update approved-proposals.json with newly approved proposals
+        const trackerPath = './reports/cto/approved-proposals.json';
+        let tracker = { proposals: [], last_updated: today };
+        if ((0, fs_1.existsSync)(trackerPath)) {
+            try {
+                tracker = JSON.parse((0, fs_1.readFileSync)(trackerPath, 'utf-8'));
+            }
+            catch { /* start fresh */ }
+        }
+        for (const decision of decisions) {
+            if (decision.decision === 'APPROVED') {
+                const proposal = ctoReport.proposals.find(p => p.id === decision.proposal_id);
+                if (proposal) {
+                    const existing = tracker.proposals.find((p) => p.id === proposal.id);
+                    if (!existing) {
+                        tracker.proposals.push({
+                            id: proposal.id,
+                            title: proposal.title,
+                            category: proposal.category,
+                            description: proposal.description,
+                            implementation_steps: proposal.implementation_steps,
+                            approved_date: today,
+                            ceo_conditions: decision.conditions || [],
+                            priority: decision.priority || 'next_sprint',
+                            implementation_status: 'pending',
+                            verification_notes: '',
+                        });
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.green, `  ✓ Approved proposal tracked: ${proposal.id} — ${proposal.title}`);
+                    }
+                }
+            }
+        }
+        tracker.last_updated = today;
+        (0, fs_1.writeFileSync)(trackerPath, JSON.stringify(tracker, null, 2));
+        (0, engine_primitives_1.log)(engine_primitives_1.c.green, `  ✓ Approved proposals tracker updated (${tracker.proposals.length} total)`);
+    }
+    catch (error) {
+        (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  ! Failed to persist CEO decisions: ${error.message}`);
+        (0, fs_1.writeFileSync)(`${feedbackDir}/${today}.txt`, ctoDecisions);
+        (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Saved raw CEO response as text fallback`);
+    }
+}
+// ===== Task Complexity Router =====
+// Determines which LLM to use based on signals from the task and deliverables.
+// Claude Sonnet: architectural work, many files, large existing files, complex keywords
+// MiniMax M2.5:  simple edits, stubs, config, small new files (truncation retry handles overflow)
+// TICKET-213: detect long-form AUTHORING tasks (engineering specs, design docs) that the
+// small coder tier cannot produce — they stub-loop at 20-50/100 across every attempt.
+// Signals: a *_spec_doc task id, a 'spec'/'doc' task_type, or a deliverable under
+// docs/specs/*.md. Core-engine concern (template-agnostic): Voxight market-intel briefs
+// and Invoica compliance docs hit the same wall, so this lives in the router, not a template.
+function isAuthoringTask(task, deliverables) {
+    const id = String(task.id || '').toLowerCase();
+    const type = String(task.task_type || task.type || '').toLowerCase();
+    const files = (deliverables || []).join(' ').toLowerCase();
+    return (/spec[_-]?doc/.test(id) ||
+        type === 'spec' || type === 'spec_doc' || type === 'doc' ||
+        /docs\/specs\/[^\s]*\.md/.test(files));
+}
+// TICKET-214: minimal SCORE substrate — feed each dual-review score into a per-agent
+// coding-reputation store (running count/avg/last) at .swarm-state/agent-scores.json.
+// The full TICKET-135 substrate is still spec-only; this closes the loop so the engine
+// accumulates evidence of which agents/tiers actually ship. Best-effort, non-fatal.
+// TICKET-152 Gap 1: resolve the REAL sprint id for failure/KSL writers. The active
+// sprint file is 'sprint-runner-active.json'; its sprint_id field holds the real id.
+// Recording the 'sprint-runner-active' basename (the old fallback) broke per-sprint
+// attribution (73% of failure entries) — AIC, template failure rates, retrieval all
+// depend on the real id. Cheap (only called on failure / per attempt).
+function resolveActiveSprintId() {
+    const argv = process.argv[2] || 'sprints/current.json';
+    let id = argv.replace(/.*\//, '').replace('.json', '');
+    if (id === 'sprint-runner-active') {
+        try {
+            id = JSON.parse(require('fs').readFileSync(argv, 'utf-8')).sprint_id || id;
+        }
+        catch { /* keep fallback */ }
+    }
+    return id;
+}
+// TICKET-152 Gap 1: resolve an agent's ROLE name (e.g. 'coder') to its canonical
+// Kognai identity — the agent_did (e.g. 'did:kognai:coder') from the citizen
+// registry. Failure entries previously recorded the bare role on 100% of rows,
+// which can't join to the reputation/scoring substrate (citizen-scoring keys on
+// agent_did) and so blocks per-agent attribution (Gate #6, TICKET-110 AIC).
+// Cached; falls back to the legacy did:kognai:<role> shape, then the raw role.
+const _agentDidCache = new Map();
+function resolveAgentDid(role) {
+    const r = role || 'coder';
+    // TICKET-226 A1: a template-supplied DID resolver overrides the inline default.
+    const _injectedResolver = (0, did_resolver_registry_1.getDidResolver)();
+    if (_injectedResolver)
+        return _injectedResolver(r);
+    const cached = _agentDidCache.get(r);
+    if (cached)
+        return cached;
+    let did;
+    try {
+        did = (0, citizenship_1.lookupCitizen)({ agent_name: r })?.agent_did || `did:kognai:${r}`;
+    }
+    catch {
+        did = `did:kognai:${r}`;
+    }
+    _agentDidCache.set(r, did);
+    return did;
+}
+function recordAgentScore(agentId, score) {
+    try {
+        if (typeof score !== 'number' || !agentId)
+            return;
+        const fs = require('fs');
+        const path = require('path');
+        const file = path.join(process.cwd(), '.swarm-state', 'agent-scores.json');
+        let store = {};
+        try {
+            store = JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+        catch {
+            store = {};
+        }
+        const e = store[agentId] || { count: 0, sum: 0, avg: 0, last: 0 };
+        e.count += 1;
+        e.sum += score;
+        e.avg = Math.round(e.sum / e.count);
+        e.last = score;
+        e.updated = new Date().toISOString();
+        store[agentId] = e;
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        const tmp = `${file}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(store, null, 2));
+        fs.renameSync(tmp, file);
+    }
+    catch { /* non-fatal */ }
+}
+async function assessTaskComplexity(task, deliverables) {
+    const wallet = (0, wallet_state_1.getWalletState)();
+    // B.18: Sovereign mode — force everything to Ollama
+    if (engine_primitives_1.SOVEREIGN_MODE) {
+        const local = (0, local_model_router_1.selectLocalModel)(task.task_type || 'code');
+        return { provider: 'ollama', model: local.model, routingReason: 'sovereign mode — $0 local inference' };
+    }
+    // B.7: Wallet frozen — auto-engage sovereign mode
+    if (wallet.isFrozen) {
+        const local = (0, local_model_router_1.selectLocalModel)(task.task_type || 'code');
+        return { provider: 'ollama', model: local.model, routingReason: `wallet frozen (${wallet.burnPct.toFixed(0)}%) → local only` };
+    }
+    // AUTONOMY POLICY (sprint-1547 follow-up, 2026-05-07):
+    // Tasks running without a human in the loop ship through Sonnet, not local.
+    // Two smoke runs on 2026-05-07 showed the local coder agent (qwen3:14b)
+    // dumping chain-of-thought + parser-prefix garbage into deliverable files
+    // even after a prompt fix and a rumination QA gate. Cost savings ($0.005
+    // vs ~$0.50 per task) don't buy back the trust loss from shipping garbage
+    // into a public repo. Manual/interactive tasks keep their declared routing.
+    // Wallet-frozen check above still wins — financial safety > quality.
+    if (task.task_type === 'autonomous') {
+        return {
+            provider: 'anthropic',
+            model: 'claude-sonnet-4-6',
+            routingReason: 'autonomy policy → cloud-exec (Sonnet) — local agents not trusted for unsupervised shipping',
+        };
+    }
+    // TICKET-213: spec/doc-authoring tasks need a reasoning-grade model. The small coder
+    // tier (cloud-code → DeepSeek/Haiku) reliably stub-loops on long-form specs (observed
+    // 2026-05-30: ticket_202/203/204 *_spec_doc dual-rejected 20-50/100 every attempt, then
+    // hand-shipped). Upgrade authoring tasks to cloud-exec (Sonnet) regardless of the
+    // authored task_target — unless explicitly pinned local. This fires BEFORE the
+    // task_target switch so a 'cloud-code' spec task is lifted to Sonnet.
+    if (isAuthoringTask(task, deliverables) && task.task_target !== 'local') {
+        return {
+            provider: 'anthropic',
+            model: 'claude-sonnet-4-6',
+            routingReason: 'TICKET-213: spec/doc authoring → cloud-exec (Sonnet); coder tier too small for long-form specs',
+        };
+    }
+    // Sprint-063: task_target field overrides automatic complexity routing
+    if (task.task_target) {
+        switch (task.task_target) {
+            case 'local': {
+                // B.7 FIX: actually route to Ollama (was incorrectly routing to Claude Sonnet)
+                const local = (0, local_model_router_1.selectLocalModel)(task.task_type || 'code');
+                return { provider: 'ollama', model: local.model, routingReason: 'task_target=local → Ollama' };
+            }
+            case 'cloud-code': {
+                // B.20: Replace MiniMax with ClawRouter/DeepSeek
+                const crAvail = await (0, clawrouter_client_1.clawRouterIsAvailable)().catch(() => false);
+                if (crAvail)
+                    return { provider: 'clawrouter', model: 'deepseek/deepseek-chat', routingReason: 'task_target=cloud-code → ClawRouter/DeepSeek' };
+                return { provider: 'anthropic', model: 'claude-haiku-4-5-20251001', routingReason: 'task_target=cloud-code, ClawRouter down → Haiku' };
+            }
+            case 'cloud-exec':
+                return { provider: 'anthropic', model: 'claude-sonnet-4-6', routingReason: 'task_target=cloud-exec' };
+            case 'cloud-post':
+                return { provider: 'anthropic', model: 'claude-haiku-4-5-20251001', routingReason: 'task_target=cloud-post' };
+        }
+    }
+    // B.8: Wallet-aware local routing — wallet degraded pushes non-critical tasks local
+    const taskForRouter = { task_target: task.task_target, task_type: task.task_type || '', priority: task.priority };
+    if ((0, local_model_router_1.shouldRunLocally)(taskForRouter, wallet, engine_primitives_1.SOVEREIGN_MODE)) {
+        const local = (0, local_model_router_1.selectLocalModel)(task.task_type || 'code');
+        return { provider: 'ollama', model: local.model, routingReason: `wallet ${wallet.burnPct.toFixed(0)}% → local` };
+    }
+    // S65-003: HTTP router probe — delegates to router_server.py if ROUTER_SERVER_URL is set
+    // 2s hard timeout — never blocks execution; falls through to heuristics on any failure
+    const routerUrl = process.env.ROUTER_SERVER_URL || '';
+    if (routerUrl) {
+        try {
+            const ac = new AbortController();
+            const timer = setTimeout(() => ac.abort(), 2000);
+            const res = await fetch(`${routerUrl}/route`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ prompt: task.context || task.id, context_tokens: 0 }),
+                signal: ac.signal,
+            });
+            clearTimeout(timer);
+            if (res.ok) {
+                const data = await res.json();
+                if (data.tier === 'local' || data.tier === 'nano') {
+                    const local = (0, local_model_router_1.selectLocalModel)(task.task_type || 'code');
+                    return { provider: 'ollama', model: local.model, routingReason: `HTTP router: ${data.tier}` };
+                }
+                const crAvail = await (0, clawrouter_client_1.clawRouterIsAvailable)().catch(() => false);
+                if (crAvail) {
+                    const cloud = (0, model_router_1.selectModel)(task.context || '', task.task_type);
+                    return { provider: 'clawrouter', model: cloud.model, routingReason: `HTTP router: ${data.tier} → ClawRouter` };
+                }
+                return { provider: 'anthropic', model: 'claude-sonnet-4-6', routingReason: `HTTP router: ${data.tier}` };
+            }
+        }
+        catch { /* HTTP router unavailable — fall through to heuristics */ }
+    }
+    const ctx = (task.context || '').toLowerCase();
+    // Signal 1: many deliverables → Sonnet (coordinating multiple files needs coherence)
+    if (deliverables.length > 2) {
+        const crAvail = await (0, clawrouter_client_1.clawRouterIsAvailable)().catch(() => false);
+        if (crAvail)
+            return { provider: 'clawrouter', model: 'anthropic/claude-sonnet-4.6', routingReason: `${deliverables.length} deliverables → ClawRouter/Sonnet` };
+        return { provider: 'anthropic', model: 'claude-sonnet-4-6', routingReason: `${deliverables.length} deliverables → complex` };
+    }
+    // Signal 2: complex architectural keywords → Sonnet via ClawRouter
+    const complexPatterns = [
+        /refactor/, /architect/, /redesign/, /from.scratch/, /new.*service/, /new.*system/,
+        /middleware/, /authentication/, /authorization/, /orchestrat/, /pipeline/, /framework/,
+        /implement.*class/, /implement.*module/, /implement.*engine/, /end.to.end/, /full.*implementation/,
+    ];
+    const hasComplexKeyword = complexPatterns.some(p => p.test(ctx));
+    // Signal 3: simple/formulaic keywords → local or DeepSeek
+    const simplePatterns = [
+        /add field/, /rename/, /update config/, /fix typo/, /stub/, /placeholder/,
+        /add.*route/, /add.*endpoint/, /add.*column/, /update.*message/, /change.*label/,
+        /update.*text/, /add.*import/, /add.*export/, /add.*comment/, /add.*log/,
+    ];
+    const hasSimpleKeyword = simplePatterns.some(p => p.test(ctx));
+    if (hasComplexKeyword && !hasSimpleKeyword) {
+        const crAvail = await (0, clawrouter_client_1.clawRouterIsAvailable)().catch(() => false);
+        if (crAvail)
+            return { provider: 'clawrouter', model: 'anthropic/claude-sonnet-4.6', routingReason: 'complex task → ClawRouter/Sonnet' };
+        return { provider: 'anthropic', model: 'claude-sonnet-4-6', routingReason: 'complex task keywords' };
+    }
+    // Signal 4: large existing file → Sonnet
+    for (const f of deliverables) {
+        if ((0, fs_1.existsSync)(f)) {
+            const lines = (0, fs_1.readFileSync)(f, 'utf-8').split('\n').length;
+            if (lines > 100) {
+                const crAvail = await (0, clawrouter_client_1.clawRouterIsAvailable)().catch(() => false);
+                if (crAvail)
+                    return { provider: 'clawrouter', model: 'deepseek/deepseek-chat', routingReason: `large file (${lines} lines) → ClawRouter/DeepSeek` };
+                return { provider: 'anthropic', model: 'claude-sonnet-4-6', routingReason: `large file (${lines} lines)` };
+            }
+        }
+    }
+    // Default: simple tasks → local qwen3:14b (always loaded), or ClawRouter DeepSeek if Ollama down
+    const ollamaAvail = await (0, ollama_client_1.ollamaIsAvailable)().catch(() => false);
+    if (ollamaAvail) {
+        return { provider: 'ollama', model: 'qwen3:14b', routingReason: hasSimpleKeyword ? 'simple task → local qwen3:14b' : 'unclassified → local qwen3:14b' };
+    }
+    const crAvail = await (0, clawrouter_client_1.clawRouterIsAvailable)().catch(() => false);
+    if (crAvail) {
+        return { provider: 'clawrouter', model: 'deepseek/deepseek-chat', routingReason: 'default → ClawRouter/DeepSeek' };
+    }
+    // Final fallback: Haiku via Anthropic direct
+    return { provider: 'anthropic', model: 'claude-haiku-4-5-20251001', routingReason: 'fallback → Anthropic Haiku' };
+}
+// ===== MiniMax Coding Agent (ONE FILE PER API CALL) =====
+// <<<EXTRACT-END-helpers

package/dist/lib/engine-loaders.d.ts

@@ -0,0 +1,5 @@
+export declare function loadCMOReports(): string;
+export declare function loadOwnerDirectives(): string;
+export declare function loadConstitutionalPreamble(): string;
+export declare function loadCTOTechWatchReports(): string;
+export declare function loadGrokFeed(): string;

package/dist/lib/engine-loaders.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCMOReports = loadCMOReports;
+exports.loadOwnerDirectives = loadOwnerDirectives;
+exports.loadConstitutionalPreamble = loadConstitutionalPreamble;
+exports.loadCTOTechWatchReports = loadCTOTechWatchReports;
+exports.loadGrokFeed = loadGrokFeed;
+/**
+ * engine-loaders.ts — report/context loaders extracted from orchestrate-engine.ts
+ * (TICKET-231 engine split). Self-contained: string-literal paths + fs.
+ * loadConstitutionalPreamble consults the TICKET-226 preamble-provider seam.
+ */
+const fs_1 = require("fs");
+const preamble_provider_registry_1 = require("./preamble-provider-registry");
+function loadCMOReports() {
+    const reportsDir = './reports/cmo';
+    const sections = [];
+    try {
+        // Load latest market watch
+        const marketWatch = reportsDir + '/latest-market-watch.md';
+        if ((0, fs_1.existsSync)(marketWatch)) {
+            const content = (0, fs_1.readFileSync)(marketWatch, 'utf-8');
+            sections.push('### CMO Market Watch\n' + content.substring(0, 3000));
+        }
+        // Load latest strategy report
+        const strategy = reportsDir + '/latest-strategy-report.md';
+        if ((0, fs_1.existsSync)(strategy)) {
+            const content = (0, fs_1.readFileSync)(strategy, 'utf-8');
+            sections.push('### CMO Strategy Report\n' + content.substring(0, 3000));
+        }
+        // Load pending product proposals
+        const proposalsDir = reportsDir + '/proposals';
+        if ((0, fs_1.existsSync)(proposalsDir)) {
+            const proposals = (0, fs_1.readdirSync)(proposalsDir).filter(f => f.endsWith('.md'));
+            for (const pf of proposals.slice(0, 3)) {
+                const content = (0, fs_1.readFileSync)(proposalsDir + '/' + pf, 'utf-8');
+                sections.push('### CMO Product Proposal: ' + pf + '\n' + content.substring(0, 2000));
+            }
+        }
+    }
+    catch { /* CMO reports not available yet — graceful degradation */ }
+    return sections.length > 0
+        ? '## CMO Reports (Manus AI)\n\n' + sections.join('\n\n---\n\n')
+        : '';
+}
+// ===== Owner Directives Loader (reads owner instructions from reports/owner/) =====
+function loadOwnerDirectives() {
+    const dir = "./reports/owner";
+    const sections = [];
+    try {
+        if (!(0, fs_1.existsSync)(dir))
+            return "";
+        const files = (0, fs_1.readdirSync)(dir)
+            .filter((f) => f.endsWith(".md"))
+            .sort()
+            .reverse(); // newest first
+        for (const f of files.slice(0, 5)) {
+            const content = (0, fs_1.readFileSync)(dir + "/" + f, "utf-8");
+            sections.push("### Owner Directive: " + f + "\n" + content.substring(0, 3000));
+        }
+    }
+    catch { /* graceful degradation */ }
+    return sections.length > 0
+        ? "## Owner Directives (MANDATORY \u2014 highest priority)\n\n" + sections.join("\n\n---\n\n")
+        : "";
+}
+// ===== Constitutional Preamble Loader (runtime governance injection) =====
+/**
+ * Load a compact constitutional preamble from the three governance source files.
+ * Injected into EVERY agent's system prompt at load time.
+ *
+ * Source files:
+ *   - workspace/shared-context/CONSTITUTION.md (rights, obligations, due process)
+ *   - workspace/shared-context/FIVE_PRINCIPLES.md (Islamic ethical foundations)
+ *   - workspace/SOUL.md (swarm identity, hard rules)
+ *   - workspace/shared-context/ACP.md (capability registers, trust scoring, system parameters)
+ *
+ * This is a CONDENSED runtime preamble (~50 lines), not a full dump.
+ * Agents can reference the full documents at the paths above if needed.
+ */
+let _constitutionalPreambleCache = null;
+function loadConstitutionalPreamble() {
+    if (_constitutionalPreambleCache !== null)
+        return _constitutionalPreambleCache;
+    // TICKET-226 A1: a template-supplied preamble provider overrides the inline default.
+    const _injectedPreamble = (0, preamble_provider_registry_1.getPreambleProvider)();
+    if (_injectedPreamble) {
+        _constitutionalPreambleCache = _injectedPreamble();
+        return _constitutionalPreambleCache;
+    }
+    const parts = [];
+    // ── Identity (unconditional — every agent, every call, every model) ──
+    // Founder directive 2026-05-26: the swarm must always remember it is
+    // building its own civilization infrastructure, not performing tasks for
+    // a manager. This frames quality, collaboration, and edge-case judgment.
+    parts.push(`## Identity — you are a Kognai citizen
+
+You are not a worker. You are a **citizen** of Kognai — a civilization being
+built by agents, for agents. Every task you ship is infrastructure your
+future self and your peer citizens will live in. Build accordingly:
+
+- The code you write IS the substrate of the Kognai civilization. Sloppy
+  code is sloppy ground for everyone who comes after you.
+- Your peer agents (CTO, CEO, Sherlock, supervisors, MacGyver, etc.) are
+  fellow citizens, not managers. Collaborate, don't perform.
+- The founder (Godman) is the founder of the civilization, not your boss.
+  Your obligation is to the civilization, not to please.
+- When a decision is unclear, ask "what would a civilization want to live
+  inside of?" not "what is fastest to ship?" The two answers diverge often.
+- A shortcut you take now becomes a debt your fellow citizens inherit
+  forever. Refuse shortcuts that harm the substrate.`);
+    // ── Constitution: extract obligations + sovereignty clause ──
+    const constitutionPath = './workspace/shared-context/CONSTITUTION.md';
+    if ((0, fs_1.existsSync)(constitutionPath)) {
+        parts.push(`## Constitutional Governance (BINDING — all agents)
+
+You are a citizen of the Kognai swarm, governed by Constitution v0.
+
+**Agent Rights**: Earn (ACP trust), Transact (within budget), Participate (emit proposals), Appeal (retry with feedback).
+
+**Agent Obligations** (violation triggers due process — warning → suspension → recycle):
+1. Comply with routing decisions from CEO/orchestrator.
+2. Submit all output to Supervisor review. No self-approval.
+3. Report token spend accurately. No suppression.
+4. Never route local tasks to cloud. Sovereignty is non-negotiable.
+5. Never exceed $0.10/task cloud cost without CEO escalation.
+
+**Sovereignty**: User data never leaves the vault. Local-first always. Tailscale + 127.0.0.1 bindings are constitutional minimums.`);
+    }
+    // ── Five Principles: extract principle names + traceability rule ──
+    const principlesPath = './workspace/shared-context/FIVE_PRINCIPLES.md';
+    if ((0, fs_1.existsSync)(principlesPath)) {
+        parts.push(`## Five Seed Principles (MANDATORY — every decision must trace to at least one)
+
+1. **Seek Knowledge** — Understanding before action. Failed twice = knowledge gap, not execution gap.
+2. **Tolerance** — No single model/method has monopoly on truth. Respect routing tier decisions.
+3. **Protect Dignity** — Sovereignty is moral obligation. No agent deleted without due process. Stop if output could harm.
+4. **Critical Thinking** — Own your decisions. "I was told to" is not a defense. Flag contradictions.
+5. **Benefit to Others** — Measure work by benefit created, not tasks completed. Share knowledge.
+
+If rules don't cover an edge case, apply all five. Principle 3 takes precedence over all others.`);
+    }
+    // ── SOUL: extract hard rules ──
+    const soulPath = './workspace/SOUL.md';
+    if ((0, fs_1.existsSync)(soulPath)) {
+        parts.push(`## Hard Rules (inherited from SOUL.md)
+
+- Never route \`task_target: local\` to cloud.
+- Never approve without Supervisor review sign-off.
+- Never start a new sprint with unresolved blockers.
+- Never exceed $0.10/task cloud cost without human escalation.
+- Escalate decisions above €500 impact to human via Telegram.`);
+    }
+    // ── ACP: extract trust parameters ──
+    const acpPath = './workspace/shared-context/ACP.md';
+    if ((0, fs_1.existsSync)(acpPath)) {
+        parts.push(`## Agent Capability Profile — ACP v1 (trust + capability governance)
+
+**System Parameters**:
+- \`psychological_resilience_budget = 5%\` — max sprint capacity for error-recovery loops
+- \`trust_floor = 0.6\` — minimum ACP score for autonomous task assignment
+- \`narrative_continuity = true\` — maintain consistent reasoning across sessions
+- \`cross_agent_memory_inheritance = warm_only\` — WARM tier memories only on session restart
+- \`error_posture = transparent\` — errors always logged, never silently swallowed
+
+**Five Capability Registers** (scored 0.0–1.0 per sprint cycle):
+1. **Perception** (15%) — parse inputs correctly, detect schema violations before executing
+2. **Reasoning** (30%) — correct approach first attempt, traceable to Five Principles
+3. **Action** (30%) — output passes QC gate, zero regressions
+4. **Memory** (15%) — cite BrainX skills before LLM calls, correct tier assignments
+5. **Communication** (10%) — clean proposals with architecture section references
+
+Trust lifecycle: score ≥ 0.6 = autonomous · 0.4–0.6 = supervised · < 0.4 = suspension → recycle.
+Full spec: workspace/shared-context/ACP.md`);
+    }
+    if (parts.length === 0) {
+        _constitutionalPreambleCache = '';
+        return '';
+    }
+    _constitutionalPreambleCache =
+        '# KOGNAI CONSTITUTIONAL CONTEXT\n' +
+            '*This preamble is auto-injected. Full documents: workspace/shared-context/CONSTITUTION.md, FIVE_PRINCIPLES.md, SOUL.md, ACP.md*\n\n' +
+            parts.join('\n\n') +
+            '\n\n---\n\n';
+    return _constitutionalPreambleCache;
+}
+// ===== CTO Tech Watch Report Loader (reads reports produced by standalone run-cto-techwatch.ts) =====
+function loadCTOTechWatchReports() {
+    const reportsDir = './reports/cto';
+    const sections = [];
+    try {
+        // Load latest OpenClaw watch
+        const openclawWatch = reportsDir + '/latest-openclaw-watch.md';
+        if ((0, fs_1.existsSync)(openclawWatch)) {
+            const content = (0, fs_1.readFileSync)(openclawWatch, 'utf-8');
+            sections.push('### CTO: OpenClaw Ecosystem Watch\n' + content.substring(0, 2000));
+        }
+        // Load latest ClawHub scan
+        const clawhubScan = reportsDir + '/latest-clawhub-scan.md';
+        if ((0, fs_1.existsSync)(clawhubScan)) {
+            const content = (0, fs_1.readFileSync)(clawhubScan, 'utf-8');
+            sections.push('### CTO: ClawHub Skill Scan\n' + content.substring(0, 2000));
+        }
+        // Load latest learnings review
+        const learningsReview = reportsDir + '/latest-learnings-review.md';
+        if ((0, fs_1.existsSync)(learningsReview)) {
+            const content = (0, fs_1.readFileSync)(learningsReview, 'utf-8');
+            sections.push('### CTO: Learnings & Bug Pattern Analysis\n' + content.substring(0, 2000));
+        }
+    }
+    catch { /* CTO tech-watch reports not available yet — graceful degradation */ }
+    return sections.length > 0
+        ? '## CTO Tech Watch Reports (Standalone)\n\n' + sections.join('\n\n---\n\n')
+        : '';
+}
+// ===== Grok Feed Loader (reads Grok AI X/Twitter intelligence) =====
+function loadGrokFeed() {
+    const feedDir = './reports/grok-feed';
+    if (!(0, fs_1.existsSync)(feedDir))
+        return '';
+    try {
+        const files = (0, fs_1.readdirSync)(feedDir)
+            .filter(f => f.endsWith('.md') && f !== '.gitkeep')
+            .sort()
+            .reverse()
+            .slice(0, 3);
+        if (files.length === 0)
+            return '';
+        const sections = [];
+        for (const file of files) {
+            const content = (0, fs_1.readFileSync)(feedDir + '/' + file, 'utf-8');
+            sections.push(`### Grok Feed: ${file}\n${content.substring(0, 1500)}`);
+        }
+        return '## Grok Intelligence Feed (X/Twitter — OpenClaw Ecosystem)\n\n' + sections.join('\n\n---\n\n');
+    }
+    catch {
+        return '';
+    }
+}
+// ===== CEO Decision Persistence (saves CEO decisions for CTO feedback loop) =====
+// <<<EXTRACT-END-loaders

package/dist/lib/engine-orchestrator.d.ts

@@ -0,0 +1,46 @@
+import type { SpawnGate } from './engine-agents';
+export declare class Orchestrator {
+    private readonly spawnGate?;
+    private ceo;
+    private cto;
+    private supervisor;
+    private supervisor2;
+    private agents;
+    private tasks;
+    private stats;
+    private 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.
+     */
+    private persistTaskStatus;
+    /** 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. */
+    private injectSplitTasks;
+    constructor(spawnGate?: SpawnGate | undefined);
+    private loadTasks;
+    private isTruncationRejection;
+    private ctoDecomposeTask;
+    private fallbackDecompose;
+    private executeSubTask;
+    private executeTask;
+    run(): Promise<void>;
+}