@unson/brainbase-mcp 0.15.1 → 0.15.3

package/dist/world-extension.js

@@ -0,0 +1,361 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { buildJudgmentValueProofReviewHome, readJudgmentValueProofAnswers, readJudgmentValueProofFeedback, readJudgmentValueProofJournal, } from './judgment-value-proof-review.js';
+import { publicHome } from './value-proof-review-http.js';
+import { projectOrganizationGraph, projectVocabularyTerms } from './organization-graph-web.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,
+        code: text(entity.metadata?.code),
+        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, terms = undefined) {
+    // The organization names its kinds in the Graph; the host's file only adds a look (form, colour).
+    const graphTerms = new Map((terms ?? []).filter((term) => term.field === 'project.kind').map((term) => [term.value, term]));
+    const named = (key, configLabel) => {
+        const term = graphTerms.get(key);
+        if (term)
+            return { label: term.label, label_source: 'graph', definition: term.definition };
+        const label = text(configLabel);
+        return label ? { label, label_source: 'config', definition: null } : { label: key, label_source: 'value', definition: null };
+    };
+    const configured = Object.entries(config?.kinds ?? {});
+    const used = new Set(businesses.map((business) => business.kind));
+    const kinds = configured.map(([key, entry], index) => ({
+        key,
+        ...named(key, entry.label),
+        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 configuredKeys = new Set(configured.map(([key]) => key));
+    [...used].filter((key) => key !== null && !configuredKeys.has(key)).sort().forEach((key) => {
+        kinds.push({ key, ...named(key, undefined), form: 'office', color: KIND_PALETTE[kinds.length % KIND_PALETTE.length], configured: false });
+    });
+    if (used.has(null))
+        kinds.push({ key: null, label: '分類なし', label_source: 'value', definition: null, 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 })), terms: terms === undefined ? 'none' : terms === null ? 'unavailable' : 'read' };
+}
+/** 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;
+    let terms;
+    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 };
+            terms = context.organizationGraph.readVocabularyTerms ? await context.organizationGraph.readVocabularyTerms().catch(() => null) : null;
+        }
+        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, terms),
+        ...projection,
+    };
+}
+/**
+ * The world of an organization from the project and glossary-term records its Graph API returns, for an
+ * organization web that hosts the same world screen (P16).  Pure: the caller reads the records with the
+ * member's own grants, so the world shows only what that member may read.
+ */
+export function projectOrganizationWorld(records, options) {
+    const now = options.now ?? new Date();
+    const { graph } = projectOrganizationGraph({
+        entities: { person: [], org: [], project: records.projects, decision: [], raci_assignment: [] },
+        memberOf: [],
+        assignedTo: [],
+    });
+    const projection = projectWorldFromGraph(graph, now);
+    return {
+        status: 'ok',
+        version: WORLD_EXTENSION_VERSION,
+        source: { authority: 'organization_graph', server: options.server },
+        as_of: now.toISOString(),
+        vocabulary: resolveWorldVocabulary(options.vocabulary, projection.businesses, projectVocabularyTerms(records.glossaryTerms ?? [])),
+        ...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 };
+}
+/**
+ * The judgments of one organization, for a world drawn from that organization's Graph.  A judgment
+ * belongs to the organization only when the repository it was worked in is one of the organization's
+ * businesses (a registered repository or the business code, the same rule as the world's placement).
+ * Every other judgment (another company's work, or one whose repository was not recorded) is withheld:
+ * only their count leaves the host, never their questions or repositories.
+ */
+export async function readOrganizationJudgments(context, businesses, workspaces = new Map()) {
+    const journal = await readJudgmentValueProofJournal({ root: context.journalRoot, cache: context.journalCache });
+    if (journal.status !== 'available')
+        return { status: 'unavailable', scope: 'organization', withheld: 0, places: [], home: null, reason: 'journal_unreadable' };
+    const belongs = (workspace) => workspace !== null
+        && businesses.some((business) => business.repositories.includes(workspace) || business.code === workspace);
+    const kept = [];
+    const places = [];
+    for (const entry of journal.entries) {
+        const workspace = await entryWorkspace(entry.file, workspaces);
+        if (!belongs(workspace))
+            continue;
+        kept.push(entry);
+        places.push({ decision_attempt_id: entry.proof.decision_attempt_id, workspace });
+    }
+    const [feedback, answers] = await Promise.all([
+        readJudgmentValueProofFeedback({ dataDir: context.dataDir }),
+        readJudgmentValueProofAnswers({ dataDir: context.dataDir }),
+    ]);
+    // Rejected files are left out too: their names would say nothing about the organization they belong to.
+    const home = buildJudgmentValueProofReviewHome({ ...journal, entries: kept, rejected: [] }, feedback, { now: context.now(), answers });
+    return { status: 'available', scope: 'organization', withheld: journal.entries.length - kept.length, places, home: publicHome(home) };
+}
+async function entryWorkspace(valueProofFile, workspaces) {
+    const turnInputFile = `${valueProofFile.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 workspaces.get(turnInputFile) ?? null;
+}
+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}/organization-judgments`) {
+                response.setHeader('Cache-Control', 'no-store');
+                const world = await read();
+                if (world.status !== 'ok' || world.source.authority !== 'organization_graph') {
+                    writeJson(response, 200, { version: WORLD_EXTENSION_VERSION, status: 'unavailable', scope: 'organization', withheld: 0, places: [], home: null, reason: 'not_reading_organization_graph' });
+                    return true;
+                }
+                writeJson(response, 200, { version: WORLD_EXTENSION_VERSION, ...(await readOrganizationJudgments(context, world.businesses, workspaces)) });
+                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.3",
   "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",
@@ -147,6 +147,10 @@
       "types": "./dist/world-model.d.ts",
       "import": "./dist/world-model.js"
     },
+    "./world": {
+      "types": "./dist/world-extension.d.ts",
+      "import": "./dist/world-extension.js"
+    },
     "./problem-selection": {
       "types": "./dist/problem-selection.d.ts",
       "import": "./dist/problem-selection.js"
@@ -329,7 +333,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 +349,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 +358,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "44f4640b17343eb3a44762b2374434568e73c890"
+  "gitHead": "bbcd694ef8e7231d88c1522d95c701421c9c5afa"
 }

package/ui/graph-projects-view.js

@@ -34,6 +34,7 @@ import {
   graphPageContext,
   graphStateNotice,
   hostReadOnlyNote,
+  hostSourceNotice,
   isEdgeView,
   isEntityView,
   isRecord,
@@ -188,7 +189,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
@@ -506,7 +508,10 @@ export function createGraphProjectsView({
     const legacyChrome = [pageHeader];
     const children = [pageHeader];
     const dir = state.list.state === 'ok' ? textOrNull(state.list.payload.source?.dataDir) : null;
-    const sourceBlock = workspaceHostNotice(doc, sourceNotice) ?? workspaceNotice(doc, {
+    // The record a host's 出典 notice may point at: the selected project once its detail is read.
+    const sourceDetail = state.detail?.id === state.selectedId && state.detail.state === 'ok' ? state.detail.payload.project : null;
+    const sourceSubject = sourceDetail ? { id: sourceDetail.id, type: 'project', metadata: sourceDetail.metadata ?? {} } : null;
+    const sourceBlock = workspaceHostNotice(doc, hostSourceNotice(sourceNotice, sourceSubject)) ?? workspaceNotice(doc, {
       label: '出典',
       text: `このMacのGraph${dir ? `（${dir}）` : ''}から読み、ここで直した内容もそこへ保存します。関係者は、プロジェクトに参加している人や責任を持つ人の記録で、ログインや共有の設定ではありません。`,
     });
@@ -714,6 +719,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 +783,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

@@ -35,6 +35,7 @@ import {
   graphPageContext,
   graphStateNotice,
   hostReadOnlyNote,
+  hostSourceNotice,
   isEdgeView,
   isEntityView,
   isRecord,
@@ -173,7 +174,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
@@ -443,6 +445,12 @@ export function createGraphRegistryView({
     return section;
   }
 
+  /** The record a host's 出典 notice may point at: the selected record once it is read. */
+  function sourceSubject() {
+    const entity = state.detail?.state === 'ok' ? state.detail.payload.entity : null;
+    return entity ? { id: entity.id, type: entity.type, metadata: entity.metadata ?? {} } : null;
+  }
+
   function renderWorkspace() {
     const dir = state.search.state === 'ok' ? textOrNull(state.search.payload.source?.dataDir) : null;
     return [
@@ -452,7 +460,7 @@ export function createGraphRegistryView({
         lead: writable ? 'Graphに何がどう登録されているかを確かめ、誤りを直します。' : 'Graphに何がどう登録されているかを確かめます。',
         source: context.source,
       }),
-      workspaceHostNotice(doc, sourceNotice) ?? workspaceNotice(doc, {
+      workspaceHostNotice(doc, hostSourceNotice(sourceNotice, sourceSubject())) ?? workspaceNotice(doc, {
         label: '出典',
         text: `このMacのGraph${dir ? `（${dir}）` : ''}だけを表示します。ここで直した内容は、同じGraphを読むMCPの search・get_context・resolve_entity で次から使われます。`,
       }),
@@ -601,6 +609,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 +657,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,64 @@ 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 出典 notice with its text resolved for the selected record: the host may pass `text` as a
+ * function of that record (`{ id, type, metadata }`, or null before one is read), for a notice that points
+ * at it.  Returns the notice for `workspaceHostNotice`, or the value it was given.
+ */
+export function hostSourceNotice(sourceNotice, subject) {
+  if (!sourceNotice || typeof sourceNotice.text !== 'function') return sourceNotice;
+  return { ...sourceNotice, text: sourceNotice.text(subject ?? null) };
+}
+
+// ---------------------------------------------------------------------------
+// The organization's web (Inspector UX-20261004-01)
+
+const ORGANIZATION_RECORD_ID = /^[A-Za-z0-9_.:-]{1,200}$/u;
+
+/** The organization web's origin the host was told about, or null. */
+export function organizationWebOrigin(organizationGraph) {
+  if (organizationGraph?.status !== 'connected') return null;
+  const origin = organizationGraph.web_url;
+  return typeof origin === 'string' && /^https:\/\/[^/?#@\s]+$/u.test(origin) ? origin : null;
+}
+
+/**
+ * Where a record opens in the organization web, `{ href, label }`, or null when it has no usable id.  The
+ * organization web opens 情報と関係 by record id and プロジェクトと関係者 by project code, and keeps that record
+ * across sign-in.  A project opens by its own code only: a sub-project's scope code is its parent's and
+ * would open the parent, so without its own code the record opens by id.
+ */
+export function organizationRecordLink(origin, screenId, record) {
+  const id = typeof record?.id === 'string' && ORGANIZATION_RECORD_ID.test(record.id) ? record.id : null;
+  const own = typeof record?.metadata?.code === 'string' ? record.metadata.code.trim() : '';
+  const code = own && ORGANIZATION_RECORD_ID.test(own) ? own : null;
+  if (screenId === 'projects' && record?.type === 'project' && code) {
+    return { href: `${origin}/?screen=projects&project=${encodeURIComponent(code)}`, label: '「プロジェクトと関係者」' };
+  }
+  return id ? { href: `${origin}/?screen=graph&entity_id=${encodeURIComponent(id)}`, label: '「情報と関係」' } : null;
+}
+
+export const ORGANIZATION_RECORD_LINK_TEXT = '組織版でこの記録を開く';
+
+/** A link that opens `target` from organizationRecordLink in a new tab. */
+export function organizationRecordAnchor(doc, target, className) {
+  return makeElement(doc, 'a', {
+    ...(className ? { className } : {}),
+    text: ORGANIZATION_RECORD_LINK_TEXT,
+    attrs: { href: target.href, target: '_blank', rel: 'noopener noreferrer' },
+  });
+}
+
+/**
+ * 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;
 }