@unson/brainbase-mcp 0.32.0 → 0.34.0

package/dist/ontology-publication.d.ts

@@ -0,0 +1,6 @@
+export declare const ONTOLOGY_PUBLICATION_RECEIPT_SCHEMA_VERSION = "1.0.0";
+export declare function sha256(bytes: any): string;
+export declare function canonicalize(value: any): any;
+export declare function canonicalJson(value: any): string;
+export declare function publicationReceiptContractErrors(receipt: any): string[];
+export declare function verifyPublicationReceipt(receipt: any, publicKeyPem: any): boolean;

package/dist/ontology-publication.js

@@ -0,0 +1,44 @@
+// Moved from brainbase-unson server/services/ontology-publication.js without changing behavior.
+// Only type annotations were added; values stay open JSON objects as in the original.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { createHash, verify } from 'node:crypto';
+export const ONTOLOGY_PUBLICATION_RECEIPT_SCHEMA_VERSION = '1.0.0';
+export function sha256(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+export function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+    }
+    return value;
+}
+export function canonicalJson(value) {
+    return JSON.stringify(canonicalize(value));
+}
+export function publicationReceiptContractErrors(receipt) {
+    const errors = [];
+    if (receipt?.payload?.schema_version !== ONTOLOGY_PUBLICATION_RECEIPT_SCHEMA_VERSION) {
+        errors.push('schema_version');
+    }
+    if (typeof receipt?.payload?.actor_entity_id !== 'string' || !receipt.payload.actor_entity_id.trim()) {
+        errors.push('actor_entity_id');
+    }
+    const issuedAt = receipt?.payload?.issued_at;
+    if (typeof issuedAt !== 'string'
+        || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(issuedAt)
+        || Number.isNaN(Date.parse(issuedAt))
+        || new Date(issuedAt).toISOString() !== issuedAt) {
+        errors.push('issued_at');
+    }
+    return errors;
+}
+export function verifyPublicationReceipt(receipt, publicKeyPem) {
+    if (receipt?.signature_algorithm !== 'ed25519' || !receipt?.payload || !receipt?.signature || !receipt?.key_id) {
+        return false;
+    }
+    if (publicationReceiptContractErrors(receipt).length)
+        return false;
+    return verify(null, Buffer.from(canonicalJson(receipt.payload)), publicKeyPem, Buffer.from(receipt.signature, 'base64'));
+}

package/dist/ontology-registry.d.ts

@@ -0,0 +1,32 @@
+import { OntologyKernel } from './ontology-kernel.js';
+export declare class OntologyRegistry {
+    [key: string]: any;
+    constructor({ rootDir, configDir, publicKeyPem }?: {
+        rootDir?: string | undefined;
+        configDir?: string | undefined;
+        publicKeyPem?: string | undefined;
+    });
+    hasCurrent(): boolean;
+    resolve({ version, asOf }?: any): {
+        kernel: OntologyKernel;
+        digest: string;
+        entry: any;
+        publicationVerification: {
+            status: string;
+            key_id: any;
+            signature_algorithm: any;
+            trust_source: string;
+            receipt_digest: any;
+            reason?: undefined;
+        } | {
+            status: string;
+            reason: any;
+            key_id?: undefined;
+            signature_algorithm?: undefined;
+            trust_source?: undefined;
+            receipt_digest?: undefined;
+        };
+    };
+    interpretHistory(snapshot?: any, { version, asOf }?: any): any;
+    unverifiedHistory(snapshot: any, asOf: any, reason: any): any;
+}

package/dist/ontology-registry.js

@@ -0,0 +1,202 @@
+// Moved from brainbase-unson server/services/ontology-registry.js without changing behavior.
+// Only type annotations were added; values stay open JSON objects as in the original.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { OntologyError, OntologyKernel } from './ontology-kernel.js';
+import { hasCompleteReceiptMetadata, hasReceiptMetadata, loadTrustedPublicKeys, verifyPublishedReceipt } from './ontology-release-trust.js';
+function parseJson(bytes, label) {
+    try {
+        return JSON.parse(bytes.toString('utf8'));
+    }
+    catch (error) {
+        throw new OntologyError('ONTOLOGY_MANIFEST_INVALID', `Invalid JSON in ${label}`, {
+            cause: error.message
+        });
+    }
+}
+function parseTime(value, label) {
+    const timestamp = Date.parse(value);
+    if (!Number.isFinite(timestamp)) {
+        throw new OntologyError('ONTOLOGY_MANIFEST_INVALID', `Invalid ${label}: ${value}`);
+    }
+    return timestamp;
+}
+export class OntologyRegistry {
+    constructor({ rootDir = process.cwd(), configDir = 'config/ontology', publicKeyPem = process.env.ONTOLOGY_PUBLICATION_SIGNING_PUBLIC_KEY || '' } = {}) {
+        this.configDir = path.resolve(rootDir, configDir);
+        this.releasesDir = path.resolve(this.configDir, 'releases');
+        this.publicKeyPem = publicKeyPem;
+        try {
+            this.trustedPublicKeys = loadTrustedPublicKeys(this.configDir);
+        }
+        catch (error) {
+            throw new OntologyError('ONTOLOGY_MANIFEST_INVALID', error.message);
+        }
+        this.index = parseJson(readFileSync(path.join(this.configDir, 'index.json')), 'ontology index');
+        if (!Array.isArray(this.index.releases)) {
+            throw new OntologyError('ONTOLOGY_MANIFEST_INVALID', 'Ontology index releases must be an array');
+        }
+    }
+    hasCurrent() {
+        return typeof this.index.current === 'string' && this.index.current.length > 0;
+    }
+    resolve({ version, asOf } = {}) {
+        let entry;
+        if (version) {
+            entry = this.index.releases.find((release) => release.version === version);
+        }
+        else if (asOf) {
+            const target = parseTime(asOf, 'asOf');
+            entry = this.index.releases
+                .filter((release) => (hasCompleteReceiptMetadata(release) || release.version === this.index.current)
+                && parseTime(release.effective_at, 'release effective_at') <= target)
+                .sort((left, right) => parseTime(right.effective_at, 'release effective_at') - parseTime(left.effective_at, 'release effective_at'))[0];
+        }
+        else {
+            if (!this.hasCurrent()) {
+                throw new OntologyError('ONTOLOGY_CURRENT_UNAVAILABLE', 'No current ontology release has been published');
+            }
+            entry = this.index.releases.find((release) => release.version === this.index.current);
+        }
+        if (!entry) {
+            throw new OntologyError('ONTOLOGY_VERSION_UNKNOWN', `Ontology release was not found: ${version || asOf}`, {
+                version: version || null,
+                as_of: asOf || null
+            });
+        }
+        const releasePath = path.resolve(this.configDir, entry.path);
+        const relativePath = path.relative(this.releasesDir, releasePath);
+        if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+            throw new OntologyError('ONTOLOGY_MANIFEST_INVALID', 'Ontology release path must stay inside releases/', {
+                path: entry.path
+            });
+        }
+        const bytes = readFileSync(releasePath);
+        const digest = createHash('sha256').update(bytes).digest('hex');
+        if (entry.content_digest_algorithm !== 'sha256' || digest !== entry.content_digest) {
+            throw new OntologyError('ONTOLOGY_DIGEST_MISMATCH', `Ontology release digest mismatch: ${entry.version}`, {
+                version: entry.version,
+                expected: entry.content_digest,
+                actual: digest
+            });
+        }
+        const manifest = parseJson(bytes, `ontology release ${entry.version}`);
+        if (manifest.version !== entry.version || manifest.effective_at !== entry.effective_at) {
+            throw new OntologyError('ONTOLOGY_MANIFEST_INVALID', 'Ontology index metadata does not match release manifest', {
+                index_version: entry.version,
+                manifest_version: manifest.version,
+                index_effective_at: entry.effective_at,
+                manifest_effective_at: manifest.effective_at
+            });
+        }
+        const receiptTrust = verifyPublishedReceipt({
+            configDir: this.configDir,
+            entry,
+            manifest,
+            publicKeyPem: this.publicKeyPem,
+            trustedPublicKeys: this.trustedPublicKeys
+        });
+        const claimsPublication = this.index.current === entry.version
+            || entry.status === 'retired'
+            || hasReceiptMetadata(entry);
+        if (claimsPublication && !receiptTrust.verified) {
+            throw new OntologyError('ONTOLOGY_PUBLICATION_UNVERIFIED', `Ontology publication receipt is not trusted: ${entry.version}`, {
+                http_status: 503,
+                version: entry.version,
+                reason: receiptTrust.reason,
+                ...receiptTrust.details
+            });
+        }
+        const effectiveStatus = receiptTrust.verified && this.index.current === entry.version
+            ? 'active'
+            : receiptTrust.verified && entry.status === 'retired'
+                ? 'retired'
+                : receiptTrust.verified
+                    ? 'approved'
+                    : 'proposed';
+        return {
+            kernel: new OntologyKernel({ manifest, status: effectiveStatus }),
+            digest,
+            entry: structuredClone(entry),
+            publicationVerification: receiptTrust.verified
+                ? {
+                    status: 'verified',
+                    key_id: receiptTrust.receipt.key_id,
+                    signature_algorithm: receiptTrust.receipt.signature_algorithm,
+                    trust_source: this.publicKeyPem ? 'environment_override' : 'git_trust_store',
+                    receipt_digest: receiptTrust.receipt_digest
+                }
+                : { status: 'unverified', reason: receiptTrust.reason }
+        };
+    }
+    interpretHistory(snapshot = {}, { version, asOf } = {}) {
+        const recordedVersion = snapshot.ontology_version || null;
+        if (version && recordedVersion && version !== recordedVersion) {
+            throw new OntologyError('ONTOLOGY_HISTORY_VERSION_MISMATCH', 'Requested ontology version does not match the recorded fact version', {
+                requested_version: version,
+                recorded_version: recordedVersion
+            });
+        }
+        let release;
+        try {
+            if (version || recordedVersion) {
+                release = this.resolve({ version: version || recordedVersion });
+            }
+            else if (asOf) {
+                release = this.resolve({ asOf });
+            }
+            else {
+                return this.unverifiedHistory(snapshot, asOf, {
+                    code: 'ONTOLOGY_HISTORY_VERSION_UNRESOLVED',
+                    message: 'Historical interpretation requires a recorded ontology version or resolvable as-of time'
+                });
+            }
+        }
+        catch (error) {
+            if (!version && !recordedVersion && error instanceof OntologyError
+                && ['ONTOLOGY_VERSION_UNKNOWN', 'ONTOLOGY_CURRENT_UNAVAILABLE', 'ONTOLOGY_PUBLICATION_UNVERIFIED'].includes(error.code)) {
+                return this.unverifiedHistory(snapshot, asOf, {
+                    code: error.code,
+                    message: error.message
+                });
+            }
+            throw error;
+        }
+        if (release.kernel.status === 'proposed') {
+            return this.unverifiedHistory(snapshot, asOf, {
+                code: 'ONTOLOGY_PUBLICATION_UNVERIFIED',
+                message: `Ontology release has not been published: ${release.entry.version}`
+            });
+        }
+        const resolvedVersion = release.entry.version;
+        const mismatchedEvents = (snapshot.evolution_events || [])
+            .filter((event) => event.ontology_version && event.ontology_version !== resolvedVersion)
+            .map((event) => event.event_id);
+        if (mismatchedEvents.length) {
+            throw new OntologyError('ONTOLOGY_HISTORY_VERSION_MISMATCH', 'Evolution events must use the recorded fact ontology version', {
+                recorded_version: recordedVersion,
+                resolved_version: resolvedVersion,
+                event_ids: mismatchedEvents
+            });
+        }
+        return {
+            ...release.kernel.interpretHistory(snapshot, { asOf }),
+            recorded_ontology_version: recordedVersion,
+            resolved_ontology_version: resolvedVersion,
+            verification: 'verified'
+        };
+    }
+    unverifiedHistory(snapshot, asOf, reason) {
+        return {
+            ...structuredClone(snapshot),
+            ontology_version: null,
+            recorded_ontology_version: snapshot.ontology_version || null,
+            resolved_ontology_version: null,
+            interpretation_as_of: asOf || null,
+            verification: 'unverified',
+            unverified_reason: reason
+        };
+    }
+}

package/dist/ontology-release-trust.d.ts

@@ -0,0 +1,4 @@
+export declare function hasReceiptMetadata(entry?: any): boolean;
+export declare function hasCompleteReceiptMetadata(entry?: any): boolean;
+export declare function loadTrustedPublicKeys(configDir: any): any;
+export declare function verifyPublishedReceipt({ configDir, entry, manifest, publicKeyPem, trustedPublicKeys }: any): any;

package/dist/ontology-release-trust.js

@@ -0,0 +1,121 @@
+// Moved from brainbase-unson server/services/ontology-release-trust.js without changing behavior.
+// Only type annotations were added; values stay open JSON objects as in the original.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { canonicalJson, publicationReceiptContractErrors, sha256, verifyPublicationReceipt } from './ontology-publication.js';
+const SHA256_DIGEST = /^[a-f0-9]{64}$/;
+const RECEIPT_FIELDS = ['receipt_path', 'receipt_digest_algorithm', 'receipt_digest'];
+export function hasReceiptMetadata(entry = {}) {
+    return RECEIPT_FIELDS.some((field) => Object.prototype.hasOwnProperty.call(entry, field));
+}
+export function hasCompleteReceiptMetadata(entry = {}) {
+    return typeof entry.receipt_path === 'string'
+        && entry.receipt_path.trim().length > 0
+        && entry.receipt_digest_algorithm === 'sha256'
+        && typeof entry.receipt_digest === 'string'
+        && SHA256_DIGEST.test(entry.receipt_digest);
+}
+function invalid(reason, details = {}) {
+    return { verified: false, reason, details };
+}
+function isContained(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+export function loadTrustedPublicKeys(configDir) {
+    const trustStorePath = path.join(configDir, 'trusted-public-keys.json');
+    if (!existsSync(trustStorePath))
+        return {};
+    const trustStore = JSON.parse(readFileSync(trustStorePath, 'utf8'));
+    if (trustStore.schema_version !== '1.0.0'
+        || !trustStore.keys
+        || Array.isArray(trustStore.keys)
+        || typeof trustStore.keys !== 'object') {
+        throw new Error('Ontology trusted public keys must use the 1.0.0 key map schema');
+    }
+    for (const [keyId, key] of Object.entries(trustStore.keys)) {
+        if (!keyId
+            || key?.algorithm !== 'ed25519'
+            || typeof key.public_key_pem !== 'string'
+            || !key.public_key_pem.includes('-----BEGIN PUBLIC KEY-----')) {
+            throw new Error(`Invalid ontology trusted public key: ${keyId || '<empty>'}`);
+        }
+    }
+    return trustStore.keys;
+}
+export function verifyPublishedReceipt({ configDir, entry = {}, manifest, publicKeyPem = '', trustedPublicKeys = {} }) {
+    if (!hasCompleteReceiptMetadata(entry)) {
+        return invalid(hasReceiptMetadata(entry) ? 'incomplete_metadata' : 'missing_metadata');
+    }
+    const publicationsDir = path.resolve(configDir, 'publications');
+    const receiptPath = path.resolve(configDir, entry.receipt_path);
+    if (!isContained(publicationsDir, receiptPath)) {
+        return invalid('path_escape');
+    }
+    let realPublicationsDir;
+    let realReceiptPath;
+    let receiptBytes;
+    try {
+        realPublicationsDir = realpathSync(publicationsDir);
+        realReceiptPath = realpathSync(receiptPath);
+        if (!isContained(realPublicationsDir, realReceiptPath) || !statSync(realReceiptPath).isFile()) {
+            return invalid('path_escape_or_not_file');
+        }
+        receiptBytes = readFileSync(realReceiptPath);
+    }
+    catch {
+        return invalid('receipt_unavailable');
+    }
+    const actualDigest = sha256(receiptBytes);
+    if (actualDigest !== entry.receipt_digest) {
+        return invalid('digest_mismatch', { expected: entry.receipt_digest, actual: actualDigest });
+    }
+    let receipt;
+    try {
+        receipt = JSON.parse(receiptBytes.toString('utf8'));
+    }
+    catch {
+        return invalid('invalid_json');
+    }
+    const contractErrors = publicationReceiptContractErrors(receipt);
+    if (contractErrors.length) {
+        return invalid('contract_mismatch', { fields: contractErrors });
+    }
+    const trustedPublicKeyPem = publicKeyPem || trustedPublicKeys[receipt.key_id]?.public_key_pem || '';
+    if (!trustedPublicKeyPem) {
+        return invalid('public_key_unavailable');
+    }
+    try {
+        if (!verifyPublicationReceipt(receipt, trustedPublicKeyPem)) {
+            return invalid('signature_invalid');
+        }
+    }
+    catch {
+        return invalid('signature_invalid');
+    }
+    const governance = manifest?.governance || {};
+    const expectedBindings = {
+        release_version: entry.version,
+        release_digest: entry.content_digest,
+        source_commit_sha: entry.source_commit_sha,
+        decision_id: governance.decision_id,
+        scope_entity_id: governance.scope_entity_id,
+        proposer_entity_id: governance.proposer_entity_id,
+        decider_entity_id: governance.decider_entity_id,
+        applier_entity_id: governance.applier_entity_id,
+        actor_entity_id: governance.applier_entity_id
+    };
+    const mismatches = Object.entries(expectedBindings)
+        .filter(([key, value]) => !value || receipt.payload?.[key] !== value)
+        .map(([key]) => key);
+    const manifestImpactScope = canonicalJson(manifest?.impact_scope);
+    if (canonicalJson(receipt.payload?.impact_scope) !== manifestImpactScope
+        || (entry.impact_scope && canonicalJson(entry.impact_scope) !== manifestImpactScope)) {
+        mismatches.push('impact_scope');
+    }
+    if (mismatches.length) {
+        return invalid('binding_mismatch', { fields: mismatches });
+    }
+    return { verified: true, receipt, receipt_path: realReceiptPath, receipt_digest: actualDigest };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "description": "Local-first Brainbase judgment OS that lets supported AI agents reuse a user's approved goals, priorities, decisions, and judgment criteria.",
   "type": "module",
   "license": "MIT",
@@ -187,6 +187,30 @@
       "types": "./dist/judgment-resolution-contract.d.ts",
       "import": "./dist/judgment-resolution-contract.js"
     },
+    "./graph-maintenance-engine": {
+      "types": "./dist/graph-maintenance-engine.d.ts",
+      "import": "./dist/graph-maintenance-engine.js"
+    },
+    "./memory-scope-policy": {
+      "types": "./dist/memory-scope-policy.d.ts",
+      "import": "./dist/memory-scope-policy.js"
+    },
+    "./ontology-kernel": {
+      "types": "./dist/ontology-kernel.d.ts",
+      "import": "./dist/ontology-kernel.js"
+    },
+    "./ontology-registry": {
+      "types": "./dist/ontology-registry.d.ts",
+      "import": "./dist/ontology-registry.js"
+    },
+    "./ontology-publication": {
+      "types": "./dist/ontology-publication.d.ts",
+      "import": "./dist/ontology-publication.js"
+    },
+    "./ontology-release-trust": {
+      "types": "./dist/ontology-release-trust.d.ts",
+      "import": "./dist/ontology-release-trust.js"
+    },
     "./canonical-document-writer": {
       "types": "./dist/canonical-document-writer.d.ts",
       "import": "./dist/canonical-document-writer.js"
@@ -455,5 +479,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "3f91401cb7221305fe1dfafc6126482bc8b55170"
+  "gitHead": "9275d1ad54f053c85229a44b1c4cba811969cd29"
 }

package/ui/world/world-view.js

@@ -1514,6 +1514,27 @@ function memoryLines(answer) {
   return lines;
 }
 
+/** At most this many waiting judgments are listed in the world; the rest are counted, never hidden. */
+const WAITING_LIST_LIMIT = 3;
+
+/**
+ * The judgments waiting for the owner now, newest first, each a way down to the same judgment in
+ * 判断の履歴 (ledger P17 / U2).  The world stays an overview: only the exceptions become a short list.
+ */
+function waitingLines(proofs, judgmentHref) {
+  const waiting = [...proofs.values()]
+    .filter(isWaiting)
+    .sort((a, b) => String(b.proof?.recorded_at ?? '').localeCompare(String(a.proof?.recorded_at ?? '')));
+  const lines = waiting.slice(0, WAITING_LIST_LIMIT).map((item) => {
+    const id = item.proof.decision_attempt_id;
+    const question = item.proof.interruption?.question_display_text ?? item.proof.decision?.summary ?? id;
+    return { text: question, summary: question, link: { href: judgmentHref(id), label: '「判断の履歴」で開く', className: 'bb-world-waiting-link' } };
+  });
+  const rest = waiting.length - lines.length;
+  if (rest > 0) lines.push({ text: `ほか${rest}件は「判断の履歴」で見られます。`, summary: `ほか${rest}件の待っている判断`, link: null });
+  return lines;
+}
+
 /** 判断の履歴 in the local web (it was 今日, `#today`, until 2026-10-11; the shell still opens old links). */
 function defaultJudgmentHref(decisionAttemptId) {
   return decisionAttemptId ? `#value-proofs?decision=${encodeURIComponent(decisionAttemptId)}` : '#value-proofs';
@@ -2439,6 +2460,9 @@ export function createWorldView({ root, rail, page, presentation = 'standard', d
         note('判断', `${home.delegation_map.judged}件。作業した場所を読めないため、事業には置かず広場の種類別だけで描いています（${placesResult.ok ? placesResult.data?.reason ?? '理由不明' : placesResult.error}）。今あなたを待っている判断${waiting}件。`, 'warning', '判断の作業場所：読めない');
       }
     }
+    if (judgmentsConnected) {
+      for (const line of waitingLines(proofs, judgmentHref)) note('待っている判断', line.text, 'attention', line.summary, line.link);
+    }
     const rowItems = new Map(rows.map((row) => [row.key, Array.isArray(row.items) ? row.items : []]));
     const memory = await memoryRead;
     if (disposed) return;