@unson/brainbase-mcp 0.6.0 → 0.8.0

package/ui/world-model-view.css

@@ -0,0 +1,188 @@
+/*
+ * Read-only World Model view (現状と見通し), on the organization edition's
+ * screen pattern: a section title under the page head (workspace-kit.css),
+ * then one read-only ledger per block.  Uses only the shared tokens in
+ * brainbase-tokens.css.
+ */
+.bb-wm {
+  display: block;
+  min-width: 0;
+  color: var(--bb-color-ink);
+  font-family: var(--bb-font-sans);
+  line-height: 1.5;
+}
+
+.bb-wm *,
+.bb-wm *::before,
+.bb-wm *::after {
+  box-sizing: border-box;
+}
+
+.bb-wm h3,
+.bb-wm p {
+  margin: 0;
+}
+
+.bb-wm > .bb-ws-section-title {
+  margin-top: var(--bb-space-4);
+}
+
+/* Blocks: a heading, a lead, state notices and the ledger. */
+.bb-wm-block {
+  display: grid;
+  gap: var(--bb-space-2);
+  min-width: 0;
+  margin-top: var(--bb-space-6);
+}
+
+.bb-wm-heading {
+  color: var(--bb-color-ink);
+  font-size: 15px;
+}
+
+.bb-wm-lead {
+  margin-bottom: var(--bb-space-2);
+  color: var(--bb-color-muted);
+  font-size: 13px;
+}
+
+.bb-wm-block > .bb-ws-notice {
+  margin: 0;
+}
+
+.bb-wm-notice-body {
+  display: grid;
+  gap: var(--bb-space-2);
+  min-width: 0;
+}
+
+.bb-wm-notice-body .bb-ws-button {
+  justify-self: start;
+}
+
+/* The local shell resets `.bb-shell button { font: inherit }`, which outranks the kit's button type. */
+.bb-wm .bb-ws-button {
+  font-size: 12px;
+  font-weight: 680;
+}
+
+/* Rows wrap: a reference view keeps its details readable instead of cutting them. */
+.bb-wm .bb-ws-ledger-row:not(.bb-ws-ledger-head) {
+  align-items: start;
+}
+
+.bb-wm .bb-ws-ledger-row > span {
+  white-space: normal;
+  overflow-wrap: anywhere;
+}
+
+.bb-wm-cell {
+  display: grid;
+  gap: 2px;
+  min-width: 0;
+}
+
+.bb-wm-main {
+  color: var(--bb-color-ink);
+  font-size: 13px;
+}
+
+.bb-wm-cell small {
+  color: var(--bb-color-muted);
+  font-size: 11px;
+}
+
+.bb-wm-cell small.is-warning {
+  color: var(--bb-color-warning);
+  font-weight: 650;
+}
+
+.bb-wm-cell small.is-accent {
+  color: var(--bb-color-accent-strong);
+  font-weight: 650;
+}
+
+.bb-wm-cell.is-value .bb-wm-main,
+.bb-wm-view-ledger .bb-ws-ledger-row > span:first-child .bb-wm-main {
+  font-weight: 690;
+}
+
+.bb-wm-cell.is-verified .bb-wm-main,
+.bb-wm-cell.is-supported .bb-wm-main,
+.bb-wm-cell.is-approved .bb-wm-main {
+  color: var(--bb-color-accent-strong);
+  font-weight: 690;
+}
+
+.bb-wm-cell.is-hypothesis .bb-wm-main,
+.bb-wm-cell.is-unverified .bb-wm-main,
+.bb-wm-cell.is-pending .bb-wm-main {
+  color: var(--bb-color-warning);
+  font-weight: 690;
+}
+
+.bb-wm-cell.is-refuted .bb-wm-main {
+  color: var(--bb-color-danger);
+  font-weight: 690;
+}
+
+.bb-wm-cell.is-unresolved .bb-wm-main {
+  color: var(--bb-color-quiet);
+}
+
+.bb-wm-code {
+  color: var(--bb-color-muted);
+  font-family: var(--bb-font-mono);
+  font-size: 11px;
+}
+
+.bb-wm .bb-ws-ledger-row.is-superseded {
+  background: var(--bb-color-surface);
+}
+
+.bb-wm .bb-ws-ledger-row.is-superseded .bb-wm-cell.is-value .bb-wm-main {
+  color: var(--bb-color-muted);
+  text-decoration: line-through;
+}
+
+/* Column templates. */
+.bb-wm-view-ledger .bb-ws-ledger-row {
+  grid-template-columns: minmax(180px, 2.2fr) minmax(84px, .8fr) 84px minmax(96px, .9fr);
+}
+
+.bb-wm-observation-ledger .bb-ws-ledger-row {
+  grid-template-columns: minmax(120px, 1.3fr) minmax(96px, 1fr) minmax(128px, 1.3fr) 104px minmax(110px, 1.1fr);
+}
+
+.bb-wm-adoption-ledger .bb-ws-ledger-row {
+  grid-template-columns: minmax(140px, 1.4fr) 72px minmax(140px, 1.6fr) 56px minmax(84px, .8fr) 104px;
+}
+
+@media (max-width: 760px) {
+  .bb-wm-view-ledger .bb-ws-ledger-row {
+    grid-template-columns: minmax(0, 1fr) 72px;
+  }
+
+  .bb-wm-view-ledger .bb-ws-ledger-row > span:nth-child(2),
+  .bb-wm-view-ledger .bb-ws-ledger-row > span:nth-child(4) {
+    display: none;
+  }
+
+  .bb-wm-observation-ledger .bb-ws-ledger-row {
+    grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  }
+
+  .bb-wm-observation-ledger .bb-ws-ledger-row > span:nth-child(3),
+  .bb-wm-observation-ledger .bb-ws-ledger-row > span:nth-child(4),
+  .bb-wm-observation-ledger .bb-ws-ledger-row > span:nth-child(5) {
+    display: none;
+  }
+
+  .bb-wm-adoption-ledger .bb-ws-ledger-row {
+    grid-template-columns: minmax(0, 1fr) 72px;
+  }
+
+  .bb-wm-adoption-ledger .bb-ws-ledger-row > span:nth-child(n + 3) {
+    display: none;
+  }
+}

package/ui/world-model-view.js

@@ -0,0 +1,486 @@
+/*
+ * Read-only World Model view (現状と見通し).
+ *
+ * Shows recorded observations apart from the variables and models that are
+ * the owner's way of seeing them (which may be hypotheses), plus model
+ * adoptions.  The host injects the fetcher and base path; this module keeps
+ * no global state and never writes.  Each section loads on its own: a failed
+ * or unverifiable section is reported in place and never shown as zero items.
+ *
+ * Drawn with the organization edition's screen pattern (workspace-kit): a
+ * section title under the page head, then one read-only ledger per block.
+ * Rows are not selectable, so the view never writes to the host's rail.
+ *
+ * A section the host cannot serve answers `{ status: 'unavailable', reason }`
+ * (HTTP 200).  It is shown as unavailable, never as zero items; a host with no
+ * World Model source at all can pass `unavailableNotice` to show one notice
+ * with its own copy instead of four.
+ */
+
+import { workspaceButton, workspaceLedger, workspaceNotice, workspaceSectionTitle } from './workspace-kit.js';
+
+export const WORLD_MODEL_VIEW_CONTRACT_VERSION = 'brainbase.world-model-view.v1';
+
+export const WORLD_MODEL_SECTIONS = Object.freeze(['variables', 'models', 'observations', 'adoptions']);
+
+const SECTION_KEYS = Object.freeze({ variables: 'records', models: 'records', observations: 'observations', adoptions: 'adoptions' });
+
+export const EPISTEMIC_STATE_LABELS = Object.freeze({
+  unverified: '未検証',
+  hypothesis: '仮説',
+  supported: '支持',
+  verified: '検証済み',
+  refuted: '反証',
+});
+const ADOPTION_LABELS = Object.freeze({ draft: '下書き', proposed: '提案中', approved: '承認済み', retired: '終了' });
+const VALIDATION_LABELS = Object.freeze({ unverified: '未検証', in_progress: '検証中', supported: '支持', verified: '検証済み', refuted: '反証' });
+const SOURCE_KIND_LABELS = Object.freeze({ candidate: '候補', document: '文書', observation: '観測', decision: '判断', import: '取り込み' });
+const USE_LABELS = Object.freeze({ draft: '下書き', judgment: '判断', evaluation: '評価', execution: '実行' });
+const UNREADABLE_LABELS = Object.freeze({
+  authorization_denied: '読む権限がない',
+  scope_violation: '扱える範囲の外',
+  invalid_input: '変数の定義と合わない',
+  not_found: '参照先が見つからない',
+});
+
+function getDocument(explicit) {
+  const value = explicit ?? (typeof document === 'undefined' ? null : document);
+  if (!value || typeof value.createElement !== 'function') throw new Error('document_unavailable');
+  return value;
+}
+
+function makeElement(doc, tag, { className, text, attrs = {} } = {}) {
+  const element = doc.createElement(tag);
+  if (className) element.className = className;
+  if (text !== undefined && text !== null) element.textContent = String(text);
+  for (const [name, value] of Object.entries(attrs)) {
+    if (value === undefined || value === null || value === false) continue;
+    element.setAttribute(name, value === true ? '' : String(value));
+  }
+  return element;
+}
+
+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 formatDateTime(value) {
+  const time = typeof value === 'string' ? Date.parse(value) : Number.NaN;
+  if (Number.isNaN(time)) return '日時不明';
+  const date = new Date(time);
+  const pad = (number) => String(number).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+function formatValue(value, unit) {
+  const rendered = typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+    ? String(value)
+    : JSON.stringify(value);
+  return unit ? `${rendered} ${unit}` : rendered;
+}
+
+function isRevisionRef(value) {
+  return isRecord(value) && typeof value.id === 'string' && typeof value.revision === 'string';
+}
+
+function isDefinitionRecord(value, type) {
+  return isRecord(value) && isRecord(value.definition) && value.definition.type === type
+    && typeof value.definition.id === 'string' && typeof value.definition.revision === 'string';
+}
+
+function isObservation(value) {
+  return isRecord(value) && typeof value.id === 'string' && isRevisionRef(value.variableRef)
+    && typeof value.subjectId === 'string' && typeof value.occurredAt === 'string' && typeof value.recordedAt === 'string'
+    && isRecord(value.period) && isRecord(value.sourceRef) && 'value' in value;
+}
+
+function isAdoption(value) {
+  return isRecord(value) && typeof value.adoptionId === 'string' && isRevisionRef(value.modelRef)
+    && typeof value.adoptionState === 'string' && isRecord(value.candidate);
+}
+
+const ITEM_CHECKS = Object.freeze({
+  variables: (item) => isDefinitionRecord(item, 'variable'),
+  models: (item) => isDefinitionRecord(item, 'model'),
+  observations: isObservation,
+  adoptions: isAdoption,
+});
+
+/**
+ * Normalize one section response.  A missing array or a malformed item is
+ * `invalid`; an empty array is `empty` only when the host confirmed absence.
+ */
+export function normalizeWorldModelSection(section, payload) {
+  const key = SECTION_KEYS[section];
+  if (key && isRecord(payload) && (payload.status === 'unavailable' || payload.state === 'unavailable')) {
+    return { state: 'unavailable', items: null, reason: text(payload.reason) };
+  }
+  if (!key || !isRecord(payload) || !Array.isArray(payload[key])) {
+    return { state: 'invalid', items: null, reason: '応答の形式が不正です' };
+  }
+  const items = payload[key];
+  if (!items.every(ITEM_CHECKS[section])) return { state: 'invalid', items: null, reason: '応答の記録の形式が不正です' };
+  const unreadableCount = Number.isInteger(payload.unreadable?.count) && payload.unreadable.count > 0 ? payload.unreadable.count : 0;
+  const unreadableCodes = Array.isArray(payload.unreadable?.codes) ? payload.unreadable.codes.filter((code) => typeof code === 'string') : [];
+  const unreadable = { count: unreadableCount, codes: unreadableCodes };
+  if (items.length === 0) {
+    return payload.absence_confirmed === true && unreadableCount === 0
+      ? { state: 'empty', items: [], unreadable }
+      : { state: 'unknown', items: null, unreadable };
+  }
+  return { state: unreadableCount > 0 ? 'partial' : 'ready', items, unreadable };
+}
+
+function unreadableMessage(unreadable) {
+  const reasons = unreadable.codes.map((code) => UNREADABLE_LABELS[code] ?? code).join('、');
+  return `読めない記録が${unreadable.count}件あります${reasons ? `（${reasons}）` : ''}。読めた記録だけを表示しています。`;
+}
+
+function refLabel(ref, names) {
+  const name = names.get(ref.id);
+  return name ? `${name}（${ref.id}@${ref.revision}）` : `${ref.id}@${ref.revision}`;
+}
+
+/** A ledger cell with a main line and quieter detail lines (the World Model rows wrap instead of cutting text). */
+function stack(doc, main, details = [], className = '') {
+  const cell = makeElement(doc, 'span', { className: `bb-wm-cell${className ? ` ${className}` : ''}` });
+  cell.append(makeElement(doc, 'span', { className: 'bb-wm-main', text: main }));
+  for (const detail of details) {
+    if (!detail) continue;
+    const [value, tone] = Array.isArray(detail) ? detail : [detail, ''];
+    cell.append(makeElement(doc, 'small', { className: tone ? `is-${tone}` : undefined, text: value }));
+  }
+  return cell;
+}
+
+/** One element for a notice body, so the kit's label column stays on the left. */
+function noticeBody(doc, message, action) {
+  const body = makeElement(doc, 'div', { className: 'bb-wm-notice-body' });
+  body.append(makeElement(doc, 'p', { text: message }));
+  if (action) body.append(action);
+  return body;
+}
+
+/**
+ * A section's state as a notice, or nothing when its rows can be shown.
+ * Returns `{ notice, rows }`: rows is false when the section has none to show.
+ */
+function sectionStatus(doc, label, section, sectionState, callbacks, emptyText) {
+  const { state } = sectionState;
+  if (state === 'loading' || state === 'idle') {
+    return { notice: workspaceNotice(doc, { label, text: '読み込んでいます。' }), rows: false };
+  }
+  if (state === 'approval_unverifiable') {
+    return {
+      notice: workspaceNotice(doc, { label, tone: 'warning', text: '承認を確かめられないため表示できません。承認済みの採用を確かめる仕組みがこのホストにありません。ほかの欄はそのまま使えます。' }),
+      rows: false,
+    };
+  }
+  if (state === 'error' || state === 'invalid') {
+    const retry = workspaceButton(doc, { text: '再試行', variant: 'quiet', onClick: () => void callbacks.onRetry?.(section) });
+    return {
+      notice: workspaceNotice(doc, { label, tone: 'danger', text: noticeBody(doc, `読み取れませんでした（${sectionState.reason ?? '理由不明'}）。0件ではありません。`, retry) }),
+      rows: false,
+    };
+  }
+  if (state === 'unavailable') {
+    return {
+      notice: workspaceNotice(doc, { label, tone: 'warning', text: `このホストでは読めません（${sectionState.reason ?? '理由不明'}）。0件ではありません。` }),
+      rows: false,
+    };
+  }
+  if (state === 'unknown') {
+    const message = sectionState.unreadable?.count
+      ? unreadableMessage(sectionState.unreadable)
+      : '記録の有無を確かめられません。0件ではありません。';
+    return { notice: workspaceNotice(doc, { label, tone: 'warning', text: message }), rows: false };
+  }
+  if (state === 'empty') return { notice: workspaceNotice(doc, { label, text: emptyText }), rows: false };
+  if (state === 'partial') return { notice: workspaceNotice(doc, { label, tone: 'warning', text: unreadableMessage(sectionState.unreadable) }), rows: true };
+  return { notice: null, rows: true };
+}
+
+function epistemicText(state) {
+  return EPISTEMIC_STATE_LABELS[state] ?? null;
+}
+
+function viewRows(doc, state, statuses, variableNames) {
+  const rows = [];
+  if (statuses.variables.rows) {
+    for (const record of state.variables.items) {
+      const definition = record.definition;
+      const epistemic = epistemicText(definition.epistemicState);
+      rows.push({
+        key: `variable:${definition.id}`,
+        cells: [
+          stack(doc, text(definition.meaning) ?? definition.id, [
+            text(definition.subject) ? `対象: ${text(definition.subject)}` : null,
+            text(definition.unit) ? `単位: ${text(definition.unit)}` : null,
+            text(definition.measurementMethod) ? `測り方: ${text(definition.measurementMethod)}` : null,
+          ]),
+          stack(doc, '変数', [ADOPTION_LABELS[definition.adoptionState] ?? (definition.adoptionState ? String(definition.adoptionState) : '採用 未記録')]),
+          stack(doc, epistemic ?? '未記録', [], epistemic ? `is-${definition.epistemicState}` : 'is-unresolved'),
+          { text: `${definition.id}@${definition.revision}`, className: 'bb-wm-code' },
+        ],
+      });
+    }
+  }
+  if (statuses.models.rows) {
+    for (const record of state.models.items) {
+      const definition = record.definition;
+      const refs = (value) => (Array.isArray(value) && value.length > 0 ? value.filter(isRevisionRef).map((ref) => refLabel(ref, variableNames)).join('、') : null);
+      const epistemic = epistemicText(definition.epistemicState);
+      rows.push({
+        key: `model:${definition.id}`,
+        cells: [
+          stack(doc, text(definition.meaning) ?? definition.id, [
+            text(definition.relationship) ? `関係: ${text(definition.relationship)}` : null,
+            text(definition.uncertainty) ? `不確かさ: ${text(definition.uncertainty)}` : null,
+            refs(definition.inputVariableRefs) ? `入力: ${refs(definition.inputVariableRefs)}` : null,
+            refs(definition.outputVariableRefs) ? `出力: ${refs(definition.outputVariableRefs)}` : null,
+          ]),
+          stack(doc, 'モデル', [`検証: ${VALIDATION_LABELS[definition.validationState] ?? '未記録'}`]),
+          stack(doc, epistemic ?? '未記録', [], epistemic ? `is-${definition.epistemicState}` : 'is-unresolved'),
+          { text: `${definition.id}@${definition.revision}`, className: 'bb-wm-code' },
+        ],
+      });
+    }
+  }
+  return rows;
+}
+
+function observationRows(doc, state, names, units) {
+  const correctedBy = new Map();
+  for (const observation of state.observations.items) {
+    if (typeof observation.supersedes === 'string') correctedBy.set(observation.supersedes, observation.id);
+  }
+  return state.observations.items.map((observation) => {
+    const newer = correctedBy.get(observation.id);
+    const source = observation.sourceRef;
+    const chain = [];
+    if (typeof observation.supersedes === 'string') chain.push([`観測「${observation.supersedes}」を訂正`, 'accent']);
+    if (newer) chain.push([`観測「${newer}」で訂正済み`, 'warning']);
+    return {
+      key: observation.id,
+      className: newer ? 'is-superseded' : '',
+      cells: [
+        stack(doc, observation.subjectId, [refLabel(observation.variableRef, names)]),
+        stack(doc, formatValue(observation.value, units.get(observation.variableRef.id)), chain, 'is-value'),
+        stack(doc, `${formatDateTime(observation.period.from)} 〜 ${formatDateTime(observation.period.until)}`, [`発生 ${formatDateTime(observation.occurredAt)}`]),
+        stack(doc, formatDateTime(observation.recordedAt)),
+        stack(doc, `${SOURCE_KIND_LABELS[source.sourceKind] ?? String(source.sourceKind)}（${String(source.sourceId)}）`, [`観測ID ${observation.id}`]),
+      ],
+    };
+  });
+}
+
+function adoptionRows(doc, state, modelNames) {
+  return state.adoptions.items.map((adoption) => {
+    const candidate = adoption.candidate;
+    return {
+      key: adoption.adoptionId,
+      cells: [
+        stack(doc, refLabel(adoption.modelRef, modelNames)),
+        stack(doc, ADOPTION_LABELS[adoption.adoptionState] ?? String(adoption.adoptionState), [], adoption.adoptionState === 'approved' ? 'is-approved' : 'is-pending'),
+        stack(doc, text(candidate.hypothesis) ?? '仮説の記録なし', [
+          EPISTEMIC_STATE_LABELS[candidate.epistemicState] ? `候補の認識: ${EPISTEMIC_STATE_LABELS[candidate.epistemicState]}` : null,
+          Array.isArray(candidate.evidenceIds) ? `証拠 ${candidate.evidenceIds.length}件` : null,
+        ]),
+        stack(doc, USE_LABELS[adoption.authorizedUse] ?? text(adoption.authorizedUse) ?? '未記録'),
+        stack(doc, isRevisionRef(adoption.approvalRef) ? `${adoption.approvalRef.id}@${adoption.approvalRef.revision}` : 'なし'),
+        stack(doc, formatDateTime(adoption.adoptedAt)),
+      ],
+    };
+  });
+}
+
+function namesOf(section) {
+  const names = new Map();
+  const units = new Map();
+  for (const record of section.items ?? []) {
+    const definition = record.definition;
+    if (text(definition.meaning)) names.set(definition.id, text(definition.meaning));
+    if (text(definition.unit)) units.set(definition.id, text(definition.unit));
+  }
+  return { names, units };
+}
+
+function block(doc, label, heading, lead) {
+  const section = makeElement(doc, 'section', { className: 'bb-wm-block', attrs: { 'aria-label': label } });
+  section.append(makeElement(doc, 'h3', { className: 'bb-wm-heading', text: heading }), makeElement(doc, 'p', { className: 'bb-wm-lead', text: lead }));
+  return section;
+}
+
+/**
+ * The host's single notice when no section can be served: its title and
+ * guidance, then the reasons the sections gave.  Null when the host passed no
+ * copy or when any section is readable, loading or failed in another way.
+ */
+function unavailableSummary(doc, state, unavailableNotice) {
+  if (!isRecord(unavailableNotice) || !text(unavailableNotice.title)) return null;
+  if (!WORLD_MODEL_SECTIONS.every((section) => state[section]?.state === 'unavailable')) return null;
+  const labels = isRecord(unavailableNotice.reasonLabels) ? unavailableNotice.reasonLabels : {};
+  const reasonText = (reason) => (Object.hasOwn(labels, reason) && text(labels[reason])) || reason;
+  const reasons = [...new Set(WORLD_MODEL_SECTIONS.map((section) => state[section].reason).filter(Boolean).map(reasonText))];
+  const body = makeElement(doc, 'div', { className: 'bb-wm-notice-body' });
+  if (text(unavailableNotice.guidance)) body.append(makeElement(doc, 'p', { text: text(unavailableNotice.guidance) }));
+  body.append(makeElement(doc, 'p', { text: `理由: ${reasons.length > 0 ? reasons.join('、') : '理由不明'}。0件ではありません。` }));
+  return workspaceNotice(doc, { label: text(unavailableNotice.title), text: body, tone: 'info' });
+}
+
+/**
+ * Render the whole view into a host-owned root: a section title and read-only ledgers.
+ * `options.unavailableNotice` is the host's `{ title, guidance }` shown once
+ * when every section is unavailable.
+ */
+export function renderWorldModelView(root, state, callbacks = {}, options = {}) {
+  const doc = getDocument(options.document);
+  root.replaceChildren();
+  const surface = makeElement(doc, 'section', { className: 'bb-wm', attrs: { 'data-contract-version': WORLD_MODEL_VIEW_CONTRACT_VERSION, 'aria-label': '現状と見通し' } });
+  surface.append(workspaceSectionTitle(doc, {
+    title: '現状と見通し',
+    lead: '見方（変数とモデル。仮説を含みます）と、記録された観測を分けて表示します。この欄は表示だけです。',
+  }));
+  const unavailable = unavailableSummary(doc, state, options.unavailableNotice);
+  if (unavailable) {
+    surface.append(unavailable);
+    root.append(surface);
+    return surface;
+  }
+
+  const variables = namesOf(state.variables);
+  const models = namesOf(state.models);
+
+  const view = block(doc, '変数とモデル', '見方：変数とモデル', '何を測り、どう関係すると考えているか。認識の状態は、確かめた度合いです。観測ではありません。');
+  const statuses = {
+    variables: sectionStatus(doc, '変数', 'variables', state.variables, callbacks, '変数はまだ登録がありません。'),
+    models: sectionStatus(doc, 'モデル', 'models', state.models, callbacks, 'モデルはまだ登録がありません。'),
+  };
+  for (const status of Object.values(statuses)) if (status.notice) view.append(status.notice);
+  const rows = viewRows(doc, state, statuses, variables.names);
+  if (rows.length > 0) {
+    view.append(workspaceLedger(doc, { className: 'bb-wm-view-ledger', ariaLabel: '変数とモデル', columns: ['名前', '種類', '認識の状態', '版'], rows }));
+  }
+  surface.append(view);
+
+  const observed = block(doc, '観測', '観測：記録された値', '実際に記録された値です。推定や予測は含みません。訂正は新しい観測として残り、元の観測との関係を示します。');
+  const observedStatus = sectionStatus(doc, '観測', 'observations', state.observations, callbacks, '観測はまだ記録がありません。');
+  if (observedStatus.notice) observed.append(observedStatus.notice);
+  if (observedStatus.rows) {
+    observed.append(workspaceLedger(doc, {
+      className: 'bb-wm-observation-ledger',
+      ariaLabel: '観測',
+      columns: ['対象', '値', '期間', '記録', '出典'],
+      rows: observationRows(doc, state, variables.names, variables.units),
+    }));
+  }
+  surface.append(observed);
+
+  const adopted = block(doc, 'モデルの採用', 'モデルの採用', 'どのモデルを、どの根拠で判断などに使うことにしたか。');
+  const adoptedStatus = sectionStatus(doc, '採用', 'adoptions', state.adoptions, callbacks, 'モデルの採用はまだありません。');
+  if (adoptedStatus.notice) adopted.append(adoptedStatus.notice);
+  if (adoptedStatus.rows) {
+    adopted.append(workspaceLedger(doc, {
+      className: 'bb-wm-adoption-ledger',
+      ariaLabel: 'モデルの採用',
+      columns: ['モデル', '状態', '根拠', '用途', '承認', '日時'],
+      rows: adoptionRows(doc, state, models.names),
+    }));
+  }
+  surface.append(adopted);
+
+  root.append(surface);
+  return surface;
+}
+
+async function readError(response) {
+  try {
+    const body = await response.json();
+    return { code: text(body?.error?.code), message: text(body?.error?.message) };
+  } catch {
+    return { code: null, message: null };
+  }
+}
+
+/**
+ * Mounts the read-only World Model view.
+ *
+ * @param {object} options
+ * @param {Element} options.root Where the view is drawn.
+ * @param {Element} [options.rail] Accepted for the host's screen contract; the view never writes to it.
+ * @param {Document} [options.document] The document to build elements with (default: the global one).
+ * @param {Function} [options.fetcher] `fetch`-compatible function for the sections.
+ * @param {string} [options.basePath='/api/world-model'] Where `{variables,models,observations,adoptions}` are served.
+ * @param {boolean} [options.autoLoad=true] Reads every section on mount.
+ * @param {{ title: string, guidance?: string, reasonLabels?: Record<string, string> }} [options.unavailableNotice]
+ *   When every section is unavailable (for example the host has no World Model source), one notice
+ *   with this title (the notice's short label) and guidance, plus the reasons, replaces the blocks.
+ *   `reasonLabels` says a reason code in the host's words.  Without it each block reports its own
+ *   state, as by default.
+ * @returns The controller: `state`, `render()`, `load()`, `loadSection(section)`.
+ */
+export function createWorldModelView({
+  root,
+  /** Accepted for the host's screen contract; the read-only view keeps the rail to the screen's editor. */
+  rail: _rail,
+  document: explicitDocument,
+  fetcher,
+  basePath = '/api/world-model',
+  autoLoad = true,
+  unavailableNotice,
+} = {}) {
+  if (!root) throw new TypeError('root is required');
+  const doc = getDocument(explicitDocument);
+  const request = typeof fetcher === 'function'
+    ? fetcher
+    : typeof globalThis.fetch === 'function' ? (path, init) => globalThis.fetch(path, init) : null;
+  const base = String(basePath).replace(/\/+$/u, '');
+  const state = Object.fromEntries(WORLD_MODEL_SECTIONS.map((section) => [section, { state: 'loading', items: null }]));
+
+  const callbacks = { onRetry: (section) => controller.loadSection(section) };
+
+  const controller = {
+    get state() { return state; },
+    render() {
+      renderWorldModelView(root, state, callbacks, { document: doc, unavailableNotice });
+      return controller;
+    },
+    async loadSection(section) {
+      state[section] = { state: 'loading', items: null };
+      controller.render();
+      if (!request) {
+        state[section] = { state: 'error', items: null, reason: '取得先が設定されていません' };
+        controller.render();
+        return state[section];
+      }
+      try {
+        const response = await request(`${base}/${section}`);
+        if (!response.ok) {
+          const error = await readError(response);
+          state[section] = error.code === 'approval_reference_unresolved'
+            ? { state: 'approval_unverifiable', items: null }
+            : { state: 'error', items: null, reason: error.message ?? error.code ?? `HTTP ${response.status}` };
+        } else {
+          state[section] = normalizeWorldModelSection(section, await response.json());
+        }
+      } catch (error) {
+        state[section] = { state: 'error', items: null, reason: error instanceof Error ? error.message : 'request_failed' };
+      }
+      controller.render();
+      return state[section];
+    },
+    async load() {
+      await Promise.all(WORLD_MODEL_SECTIONS.map((section) => controller.loadSection(section)));
+      return state;
+    },
+  };
+  controller.render();
+  if (autoLoad) void controller.load();
+  return controller;
+}
+
+export default createWorldModelView;