@kognai/orchestrator-core 0.1.0

package/dist/lib/task-router/router/generate-execution-id.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExecutionId = generateExecutionId;
+const crypto_1 = require("crypto");
+/**
+ * Generates a deterministic execution ID from sprintId and taskId.
+ * Uses SHA256 hash of `${sprintId}:${taskId}` to create a consistent identifier.
+ *
+ * @param sprintId - The unique identifier for the sprint
+ * @param taskId - The unique identifier for the task
+ * @returns A 64-character hexadecimal SHA256 hash string
+ * @throws Error if sprintId or taskId is not provided
+ */
+function generateExecutionId(sprintId, taskId) {
+    if (!sprintId || typeof sprintId !== 'string') {
+        throw new Error('sprintId must be a non-empty string');
+    }
+    if (!taskId || typeof taskId !== 'string') {
+        throw new Error('taskId must be a non-empty string');
+    }
+    const input = `${sprintId}:${taskId}`;
+    const hash = (0, crypto_1.createHash)('sha256').update(input).digest('hex');
+    return hash;
+}

package/dist/lib/task-router/router/resolve-route.d.ts

@@ -0,0 +1,2 @@
+import { TaskTarget, TaskRoute } from '../types';
+export declare function resolveRoute(target: TaskTarget): TaskRoute;

package/dist/lib/task-router/router/resolve-route.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRoute = resolveRoute;
+const types_1 = require("../types");
+function resolveRoute(target) {
+    switch (target) {
+        case 'local': {
+            return {
+                provider: 'ollama',
+                model: process.env.VAULT_MODEL ?? 'qwen3:14b',
+                endpoint: process.env.VAULT_OLLAMA_URL ?? 'http://vault:11434',
+                timeoutMs: types_1.TIMEOUT_BUDGETS.local,
+                target: 'local',
+            };
+        }
+        case 'cloud-code': {
+            return {
+                provider: 'minimax',
+                model: 'MiniMax-M2.5',
+                endpoint: 'https://api.minimax.io/v1/chat/completions',
+                timeoutMs: types_1.TIMEOUT_BUDGETS['cloud-code'],
+                target: 'cloud-code',
+            };
+        }
+        case 'cloud-exec': {
+            return {
+                provider: 'anthropic',
+                model: 'claude-sonnet-4-20250514',
+                endpoint: 'https://api.anthropic.com/v1/messages',
+                timeoutMs: types_1.TIMEOUT_BUDGETS['cloud-exec'],
+                target: 'cloud-exec',
+            };
+        }
+        case 'cloud-post': {
+            return {
+                provider: 'external',
+                model: 'n/a',
+                endpoint: '',
+                timeoutMs: types_1.TIMEOUT_BUDGETS['cloud-post'],
+                target: 'cloud-post',
+            };
+        }
+        default: {
+            const exhaustiveCheck = target;
+            console.warn(`[resolveRoute] Unhandled target type: ${exhaustiveCheck}, defaulting to cloud-code`);
+            return resolveRoute('cloud-code');
+        }
+    }
+}

package/dist/lib/task-router/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Kognai Task Router Types
+ *
+ * Defines the core type definitions for the task routing system,
+ * including task targets, timeout budgets, route configurations,
+ * and routing log entries.
+ */
+/**
+ * Task execution target environments
+ */
+export type TaskTarget = 'local' | 'cloud-code' | 'cloud-exec' | 'cloud-post';
+/**
+ * Timeout budgets in milliseconds for each task target
+ * - local: 10 minutes (600000ms) - local Ollama execution
+ * - cloud-code: 2 minutes (120000ms) - cloud code generation
+ * - cloud-exec: 90 seconds (90000ms) - cloud code execution
+ * - cloud-post: 30 seconds (30000ms) - cloud post-processing
+ */
+export declare const TIMEOUT_BUDGETS: Record<TaskTarget, number>;
+/**
+ * Supported AI model providers
+ */
+export type ModelProvider = 'ollama' | 'minimax' | 'anthropic' | 'external';
+/**
+ * Task route configuration
+ * Defines how a task should be routed to a specific provider and model
+ */
+export interface TaskRoute {
+    /** The AI provider to use for this route */
+    provider: ModelProvider;
+    /** The specific model identifier */
+    model: string;
+    /** The endpoint URL for the provider */
+    endpoint: string;
+    /** Timeout in milliseconds for this route */
+    timeoutMs: number;
+    /** The target environment for task execution */
+    target: TaskTarget;
+}
+/**
+ * Routing log entry
+ * Records the routing decision and execution details for audit and debugging
+ */
+export interface RoutingLogEntry {
+    /** Unique execution identifier */
+    execution_id: string;
+    /** Sprint identifier this task belongs to */
+    sprint_id: string;
+    /** Task identifier within the sprint */
+    task_id: string;
+    /** Selected task target environment */
+    task_target: TaskTarget;
+    /** Provider used for execution */
+    provider: string;
+    /** Model used for execution */
+    model: string;
+    /** Timestamp when task was queued */
+    queued_at: string;
+    /** Timestamp when task started execution (optional) */
+    executed_at?: string;
+    /** Source of the execution request */
+    execution_source: string;
+    /** Whether the vault was reachable at routing time */
+    vault_reachable?: boolean;
+    /** Whether task was queued locally */
+    queued_local?: boolean;
+    /** Error message if routing or execution failed */
+    error?: string;
+}
+/**
+ * Type guard to check if a string is a valid TaskTarget
+ */
+export declare function isValidTaskTarget(value: string): value is TaskTarget;
+/**
+ * Get timeout budget for a task target
+ * @param target - The task target environment
+ * @returns Timeout in milliseconds, defaults to 60000ms if unknown
+ */
+export declare function getTimeoutBudget(target: TaskTarget): number;

package/dist/lib/task-router/types.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Kognai Task Router Types
+ *
+ * Defines the core type definitions for the task routing system,
+ * including task targets, timeout budgets, route configurations,
+ * and routing log entries.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMEOUT_BUDGETS = void 0;
+exports.isValidTaskTarget = isValidTaskTarget;
+exports.getTimeoutBudget = getTimeoutBudget;
+/**
+ * Timeout budgets in milliseconds for each task target
+ * - local: 10 minutes (600000ms) - local Ollama execution
+ * - cloud-code: 2 minutes (120000ms) - cloud code generation
+ * - cloud-exec: 90 seconds (90000ms) - cloud code execution
+ * - cloud-post: 30 seconds (30000ms) - cloud post-processing
+ */
+exports.TIMEOUT_BUDGETS = {
+    local: 600000,
+    'cloud-code': 120000,
+    'cloud-exec': 90000,
+    'cloud-post': 30000,
+};
+/**
+ * Type guard to check if a string is a valid TaskTarget
+ */
+function isValidTaskTarget(value) {
+    return ['local', 'cloud-code', 'cloud-exec', 'cloud-post'].includes(value);
+}
+/**
+ * Get timeout budget for a task target
+ * @param target - The task target environment
+ * @returns Timeout in milliseconds, defaults to 60000ms if unknown
+ */
+function getTimeoutBudget(target) {
+    return exports.TIMEOUT_BUDGETS[target] ?? 60000;
+}

package/dist/lib/token-budget-validator.d.ts

@@ -0,0 +1,44 @@
+/**
+ * token-budget-validator.ts — Deterministic pre-flight gate on MiniMax dispatch.
+ *
+ * Estimates the output-token cost for a task before any LLM is called. Rejects
+ * tasks predicted to exceed the truncation threshold (3800 tokens default —
+ * 700-token safety margin below MiniMax M2.5's documented ~4500 truncation
+ * point per docs/learnings.md §1).
+ *
+ * Stdlib only. NO LLM calls — this is a budget gate, it can't cost tokens to
+ * run. Returns suggested splits when rejecting so the decomposer-feedback
+ * router has something concrete to resplit on.
+ *
+ * Created: sprint-1566 task `wire_token_budget_validator` (F0).
+ * Replaces the orphaned `agents/token-budget-validator/` agent that CEO
+ * auto-spawned 2026-05-19 but never wired in.
+ */
+/** Minimal task shape the validator needs. Compatible with AgentTask in
+ *  orchestrate-agents-v2.ts but defined locally to avoid circular imports. */
+export interface ValidatableTask {
+    id: string;
+    context?: string;
+    deliverables?: {
+        code?: string[];
+        edits?: string[];
+        tests?: string[];
+    };
+}
+export type ValidationResult = {
+    ok: true;
+    estimated_tokens: number;
+} | {
+    ok: false;
+    estimated_tokens: number;
+    reason: string;
+    suggested_split: string[];
+};
+/** Estimate output tokens for a single task. Heuristic per sprint-1566 spec:
+ *   base + Σ(per_file_min + tokens_per_loc × estimated_loc) × test_multiplier?
+ *  estimated_loc derives from context length (denser specs imply more output).
+ */
+export declare function estimateOutputTokens(task: ValidatableTask): number;
+/** Validate a task against the truncation budget. When over budget, suggest a
+ *  per-file split so the decomposer-feedback router can resplit deterministically. */
+export declare function validateTask(task: ValidatableTask, threshold?: number): ValidationResult;

package/dist/lib/token-budget-validator.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * token-budget-validator.ts — Deterministic pre-flight gate on MiniMax dispatch.
+ *
+ * Estimates the output-token cost for a task before any LLM is called. Rejects
+ * tasks predicted to exceed the truncation threshold (3800 tokens default —
+ * 700-token safety margin below MiniMax M2.5's documented ~4500 truncation
+ * point per docs/learnings.md §1).
+ *
+ * Stdlib only. NO LLM calls — this is a budget gate, it can't cost tokens to
+ * run. Returns suggested splits when rejecting so the decomposer-feedback
+ * router has something concrete to resplit on.
+ *
+ * Created: sprint-1566 task `wire_token_budget_validator` (F0).
+ * Replaces the orphaned `agents/token-budget-validator/` agent that CEO
+ * auto-spawned 2026-05-19 but never wired in.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateOutputTokens = estimateOutputTokens;
+exports.validateTask = validateTask;
+const DEFAULT_THRESHOLD = parseInt(process.env.TOKEN_BUDGET_THRESHOLD || '3800', 10);
+const BASE_BOILERPLATE_TOKENS = 400;
+const PER_FILE_MIN_TOKENS = 200;
+// Calibrated from observed MiniMax M2.5 truncations on real Kognai tasks
+// (data/failure-library/code/). The 138 "truncated" entries cluster around
+// tasks whose context was 4-12KB with 1-3 deliverable files — these numbers
+// reproduce that rejection envelope.
+const TOKENS_PER_LOC = 12;
+const CHARS_PER_LOC = 40;
+const TEST_MULTIPLIER = 1.4;
+/** Estimate output tokens for a single task. Heuristic per sprint-1566 spec:
+ *   base + Σ(per_file_min + tokens_per_loc × estimated_loc) × test_multiplier?
+ *  estimated_loc derives from context length (denser specs imply more output).
+ */
+function estimateOutputTokens(task) {
+    const codeFiles = task.deliverables?.code || [];
+    const editFiles = task.deliverables?.edits || [];
+    const testFiles = task.deliverables?.tests || [];
+    const fileCount = codeFiles.length + editFiles.length;
+    if (fileCount === 0)
+        return 0; // pure-edit or non-code task — skip validation
+    const contextChars = (task.context || '').length;
+    const estimatedLoc = Math.max(40, Math.ceil(contextChars / CHARS_PER_LOC));
+    const perFileTokens = PER_FILE_MIN_TOKENS + TOKENS_PER_LOC * estimatedLoc;
+    let total = BASE_BOILERPLATE_TOKENS + fileCount * perFileTokens;
+    const hasTests = testFiles.length > 0 || codeFiles.some(f => f.includes('__tests__') || f.includes('.test.'));
+    if (hasTests)
+        total = Math.ceil(total * TEST_MULTIPLIER);
+    return total;
+}
+/** Validate a task against the truncation budget. When over budget, suggest a
+ *  per-file split so the decomposer-feedback router can resplit deterministically. */
+function validateTask(task, threshold = DEFAULT_THRESHOLD) {
+    const estimated = estimateOutputTokens(task);
+    // Empty deliverables skip the gate (nothing to estimate)
+    if (estimated === 0)
+        return { ok: true, estimated_tokens: 0 };
+    if (estimated <= threshold)
+        return { ok: true, estimated_tokens: estimated };
+    const codeFiles = task.deliverables?.code || [];
+    const editFiles = task.deliverables?.edits || [];
+    // Suggested split: if multiple files, propose one sub-task per file. If a
+    // single file, propose splitting context into N sub-tasks (caller decides
+    // how to actually slice the context — we just hint at the cardinality).
+    let suggested;
+    if ((codeFiles.length + editFiles.length) > 1) {
+        suggested = [...codeFiles, ...editFiles].map(f => `${task.id}__${slugForPath(f)}`);
+    }
+    else {
+        const target = codeFiles[0] || editFiles[0] || task.id;
+        // Estimate how many splits would each land under threshold
+        const splitCount = Math.max(2, Math.ceil(estimated / threshold));
+        suggested = Array.from({ length: splitCount }, (_, i) => `${task.id}__part${i + 1}`);
+    }
+    return {
+        ok: false,
+        estimated_tokens: estimated,
+        reason: `Estimated output ${estimated} tokens exceeds threshold ${threshold} (MiniMax truncates at ~4500 per docs/learnings.md §1). Decomposer must re-split.`,
+        suggested_split: suggested,
+    };
+}
+function slugForPath(p) {
+    return p.replace(/^scripts\//, '').replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, '').replace(/[^a-z0-9]+/gi, '_').toLowerCase();
+}

package/dist/lib/trust-score-updater.d.ts

@@ -0,0 +1,30 @@
+/**
+ * trust-score-updater.ts — Sprint 703 (GOV Phase 1)
+ *
+ * Dynamic ACP trust score updater. Adjusts scores based on real outcomes:
+ * - Approved tasks (score >= 80): accuracy +1
+ * - Rejected tasks: accuracy -2
+ * - Safety flags: safety -3
+ * - 5% daily decay toward 70 (mean) for stale agents
+ *
+ * Called by orchestrate-agents-v2.ts on both approval and rejection paths.
+ *
+ * TICKET-215 Phase 3b-2: the repo root now resolves via engine-paths
+ * (KOGNAI_ROOT / cwd) instead of `join(__dirname, '../..')`, so the module is
+ * location-independent and can live in @kognai/orchestrator-core. When run from a
+ * product repo root, resolveEnginePaths().root === the old __dirname/../.. — same
+ * <root>/acp/trust-scores.json path, no behavior change.
+ */
+/**
+ * Update trust scores after a task outcome.
+ * @param agentId - The agent whose scores to update
+ * @param outcome - 'approved' or 'rejected'
+ * @param taskScore - The supervisor score (0-100)
+ * @param safetyFlag - Whether a safety issue was flagged
+ */
+export declare function updateTrustScore(agentId: string, outcome: 'approved' | 'rejected', taskScore: number, safetyFlag?: boolean): void;
+/**
+ * Apply daily decay: stale agents drift 5% toward mean (70) per day.
+ * Run once per day (e.g., in daily-digest or a cron).
+ */
+export declare function applyDailyDecay(): void;

package/dist/lib/trust-score-updater.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * trust-score-updater.ts — Sprint 703 (GOV Phase 1)
+ *
+ * Dynamic ACP trust score updater. Adjusts scores based on real outcomes:
+ * - Approved tasks (score >= 80): accuracy +1
+ * - Rejected tasks: accuracy -2
+ * - Safety flags: safety -3
+ * - 5% daily decay toward 70 (mean) for stale agents
+ *
+ * Called by orchestrate-agents-v2.ts on both approval and rejection paths.
+ *
+ * TICKET-215 Phase 3b-2: the repo root now resolves via engine-paths
+ * (KOGNAI_ROOT / cwd) instead of `join(__dirname, '../..')`, so the module is
+ * location-independent and can live in @kognai/orchestrator-core. When run from a
+ * product repo root, resolveEnginePaths().root === the old __dirname/../.. — same
+ * <root>/acp/trust-scores.json path, no behavior change.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTrustScore = updateTrustScore;
+exports.applyDailyDecay = applyDailyDecay;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const engine_paths_1 = require("./engine-paths");
+const ROOT = (0, engine_paths_1.resolveEnginePaths)().root;
+const TRUST_PATH = (0, path_1.join)(ROOT, 'acp', 'trust-scores.json');
+function clamp(val, min, max) {
+    return Math.max(min, Math.min(max, val));
+}
+function recomputeComposite(scores, dims) {
+    let weighted = 0;
+    let totalWeight = 0;
+    for (const [dim, config] of Object.entries(dims)) {
+        const val = scores[dim];
+        if (typeof val === 'number') {
+            weighted += val * config.weight;
+            totalWeight += config.weight;
+        }
+    }
+    return totalWeight > 0 ? Math.round(weighted / totalWeight) : 0;
+}
+function loadTrustData() {
+    return JSON.parse((0, fs_1.readFileSync)(TRUST_PATH, 'utf-8'));
+}
+function saveTrustData(data) {
+    data.updated = new Date().toISOString().slice(0, 10);
+    (0, fs_1.writeFileSync)(TRUST_PATH, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+/**
+ * Update trust scores after a task outcome.
+ * @param agentId - The agent whose scores to update
+ * @param outcome - 'approved' or 'rejected'
+ * @param taskScore - The supervisor score (0-100)
+ * @param safetyFlag - Whether a safety issue was flagged
+ */
+function updateTrustScore(agentId, outcome, taskScore, safetyFlag = false) {
+    try {
+        const data = loadTrustData();
+        const scores = data.scores[agentId];
+        if (!scores) {
+            console.warn(`[trust-updater] Agent '${agentId}' not in trust-scores.json — skipping`);
+            return;
+        }
+        if (outcome === 'approved' && taskScore >= 80) {
+            scores.accuracy = clamp(scores.accuracy + 1, 0, 100);
+        }
+        else if (outcome === 'rejected') {
+            scores.accuracy = clamp(scores.accuracy - 2, 0, 100);
+        }
+        if (safetyFlag) {
+            scores.safety = clamp(scores.safety - 3, 0, 100);
+        }
+        scores.composite = recomputeComposite(scores, data.dimensions);
+        scores.last_updated = new Date().toISOString().slice(0, 10);
+        saveTrustData(data);
+    }
+    catch (err) {
+        // Non-fatal — trust score update failure should never block execution
+        console.warn(`[trust-updater] Failed to update scores: ${err.message}`);
+    }
+}
+/**
+ * Apply daily decay: stale agents drift 5% toward mean (70) per day.
+ * Run once per day (e.g., in daily-digest or a cron).
+ */
+function applyDailyDecay() {
+    try {
+        const data = loadTrustData();
+        const MEAN = 70;
+        const DECAY_RATE = 0.05;
+        const today = new Date().toISOString().slice(0, 10);
+        for (const [agentId, scores] of Object.entries(data.scores)) {
+            if (scores.last_updated === today)
+                continue; // Active today, skip
+            for (const dim of ['safety', 'accuracy', 'brand_alignment', 'cultural_sensitivity', 'legal_compliance']) {
+                const current = scores[dim];
+                const diff = current - MEAN;
+                scores[dim] = Math.round(current - diff * DECAY_RATE);
+            }
+            scores.composite = recomputeComposite(scores, data.dimensions);
+        }
+        saveTrustData(data);
+    }
+    catch (err) {
+        console.warn(`[trust-updater] Daily decay failed: ${err.message}`);
+    }
+}

package/dist/lib/wallet-state.d.ts

@@ -0,0 +1,26 @@
+/**
+ * wallet-state.ts — CFO budget tracking for ClawRouter spend
+ *
+ * Accumulates spend from ClawRouter X-Payment-Amount headers.
+ * Enforces degraded (≥80%) and frozen (≥95%) modes to protect the wallet.
+ * Persists to logs/wallet/state.json across sprint runs.
+ *
+ * TICKET-215 Phase 3b-3 (Wave B): KOGNAI_ROOT now resolves via engine-paths
+ * (KOGNAI_ROOT / cwd) instead of `resolve(__dirname, '../..')`, so the bank
+ * state layer is location-independent and ships in @kognai/orchestrator-core.
+ * When run from a product repo root, resolveEnginePaths().root === the old
+ * __dirname/../.. — same <root>/logs/wallet/state.json, no behavior change.
+ */
+export interface WalletState {
+    monthlyBudget: number;
+    spentThisMonth: number;
+    callCount: number;
+    remaining: number;
+    burnPct: number;
+    isDegraded: boolean;
+    isFrozen: boolean;
+}
+export declare function getWalletState(): WalletState;
+export declare function recordSpend(costUsdc: number): void;
+export declare function resetWallet(): void;
+export declare function logWalletStatus(): void;

package/dist/lib/wallet-state.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * wallet-state.ts — CFO budget tracking for ClawRouter spend
+ *
+ * Accumulates spend from ClawRouter X-Payment-Amount headers.
+ * Enforces degraded (≥80%) and frozen (≥95%) modes to protect the wallet.
+ * Persists to logs/wallet/state.json across sprint runs.
+ *
+ * TICKET-215 Phase 3b-3 (Wave B): KOGNAI_ROOT now resolves via engine-paths
+ * (KOGNAI_ROOT / cwd) instead of `resolve(__dirname, '../..')`, so the bank
+ * state layer is location-independent and ships in @kognai/orchestrator-core.
+ * When run from a product repo root, resolveEnginePaths().root === the old
+ * __dirname/../.. — same <root>/logs/wallet/state.json, no behavior change.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWalletState = getWalletState;
+exports.recordSpend = recordSpend;
+exports.resetWallet = resetWallet;
+exports.logWalletStatus = logWalletStatus;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const engine_paths_1 = require("./engine-paths");
+const KOGNAI_ROOT = (0, engine_paths_1.resolveEnginePaths)().root;
+const STATE_FILE = (0, path_1.resolve)(KOGNAI_ROOT, 'logs/wallet/state.json');
+const DEFAULT_BUDGET = parseFloat(process.env.CEO_WALLET_BUDGET_USDC || '25'); // $25/month default
+function loadState() {
+    if ((0, fs_1.existsSync)(STATE_FILE)) {
+        try {
+            const raw = JSON.parse((0, fs_1.readFileSync)(STATE_FILE, 'utf8'));
+            // Auto-reset on new month
+            const lastReset = new Date(raw.lastReset);
+            const now = new Date();
+            if (lastReset.getMonth() !== now.getMonth() || lastReset.getFullYear() !== now.getFullYear()) {
+                return freshState();
+            }
+            return raw;
+        }
+        catch { /* fall through */ }
+    }
+    return freshState();
+}
+function freshState() {
+    return {
+        monthlyBudget: DEFAULT_BUDGET,
+        spentThisMonth: 0,
+        callCount: 0,
+        lastReset: new Date().toISOString(),
+    };
+}
+function saveState(data) {
+    try {
+        (0, fs_1.mkdirSync)((0, path_1.resolve)(KOGNAI_ROOT, 'logs/wallet'), { recursive: true });
+        (0, fs_1.writeFileSync)(STATE_FILE, JSON.stringify(data, null, 2), 'utf8');
+    }
+    catch { /* non-fatal */ }
+}
+// Singleton
+let _state = loadState();
+function getWalletState() {
+    const remaining = Math.max(0, _state.monthlyBudget - _state.spentThisMonth);
+    const burnPct = (_state.spentThisMonth / _state.monthlyBudget) * 100;
+    return {
+        monthlyBudget: _state.monthlyBudget,
+        spentThisMonth: _state.spentThisMonth,
+        callCount: _state.callCount,
+        remaining,
+        burnPct,
+        isDegraded: burnPct >= 80,
+        isFrozen: burnPct >= 95,
+    };
+}
+function recordSpend(costUsdc) {
+    _state.spentThisMonth += costUsdc;
+    _state.callCount += 1;
+    saveState(_state);
+}
+function resetWallet() {
+    _state = freshState();
+    saveState(_state);
+}
+function logWalletStatus() {
+    const s = getWalletState();
+    const status = s.isFrozen ? '🔴 FROZEN' : s.isDegraded ? '🟡 DEGRADED' : '🟢 OK';
+    console.log(`  💳 Wallet ${status}: $${s.spentThisMonth.toFixed(4)}/$${s.monthlyBudget} (${s.burnPct.toFixed(1)}%)`);
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@kognai/orchestrator-core",
+  "version": "0.1.0",
+  "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",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "kognai",
+    "orchestrator",
+    "agent-swarm",
+    "core-engine"
+  ],
+  "dependencies": {}
+}