@unson/brainbase-mcp 0.10.15 → 0.12.0

package/dist/server-support.js

@@ -0,0 +1,158 @@
+/**
+ * Small HTTP-host helpers shared by Brainbase servers: a structured error with
+ * client-safe JSON, an async route wrapper, and a JSON logger that masks
+ * secrets. They carry no organization, tenant, or deployment concept.
+ */
+/** Standard error codes. `code` is safe to expose to clients. */
+export const ErrorCodes = {
+    VALIDATION_ERROR: { code: 'VALIDATION_ERROR', statusCode: 400 },
+    INVALID_DATE_FORMAT: { code: 'INVALID_DATE_FORMAT', statusCode: 400 },
+    MISSING_REQUIRED_FIELD: { code: 'MISSING_REQUIRED_FIELD', statusCode: 400 },
+    UNSUPPORTED_FORMAT: { code: 'UNSUPPORTED_FORMAT', statusCode: 400 },
+    UNAUTHORIZED: { code: 'UNAUTHORIZED', statusCode: 401 },
+    FORBIDDEN: { code: 'FORBIDDEN', statusCode: 403 },
+    CROSS_TENANT_CANDIDATE: { code: 'CROSS_TENANT_CANDIDATE', statusCode: 403 },
+    PROJECT_NOT_FOUND: { code: 'PROJECT_NOT_FOUND', statusCode: 404 },
+    SESSION_NOT_FOUND: { code: 'SESSION_NOT_FOUND', statusCode: 404 },
+    TASK_NOT_FOUND: { code: 'TASK_NOT_FOUND', statusCode: 404 },
+    SCHEDULE_NOT_FOUND: { code: 'SCHEDULE_NOT_FOUND', statusCode: 404 },
+    WORKTREE_NOT_FOUND: { code: 'WORKTREE_NOT_FOUND', statusCode: 404 },
+    EVENT_NOT_FOUND: { code: 'EVENT_NOT_FOUND', statusCode: 404 },
+    CONFLICT: { code: 'CONFLICT', statusCode: 409 },
+    PORT_IN_USE: { code: 'PORT_IN_USE', statusCode: 409 },
+    INTERNAL_ERROR: { code: 'INTERNAL_ERROR', statusCode: 500 },
+    DATABASE_ERROR: { code: 'DATABASE_ERROR', statusCode: 500 },
+    PROJECT_CATALOG_UNAVAILABLE: { code: 'PROJECT_CATALOG_UNAVAILABLE', statusCode: 503 },
+    TIMEOUT: { code: 'TIMEOUT', statusCode: 504 },
+};
+/** A structured error: the message and code go to clients, details stay in logs. */
+export class AppError extends Error {
+    code;
+    statusCode;
+    timestamp;
+    details;
+    cause;
+    constructor(message, errorCode, options = {}) {
+        super(message);
+        this.name = 'AppError';
+        this.code = errorCode.code;
+        this.statusCode = errorCode.statusCode;
+        this.timestamp = new Date().toISOString();
+        this.details = options.details || null;
+        if (options.cause)
+            this.cause = options.cause;
+    }
+    /** Client-safe JSON. It never includes details. */
+    toJSON() {
+        return { error: { code: this.code, message: this.message, timestamp: this.timestamp } };
+    }
+    /** Log object, including details and the cause message. */
+    toLog() {
+        const log = {
+            code: this.code,
+            message: this.message,
+            statusCode: this.statusCode,
+            timestamp: this.timestamp,
+        };
+        if (this.details)
+            log.details = this.details;
+        if (this.cause)
+            log.cause = this.cause instanceof Error ? this.cause.message : String(this.cause);
+        return log;
+    }
+    static isAppError(error) {
+        return error instanceof AppError;
+    }
+    static notFound(resource, id) {
+        const dynamicCode = ErrorCodes[`${resource.toUpperCase()}_NOT_FOUND`];
+        return new AppError(`${resource} '${id}' not found`, dynamicCode || ErrorCodes.SESSION_NOT_FOUND);
+    }
+    static validation(message, details) {
+        return new AppError(message, ErrorCodes.VALIDATION_ERROR, { details });
+    }
+    static unauthorized(message = 'Unauthorized') {
+        return new AppError(message, ErrorCodes.UNAUTHORIZED);
+    }
+    static forbidden(message = 'Forbidden', details) {
+        return new AppError(message, ErrorCodes.FORBIDDEN, { details });
+    }
+    static conflict(message, details) {
+        return new AppError(message, ErrorCodes.CONFLICT, { details });
+    }
+    static internal(message = 'Internal server error', cause) {
+        return new AppError(message, ErrorCodes.INTERNAL_ERROR, { cause });
+    }
+}
+/** Wraps an async route handler so that a rejection reaches the error middleware. */
+export function asyncHandler(fn) {
+    return (req, res, next) => {
+        Promise.resolve(fn(req, res, next)).catch((error) => {
+            next(error);
+        });
+    };
+}
+const SENSITIVE_KEYS = [
+    'password', 'token', 'secret', 'key', 'credential', 'auth', 'apikey', 'api_key',
+    'access_token', 'refresh_token', 'private', 'cookie', 'session',
+];
+const SENSITIVE_PATH_PATTERNS = [/\/\.env/, /\/credentials/, /\/secrets/, /\/\.ssh/, /\/\.gnupg/];
+function redact(value, depth = 0) {
+    if (depth > 10)
+        return '[MAX_DEPTH]';
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value !== 'object') {
+        if (typeof value === 'string') {
+            if (/^eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+$/.test(value))
+                return '[JWT_REDACTED]';
+            if (/^[a-fA-F0-9]{32,}$/.test(value))
+                return '[HEX_KEY_REDACTED]';
+            if (SENSITIVE_PATH_PATTERNS.some((pattern) => pattern.test(value)))
+                return '[SENSITIVE_PATH_REDACTED]';
+        }
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map((item) => redact(item, depth + 1));
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        const lowerKey = key.toLowerCase();
+        result[key] = SENSITIVE_KEYS.some((sensitive) => lowerKey.includes(sensitive)) ? '[REDACTED]' : redact(item, depth + 1);
+    }
+    return result;
+}
+function formatLog(level, msg, data = {}) {
+    const masked = redact(data);
+    return JSON.stringify({
+        timestamp: new Date().toISOString(),
+        level,
+        msg,
+        ...(masked && typeof masked === 'object' && !Array.isArray(masked) ? masked : {}),
+    });
+}
+/** JSON-line logger that masks secrets. DEBUG enables debug lines. */
+export const logger = {
+    info(msg, data = {}) {
+        console.log(formatLog('info', msg, data));
+    },
+    warn(msg, data = {}) {
+        console.warn(formatLog('warn', msg, data));
+    },
+    error(msg, data = {}) {
+        let entry;
+        if (data instanceof Error) {
+            entry = { error: data.message, stack: data.stack };
+        }
+        else if (data.error instanceof Error) {
+            entry = { ...data, error: data.error.message, stack: data.error.stack };
+        }
+        else {
+            entry = data;
+        }
+        console.error(formatLog('error', msg, entry));
+    },
+    debug(msg, data = {}) {
+        if (process.env.DEBUG)
+            console.log(formatLog('debug', msg, data));
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.10.15",
+  "version": "0.12.0",
   "description": "Local-first Brainbase judgment OS that lets supported AI agents reuse a user's approved goals, priorities, decisions, and judgment criteria.",
   "type": "module",
   "license": "MIT",
@@ -191,6 +191,10 @@
       "types": "./dist/execution-authority-http.d.ts",
       "import": "./dist/execution-authority-http.js"
     },
+    "./server-support": {
+      "types": "./dist/server-support.d.ts",
+      "import": "./dist/server-support.js"
+    },
     "./company-os-impact-review": {
       "types": "./dist/company-os-impact-review.d.ts",
       "import": "./dist/company-os-impact-review.js"
@@ -344,5 +348,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "04f1192c75877ca241970ee379c274e37c6693cc"
+  "gitHead": "084154257b751ba7bf6b303aa889c42ac551c9b9"
 }

package/ui/graph-registry-view.js

@@ -163,6 +163,7 @@ function textCell(value, fallback) {
  * @param {string} [options.token] Launch token sent with a correction.
  * @param {string} [options.tokenHeader] Header name for the token.
  * @param {boolean} [options.autoLoad=true] Runs the empty search and reads the kinds on mount.
+ * @param {string} [options.initialEntityId] Opens this exact entity after the initial Graph read.
  * @param {() => Date} [options.now] The owner's clock.
  * @param {boolean} [options.canCorrect=true] When false, no correction control is drawn anywhere
  *   (この記録を直す, 関係を加える, この関係を直す, and この画面で直せること under the kinds of
@@ -204,6 +205,7 @@ export function createGraphRegistryView({
   token,
   tokenHeader,
   autoLoad = true,
+  initialEntityId,
   now = () => new Date(),
   canCorrect = true,
   correctionScope,
@@ -617,6 +619,23 @@ export function createGraphRegistryView({
       const canFix = scope.entity(entity.type) && scope.fields(graphEntityCorrectionFields(entity.type)).length > 0;
       const relatable = newRelationOptions(entity.type).length > 0;
       const related = loaded.outgoing.length + loaded.incoming.length > 0;
+      const correctionEntries = [
+        canFix ? '「この記録を直す」' : null,
+        relatable && scope.createEdges ? '「関係を加える」' : null,
+        related && scope.edges ? '関係ごとの「この関係を直す」' : null,
+      ].filter(Boolean);
+      if (correctionEntries.length > 0) {
+        const lastEntry = correctionEntries.at(-1);
+        const entries = correctionEntries.length === 1
+          ? lastEntry
+          : `${correctionEntries.slice(0, -1).join('、')}、または${lastEntry}`;
+        children.push(workspaceRailBlock(doc, {
+          title: '訂正の流れ',
+          content: makeElement(doc, 'p', {
+            text: `誤りを見つけたときの訂正入口です。${entries}から変更案を入力します。承認待ちの提出ではなく、保存するとその場でGraphに反映され、理由と変更前後が履歴に残ります。保存後に読み直して一致を確かめ、確認できた内容は、次のMCPの search・get_context・resolve_entity で使われます。`,
+          }),
+        }));
+      }
       const actions = [
         canFix ? workspaceButton(doc, { text: 'この記録を直す', onClick: () => openCorrection('entity', () => correction.openEntity(entity, { title: 'この記録を直す' })) }) : null,
         relatable && scope.createEdges
@@ -797,7 +816,14 @@ export function createGraphRegistryView({
     },
   };
   controller.render();
-  if (autoLoad) void controller.load();
+  if (autoLoad) {
+    void controller.load().then(() => {
+      if (initialEntityId) return controller.openEntity(initialEntityId);
+      return undefined;
+    });
+  } else if (initialEntityId) {
+    void controller.openEntity(initialEntityId);
+  }
   return controller;
 }
 

package/ui/local-web-shell.js

@@ -21,6 +21,7 @@ import { createObjectiveEditorController } from './objective-editor.js';
 import { createObjectiveEditorHttpPort } from './objective-editor-http-port.js';
 import { createValueProofReviewUI } from './value-proof-review.js';
 import { createWorldModelView } from './world-model-view.js';
+import { createGraphClient } from './graph-view-shared.js';
 
 export const LOCAL_WEB_SHELL_CONTRACT_VERSION = 'brainbase.local-web-shell.v1';
 
@@ -75,6 +76,60 @@ function isRecord(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
+/**
+ * Parses the local shell's hash target without treating query data as a
+ * screen id.  Only the Graph screen accepts an entity target; all other
+ * screens deliberately discard query parameters.
+ */
+export function parseLocalWebTarget(target) {
+  const raw = typeof target === 'string' ? target.replace(/^#/, '') : '';
+  const separator = raw.indexOf('?');
+  const screenId = separator < 0 ? raw : raw.slice(0, separator);
+  if (!screenId) return { screenId: null, entityId: null };
+  const query = separator < 0 ? '' : raw.slice(separator + 1);
+  const params = new URLSearchParams(query);
+  return {
+    screenId,
+    entityId: screenId === 'graph' ? params.get('entity_id')?.trim() || null : null,
+  };
+}
+
+function graphSourceReader(context) {
+  const client = createGraphClient({ fetcher: context.fetcher, basePath: '/api/graph', token: context.token });
+  return async (source) => {
+    if (!isRecord(source) || source.kind !== 'local_graph'
+      || typeof source.entity_id !== 'string' || !source.entity_id.trim()
+      || typeof source.entity_type !== 'string' || !source.entity_type.trim()) {
+      return { state: 'unavailable', reason: 'source_contract_invalid' };
+    }
+    const result = await client.read(`/entities/${encodeURIComponent(source.entity_id)}`);
+    if (result.state === 'error') {
+      if (result.status === 404 || result.code === 'entity_not_found') return { state: 'not_found' };
+      if (result.status === 403 || result.code === 'authorization_denied' || result.code === 'scope_violation') return { state: 'forbidden' };
+      if (result.code === 'entity_id_ambiguous') return { state: 'ambiguous' };
+      return { state: 'unavailable', reason: result.code };
+    }
+    if (result.state !== 'ok' || !isRecord(result.payload?.entity)) return { state: 'unavailable', reason: 'source_response_invalid' };
+    const entity = result.payload.entity;
+    if (entity.id !== source.entity_id || entity.type !== source.entity_type) {
+      return { state: 'unavailable', reason: 'source_target_mismatch' };
+    }
+    if (source.digest && entity.digest !== source.digest) {
+      return { state: 'unavailable', reason: 'source_digest_mismatch' };
+    }
+    // The local Graph response currently exposes a content digest, not a
+    // revision number.  A requested version is therefore linkable only when
+    // the provider returns the same explicit version field.
+    if (source.version) {
+      const currentVersion = entity.version ?? entity.revision ?? null;
+      if (!currentVersion || currentVersion !== source.version) {
+        return { state: 'unavailable', reason: 'source_version_mismatch' };
+      }
+    }
+    return { state: 'available' };
+  };
+}
+
 function makePage(container, context) {
   const page = makeElement(context.document, 'div', { className: 'bb-shell-page' });
   container.append(page);
@@ -89,6 +144,7 @@ function mountToday(container, context) {
     document: context.document,
     fetcher: context.fetcher,
     token: context.token,
+    sourceReader: graphSourceReader(context),
   });
 }
 
@@ -129,7 +185,13 @@ function mountObjectives(container, context) {
     constraintsEditable: false,
     storyLinks: false,
   });
-  const worldModel = createWorldModelView({ root: worldRoot, rail: context.rail, document: doc, fetcher: context.fetcher });
+  const worldModel = createWorldModelView({
+    root: worldRoot,
+    rail: context.rail,
+    document: doc,
+    fetcher: context.fetcher,
+    token: context.token,
+  });
   return { editor, worldModel };
 }
 
@@ -144,6 +206,7 @@ function mountGraphScreen(createView) {
       document: context.document,
       fetcher: context.fetcher,
       token: context.token,
+      initialEntityId: context.initialEntityId,
     });
   };
 }
@@ -248,6 +311,7 @@ export function createLocalWebShell({
   const mounted = new Map();
   const slots = new Map();
   const links = new Map();
+  const pendingEntityIds = new Map();
   let active = null;
 
   const shell = makeElement(doc, 'div', { className: 'bb-shell', attrs: { 'data-contract-version': LOCAL_WEB_SHELL_CONTRACT_VERSION } });
@@ -311,8 +375,14 @@ export function createLocalWebShell({
     for (const [screenId, railSlot] of rails) railSlot.hidden = !(showRail && screenId === active);
   }
 
-  function ensureMounted(screen) {
-    if (mounted.has(screen.id)) return;
+  function ensureMounted(screen, entityId = pendingEntityIds.get(screen.id) ?? null) {
+    if (mounted.has(screen.id)) {
+      if (entityId && screen.id === 'graph') {
+        const view = mounted.get(screen.id);
+        if (typeof view?.openEntity === 'function') void view.openEntity(entityId);
+      }
+      return;
+    }
     const slot = slots.get(screen.id);
     if (screen.usesGraph && !(status.phase === 'ready' && status.data.graph.status === 'ready')) {
       renderGraphGate(doc, slot, status, controller.refreshStatus, screen.label);
@@ -322,7 +392,7 @@ export function createLocalWebShell({
     const rail = rails.get(screen.id) ?? null;
     rail?.replaceChildren();
     const page = Object.freeze({ crumbs: Object.freeze(['あなたのBrainbase', screen.label]), source: screen.source ?? null });
-    mounted.set(screen.id, screen.mount(slot, Object.freeze({ ...context, rail, page })) ?? true);
+    mounted.set(screen.id, screen.mount(slot, Object.freeze({ ...context, rail, page, initialEntityId: entityId })) ?? true);
     updateRail();
   }
 
@@ -330,15 +400,17 @@ export function createLocalWebShell({
     get state() {
       return { active, status, mounted: [...mounted.keys()] };
     },
-    show(id) {
-      const screen = screens.find((candidate) => candidate.id === id) ?? screens[0];
+    show(target) {
+      const parsed = parseLocalWebTarget(target);
+      const screen = screens.find((candidate) => candidate.id === parsed.screenId) ?? screens[0];
+      pendingEntityIds.set(screen.id, screen.id === 'graph' ? parsed.entityId : null);
       active = screen.id;
       for (const [screenId, slot] of slots) slot.hidden = screenId !== screen.id;
       for (const [screenId, link] of links) {
         if (screenId === screen.id) link.setAttribute('aria-current', 'page');
         else link.removeAttribute('aria-current');
       }
-      ensureMounted(screen);
+      ensureMounted(screen, pendingEntityIds.get(screen.id));
       updateRail();
       return controller;
     },
@@ -362,7 +434,7 @@ export function createLocalWebShell({
       renderSource(doc, source, status, controller.refreshStatus);
       // Re-evaluate Graph-backed screens that are waiting behind the gate.
       for (const screen of screens) {
-        if (screen.usesGraph && !mounted.has(screen.id) && (screen.id === active)) ensureMounted(screen);
+        if (screen.usesGraph && !mounted.has(screen.id) && (screen.id === active)) ensureMounted(screen, pendingEntityIds.get(screen.id));
       }
       return status;
     },

package/ui/project-workspace.js

@@ -667,7 +667,7 @@ function renderDenseOverview(doc, detail, context, entities, actions = {}) {
   todayHead.append(makeElement(doc, 'h4', { text: '今日判断・対応すること' }));
   if (typeof actions.openWorkList === 'function') todayHead.append(denseButton(doc, 'すべて見る', 'bb-pkw-dense-action', actions.openWorkList));
   today.append(todayHead);
-  const todayNotice = denseContextStateNotice(doc, taskSection ?? (context?.state !== 'ok' ? context : null), 'タスクを読み取れませんでした。');
+  const todayNotice = denseContextStateNotice(doc, taskSection ?? (context?.state && context.state !== 'ok' ? context : { state: 'unknown' }), 'タスクを読み取れませんでした。');
   if (todayNotice) today.append(todayNotice);
   if (!todayNotice && due.length === 0) today.append(makeElement(doc, 'p', { className: 'bb-pkw-muted', text: '表示できる仕事はありません。' }));
   if (!todayNotice && due.length > 0) {

package/ui/value-proof-review.css

@@ -93,6 +93,28 @@ body:has(#brainbase-value-proof-review) {
   font-weight: 700;
 }
 
+.bb-vpr-setup-guide {
+  display: grid;
+  gap: var(--bb-space-1);
+  padding: var(--bb-space-2) var(--bb-space-3);
+  border: 1px solid var(--bb-color-border, #d8dee9);
+  background: var(--bb-color-panel, #ffffff);
+}
+
+.bb-vpr-setup-guide p,
+.bb-vpr-setup-guide ol {
+  margin: 0;
+}
+
+.bb-vpr-setup-guide ol {
+  padding-left: var(--bb-space-5);
+}
+
+.bb-vpr-setup-guide code {
+  overflow-wrap: anywhere;
+  font-size: .92em;
+}
+
 .bb-vpr-rejected summary {
   cursor: pointer;
 }
@@ -225,6 +247,38 @@ body:has(#brainbase-value-proof-review) {
   font-size: 13px;
 }
 
+/* A source-bearing target is still trace metadata until the host has read the
+ * exact Graph record.  Only the same-origin link is styled as an action. */
+.bb-vpr-source-target {
+  display: inline-flex;
+  flex-wrap: wrap;
+  gap: var(--bb-space-1, 4px);
+  align-items: baseline;
+}
+
+.bb-vpr-source-link {
+  color: var(--vpr-action);
+  font-weight: 680;
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+
+.bb-vpr-source-status {
+  color: var(--vpr-muted);
+  font-size: 12px;
+}
+
+.bb-vpr-source-status.is-loading {
+  color: var(--vpr-muted);
+}
+
+.bb-vpr-source-status.is-not_found,
+.bb-vpr-source-status.is-ambiguous,
+.bb-vpr-source-status.is-forbidden,
+.bb-vpr-source-status.is-unavailable {
+  color: var(--vpr-warning);
+}
+
 /* Detail: in the rail, or after the workspace when the host has none. */
 .bb-vpr-inline-detail {
   max-width: 760px;

package/ui/value-proof-review.js

@@ -4,8 +4,9 @@
  * The host supplies a same-origin request function and a review token. A host
  * that cannot read a local journal may replace the unavailable notice. This
  * module owns presentation only: it never treats an unavailable journal as an
- * empty list, never edits the judgment journal, and keeps internal IDs inside
- * the audit details.
+ * empty list and never edits the judgment journal. Recorded basis target IDs
+ * are shown as trace metadata; no source URL is invented when the payload has
+ * no source-read contract.
  *
  * The screen follows the organization edition's pattern (workspace-kit): page
  * head, the 記録の範囲 notice, filters, metrics, and the 委任の地図 as a ledger
@@ -547,11 +548,98 @@ function renderDelegationMap(doc, state, callbacks) {
 }
 
 function basisText(entry) {
-  const application = text(entry.application) ?? '適用内容なし';
-  const layer = BASIS_LAYER_LABELS[entry.layer];
+  const application = text(entry?.application) ?? '適用内容なし';
+  const layer = BASIS_LAYER_LABELS[entry?.layer];
   return layer ? `[${layer}] ${application}` : application;
 }
 
+function basisTargetText(entry) {
+  const entityId = text(entry?.entity_id);
+  if (!entityId) return '対象の記録なし';
+  const version = text(entry?.version);
+  return version ? `${entityId}（版 ${version}）` : entityId;
+}
+
+const SOURCE_READ_STATES = Object.freeze(['loading', 'available', 'not_found', 'ambiguous', 'forbidden', 'unavailable']);
+const SOURCE_READ_LABELS = Object.freeze({
+  loading: '出典を確認中…',
+  not_found: '出典が見つかりません（未確認）',
+  ambiguous: '同じIDの出典が複数あります（未確認）',
+  forbidden: '出典を読む権限がありません（未確認）',
+  unavailable: '出典を確認できません（未確認）',
+});
+
+function sourceContract(entry) {
+  const source = entry?.source;
+  if (!isRecord(source) || source.kind !== 'local_graph') return null;
+  const entityId = text(source.entity_id);
+  const entityType = text(source.entity_type);
+  if (!entityId || !entityType || entityId !== text(entry?.entity_id)) return null;
+  return source;
+}
+
+function sourceKey(source) {
+  return [source.kind, source.entity_id, source.entity_type, source.version ?? '', source.digest ?? ''].join('\u0000');
+}
+
+function sourceReadState(value) {
+  const state = text(value?.state);
+  return SOURCE_READ_STATES.includes(state) ? state : 'unavailable';
+}
+
+function renderBasisTarget(doc, entry, state) {
+  const target = makeElement(doc, 'span', { className: 'bb-vpr-source-target' });
+  target.append(makeElement(doc, 'span', { text: basisTargetText(entry) }));
+  const source = sourceContract(entry);
+  if (!source) return target;
+  const key = sourceKey(source);
+  const read = state.sourceReads instanceof Map ? state.sourceReads.get(key) : null;
+  if (!read) {
+    target.append(makeElement(doc, 'span', {
+      className: 'bb-vpr-source-status is-unavailable',
+      text: '出典の読み取り先を確認できません（未確認）',
+    }));
+    return target;
+  }
+  const readState = sourceReadState(read);
+  if (readState === 'available') {
+    const link = makeElement(doc, 'a', {
+      className: 'bb-vpr-source-link',
+      text: '出典を開く',
+      attrs: { href: `#graph?entity_id=${encodeURIComponent(source.entity_id)}` },
+    });
+    target.append(link);
+    return target;
+  }
+  target.append(makeElement(doc, 'span', {
+    className: `bb-vpr-source-status is-${readState}`,
+    text: SOURCE_READ_LABELS[readState] ?? SOURCE_READ_LABELS.unavailable,
+  }));
+  return target;
+}
+
+function journalSetupGuide(doc) {
+  const guide = makeElement(doc, 'div', { className: 'bb-vpr-setup-guide' });
+  guide.append(makeElement(doc, 'strong', { text: '接続を直す' }));
+  guide.append(makeElement(doc, 'p', { text: '判断journalの場所を指定して画面を起動し直したあと、「再試行」を押してください。' }));
+  const list = makeElement(doc, 'ol');
+  const journalOption = makeElement(doc, 'li');
+  journalOption.append(
+    makeElement(doc, 'span', { text: '起動時に ' }),
+    makeElement(doc, 'code', { text: 'brainbase review:serve --journal <判断journalの場所>' }),
+    makeElement(doc, 'span', { text: ' を指定する' }),
+  );
+  const journalEnv = makeElement(doc, 'li');
+  journalEnv.append(
+    makeElement(doc, 'span', { text: 'または環境変数 ' }),
+    makeElement(doc, 'code', { text: 'BRAINBASE_JUDGMENT_JOURNAL_DIR=<判断journalの場所>' }),
+    makeElement(doc, 'span', { text: ' を設定する' }),
+  );
+  list.append(journalOption, journalEnv);
+  guide.append(list);
+  return guide;
+}
+
 function inheritanceText(inheritance) {
   const sources = Array.isArray(inheritance?.sources) ? inheritance.sources : [];
   if (sources.length === 0) return '引き継ぎの記録なし';
@@ -733,6 +821,7 @@ function renderJudgmentDetail(doc, state, item, callbacks) {
     title: '根拠と引き継ぎ',
     content: facts(doc, [
       ['根拠', basis.length > 0 ? basis.map(basisText).join(' / ') : '根拠の記録なし'],
+      ['根拠の対象', basis.length > 0 ? basis.map((entry) => renderBasisTarget(doc, entry, state)) : '対象の記録なし'],
       ['過去の学習の再利用', reuse === true ? 'あり' : reuse === false ? 'なし' : '未確認'],
       ['引き継ぎ', inheritanceText(proof.decision.inheritance)],
     ]),
@@ -861,13 +950,18 @@ export function renderValueProofReview(root, state, callbacks = {}, options = {}
   if (home.status === 'unavailable') {
     const hostNotice = options.unavailableNotice;
     const title = makeElement(doc, 'p', { className: 'bb-vpr-notice-title', text: text(hostNotice?.title) ?? '判断journalに接続できません' });
+    const retry = workspaceButton(doc, { text: '再試行', variant: 'primary', onClick: () => void callbacks.onReload?.() });
+    const defaultGuide = hostNotice ? null : journalSetupGuide(doc);
     surface.append(workspaceNotice(doc, {
       label: '記録の範囲',
       tone: 'danger',
       text: noticeBody(doc,
         title,
         home.root ? `場所: ${home.root}（${home.reason}）` : `理由: ${home.reason}`,
-        `${text(hostNotice?.guidance) ?? '記録の場所は、起動時の --journal か環境変数 BRAINBASE_JUDGMENT_JOURNAL_DIR で指定できます。'}0件としては扱いません。`),
+        text(hostNotice?.guidance) ?? (defaultGuide ? null : '接続元の案内に従って記録を読める状態にしてください。'),
+        defaultGuide,
+        retry,
+        '接続できる状態にしたら「再試行」を押してください。0件としては扱いません。'),
     }));
     return finish(null, unreadable);
   }
@@ -934,6 +1028,8 @@ export function createValueProofReviewUI({
   clipboard,
   /** Optional `{ title, guidance }` for hosts where the local journal hint does not apply. */
   unavailableNotice,
+  /** Optional host-owned reader for typed basis sources. It must not invent a URL. */
+  sourceReader,
   autoLoad = true,
 } = {}) {
   if (!root) throw new TypeError('root is required');
@@ -958,6 +1054,30 @@ export function createValueProofReviewUI({
     save: { state: 'idle', message: '' },
     focusCard: false,
     consultMessage: '',
+    sourceReads: new Map(),
+  };
+
+  const readSelectedSources = async (item) => {
+    if (typeof sourceReader !== 'function' || !item?.proof?.decision?.basis) return;
+    const sources = item.proof.decision.basis.map(sourceContract).filter(Boolean);
+    for (const source of sources) {
+      const key = sourceKey(source);
+      state.sourceReads.set(key, { state: 'loading' });
+    }
+    if (sources.length > 0) controller.render();
+    await Promise.all(sources.map(async (source) => {
+      const key = sourceKey(source);
+      let result;
+      try {
+        result = await sourceReader(source);
+      } catch {
+        result = { state: 'unavailable' };
+      }
+      if (state.selectedKey !== itemKey(item.proof)) return;
+      const normalized = isRecord(result) ? result : {};
+      state.sourceReads.set(key, { ...normalized, state: sourceReadState(normalized) });
+    }));
+    if (state.selectedKey === itemKey(item.proof)) controller.render();
   };
 
   const resetJudgmentInput = () => {
@@ -1000,6 +1120,8 @@ export function createValueProofReviewUI({
       state.focusCard = true;
       controller.render();
       state.focusCard = false;
+      const item = findItem(state, key);
+      if (item) void readSelectedSources(item);
     },
     onDraft(patch) {
       state.draft = { ...state.draft, ...patch };