@kognai/orchestrator-core 0.1.3 → 0.1.4

package/dist/index.d.ts

@@ -23,6 +23,7 @@ export * from './lib/trust-score-updater';
 export * from './lib/citizenship';
 export * from './lib/agent-registry';
 export * from './lib/sprint-state';
+export * from './lib/build-triage';
 export * as ksl from './lib/ksl';
 export * from './lib/wallet-state';
 export * from './lib/ceo-wallet';

package/dist/index.js

@@ -82,6 +82,9 @@ __exportStar(require("./lib/citizenship"), exports);
 __exportStar(require("./lib/agent-registry"), exports);
 // TICKET-098 sprint runtime-state split (committed defs vs gitignored status).
 __exportStar(require("./lib/sprint-state"), exports);
+// TICKET-234 build triage seam — classifyBuildPath (ceremony-depth axis) +
+// logBuildTriage. Consumed by the orchestrator run loop AND by kognai-build.
+__exportStar(require("./lib/build-triage"), exports);
 // Phase 3b-3 Wave B: KSL capture cluster (session records + error log + tap).
 // Namespaced ('ksl.tapAttempt', 'ksl.writeRecord', 'ksl.record', …) to keep the
 // generic 'record' export off the package's flat public surface.

package/dist/lib/build-triage.d.ts

@@ -0,0 +1,27 @@
+export type BuildPath = 'regulated' | 'fast';
+export interface BuildTriageResult {
+    path: BuildPath;
+    reason: string;
+    triggers: string[];
+    sensitive: boolean;
+    sovereign: boolean;
+    complexity: 'low' | 'medium' | 'high';
+    taskCount: number;
+    codeFileCount: number;
+}
+/**
+ * Classify a build into a ceremony-depth path. Pure + synchronous: it only reads
+ * the sprint JSON + task list, so it adds negligible cost relative to the
+ * ceremony it gates. Default-to-regulated on uncertainty.
+ *
+ * @param sprint  the raw sprint object (may carry regulated/strict/fast_track/sovereign flags)
+ * @param tasks   the loaded task list (each with deliverables/context/type)
+ */
+export declare function classifyBuildPath(sprint: any, tasks: any[]): BuildTriageResult;
+/**
+ * Append the triage decision to logs/routing/triage.jsonl (location-independent
+ * via engine-paths). Best-effort: never throws into the run loop. This is the
+ * audit trail required by the ticket — evidence that triage routes correctly and
+ * the means to audit any fast-tracked build later.
+ */
+export declare function logBuildTriage(sprintId: string, result: BuildTriageResult): void;

package/dist/lib/build-triage.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyBuildPath = classifyBuildPath;
+exports.logBuildTriage = logBuildTriage;
+/**
+ * build-triage.ts — TICKET-234: pre-orchestrator build triage (ceremony-depth axis).
+ *
+ * The orchestrator historically ran the SAME full ceremony for every build
+ * regardless of complexity or sensitivity (CEO assessment → execution →
+ * dual-supervisor review → CTO data analysis → CEO proposal cycle → post-sprint
+ * + agent minting). A 3-line `addTwo` cost 171s + the entire ceremony.
+ *
+ * This module adds a cheap classifier that runs BEFORE the orchestrator hands
+ * off to the swarm and routes the build to one of two execution paths:
+ *
+ *   - REGULATED (full ceremony) — CEO · CTO governance gate · dual-supervisor
+ *     review · reconciliation · the full CTO/CEO proposal cycle. Templates apply
+ *     on this path only. For sensitive / sovereign / complex builds.
+ *
+ *   - FAST  — coder → single-supervisor review → the minimum safety/security/
+ *     quality gate (QA gate: typecheck/compile/no-secrets, always on). No
+ *     dual-supervisor, no CTO/CEO post-sprint ceremony, no templates. For
+ *     simple, low-stakes, single-file, non-sensitive builds.
+ *
+ * It is the CEREMONY-DEPTH axis. It composes WITH `assessTaskComplexity`
+ * (engine-helpers), which scores the MODEL-ROUTING axis — they are orthogonal:
+ * a fast-tracked build can still route to a cloud model, and a regulated build
+ * can still run local. This stays a PURE HEURISTIC (no LLM call) so the triage
+ * never reintroduces the overhead it removes.
+ *
+ * Safety invariant: DEFAULT TO REGULATED on any uncertainty. `fast` is returned
+ * only when the build is provably simple AND non-sensitive AND non-sovereign.
+ * A `fast_track` opt-in never lowers the safety floor — sensitivity/complexity
+ * still force REGULATED.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const engine_paths_1 = require("./engine-paths");
+// Sensitivity keywords — PHI/PII, payments/financial, auth/secrets/credentials,
+// crypto/on-chain/contracts, destructive or privileged operations. A match in a
+// deliverable path, task context, or sprint goal forces REGULATED.
+const SENSITIVE_KEYWORDS = [
+    // auth / secrets / credentials
+    'auth', 'secret', 'credential', 'password', 'passwd', 'api[_-]?key', 'apikey',
+    'access[_-]?token', 'private[_-]?key', 'privatekey', 'seed[_-]?phrase', 'mnemonic',
+    'oauth', 'jwt', 'session[_-]?token', 'vault',
+    // payments / financial
+    'payment', 'billing', 'invoice', 'payout', 'stripe', 'paypal', 'charge', 'refund',
+    'kyc', 'ledger', 'wallet', 'pricing',
+    // crypto / on-chain / contracts
+    'x402', 'crypto', 'on[_-]?chain', 'onchain', 'blockchain', 'smart[_-]?contract',
+    'erc20', 'erc-20', 'usdc', '\\$kog', 'viem', 'web3',
+    // PHI / PII / regulated data
+    '\\bphi\\b', '\\bpii\\b', 'gdpr', 'hipaa', 'personal[_-]?data', 'health[_-]?record',
+    // schema / data migrations (high-blast-radius, hard to roll back)
+    'migration', 'prisma/migrations', 'drop[_-]?table', 'alter[_-]?table',
+];
+// Destructive / privileged operations — context-level matches force REGULATED.
+const DESTRUCTIVE_KEYWORDS = [
+    'rm\\s+-rf', 'drop\\s+table', 'delete\\s+from', 'truncate\\s+table',
+    'force[_-]?push', '--force', 'chmod\\s+777', 'sudo\\b', 'kill\\s+-9',
+];
+// Sensitive directories — a deliverable under one of these forces REGULATED.
+const SENSITIVE_DIRS = [
+    'banks/', 'wallet', 'ceo-wallet', 'gates/', 'policy/', 'contracts/', 'omel/',
+    'x402-base/', 'prisma/', 'credential', '.env', 'auth/', 'secrets/',
+];
+// Architectural / cross-cutting keywords — a match means the change is not a
+// simple single-concern build → REGULATED.
+const ARCHITECTURAL_KEYWORDS = [
+    'architect', 'refactor', 'migrate', 'cross[_-]?cutting', 'system[_-]?wide',
+    'redesign', 'database', 'schema', 'infrastructure', 'orchestrat', 'pipeline',
+    'framework', 'breaking[_-]?change', 'rewrite',
+];
+function compile(words) {
+    return new RegExp(`(${words.join('|')})`, 'i');
+}
+const SENSITIVE_RE = compile(SENSITIVE_KEYWORDS);
+const DESTRUCTIVE_RE = compile(DESTRUCTIVE_KEYWORDS);
+const ARCH_RE = compile(ARCHITECTURAL_KEYWORDS);
+function asBool(v) {
+    return v === true || v === 'true' || v === 1 || v === '1';
+}
+/**
+ * Classify a build into a ceremony-depth path. Pure + synchronous: it only reads
+ * the sprint JSON + task list, so it adds negligible cost relative to the
+ * ceremony it gates. Default-to-regulated on uncertainty.
+ *
+ * @param sprint  the raw sprint object (may carry regulated/strict/fast_track/sovereign flags)
+ * @param tasks   the loaded task list (each with deliverables/context/type)
+ */
+function classifyBuildPath(sprint, tasks) {
+    const triggers = [];
+    const taskList = Array.isArray(tasks) ? tasks : [];
+    const taskCount = taskList.length;
+    // Gather all the text we scan for sensitivity/architecture signals.
+    const deliverablePaths = [];
+    const codeFiles = [];
+    for (const t of taskList) {
+        const d = (t && t.deliverables) || {};
+        const code = Array.isArray(d.code) ? d.code : [];
+        const tests = Array.isArray(d.tests) ? d.tests : [];
+        const docs = Array.isArray(d.docs) ? d.docs : [];
+        codeFiles.push(...code);
+        deliverablePaths.push(...code, ...tests, ...docs);
+    }
+    const codeFileCount = new Set(codeFiles).size;
+    const contextText = taskList
+        .map((t) => `${(t && (t.context || t.title || t.id)) || ''} ${(t && (t.type || t.task_type)) || ''}`)
+        .join(' ');
+    const goalText = `${sprint?.name || sprint?.title || ''} ${sprint?.goal || sprint?.description || ''}`;
+    const pathText = deliverablePaths.join(' ');
+    const haystack = `${goalText} ${contextText} ${pathText}`;
+    // ── Explicit flags ────────────────────────────────────────────────────────
+    const forcedRegulated = asBool(sprint?.regulated) || asBool(sprint?.strict) || asBool(process.env.KOGNAI_FORCE_REGULATED);
+    const requestedFast = asBool(sprint?.fast_track) || asBool(sprint?.fast);
+    if (forcedRegulated)
+        triggers.push('explicit:regulated');
+    // ── Sensitivity ───────────────────────────────────────────────────────────
+    let sensitive = false;
+    if (SENSITIVE_RE.test(haystack)) {
+        sensitive = true;
+        triggers.push(`sensitive:keyword(${(haystack.match(SENSITIVE_RE) || [])[1]})`);
+    }
+    if (DESTRUCTIVE_RE.test(haystack)) {
+        sensitive = true;
+        triggers.push(`sensitive:destructive(${(haystack.match(DESTRUCTIVE_RE) || [])[1]})`);
+    }
+    const dirHit = SENSITIVE_DIRS.find((dir) => pathText.toLowerCase().includes(dir.toLowerCase()));
+    if (dirHit) {
+        sensitive = true;
+        triggers.push(`sensitive:path(${dirHit})`);
+    }
+    // ── Sovereign / regulated domain ──────────────────────────────────────────
+    const sovereign = asBool(sprint?.sovereign) || asBool(sprint?.regulated_domain);
+    if (sovereign)
+        triggers.push('sovereign');
+    // ── Complexity (ceremony-depth, NOT model routing) ────────────────────────
+    const estimated = String(sprint?.estimated_complexity || '').toLowerCase();
+    const archHit = ARCH_RE.test(haystack);
+    if (archHit)
+        triggers.push(`complex:architectural(${(haystack.match(ARCH_RE) || [])[1]})`);
+    if (taskCount > 1)
+        triggers.push(`complex:multi-task(${taskCount})`);
+    if (codeFileCount > 1)
+        triggers.push(`complex:multi-file(${codeFileCount})`);
+    if (estimated === 'high')
+        triggers.push('complex:estimated-high');
+    let complexity = 'low';
+    if (archHit || taskCount > 2 || codeFileCount > 2 || estimated === 'high')
+        complexity = 'high';
+    else if (taskCount > 1 || codeFileCount > 1 || estimated === 'medium')
+        complexity = 'medium';
+    // ── Decision (default-to-regulated) ───────────────────────────────────────
+    // A build is FAST-eligible only if it is provably simple AND nothing sensitive
+    // / sovereign / forced fired. Anything ambiguous → REGULATED.
+    const isSimple = taskCount === 1 && codeFileCount <= 1 && !archHit && estimated !== 'high';
+    const blockFast = forcedRegulated || sensitive || sovereign || !isSimple;
+    let path;
+    let reason;
+    if (blockFast) {
+        path = 'regulated';
+        reason =
+            forcedRegulated ? 'explicit --regulated/--strict flag'
+                : sensitive ? `sensitive build (${triggers.filter((t) => t.startsWith('sensitive')).join(', ')})`
+                    : sovereign ? 'sovereign / regulated-domain build'
+                        : `complexity above fast-track threshold (${triggers.filter((t) => t.startsWith('complex')).join(', ') || 'multi-concern'})`;
+    }
+    else {
+        path = 'fast';
+        reason = requestedFast
+            ? 'fast-track opt-in; simple non-sensitive single-file build'
+            : 'simple non-sensitive single-file build → fast track';
+    }
+    return { path, reason, triggers, sensitive, sovereign, complexity, taskCount, codeFileCount };
+}
+/**
+ * Append the triage decision to logs/routing/triage.jsonl (location-independent
+ * via engine-paths). Best-effort: never throws into the run loop. This is the
+ * audit trail required by the ticket — evidence that triage routes correctly and
+ * the means to audit any fast-tracked build later.
+ */
+function logBuildTriage(sprintId, result) {
+    try {
+        const file = (0, path_1.join)((0, engine_paths_1.resolveEnginePaths)().logs, 'routing', 'triage.jsonl');
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(file), { recursive: true });
+        const row = {
+            sprint_id: sprintId,
+            path: result.path,
+            reason: result.reason,
+            triggers: result.triggers,
+            sensitive: result.sensitive,
+            sovereign: result.sovereign,
+            complexity: result.complexity,
+            task_count: result.taskCount,
+            code_file_count: result.codeFileCount,
+            logged_at: new Date().toISOString(),
+        };
+        (0, fs_1.appendFileSync)(file, JSON.stringify(row) + '\n');
+    }
+    catch { /* non-fatal — audit log must never break a run */ }
+}

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

@@ -7,6 +7,8 @@ export declare class Orchestrator {
     private supervisor2;
     private agents;
     private tasks;
+    private buildPath;
+    private triage;
     private stats;
     private taskRuns;
     /**

package/dist/lib/engine-orchestrator.js

@@ -36,6 +36,7 @@ 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");
+const build_triage_1 = require("./build-triage");
 class Orchestrator {
     spawnGate;
     ceo;
@@ -44,6 +45,11 @@ class Orchestrator {
     supervisor2;
     agents = new Map();
     tasks = [];
+    // TICKET-234: ceremony-depth path for this run. 'regulated' = full ceremony
+    // (default, safe); 'fast' = coder → single-supervisor → QA safety floor only.
+    // Set in run() by classifyBuildPath after tasks load. Defaults to regulated.
+    buildPath = 'regulated';
+    triage = null;
     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 = [];
@@ -219,6 +225,13 @@ class Orchestrator {
             // Normalize priority: sprint JSON may omit it
             if (!task.priority)
                 task.priority = 'medium';
+            // Normalize status: sprint JSON may omit it. Without a status the task is
+            // silently skipped in Phase 2 (`if (task.status !== 'pending') continue`),
+            // so the full ceremony runs but executes 0 tasks. Default a MISSING status
+            // to 'pending'; explicit terminal states (done/skipped/rejected/approved)
+            // are preserved so re-runs don't re-execute finished work.
+            if (!task.status)
+                task.status = 'pending';
             // 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'];
@@ -404,17 +417,23 @@ ONLY output the JSON array. No markdown, no explanation.`;
                 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++;
+            // Supervisor review. TICKET-234: fast track → single supervisor; regulated → dual.
+            let review;
+            if (this.buildPath === 'fast') {
+                review = await this.supervisor.reviewTask(subtask, result.files);
+            }
+            else {
+                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);
+                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
@@ -787,18 +806,28 @@ ONLY output the JSON array. No markdown, no explanation.`;
                     return;
                 }
                 (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  [QA-gate] PASS — ${qaResult.reason}`);
-                // Dual Supervisor review (DeepSeek/ClawRouter + Haiku in parallel)
+                // Supervisor review. TICKET-234: fast track runs ONE supervisor (no dual
+                // review / reconcile / CEO escalation); regulated runs the dual-supervisor
+                // ceremony. The QA gate above already enforced the safety floor
+                // (typecheck/compile/no-secrets) on both paths.
                 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++;
+                let review;
+                if (this.buildPath === 'fast') {
+                    review = await this.supervisor.reviewTask(task, result.files);
+                    (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '  [fast-track] single-supervisor review (dual-supervisor skipped)');
+                }
+                else {
+                    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);
+                    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):
@@ -1050,6 +1079,28 @@ ONLY output the JSON array. No markdown, no explanation.`;
                 await mc.disconnect().catch(() => { });
             return;
         }
+        // ── BUILD TRIAGE — TICKET-234 (ceremony-depth routing) ─────────────────
+        // Classify the build BEFORE the swarm ceremony: simple, non-sensitive,
+        // single-file builds take the FAST path (single-supervisor + QA safety
+        // floor, no CTO/CEO post-sprint ceremony, no templates); everything
+        // sensitive/sovereign/complex/ambiguous takes the REGULATED full ceremony.
+        // Pure heuristic — negligible cost vs the ceremony it gates. SOVEREIGN_MODE
+        // always forces regulated: a sovereign build is regulated by definition.
+        {
+            const triageSprint = JSON.parse((0, fs_1.readFileSync)(process.argv[2] || 'sprints/current.json', 'utf-8'));
+            this.triage = (0, build_triage_1.classifyBuildPath)(triageSprint, this.tasks);
+            if (engine_primitives_1.SOVEREIGN_MODE && this.triage.path === 'fast') {
+                this.triage = { ...this.triage, path: 'regulated', reason: 'sovereign mode → regulated by definition', triggers: [...this.triage.triggers, 'sovereign:mode'], sovereign: true };
+            }
+            this.buildPath = this.triage.path;
+            (0, build_triage_1.logBuildTriage)(_evtSprintId, this.triage);
+            const col = this.buildPath === 'fast' ? engine_primitives_1.c.green : engine_primitives_1.c.magenta;
+            (0, engine_primitives_1.log)(col, `\n--- Build Triage: ${this.buildPath.toUpperCase()} ---`);
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  ${this.triage.reason}`);
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, `  complexity=${this.triage.complexity} tasks=${this.triage.taskCount} code-files=${this.triage.codeFileCount}${this.triage.triggers.length ? ` · triggers: ${this.triage.triggers.join(', ')}` : ''}`);
+            if (this.buildPath === 'fast')
+                (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '  Fast track: single-supervisor + QA safety floor; skipping dual-supervisor, CTO/CEO post-sprint ceremony, and templates.');
+        }
         // ── 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.
@@ -1100,8 +1151,14 @@ ONLY output the JSON array. No markdown, no explanation.`;
         }
         // ── 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);
+        // TICKET-234: regulated path only — the fast track skips the CEO ceremony.
+        if (this.buildPath === 'regulated') {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, '\n--- Phase 1: CEO Initial Assessment ---');
+            await this.ceo.reviewSprintProgress(this.tasks);
+        }
+        else {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '\n--- Phase 1: CEO Initial Assessment — SKIPPED (fast track) ---');
+        }
         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 ---');
@@ -1220,79 +1277,91 @@ ONLY output the JSON array. No markdown, no explanation.`;
             }
         }
         // 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 ---');
+        // TICKET-234: Phases 3–6 (CTO/CEO governance ceremony + agent minting +
+        // daily report) run on the REGULATED path only. Fast track ships after the
+        // per-task review + QA safety floor; the financial telemetry below (wallet
+        // burn + budget freeze/warning) still runs on both paths.
         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}`);
+        if (this.buildPath === 'regulated') {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, '\n--- Phase 3: CTO Data-Driven Analysis + CMO Reports ---');
+            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.';
+                }
             }
-            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.';
             }
         }
-        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.';
+        else {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '\n--- Phases 3–4: CTO/CEO Governance Ceremony — SKIPPED (fast track) ---');
         }
         // 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) {
+        if (this.buildPath === 'fast') {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '  Fast track — skipping CEO final assessment');
+        }
+        else if (rejectedCount >= 2) {
             (0, engine_primitives_1.log)(engine_primitives_1.c.magenta, `  ${rejectedCount} tasks rejected — CEO reviewing...`);
             await this.ceo.reviewSprintProgress(this.tasks);
         }
@@ -1309,63 +1378,68 @@ ONLY output the JSON array. No markdown, no explanation.`;
                 (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) ---');
+        // 6b. CTO autonomous post-sprint analysis — regulated path only (TICKET-234)
         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');
+        if (this.buildPath === 'regulated') {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.cyan, '\n--- Phase 5b: CTO Post-Sprint Analysis (Autonomous) ---');
+            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');
+                        }
                     }
-                    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 (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);
         }
-        catch (error) {
-            (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `  Post-sprint analysis skipped: ${error.message}`);
+        else {
+            (0, engine_primitives_1.log)(engine_primitives_1.c.gray, '\n--- Phases 5b–6: Post-Sprint Ceremony + Daily Report — SKIPPED (fast track) ---');
         }
-        // 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));
@@ -1412,6 +1486,8 @@ ONLY output the JSON array. No markdown, no explanation.`;
                 git_head_before: gitHeadBefore,
                 git_head_after: gitHeadAfter,
                 sovereign_mode: engine_primitives_1.SOVEREIGN_MODE,
+                build_path: this.buildPath, // TICKET-234: 'regulated' | 'fast'
+                triage: this.triage, // TICKET-234: classifier reason + triggers
                 summary: {
                     total_tasks: this.tasks.length,
                     done: this.tasks.filter(t => t.status === 'done').length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kognai/orchestrator-core",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Kognai sovereign orchestrator — core engine (template-agnostic). Shared by all products (Kognai/coding, Voxight/market-intel, Invoica/fin-compliance); each supplies only its template. Replaces per-repo forks of orchestrate-agents-v2 / sprint-runner / lib.",
   "license": "MIT",
   "author": "SkinGem",