@kognai/build 0.6.0

package/dist/lib/mandate.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMandate = buildMandate;
+exports.signMandate = signMandate;
+exports.verifyMandateSignature = verifyMandateSignature;
+exports.renderMandateMarkdown = renderMandateMarkdown;
+exports.persistMandate = persistMandate;
+exports.loadMandate = loadMandate;
+exports.loadActiveMandate = loadActiveMandate;
+exports.listMandates = listMandates;
+exports.checkEnvelope = checkEnvelope;
+exports.updateBurn = updateBurn;
+exports.revokeMandate = revokeMandate;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const STATE_ROOT = '.swarm-state/mandates';
+const ACTIVE_POINTER = (0, node_path_1.join)(STATE_ROOT, 'active.json');
+const SECRET_PATH = (0, node_path_1.join)((0, node_os_1.homedir)(), '.kognai', 'mandate-secret');
+function ensureDir(path) {
+    if (!(0, node_fs_1.existsSync)(path)) {
+        (0, node_fs_1.mkdirSync)(path, { recursive: true });
+    }
+}
+function getMandateSecret() {
+    const envSecret = process.env.KOGNAI_MANDATE_SECRET;
+    if (envSecret && envSecret.length > 0) {
+        return envSecret;
+    }
+    if ((0, node_fs_1.existsSync)(SECRET_PATH)) {
+        const value = (0, node_fs_1.readFileSync)(SECRET_PATH, 'utf8').trim();
+        if (value.length > 0) {
+            return value;
+        }
+    }
+    const generated = (0, node_crypto_1.randomBytes)(32).toString('hex');
+    ensureDir((0, node_path_1.dirname)(SECRET_PATH));
+    (0, node_fs_1.writeFileSync)(SECRET_PATH, generated, { mode: 0o600 });
+    return generated;
+}
+function canonicalSignaturePayload(unsigned, signed_at) {
+    return JSON.stringify({
+        objective: unsigned.objective,
+        success_criteria: unsigned.success_criteria,
+        scope_boundaries: unsigned.scope_boundaries,
+        template_id: unsigned.template_id,
+        profile: unsigned.profile,
+        capabilities: unsigned.capabilities,
+        cost_envelope: unsigned.cost_envelope,
+        deadline: unsigned.deadline,
+        signed_at,
+    });
+}
+function deriveMandateId(objective, template_id, estimated_usdc, signed_at) {
+    const seed = `${objective}${template_id}${estimated_usdc}${signed_at}`;
+    return (0, node_crypto_1.createHash)('sha256').update(seed).digest('hex').slice(0, 16);
+}
+function computeSignature(payload, secret) {
+    return (0, node_crypto_1.createHmac)('sha256', secret).update(payload).digest('hex');
+}
+function buildMandate(input) {
+    if (!input.objective || input.objective.trim().length === 0) {
+        throw new Error('Mandate objective is required');
+    }
+    if (!input.template_id || input.template_id.trim().length === 0) {
+        throw new Error('Mandate template_id is required');
+    }
+    // deadline is optional (string | null) — a mandate may run open-ended within its
+    // budget/scope envelope (TICKET-202 spec: deadline string | null).
+    if (!Array.isArray(input.success_criteria) || input.success_criteria.length === 0) {
+        throw new Error('Mandate success_criteria must be a non-empty array');
+    }
+    if (!Array.isArray(input.scope_boundaries)) {
+        throw new Error('Mandate scope_boundaries must be an array');
+    }
+    if (!input.profile || !input.profile.primary) {
+        throw new Error('Mandate profile.primary is required');
+    }
+    if (!input.capabilities) {
+        throw new Error('Mandate capabilities are required');
+    }
+    if (!input.cost_envelope) {
+        throw new Error('Mandate cost_envelope is required');
+    }
+    if (input.cost_envelope.max_usdc < input.cost_envelope.estimated_usdc) {
+        throw new Error('max_usdc must be >= estimated_usdc');
+    }
+    return {
+        objective: input.objective,
+        success_criteria: [...input.success_criteria],
+        scope_boundaries: [...input.scope_boundaries],
+        template_id: input.template_id,
+        profile: {
+            primary: input.profile.primary,
+            secondary: [...input.profile.secondary],
+            hard_constraints: [...input.profile.hard_constraints],
+        },
+        capabilities: {
+            skills: [...input.capabilities.skills],
+            tools: [...input.capabilities.tools],
+            agents: [...input.capabilities.agents],
+        },
+        cost_envelope: { ...input.cost_envelope },
+        deadline: input.deadline,
+    };
+}
+function signMandate(unsigned, signer = 'founder') {
+    const signed_at = new Date().toISOString();
+    const payload = canonicalSignaturePayload(unsigned, signed_at);
+    const secret = getMandateSecret();
+    const signature = computeSignature(payload, secret);
+    const mandate_id = deriveMandateId(unsigned.objective, unsigned.template_id, unsigned.cost_envelope.estimated_usdc, signed_at);
+    return {
+        mandate_id,
+        objective: unsigned.objective,
+        success_criteria: [...unsigned.success_criteria],
+        scope_boundaries: [...unsigned.scope_boundaries],
+        template_id: unsigned.template_id,
+        profile: {
+            primary: unsigned.profile.primary,
+            secondary: [...unsigned.profile.secondary],
+            hard_constraints: [...unsigned.profile.hard_constraints],
+        },
+        capabilities: {
+            skills: [...unsigned.capabilities.skills],
+            tools: [...unsigned.capabilities.tools],
+            agents: [...unsigned.capabilities.agents],
+        },
+        cost_envelope: { ...unsigned.cost_envelope },
+        deadline: unsigned.deadline,
+        signed_at,
+        signed_by: signer,
+        signature,
+        status: 'active',
+        burn: {
+            usdc_consumed: 0,
+            tasks_completed: 0,
+            last_updated: signed_at,
+        },
+    };
+}
+function verifyMandateSignature(m) {
+    const payload = canonicalSignaturePayload({
+        objective: m.objective,
+        success_criteria: m.success_criteria,
+        scope_boundaries: m.scope_boundaries,
+        template_id: m.template_id,
+        profile: m.profile,
+        capabilities: m.capabilities,
+        cost_envelope: m.cost_envelope,
+        deadline: m.deadline,
+    }, m.signed_at);
+    const secret = getMandateSecret();
+    const expected = computeSignature(payload, secret);
+    return expected === m.signature;
+}
+function renderMandateMarkdown(m) {
+    const shortId = m.mandate_id.slice(0, 8);
+    const lines = [];
+    lines.push(`# ⟢ Mandate ${shortId}`);
+    lines.push('');
+    lines.push(`**Objective:** ${m.objective}`);
+    lines.push(`**Template:** ${m.template_id}`);
+    lines.push(`**Status:** ${m.status}`);
+    lines.push(`**Signed by:** ${m.signed_by} at ${m.signed_at}`);
+    lines.push(`**Deadline:** ${m.deadline ?? 'none'}`);
+    lines.push('');
+    lines.push('## ⟡ Success Criteria');
+    for (const sc of m.success_criteria) {
+        lines.push(`- ${sc}`);
+    }
+    lines.push('');
+    lines.push('## ⟡ Scope Boundaries');
+    if (m.scope_boundaries.length === 0) {
+        lines.push('- _(none specified)_');
+    }
+    else {
+        for (const sb of m.scope_boundaries) {
+            lines.push(`- ${sb}`);
+        }
+    }
+    lines.push('');
+    lines.push('## ⟡ Profile');
+    lines.push(`- **Primary:** ${m.profile.primary}`);
+    lines.push(`- **Secondary:** ${m.profile.secondary.length > 0 ? m.profile.secondary.join(', ') : '_(none)_'}`);
+    lines.push(`- **Hard Constraints:** ${m.profile.hard_constraints.length > 0
+        ? m.profile.hard_constraints.join(', ')
+        : '_(none)_'}`);
+    lines.push('');
+    lines.push('## ⟡ Capabilities');
+    lines.push(`- **Skills:** ${m.capabilities.skills.length > 0 ? m.capabilities.skills.join(', ') : '_(none)_'}`);
+    lines.push(`- **Tools:** ${m.capabilities.tools.length > 0 ? m.capabilities.tools.join(', ') : '_(none)_'}`);
+    lines.push(`- **Agents:** ${m.capabilities.agents.length > 0 ? m.capabilities.agents.join(', ') : '_(none)_'}`);
+    lines.push('');
+    lines.push('## ⟡ Cost Envelope');
+    lines.push(`- **Estimated:** ${m.cost_envelope.estimated_usdc.toFixed(4)} USDC`);
+    lines.push(`- **Max (hard ceiling):** ${m.cost_envelope.max_usdc.toFixed(4)} USDC`);
+    lines.push(`- **Per-task budget:** ${m.cost_envelope.per_task_budget.toFixed(4)} USDC`);
+    lines.push('');
+    lines.push('## ⟡ Burn');
+    lines.push(`- **Consumed:** ${m.burn.usdc_consumed.toFixed(4)} USDC`);
+    lines.push(`- **Tasks Completed:** ${m.burn.tasks_completed}`);
+    lines.push(`- **Last Updated:** ${m.burn.last_updated}`);
+    lines.push('');
+    lines.push(`_signature: ${m.signature.slice(0, 16)}…_`);
+    return lines.join('\n');
+}
+function mandatePath(mandate_id) {
+    return (0, node_path_1.join)(STATE_ROOT, `${mandate_id}.json`);
+}
+function persistMandate(m) {
+    ensureDir(STATE_ROOT);
+    const path = mandatePath(m.mandate_id);
+    (0, node_fs_1.writeFileSync)(path, JSON.stringify(m, null, 2), 'utf8');
+    if (m.status === 'active') {
+        (0, node_fs_1.writeFileSync)(ACTIVE_POINTER, JSON.stringify({ mandate_id: m.mandate_id, updated_at: new Date().toISOString() }, null, 2), 'utf8');
+    }
+    return path;
+}
+function loadMandate(mandate_id) {
+    const path = mandatePath(mandate_id);
+    if (!(0, node_fs_1.existsSync)(path)) {
+        return null;
+    }
+    try {
+        const raw = (0, node_fs_1.readFileSync)(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch (err) {
+        throw new Error(`Failed to load mandate ${mandate_id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function loadActiveMandate() {
+    if ((0, node_fs_1.existsSync)(ACTIVE_POINTER)) {
+        try {
+            const raw = (0, node_fs_1.readFileSync)(ACTIVE_POINTER, 'utf8');
+            const pointer = JSON.parse(raw);
+            if (pointer.mandate_id) {
+                const m = loadMandate(pointer.mandate_id);
+                if (m && m.status === 'active') {
+                    return m;
+                }
+            }
+        }
+        catch {
+            // fall through to directory scan
+        }
+    }
+    if (!(0, node_fs_1.existsSync)(STATE_ROOT)) {
+        return null;
+    }
+    const entries = (0, node_fs_1.readdirSync)(STATE_ROOT).filter((f) => f.endsWith('.json') && f !== 'active.json');
+    let latest = null;
+    for (const entry of entries) {
+        try {
+            const raw = (0, node_fs_1.readFileSync)((0, node_path_1.join)(STATE_ROOT, entry), 'utf8');
+            const m = JSON.parse(raw);
+            if (m.status !== 'active')
+                continue;
+            if (!latest || m.signed_at > latest.signed_at) {
+                latest = m;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return latest;
+}
+/** All persisted mandates, newest first. Skips the active.json pointer and any
+ *  unreadable file. Used by the REPL `/mandates` listing. */
+function listMandates() {
+    if (!(0, node_fs_1.existsSync)(STATE_ROOT)) {
+        return [];
+    }
+    const entries = (0, node_fs_1.readdirSync)(STATE_ROOT).filter((f) => f.endsWith('.json') && f !== 'active.json');
+    const out = [];
+    for (const entry of entries) {
+        try {
+            out.push(JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(STATE_ROOT, entry), 'utf8')));
+        }
+        catch {
+            continue;
+        }
+    }
+    out.sort((a, b) => String(b.signed_at).localeCompare(String(a.signed_at)));
+    return out;
+}
+function checkEnvelope(m) {
+    if (m.status === 'revoked') {
+        return { reason: 'revoked', detail: 'Mandate has been revoked' };
+    }
+    if (m.burn.usdc_consumed > m.cost_envelope.max_usdc) {
+        return {
+            reason: 'budget',
+            detail: `Burn ${m.burn.usdc_consumed.toFixed(4)} USDC exceeds hard ceiling ${m.cost_envelope.max_usdc.toFixed(4)} USDC`,
+        };
+    }
+    if (m.deadline) {
+        const deadlineMs = Date.parse(m.deadline);
+        if (!Number.isNaN(deadlineMs) && Date.now() > deadlineMs) {
+            return {
+                reason: 'deadline',
+                detail: `Deadline ${m.deadline} has passed`,
+            };
+        }
+    }
+    if (m.profile.hard_constraints.length === 0 && m.scope_boundaries.length === 0) {
+        // no explicit scope rules to evaluate
+    }
+    return null;
+}
+function updateBurn(mandate_id, delta_usdc, task_completed) {
+    if (!Number.isFinite(delta_usdc) || delta_usdc < 0) {
+        throw new Error('delta_usdc must be a non-negative finite number');
+    }
+    const m = loadMandate(mandate_id);
+    if (!m) {
+        throw new Error(`Mandate ${mandate_id} not found`);
+    }
+    m.burn.usdc_consumed = Number((m.burn.usdc_consumed + delta_usdc).toFixed(6));
+    if (task_completed) {
+        m.burn.tasks_completed += 1;
+    }
+    m.burn.last_updated = new Date().toISOString();
+    const breach = checkEnvelope(m);
+    if (breach && breach.reason === 'budget') {
+        m.status = 'breached';
+    }
+    persistMandate(m);
+    return m;
+}
+function revokeMandate(mandate_id, reason) {
+    if (!reason || reason.trim().length === 0) {
+        throw new Error('Revocation reason is required');
+    }
+    const m = loadMandate(mandate_id);
+    if (!m) {
+        throw new Error(`Mandate ${mandate_id} not found`);
+    }
+    m.status = 'revoked';
+    m.burn.last_updated = new Date().toISOString();
+    persistMandate(m);
+    // Clear active pointer if this was the active mandate
+    if ((0, node_fs_1.existsSync)(ACTIVE_POINTER)) {
+        try {
+            const raw = (0, node_fs_1.readFileSync)(ACTIVE_POINTER, 'utf8');
+            const pointer = JSON.parse(raw);
+            if (pointer.mandate_id === mandate_id) {
+                (0, node_fs_1.writeFileSync)(ACTIVE_POINTER, JSON.stringify({ mandate_id: null, revoked: mandate_id, reason, revoked_at: m.burn.last_updated }, null, 2), 'utf8');
+            }
+        }
+        catch {
+            // ignore pointer cleanup errors
+        }
+    }
+    return m;
+}

package/dist/lib/memory.js

@@ -0,0 +1,243 @@
+"use strict";
+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.loadMemory = loadMemory;
+exports.renderMemoryPrefix = renderMemoryPrefix;
+exports.writeSessionSummary = writeSessionSummary;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const DEFAULT_MAX_BYTES = 100_000;
+function walkDir(root, source) {
+    const out = [];
+    if (!root)
+        return out;
+    let stat;
+    try {
+        stat = fs.statSync(root);
+    }
+    catch {
+        return out;
+    }
+    if (!stat.isDirectory())
+        return out;
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const abs = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(abs);
+            }
+            else if (entry.isFile()) {
+                let s;
+                try {
+                    s = fs.statSync(abs);
+                }
+                catch {
+                    continue;
+                }
+                out.push({
+                    absPath: abs,
+                    relPath: path.relative(root, abs),
+                    source,
+                    size: s.size,
+                    mtimeMs: s.mtimeMs,
+                });
+            }
+        }
+    }
+    return out;
+}
+function loadMemory(workspace, maxBytes) {
+    const cap = typeof maxBytes === 'number' && maxBytes >= 0 ? maxBytes : DEFAULT_MAX_BYTES;
+    const userDir = workspace.memory_user_dir || '';
+    const kognaiDir = workspace.memory_kognai_dir || '';
+    const userEntries = walkDir(userDir, 'user');
+    const kognaiEntries = walkDir(kognaiDir, 'kognai');
+    // Most-recent first across both dirs.
+    const all = [...userEntries, ...kognaiEntries].sort((a, b) => b.mtimeMs - a.mtimeMs);
+    const filesRead = [];
+    const filesSkipped = [];
+    const chunks = [];
+    let totalBytes = 0;
+    for (const entry of all) {
+        const sourceLabel = entry.source === 'user' ? 'user' : 'kognai';
+        const header = `MEMORY: ${sourceLabel}/${entry.relPath}\n`;
+        const footer = `\nMEMORY: end ${sourceLabel}/${entry.relPath}\n`;
+        let content;
+        try {
+            content = fs.readFileSync(entry.absPath, 'utf8');
+        }
+        catch {
+            filesSkipped.push(entry.absPath);
+            continue;
+        }
+        const block = header + content + footer;
+        const blockBytes = Buffer.byteLength(block, 'utf8');
+        if (totalBytes + blockBytes > cap) {
+            filesSkipped.push(entry.absPath);
+            continue;
+        }
+        chunks.push(block);
+        totalBytes += blockBytes;
+        filesRead.push(entry.absPath);
+    }
+    return {
+        text: chunks.join('\n'),
+        files_read: filesRead,
+        files_skipped: filesSkipped,
+        total_bytes: totalBytes,
+    };
+}
+function renderMemoryPrefix(block) {
+    if (!block.files_read || block.files_read.length === 0) {
+        return '';
+    }
+    return ('# Workspace Memory\n\nPrior session memories (most-recent first). Use these for context.\n\n' +
+        block.text +
+        '\n# End of Workspace Memory\n\n');
+}
+function escapeMarkdown(text) {
+    // Escape characters that could break Markdown rendering or list structure.
+    return text
+        .replace(/\\/g, '\\\\')
+        .replace(/\r\n/g, '\n')
+        .replace(/\n/g, ' ')
+        .replace(/`/g, '\\`')
+        .replace(/\*/g, '\\*')
+        .replace(/_/g, '\\_')
+        .replace(/\[/g, '\\[')
+        .replace(/\]/g, '\\]');
+}
+function shortIdFromMandate(mandateId) {
+    if (mandateId && mandateId.length > 0) {
+        return mandateId.slice(0, 8);
+    }
+    // Random base36 short id.
+    const bytes = crypto.randomBytes(6);
+    let n = 0n;
+    for (const b of bytes) {
+        n = (n << 8n) | BigInt(b);
+    }
+    return n.toString(36).slice(0, 8).padStart(8, '0');
+}
+function datePartISO(iso) {
+    // Extract YYYY-MM-DD from an ISO timestamp; fall back to today (UTC).
+    const m = /^(\d{4}-\d{2}-\d{2})/.exec(iso || '');
+    if (m)
+        return m[1];
+    const now = new Date();
+    const yyyy = now.getUTCFullYear().toString().padStart(4, '0');
+    const mm = (now.getUTCMonth() + 1).toString().padStart(2, '0');
+    const dd = now.getUTCDate().toString().padStart(2, '0');
+    return `${yyyy}-${mm}-${dd}`;
+}
+function atomicWriteFile(targetPath, contents) {
+    const dir = path.dirname(targetPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmpName = `.${path.basename(targetPath)}.${process.pid}.${crypto
+        .randomBytes(4)
+        .toString('hex')}.tmp`;
+    const tmpPath = path.join(dir, tmpName);
+    fs.writeFileSync(tmpPath, contents, { encoding: 'utf8' });
+    try {
+        fs.renameSync(tmpPath, targetPath);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch {
+            // ignore
+        }
+        throw err;
+    }
+}
+function writeSessionSummary(workspace, summary) {
+    const kognaiDir = workspace.memory_kognai_dir;
+    if (!kognaiDir) {
+        throw new Error('writeSessionSummary: workspace.memory_kognai_dir is not configured');
+    }
+    fs.mkdirSync(kognaiDir, { recursive: true });
+    const datePart = datePartISO(summary.ended_at || summary.started_at);
+    const shortId = shortIdFromMandate(summary.mandate_id);
+    const baseName = `session-${datePart}-${shortId}`;
+    let candidate = path.join(kognaiDir, `${baseName}.md`);
+    let suffix = 1;
+    while (fs.existsSync(candidate)) {
+        candidate = path.join(kognaiDir, `${baseName}-${suffix}.md`);
+        suffix += 1;
+    }
+    const profile = summary.profile && summary.profile.length > 0 ? summary.profile : 'none';
+    const mandate = summary.mandate_id && summary.mandate_id.length > 0 ? summary.mandate_id : 'unsigned';
+    const goalEscaped = escapeMarkdown(summary.goal || '');
+    const costStr = (() => {
+        const n = Number(summary.cost_usdc);
+        if (!Number.isFinite(n))
+            return '0.0000';
+        return n.toFixed(4);
+    })();
+    const deliverables = summary.files && summary.files.length > 0
+        ? summary.files.map((f) => `- \`${f}\``).join('\n')
+        : '- _none_';
+    const md = `# Session ${shortId}\n` +
+        `\n` +
+        `- **Started:** ${summary.started_at}\n` +
+        `- **Ended:** ${summary.ended_at}\n` +
+        `- **Goal:** ${goalEscaped}\n` +
+        `- **Profile:** ${profile}\n` +
+        `- **Mandate:** ${mandate}\n` +
+        `- **Tasks shipped:** ${summary.tasks_shipped} / ${summary.tasks_total}\n` +
+        `- **Cost:** \\$${costStr} USDC\n` +
+        `\n` +
+        `## Deliverables\n` +
+        `\n` +
+        `${deliverables}\n` +
+        `\n` +
+        `---\n` +
+        `*Auto-generated by Kognai orchestrator. Phase 2 will extract agent decisions + key learnings from the session transcript.*\n`;
+    atomicWriteFile(candidate, md);
+    return candidate;
+}

package/dist/lib/registry-overrides.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyRegistryOverrides = applyRegistryOverrides;
+/**
+ * registry-overrides.ts — merge optional `.kognai/<file>.json` into a base
+ * registry (tool-layer / skill-bank) at module load, so the registries are
+ * real and extensible per workspace rather than frozen catalogs (TICKET-233).
+ *
+ * Resolves the workspace root from KOGNAI_ROOT (set by boot-env) or cwd. A
+ * missing or malformed override file is a no-op — it must never break the CLI.
+ * Entries override the base by `id`; unknown ids are appended.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function applyRegistryOverrides(base, filename) {
+    try {
+        const root = process.env.KOGNAI_ROOT || process.cwd();
+        const path = (0, node_path_1.join)(root, '.kognai', filename);
+        if (!(0, node_fs_1.existsSync)(path))
+            return;
+        const raw = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+        const extra = Array.isArray(raw)
+            ? raw
+            : Array.isArray(raw.entries)
+                ? raw.entries
+                : [];
+        for (const e of extra) {
+            if (!e || typeof e.id !== 'string')
+                continue;
+            const i = base.findIndex((b) => b.id === e.id);
+            if (i >= 0)
+                base[i] = e;
+            else
+                base.push(e);
+        }
+    }
+    catch {
+        /* best-effort: a malformed override file must never break the CLI */
+    }
+}