@unson/brainbase-mcp 0.15.1 → 0.15.2

package/dist/value-proof-review-http.d.ts

@@ -1,4 +1,5 @@
 import { type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import { JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
 export declare const VALUE_PROOF_REVIEW_HTTP_VERSION: "value-proof-review-http.v1";
 export declare const VALUE_PROOF_REVIEW_TOKEN_HEADER = "x-brainbase-review-token";
 export interface ValueProofReviewHttpOptions {
@@ -10,6 +11,8 @@ export interface ValueProofReviewHttpOptions {
     readonly token: string;
     readonly basePath?: string;
     readonly now?: () => Date;
+    /** One cache per journal; a host passes the one it shares with other readers of the same journal. */
+    readonly journalCache?: JudgmentValueProofJournalCache;
 }
 export type ValueProofReviewHttpHandler = (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
 export declare function createValueProofReviewHttpHandler(options: ValueProofReviewHttpOptions): ValueProofReviewHttpHandler;

package/dist/value-proof-review-http.js

@@ -3,7 +3,7 @@ import { readFile } from 'node:fs/promises';
 import { createServer } from 'node:http';
 import { join, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { applyJudgmentValueProofFeedback, buildJudgmentValueProofReviewHome, classifyJudgmentValueProof, JudgmentValueProofAnswerConflictError, readJudgmentValueProofAnswers, readJudgmentValueProofFeedback, readJudgmentValueProofJournal, recordJudgmentValueProofAnswer, recordJudgmentValueProofFeedback } from './judgment-value-proof-review.js';
+import { applyJudgmentValueProofFeedback, buildJudgmentValueProofReviewHome, classifyJudgmentValueProof, JudgmentValueProofAnswerConflictError, JudgmentValueProofJournalCache, readJudgmentValueProofAnswers, readJudgmentValueProofFeedback, readJudgmentValueProofJournal, recordJudgmentValueProofAnswer, recordJudgmentValueProofFeedback } from './judgment-value-proof-review.js';
 import { assertSameOrigin, isLoopbackHost, LOCAL_WEB_CONTENT_SECURITY_POLICY, LocalWebHttpError as HttpError, readJsonObjectBody, requestUrl, tokenMatches, writeHttpError as writeError, writeJson } from './local-web-security.js';
 export const VALUE_PROOF_REVIEW_HTTP_VERSION = 'value-proof-review-http.v1';
 export const VALUE_PROOF_REVIEW_TOKEN_HEADER = 'x-brainbase-review-token';
@@ -22,8 +22,12 @@ function publicHome(home) {
         return home;
     const strip = (items) => Object.fromEntries(Object.entries(items).map(([section, list]) => [
         section,
-        list.map(({ section: itemSection, proof, feedback_history, answer }) => ({
-            section: itemSection, proof, feedback_history, answer: answer ?? null
+        list.map(({ section: itemSection, proof, feedback_history, answer, conversation_moved_on_at }) => ({
+            section: itemSection,
+            proof,
+            feedback_history,
+            answer: answer ?? null,
+            conversation_moved_on_at: conversation_moved_on_at ?? null
         }))
     ]));
     return {
@@ -44,8 +48,11 @@ export function createValueProofReviewHttpHandler(options) {
     }
     const basePath = (options.basePath ?? DEFAULT_BASE_PATH).replace(/\/+$/u, '');
     const now = options.now ?? (() => new Date());
+    // A large journal has thousands of conversation folders; only the ones that changed are listed again.
+    const journalCache = options.journalCache ?? new JudgmentValueProofJournalCache();
+    const readJournal = () => readJudgmentValueProofJournal({ root: options.journalRoot, cache: journalCache });
     async function readHome() {
-        const journal = await readJudgmentValueProofJournal({ root: options.journalRoot });
+        const journal = await readJournal();
         if (journal.status !== 'available')
             return buildJudgmentValueProofReviewHome(journal, [], { now: now() });
         const [feedback, answers] = await Promise.all([
@@ -65,7 +72,7 @@ export function createValueProofReviewHttpHandler(options) {
         const body = await authorizedBody(request);
         const intentId = typeof body.intent_id === 'string' ? body.intent_id : '';
         const attemptId = typeof body.decision_attempt_id === 'string' ? body.decision_attempt_id : '';
-        const journal = await readJudgmentValueProofJournal({ root: options.journalRoot });
+        const journal = await readJournal();
         if (journal.status === 'unavailable') {
             throw new HttpError(503, 'judgment_journal_unavailable', journal.reason);
         }
@@ -78,6 +85,10 @@ export function createValueProofReviewHttpHandler(options) {
         if (classifyJudgmentValueProof(proof) !== 'needs_human' || !proof.human_decision) {
             throw new HttpError(422, 'not_answerable', 'This judgment is not waiting for the owner');
         }
+        if (entry.conversation_moved_on_at) {
+            // The owner answered in that conversation or moved on; answering here could replay a settled question.
+            throw new HttpError(422, 'conversation_moved_on', 'The conversation moved on after this question; continue it there');
+        }
         try {
             const result = await recordJudgmentValueProofAnswer({
                 dataDir: options.dataDir,
@@ -108,7 +119,7 @@ export function createValueProofReviewHttpHandler(options) {
         const body = await authorizedBody(request);
         const intentId = typeof body.intent_id === 'string' ? body.intent_id : '';
         const attemptId = typeof body.decision_attempt_id === 'string' ? body.decision_attempt_id : '';
-        const journal = await readJudgmentValueProofJournal({ root: options.journalRoot });
+        const journal = await readJournal();
         if (journal.status === 'unavailable') {
             throw new HttpError(503, 'judgment_journal_unavailable', journal.reason);
         }

package/dist/world-extension.d.ts

@@ -0,0 +1,148 @@
+import { JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
+import { type LocalWebExtension, type LocalWebModuleContext } from './local-web-host.js';
+import type { GraphFileV2 } from './types.js';
+/**
+ * World view (ledger P17, adopted 2026-10-04): the home's upper layer.
+ *
+ * The world is a read-only projection.  Businesses come from the same Graph
+ * the other screens read (the organization Graph under C1, else the local
+ * Graph); judgments come from the existing value-proof home on the browser
+ * side.  Nothing here writes, and a failure to read is reported as a state,
+ * never as zero businesses.
+ */
+export declare const WORLD_EXTENSION_ID = "world";
+export declare const WORLD_EXTENSION_VERSION: "world-extension.v1";
+declare const LIFECYCLE_PHASES: readonly ["active", "maintenance", "finished", "concept"];
+/** How a status looks in the world: lit, muted, an empty lot, or a scaffold. */
+export type WorldLifecyclePhase = (typeof LIFECYCLE_PHASES)[number];
+declare const BUILDING_FORMS: readonly ["tower", "hall", "dome", "office"];
+export type WorldBuildingForm = (typeof BUILDING_FORMS)[number];
+/**
+ * The words of the owner's Graph, given by the host (`--world-vocabulary`):
+ * the project kinds in display order with their label and building, and the
+ * statuses with their label and lifecycle phase.  None of it is required: a
+ * kind the vocabulary does not name is drawn under its own value, and a status
+ * it does not name keeps its value and the active look.
+ */
+export interface WorldVocabularyConfig {
+    readonly kinds?: Readonly<Record<string, {
+        readonly label?: string;
+        readonly form?: WorldBuildingForm;
+        readonly color?: string;
+    }>>;
+    readonly statuses?: Readonly<Record<string, {
+        readonly label?: string;
+        readonly phase?: WorldLifecyclePhase;
+    }>>;
+}
+export interface WorldVocabulary {
+    readonly kinds: readonly {
+        readonly key: string | null;
+        readonly label: string;
+        readonly form: WorldBuildingForm;
+        readonly color: string;
+        readonly configured: boolean;
+    }[];
+    readonly statuses: readonly {
+        readonly key: string;
+        readonly label: string;
+        readonly phase: WorldLifecyclePhase;
+    }[];
+}
+export interface WorldEngagement {
+    readonly id: string;
+    readonly name: string;
+    readonly summary: string | null;
+    readonly status: string | null;
+}
+export interface WorldBusiness {
+    readonly id: string;
+    /** The project's code in its Graph (`metadata.code`), else its id; judgments are placed by it. */
+    readonly code: string;
+    readonly name: string;
+    /** `metadata.kind`, or null when the Graph does not classify the project. */
+    readonly kind: string | null;
+    readonly purpose: string | null;
+    readonly status: string | null;
+    /** Repository names the Graph registers for this project (`metadata.repositories`). */
+    readonly repositories: readonly string[];
+    readonly engagements: readonly WorldEngagement[];
+}
+export interface WorldBusinessProjection {
+    readonly businesses: readonly WorldBusiness[];
+    /** Projects that name a parent the Graph does not hold (kept visible as a count, never dropped silently). */
+    readonly unplaced: readonly WorldEngagement[];
+    readonly excluded: {
+        readonly inactive: number;
+    };
+}
+export type WorldSource = {
+    readonly authority: 'organization_graph';
+    readonly server: string;
+} | {
+    readonly authority: 'local';
+    readonly dataDir: string;
+};
+export type WorldBusinessesResponse = ({
+    readonly status: 'ok';
+    readonly version: typeof WORLD_EXTENSION_VERSION;
+    readonly source: WorldSource;
+    readonly as_of: string;
+    readonly vocabulary: WorldVocabulary;
+} & WorldBusinessProjection) | {
+    readonly status: 'not_initialized' | 'migration_required' | 'unavailable';
+    readonly version: typeof WORLD_EXTENSION_VERSION;
+    readonly reason: string;
+};
+/**
+ * The projects of a Graph v2 → cities (top-level projects) and their districts
+ * (projects whose `metadata.parent_project_id` names another project).  A
+ * project whose declared parent (`metadata.parent_project_code`) is not in the
+ * Graph is counted as unplaced.  Projects past `validTo` are counted, not drawn.
+ * Nothing here knows any organization's words: kinds and statuses are the
+ * Graph's own values.
+ */
+export declare function projectWorldFromGraph(graph: Pick<GraphFileV2, 'entities'>, now?: Date): WorldBusinessProjection;
+/**
+ * The vocabulary the world draws with: the host's kinds in their order, then
+ * kinds the Graph uses that the host did not name (under their own value),
+ * then unclassified projects; statuses are the common lifecycle words with the
+ * host's on top.
+ */
+export declare function resolveWorldVocabulary(config: WorldVocabularyConfig | undefined, businesses: readonly WorldBusiness[]): WorldVocabulary;
+/** Reads and checks a vocabulary file; an invalid file is an error, never silently ignored. */
+export declare function readWorldVocabulary(path: string): Promise<WorldVocabularyConfig>;
+/**
+ * The businesses from the same Graph the other screens read: the organization
+ * Graph when the host reads it (C1), else the local Graph.  A Graph that cannot
+ * be read is a state with its reason, never zero businesses.
+ */
+export declare function readWorldBusinesses(context: Pick<LocalWebModuleContext, 'dataDir' | 'organizationGraph'>, options?: {
+    readonly vocabulary?: WorldVocabularyConfig;
+    readonly now?: () => Date;
+}): Promise<WorldBusinessesResponse>;
+export interface WorldJudgmentPlace {
+    readonly decision_attempt_id: string;
+    /** Repository the judgment Host recorded for the turn (`turn-input.json` project_code); null when unrecorded. */
+    readonly workspace: string | null;
+}
+/**
+ * Reads, for every saved value proof in the judgment journal, the repository
+ * the Host recorded for that turn. The journal is listed through the host's
+ * shared listing cache (the same one as the 今日 list), so only folders that
+ * changed are listed again; turn inputs are never rewritten by the Host, so
+ * each is read once. A journal that cannot be read is `unavailable`, never
+ * an empty list.
+ */
+export declare function readJudgmentPlaces(journalRoot: string, options?: {
+    readonly cache?: JudgmentValueProofJournalCache;
+    readonly workspaces?: Map<string, string | null>;
+}): Promise<{
+    readonly status: 'available' | 'unavailable';
+    readonly places: readonly WorldJudgmentPlace[];
+    readonly reason?: string;
+}>;
+export declare function createWorldExtension(options?: {
+    readonly vocabulary?: WorldVocabularyConfig;
+}): LocalWebExtension;
+export {};

package/dist/world-extension.js

@@ -0,0 +1,277 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { readJudgmentValueProofJournal } from './judgment-value-proof-review.js';
+import { readLocalGraphState } from './local-web-host.js';
+import { loadPersonalOs } from './ssot.js';
+import { requestUrl, writeJson } from './local-web-security.js';
+/**
+ * World view (ledger P17, adopted 2026-10-04): the home's upper layer.
+ *
+ * The world is a read-only projection.  Businesses come from the same Graph
+ * the other screens read (the organization Graph under C1, else the local
+ * Graph); judgments come from the existing value-proof home on the browser
+ * side.  Nothing here writes, and a failure to read is reported as a state,
+ * never as zero businesses.
+ */
+export const WORLD_EXTENSION_ID = 'world';
+export const WORLD_EXTENSION_VERSION = 'world-extension.v1';
+const LIFECYCLE_PHASES = ['active', 'maintenance', 'finished', 'concept'];
+const BUILDING_FORMS = ['tower', 'hall', 'dome', 'office'];
+/** Lifecycle words common to any Graph; a host vocabulary may relabel or add to them. */
+const DEFAULT_STATUSES = Object.freeze({
+    active: { label: '進行中', phase: 'active' },
+    maintenance: { label: '保守', phase: 'maintenance' },
+    completed: { label: '完了', phase: 'finished' },
+    closed: { label: '終了', phase: 'finished' },
+    archived: { label: '保管', phase: 'finished' },
+    concept: { label: '構想', phase: 'concept' },
+});
+const KIND_PALETTE = ['#1261ad', '#b07a1f', '#35684c', '#6b4fa0', '#a8433a', '#2f7d86', '#7a6a2b', '#5b6470'];
+const UNCLASSIFIED_COLOR = '#69746d';
+const HEX_COLOR = /^#[0-9a-f]{6}$/iu;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function engagementOf(entity) {
+    return {
+        id: entity.id,
+        name: entity.name,
+        summary: text(entity.summary) ?? text(entity.metadata?.goal),
+        status: text(entity.metadata?.status),
+    };
+}
+/**
+ * The projects of a Graph v2 → cities (top-level projects) and their districts
+ * (projects whose `metadata.parent_project_id` names another project).  A
+ * project whose declared parent (`metadata.parent_project_code`) is not in the
+ * Graph is counted as unplaced.  Projects past `validTo` are counted, not drawn.
+ * Nothing here knows any organization's words: kinds and statuses are the
+ * Graph's own values.
+ */
+export function projectWorldFromGraph(graph, now = new Date()) {
+    const projects = graph.entities.filter((entity) => entity.type === 'project');
+    const active = projects.filter((entity) => !entity.validTo || Date.parse(entity.validTo) > now.getTime());
+    const byId = new Map(active.map((entity) => [entity.id, entity]));
+    // A district hangs on its top-level ancestor, so nested projects stay in one city.
+    const topOf = (entity) => {
+        let current = entity;
+        const seen = new Set();
+        for (;;) {
+            const parentId = text(current.metadata?.parent_project_id);
+            if (!parentId || parentId === current.id)
+                return current;
+            const parent = byId.get(parentId);
+            if (!parent || seen.has(parentId))
+                return parent ? current : null;
+            seen.add(parentId);
+            current = parent;
+        }
+    };
+    const cities = new Map();
+    const unplaced = [];
+    const children = [];
+    for (const entity of active) {
+        const parentId = text(entity.metadata?.parent_project_id);
+        if (parentId && parentId !== entity.id)
+            children.push(entity);
+        else if (text(entity.metadata?.parent_project_code))
+            unplaced.push(engagementOf(entity));
+        else
+            cities.set(entity.id, { entity, engagements: [] });
+    }
+    for (const entity of children) {
+        const top = topOf(entity);
+        const city = top ? cities.get(top.id) : undefined;
+        if (city && top.id !== entity.id)
+            city.engagements.push(engagementOf(entity));
+        else
+            unplaced.push(engagementOf(entity));
+    }
+    const businesses = [...cities.values()].map(({ entity, engagements }) => ({
+        id: entity.id,
+        code: text(entity.metadata?.code) ?? entity.id,
+        name: entity.name,
+        kind: text(entity.metadata?.kind),
+        purpose: text(entity.metadata?.goal) ?? text(entity.summary),
+        status: text(entity.metadata?.status),
+        repositories: Array.isArray(entity.metadata?.repositories)
+            ? entity.metadata.repositories.map(text).filter((name) => name !== null)
+            : [],
+        engagements: engagements.sort((a, b) => a.name.localeCompare(b.name, 'ja')),
+    }));
+    return {
+        businesses: businesses.sort((a, b) => a.name.localeCompare(b.name, 'ja')),
+        unplaced,
+        excluded: { inactive: projects.length - active.length },
+    };
+}
+/**
+ * The vocabulary the world draws with: the host's kinds in their order, then
+ * kinds the Graph uses that the host did not name (under their own value),
+ * then unclassified projects; statuses are the common lifecycle words with the
+ * host's on top.
+ */
+export function resolveWorldVocabulary(config, businesses) {
+    const configured = Object.entries(config?.kinds ?? {});
+    const used = new Set(businesses.map((business) => business.kind));
+    const kinds = configured.map(([key, entry], index) => ({
+        key,
+        label: text(entry.label) ?? key,
+        form: entry.form && BUILDING_FORMS.includes(entry.form) ? entry.form : 'office',
+        color: entry.color && HEX_COLOR.test(entry.color) ? entry.color : KIND_PALETTE[index % KIND_PALETTE.length],
+        configured: true,
+    }));
+    const named = new Set(configured.map(([key]) => key));
+    [...used].filter((key) => key !== null && !named.has(key)).sort().forEach((key) => {
+        kinds.push({ key, label: key, form: 'office', color: KIND_PALETTE[kinds.length % KIND_PALETTE.length], configured: false });
+    });
+    if (used.has(null))
+        kinds.push({ key: null, label: '分類なし', form: 'office', color: UNCLASSIFIED_COLOR, configured: false });
+    const statuses = new Map(Object.entries(DEFAULT_STATUSES));
+    for (const [key, entry] of Object.entries(config?.statuses ?? {})) {
+        const base = statuses.get(key);
+        statuses.set(key, {
+            label: text(entry.label) ?? base?.label ?? key,
+            phase: entry.phase && LIFECYCLE_PHASES.includes(entry.phase) ? entry.phase : base?.phase ?? 'active',
+        });
+    }
+    return { kinds, statuses: [...statuses].map(([key, entry]) => ({ key, ...entry })) };
+}
+/** Reads and checks a vocabulary file; an invalid file is an error, never silently ignored. */
+export async function readWorldVocabulary(path) {
+    const parsed = JSON.parse(await readFile(path, 'utf8'));
+    if (!isRecord(parsed))
+        throw new Error('world vocabulary must be a JSON object');
+    const kinds = {};
+    for (const [key, entry] of Object.entries(isRecord(parsed.kinds) ? parsed.kinds : {})) {
+        if (!isRecord(entry))
+            throw new Error(`world vocabulary kind ${key} must be an object`);
+        if (entry.form !== undefined && !BUILDING_FORMS.includes(entry.form))
+            throw new Error(`world vocabulary kind ${key} has an unknown form`);
+        if (entry.color !== undefined && !(typeof entry.color === 'string' && HEX_COLOR.test(entry.color)))
+            throw new Error(`world vocabulary kind ${key} has an invalid color`);
+        kinds[key] = { ...(text(entry.label) ? { label: text(entry.label) } : {}), ...(entry.form ? { form: entry.form } : {}), ...(entry.color ? { color: entry.color } : {}) };
+    }
+    const statuses = {};
+    for (const [key, entry] of Object.entries(isRecord(parsed.statuses) ? parsed.statuses : {})) {
+        if (!isRecord(entry))
+            throw new Error(`world vocabulary status ${key} must be an object`);
+        if (entry.phase !== undefined && !LIFECYCLE_PHASES.includes(entry.phase))
+            throw new Error(`world vocabulary status ${key} has an unknown phase`);
+        statuses[key] = { ...(text(entry.label) ? { label: text(entry.label) } : {}), ...(entry.phase ? { phase: entry.phase } : {}) };
+    }
+    return { kinds, statuses };
+}
+/**
+ * The businesses from the same Graph the other screens read: the organization
+ * Graph when the host reads it (C1), else the local Graph.  A Graph that cannot
+ * be read is a state with its reason, never zero businesses.
+ */
+export async function readWorldBusinesses(context, options = {}) {
+    const now = (options.now ?? (() => new Date()))();
+    let graph;
+    let source;
+    try {
+        if (context.organizationGraph) {
+            if (!context.organizationGraph.readGraphFile) {
+                return { status: 'unavailable', version: WORLD_EXTENSION_VERSION, reason: 'organization_graph_records_unavailable' };
+            }
+            graph = await context.organizationGraph.readGraphFile();
+            source = { authority: 'organization_graph', server: context.organizationGraph.server };
+        }
+        else {
+            const state = await readLocalGraphState(context.dataDir);
+            if (state.status === 'not_initialized' || state.status === 'migration_required') {
+                return { status: state.status, version: WORLD_EXTENSION_VERSION, reason: state.status };
+            }
+            if (state.status !== 'ready')
+                return { status: 'unavailable', version: WORLD_EXTENSION_VERSION, reason: state.message ?? 'local_graph_unreadable' };
+            const os = await loadPersonalOs(context.dataDir);
+            if (os.graph.version !== 2)
+                return { status: 'migration_required', version: WORLD_EXTENSION_VERSION, reason: 'migration_required' };
+            graph = os.graph;
+            source = { authority: 'local', dataDir: context.dataDir };
+        }
+    }
+    catch (error) {
+        return { status: 'unavailable', version: WORLD_EXTENSION_VERSION, reason: error instanceof Error ? error.message : 'graph_unreadable' };
+    }
+    const projection = projectWorldFromGraph(graph, now);
+    return {
+        status: 'ok',
+        version: WORLD_EXTENSION_VERSION,
+        source,
+        as_of: now.toISOString(),
+        vocabulary: resolveWorldVocabulary(options.vocabulary, projection.businesses),
+        ...projection,
+    };
+}
+const VALUE_PROOF_SUFFIX = '.value-proof.json';
+/**
+ * Reads, for every saved value proof in the judgment journal, the repository
+ * the Host recorded for that turn. The journal is listed through the host's
+ * shared listing cache (the same one as the 今日 list), so only folders that
+ * changed are listed again; turn inputs are never rewritten by the Host, so
+ * each is read once. A journal that cannot be read is `unavailable`, never
+ * an empty list.
+ */
+export async function readJudgmentPlaces(journalRoot, options = {}) {
+    const journal = await readJudgmentValueProofJournal({ root: journalRoot, ...(options.cache ? { cache: options.cache } : {}) });
+    if (journal.status !== 'available')
+        return { status: 'unavailable', places: [], reason: 'journal_unreadable' };
+    const workspaces = options.workspaces ?? new Map();
+    const places = await Promise.all(journal.entries.map(async (entry) => {
+        const turnInputFile = `${entry.file.slice(0, -VALUE_PROOF_SUFFIX.length)}.turn-input.json`;
+        if (!workspaces.has(turnInputFile)) {
+            const turnInput = await readJsonFile(turnInputFile);
+            workspaces.set(turnInputFile, isRecord(turnInput) ? text(turnInput.project_code) : null);
+        }
+        return { decision_attempt_id: entry.proof.decision_attempt_id, workspace: workspaces.get(turnInputFile) ?? null };
+    }));
+    return { status: 'available', places };
+}
+async function readJsonFile(path) {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function createWorldModule(context, read) {
+    const workspaces = new Map();
+    return {
+        id: WORLD_EXTENSION_ID,
+        uiFiles: [],
+        async handle(request, response) {
+            if (request.method !== 'GET')
+                return false;
+            const path = requestUrl(request).pathname;
+            if (path === `/api/extensions/${WORLD_EXTENSION_ID}/businesses`) {
+                response.setHeader('Cache-Control', 'no-store');
+                writeJson(response, 200, await read());
+                return true;
+            }
+            if (path === `/api/extensions/${WORLD_EXTENSION_ID}/judgment-places`) {
+                response.setHeader('Cache-Control', 'no-store');
+                writeJson(response, 200, { version: WORLD_EXTENSION_VERSION, ...(await readJudgmentPlaces(context.journalRoot, { cache: context.journalCache, workspaces })) });
+                return true;
+            }
+            return false;
+        },
+    };
+}
+export function createWorldExtension(options = {}) {
+    return {
+        id: WORLD_EXTENSION_ID,
+        uiDir: fileURLToPath(new URL('../ui/world/', import.meta.url)),
+        uiFiles: ['world-view.js', 'world-view.css', 'world-vendor.js', 'world-placement.js'],
+        screenEntry: 'world-view.js',
+        // P17: the world sits above the home and opens first.
+        navPosition: 'first',
+        createModule: (context) => createWorldModule(context, () => readWorldBusinesses(context, { vocabulary: options.vocabulary, now: context.now })),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "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",
@@ -329,7 +329,8 @@
     "release:validate": "node scripts/npm-release.mjs validate",
     "release:publish": "node scripts/npm-release.mjs publish",
     "release:verify": "node scripts/npm-release.mjs verify",
-    "build:graph": "node scripts/build-project-graph.mjs"
+    "build:graph": "node scripts/build-project-graph.mjs",
+    "build:world": "node scripts/build-world-vendor.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
@@ -344,6 +345,7 @@
     "@electric-sql/pglite": "^0.5.8",
     "@types/node": "^22.15.29",
     "esbuild": "0.28.2",
+    "three": "0.186.1",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "vitepress": "^1.6.4",
@@ -352,5 +354,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "44f4640b17343eb3a44762b2374434568e73c890"
+  "gitHead": "ae251c43b4f42eddbeb18297e67710582a42af1f"
 }

package/ui/graph-projects-view.js

@@ -188,7 +188,8 @@ function normalizeProjectSummary(value) {
  *   プロジェクトを直す, `fields` limits its form, `edges: false` withholds 役割を直す and 関わりを終える /
  *   終了日を直す, and `createEdges: false` withholds 関係者を加える.  A withheld control is not drawn and the
  *   client refuses such a correction before sending it.  Without it every correction is allowed.
- * @param {string} [options.readOnlyNote] With `canCorrect: false`, or where `correctionScope` withholds a
+ * @param {string | ((record: { id: string, type: string | null, metadata: object } | null) => string | Element | null)} [options.readOnlyNote]
+ *   With `canCorrect: false`, or where `correctionScope` withholds a
  *   control of the selected project, a note shown in the rail where the correction buttons would be.
  *   Without it the rail says nothing about corrections.
  * @param {{ label?: string, text: string | Element }} [options.emptyNotice] Replaces the 未登録 notice
@@ -714,6 +715,8 @@ export function createGraphProjectsView({
     const detail = state.detail;
     const loaded = detail?.id === state.selectedId && detail.state === 'ok' ? detail.payload : null;
     const project = loaded?.project ?? listItem(state.selectedId) ?? { id: state.selectedId, name: state.selectedId };
+    // The record a host's read-only note may point at.
+    const noteSubject = { id: project.id, type: 'project', metadata: loaded?.project?.metadata ?? {} };
     const children = [workspaceRailHead(doc, { kicker: 'プロジェクト', title: project.name, sub: project.id })];
     if (!loaded) {
       const readState = detail?.id === state.selectedId
@@ -776,9 +779,9 @@ export function createGraphProjectsView({
       if (!loaded.participants.some((edge) => edge.id === state.panelAt)) children.push(correction.render(doc));
       // The host's reason for a control it withholds, where that control would be.
       const withheld = !canAdd || projectFields.length === 0 || (!scope.edges && loaded.participants.length > 0);
-      if (withheld) children.push(hostReadOnlyNote(doc, readOnlyNote));
+      if (withheld) children.push(hostReadOnlyNote(doc, readOnlyNote, noteSubject));
     } else {
-      children.push(hostReadOnlyNote(doc, readOnlyNote));
+      children.push(hostReadOnlyNote(doc, readOnlyNote, noteSubject));
     }
     children.push(...railExtensions(state.selectedId, loaded));
     children.push(renderOtherRelations(loaded));

package/ui/graph-registry-view.js

@@ -173,7 +173,8 @@ function textCell(value, fallback) {
  *   offer この記録を直す, `fields` limits its form, `edges: false` withholds この関係を直す and
  *   `createEdges: false` withholds 関係を加える.  A withheld control is not drawn and the client refuses
  *   such a correction before sending it.  Without it every correction is allowed.
- * @param {string} [options.readOnlyNote] With `canCorrect: false`, or where `correctionScope` withholds a
+ * @param {string | ((record: { id: string, type: string | null, metadata: object } | null) => string | Element | null)} [options.readOnlyNote]
+ *   With `canCorrect: false`, or where `correctionScope` withholds a
  *   control of the selected record, a note shown in the rail where the correction buttons would be.
  *   Without it the rail says nothing about corrections.
  * @param {{ label?: string, text: string | Element }} [options.emptyNotice] Replaces the 未登録 notice
@@ -601,6 +602,8 @@ export function createGraphRegistryView({
       children.push(graphStateNotice(doc, detail, { onRetry: () => controller.loadEntity(detail.id), loadingText: 'この記録を読み込んでいます。' }));
       return children;
     }
+    // The record a host's read-only note may point at.
+    const noteSubject = { id: entity.id, type: entity.type, metadata: loaded.entity?.metadata ?? {} };
     const summaryRows = [
       ['別名', entity.aliases.length > 0 ? entity.aliases.join('、') : { text: 'なし', className: 'is-unrecorded' }],
       ['要約', textOrNull(entity.summary)],
@@ -647,9 +650,9 @@ export function createGraphRegistryView({
       const inRelation = [...loaded.outgoing, ...loaded.incoming].some((edge) => edge.id === state.panelAt);
       if (!inRelation) children.push(correction.render(doc));
       // The host's reason for a control it withholds, where that control would be.
-      if (!canFix || (relatable && !scope.createEdges) || (related && !scope.edges)) children.push(hostReadOnlyNote(doc, readOnlyNote));
+      if (!canFix || (relatable && !scope.createEdges) || (related && !scope.edges)) children.push(hostReadOnlyNote(doc, readOnlyNote, noteSubject));
     } else {
-      children.push(hostReadOnlyNote(doc, readOnlyNote));
+      children.push(hostReadOnlyNote(doc, readOnlyNote, noteSubject));
     }
     children.push(renderRelations(loaded, 'outgoing'), renderRelations(loaded, 'incoming'));
     children.push(renderCorrectionHistory(doc, loaded.history));

package/ui/graph-view-shared.css

@@ -47,6 +47,8 @@
 /* Notices inside the rail sit closer than the workspace's. */
 .bb-graph-rail .bb-ws-notice {
   margin: 16px 0;
+  /* A host's read-only note may list steps on separate lines. */
+  white-space: pre-line;
 }
 
 .bb-graph-notice-body {

package/ui/graph-view-shared.js

@@ -459,9 +459,15 @@ function withinCorrectionScope(scope, body, recordType) {
   return scope.entity(recordType) && scope.fields(changed).length === changed.length;
 }
 
-/** A host's note that corrections are not available here, or null when it passed none. */
-export function hostReadOnlyNote(doc, readOnlyNote) {
-  const text = textOrNull(readOnlyNote);
+/**
+ * A host's note that corrections are not available here, or null when it passed none.  The host may
+ * pass a function of the selected record (`{ id, type, metadata }`) returning a string or an element,
+ * for a note that points at that record (for example a link to where it is corrected).
+ */
+export function hostReadOnlyNote(doc, readOnlyNote, subject) {
+  const value = typeof readOnlyNote === 'function' ? readOnlyNote(subject ?? null) : readOnlyNote;
+  if (value && typeof value === 'object' && typeof value.tagName === 'string') return workspaceNotice(doc, { text: value, tone: 'info' });
+  const text = textOrNull(value);
   return text ? workspaceNotice(doc, { text, tone: 'info' }) : null;
 }