@unson/brainbase-mcp 0.41.11 → 0.42.0

package/README.md

@@ -105,7 +105,7 @@ brainbase onboard:candidates
 
 ### Google Workspace local-first adopter
 
-常時稼働のMac mini、Google Workspace、補助Gmail、許可したDrive/local folder、Calendar/notesに散在するタスクを対象にする例です。全Driveやhome directory全体は走査しません。
+常時稼働のローカルホスト（例: Mac mini）、Google Workspace、必要なら補助Gmail、許可したDrive/local folder、Calendar/notesに散在するタスクを想定した例です。使わないタスクツール（例: Notion）は`--inactive-task-tool`で非アクティブ扱いにできます。全Driveやhome directory全体は走査しません。
 
 ```bash
 brainbase onboard:plan --profile google-workspace-local --host mac-mini --email google-workspace --secondary-email gmail --calendar google-calendar --drive google-drive --drive-folder "<folder-id>" --local-folder "/Users/owner/Notes" --tasks scattered-calendar-notes --inactive-task-tool notion

package/contracts/judgment-dag/digest.json

@@ -25,8 +25,8 @@
     },
     {
       "path": "README.md",
-      "sha256": "55fc2b9c7945b81cfe3b7971bc1d067f8cd45d057fbf23dcf3dfae175838d1d3"
+      "sha256": "26eacd2a057380b4fd386b2176bd6e790a41c0bb8d684857c53bb5cd947e2d28"
     }
   ],
-  "digest": "89b20a5aa122e73e9d2f7c99e1b029cb12b101b95574ee4560ce023ec3197304"
+  "digest": "38bf5aff53993b1ee737071ca7952d44e36ac2e5ed3a7adcac65fdd86e8954af"
 }

package/dist/local-web-host.d.ts

@@ -195,6 +195,12 @@ export declare function createWorldModelReadModule(context: LocalWebModuleContex
  * correction is never saved through a path that skipped the host check.
  */
 export declare function createGraphWebModule(context: LocalWebModuleContext): LocalWebModule;
+/**
+ * 「あなたの記憶」: the owner's `personal-kg.jsonl`, read only.  The memory
+ * bodies are private, so these reads require the launch token and the same
+ * origin like every write on this host.
+ */
+export declare function createPersonalMemoryModule(context: LocalWebModuleContext): LocalWebModule;
 /** 今日 (value proofs), 目的と現状 (objectives + world model), プロジェクトと関係者 and 情報と関係 (Graph). */
 export declare function defaultLocalWebModules(context: LocalWebModuleContext): LocalWebModule[];
 /** Local single-owner host. The caller owns `listen()` and must bind to a loopback address. */

package/dist/local-web-host.js

@@ -12,6 +12,7 @@ import { createJudgmentHistoryHttpHandler, JUDGMENT_HISTORY_HTTP_PREFIX } from '
 import { createJudgmentHistoryReader, createLocalJudgmentHistoryFeedbackWriter, createLocalJudgmentHistorySource } from './judgment-history.js';
 import { defaultJudgmentJournalRoot, JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
 import { createMeetingMinutesHttpHandler } from './meeting-minutes-http.js';
+import { createPersonalMemoryHttpHandler, createPersonalMemoryJudgmentIndex, readLocalPersonalMemories } from './personal-memory.js';
 import { createMeetingMinutesLineageHttpHandler } from './meeting-minutes-lineage-http.js';
 import { createMeetingMinutesLineageCorrectionHook, } from './meeting-minutes-lineage-lifecycle.js';
 import { createMeetingMinutesStore } from './meeting-minutes.js';
@@ -52,7 +53,7 @@ export const LOCAL_WEB_JUDGMENT_HISTORY_PREFIX = JUDGMENT_HISTORY_HTTP_PREFIX;
 export const LOCAL_WEB_FOUNDATION_BODY_LIMIT_BYTES = 64 * 1024;
 export const LOCAL_WEB_PROVENANCE_SOURCE_ID = 'brainbase-local-web';
 const CANONICAL_FILES = ['graph.json', 'relationships.json', 'personal-kg.jsonl', 'decisions.jsonl'];
-const BASE_UI_FILES = ['brainbase-tokens.css', 'local-web-shell.js', 'local-web-shell.css', 'workspace-kit.js', 'workspace-kit.css', 'native-scrollbars.js', 'native-scrollbars.css'];
+const BASE_UI_FILES = ['brainbase-tokens.css', 'local-web-shell.js', 'local-web-shell.css', 'workspace-kit.js', 'workspace-kit.css', 'native-scrollbars.js', 'native-scrollbars.css', 'area-nav.js', 'area-nav.css'];
 const CONTENT_TYPES = Object.freeze({
     '.js': 'text/javascript; charset=utf-8',
     '.css': 'text/css; charset=utf-8'
@@ -883,12 +884,46 @@ export function createGraphWebModule(context) {
             'project-graph-vendor.js',
             'graph-registry-view.js',
             'graph-registry-view.css',
+            'graph-ontology-view.js',
+            'graph-ontology-view.css',
             'people-and-companies-view.js',
             'people-and-companies-view.css'
         ],
         handle: handler
     };
 }
+/**
+ * 「あなたの記憶」: the owner's `personal-kg.jsonl`, read only.  The memory
+ * bodies are private, so these reads require the launch token and the same
+ * origin like every write on this host.
+ */
+export function createPersonalMemoryModule(context) {
+    const readMemories = () => readLocalPersonalMemories(context.dataDir);
+    const index = createPersonalMemoryJudgmentIndex({
+        source: createLocalJudgmentHistorySource({
+            root: context.journalRoot,
+            entrypoint: context.judgmentHistoryEntrypoint ?? 'codex'
+        }),
+        memoryIds: async () => {
+            const list = await readMemories();
+            return list.status === 'ok' ? list.items.map((item) => item.id) : null;
+        }
+    });
+    return {
+        id: 'personal-memory',
+        uiFiles: ['personal-memory.js', 'personal-memory-http-port.js', 'personal-memory.css'],
+        handle: createPersonalMemoryHttpHandler({
+            readMemories,
+            index,
+            authorize(request) {
+                if (isTrustedLocalWrite(request, context.token))
+                    return;
+                throw rejectUntrustedWrite(request, context.token)
+                    ?? new LocalWebHttpError(403, 'web_token_required', 'A valid launch token is required');
+            }
+        })
+    };
+}
 /** 今日 (value proofs), 目的と現状 (objectives + world model), プロジェクトと関係者 and 情報と関係 (Graph). */
 export function defaultLocalWebModules(context) {
     return [
@@ -898,7 +933,8 @@ export function defaultLocalWebModules(context) {
         createMeetingMinutesModule(context),
         createObjectiveFoundationModule(context),
         createWorldModelReadModule(context),
-        createGraphWebModule(context)
+        createGraphWebModule(context),
+        createPersonalMemoryModule(context)
     ];
 }
 function escapeAttribute(value) {
@@ -938,10 +974,25 @@ const meta = (name) => document.querySelector(\`meta[name="\${name}"]\`)?.getAtt
 // Keep the query portion intact; the shell parses the Graph entity query and
 // only treats the entity id as a target of the Graph screen.
 const screenFromHash = () => location.hash.replace(/^#/, '') || undefined;
-const shell = createLocalWebShell({
+// A screen that opened its own address (a record of 情報と関係) goes back with the
+// browser's history, so 「一覧に戻る」 and the back button land on the same list.
+// Each entry remembers how many records deep it is, which stays right when the
+// owner also uses the browser's back and forward.
+const depth = () => (Number.isInteger(history.state?.bbDepth) ? history.state.bbDepth : 0);
+let shell = null;
+const navigate = (target, { back = false } = {}) => {
+  if (back && depth() > 0) {
+    history.go(-depth());
+    return;
+  }
+  history.pushState({ bbDepth: back ? 0 : depth() + 1 }, '', \`#\${target}\`);
+  shell?.show(target);
+};
+shell = createLocalWebShell({
   root: document.getElementById('brainbase-local-web'),
   token: meta('brainbase-web-token'),
   initialScreen: screenFromHash(),
+  onNavigate: navigate,
   meetingMinutesStorage: ${JSON.stringify(meetingMinutesStorage ?? null)},
   meetingMinutesLineage: ${JSON.stringify(meetingMinutesLineage ?? null)},
   screens: ${leading ? `[${leading}, ...LOCAL_WEB_SCREENS${trailing ? `, ${trailing}` : ''}]` : '[...LOCAL_WEB_SCREENS, ...extensionScreens]'}

package/dist/personal-memory.d.ts

@@ -0,0 +1,101 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { JudgmentHistorySource } from './judgment-history.js';
+import type { PersonalKgEntry } from './types.js';
+/**
+ * 「あなたの記憶」 (docs/specs/personal-memory-viewer.md): the owner's own
+ * memories read from the local `personal-kg.jsonl`, and the judgments that
+ * used each one, found back from the judgment journal's `personal_knowledge`
+ * references.  Read only.  A memory body travels in the response body only,
+ * never in a URL or a log line.
+ */
+export declare const PERSONAL_MEMORY_HTTP_PREFIX = "/api/personal-memory";
+export type PersonalMemoryState = 'active' | 'superseded' | 'retracted' | 'unrecorded';
+export interface PersonalMemoryItem {
+    readonly id: string;
+    readonly kind: string | null;
+    readonly text: string;
+    readonly tags: readonly string[];
+    readonly state: PersonalMemoryState;
+    readonly supersededBy: string | null;
+    readonly origin: {
+        readonly organizationLabel: string | null;
+        readonly projectLabel: string | null;
+        readonly workplace: string | null;
+        readonly inferred: boolean;
+    };
+    readonly occurredAt: string | null;
+    readonly updatedAt: string | null;
+    readonly recallScope: 'organization' | 'general' | 'unknown';
+    readonly history: readonly {
+        readonly state: PersonalMemoryState;
+        readonly at: string;
+        readonly reason: string | null;
+    }[];
+}
+export type PersonalMemoryList = {
+    readonly status: 'ok';
+    readonly items: readonly PersonalMemoryItem[];
+} | {
+    readonly status: 'unavailable';
+    readonly reason: string;
+};
+export interface PersonalMemoryJudgment {
+    readonly decisionId: string;
+    readonly title: string | null;
+    readonly at: string;
+    readonly kind: string | null;
+}
+export type PersonalMemoryJudgments = {
+    readonly status: 'ok';
+    readonly items: readonly PersonalMemoryJudgment[];
+    readonly total: number;
+} | {
+    readonly status: 'unavailable';
+    readonly reason: string;
+};
+export type PersonalMemoryJudgmentCounts = {
+    readonly status: 'ok';
+    readonly counts: Readonly<Record<string, number>>;
+} | {
+    readonly status: 'unavailable';
+    readonly reason: string;
+};
+/** The local writer keeps no state, origin organization or recall scope: the spec's fixed values. */
+export declare function personalMemoryFromEntry(entry: PersonalKgEntry): PersonalMemoryItem;
+/** An empty file is zero memories; a missing or malformed one is unavailable, never zero. */
+export declare function readLocalPersonalMemories(dataDir: string): Promise<PersonalMemoryList>;
+export interface PersonalMemoryJudgmentIndex {
+    judgmentsUsing(id: string, limit: number): Promise<PersonalMemoryJudgments>;
+    counts(): Promise<PersonalMemoryJudgmentCounts>;
+}
+/**
+ * Finds judgments back from their `personal_knowledge` references.  A
+ * reference names a memory by its id, so the journal is bound to these
+ * memories only when at least one recorded reference is one of their ids.
+ * When every reference names a memory kept elsewhere (for example the
+ * organization's personal KG), "not used" cannot be told from "used under
+ * another id", and the answer is unavailable instead of zero.
+ */
+export declare function createPersonalMemoryJudgmentIndex(options: {
+    readonly source: JudgmentHistorySource;
+    /** The memory ids, or null when the memories cannot be read. */
+    readonly memoryIds: () => Promise<readonly string[] | null>;
+    /**
+     * How long one journal read answers later requests. A large journal takes
+     * tens of seconds to scan, and one opened memory asks for its judgments and
+     * the list's counts at the same time.
+     */
+    readonly reuseMs?: number;
+    readonly now?: () => number;
+}): PersonalMemoryJudgmentIndex;
+/**
+ * GET routes under `/api/personal-memory`.  `authorize` runs before any read
+ * and throws to refuse the request (the local host requires its launch token
+ * on these reads, not only on writes).
+ */
+export declare function createPersonalMemoryHttpHandler(options: {
+    readonly readMemories: () => Promise<PersonalMemoryList>;
+    readonly index: PersonalMemoryJudgmentIndex;
+    readonly authorize: (request: IncomingMessage) => void;
+    readonly basePath?: string;
+}): (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;

package/dist/personal-memory.js

@@ -0,0 +1,204 @@
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { requestUrl, writeJson } from './local-web-security.js';
+import { readPersonalKg } from './ssot.js';
+/**
+ * 「あなたの記憶」 (docs/specs/personal-memory-viewer.md): the owner's own
+ * memories read from the local `personal-kg.jsonl`, and the judgments that
+ * used each one, found back from the judgment journal's `personal_knowledge`
+ * references.  Read only.  A memory body travels in the response body only,
+ * never in a URL or a log line.
+ */
+export const PERSONAL_MEMORY_HTTP_PREFIX = '/api/personal-memory';
+/** The local writer keeps no state, origin organization or recall scope: the spec's fixed values. */
+export function personalMemoryFromEntry(entry) {
+    return {
+        id: entry.id,
+        kind: entry.type,
+        text: entry.text,
+        tags: [...entry.tags ?? []],
+        state: 'unrecorded',
+        supersededBy: null,
+        origin: { organizationLabel: '手元', projectLabel: null, workplace: null, inferred: false },
+        occurredAt: null,
+        updatedAt: entry.updatedAt ?? null,
+        recallScope: 'general',
+        history: []
+    };
+}
+function newestFirst(left, right) {
+    if (left === right)
+        return 0;
+    if (left === null)
+        return 1;
+    if (right === null)
+        return -1;
+    return left < right ? 1 : -1;
+}
+/** An empty file is zero memories; a missing or malformed one is unavailable, never zero. */
+export async function readLocalPersonalMemories(dataDir) {
+    try {
+        await stat(join(dataDir, 'personal-kg.jsonl'));
+    }
+    catch {
+        return { status: 'unavailable', reason: 'personal_kg_missing' };
+    }
+    let entries;
+    try {
+        entries = await readPersonalKg(dataDir);
+    }
+    catch {
+        return { status: 'unavailable', reason: 'personal_kg_invalid' };
+    }
+    const items = entries.map(personalMemoryFromEntry);
+    items.sort((left, right) => newestFirst(left.updatedAt, right.updatedAt));
+    return { status: 'ok', items };
+}
+function personalReferences(record) {
+    const refs = new Set();
+    for (const reference of record.judgment.selected_references ?? []) {
+        if (reference.kind === 'personal_knowledge' && reference.ref)
+            refs.add(reference.ref);
+    }
+    return refs;
+}
+/**
+ * Finds judgments back from their `personal_knowledge` references.  A
+ * reference names a memory by its id, so the journal is bound to these
+ * memories only when at least one recorded reference is one of their ids.
+ * When every reference names a memory kept elsewhere (for example the
+ * organization's personal KG), "not used" cannot be told from "used under
+ * another id", and the answer is unavailable instead of zero.
+ */
+export function createPersonalMemoryJudgmentIndex(options) {
+    async function build() {
+        const [snapshot, ids] = await Promise.all([options.source.read(), options.memoryIds()]);
+        if (ids === null)
+            return { status: 'unavailable', reason: 'personal_kg_unavailable' };
+        if (snapshot.status !== 'available' || !snapshot.records) {
+            return { status: 'unavailable', reason: `journal_${snapshot.status === 'partial' ? 'partial' : 'unavailable'}` };
+        }
+        const known = new Set(ids);
+        const byMemory = new Map(ids.map((id) => [id, []]));
+        let referenced = 0;
+        let bound = 0;
+        for (const record of snapshot.records) {
+            const refs = personalReferences(record);
+            for (const ref of refs) {
+                referenced += 1;
+                if (!known.has(ref))
+                    continue;
+                bound += 1;
+                byMemory.get(ref)?.push({ decisionId: record.record_id, title: record.judgment.summary, at: record.recorded_at, kind: null });
+            }
+        }
+        if (referenced > 0 && bound === 0)
+            return { status: 'unavailable', reason: 'reference_source_mismatch' };
+        for (const judgments of byMemory.values())
+            judgments.sort((left, right) => newestFirst(left.at, right.at));
+        return { status: 'ok', byMemory };
+    }
+    const reuseMs = options.reuseMs ?? 30_000;
+    const now = options.now ?? (() => Date.now());
+    let current = null;
+    function shared() {
+        if (current && now() - current.startedAt < reuseMs)
+            return current.promise;
+        const entry = { promise: build(), startedAt: now() };
+        current = entry;
+        // A failed read, a missing journal and unreadable memories are not reused: the owner may fix them now.
+        const forget = () => { if (current === entry)
+            current = null; };
+        entry.promise.then((index) => {
+            if (index.status === 'unavailable' && (index.reason === 'journal_unavailable' || index.reason === 'personal_kg_unavailable'))
+                forget();
+        }, forget);
+        return entry.promise;
+    }
+    return {
+        async judgmentsUsing(id, limit) {
+            const index = await shared();
+            if (index.status !== 'ok')
+                return index;
+            const judgments = index.byMemory.get(id) ?? [];
+            return { status: 'ok', items: judgments.slice(0, Math.max(0, limit)), total: judgments.length };
+        },
+        async counts() {
+            const index = await shared();
+            if (index.status !== 'ok')
+                return index;
+            return { status: 'ok', counts: Object.fromEntries([...index.byMemory].map(([id, judgments]) => [id, judgments.length])) };
+        }
+    };
+}
+const DEFAULT_JUDGMENT_LIMIT = 5;
+const MAX_JUDGMENT_LIMIT = 500;
+/**
+ * GET routes under `/api/personal-memory`.  `authorize` runs before any read
+ * and throws to refuse the request (the local host requires its launch token
+ * on these reads, not only on writes).
+ */
+export function createPersonalMemoryHttpHandler(options) {
+    const basePath = (options.basePath ?? PERSONAL_MEMORY_HTTP_PREFIX).replace(/\/+$/u, '');
+    return async (request, response) => {
+        const url = requestUrl(request);
+        if (url.pathname !== basePath && !url.pathname.startsWith(`${basePath}/`))
+            return false;
+        if (request.method !== 'GET') {
+            writeJson(response, 405, { error: { code: 'method_not_allowed', message: 'Use GET' } });
+            return true;
+        }
+        options.authorize(request);
+        const unavailable = (result) => writeJson(response, 503, { status: 'unavailable', reason: result.reason });
+        if (url.pathname === basePath) {
+            if (url.searchParams.get('view') === 'judgment-counts') {
+                const counts = await options.index.counts();
+                if (counts.status === 'ok')
+                    writeJson(response, 200, counts);
+                else
+                    unavailable(counts);
+                return true;
+            }
+            const list = await options.readMemories();
+            if (list.status === 'ok')
+                writeJson(response, 200, { status: 'ok', items: list.items, next_cursor: null });
+            else
+                unavailable(list);
+            return true;
+        }
+        const rest = url.pathname.slice(basePath.length + 1).split('/');
+        let id;
+        try {
+            id = decodeURIComponent(rest[0] ?? '');
+        }
+        catch {
+            writeJson(response, 400, { error: { code: 'invalid_id', message: 'The memory id is not valid' } });
+            return true;
+        }
+        if (!id || rest.length > 2 || (rest.length === 2 && rest[1] !== 'judgments')) {
+            writeJson(response, 404, { error: { code: 'not_found', message: 'Not found' } });
+            return true;
+        }
+        if (rest.length === 2) {
+            const requested = Number.parseInt(url.searchParams.get('limit') ?? '', 10);
+            const limit = Number.isInteger(requested) && requested > 0 ? Math.min(requested, MAX_JUDGMENT_LIMIT) : DEFAULT_JUDGMENT_LIMIT;
+            const judgments = await options.index.judgmentsUsing(id, limit);
+            if (judgments.status === 'ok')
+                writeJson(response, 200, judgments);
+            else
+                unavailable(judgments);
+            return true;
+        }
+        const list = await options.readMemories();
+        if (list.status !== 'ok') {
+            unavailable(list);
+            return true;
+        }
+        const item = list.items.find((candidate) => candidate.id === id);
+        if (item)
+            writeJson(response, 200, { status: 'ok', item });
+        else
+            writeJson(response, 404, { status: 'not_found' });
+        return true;
+    };
+}

package/dist/ssot.d.ts

@@ -1,7 +1,9 @@
 import { type CanonicalGraphMigrationPlan } from './ontology-migration.js';
-import type { PersonalOs } from './types.js';
+import type { PersonalKgEntry, PersonalOs } from './types.js';
 export declare function initializePersonalOs(dataDir: string): Promise<void>;
 export declare function loadPersonalOs(dataDir: string): Promise<PersonalOs>;
+/** Only `personal-kg.jsonl`, validated line by line as `loadPersonalOs` does. */
+export declare function readPersonalKg(dataDir: string): Promise<PersonalKgEntry[]>;
 export declare function mutatePersonalOs(dataDir: string, mutator: (current: PersonalOs) => PersonalOs | Promise<PersonalOs>): Promise<PersonalOs>;
 export declare function mutatePersonalOsWithSidecar<T>(dataDir: string, sidecarPath: string, mutator: (current: PersonalOs, sidecarContent?: string) => {
     next: PersonalOs;

package/dist/ssot.js

@@ -74,6 +74,10 @@ export async function loadPersonalOs(dataDir) {
         return loadPersonalOsUnlocked(dataDir);
     });
 }
+/** Only `personal-kg.jsonl`, validated line by line as `loadPersonalOs` does. */
+export async function readPersonalKg(dataDir) {
+    return readJsonl(join(dataDir, 'personal-kg.jsonl'), personalKgSchema, 'personal-kg.jsonl');
+}
 export async function mutatePersonalOs(dataDir, mutator) {
     return withSsotLock(dataDir, async () => {
         await recoverTransactions(dataDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.41.11",
+  "version": "0.42.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",
@@ -295,6 +295,10 @@
       "types": "./dist/streamable-http.d.ts",
       "import": "./dist/streamable-http.js"
     },
+    "./personal-memory": {
+      "types": "./dist/personal-memory.d.ts",
+      "import": "./dist/personal-memory.js"
+    },
     "./meeting-minutes": {
       "types": "./dist/meeting-minutes.d.ts",
       "import": "./dist/meeting-minutes.js"
@@ -328,6 +332,11 @@
     "./ui/world-model-view.css": "./ui/world-model-view.css",
     "./ui/people-and-companies-view": "./ui/people-and-companies-view.js",
     "./ui/people-and-companies-view.css": "./ui/people-and-companies-view.css",
+    "./ui/personal-memory": "./ui/personal-memory.js",
+    "./ui/personal-memory.css": "./ui/personal-memory.css",
+    "./ui/personal-memory-http-port": "./ui/personal-memory-http-port.js",
+    "./ui/area-nav": "./ui/area-nav.js",
+    "./ui/area-nav.css": "./ui/area-nav.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",
@@ -342,6 +351,8 @@
     "./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/graph-ontology-view": "./ui/graph-ontology-view.js",
+    "./ui/graph-ontology-view.css": "./ui/graph-ontology-view.css",
     "./ui/meeting-minutes-storage": "./ui/meeting-minutes-storage.js",
     "./ui/meeting-minutes-storage.css": "./ui/meeting-minutes-storage.css",
     "./ui/brainbase-tokens.css": "./ui/brainbase-tokens.css",
@@ -483,5 +494,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "3849d107c129672e91d6c28cfa3b8b5053d7f53a"
+  "gitHead": "35fc142733aac0f385f2d21e6d0651e1a9d8d7db"
 }

package/ui/area-nav.css

@@ -0,0 +1,79 @@
+/*
+ * Area navigation (ledger D10, stage 2): the area links on the left and the
+ * tabs of the current area above the page. Uses only the shared tokens in
+ * brainbase-tokens.css; a host gives the area links its own look through
+ * `linkClassName`.
+ */
+.bb-area-nav {
+  display: grid;
+  gap: 2px;
+}
+
+.bb-area-link[hidden],
+.bb-area-tabs[hidden] {
+  display: none;
+}
+
+.bb-area-link-label {
+  min-width: 0;
+  flex: 1 1 auto;
+}
+
+.bb-area-count {
+  min-width: 20px;
+  flex: 0 0 auto;
+  border-radius: 999px;
+  padding: 0 6px;
+  background: var(--bb-color-accent-soft);
+  color: var(--bb-color-accent);
+  font-size: 11px;
+  font-weight: 700;
+  line-height: 18px;
+  text-align: center;
+}
+
+.bb-area-tabs {
+  display: flex;
+  gap: var(--bb-space-1);
+  overflow-x: auto;
+  border-bottom: 1px solid var(--bb-color-border);
+  padding: 0 var(--bb-space-5);
+  background: var(--bb-color-paper);
+  scrollbar-width: none;
+}
+
+.bb-area-tab {
+  min-height: 44px;
+  display: inline-flex;
+  flex: 0 0 auto;
+  align-items: center;
+  gap: var(--bb-space-2);
+  border-bottom: 2px solid transparent;
+  padding: 0 var(--bb-space-3);
+  color: var(--bb-color-muted);
+  font-size: 13px;
+  font-weight: 620;
+  text-decoration: none;
+  white-space: nowrap;
+}
+
+.bb-area-tab:hover {
+  color: var(--bb-color-ink);
+}
+
+.bb-area-tab[aria-current="page"] {
+  border-bottom-color: var(--bb-color-accent);
+  color: var(--bb-color-accent);
+}
+
+.bb-area-tab:focus-visible,
+.bb-area-link:focus-visible {
+  outline: 2px solid var(--bb-color-accent);
+  outline-offset: -2px;
+}
+
+@media (max-width: 760px) {
+  .bb-area-tabs {
+    padding: 0 var(--bb-space-4);
+  }
+}