@unson/brainbase-mcp 0.1.0

package/dist/ontology-ssot.d.ts

@@ -0,0 +1,4 @@
+import { type OntologyVersion, type PersonalOsOntologyAudit } from './ontology.js';
+export declare function auditPersonalOsDirectory(dataDir: string, options?: {
+    ontologyVersion?: OntologyVersion;
+}): Promise<PersonalOsOntologyAudit>;

package/dist/ontology-ssot.js

@@ -0,0 +1,33 @@
+import { auditOntology, resolveOntologyVersion } from './ontology.js';
+import { loadPersonalOs } from './ssot.js';
+export async function auditPersonalOsDirectory(dataDir, options = {}) {
+    const ontologyVersion = resolveOntologyVersion(options.ontologyVersion);
+    try {
+        return auditOntology(await loadPersonalOs(dataDir), { ontologyVersion });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            status: 'unverified',
+            ontologyVersion,
+            violationCount: null,
+            violations: [],
+            counts: null,
+            coverage: {
+                complete: false,
+                unavailableSources: canonicalSourcesFromError(message)
+            },
+            issues: [{
+                    ruleId: 'ONT-AUDIT-SOURCE-UNAVAILABLE',
+                    severity: 'error',
+                    path: dataDir,
+                    message
+                }]
+        };
+    }
+}
+function canonicalSourcesFromError(message) {
+    const sources = ['graph.json', 'relationships.json', 'personal-kg.jsonl', 'decisions.jsonl'];
+    const matched = sources.filter((source) => message.includes(source));
+    return matched.length > 0 ? matched : sources;
+}

package/dist/ontology.d.ts

@@ -0,0 +1,181 @@
+import type { DecisionRecord, PersonalOs } from './types.js';
+export declare const ONTOLOGY_VERSION: "1.0.0";
+export declare const SUPPORTED_ONTOLOGY_VERSIONS: readonly ["0.0.0", "1.0.0"];
+export type OntologyVersion = typeof SUPPORTED_ONTOLOGY_VERSIONS[number];
+export type OntologySeverity = 'error' | 'warning';
+export interface OntologyViolation {
+    ruleId: string;
+    severity: OntologySeverity;
+    path: string;
+    message: string;
+}
+export interface OntologyAuditResult {
+    status: 'complete';
+    ontologyVersion: OntologyVersion;
+    violationCount: number;
+    violations: OntologyViolation[];
+    counts: {
+        entities: number;
+        relationships: number;
+        personalKg: number;
+        decisions: number;
+    };
+    coverage: {
+        complete: true;
+        unavailableSources: [];
+    };
+    issues: [];
+}
+export interface UnverifiedOntologyAuditResult {
+    status: 'unverified';
+    ontologyVersion: OntologyVersion;
+    violationCount: null;
+    violations: [];
+    counts: null;
+    coverage: {
+        complete: false;
+        unavailableSources: string[];
+    };
+    issues: OntologyViolation[];
+}
+export type PersonalOsOntologyAudit = OntologyAuditResult | UnverifiedOntologyAuditResult;
+export declare const portableOntology: {
+    readonly version: "1.0.0";
+    readonly effectiveAt: "2026-08-03T00:00:00.000Z";
+    readonly compatibility: "read-compatible-write-gated";
+    readonly name: "Brainbase Portable Ontology Kernel";
+    readonly description: "A local-first semantic contract for Brainbase Personal OS data.";
+    readonly domains: {
+        readonly types: {
+            readonly concepts: readonly [{
+                readonly id: "person";
+                readonly meaning: "A human represented in the local Graph.";
+                readonly usageConditions: readonly ["Use only for a human identity approved for the canonical local SSOT."];
+            }, {
+                readonly id: "org";
+                readonly meaning: "An organization represented in the local Graph.";
+                readonly usageConditions: readonly ["Use for a named organizational actor, not for a project or product."];
+            }, {
+                readonly id: "project";
+                readonly meaning: "A bounded body of work represented in the local Graph.";
+                readonly usageConditions: readonly ["Use when the entity has a bounded work objective; do not use it as an organization alias."];
+            }, {
+                readonly id: "relationship";
+                readonly meaning: "A contextual connection to a person.";
+                readonly usageConditions: readonly ["The person field must resolve to a canonical person entity by name."];
+            }, {
+                readonly id: "decision";
+                readonly meaning: "A durable choice that may explicitly supersede another choice.";
+                readonly usageConditions: readonly ["Use for an explicit durable choice; replacement requires a supersedes Decision ID."];
+            }];
+        };
+        readonly relations: {
+            readonly vocabulary: readonly [{
+                readonly id: "relates_to";
+                readonly source: "relationship";
+                readonly target: "person";
+            }, {
+                readonly id: "supersedes";
+                readonly source: "decision";
+                readonly target: "decision";
+            }, {
+                readonly id: "about";
+                readonly source: "decision";
+                readonly target: "topic";
+            }];
+        };
+        readonly constraints: {
+            readonly rules: readonly [{
+                readonly id: "ONT-ENTITY-ID-UNIQUE";
+                readonly severity: "error";
+                readonly meaning: "Graph entity IDs must be unique.";
+            }, {
+                readonly id: "ONT-RELATIONSHIP-ID-UNIQUE";
+                readonly severity: "error";
+                readonly meaning: "Relationship IDs must be unique.";
+            }, {
+                readonly id: "ONT-DECISION-ID-UNIQUE";
+                readonly severity: "error";
+                readonly meaning: "Decision IDs must be unique.";
+            }, {
+                readonly id: "ONT-RELATIONSHIP-PERSON-RESOLVES";
+                readonly severity: "warning";
+                readonly meaning: "A relationship person should resolve to a canonical person entity by name.";
+            }, {
+                readonly id: "ONT-DECISION-SUPERSEDES-EXISTS";
+                readonly severity: "error";
+                readonly meaning: "A supersedes reference must resolve to an existing decision.";
+            }, {
+                readonly id: "ONT-DECISION-SUPERSEDES-SELF";
+                readonly severity: "error";
+                readonly meaning: "A decision must not supersede itself.";
+            }, {
+                readonly id: "ONT-DECISION-SUPERSEDES-CYCLE";
+                readonly severity: "error";
+                readonly meaning: "Decision supersession edges must not form a cycle.";
+            }];
+        };
+        readonly inference: {
+            readonly rules: readonly [{
+                readonly id: "ONT-INFER-EXPLICIT-SUPERSESSION";
+                readonly meaning: "Only an explicit supersedes edge makes an older decision inactive.";
+            }, {
+                readonly id: "ONT-INFER-SAME-TOPIC-CONFLICT";
+                readonly meaning: "Multiple active decisions on the same explicit topic are reported as a conflict.";
+            }];
+        };
+        readonly evolution: {
+            readonly compatibility: readonly [{
+                readonly fromVersion: "0.0.0";
+                readonly toVersion: "1.0.0";
+                readonly level: "read-compatible-write-gated";
+                readonly changes: readonly ["Adds a versioned public semantic contract.", "Adds optional topic, supersedes, and effectiveAt decision fields."];
+                readonly migration: "Before enabling 1.0.0 writes, back up the Personal OS directory and run ontology:audit with ontology version 1.0.0. Existing files remain readable, but error violations must be reviewed and repaired before a canonical write.";
+                readonly rollback: "For the first npm release, run npm uninstall -g @unson/brainbase-mcp, restore the MCP client configuration and launch command captured before rollout, and restart the client. For later upgrades, reinstall the recorded last known working package version. Restore the pre-upgrade Personal OS backup only if a reviewed repair changed canonical files. Merely avoiding ontology commands does not disable the write guards.";
+            }];
+        };
+    };
+};
+export declare function auditOntology(os: PersonalOs, options?: {
+    ontologyVersion?: OntologyVersion;
+}): OntologyAuditResult;
+export declare function assertOntologyValid(os: PersonalOs): void;
+export interface DecisionInferenceEvidence {
+    ruleId: string;
+    sourceDecisionId?: string;
+    targetDecisionId?: string;
+    topic?: string;
+    decisionIds?: string[];
+}
+export interface DecisionInferenceResult {
+    status: 'empty' | 'resolved' | 'conflict' | 'invalid';
+    ontologyVersion: OntologyVersion;
+    asOf: string;
+    activeDecisionIds: string[];
+    supersededDecisionIds: string[];
+    conflicts: Array<{
+        topic: string;
+        decisionIds: string[];
+    }>;
+    evidence: DecisionInferenceEvidence[];
+    explanations: string[];
+    violations: OntologyViolation[];
+}
+export declare function inferPersonalOs(os: PersonalOs, options?: {
+    asOf?: string;
+    ontologyVersion?: OntologyVersion;
+}): DecisionInferenceResult;
+export declare function inferDecisions(decisions: DecisionRecord[], options?: {
+    asOf?: string;
+    ontologyVersion?: OntologyVersion;
+}): DecisionInferenceResult;
+export declare function getOntologyImpact(fromVersion?: string): {
+    fromVersion: string;
+    toVersion: typeof ONTOLOGY_VERSION;
+    supported: boolean;
+    compatibility: string | null;
+    changes: readonly string[];
+    migration: string | null;
+    rollback: string | null;
+};
+export declare function resolveOntologyVersion(version: string | undefined): OntologyVersion;

package/dist/ontology.js

@@ -0,0 +1,384 @@
+export const ONTOLOGY_VERSION = '1.0.0';
+export const SUPPORTED_ONTOLOGY_VERSIONS = ['0.0.0', ONTOLOGY_VERSION];
+const release = {
+    version: ONTOLOGY_VERSION,
+    effectiveAt: '2026-08-03T00:00:00.000Z',
+    compatibility: 'read-compatible-write-gated',
+    name: 'Brainbase Portable Ontology Kernel',
+    description: 'A local-first semantic contract for Brainbase Personal OS data.',
+    domains: {
+        types: {
+            concepts: [
+                {
+                    id: 'person',
+                    meaning: 'A human represented in the local Graph.',
+                    usageConditions: ['Use only for a human identity approved for the canonical local SSOT.']
+                },
+                {
+                    id: 'org',
+                    meaning: 'An organization represented in the local Graph.',
+                    usageConditions: ['Use for a named organizational actor, not for a project or product.']
+                },
+                {
+                    id: 'project',
+                    meaning: 'A bounded body of work represented in the local Graph.',
+                    usageConditions: ['Use when the entity has a bounded work objective; do not use it as an organization alias.']
+                },
+                {
+                    id: 'relationship',
+                    meaning: 'A contextual connection to a person.',
+                    usageConditions: ['The person field must resolve to a canonical person entity by name.']
+                },
+                {
+                    id: 'decision',
+                    meaning: 'A durable choice that may explicitly supersede another choice.',
+                    usageConditions: ['Use for an explicit durable choice; replacement requires a supersedes Decision ID.']
+                }
+            ]
+        },
+        relations: {
+            vocabulary: [
+                { id: 'relates_to', source: 'relationship', target: 'person' },
+                { id: 'supersedes', source: 'decision', target: 'decision' },
+                { id: 'about', source: 'decision', target: 'topic' }
+            ]
+        },
+        constraints: {
+            rules: [
+                { id: 'ONT-ENTITY-ID-UNIQUE', severity: 'error', meaning: 'Graph entity IDs must be unique.' },
+                { id: 'ONT-RELATIONSHIP-ID-UNIQUE', severity: 'error', meaning: 'Relationship IDs must be unique.' },
+                { id: 'ONT-DECISION-ID-UNIQUE', severity: 'error', meaning: 'Decision IDs must be unique.' },
+                { id: 'ONT-RELATIONSHIP-PERSON-RESOLVES', severity: 'warning', meaning: 'A relationship person should resolve to a canonical person entity by name.' },
+                { id: 'ONT-DECISION-SUPERSEDES-EXISTS', severity: 'error', meaning: 'A supersedes reference must resolve to an existing decision.' },
+                { id: 'ONT-DECISION-SUPERSEDES-SELF', severity: 'error', meaning: 'A decision must not supersede itself.' },
+                { id: 'ONT-DECISION-SUPERSEDES-CYCLE', severity: 'error', meaning: 'Decision supersession edges must not form a cycle.' }
+            ]
+        },
+        inference: {
+            rules: [
+                {
+                    id: 'ONT-INFER-EXPLICIT-SUPERSESSION',
+                    meaning: 'Only an explicit supersedes edge makes an older decision inactive.'
+                },
+                {
+                    id: 'ONT-INFER-SAME-TOPIC-CONFLICT',
+                    meaning: 'Multiple active decisions on the same explicit topic are reported as a conflict.'
+                }
+            ]
+        },
+        evolution: {
+            compatibility: [
+                {
+                    fromVersion: '0.0.0',
+                    toVersion: ONTOLOGY_VERSION,
+                    level: 'read-compatible-write-gated',
+                    changes: [
+                        'Adds a versioned public semantic contract.',
+                        'Adds optional topic, supersedes, and effectiveAt decision fields.'
+                    ],
+                    migration: 'Before enabling 1.0.0 writes, back up the Personal OS directory and run ontology:audit with ontology version 1.0.0. Existing files remain readable, but error violations must be reviewed and repaired before a canonical write.',
+                    rollback: 'For the first npm release, run npm uninstall -g @unson/brainbase-mcp, restore the MCP client configuration and launch command captured before rollout, and restart the client. For later upgrades, reinstall the recorded last known working package version. Restore the pre-upgrade Personal OS backup only if a reviewed repair changed canonical files. Merely avoiding ontology commands does not disable the write guards.'
+                }
+            ]
+        }
+    }
+};
+export const portableOntology = deepFreeze(release);
+export function auditOntology(os, options = {}) {
+    const ontologyVersion = resolveOntologyVersion(options.ontologyVersion);
+    const violations = [];
+    // 0.0.0 names the pre-kernel legacy semantics. Canonical shape validation is
+    // still performed by the SSOT reader, but no 1.0.0 semantic rules are
+    // projected backward onto historical snapshots.
+    if (ontologyVersion === '0.0.0') {
+        return completeAudit(os, ontologyVersion, violations);
+    }
+    auditDuplicateIds(os.graph.entities, 'graph.entities', 'ONT-ENTITY-ID-UNIQUE', 'Graph entity IDs must be unique.', violations);
+    auditDuplicateIds(os.relationships.relationships, 'relationships.relationships', 'ONT-RELATIONSHIP-ID-UNIQUE', 'Relationship IDs must be unique.', violations);
+    auditDuplicateIds(os.decisions, 'decisions', 'ONT-DECISION-ID-UNIQUE', 'Decision IDs must be unique.', violations);
+    const personNames = new Set(os.graph.entities.filter((entity) => entity.type === 'person').map((entity) => entity.name));
+    os.relationships.relationships.forEach((relationship, index) => {
+        if (!personNames.has(relationship.person)) {
+            violations.push({
+                ruleId: 'ONT-RELATIONSHIP-PERSON-RESOLVES',
+                severity: 'warning',
+                path: `relationships.relationships[${index}].person`,
+                message: `Relationship person ${JSON.stringify(relationship.person)} does not resolve to a person entity.`
+            });
+        }
+    });
+    auditDecisionSupersession(os.decisions, violations);
+    return completeAudit(os, ontologyVersion, violations);
+}
+export function assertOntologyValid(os) {
+    const result = auditOntology(os);
+    const errors = result.violations.filter((violation) => violation.severity === 'error');
+    if (errors.length > 0) {
+        throw new Error(`Ontology validation failed: ${errors.map((error) => `${error.ruleId} at ${error.path}: ${error.message}`).join('; ')}`);
+    }
+}
+export function inferPersonalOs(os, options = {}) {
+    const ontologyVersion = resolveOntologyVersion(options.ontologyVersion);
+    const audit = auditOntology(os, { ontologyVersion });
+    const errors = audit.violations.filter((violation) => violation.severity === 'error');
+    if (errors.length > 0) {
+        return {
+            status: 'invalid',
+            ontologyVersion,
+            asOf: options.asOf ?? new Date().toISOString(),
+            activeDecisionIds: [],
+            supersededDecisionIds: [],
+            conflicts: [],
+            evidence: [],
+            explanations: ['Inference was not performed because the complete Personal OS snapshot is invalid.'],
+            violations: errors
+        };
+    }
+    return inferDecisions(os.decisions, { ...options, ontologyVersion });
+}
+export function inferDecisions(decisions, options = {}) {
+    const ontologyVersion = resolveOntologyVersion(options.ontologyVersion);
+    const asOf = options.asOf ?? new Date().toISOString();
+    if (ontologyVersion === '0.0.0') {
+        return {
+            status: decisions.length === 0 ? 'empty' : 'resolved',
+            ontologyVersion,
+            asOf,
+            activeDecisionIds: decisions.map((decision) => decision.id),
+            supersededDecisionIds: [],
+            conflicts: [],
+            evidence: [],
+            explanations: [
+                'Ontology 0.0.0 is the pre-kernel legacy interpretation; 1.0.0 effectiveAt, supersession, and conflict rules were not applied.'
+            ],
+            violations: []
+        };
+    }
+    const asOfInstant = Date.parse(asOf);
+    if (Number.isNaN(asOfInstant)) {
+        return {
+            status: 'invalid',
+            ontologyVersion,
+            asOf,
+            activeDecisionIds: [],
+            supersededDecisionIds: [],
+            conflicts: [],
+            evidence: [],
+            explanations: ['Inference was not performed because asOf is not a valid ISO date-time.'],
+            violations: [{
+                    ruleId: 'ONT-INFERENCE-AS-OF-DATETIME',
+                    severity: 'error',
+                    path: 'asOf',
+                    message: `asOf must be a valid ISO date-time. Received: ${asOf}.`
+                }]
+        };
+    }
+    const effectiveDecisions = decisions.filter((decision) => {
+        if (!decision.effectiveAt)
+            return true;
+        const effectiveInstant = Date.parse(decision.effectiveAt);
+        return !Number.isNaN(effectiveInstant) && effectiveInstant <= asOfInstant;
+    });
+    const violations = [];
+    auditDuplicateIds(effectiveDecisions, 'decisions', 'ONT-DECISION-ID-UNIQUE', 'Decision IDs must be unique.', violations);
+    auditDecisionSupersession(effectiveDecisions, violations);
+    if (violations.some((violation) => violation.severity === 'error')) {
+        return {
+            status: 'invalid',
+            ontologyVersion,
+            asOf,
+            activeDecisionIds: [],
+            supersededDecisionIds: [],
+            conflicts: [],
+            evidence: [],
+            explanations: ['Inference was not performed because the decision graph is invalid.'],
+            violations
+        };
+    }
+    const superseded = new Set();
+    const evidence = [];
+    for (const decision of effectiveDecisions) {
+        for (const target of decision.supersedes ?? []) {
+            superseded.add(target);
+            evidence.push({
+                sourceDecisionId: decision.id,
+                targetDecisionId: target,
+                ruleId: 'ONT-INFER-EXPLICIT-SUPERSESSION'
+            });
+        }
+    }
+    const active = effectiveDecisions.filter((decision) => !superseded.has(decision.id));
+    const topicGroups = new Map();
+    for (const decision of active) {
+        if (!decision.topic) {
+            continue;
+        }
+        const ids = topicGroups.get(decision.topic) ?? [];
+        ids.push(decision.id);
+        topicGroups.set(decision.topic, ids);
+    }
+    const conflicts = [...topicGroups.entries()]
+        .filter(([, ids]) => ids.length > 1)
+        .map(([topic, decisionIds]) => ({ topic, decisionIds }));
+    const conflictedDecisionIds = new Set(conflicts.flatMap((conflict) => conflict.decisionIds));
+    const current = active.filter((decision) => !conflictedDecisionIds.has(decision.id));
+    evidence.push(...conflicts.map((conflict) => ({
+        ruleId: 'ONT-INFER-SAME-TOPIC-CONFLICT',
+        topic: conflict.topic,
+        decisionIds: conflict.decisionIds
+    })));
+    return {
+        status: decisions.length === 0 ? 'empty' : conflicts.length > 0 ? 'conflict' : 'resolved',
+        ontologyVersion,
+        asOf,
+        activeDecisionIds: current.map((decision) => decision.id),
+        supersededDecisionIds: effectiveDecisions.filter((decision) => superseded.has(decision.id)).map((decision) => decision.id),
+        conflicts,
+        evidence,
+        explanations: [
+            ...evidence
+                .filter((item) => item.ruleId === 'ONT-INFER-EXPLICIT-SUPERSESSION')
+                .map((item) => `${item.sourceDecisionId} explicitly supersedes ${item.targetDecisionId}.`),
+            ...conflicts.map((conflict) => `Topic ${JSON.stringify(conflict.topic)} has multiple current candidates, so none is active: ${conflict.decisionIds.join(', ')}.`),
+            ...active.filter((decision) => !decision.topic).map((decision) => `${decision.id} has no topic and remains an independent legacy decision.`)
+        ],
+        violations
+    };
+}
+export function getOntologyImpact(fromVersion = ONTOLOGY_VERSION) {
+    if (fromVersion === ONTOLOGY_VERSION) {
+        return {
+            fromVersion,
+            toVersion: ONTOLOGY_VERSION,
+            supported: true,
+            compatibility: 'identical',
+            changes: [],
+            migration: 'No migration is required.',
+            rollback: 'No rollback is required.'
+        };
+    }
+    const release = portableOntology.domains.evolution.compatibility.find((item) => item.fromVersion === fromVersion);
+    if (!release) {
+        return {
+            fromVersion,
+            toVersion: ONTOLOGY_VERSION,
+            supported: false,
+            compatibility: null,
+            changes: [],
+            migration: null,
+            rollback: null
+        };
+    }
+    return {
+        fromVersion,
+        toVersion: ONTOLOGY_VERSION,
+        supported: true,
+        compatibility: release.level,
+        changes: release.changes,
+        migration: release.migration,
+        rollback: release.rollback
+    };
+}
+function auditDuplicateIds(records, path, ruleId, message, violations) {
+    const seen = new Set();
+    records.forEach((record, index) => {
+        if (seen.has(record.id)) {
+            violations.push({ ruleId, severity: 'error', path: `${path}[${index}].id`, message: `${message} Duplicate: ${record.id}.` });
+        }
+        seen.add(record.id);
+    });
+}
+function completeAudit(os, ontologyVersion, violations) {
+    return {
+        status: 'complete',
+        ontologyVersion,
+        violationCount: violations.length,
+        violations,
+        counts: {
+            entities: os.graph.entities.length,
+            relationships: os.relationships.relationships.length,
+            personalKg: os.personalKg.length,
+            decisions: os.decisions.length
+        },
+        coverage: { complete: true, unavailableSources: [] },
+        issues: []
+    };
+}
+export function resolveOntologyVersion(version) {
+    const requested = version ?? ONTOLOGY_VERSION;
+    if (!SUPPORTED_ONTOLOGY_VERSIONS.includes(requested)) {
+        throw new Error(`Unsupported ontology version ${JSON.stringify(requested)}. Supported versions: ${SUPPORTED_ONTOLOGY_VERSIONS.join(', ')}.`);
+    }
+    return requested;
+}
+function auditDecisionSupersession(decisions, violations) {
+    const ids = new Set(decisions.map((decision) => decision.id));
+    const edges = new Map(decisions.map((decision) => [decision.id, decision.supersedes ?? []]));
+    decisions.forEach((decision, decisionIndex) => {
+        (decision.supersedes ?? []).forEach((target, targetIndex) => {
+            const path = `decisions[${decisionIndex}].supersedes[${targetIndex}]`;
+            if (!ids.has(target)) {
+                violations.push({
+                    ruleId: 'ONT-DECISION-SUPERSEDES-EXISTS',
+                    severity: 'error',
+                    path,
+                    message: `Superseded decision ${JSON.stringify(target)} does not exist.`
+                });
+            }
+            if (target === decision.id) {
+                violations.push({
+                    ruleId: 'ONT-DECISION-SUPERSEDES-SELF',
+                    severity: 'error',
+                    path,
+                    message: 'A decision cannot supersede itself.'
+                });
+            }
+        });
+    });
+    const state = new Map();
+    const stack = [];
+    const cycleNodes = new Set();
+    const visit = (id) => {
+        if (state.has(id)) {
+            return;
+        }
+        state.set(id, 'visiting');
+        stack.push(id);
+        for (const target of edges.get(id) ?? []) {
+            if (!ids.has(target)) {
+                continue;
+            }
+            if (state.get(target) === 'visiting') {
+                const cycleStart = stack.indexOf(target);
+                for (const cycleId of stack.slice(cycleStart)) {
+                    cycleNodes.add(cycleId);
+                }
+            }
+            else if (!state.has(target)) {
+                visit(target);
+            }
+        }
+        stack.pop();
+        state.set(id, 'visited');
+    };
+    for (const id of ids) {
+        visit(id);
+    }
+    for (const id of cycleNodes) {
+        violations.push({
+            ruleId: 'ONT-DECISION-SUPERSEDES-CYCLE',
+            severity: 'error',
+            path: `decisions.${id}.supersedes`,
+            message: `Decision supersession cycle includes ${id}.`
+        });
+    }
+}
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value)) {
+            deepFreeze(child);
+        }
+    }
+    return value;
+}

package/dist/operationalization.d.ts

@@ -0,0 +1,24 @@
+export type OperationalizationTarget = 'codex' | 'claude' | 'codecode' | 'agent';
+export interface OperationalizationAction {
+    id: 'public-skills' | 'routines' | 'mcp-config' | 'source-allowlist' | 'verification';
+    title: string;
+    status: 'pending';
+    command: string;
+    why: string;
+    safety: string;
+}
+export interface OperationalizationPlan {
+    goal: string;
+    completed: string[];
+    pending: OperationalizationAction[];
+    recommendedOrder: string[];
+    safetyRules: string[];
+    completionCheck: string[];
+}
+export interface OperationalizationPlanInput {
+    target?: OperationalizationTarget;
+    dataDir?: string;
+    cwd?: string;
+    firstValueReady?: boolean;
+}
+export declare function buildOperationalizationPlan(input?: OperationalizationPlanInput): OperationalizationPlan;