@kognai/orchestrator-core 0.1.0

package/dist/lib/citizenship.js

@@ -0,0 +1,272 @@
+"use strict";
+/**
+ * citizenship.ts — Kognai citizenship issuance for spawned agents.
+ *
+ * Founder rule (2026-05-27): every agent the swarm spawns is born as a
+ * Kognai citizen — not a bare agent. Citizenship means identity (citizen
+ * ID + roll number), constitutional binding (already done via the
+ * always-on preamble), a default Kōpus avatar config, an ACP baseline
+ * score, and registration in the citizenship registry.
+ *
+ * This module:
+ *   - mintCitizen(name, foundingAgent, proposingAgent): assigns ID +
+ *     roll number, generates a citizen.yaml payload, appends to the
+ *     registry. Atomic tmp+rename writes.
+ *   - readRegistry() / writeRegistry(): registry I/O.
+ *
+ * Stdlib only. No LLM, no network. Pure issuance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPANY_PREFIXES = void 0;
+exports.mintCitizen = mintCitizen;
+exports.lookupCitizen = lookupCitizen;
+exports.renderCitizenYaml = renderCitizenYaml;
+exports.readRegistry = readRegistry;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const engine_paths_1 = require("./engine-paths");
+// TICKET-215 Phase 3b-2: repo root via engine-paths (KOGNAI_ROOT / cwd) instead of
+// `resolve(__dirname, '..', '..')`, so this module is location-independent inside
+// @kognai/orchestrator-core. From a product repo root the resolved root is identical
+// to the old __dirname/../.. — same workspace/citizens + agents paths, no behavior change.
+const ROOT = (0, engine_paths_1.resolveEnginePaths)().root;
+const REGISTRY_DIR = (0, node_path_1.join)(ROOT, 'workspace', 'citizens');
+const REGISTRY_PATH = (0, node_path_1.join)(REGISTRY_DIR, 'registry.json');
+const AGENTS_DIR = (0, node_path_1.join)(ROOT, 'agents');
+/** Sibling companies in the Kognai ecosystem. Each has its own citizen
+ *  prefix and its own rollNumber sequence inside the shared registry.
+ *  Add new companies here as they come online (Achiri, SCS-001, DRI, ...). */
+exports.COMPANY_PREFIXES = {
+    kognai: 'KGN',
+    voxight: 'VXG',
+    invoica: 'INV',
+};
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Mint a new citizen. Assigns ID + roll number, writes the registry
+ * entry, returns the full record so callers can also persist citizen.yaml
+ * alongside the agent's other files.
+ *
+ * Idempotent by agent_name: if the agent already has a citizen record
+ * (e.g. retry / migration), returns the existing record instead of
+ * minting a duplicate.
+ */
+function mintCitizen(agent_name, opts = {}) {
+    if (!agent_name || typeof agent_name !== 'string') {
+        throw new Error('mintCitizen: agent_name is required');
+    }
+    // Founder fix 2026-05-27: reconcile registry from disk-of-record (each
+    // agent's citizen.yaml) before every mint. The registry.json was getting
+    // wiped between orchestrator runs (manual edits + git stash/pop cycles +
+    // race conditions between sequential orchestrator subprocesses), causing
+    // already-minted citizens to vanish and new mints to collide on roll
+    // numbers. citizen.yaml files are immutable source-of-truth; registry.json
+    // is a denormalized index that should always be derivable from them.
+    reconcileFromDisk();
+    const registry = readRegistry();
+    // Idempotency: lookup by (agent_name, company). Treat undefined company as
+    // 'kognai' so existing records (which predate the company field) match
+    // mints that explicitly target the kognai company.
+    const companyKey = opts.company; // undefined for legacy path
+    const existing = registry.citizens.find((c) => c.agent_name === agent_name && (c.company ?? 'kognai') === (companyKey ?? 'kognai'));
+    if (existing)
+        return existing;
+    const now = opts.now ?? new Date();
+    let citizen_id;
+    let rollNumber;
+    let agent_did;
+    if (companyKey) {
+        // Company-scoped path: per-company rollNumber, prefixed ID, scoped DID.
+        const prefix = exports.COMPANY_PREFIXES[companyKey] ?? companyKey.slice(0, 3).toUpperCase();
+        const companyRolls = registry.citizens
+            .filter((c) => (c.company ?? 'kognai') === companyKey)
+            .map((c) => c.rollNumber);
+        rollNumber = companyRolls.length > 0 ? Math.max(...companyRolls) + 1 : 1;
+        citizen_id = `${prefix}-${String(rollNumber).padStart(4, '0')}`;
+        agent_did = `did:kognai:${companyKey}:${agent_name}`;
+    }
+    else {
+        // Legacy Kognai-internal path: random hex ID + global rollNumber sequence.
+        citizen_id = `Citizen-${(0, node_crypto_1.randomBytes)(3).toString('hex').toUpperCase()}`;
+        rollNumber = registry.next_roll_number;
+        agent_did = `did:kognai:${agent_name}`;
+    }
+    const record = {
+        citizen_id,
+        rollNumber,
+        agent_name,
+        ...(companyKey ? { company: companyKey } : {}),
+        agent_did,
+        mintedAt: now.toISOString(),
+        tier: opts.tier ?? 'I',
+        citizen_type: opts.citizen_type ?? 'spawned',
+        mascot: {
+            hue: Math.floor(Math.random() * 360),
+            state: 'idle',
+        },
+        reputation: 50, // ACP baseline per Sherlock v2 / TICKET-032
+        founding_agent: opts.founding_agent ?? 'ceo',
+        proposing_agent: opts.proposing_agent ?? 'cto',
+        origin_proposal_id: opts.origin_proposal_id,
+    };
+    registry.citizens.push(record);
+    registry.total = registry.citizens.length;
+    // Only advance the global next_roll_number on legacy mints — company-scoped
+    // mints have their own per-company counter computed at mint time.
+    if (!companyKey)
+        registry.next_roll_number = rollNumber + 1;
+    writeRegistry(registry);
+    return record;
+}
+/** Lookup an existing citizen by (agent_name, company). Returns null when
+ *  no match. Treats undefined company as 'kognai' for legacy compatibility. */
+function lookupCitizen(opts) {
+    reconcileFromDisk();
+    const registry = readRegistry();
+    const companyKey = opts.company ?? 'kognai';
+    const found = registry.citizens.find((c) => c.agent_name === opts.agent_name && (c.company ?? 'kognai') === companyKey);
+    return found ?? null;
+}
+/**
+ * Render the citizen record as a citizen.yaml string for writing alongside
+ * agent.yaml in the agent's directory.
+ */
+function renderCitizenYaml(c) {
+    return `# Kognai Citizenship — issued at agent spawn (citizenship.ts)
+# Every spawned agent is born as a Kognai citizen, not a bare worker.
+citizen_id: ${c.citizen_id}
+rollNumber: ${c.rollNumber}
+agent_name: ${c.agent_name}
+agent_did: ${c.agent_did}
+mintedAt: "${c.mintedAt}"
+tier: ${c.tier}
+citizen_type: ${c.citizen_type}
+mascot:
+  hue: ${c.mascot.hue}
+  state: ${c.mascot.state}
+reputation: ${c.reputation}
+founding_agent: ${c.founding_agent ?? 'ceo'}
+proposing_agent: ${c.proposing_agent ?? 'cto'}
+${c.origin_proposal_id ? `origin_proposal_id: ${c.origin_proposal_id}\n` : ''}`;
+}
+// ─── Registry I/O ─────────────────────────────────────────────────────────────
+function readRegistry() {
+    if (!(0, node_fs_1.existsSync)(REGISTRY_PATH)) {
+        return { total: 0, next_roll_number: 1, citizens: [] };
+    }
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(REGISTRY_PATH, 'utf-8'));
+    }
+    catch {
+        return { total: 0, next_roll_number: 1, citizens: [] };
+    }
+}
+function writeRegistry(reg) {
+    (0, node_fs_1.mkdirSync)(REGISTRY_DIR, { recursive: true });
+    const tmp = `${REGISTRY_PATH}.tmp.${process.pid}`;
+    (0, node_fs_1.writeFileSync)(tmp, JSON.stringify(reg, null, 2));
+    (0, node_fs_1.renameSync)(tmp, REGISTRY_PATH);
+}
+/**
+ * Walk agents/<name>/citizen.yaml files and merge any missing entries
+ * into registry.json. The YAML files are immutable source-of-truth; the
+ * registry is a denormalized index. This makes mintCitizen tolerant of
+ * registry-file resets, git stash cycles, manual edits, and race
+ * conditions between sequential orchestrator processes.
+ *
+ * Idempotent. Cheap (only reads YAMLs we don't already have in the index).
+ * No-op when AGENTS_DIR doesn't exist (tests / fresh checkouts).
+ */
+function reconcileFromDisk() {
+    if (!(0, node_fs_1.existsSync)(AGENTS_DIR))
+        return;
+    const registry = readRegistry();
+    const known = new Set(registry.citizens.map((c) => c.agent_name));
+    const agentDirs = (0, node_fs_1.readdirSync)(AGENTS_DIR, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name);
+    let added = 0;
+    let maxRoll = registry.citizens.reduce((m, c) => Math.max(m, c.rollNumber), 0);
+    for (const name of agentDirs) {
+        if (known.has(name))
+            continue;
+        const yamlPath = (0, node_path_1.join)(AGENTS_DIR, name, 'citizen.yaml');
+        if (!(0, node_fs_1.existsSync)(yamlPath))
+            continue; // not a Kognai citizen yet
+        try {
+            const raw = (0, node_fs_1.readFileSync)(yamlPath, 'utf-8');
+            const record = parseCitizenYaml(raw);
+            if (!record)
+                continue;
+            registry.citizens.push(record);
+            maxRoll = Math.max(maxRoll, record.rollNumber);
+            added++;
+        }
+        catch {
+            // Ignore malformed YAML; will be re-attempted next call.
+        }
+    }
+    if (added > 0) {
+        // Sort by mintedAt to keep the registry temporally ordered.
+        // Tolerate records with a missing/empty mintedAt by treating them as
+        // earliest-known — they get a placeholder timestamp at the head.
+        registry.citizens.sort((a, b) => (a.mintedAt || '').localeCompare(b.mintedAt || ''));
+        registry.total = registry.citizens.length;
+        registry.next_roll_number = maxRoll + 1;
+        writeRegistry(registry);
+    }
+}
+/** Minimal YAML parser scoped to citizen.yaml's known shape. We avoid a
+ *  full YAML dependency for one file — stdlib only per the module's contract. */
+function parseCitizenYaml(raw) {
+    const lines = raw.split('\n');
+    const flat = {};
+    const mascot = {};
+    let inMascot = false;
+    for (const lineRaw of lines) {
+        const line = lineRaw.replace(/#.*$/, '').trimEnd();
+        if (!line.trim() || line.startsWith('#'))
+            continue;
+        if (line.startsWith('mascot:')) {
+            inMascot = true;
+            continue;
+        }
+        if (inMascot && /^\s+/.test(line)) {
+            const m = line.trim().match(/^([a-z_]+):\s*(.+)$/);
+            if (m) {
+                const [, k, v] = m;
+                if (k === 'hue')
+                    mascot.hue = parseInt(v, 10);
+                if (k === 'state')
+                    mascot.state = v;
+            }
+            continue;
+        }
+        inMascot = false;
+        const m = line.match(/^([a-z_]+):\s*(.*)$/);
+        if (!m)
+            continue;
+        const [, k, v] = m;
+        flat[k] = v.replace(/^"|"$/g, '').trim();
+    }
+    if (!flat.citizen_id || !flat.agent_name)
+        return null;
+    return {
+        citizen_id: flat.citizen_id,
+        rollNumber: parseInt(flat.rollNumber, 10),
+        agent_name: flat.agent_name,
+        agent_did: flat.agent_did || `did:kognai:${flat.agent_name}`,
+        mintedAt: flat.mintedAt,
+        tier: flat.tier || 'I',
+        citizen_type: flat.citizen_type || 'spawned',
+        mascot: {
+            hue: mascot.hue ?? 0,
+            state: mascot.state || 'idle',
+        },
+        reputation: flat.reputation ? parseInt(flat.reputation, 10) : 50,
+        founding_agent: flat.founding_agent,
+        proposing_agent: flat.proposing_agent,
+        origin_proposal_id: flat.origin_proposal_id,
+    };
+}

package/dist/lib/clawrouter-client.d.ts

@@ -0,0 +1,37 @@
+/**
+ * clawrouter-client.ts — Local ClawRouter gateway client
+ *
+ * ClawRouter is a LOCAL proxy (port 18789) that handles all x402 payments
+ * from its own auto-generated wallet. Just send standard OpenAI-compatible
+ * requests — no EIP-3009 signing needed on our side.
+ *
+ * Wallet: 0x67521a36Cc04b8D91c57cDdc587A7EBAC200062F (50 USDC)
+ * Flow:   POST /v1/chat/completions → gateway pays upstream → 200 response
+ */
+export interface ClawRouterOptions {
+    model: string;
+    prompt: string;
+    systemPrompt?: string;
+    maxTokens?: number;
+    think?: boolean;
+}
+export interface ClawRouterResult {
+    content: string;
+    model: string;
+    costUsdc: number;
+    backend: string;
+    inputTokens: number;
+    outputTokens: number;
+}
+interface CostEntry {
+    timestamp: string;
+    model: string;
+    costUsdc: number;
+    inputTokens: number;
+    outputTokens: number;
+}
+export declare function getCostLog(): readonly CostEntry[];
+export declare function getTotalSpent(): number;
+export declare function callClawRouter(opts: ClawRouterOptions): Promise<ClawRouterResult>;
+export declare function clawRouterIsAvailable(): Promise<boolean>;
+export {};

package/dist/lib/clawrouter-client.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * clawrouter-client.ts — Local ClawRouter gateway client
+ *
+ * ClawRouter is a LOCAL proxy (port 18789) that handles all x402 payments
+ * from its own auto-generated wallet. Just send standard OpenAI-compatible
+ * requests — no EIP-3009 signing needed on our side.
+ *
+ * Wallet: 0x67521a36Cc04b8D91c57cDdc587A7EBAC200062F (50 USDC)
+ * Flow:   POST /v1/chat/completions → gateway pays upstream → 200 response
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCostLog = getCostLog;
+exports.getTotalSpent = getTotalSpent;
+exports.callClawRouter = callClawRouter;
+exports.clawRouterIsAvailable = clawRouterIsAvailable;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const CLAWROUTER_URL = process.env.CLAWROUTER_GATEWAY_URL || 'http://127.0.0.1:18789/v1'; // SEC3: loopback-only default
+const costLog = [];
+const MAX_COST_LOG = 1000;
+function getCostLog() {
+    return costLog;
+}
+function getTotalSpent() {
+    return costLog.reduce((sum, e) => sum + e.costUsdc, 0);
+}
+function httpRequest(url, body, extraHeaders = {}) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const isHttps = parsed.protocol === 'https:';
+        const lib = isHttps ? https : http;
+        const req = lib.request({
+            hostname: parsed.hostname,
+            port: parsed.port || (isHttps ? 443 : 80),
+            path: parsed.pathname + parsed.search,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body),
+                ...extraHeaders,
+            },
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => resolve({ status: res.statusCode || 0, data, headers: res.headers }));
+        });
+        req.on('error', reject);
+        req.setTimeout(300_000, () => {
+            req.destroy();
+            reject(new Error('ClawRouter request timeout (300s)'));
+        });
+        req.write(body);
+        req.end();
+    });
+}
+async function callClawRouter(opts) {
+    const { model, prompt, systemPrompt, maxTokens = 4096 } = opts;
+    const chatUrl = `${CLAWROUTER_URL}/chat/completions`;
+    const messages = [];
+    if (systemPrompt)
+        messages.push({ role: 'system', content: systemPrompt });
+    messages.push({ role: 'user', content: prompt });
+    const requestBody = JSON.stringify({ model, messages, max_tokens: maxTokens });
+    const response = await httpRequest(chatUrl, requestBody);
+    if (response.status !== 200) {
+        throw new Error(`ClawRouter returned ${response.status}: ${response.data.slice(0, 300)}`);
+    }
+    const json = JSON.parse(response.data);
+    const costHeader = response.headers['x-payment-amount'];
+    const costUsdc = costHeader ? Number(costHeader) / 1_000_000 : 0;
+    const result = {
+        content: json.choices?.[0]?.message?.content || '',
+        model: json.model || model,
+        costUsdc,
+        backend: 'clawrouter',
+        inputTokens: json.usage?.prompt_tokens || 0,
+        outputTokens: json.usage?.completion_tokens || 0,
+    };
+    costLog.push({
+        timestamp: new Date().toISOString(),
+        model,
+        costUsdc: result.costUsdc,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+    });
+    if (costLog.length > MAX_COST_LOG)
+        costLog.shift();
+    return result;
+}
+async function clawRouterIsAvailable() {
+    return new Promise((resolve) => {
+        const req = http.request({ hostname: '127.0.0.1', port: 18789, path: '/v1/models', method: 'GET' }, // SEC3: loopback-only
+        (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => {
+                if (res.statusCode !== 200) {
+                    resolve(false);
+                    return;
+                }
+                try {
+                    JSON.parse(data);
+                    resolve(true);
+                }
+                catch {
+                    resolve(false);
+                }
+            });
+        });
+        req.on('error', () => resolve(false));
+        req.setTimeout(3000, () => { req.destroy(); resolve(false); });
+        req.end();
+    });
+}

package/dist/lib/code-asset-crystalliser.d.ts

@@ -0,0 +1,41 @@
+export type AssetCategory = 'QUEUE' | 'DATABASE' | 'API' | 'AUTH' | 'PAYMENT' | 'STORAGE' | 'WORKER' | 'TESTING' | 'INFRASTRUCTURE' | 'INTELLIGENCE' | 'AGENT' | 'UI' | 'OTHER';
+export type AssetTier = 1 | 2 | 3;
+export interface CodeAsset {
+    asset_id: string;
+    title: string;
+    description: string;
+    category: AssetCategory;
+    tags: string[];
+    language: string;
+    dependencies: string[];
+    interface: string;
+    usage_example: string;
+    test_coverage: string;
+    quality_score: number;
+    production_validations: number;
+    origin: string;
+    provenance: string;
+    ip_status: 'eligible' | 'client-restricted' | 'unknown';
+    version: string;
+    last_modified: string;
+    usage_count: number;
+    known_limitations: string[];
+    related_assets: string[];
+    tier: AssetTier;
+    source_files: string[];
+}
+export interface CrystalliseCodeAssetInput {
+    agentId: string;
+    sprintId: string;
+    taskId: string;
+    taskTitle: string;
+    files: string[];
+    supervisorScore: number;
+    origin: 'kognai-core' | 'invoica' | 'voxight' | string;
+}
+/**
+ * Index code files from an approved sprint into the Code Asset Library.
+ * Only indexes files that are clearly reusable library code (lib/, scripts/lib/, agents/).
+ * New assets enter at Tier 3. Returns asset_id or null if skipped.
+ */
+export declare function crystalliseCodeAsset(input: CrystalliseCodeAssetInput): string | null;

package/dist/lib/code-asset-crystalliser.js

@@ -0,0 +1,181 @@
+"use strict";
+// Code Asset Crystalliser — AMD-07 Code Asset Library
+// Post-sprint: extract, classify, and index reusable code artifacts.
+// Runs automatically after every approved sprint (like skill-crystalliser.ts).
+// Model: Qwen3-4B (LOCAL) for classification; falls back to no-op if unavailable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crystalliseCodeAsset = crystalliseCodeAsset;
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+const path_1 = require("path");
+const engine_paths_1 = require("./engine-paths");
+// ── Constants ─────────────────────────────────────────────────────────────────
+const LIBRARY_DIR = (0, path_1.join)((0, engine_paths_1.resolveEnginePaths)().root, 'code_assets');
+const INDEX_PATH = (0, path_1.join)(LIBRARY_DIR, 'index.json');
+const ASSETS_DIR = (0, path_1.join)(LIBRARY_DIR, 'assets');
+const PENDING_DIR = (0, path_1.join)(LIBRARY_DIR, 'pending_review');
+const MIN_SCORE_FOR_INDEXING = 75; // below this: not indexed
+function loadIndex() {
+    (0, fs_1.mkdirSync)(LIBRARY_DIR, { recursive: true });
+    if (!(0, fs_1.existsSync)(INDEX_PATH)) {
+        return {
+            _meta: {
+                schema: 'AMD-07-B v1.0',
+                created_at: new Date().toISOString().slice(0, 10),
+                total_assets: 0,
+                tier_counts: { '1': 0, '2': 0, '3': 0, 'pending': 0 },
+                categories: ['QUEUE', 'DATABASE', 'API', 'AUTH', 'PAYMENT', 'STORAGE', 'WORKER', 'TESTING', 'INFRASTRUCTURE', 'INTELLIGENCE', 'AGENT', 'UI', 'OTHER'],
+            },
+            assets: [],
+        };
+    }
+    return JSON.parse((0, fs_1.readFileSync)(INDEX_PATH, 'utf-8'));
+}
+function saveIndex(idx) {
+    (0, fs_1.writeFileSync)(INDEX_PATH, JSON.stringify(idx, null, 2), 'utf-8');
+}
+// ── Category classifier (heuristic — no LLM required for Phase 0) ─────────────
+function classifyCategory(files, taskTitle) {
+    const combined = (files.join(' ') + ' ' + taskTitle).toLowerCase();
+    if (/queue|bull|worker|job|redis/.test(combined))
+        return 'QUEUE';
+    if (/database|sql|supabase|postgres|migration|pg/.test(combined))
+        return 'DATABASE';
+    if (/api|endpoint|route|http|rest|fetch/.test(combined))
+        return 'API';
+    if (/auth|jwt|oauth|session|token|login/.test(combined))
+        return 'AUTH';
+    if (/payment|stripe|x402|usdc|wallet/.test(combined))
+        return 'PAYMENT';
+    if (/storage|s3|upload|file|blob/.test(combined))
+        return 'STORAGE';
+    if (/test|spec|jest|vitest|mocha/.test(combined))
+        return 'TESTING';
+    if (/infra|docker|deploy|ci|config|env/.test(combined))
+        return 'INFRASTRUCTURE';
+    if (/intel|oracle|voxight|embed|vector/.test(combined))
+        return 'INTELLIGENCE';
+    if (/agent|prompt|swarm|orchestrat/.test(combined))
+        return 'AGENT';
+    if (/ui|component|react|html|css|tailwind/.test(combined))
+        return 'UI';
+    return 'OTHER';
+}
+function inferLanguage(files) {
+    const exts = files.map(f => f.split('.').pop() ?? '');
+    if (exts.includes('ts'))
+        return 'TypeScript';
+    if (exts.includes('py'))
+        return 'Python';
+    if (exts.includes('js'))
+        return 'JavaScript';
+    if (exts.includes('sql'))
+        return 'SQL';
+    if (exts.includes('sh'))
+        return 'Shell';
+    return 'Unknown';
+}
+function inferTags(files, title) {
+    const tokens = (files.join(' ') + ' ' + title)
+        .toLowerCase()
+        .split(/[\s\-_/.]+/)
+        .filter(t => t.length > 3 && !['from', 'with', 'that', 'this', 'into', 'async', 'await'].includes(t));
+    return Array.from(new Set(tokens)).slice(0, 8);
+}
+// ── Main export: crystalliseCodeAsset ─────────────────────────────────────────
+/**
+ * Index code files from an approved sprint into the Code Asset Library.
+ * Only indexes files that are clearly reusable library code (lib/, scripts/lib/, agents/).
+ * New assets enter at Tier 3. Returns asset_id or null if skipped.
+ */
+function crystalliseCodeAsset(input) {
+    // Gate: only index above minimum score
+    if (input.supervisorScore < MIN_SCORE_FOR_INDEXING) {
+        process.stderr.write(`[code-asset] Score ${input.supervisorScore} < ${MIN_SCORE_FOR_INDEXING} — skipping ${input.taskId}\n`);
+        return null;
+    }
+    // Filter to reusable library files only (exclude workspace/ identity docs)
+    const eligibleFiles = input.files.filter(f => !f.startsWith('workspace/') && (/\/(lib|utils|helpers|agents)\//i.test(f) ||
+        f.endsWith('.sql') ||
+        (f.includes('/scripts/') && !f.includes('.test.'))));
+    if (eligibleFiles.length === 0) {
+        return null; // no reusable library code in this sprint
+    }
+    const idx = loadIndex();
+    // Dedup: skip if this exact task (sprint+title) is already indexed
+    const alreadyIndexed = idx.assets.some(a => a.provenance === input.sprintId && a.title === input.taskTitle);
+    if (alreadyIndexed) {
+        return null;
+    }
+    const assetId = (0, crypto_1.randomUUID)();
+    const category = classifyCategory(eligibleFiles, input.taskTitle);
+    const language = inferLanguage(eligibleFiles);
+    const tags = inferTags(eligibleFiles, input.taskTitle);
+    const asset = {
+        asset_id: assetId,
+        title: input.taskTitle,
+        description: `Auto-indexed from sprint ${input.sprintId} task ${input.taskId}`,
+        category,
+        tags,
+        language,
+        dependencies: [],
+        interface: '', // Phase 0: populated manually or by future Code Asset Agent LLM pass
+        usage_example: '',
+        test_coverage: 'none',
+        quality_score: input.supervisorScore,
+        production_validations: 1,
+        origin: input.origin,
+        provenance: input.sprintId,
+        ip_status: 'eligible',
+        version: '1.0.0',
+        last_modified: new Date().toISOString().slice(0, 10),
+        usage_count: 0,
+        known_limitations: [],
+        related_assets: [],
+        tier: 3, // all new assets enter at Tier 3
+        source_files: eligibleFiles,
+    };
+    // Write asset schema to assets/{assetId}/schema.json
+    const assetDir = (0, path_1.join)(ASSETS_DIR, assetId);
+    (0, fs_1.mkdirSync)(assetDir, { recursive: true });
+    (0, fs_1.writeFileSync)((0, path_1.join)(assetDir, 'schema.json'), JSON.stringify(asset, null, 2), 'utf-8');
+    // Update index
+    idx.assets.push({
+        asset_id: asset.asset_id,
+        title: asset.title,
+        category: asset.category,
+        tags: asset.tags,
+        tier: asset.tier,
+        quality_score: asset.quality_score,
+        language: asset.language,
+        usage_count: asset.usage_count,
+        provenance: asset.provenance,
+    });
+    idx._meta.total_assets++;
+    idx._meta.tier_counts['3'] = (idx._meta.tier_counts['3'] || 0) + 1;
+    saveIndex(idx);
+    process.stdout.write(`[code-asset] Indexed ${assetId} (${category}, Tier 3, score ${input.supervisorScore}) ← ${input.sprintId}\n`);
+    return assetId;
+}
+// ── Smoke test ────────────────────────────────────────────────────────────────
+if (require.main === module) {
+    console.log('\n📚 Code Asset Crystalliser — Smoke Test\n');
+    const id = crystalliseCodeAsset({
+        agentId: 'smoke-coder',
+        sprintId: 'sprint-000-smoke',
+        taskId: '000-01',
+        taskTitle: 'BrainX PostgreSQL memory client with pgvector',
+        files: ['scripts/lib/brainx-client.ts', 'scripts/lib/brainx-embed.ts', 'scripts/lib/brainx-schema.sql'],
+        supervisorScore: 88,
+        origin: 'kognai-core',
+    });
+    if (id) {
+        console.log(`✅ crystalliseCodeAsset() → asset_id: ${id}`);
+        const idx = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)((0, engine_paths_1.resolveEnginePaths)().root, 'code_assets/index.json'), 'utf-8'));
+        console.log(`✅ index.json total_assets: ${idx._meta.total_assets}`);
+    }
+    else {
+        console.log('⚠️  Skipped (score below threshold or no lib files)');
+    }
+    console.log('\n✅ PASS\n');
+}