@unson/brainbase-mcp 0.7.0 → 0.8.0

package/dist/world-model.d.ts

@@ -40,7 +40,7 @@ export interface WorldModelObservation extends WorldModelObservationInput {
     readonly sourceRef: FoundationProvenance;
     readonly supersedes?: string;
 }
-export type WorldModelValidationIssueCode = 'MISSING_FIELD' | 'INVALID_FIELD' | 'INVALID_TIMESTAMP' | 'INVALID_PERIOD' | 'INVALID_VARIABLE_REFERENCE' | 'VARIABLE_VALUE_KIND_MISMATCH' | 'OBSERVATION_SCOPE_MISMATCH' | 'OBSERVATION_PERIOD_MISMATCH' | 'RECORDED_BEFORE_OCCURRED' | 'INVALID_CORRECTION_REFERENCE' | 'MISSING_SOURCE' | 'MODEL_CONTRACT_INVALID';
+export type WorldModelValidationIssueCode = 'MISSING_FIELD' | 'INVALID_FIELD' | 'INVALID_TIMESTAMP' | 'INVALID_PERIOD' | 'INVALID_VARIABLE_REFERENCE' | 'VARIABLE_VALUE_KIND_MISMATCH' | 'OBSERVATION_SCOPE_MISMATCH' | 'OBSERVATION_PERIOD_MISMATCH' | 'RECORDED_BEFORE_OCCURRED' | 'INVALID_CORRECTION_REFERENCE' | 'MISSING_SOURCE' | 'MODEL_CONTRACT_INVALID' | 'MISSING_APPROVAL_REFERENCE' | 'INVALID_APPROVAL_REFERENCE' | 'MODEL_DIGEST_MISMATCH';
 export interface WorldModelValidationIssue {
     readonly code: WorldModelValidationIssueCode;
     readonly path: string;
@@ -70,14 +70,17 @@ export interface ModelAdoptionInput {
     readonly adoptionState: Extract<FoundationAdoptionState, 'proposed' | 'approved'>;
     readonly authorizedUse: FoundationUse;
     readonly adoptedAt: string;
+    /** Digest of the exact Model definition used for this adoption. */
+    readonly modelDigest?: string;
     readonly approvalRef?: DecisionRevision;
 }
-export interface ModelAdoptionRecord extends ModelAdoptionInput {
+export interface ModelAdoptionRecord extends Omit<ModelAdoptionInput, 'modelDigest'> {
     readonly modelRef: FoundationRevision;
     readonly candidate: CandidateModelSnapshot;
     readonly adoptionState: Extract<FoundationAdoptionState, 'proposed' | 'approved'>;
     readonly authorizedUse: FoundationUse;
     readonly adoptedAt: string;
+    readonly modelDigest: string;
     readonly approvalRef?: DecisionRevision;
 }
 /**
@@ -113,13 +116,27 @@ export interface WorldModelFoundationStore {
     }>;
     read(reference: FoundationRevision, context: WorldModelStoreContext): Promise<WorldModelFoundationRecord | null>;
 }
+/**
+ * Approval resolution is the world-model adapter for the existing
+ * constraint-resolution DecisionRevisionReader contract. The adapter must
+ * resolve the exact decision revision, verify that it actually approves the
+ * exact Model revision, and enforce the current authorization boundary. A
+ * mere decision-existence check is not sufficient to return true here.
+ */
+export interface WorldModelApprovalReader {
+    isApproved(request: {
+        readonly approvalRef: DecisionRevision;
+        readonly modelRef: FoundationRevision;
+        readonly context: WorldModelStoreContext;
+    }): Promise<boolean>;
+}
 export interface WorldModelObservationQuery {
     readonly variableRef?: FoundationRevision;
     readonly subjectId?: string;
     readonly supersedes?: string;
 }
 export type ModelAdoptionStoreInput = Omit<ModelAdoptionInput, 'candidate' | 'modelRef'>;
-export type WorldModelStoreErrorCode = 'invalid_input' | 'not_found' | 'revision_conflict' | 'authorization_denied' | 'unsupported_graph' | 'corrupt_record' | 'readback_mismatch';
+export type WorldModelStoreErrorCode = 'invalid_input' | 'not_found' | 'revision_conflict' | 'authorization_denied' | 'unsupported_graph' | 'corrupt_record' | 'readback_mismatch' | 'approval_reference_unresolved';
 export declare class WorldModelStoreError extends Error {
     readonly code: WorldModelStoreErrorCode;
     constructor(code: WorldModelStoreErrorCode, message: string);
@@ -178,4 +195,5 @@ export declare function retainCandidateModel(candidate: CandidateModelSnapshot,
 export declare function createWorldModelStore(options: {
     dataDir: string;
     foundationStore: WorldModelFoundationStore;
+    approvalReader?: WorldModelApprovalReader;
 }): WorldModelRecordStore;

package/dist/world-model.js

@@ -1,5 +1,5 @@
 import { validateFoundationDefinition } from './ontology-foundation.js';
-import { findFoundationRecord, findLatestFoundationRecord, foundationCatalogOrEmpty } from './foundation-catalog.js';
+import { digestFoundationDefinition, findFoundationRecord, findLatestFoundationRecord, foundationCatalogOrEmpty } from './foundation-catalog.js';
 import { loadPersonalOs, mutatePersonalOsWithSidecar, readPersonalOsSidecar } from './ssot.js';
 /**
  * The world-model helpers are deliberately independent of storage.  Definitions
@@ -115,6 +115,16 @@ export function validateWorldModelModel(model, use = 'judgment') {
  */
 export function retainCandidateModel(candidate, model, adoption) {
     const issues = [];
+    if (!isNonEmptyString(adoption.adoptionId))
+        issues.push(missing('adoptionId'));
+    if (!['proposed', 'approved'].includes(String(adoption.adoptionState))) {
+        issues.push({ code: 'INVALID_FIELD', path: 'adoptionState', message: 'Adoption state must be proposed or approved.' });
+    }
+    if (!isFoundationUse(adoption.authorizedUse)) {
+        issues.push({ code: 'INVALID_FIELD', path: 'authorizedUse', message: 'Adoption authorizedUse must be a valid Foundation use.' });
+    }
+    if (!isIsoTimestamp(adoption.adoptedAt))
+        issues.push(invalidTimestamp('adoptedAt'));
     if (!candidate.candidateId.trim())
         issues.push(missing('candidate.candidateId'));
     if (!candidate.hypothesis.trim())
@@ -159,6 +169,29 @@ export function retainCandidateModel(candidate, model, adoption) {
             message: `Adoption modelRef must match ${model.id}@${model.revision}.`
         });
     }
+    if (adoption.approvalRef !== undefined && !isDecisionRevision(adoption.approvalRef)) {
+        issues.push({
+            code: 'INVALID_APPROVAL_REFERENCE',
+            path: 'approvalRef',
+            message: 'approvalRef must contain a decision id and positive revision.'
+        });
+    }
+    if (adoption.adoptionState === 'approved' && !isDecisionRevision(adoption.approvalRef)) {
+        issues.push({
+            code: adoption.approvalRef === undefined ? 'MISSING_APPROVAL_REFERENCE' : 'INVALID_APPROVAL_REFERENCE',
+            path: 'approvalRef',
+            message: 'Approved adoption requires a valid approvalRef decision revision.'
+        });
+    }
+    const canonicalModelDigest = digestFoundationDefinition(model);
+    if (adoption.modelDigest !== undefined
+        && (!isDigest(adoption.modelDigest) || adoption.modelDigest !== canonicalModelDigest)) {
+        issues.push({
+            code: 'MODEL_DIGEST_MISMATCH',
+            path: 'modelDigest',
+            message: 'modelDigest must match the canonical digest of the adopted Model definition.'
+        });
+    }
     if (issues.length > 0)
         throw new WorldModelValidationError(issues);
     const modelRef = freezeCloneRevision(adoption.modelRef ?? {
@@ -180,12 +213,9 @@ export function retainCandidateModel(candidate, model, adoption) {
         adoptionState: adoption.adoptionState,
         authorizedUse: adoption.authorizedUse,
         adoptedAt: adoption.adoptedAt,
+        modelDigest: canonicalModelDigest,
         ...(adoption.approvalRef === undefined ? {} : { approvalRef: freezeCloneDecisionRevision(adoption.approvalRef) })
     };
-    if (!record.adoptionId)
-        throw new WorldModelValidationError([missing('adoptionId')]);
-    if (!parseIsoTimestamp(record.adoptedAt))
-        throw new WorldModelValidationError([invalidTimestamp('adoptedAt')]);
     return deepFreeze(record);
 }
 /**
@@ -202,14 +232,19 @@ export function createWorldModelStore(options) {
         || typeof options.foundationStore.create !== 'function') {
         throw new WorldModelStoreError('invalid_input', 'foundationStore with create/read is required');
     }
-    return new GraphWorldModelRecordStore(options.dataDir, options.foundationStore);
+    if (options.approvalReader !== undefined && typeof options.approvalReader.isApproved !== 'function') {
+        throw new WorldModelStoreError('invalid_input', 'approvalReader.isApproved is required when approvalReader is provided');
+    }
+    return new GraphWorldModelRecordStore(options.dataDir, options.foundationStore, options.approvalReader);
 }
 class GraphWorldModelRecordStore {
     dataDir;
     foundationStore;
-    constructor(dataDir, foundationStore) {
+    approvalReader;
+    constructor(dataDir, foundationStore, approvalReader) {
         this.dataDir = dataDir;
         this.foundationStore = foundationStore;
+        this.approvalReader = approvalReader;
     }
     async createVariable(variable, context) {
         assertStoreContext(context);
@@ -320,18 +355,22 @@ class GraphWorldModelRecordStore {
         assertFoundationAclWrite(modelRecord.definition, context.principal);
         assertCandidateAclWrite(candidate, context.principal);
         let record;
-        await this.mutateCatalog((catalog, current) => {
+        await this.mutateCatalog(async (catalog, current) => {
             const currentModel = resolveFoundationAtAggregate(current, modelRef, modelRecord, context.principal, 'write');
             if (currentModel.definition.type !== 'model') {
                 throw new WorldModelStoreError('corrupt_record', `Model ${modelRef.id} changed type during commit`);
             }
             assertFoundationAclWrite(currentModel.definition, context.principal);
             assertCandidateAclWrite(candidate, context.principal);
+            if (catalog.adoptions.some((existing) => existing.adoptionId === adoption.adoptionId)) {
+                throw new WorldModelStoreError('revision_conflict', `Model adoption ${adoption.adoptionId} already exists`);
+            }
+            // Resolve approval while the SSOT mutation lock is held and before the
+            // sidecar is returned for commit. A post-commit approval read could
+            // fail after the approved record was already persisted.
+            await this.assertApprovalReference(modelRef, adoption, context);
             const retained = retainCandidateModel(candidate, currentModel.definition, { ...adoption, modelRef });
             record = retained;
-            if (catalog.adoptions.some((existing) => existing.adoptionId === retained.adoptionId)) {
-                throw new WorldModelStoreError('revision_conflict', `Model adoption ${retained.adoptionId} already exists`);
-            }
             return {
                 ...catalog,
                 adoptions: [...catalog.adoptions, retained]
@@ -339,12 +378,18 @@ class GraphWorldModelRecordStore {
         });
         if (!record)
             throw new WorldModelStoreError('readback_mismatch', 'Model adoption commit did not produce a record');
-        const readback = await this.readModelAdoption(record.adoptionId, context);
+        // Approval was checked before the atomic append. This structural readback
+        // deliberately avoids a second provider call that could report failure
+        // while leaving the successful commit in place.
+        const readback = await this.readModelAdoptionRecord(record.adoptionId, context, { verifyApproval: false });
         if (!readback)
             throw new WorldModelStoreError('readback_mismatch', `Model adoption ${record.adoptionId} was not readable after commit`);
         return readback;
     }
     async readModelAdoption(adoptionId, context) {
+        return this.readModelAdoptionRecord(adoptionId, context, { verifyApproval: true });
+    }
+    async readModelAdoptionRecord(adoptionId, context, options) {
         assertStoreContext(context);
         if (!isNonEmptyString(adoptionId))
             throw new WorldModelStoreError('invalid_input', 'adoptionId is required');
@@ -358,12 +403,18 @@ class GraphWorldModelRecordStore {
             throw new WorldModelStoreError('corrupt_record', `Model for adoption ${adoptionId} is missing`);
         }
         assertFoundationAclRead(modelRecord.definition, context.principal);
+        if (options.verifyApproval)
+            await this.assertApprovalReference(record.modelRef, record, context);
+        if (record.modelDigest !== modelRecord.digest) {
+            throw new WorldModelStoreError('readback_mismatch', `Model adoption ${adoptionId} digest does not match ${record.modelRef.id}@${record.modelRef.revision}`);
+        }
         const verified = retainCandidateModel(record.candidate, modelRecord.definition, {
             adoptionId: record.adoptionId,
             adoptionState: record.adoptionState,
             authorizedUse: record.authorizedUse,
             adoptedAt: record.adoptedAt,
             modelRef: record.modelRef,
+            modelDigest: record.modelDigest,
             ...(record.approvalRef === undefined ? {} : { approvalRef: record.approvalRef })
         });
         return verified;
@@ -396,6 +447,30 @@ class GraphWorldModelRecordStore {
             throw new WorldModelStoreError('corrupt_record', formatError(error));
         }
     }
+    async assertApprovalReference(modelRef, adoption, context) {
+        if (adoption.adoptionState !== 'approved')
+            return;
+        if (!isDecisionRevision(adoption.approvalRef)) {
+            throw new WorldModelStoreError('approval_reference_unresolved', 'Approved model adoption requires a valid approvalRef decision revision');
+        }
+        if (!this.approvalReader) {
+            throw new WorldModelStoreError('approval_reference_unresolved', 'Approved model adoption requires an approval reader that verifies the decision binding');
+        }
+        let approved = false;
+        try {
+            approved = await this.approvalReader.isApproved({
+                approvalRef: adoption.approvalRef,
+                modelRef,
+                context
+            });
+        }
+        catch {
+            approved = false;
+        }
+        if (!approved) {
+            throw new WorldModelStoreError('approval_reference_unresolved', `Approval ${adoption.approvalRef.id}@${adoption.approvalRef.revision} does not approve Model ${modelRef.id}@${modelRef.revision}`);
+        }
+    }
     async mutateCatalog(mutator) {
         await mutatePersonalOsWithSidecar(this.dataDir, WORLD_MODEL_EVIDENCE_SIDECAR, async (current, existingContent) => {
             if (current.graph.version !== 2) {
@@ -591,6 +666,7 @@ function normalizeStoredAdoption(value) {
     if (!isRecord(value)
         || !isNonEmptyString(value.adoptionId)
         || !isVariableOrModelRevision(value.modelRef, 'model')
+        || !isDigest(value.modelDigest)
         || !isRecord(value.candidate)
         || !isNonEmptyString(value.candidate.candidateId)
         || !isNonEmptyString(value.candidate.hypothesis)
@@ -602,6 +678,7 @@ function normalizeStoredAdoption(value) {
         || !['proposed', 'approved'].includes(String(value.adoptionState))
         || !isFoundationUse(String(value.authorizedUse))
         || !isIsoTimestamp(value.adoptedAt)
+        || (value.adoptionState === 'approved' && !isDecisionRevision(value.approvalRef))
         || (value.approvalRef !== undefined && !isDecisionRevision(value.approvalRef))) {
         throw new WorldModelStoreError('corrupt_record', 'world-model adoption record is malformed');
     }
@@ -619,6 +696,7 @@ function normalizeStoredAdoption(value) {
         adoptionState: value.adoptionState,
         authorizedUse: value.authorizedUse,
         adoptedAt: String(value.adoptedAt),
+        modelDigest: String(value.modelDigest),
         ...(value.approvalRef === undefined ? {} : { approvalRef: freezeCloneDecisionRevision(value.approvalRef) })
     });
 }
@@ -631,6 +709,9 @@ function isDecisionRevision(value) {
         && isNonEmptyString(value.id)
         && /^[1-9]\d*$/.test(String(value.revision));
 }
+function isDigest(value) {
+    return typeof value === 'string' && /^sha256:[0-9a-f]{64}$/.test(value);
+}
 function isCandidateAcl(value) {
     return isRecord(value)
         && isNonEmptyString(value.ownerId)
@@ -667,6 +748,7 @@ function freezeAdoption(adoption) {
         adoptionState: adoption.adoptionState,
         authorizedUse: adoption.authorizedUse,
         adoptedAt: adoption.adoptedAt,
+        modelDigest: adoption.modelDigest,
         ...(adoption.approvalRef === undefined ? {} : { approvalRef: freezeCloneDecisionRevision(adoption.approvalRef) })
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.7.0",
+  "version": "0.8.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",
@@ -31,10 +31,46 @@
       "types": "./dist/judgment-value-proof.d.ts",
       "import": "./dist/judgment-value-proof.js"
     },
+    "./judgment-value-proof-review": {
+      "types": "./dist/judgment-value-proof-review.d.ts",
+      "import": "./dist/judgment-value-proof-review.js"
+    },
+    "./value-proof-review-http": {
+      "types": "./dist/value-proof-review-http.d.ts",
+      "import": "./dist/value-proof-review-http.js"
+    },
+    "./local-web-host": {
+      "types": "./dist/local-web-host.d.ts",
+      "import": "./dist/local-web-host.js"
+    },
+    "./graph-corrections": {
+      "types": "./dist/graph-corrections.d.ts",
+      "import": "./dist/graph-corrections.js"
+    },
+    "./graph-web": {
+      "types": "./dist/graph-web.d.ts",
+      "import": "./dist/graph-web.js"
+    },
+    "./graph-web-http": {
+      "types": "./dist/graph-web-http.d.ts",
+      "import": "./dist/graph-web-http.js"
+    },
     "./portable-graph": {
       "types": "./dist/portable-graph.d.ts",
       "import": "./dist/portable-graph.js"
     },
+    "./canonical-graph": {
+      "types": "./dist/canonical-graph.d.ts",
+      "import": "./dist/canonical-graph.js"
+    },
+    "./embedding-provider": {
+      "types": "./dist/embedding-provider.d.ts",
+      "import": "./dist/embedding-provider.js"
+    },
+    "./graph-revision-reader": {
+      "types": "./dist/graph-revision-reader.d.ts",
+      "import": "./dist/graph-revision-reader.js"
+    },
     "./canonical-task-principal": {
       "types": "./dist/canonical-task-principal.d.ts",
       "import": "./dist/canonical-task-principal.js"
@@ -55,6 +91,10 @@
       "types": "./dist/foundation-store.d.ts",
       "import": "./dist/foundation-store.js"
     },
+    "./foundation-graph-write": {
+      "types": "./dist/foundation-graph-write.d.ts",
+      "import": "./dist/foundation-graph-write.js"
+    },
     "./company-os-objectives": {
       "types": "./dist/company-os-objectives.d.ts",
       "import": "./dist/company-os-objectives.js"
@@ -83,6 +123,10 @@
       "types": "./dist/foundation-http.d.ts",
       "import": "./dist/foundation-http.js"
     },
+    "./foundation-graph-http": {
+      "types": "./dist/foundation-graph-http.d.ts",
+      "import": "./dist/foundation-graph-http.js"
+    },
     "./constraint-exception-store": {
       "types": "./dist/constraint-exception-store.d.ts",
       "import": "./dist/constraint-exception-store.js"
@@ -155,6 +199,23 @@
     "./ui/judgment-view.css": "./ui/judgment-view.css",
     "./ui/objective-editor": "./ui/objective-editor.js",
     "./ui/objective-editor.css": "./ui/objective-editor.css",
+    "./ui/value-proof-review": "./ui/value-proof-review.js",
+    "./ui/value-proof-review.css": "./ui/value-proof-review.css",
+    "./ui/objective-editor-http-port": "./ui/objective-editor-http-port.js",
+    "./ui/world-model-view": "./ui/world-model-view.js",
+    "./ui/world-model-view.css": "./ui/world-model-view.css",
+    "./ui/local-web-shell": "./ui/local-web-shell.js",
+    "./ui/local-web-shell.css": "./ui/local-web-shell.css",
+    "./ui/workspace-kit": "./ui/workspace-kit.js",
+    "./ui/workspace-kit.css": "./ui/workspace-kit.css",
+    "./ui/graph-view-shared": "./ui/graph-view-shared.js",
+    "./ui/graph-view-shared.css": "./ui/graph-view-shared.css",
+    "./ui/graph-own-share": "./ui/graph-own-share.js",
+    "./ui/graph-projects-view": "./ui/graph-projects-view.js",
+    "./ui/graph-projects-view.css": "./ui/graph-projects-view.css",
+    "./ui/graph-registry-view": "./ui/graph-registry-view.js",
+    "./ui/graph-registry-view.css": "./ui/graph-registry-view.css",
+    "./ui/brainbase-tokens.css": "./ui/brainbase-tokens.css",
     "./ui/icons/*": "./ui/icons/*",
     "./dist/*": "./dist/*",
     "./contracts/judgment-dag/schema.json": "./contracts/judgment-dag/schema.json",
@@ -175,7 +236,36 @@
     "./execution-authority": {
       "types": "./dist/execution-authority.d.ts",
       "import": "./dist/execution-authority.js"
-    }
+    },
+    "./knowledge-continuation": {
+      "types": "./dist/knowledge-continuation.d.ts",
+      "import": "./dist/knowledge-continuation.js"
+    },
+    "./knowledge-lookup": {
+      "types": "./dist/knowledge-lookup.d.ts",
+      "import": "./dist/knowledge-lookup.js"
+    },
+    "./foundation-public-provider": {
+      "types": "./dist/foundation-public-provider.d.ts",
+      "import": "./dist/foundation-public-provider.js"
+    },
+    "./foundation-authenticated-tools": {
+      "types": "./dist/foundation-authenticated-tools.d.ts",
+      "import": "./dist/foundation-authenticated-tools.js"
+    },
+    "./philosophy-revision-reader": {
+      "types": "./dist/philosophy-revision-reader.d.ts",
+      "import": "./dist/philosophy-revision-reader.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./graph-foundation-reader": {
+      "types": "./dist/graph-foundation-reader.d.ts",
+      "import": "./dist/graph-foundation-reader.js"
+    },
+    "./contracts/foundation/graph-history.sql": "./contracts/foundation/graph-history.sql"
   },
   "bin": {
     "brainbase-mcp": "dist/index.js",
@@ -231,6 +321,7 @@
     "ip-address": "^10.4.0"
   },
   "devDependencies": {
+    "@electric-sql/pglite": "^0.5.8",
     "@types/node": "^22.15.29",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
@@ -240,5 +331,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "38ce235f75694101c64bb32c0ea830f187ae5d1e"
+  "gitHead": "3313189aecafbc086d33dc1ef20a7fe9f70bb54e"
 }

package/ui/brainbase-tokens.css

@@ -0,0 +1,56 @@
+/*
+ * Brainbase shared visual tokens (color, type, radius, spacing, rail).
+ * Common UI parts and hosts read only these names so that the personal and
+ * organization editions look the same. The values are the organization
+ * edition's design (brainbase-organization apps/web/public/styles.css, final
+ * :root layer and the outcome workspace rules), which is the visual source of
+ * truth for every Brainbase Web surface.
+ */
+:root {
+  --bb-color-ink: #1e2822;
+  --bb-color-muted: #69746d;
+  --bb-color-quiet: #929b95;
+  --bb-color-border: #dce3dd;
+  --bb-color-border-strong: #b7c3ba;
+  --bb-color-control-border: #cbd8d0;
+  --bb-color-paper: #fbfcfa;
+  --bb-color-canvas: #f1f3f0;
+  --bb-color-panel: #ffffff;
+  --bb-color-surface: #f5f8f5;
+  --bb-color-header-start: #f7faf8;
+  --bb-color-header-end: #eef5f0;
+  --bb-color-eyebrow: #47715a;
+  --bb-color-accent: #087d62;
+  --bb-color-accent-soft: #e6f2ec;
+  --bb-color-accent-strong: #176448;
+  --bb-color-action: #35684c;
+  --bb-color-action-hover: #2a5540;
+  --bb-color-action-text: #ffffff;
+  --bb-color-focus: #20a37e;
+  --bb-color-success: #087d62;
+  --bb-color-success-soft: #e6f2ec;
+  --bb-color-warning: #8a631d;
+  --bb-color-warning-soft: #fff0c7;
+  --bb-color-danger: #d92335;
+  --bb-color-danger-soft: #fde9eb;
+  --bb-color-rail: #171c19;
+  --bb-color-rail-border: #2c332e;
+  --bb-color-rail-text: #d5ded8;
+  --bb-color-rail-muted: #89938c;
+  --bb-color-rail-hover: #232c26;
+  --bb-color-rail-active: #203e33;
+  --bb-color-rail-strong: #ffffff;
+  --bb-color-overlay: rgb(8 15 11 / 40%);
+  --bb-shadow: 0 16px 42px rgb(13 24 17 / 12%);
+  --bb-font-sans: Geist, "Noto Sans JP", "Hiragino Sans", system-ui, sans-serif;
+  --bb-font-mono: ui-monospace, SFMono-Regular, Menlo, monospace;
+  --bb-radius-sm: 7px;
+  --bb-radius-md: 14px;
+  --bb-radius-lg: 16px;
+  --bb-space-1: 4px;
+  --bb-space-2: 8px;
+  --bb-space-3: 12px;
+  --bb-space-4: 16px;
+  --bb-space-5: 24px;
+  --bb-space-6: 32px;
+}