@unson/brainbase-mcp 0.41.13 → 0.43.0

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';
@@ -891,6 +892,38 @@ export function createGraphWebModule(context) {
         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 [
@@ -900,7 +933,8 @@ export function defaultLocalWebModules(context) {
         createMeetingMinutesModule(context),
         createObjectiveFoundationModule(context),
         createWorldModelReadModule(context),
-        createGraphWebModule(context)
+        createGraphWebModule(context),
+        createPersonalMemoryModule(context)
     ];
 }
 function escapeAttribute(value) {

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.13",
+  "version": "0.43.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/inbox": "./ui/inbox.js",
+    "./ui/inbox.css": "./ui/inbox.css",
     "./ui/area-nav": "./ui/area-nav.js",
     "./ui/area-nav.css": "./ui/area-nav.css",
     "./ui/local-web-shell": "./ui/local-web-shell.js",
@@ -487,5 +496,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "fcfea3958913012579029adf0bf785c45643c77b"
+  "gitHead": "a8166d088899a27bb8267af9e6dd99d3550c7b63"
 }

package/ui/area-nav.css

@@ -1,15 +1,66 @@
 /*
- * 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
+ * Area navigation (ledger D10): the destinations on the left, grouped under
+ * small headings with 設定 at the bottom, and the tabs of a destination with
+ * several screens above the page. Uses only the shared tokens in
+ * brainbase-tokens.css; a host gives the links its own look through
  * `linkClassName`.
  */
 .bb-area-nav {
+  flex: 1 1 auto;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.bb-area-section,
+.bb-area-section-links {
   display: grid;
   gap: 2px;
 }
 
+/* Space between the groups; the footer group sits at the bottom of the nav. */
+.bb-area-section + .bb-area-section {
+  margin-top: var(--bb-space-4);
+}
+
+.bb-area-section.is-footer {
+  margin-top: auto;
+  padding-top: var(--bb-space-4);
+}
+
+.bb-area-section-label {
+  padding: 0 10px 4px;
+  color: var(--bb-color-rail-muted, var(--bb-color-muted));
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: .04em;
+}
+
+.bb-area-section-link {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  border-radius: 6px;
+  padding-top: 4px;
+  text-decoration: none;
+}
+
+/* A heading that opens a screen says so with a chevron (not part of its name). */
+.bb-area-section-link::after {
+  content: "›";
+  font-size: 13px;
+  line-height: 1;
+}
+
+.bb-area-section-link:hover,
+.bb-area-section-link[aria-current="page"] {
+  color: var(--bb-color-accent);
+}
+
 .bb-area-link[hidden],
+.bb-area-section[hidden],
+.bb-area-section-label[hidden],
+.bb-area-section-links[hidden],
 .bb-area-tabs[hidden] {
   display: none;
 }
@@ -67,7 +118,8 @@
 }
 
 .bb-area-tab:focus-visible,
-.bb-area-link:focus-visible {
+.bb-area-link:focus-visible,
+.bb-area-section-link:focus-visible {
   outline: 2px solid var(--bb-color-accent);
   outline-offset: -2px;
 }