@unson/brainbase-mcp 0.41.13 → 0.42.0

package/dist/local-web-host.d.ts

@@ -195,6 +195,12 @@ export declare function createWorldModelReadModule(context: LocalWebModuleContex
  * correction is never saved through a path that skipped the host check.
  */
 export declare function createGraphWebModule(context: LocalWebModuleContext): LocalWebModule;
+/**
+ * 「あなたの記憶」: the owner's `personal-kg.jsonl`, read only.  The memory
+ * bodies are private, so these reads require the launch token and the same
+ * origin like every write on this host.
+ */
+export declare function createPersonalMemoryModule(context: LocalWebModuleContext): LocalWebModule;
 /** 今日 (value proofs), 目的と現状 (objectives + world model), プロジェクトと関係者 and 情報と関係 (Graph). */
 export declare function defaultLocalWebModules(context: LocalWebModuleContext): LocalWebModule[];
 /** Local single-owner host. The caller owns `listen()` and must bind to a loopback address. */

package/dist/local-web-host.js

@@ -12,6 +12,7 @@ import { createJudgmentHistoryHttpHandler, JUDGMENT_HISTORY_HTTP_PREFIX } from '
 import { createJudgmentHistoryReader, createLocalJudgmentHistoryFeedbackWriter, createLocalJudgmentHistorySource } from './judgment-history.js';
 import { defaultJudgmentJournalRoot, JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
 import { createMeetingMinutesHttpHandler } from './meeting-minutes-http.js';
+import { createPersonalMemoryHttpHandler, createPersonalMemoryJudgmentIndex, readLocalPersonalMemories } from './personal-memory.js';
 import { createMeetingMinutesLineageHttpHandler } from './meeting-minutes-lineage-http.js';
 import { createMeetingMinutesLineageCorrectionHook, } from './meeting-minutes-lineage-lifecycle.js';
 import { createMeetingMinutesStore } from './meeting-minutes.js';
@@ -891,6 +892,38 @@ export function createGraphWebModule(context) {
         handle: handler
     };
 }
+/**
+ * 「あなたの記憶」: the owner's `personal-kg.jsonl`, read only.  The memory
+ * bodies are private, so these reads require the launch token and the same
+ * origin like every write on this host.
+ */
+export function createPersonalMemoryModule(context) {
+    const readMemories = () => readLocalPersonalMemories(context.dataDir);
+    const index = createPersonalMemoryJudgmentIndex({
+        source: createLocalJudgmentHistorySource({
+            root: context.journalRoot,
+            entrypoint: context.judgmentHistoryEntrypoint ?? 'codex'
+        }),
+        memoryIds: async () => {
+            const list = await readMemories();
+            return list.status === 'ok' ? list.items.map((item) => item.id) : null;
+        }
+    });
+    return {
+        id: 'personal-memory',
+        uiFiles: ['personal-memory.js', 'personal-memory-http-port.js', 'personal-memory.css'],
+        handle: createPersonalMemoryHttpHandler({
+            readMemories,
+            index,
+            authorize(request) {
+                if (isTrustedLocalWrite(request, context.token))
+                    return;
+                throw rejectUntrustedWrite(request, context.token)
+                    ?? new LocalWebHttpError(403, 'web_token_required', 'A valid launch token is required');
+            }
+        })
+    };
+}
 /** 今日 (value proofs), 目的と現状 (objectives + world model), プロジェクトと関係者 and 情報と関係 (Graph). */
 export function defaultLocalWebModules(context) {
     return [
@@ -900,7 +933,8 @@ export function defaultLocalWebModules(context) {
         createMeetingMinutesModule(context),
         createObjectiveFoundationModule(context),
         createWorldModelReadModule(context),
-        createGraphWebModule(context)
+        createGraphWebModule(context),
+        createPersonalMemoryModule(context)
     ];
 }
 function escapeAttribute(value) {

package/dist/personal-memory.d.ts

@@ -0,0 +1,101 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { JudgmentHistorySource } from './judgment-history.js';
+import type { PersonalKgEntry } from './types.js';
+/**
+ * 「あなたの記憶」 (docs/specs/personal-memory-viewer.md): the owner's own
+ * memories read from the local `personal-kg.jsonl`, and the judgments that
+ * used each one, found back from the judgment journal's `personal_knowledge`
+ * references.  Read only.  A memory body travels in the response body only,
+ * never in a URL or a log line.
+ */
+export declare const PERSONAL_MEMORY_HTTP_PREFIX = "/api/personal-memory";
+export type PersonalMemoryState = 'active' | 'superseded' | 'retracted' | 'unrecorded';
+export interface PersonalMemoryItem {
+    readonly id: string;
+    readonly kind: string | null;
+    readonly text: string;
+    readonly tags: readonly string[];
+    readonly state: PersonalMemoryState;
+    readonly supersededBy: string | null;
+    readonly origin: {
+        readonly organizationLabel: string | null;
+        readonly projectLabel: string | null;
+        readonly workplace: string | null;
+        readonly inferred: boolean;
+    };
+    readonly occurredAt: string | null;
+    readonly updatedAt: string | null;
+    readonly recallScope: 'organization' | 'general' | 'unknown';
+    readonly history: readonly {
+        readonly state: PersonalMemoryState;
+        readonly at: string;
+        readonly reason: string | null;
+    }[];
+}
+export type PersonalMemoryList = {
+    readonly status: 'ok';
+    readonly items: readonly PersonalMemoryItem[];
+} | {
+    readonly status: 'unavailable';
+    readonly reason: string;
+};
+export interface PersonalMemoryJudgment {
+    readonly decisionId: string;
+    readonly title: string | null;
+    readonly at: string;
+    readonly kind: string | null;
+}
+export type PersonalMemoryJudgments = {
+    readonly status: 'ok';
+    readonly items: readonly PersonalMemoryJudgment[];
+    readonly total: number;
+} | {
+    readonly status: 'unavailable';
+    readonly reason: string;
+};
+export type PersonalMemoryJudgmentCounts = {
+    readonly status: 'ok';
+    readonly counts: Readonly<Record<string, number>>;
+} | {
+    readonly status: 'unavailable';
+    readonly reason: string;
+};
+/** The local writer keeps no state, origin organization or recall scope: the spec's fixed values. */
+export declare function personalMemoryFromEntry(entry: PersonalKgEntry): PersonalMemoryItem;
+/** An empty file is zero memories; a missing or malformed one is unavailable, never zero. */
+export declare function readLocalPersonalMemories(dataDir: string): Promise<PersonalMemoryList>;
+export interface PersonalMemoryJudgmentIndex {
+    judgmentsUsing(id: string, limit: number): Promise<PersonalMemoryJudgments>;
+    counts(): Promise<PersonalMemoryJudgmentCounts>;
+}
+/**
+ * Finds judgments back from their `personal_knowledge` references.  A
+ * reference names a memory by its id, so the journal is bound to these
+ * memories only when at least one recorded reference is one of their ids.
+ * When every reference names a memory kept elsewhere (for example the
+ * organization's personal KG), "not used" cannot be told from "used under
+ * another id", and the answer is unavailable instead of zero.
+ */
+export declare function createPersonalMemoryJudgmentIndex(options: {
+    readonly source: JudgmentHistorySource;
+    /** The memory ids, or null when the memories cannot be read. */
+    readonly memoryIds: () => Promise<readonly string[] | null>;
+    /**
+     * How long one journal read answers later requests. A large journal takes
+     * tens of seconds to scan, and one opened memory asks for its judgments and
+     * the list's counts at the same time.
+     */
+    readonly reuseMs?: number;
+    readonly now?: () => number;
+}): PersonalMemoryJudgmentIndex;
+/**
+ * GET routes under `/api/personal-memory`.  `authorize` runs before any read
+ * and throws to refuse the request (the local host requires its launch token
+ * on these reads, not only on writes).
+ */
+export declare function createPersonalMemoryHttpHandler(options: {
+    readonly readMemories: () => Promise<PersonalMemoryList>;
+    readonly index: PersonalMemoryJudgmentIndex;
+    readonly authorize: (request: IncomingMessage) => void;
+    readonly basePath?: string;
+}): (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;

package/dist/personal-memory.js

@@ -0,0 +1,204 @@
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { requestUrl, writeJson } from './local-web-security.js';
+import { readPersonalKg } from './ssot.js';
+/**
+ * 「あなたの記憶」 (docs/specs/personal-memory-viewer.md): the owner's own
+ * memories read from the local `personal-kg.jsonl`, and the judgments that
+ * used each one, found back from the judgment journal's `personal_knowledge`
+ * references.  Read only.  A memory body travels in the response body only,
+ * never in a URL or a log line.
+ */
+export const PERSONAL_MEMORY_HTTP_PREFIX = '/api/personal-memory';
+/** The local writer keeps no state, origin organization or recall scope: the spec's fixed values. */
+export function personalMemoryFromEntry(entry) {
+    return {
+        id: entry.id,
+        kind: entry.type,
+        text: entry.text,
+        tags: [...entry.tags ?? []],
+        state: 'unrecorded',
+        supersededBy: null,
+        origin: { organizationLabel: '手元', projectLabel: null, workplace: null, inferred: false },
+        occurredAt: null,
+        updatedAt: entry.updatedAt ?? null,
+        recallScope: 'general',
+        history: []
+    };
+}
+function newestFirst(left, right) {
+    if (left === right)
+        return 0;
+    if (left === null)
+        return 1;
+    if (right === null)
+        return -1;
+    return left < right ? 1 : -1;
+}
+/** An empty file is zero memories; a missing or malformed one is unavailable, never zero. */
+export async function readLocalPersonalMemories(dataDir) {
+    try {
+        await stat(join(dataDir, 'personal-kg.jsonl'));
+    }
+    catch {
+        return { status: 'unavailable', reason: 'personal_kg_missing' };
+    }
+    let entries;
+    try {
+        entries = await readPersonalKg(dataDir);
+    }
+    catch {
+        return { status: 'unavailable', reason: 'personal_kg_invalid' };
+    }
+    const items = entries.map(personalMemoryFromEntry);
+    items.sort((left, right) => newestFirst(left.updatedAt, right.updatedAt));
+    return { status: 'ok', items };
+}
+function personalReferences(record) {
+    const refs = new Set();
+    for (const reference of record.judgment.selected_references ?? []) {
+        if (reference.kind === 'personal_knowledge' && reference.ref)
+            refs.add(reference.ref);
+    }
+    return refs;
+}
+/**
+ * Finds judgments back from their `personal_knowledge` references.  A
+ * reference names a memory by its id, so the journal is bound to these
+ * memories only when at least one recorded reference is one of their ids.
+ * When every reference names a memory kept elsewhere (for example the
+ * organization's personal KG), "not used" cannot be told from "used under
+ * another id", and the answer is unavailable instead of zero.
+ */
+export function createPersonalMemoryJudgmentIndex(options) {
+    async function build() {
+        const [snapshot, ids] = await Promise.all([options.source.read(), options.memoryIds()]);
+        if (ids === null)
+            return { status: 'unavailable', reason: 'personal_kg_unavailable' };
+        if (snapshot.status !== 'available' || !snapshot.records) {
+            return { status: 'unavailable', reason: `journal_${snapshot.status === 'partial' ? 'partial' : 'unavailable'}` };
+        }
+        const known = new Set(ids);
+        const byMemory = new Map(ids.map((id) => [id, []]));
+        let referenced = 0;
+        let bound = 0;
+        for (const record of snapshot.records) {
+            const refs = personalReferences(record);
+            for (const ref of refs) {
+                referenced += 1;
+                if (!known.has(ref))
+                    continue;
+                bound += 1;
+                byMemory.get(ref)?.push({ decisionId: record.record_id, title: record.judgment.summary, at: record.recorded_at, kind: null });
+            }
+        }
+        if (referenced > 0 && bound === 0)
+            return { status: 'unavailable', reason: 'reference_source_mismatch' };
+        for (const judgments of byMemory.values())
+            judgments.sort((left, right) => newestFirst(left.at, right.at));
+        return { status: 'ok', byMemory };
+    }
+    const reuseMs = options.reuseMs ?? 30_000;
+    const now = options.now ?? (() => Date.now());
+    let current = null;
+    function shared() {
+        if (current && now() - current.startedAt < reuseMs)
+            return current.promise;
+        const entry = { promise: build(), startedAt: now() };
+        current = entry;
+        // A failed read, a missing journal and unreadable memories are not reused: the owner may fix them now.
+        const forget = () => { if (current === entry)
+            current = null; };
+        entry.promise.then((index) => {
+            if (index.status === 'unavailable' && (index.reason === 'journal_unavailable' || index.reason === 'personal_kg_unavailable'))
+                forget();
+        }, forget);
+        return entry.promise;
+    }
+    return {
+        async judgmentsUsing(id, limit) {
+            const index = await shared();
+            if (index.status !== 'ok')
+                return index;
+            const judgments = index.byMemory.get(id) ?? [];
+            return { status: 'ok', items: judgments.slice(0, Math.max(0, limit)), total: judgments.length };
+        },
+        async counts() {
+            const index = await shared();
+            if (index.status !== 'ok')
+                return index;
+            return { status: 'ok', counts: Object.fromEntries([...index.byMemory].map(([id, judgments]) => [id, judgments.length])) };
+        }
+    };
+}
+const DEFAULT_JUDGMENT_LIMIT = 5;
+const MAX_JUDGMENT_LIMIT = 500;
+/**
+ * GET routes under `/api/personal-memory`.  `authorize` runs before any read
+ * and throws to refuse the request (the local host requires its launch token
+ * on these reads, not only on writes).
+ */
+export function createPersonalMemoryHttpHandler(options) {
+    const basePath = (options.basePath ?? PERSONAL_MEMORY_HTTP_PREFIX).replace(/\/+$/u, '');
+    return async (request, response) => {
+        const url = requestUrl(request);
+        if (url.pathname !== basePath && !url.pathname.startsWith(`${basePath}/`))
+            return false;
+        if (request.method !== 'GET') {
+            writeJson(response, 405, { error: { code: 'method_not_allowed', message: 'Use GET' } });
+            return true;
+        }
+        options.authorize(request);
+        const unavailable = (result) => writeJson(response, 503, { status: 'unavailable', reason: result.reason });
+        if (url.pathname === basePath) {
+            if (url.searchParams.get('view') === 'judgment-counts') {
+                const counts = await options.index.counts();
+                if (counts.status === 'ok')
+                    writeJson(response, 200, counts);
+                else
+                    unavailable(counts);
+                return true;
+            }
+            const list = await options.readMemories();
+            if (list.status === 'ok')
+                writeJson(response, 200, { status: 'ok', items: list.items, next_cursor: null });
+            else
+                unavailable(list);
+            return true;
+        }
+        const rest = url.pathname.slice(basePath.length + 1).split('/');
+        let id;
+        try {
+            id = decodeURIComponent(rest[0] ?? '');
+        }
+        catch {
+            writeJson(response, 400, { error: { code: 'invalid_id', message: 'The memory id is not valid' } });
+            return true;
+        }
+        if (!id || rest.length > 2 || (rest.length === 2 && rest[1] !== 'judgments')) {
+            writeJson(response, 404, { error: { code: 'not_found', message: 'Not found' } });
+            return true;
+        }
+        if (rest.length === 2) {
+            const requested = Number.parseInt(url.searchParams.get('limit') ?? '', 10);
+            const limit = Number.isInteger(requested) && requested > 0 ? Math.min(requested, MAX_JUDGMENT_LIMIT) : DEFAULT_JUDGMENT_LIMIT;
+            const judgments = await options.index.judgmentsUsing(id, limit);
+            if (judgments.status === 'ok')
+                writeJson(response, 200, judgments);
+            else
+                unavailable(judgments);
+            return true;
+        }
+        const list = await options.readMemories();
+        if (list.status !== 'ok') {
+            unavailable(list);
+            return true;
+        }
+        const item = list.items.find((candidate) => candidate.id === id);
+        if (item)
+            writeJson(response, 200, { status: 'ok', item });
+        else
+            writeJson(response, 404, { status: 'not_found' });
+        return true;
+    };
+}

package/dist/ssot.d.ts

@@ -1,7 +1,9 @@
 import { type CanonicalGraphMigrationPlan } from './ontology-migration.js';
-import type { PersonalOs } from './types.js';
+import type { PersonalKgEntry, PersonalOs } from './types.js';
 export declare function initializePersonalOs(dataDir: string): Promise<void>;
 export declare function loadPersonalOs(dataDir: string): Promise<PersonalOs>;
+/** Only `personal-kg.jsonl`, validated line by line as `loadPersonalOs` does. */
+export declare function readPersonalKg(dataDir: string): Promise<PersonalKgEntry[]>;
 export declare function mutatePersonalOs(dataDir: string, mutator: (current: PersonalOs) => PersonalOs | Promise<PersonalOs>): Promise<PersonalOs>;
 export declare function mutatePersonalOsWithSidecar<T>(dataDir: string, sidecarPath: string, mutator: (current: PersonalOs, sidecarContent?: string) => {
     next: PersonalOs;

package/dist/ssot.js

@@ -74,6 +74,10 @@ export async function loadPersonalOs(dataDir) {
         return loadPersonalOsUnlocked(dataDir);
     });
 }
+/** Only `personal-kg.jsonl`, validated line by line as `loadPersonalOs` does. */
+export async function readPersonalKg(dataDir) {
+    return readJsonl(join(dataDir, 'personal-kg.jsonl'), personalKgSchema, 'personal-kg.jsonl');
+}
 export async function mutatePersonalOs(dataDir, mutator) {
     return withSsotLock(dataDir, async () => {
         await recoverTransactions(dataDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.41.13",
+  "version": "0.42.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",
@@ -295,6 +295,10 @@
       "types": "./dist/streamable-http.d.ts",
       "import": "./dist/streamable-http.js"
     },
+    "./personal-memory": {
+      "types": "./dist/personal-memory.d.ts",
+      "import": "./dist/personal-memory.js"
+    },
     "./meeting-minutes": {
       "types": "./dist/meeting-minutes.d.ts",
       "import": "./dist/meeting-minutes.js"
@@ -328,6 +332,9 @@
     "./ui/world-model-view.css": "./ui/world-model-view.css",
     "./ui/people-and-companies-view": "./ui/people-and-companies-view.js",
     "./ui/people-and-companies-view.css": "./ui/people-and-companies-view.css",
+    "./ui/personal-memory": "./ui/personal-memory.js",
+    "./ui/personal-memory.css": "./ui/personal-memory.css",
+    "./ui/personal-memory-http-port": "./ui/personal-memory-http-port.js",
     "./ui/area-nav": "./ui/area-nav.js",
     "./ui/area-nav.css": "./ui/area-nav.css",
     "./ui/local-web-shell": "./ui/local-web-shell.js",
@@ -487,5 +494,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "fcfea3958913012579029adf0bf785c45643c77b"
+  "gitHead": "35fc142733aac0f385f2d21e6d0651e1a9d8d7db"
 }

package/ui/judgment-history.js

@@ -1148,12 +1148,45 @@ function appendJudgmentBasis(doc, references, labels) {
   return wrap;
 }
 
-function appendOwnerJudgment(doc, references) {
+function personalMemoryExcerpt(value) {
+  const body = String(value ?? '').replace(/\s+/gu, ' ').trim();
+  return body.length > 60 ? `${body.slice(0, 60)}…` : body;
+}
+
+/**
+ * The used memories the host resolved for this viewer: an opening and a link
+ * to あなたの記憶.  Only the owner's host resolves them; without that, or when
+ * the lookup failed, this stays the count only.
+ */
+function ownerMemoryLinks(doc, references, memories) {
+  if (!(memories instanceof Map)) return null;
+  const found = [];
+  for (const reference of Array.isArray(references) ? references : []) {
+    if (judgmentReferenceKind(reference) !== PERSONAL_KNOWLEDGE_KIND) continue;
+    const entry = memories.get(text(reference?.ref));
+    if (entry?.status === 'found') found.push(entry);
+  }
+  if (found.length === 0) return null;
+  const list = makeWorkspaceElement(doc, 'ul', { className: 'bb-jh-owner-memories', attrs: { 'aria-label': '使った記憶' } });
+  for (const entry of found) {
+    const item = makeWorkspaceElement(doc, 'li');
+    item.append(makeWorkspaceElement(doc, 'a', { text: entry.excerpt, attrs: { href: entry.href } }));
+    list.append(item);
+  }
+  return list;
+}
+
+function appendOwnerJudgment(doc, references, memories = null) {
   const { owner } = describeJudgmentBasis(references);
   const wrap = makeWorkspaceElement(doc, 'div', { className: `bb-jh-owner is-${owner.state}` });
   if (owner.state === 'applied') {
     wrap.append(makeWorkspaceElement(doc, 'strong', { text: `あなたの判断の材料（個人KG）を${owner.count}件使いました。` }));
-    wrap.append(makeWorkspaceElement(doc, 'p', { text: 'この判断には、あなたの考えが入っています。個人KGの中身はここには出しません。' }));
+    const links = ownerMemoryLinks(doc, references, memories);
+    if (links) {
+      wrap.append(makeWorkspaceElement(doc, 'p', { text: 'この判断には、あなたの考えが入っています。使った記憶はあなたにだけ見えています。' }), links);
+    } else {
+      wrap.append(makeWorkspaceElement(doc, 'p', { text: 'この判断には、あなたの考えが入っています。個人KGの中身はここには出しません。' }));
+    }
   } else if (owner.state === 'not_applied') {
     wrap.append(makeWorkspaceElement(doc, 'strong', { text: 'あなたの判断の材料（個人KG）は使っていません。' }));
     wrap.append(makeWorkspaceElement(doc, 'p', { text: 'Graphの哲学・目的・世界モデルと、AIの判断で進めました。' }));
@@ -1467,7 +1500,7 @@ function renderNormalRail(doc, rail, row, detail, onClose, options = {}) {
   }));
   rail.append(workspaceRailBlock(doc, {
     title: '本人の考え',
-    content: appendOwnerJudgment(doc, record.selectedReferences),
+    content: appendOwnerJudgment(doc, record.selectedReferences, options.personalMemories),
   }));
   rail.append(workspaceRailBlock(doc, {
     title: '判断の理由',
@@ -1907,6 +1940,10 @@ export function createJudgmentHistoryUI({
   // Optional host port: (references: {ref, kind}[]) => Promise<Map|object of ref -> name>.
   // The host resolves names under the viewer's current permission.
   resolveReferenceLabels = null,
+  // Optional owner-only port: (refs: string[]) => Promise<Map|object of ref -> { excerpt, href }>.
+  // A host passes it only to the owner; the 本人の考え block then shows the
+  // opening of each used memory with a link to あなたの記憶.
+  resolvePersonalMemory = null,
 } = {}) {
   if (!root) throw new TypeError('root is required');
   const doc = safeDocument(explicitDocument);
@@ -1946,6 +1983,7 @@ export function createJudgmentHistoryUI({
     skeletonTimer: null,
     slowTimer: null,
     labels: new Map(),
+    personalMemories: new Map(),
   };
 
   let filterPopover = null;
@@ -2254,6 +2292,37 @@ export function createJudgmentHistoryUI({
     void load({ append: false });
   }
 
+  function requestPersonalMemories(rows) {
+    if (typeof resolvePersonalMemory !== 'function') return;
+    const pending = [];
+    for (const row of rows) {
+      if (row.mode !== 'normal' || !Array.isArray(row.references)) continue;
+      for (const reference of row.references) {
+        const ref = text(reference?.ref);
+        if (!ref || judgmentReferenceKind(reference) !== PERSONAL_KNOWLEDGE_KIND || state.personalMemories.has(ref)) continue;
+        state.personalMemories.set(ref, { status: 'loading' });
+        pending.push(ref);
+      }
+    }
+    if (!pending.length) return;
+    const settle = (resolved) => {
+      if (state.disposed) return;
+      const lookup = resolved instanceof Map
+        ? (ref) => resolved.get(ref)
+        : isRecord(resolved) ? (ref) => resolved[ref] : () => null;
+      for (const ref of pending) {
+        const entry = lookup(ref);
+        const excerpt = isRecord(entry) ? personalMemoryExcerpt(entry.excerpt) : '';
+        const href = isRecord(entry) ? text(entry.href) : '';
+        state.personalMemories.set(ref, excerpt && href ? { status: 'found', excerpt, href } : { status: 'missing' });
+      }
+      render();
+    };
+    Promise.resolve()
+      .then(() => resolvePersonalMemory([...pending]))
+      .then(settle, () => settle(null));
+  }
+
   function requestReferenceLabels(rows) {
     const pending = [];
     for (const row of rows) {
@@ -2440,6 +2509,7 @@ export function createJudgmentHistoryUI({
       ? 'この期間に取得できた判断履歴はありません。全件数が未確認のため0件とは確認できません。'
       : 'この期間の判断履歴はありません。';
     requestReferenceLabels(aggregate.rows);
+    requestPersonalMemories(aggregate.rows);
     const dataRows = makeRows(doc, aggregate, state.selectedKey, (key) => {
       state.lastFocusedKey = key;
       state.selectedKey = key;
@@ -2507,6 +2577,7 @@ export function createJudgmentHistoryUI({
         onSubmitFeedback: (controls) => void submitFeedback(selected, controls),
         onCopyReference: (payload) => void copyReference(payload),
         labels: state.labels,
+        personalMemories: state.personalMemories,
       }
       : {};
     if (nativeDrawer) {