@unson/brainbase-mcp 0.40.0 → 0.41.0

package/dist/foundation-http.d.ts

@@ -1,8 +1,8 @@
 import type { CompanyOsObjectives } from './company-os-objectives.js';
 import { type FoundationStoreContext } from './foundation-store.js';
-import type { FoundationRef } from './foundation-catalog.js';
+import { type FoundationRef } from './foundation-catalog.js';
 import type { FoundationRevision, ObjectiveDefinition } from './ontology-foundation.js';
-import type { FoundationCatalogRecord } from './types.js';
+import type { FoundationCatalogRecord, ObjectiveReadback } from './types.js';
 /**
  * HTTP boundary shared by the OSS Objective UI and organization adapters.
  *
@@ -15,6 +15,7 @@ import type { FoundationCatalogRecord } from './types.js';
 export declare const FOUNDATION_HTTP_CONTRACT_VERSION: "brainbase.foundation-http.v1";
 export declare const FOUNDATION_HTTP_PREFIX: "/api/foundation";
 export declare const FOUNDATION_OBJECTIVE_ROUTE_PREFIX: "/api/foundation/objectives";
+export declare const FOUNDATION_OBJECTIVE_READBACK_CONTRACT_VERSION: "brainbase.objective-readback.v1";
 export declare const FOUNDATION_OBJECTIVE_ROUTES: readonly string[];
 type MaybePromise<T> = T | Promise<T>;
 export interface FoundationHttpRouteContext {
@@ -75,6 +76,8 @@ export interface ObjectiveFoundationHttpRouteOptions {
     /** Constraint relation reads/writes remain owned by the canonical adapter. */
     listObjectiveConstraintRefs?: (reference: FoundationRevision, context: FoundationStoreContext) => MaybePromise<unknown>;
     replaceObjectiveConstraintRefs?: (reference: FoundationRef, refs: readonly FoundationRevision[], context: FoundationStoreContext) => MaybePromise<unknown>;
+    /** Injectable clock for deterministic readback evidence; production uses the real clock. */
+    clock?: () => Date;
     bodyLimitBytes?: number;
 }
 /** Typed, explicitly sanitized error for trusted host adapters. */
@@ -86,6 +89,13 @@ export declare class FoundationHttpError extends Error {
         currentRevision?: string;
     });
 }
+/**
+ * Runtime guard for the Objective detail contract.  It is exported so a BFF
+ * can fail closed when a canonical host returns an old or malformed payload.
+ * The guard only accepts source metadata that agrees with the returned
+ * FoundationCatalogRecord; it never creates a source from request data.
+ */
+export declare function isObjectiveReadbackPayload(value: unknown): value is ObjectiveReadback;
 /**
  * Compose OSS Company OS routes under one local server boundary.  The
  * resolver is called only for a matching route and the resulting trusted

package/dist/foundation-http.js

@@ -1,4 +1,5 @@
 import { FoundationStoreError } from './foundation-store.js';
+import { assertFoundationCatalog, foundationKey } from './foundation-catalog.js';
 /**
  * HTTP boundary shared by the OSS Objective UI and organization adapters.
  *
@@ -11,6 +12,7 @@ import { FoundationStoreError } from './foundation-store.js';
 export const FOUNDATION_HTTP_CONTRACT_VERSION = 'brainbase.foundation-http.v1';
 export const FOUNDATION_HTTP_PREFIX = '/api/foundation';
 export const FOUNDATION_OBJECTIVE_ROUTE_PREFIX = `${FOUNDATION_HTTP_PREFIX}/objectives`;
+export const FOUNDATION_OBJECTIVE_READBACK_CONTRACT_VERSION = 'brainbase.objective-readback.v1';
 export const FOUNDATION_OBJECTIVE_ROUTES = Object.freeze([
     'GET /api/foundation/objectives',
     'GET /api/foundation/objectives/:id',
@@ -23,6 +25,8 @@ export const FOUNDATION_OBJECTIVE_ROUTES = Object.freeze([
 ]);
 const DEFAULT_BODY_LIMIT_BYTES = 1024 * 1024;
 const MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
+const OBJECTIVE_READBACK_STATUSES = ['ready', 'error', 'unknown'];
+const FOUNDATION_PROVENANCE_KINDS = new Set(['candidate', 'document', 'observation', 'decision', 'import']);
 const AUTHORITY_FIELDS = new Set([
     'acl',
     'scope',
@@ -78,6 +82,143 @@ export class FoundationHttpError extends Error {
         this.currentRevision = options.currentRevision;
     }
 }
+/**
+ * Runtime guard for the Objective detail contract.  It is exported so a BFF
+ * can fail closed when a canonical host returns an old or malformed payload.
+ * The guard only accepts source metadata that agrees with the returned
+ * FoundationCatalogRecord; it never creates a source from request data.
+ */
+export function isObjectiveReadbackPayload(value) {
+    const object = asRecord(value);
+    if (!object
+        || object.contract_version !== FOUNDATION_OBJECTIVE_READBACK_CONTRACT_VERSION
+        || !OBJECTIVE_READBACK_STATUSES.includes(object.status)
+        || !isCanonicalIsoTimestamp(object.checked_at)) {
+        return false;
+    }
+    if (object.status === 'ready') {
+        if (object.reason !== null)
+            return false;
+        const record = objectiveReadbackRecord(object.record);
+        const objective = objectiveReadbackRecord(object.objective);
+        const source = objectiveReadbackSourceValue(object.source);
+        if (!record || !objective || !source)
+            return false;
+        return sameObjectiveIdentity(record, objective)
+            && source.source_id === record.definition.id
+            && source.source_version === record.definition.revision
+            && source.digest === record.digest
+            && JSON.stringify(source.provenance) === JSON.stringify(record.definition.provenance);
+    }
+    return object.source === null
+        && object.record === null
+        && object.objective === null
+        && objectiveReadbackReason(object.reason) !== null;
+}
+function objectiveReadbackSourceFromRecord(record) {
+    const normalized = objectiveReadbackRecord(record);
+    if (!normalized)
+        return null;
+    return {
+        source_type: 'foundation_revision_store',
+        source_id: normalized.definition.id,
+        source_version: normalized.definition.revision,
+        digest: normalized.digest,
+        // Keep the exact canonical provenance array.  Do not derive it from the
+        // request, a UI label, or a BFF projection.
+        provenance: normalized.definition.provenance,
+    };
+}
+function objectiveReadbackPayload(status, checkedAt, record, reason) {
+    const source = status === 'ready' && record ? objectiveReadbackSourceFromRecord(record) : null;
+    if (status === 'ready' && (!source || !record)) {
+        throw new Error('objective_readback_source_unavailable');
+    }
+    return {
+        contract_version: FOUNDATION_OBJECTIVE_READBACK_CONTRACT_VERSION,
+        status,
+        source,
+        checked_at: checkedAt,
+        record: status === 'ready' ? record : null,
+        objective: status === 'ready' ? record : null,
+        reason: status === 'ready' ? null : reason,
+    };
+}
+function objectiveReadbackReason(value) {
+    const object = asRecord(value);
+    if (!object || typeof object.code !== 'string' || !object.code.trim()
+        || typeof object.message !== 'string' || !object.message.trim())
+        return null;
+    return { code: object.code, message: object.message };
+}
+function objectiveReadbackRecord(value) {
+    const object = asRecord(value);
+    const definition = asRecord(object?.definition);
+    if (!object || !definition || definition.type !== 'objective'
+        || typeof definition.id !== 'string' || !definition.id.trim())
+        return null;
+    const logicalKey = foundationKey({ type: 'objective', id: definition.id });
+    try {
+        // Reuse the canonical catalog guard so the readback cannot accept a
+        // partial draft shape, an arbitrary digest, or a non-canonical revision.
+        // The catalog guard deliberately validates definitions with `use: draft`:
+        // displayable draft/adopted Objectives remain readable without turning
+        // this transport check into a judgment/evaluation gate.
+        assertFoundationCatalog({
+            version: 1,
+            records: [object],
+            latest: {
+                [logicalKey]: {
+                    id: definition.id,
+                    type: 'objective',
+                    revision: definition.revision,
+                },
+            },
+            relations: [],
+        });
+    }
+    catch {
+        return null;
+    }
+    return object;
+}
+function objectiveReadbackMatchesRequest(record, requestedId, requestedRevision) {
+    return record.definition.id === requestedId
+        && (!requestedRevision || record.definition.revision === requestedRevision);
+}
+function objectiveReadbackSourceValue(value) {
+    const object = asRecord(value);
+    if (!object || object.source_type !== 'foundation_revision_store'
+        || typeof object.source_id !== 'string' || !object.source_id.trim()
+        || typeof object.source_version !== 'string' || !object.source_version.trim()
+        || typeof object.digest !== 'string' || !object.digest.trim()
+        || !Array.isArray(object.provenance)
+        || !object.provenance.every(isFoundationProvenance))
+        return null;
+    return object;
+}
+function isFoundationProvenance(value) {
+    const object = asRecord(value);
+    if (!object)
+        return false;
+    return typeof object.sourceId === 'string'
+        && object.sourceId.trim().length > 0
+        && typeof object.sourceKind === 'string'
+        && FOUNDATION_PROVENANCE_KINDS.has(object.sourceKind)
+        && Array.isArray(object.evidenceIds)
+        && object.evidenceIds.every((id) => typeof id === 'string');
+}
+function sameObjectiveIdentity(left, right) {
+    return left.definition.id === right.definition.id
+        && left.definition.revision === right.definition.revision
+        && left.digest === right.digest;
+}
+function isCanonicalIsoTimestamp(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return false;
+    const parsed = new Date(value);
+    return !Number.isNaN(parsed.getTime()) && parsed.toISOString() === value;
+}
 /**
  * Compose OSS Company OS routes under one local server boundary.  The
  * resolver is called only for a matching route and the resulting trusted
@@ -225,10 +366,34 @@ export function createObjectiveFoundationRoute(options) {
                 return methodNotAllowed(['GET', 'PUT']);
             }
             if (method === 'GET') {
-                const record = await options.objectives.readObjective(id, input.context, revision);
-                if (!record)
-                    throw new FoundationHttpError(404, 'not_found', `Objective ${id} was not found`);
-                return jsonResponse(200, { state: 'ready', record, objective: record });
+                try {
+                    const record = await options.objectives.readObjective(id, input.context, revision);
+                    const checkedAt = objectiveReadbackCheckedAt(options.clock);
+                    if (!record) {
+                        return jsonResponse(404, objectiveReadbackPayload('unknown', checkedAt, null, { code: 'not_found', message: `Objective ${id} was not found` }));
+                    }
+                    const canonicalRecord = objectiveReadbackRecord(record);
+                    if (!canonicalRecord) {
+                        return jsonResponse(502, objectiveReadbackPayload('error', checkedAt, null, { code: 'invalid_canonical_record', message: 'The canonical Objective readback is incomplete' }));
+                    }
+                    if (!objectiveReadbackMatchesRequest(canonicalRecord, id, revision)) {
+                        return jsonResponse(502, objectiveReadbackPayload('error', checkedAt, null, { code: 'readback_identity_mismatch', message: 'The canonical Objective readback does not match the requested id or revision' }));
+                    }
+                    // Keep the pre-readback `state` field for existing OSS consumers while
+                    // the canonical envelope is adopted by newer clients.
+                    return jsonResponse(200, {
+                        ...objectiveReadbackPayload('ready', checkedAt, canonicalRecord, null),
+                        state: 'ready',
+                    });
+                }
+                catch (error) {
+                    const normalized = normalizeHttpError(error);
+                    const checkedAt = objectiveReadbackCheckedAt(options.clock);
+                    const status = normalized.status === 404 || normalized.code === 'not_found'
+                        ? 'unknown'
+                        : 'error';
+                    return jsonResponse(normalized.status, objectiveReadbackPayload(status, checkedAt, null, { code: normalized.code, message: normalized.message }));
+                }
             }
             if (method === 'PUT') {
                 const current = await options.objectives.readObjective(id, input.context, revision);
@@ -252,13 +417,20 @@ export function createObjectiveFoundationRoute(options) {
 }
 async function readObjectiveReference(options, id, revision, context) {
     const record = await options.objectives.readObjective(id, context, revision);
-    if (!record || record.definition.type !== 'objective')
+    if (!record)
         throw new FoundationHttpError(404, 'not_found', `Objective ${id} was not found`);
+    const canonicalRecord = objectiveReadbackRecord(record);
+    if (!canonicalRecord) {
+        throw new FoundationHttpError(502, 'invalid_canonical_record', 'The canonical Objective readback is incomplete');
+    }
+    if (!objectiveReadbackMatchesRequest(canonicalRecord, id, revision)) {
+        throw new FoundationHttpError(502, 'readback_identity_mismatch', 'The canonical Objective readback does not match the requested id or revision');
+    }
     return {
-        id: record.definition.id,
+        id: canonicalRecord.definition.id,
         type: 'objective',
-        revision: record.definition.revision,
-        digest: record.digest,
+        revision: canonicalRecord.definition.revision,
+        digest: canonicalRecord.digest,
     };
 }
 async function buildObjectiveDefinition(options, payload, input) {
@@ -337,6 +509,9 @@ function parseConstraintReferences(payload) {
 function readinessPayload(readiness) {
     return { state: 'ready', ready: readiness.ready, issues: readiness.issues };
 }
+function objectiveReadbackCheckedAt(clock) {
+    return (clock?.() ?? new Date()).toISOString();
+}
 function normalizeCollectionPayload(value, key) {
     if (Array.isArray(value))
         return { state: value.length ? 'ready' : 'empty', [key]: value, absence_confirmed: true };

package/dist/graph-web.d.ts

@@ -197,6 +197,8 @@ export interface GraphProjectDetail<S extends GraphWebAnySource = GraphWebSource
     participants: GraphEdgeView[];
     /** Other relations of the project (governs, owned_by, ...). */
     relations: GraphEdgeView[];
+    /** True only after the same Graph v2 was fully read and strictly validated with no participant edge. */
+    participantsAbsenceConfirmed: boolean;
     history: GraphCorrectionRecord[];
     issues: GraphReadIssue[];
 }

package/dist/graph-web.js

@@ -1,6 +1,6 @@
 import { access, readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { isActiveAt } from './canonical-graph.js';
+import { isActiveAt, validateCanonicalGraph } from './canonical-graph.js';
 import { assertFoundationCatalog, findFoundationRecord } from './foundation-catalog.js';
 import { GRAPH_CORRECTION_EDGE_FIELDS, GRAPH_CORRECTION_ENTITY_FIELDS, GRAPH_CORRECTION_NEW_EDGE_RELATIONS, GRAPH_CORRECTION_NEW_ENTITY_TYPES, GRAPH_CORRECTION_PROJECT_FIELDS, GRAPH_CORRECTIONS_FILE, graphRecordDigest, isProjectIconDataUrl, readGraphCorrectionHistory } from './graph-corrections.js';
 import { ONTOLOGY_VERSION, portableOntology } from './ontology.js';
@@ -213,6 +213,14 @@ export async function readGraphProject(dataDir, projectId, options = {}) {
     return projectDetailOf(loaded.graph, loaded.source, projectId, asOf, await loadReferences(dataDir));
 }
 function projectDetailOf(graph, source, projectId, asOf, references) {
+    try {
+        // loadPersonalOs intentionally preserves duplicate entity IDs for audit reads;
+        // participant absence must use a strict, same-snapshot Graph validation.
+        validateCanonicalGraph(graph);
+    }
+    catch (error) {
+        throw new GraphWebError('unavailable', 'graph_unavailable', errorMessage(error));
+    }
     const project = graph.entities.find((entity) => entity.id === projectId && entity.type === 'project');
     if (!project)
         throw new GraphWebError('not_found', 'project_not_found', `No project ${projectId}`);
@@ -232,6 +240,7 @@ function projectDetailOf(graph, source, projectId, asOf, references) {
         },
         participants,
         relations,
+        participantsAbsenceConfirmed: participants.length === 0,
         history: historyFor(references.history, touched),
         issues: references.issues
     };

package/dist/judgment-history.js

@@ -447,7 +447,9 @@ function validJournalEvent(value, sessionRef, key, eventKey) {
             || !sha256Text(text(value.input_digest))
             || !sha256Text(text(value.response_digest))
             || !sha256Text(text(value.event_fingerprint))
-            || !(text(value.display_line) || value.event_kind === 'turn_resolution' && value.display_line === null))
+            || !(value.display_line === undefined
+                || value.display_line === null
+                || text(value.display_line)))
             return false;
         return Boolean(eventKey && /^[a-f0-9]{64}$/u.test(eventKey)
             && sha256(text(value.tool_use_id)) === eventKey);

package/dist/local-web-host.js

@@ -586,7 +586,7 @@ export function createObjectiveFoundationModule(context) {
     });
     return {
         id: 'foundation-objectives',
-        uiFiles: ['objective-editor.js', 'objective-editor.css', 'objective-editor-http-port.js'],
+        uiFiles: ['objective-editor.js', 'objective-editor.css', 'objective-editor-http-port.js', 'objective-readback-contract.js'],
         async handle(request, response) {
             const path = requestUrl(request).pathname;
             if (path !== FOUNDATION_HTTP_PREFIX && !path.startsWith(`${FOUNDATION_HTTP_PREFIX}/`))

package/dist/portable-graph.d.ts

@@ -47,8 +47,8 @@ export interface PortableGraphOwner {
  * `applicability`, constraint exception scopes).
  *
  * The result is a read projection, not a bundle to store or send: the input
- * is not changed, relation IDs stay those of the stored bundle (they name the
- * relation there) and foundation digests are not recomputed.  A bundle that
+ * is not changed, endpoint-dependent edge IDs are re-derived for the bound
+ * projection, and foundation digests are not recomputed.  A bundle that
  * already has another record with the owner's person ID is refused rather
  * than merged.
  */

package/dist/portable-graph.js

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { validateCanonicalGraph } from './canonical-graph.js';
+import { canonicalEdgeId, validateCanonicalGraph } from './canonical-graph.js';
 import { retrieveGraph } from './graph-retrieval.js';
 /** The public, read-only interchange format for a canonical Graph v2 snapshot. */
 export const PORTABLE_GRAPH_SCHEMA_VERSION = 1;
@@ -114,8 +114,8 @@ export const PORTABLE_GRAPH_OWNER_PLACEHOLDER = 'self';
  * `applicability`, constraint exception scopes).
  *
  * The result is a read projection, not a bundle to store or send: the input
- * is not changed, relation IDs stay those of the stored bundle (they name the
- * relation there) and foundation digests are not recomputed.  A bundle that
+ * is not changed, endpoint-dependent edge IDs are re-derived for the bound
+ * projection, and foundation digests are not recomputed.  A bundle that
  * already has another record with the owner's person ID is refused rather
  * than merged.
  */
@@ -160,6 +160,7 @@ export function bindPortableGraphOwner(bundle, owner) {
     for (const edge of graph.edges) {
         edge.fromId = swap(edge.fromId);
         edge.toId = swap(edge.toId);
+        edge.id = canonicalEdgeId(edge);
     }
     for (const record of graph.foundation?.records ?? []) {
         const definition = record.definition;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { FoundationDefinition, FoundationRelationReference, FoundationRevision } from './ontology-foundation.js';
+import type { FoundationDefinition, FoundationRelationReference, FoundationRevision, FoundationProvenance } from './ontology-foundation.js';
 export type EntityKind = 'person' | 'org' | 'project' | 'relationship' | 'decision';
 export type CanonicalEntityKind = 'person' | 'org' | 'project' | 'decision';
 export type CoreRelation = 'member_of' | 'participates_in' | 'accountable_for' | 'owned_by' | 'related_to' | 'governs' | 'supersedes';
@@ -56,6 +56,37 @@ export interface FoundationCatalogRecord {
     definition: FoundationDefinition;
     digest: string;
 }
+/**
+ * A detail read is useful only when the host can show which canonical record
+ * was actually read.  This envelope deliberately keeps the source separate
+ * from the record so a UI cannot mistake a client supplied proposal for a
+ * canonical provenance.
+ */
+export type ObjectiveReadbackStatus = 'ready' | 'error' | 'unknown';
+export interface ObjectiveReadbackReason {
+    code: string;
+    message: string;
+}
+export interface ObjectiveReadbackSource {
+    source_type: 'foundation_revision_store';
+    source_id: string;
+    source_version: string;
+    digest: string;
+    provenance: readonly FoundationProvenance[];
+}
+export interface ObjectiveReadback {
+    contract_version: 'brainbase.objective-readback.v1';
+    status: ObjectiveReadbackStatus;
+    /** Null means that no canonical record was established by this read. */
+    source: ObjectiveReadbackSource | null;
+    /** The time at which the canonical read completed (or failed). */
+    checked_at: string;
+    record: FoundationCatalogRecord | null;
+    /** Compatibility alias retained for existing Objective UI consumers. */
+    objective: FoundationCatalogRecord | null;
+    /** Ready has no reason; error/unknown must explain the unresolved result. */
+    reason: ObjectiveReadbackReason | null;
+}
 export interface FoundationCatalog {
     version: 1;
     records: FoundationCatalogRecord[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.40.0",
+  "version": "0.41.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",
@@ -481,5 +481,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "05c940b491a191339b9bc59ffb123579220714a3"
+  "gitHead": "c460d39f08bd68e8630fcdd000a934017f41203c"
 }

package/ui/foundation-overview.js

@@ -148,6 +148,17 @@ export function normalizeFoundationCatalog(value, expectedScopeId) {
   if (scopeId !== expectedScopeId) {
     throw error('scope_mismatch', '選択した対象範囲と応答の対象範囲が一致しません。');
   }
+  const readStatus = nonEmpty(firstValue(value, 'read_status', 'readStatus'));
+  const catalogStatus = nonEmpty(value.status);
+  const knownReadableStatuses = new Set(['complete', 'ready', 'resolved', 'empty']);
+  const unreadableStatus = (readStatus && !knownReadableStatuses.has(readStatus))
+    || (catalogStatus && !knownReadableStatuses.has(catalogStatus));
+  const collections = [value.objectives, value.variables, value.models, value.philosophies];
+  const hasRecords = collections.some((records) => Array.isArray(records) && records.length > 0);
+  const absenceConfirmed = value.absence_confirmed === true;
+  if (unreadableStatus || (!hasRecords && ('absence_confirmed' in value || readStatus || catalogStatus) && !absenceConfirmed)) {
+    throw error('unavailable', '目的・哲学・世界モデルの取得状態を確認できません。');
+  }
   validateFoundationRecords(value.objectives, 'objective', '目的');
   validateFoundationRecords(value.variables, 'variable', '変数');
   validateFoundationRecords(value.models, 'model', '世界モデル');
@@ -159,6 +170,10 @@ export function normalizeFoundationCatalog(value, expectedScopeId) {
     variables: value.variables,
     models: value.models,
     philosophies: value.philosophies,
+    ...(readStatus ? { read_status: readStatus } : {}),
+    ...(catalogStatus ? { status: catalogStatus } : {}),
+    ...(typeof value.absence_confirmed === 'boolean' ? { absence_confirmed: value.absence_confirmed } : {}),
+    ...(value.source !== undefined ? { source: value.source } : {}),
   };
 }
 
@@ -818,7 +833,8 @@ export function createFoundationOverview({ root, port, scopeId, document: explic
         if (destroyed || requestGeneration !== generation) return state;
         const code = cause?.code === 'scope_mismatch' ? 'scope_mismatch'
           : cause?.code === 'invalid_schema' ? 'invalid'
-            : cause?.code === 'authorization_denied' || cause?.code === 'forbidden' ? 'denied' : 'error';
+            : cause?.code === 'authorization_denied' || cause?.code === 'forbidden' ? 'denied'
+              : cause?.code === 'unavailable' ? 'unavailable' : 'error';
         state.status = code;
         state.error = {
           code,

package/ui/graph-own-share.js

@@ -80,7 +80,8 @@ export function graphOwnShareSource(option, { fetcher } = {}) {
 export function ownShareHandoverText(handover) {
   if (!isRecord(handover) || !textOrNull(handover.graphId)) return null;
   const where = textOrNull(handover.projectCode);
-  return `束 ${handover.graphId}（${where ? `置き場所 ${where}、` : ''}${formatDateTime(handover.createdAt)} に送信）`;
+  const digest = textOrNull(handover.digest) ?? '未確認';
+  return `束 ${handover.graphId}（${where ? `置き場所 ${where}、` : ''}digest ${digest}、${formatDateTime(handover.createdAt)} に送信）`;
 }
 
 /**
@@ -216,7 +217,8 @@ export function ownEntityDetail(doc, detail, { onClose, onRetry, onOpen } = {})
       ...(entity.type === 'project' ? [['目的', textOrNull(entity.goal)], ['状態', textOrNull(entity.status)]] : []),
     ]),
   }));
-  wrap.append(decisionRecordBlock(doc, entity, loaded.decisionRecord));
+  const decisionBlock = decisionRecordBlock(doc, entity, loaded.decisionRecord);
+  if (decisionBlock) wrap.append(decisionBlock);
   for (const [key, title, empty] of [['outgoing', '出る関係', 'この記録から出る関係はありません。'], ['incoming', '入る関係', 'この記録へ入る関係はありません。']]) {
     const edges = Array.isArray(loaded[key]) ? loaded[key] : [];
     wrap.append(workspaceRailBlock(doc, {