claude-memory-admin 1.5.1 → 1.6.0

package/public/views/issue.mjs

@@ -0,0 +1,262 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { confirmDialog } from '/dialog.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { issue, goTo } from '/parts.mjs';
+import { openStore, selectMemory, restoreFromTrash } from '/store.mjs';
+import { openDeleteDialog } from '/dialogs/delete.mjs';
+import { openAddEntryDialog } from '/dialogs/add-entry.mjs';
+import { openHookEditor } from '/dialogs/hook-editor.mjs';
+
+async function removeIndexLine(lineIndex, expectedText, done) {
+  const go = await confirmDialog({
+    title: `Remove line ${lineIndex + 1} from MEMORY.md?`,
+    confirmLabel: 'Remove',
+    tone: 'danger',
+    body: [
+      node('div', { class: ui.willBlock }, [
+        node('div', { class: ui.willTitle, text: 'Will be removed' }),
+        node('div', { class: ui.willItem('remove'), text: expectedText }),
+      ]),
+      node('p', { class: ui.noteTight, text: 'Only this line goes. The memory file it points at is left on disk.' }),
+    ],
+  });
+  if (!go) return;
+  try {
+    await api(`/api/stores/${encodeURIComponent(state.storeId)}/index-line/delete`, {
+      method: 'POST',
+      body: JSON.stringify({ lineIndex, expectedText }),
+    });
+    toast(done);
+    await openStore(state.storeId, { keepTab: true });
+  } catch (err) {
+    toast(err.message, { error: true });
+  }
+}
+
+export function renderIssue(item, memories) {
+  const bad = item.severity === 'bad';
+
+  if (item.kind === 'dangling-index') {
+    const { entry } = item;
+    return issue(
+      `MEMORY.md points at a file that does not exist: ${entry.file}`,
+      `line ${entry.index + 1}: ${entry.text}`,
+      {
+        bad,
+        action: {
+          label: 'Remove pointer',
+          run: () => removeIndexLine(entry.index, entry.text, 'Pointer removed'),
+        },
+      },
+    );
+  }
+
+  if (item.kind === 'dangling-wikilink') {
+    const { link } = item;
+    return issue(
+      `Broken [[${link.target}]]`,
+      `referenced from ${link.from} - no memory has that name`,
+      {
+        bad,
+        secondary: { label: 'Open source', run: () => selectMemory(link.from) },
+        action: {
+          label: 'Remove link',
+          run: async () => {
+            const go = await confirmDialog({
+              title: `Remove [[${link.target}]] from ${link.from}?`,
+              confirmLabel: 'Remove link',
+              tone: 'danger',
+              body: [
+                node('p', { class: ui.noteTight, text: 'The link markup goes, the words stay.' }),
+                node('div', { class: ui.willBlock }, [
+                  node('div', { class: ui.willTitle, text: 'Will change' }),
+                  node('div', { class: ui.willItem('remove'), text: `see [[${link.target}]]` }),
+                  node('div', { class: ui.willItem('keep'), text: `see ${link.target}` }),
+                ]),
+                node('p', { class: ui.noteTight, text: 'A copy of the file is kept in the trash, so this can be undone.' }),
+              ],
+            });
+            if (!go) return;
+            try {
+              const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/wikilink/remove`, {
+                method: 'POST',
+                body: JSON.stringify({ file: link.from, target: link.target }),
+              });
+              await openStore(state.storeId, { keepTab: true });
+              toast(`Unlinked ${result.occurrences} reference(s)`, {
+                action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) },
+              });
+            } catch (err) {
+              toast(err.message, { error: true });
+            }
+          },
+        },
+      },
+    );
+  }
+
+  if (item.kind === 'orphan') {
+    const memory = memories.find((m) => m.file === item.file);
+    return issue(
+      `Not referenced anywhere in MEMORY.md: ${item.file}`,
+      `"${memory?.name || item.file}" exists on disk but nothing points to it, so Claude will not load it.`,
+      {
+        bad,
+        secondary: { label: 'Open', run: () => selectMemory(item.file) },
+        action: { label: 'Add to MEMORY.md', run: () => openAddEntryDialog(item.file) },
+      },
+    );
+  }
+
+  if (item.kind === 'referenced-only') {
+    const memory = memories.find((m) => m.file === item.file);
+    return issue(
+      `Linked mid-sentence, not indexed: ${item.file}`,
+      `"${memory?.name || item.file}" is mentioned inside prose in MEMORY.md but has no index bullet of its own.`,
+      {
+        bad,
+        secondary: { label: 'Open', run: () => selectMemory(item.file) },
+        action: { label: 'Add to MEMORY.md', run: () => openAddEntryDialog(item.file) },
+      },
+    );
+  }
+
+  if (item.kind === 'name-mismatch') {
+    return issue(
+      `Frontmatter name differs from filename: ${item.mismatch.file}`,
+      `name: "${item.mismatch.name}" - [[wikilinks]] must use this name, not the filename.`,
+      { bad, action: { label: 'Open', run: () => selectMemory(item.mismatch.file) } },
+    );
+  }
+
+  if (item.kind === 'missing-frontmatter') {
+    return issue(
+      `No YAML frontmatter: ${item.file}`,
+      'Type and description cannot be read from this file.',
+      { bad, action: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+  }
+
+  if (item.kind === 'duplicate-name') {
+    return issue(
+      `Two memories claim the name "${item.name}"`,
+      `${item.files.join(', ')} - every [[${item.name}]] resolves to ${item.reachable}, so the other one cannot be linked at all.`,
+      {
+        bad,
+        secondary: { label: 'Open first', run: () => selectMemory(item.files[0]) },
+        action: { label: 'Open second', run: () => selectMemory(item.files[1]) },
+      },
+    );
+  }
+
+  if (item.kind === 'duplicate-index-entry') {
+    return issue(
+      `Listed twice in MEMORY.md: ${item.file}`,
+      `lines ${item.lines.map((line) => line + 1).join(' and ')} - one memory, two index lines, both loaded every session.`,
+      {
+        bad,
+        action: {
+          label: 'Remove duplicate',
+          run: () => removeIndexLine(item.removable.index, item.removable.text, 'Duplicate removed'),
+        },
+      },
+    );
+  }
+
+  if (item.kind === 'missing-description') {
+    return issue(
+      `No description: ${item.file}`,
+      'The description is what a memory is recalled by, so this one is found on its name alone.',
+      { bad, action: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+  }
+
+  if (item.kind === 'unknown-type') {
+    return issue(
+      `Unrecognised type: ${item.file}`,
+      `type: "${item.type}" - expected one of user, feedback, project, reference.`,
+      { bad, action: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+  }
+
+  if (item.kind === 'empty-body') {
+    const memory = memories.find((m) => m.file === item.file);
+    return issue(
+      `Almost nothing in it: ${item.file}`,
+      `"${memory?.name || item.file}" has ${item.chars} characters of body - it costs an index line every session and says nothing.`,
+      {
+        bad,
+        secondary: { label: 'Open', run: () => selectMemory(item.file) },
+        action: { label: 'Delete', run: () => openDeleteDialog(item.file) },
+      },
+    );
+  }
+
+  if (item.kind === 'hook-repeats-description') {
+    const row = issue(
+      `Hook repeats the description: ${item.file}`,
+      `MEMORY.md line ${item.index + 1} - ${item.hookLength} characters restating what the file's own description already says. Only the hook loads every session.`,
+      { bad, secondary: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+    row.append(node('button', {
+      class: ui.buttonPrimarySmall,
+      text: 'Edit hook',
+      onclick: () => openHookEditor(row, item.index),
+    }));
+    return row;
+  }
+
+  if (item.kind === 'empty-section') {
+    return issue(
+      `Empty section in MEMORY.md: "${item.section}"`,
+      `line ${item.index + 1} - the heading has no entries under it, and headings count against the 200-line budget too.`,
+      { bad, action: { label: 'Open MEMORY.md', run: () => goTo('memory', 'index') } },
+    );
+  }
+
+  if (item.kind === 'stale-path') {
+    return issue(
+      `No file matches ${item.token}`,
+      `named by "${item.name || item.file}"`,
+      { bad, action: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+  }
+
+  if (item.kind === 'index-continuation') {
+    return issue(
+      `${item.count} index ${item.count === 1 ? 'entry spills' : 'entries spill'} onto extra lines`,
+      `${item.extraLines} extra line${item.extraLines === 1 ? '' : 's'} of the 200-line budget - the guidance is one line per entry, with the detail in the topic file.`,
+      { bad, action: { label: 'Open MEMORY.md', run: () => goTo('memory', 'index') } },
+    );
+  }
+
+  if (item.kind === 'provenance-expired') {
+    return issue(
+      `Provenance gone: ${item.name}`,
+      `the session it was written in (${item.sessionId}) has been swept, so why this memory exists can no longer be traced. Nothing recovers it - judge the memory on what it says.`,
+      { bad, action: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+  }
+
+  if (item.kind === 'path-evidence-expiring') {
+    return issue(
+      item.days === 0
+        ? 'The last transcript naming this project is due to be swept'
+        : `The last transcript naming this project is swept in ${item.days} days`,
+      `${item.path} is recovered from the session transcripts, and Claude Code drops those after ${item.retentionDays} days while never touching memory/. Once the last one goes this store shows its raw folder name instead. Remember path records it now.`,
+      { bad, action: { label: 'Remember path\u2026', run: openRememberPathDialog } },
+    );
+  }
+
+  if (item.kind === 'no-memory-despite-sessions') {
+    return issue(
+      `${item.sessionCount} ${item.sessionCount === 1 ? 'session' : 'sessions'}, and no memory written`,
+      `auto memory is on for this project, but nothing has been saved in the ${item.retentionDays} days of transcripts kept here. Either nothing was worth remembering, or memory is not being written.`,
+      { bad },
+    );
+  }
+
+  return issue(item.kind, JSON.stringify(item));
+}

package/public/views/memories.mjs

@@ -0,0 +1,156 @@
+import * as ui from '/ui.mjs';
+import { el, node } from '/dom.mjs';
+import { renderMarkdown } from '/markdown.mjs';
+import { state } from '/state.mjs';
+import { selectMemory, loadSessionsForProvenance } from '/store.mjs';
+import { goTo, sessionDate } from '/parts.mjs';
+import { openDeleteDialog } from '/dialogs/delete.mjs';
+import { renderMemoryList } from '/views/memory-list.mjs';
+
+export function memoryLookup(project) {
+  const byName = new Map();
+  for (const memory of project.memories) {
+    byName.set(memory.name, memory.file);
+    byName.set(memory.stem, memory.file);
+  }
+  return byName;
+}
+
+export function openTarget(file) {
+  return file ? { open: () => selectMemory(file) } : null;
+}
+
+export function renderBody(container, memory, project) {
+  const byName = memoryLookup(project);
+  renderMarkdown(container, memory.body, {
+    resolveWikilink: (target) => openTarget(byName.get(target)),
+  });
+}
+
+export function renderMemories(container) {
+  const project = state.store;
+  if (!project.memories.length) {
+    container.append(node('p', { class: ui.note, text: 'This project has no memory files yet.' }));
+    return;
+  }
+
+  const left = node('div');
+  renderMemoryList(left);
+
+  const right = node('div', { id: 'detail', class: ui.detailPane });
+  container.append(node('div', { class: ui.split }, [left, right]));
+  renderDetail();
+}
+
+function renderDetail() {
+  const host = el('detail');
+  if (!host) return;
+  host.textContent = '';
+
+  const memory = state.store.memories.find((m) => m.file === state.selected);
+  if (!memory) {
+    host.append(node('p', { class: ui.note, text: 'Select a memory to read it.' }));
+    return;
+  }
+
+  const card = node('div', { class: ui.card });
+  card.append(node('div', { class: ui.detailHead }, [
+    node('h3', { class: ui.detailTitle, text: memory.name }),
+    node('span', { class: ui.typeBadge(memory.type), text: memory.type }),
+    node('button', {
+      class: ui.buttonDangerSmall,
+      text: 'Delete',
+      onclick: () => openDeleteDialog(memory.file),
+    }),
+  ]));
+
+  if (memory.description) card.append(node('p', { class: ui.detailDesc, text: memory.description }));
+
+  const meta = node('dl', { class: ui.metaList });
+  const rows = [
+    ['file', memory.file],
+    ['status', memory.status],
+    ['modified', memory.modified
+      ? `${memory.modified.replace('T', ' ').replace(/\..*$/, '')}${memory.modifiedFrom === 'mtime' ? '  (file mtime)' : ''}`
+      : '-'],
+    ['size', `${(memory.bytes / 1024).toFixed(1)} KB`],
+  ];
+  if (!memory.nameMatchesFile) rows.push(['name', `${memory.name}  (differs from filename)`]);
+  for (const [key, value] of Object.entries(memory.metadata)) {
+    if (key !== 'type' && key !== 'modified' && key !== 'originSessionId') rows.push([key, value]);
+  }
+  for (const [key, value] of rows) {
+    meta.append(node('dt', { class: ui.metaKey, text: key }), node('dd', { class: ui.metaValue, text: String(value) }));
+  }
+  card.append(meta);
+
+  const origin = provenanceLine(memory);
+  if (origin) card.append(origin);
+
+  const body = node('div', { class: ui.prose });
+  card.append(body);
+  renderBody(body, memory, state.store);
+
+  const outbound = memory.outboundResolved || [];
+  if (outbound.length || memory.inbound.length) {
+    const links = node('div', { class: ui.linkSection });
+    if (outbound.length) {
+      links.append(node('div', { class: ui.sectionLabel, text: 'Links out' }));
+      const chips = node('div', { class: ui.linkRow });
+      for (const link of outbound) {
+        chips.append(node('button', {
+          class: ui.chip(Boolean(link.file)),
+          text: link.file ? link.target : `${link.target} (missing)`,
+          onclick: link.file ? () => selectMemory(link.file) : null,
+        }));
+      }
+      links.append(chips);
+    }
+    if (memory.inbound.length) {
+      links.append(node('div', { class: ui.sectionLabel, text: 'Linked from' }));
+      const chips = node('div', { class: ui.linkRow });
+      for (const link of memory.inbound) {
+        const source = state.store.memories.find((m) => m.file === link.from);
+        chips.append(node('button', {
+          class: ui.chip(true),
+          text: source ? source.name : link.from,
+          onclick: () => selectMemory(link.from),
+        }));
+      }
+      links.append(chips);
+    }
+    card.append(links);
+  }
+
+  host.append(card);
+}
+
+function provenanceLine(memory) {
+  const origin = memory.origin;
+  if (!origin) return null;
+
+  const known = state.aux.sessions?.sessions.find((session) => session.id === origin.sessionId);
+  const label = origin.present ? (known?.title || origin.sessionId) : origin.sessionId;
+
+  const row = node('div', { class: ui.provenanceRow }, [node('span', { text: 'written in' })]);
+
+  if (origin.present) {
+    row.append(node('button', {
+      class: ui.provenanceLink(true),
+      text: label,
+      title: 'Open Environment \u203a Sessions',
+      onclick: () => goTo('environment', 'sessions'),
+    }));
+    if (known?.gitBranch) row.append(node('span', { text: `on ${known.gitBranch}` }));
+    if (origin.modified) row.append(node('span', { text: sessionDate(origin.modified).slice(0, 10) }));
+    if (!known) loadSessionsForProvenance();
+  } else {
+    row.append(node('span', {
+      class: ui.provenanceLink(false),
+      text: label,
+      title: 'This transcript is no longer on disk',
+    }));
+    row.append(node('span', { text: '- transcript swept, so why this memory exists can no longer be traced' }));
+  }
+  return row;
+}

package/public/views/memory-list.mjs

@@ -0,0 +1,121 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { state } from '/state.mjs';
+import { paint } from '/bus.mjs';
+import { formatAge } from '/parts.mjs';
+import { selectMemory } from '/store.mjs';
+import { openBulkDeleteDialog } from '/dialogs/bulk-delete.mjs';
+
+const SORTS = {
+  section: { label: 'by section', compare: null },
+  oldest: { label: 'oldest first', compare: (a, b) => (b.ageDays ?? -1) - (a.ageDays ?? -1) },
+  largest: { label: 'largest first', compare: (a, b) => b.bytes - a.bytes },
+  unlinked: { label: 'least linked', compare: (a, b) => a.inbound.length - b.inbound.length || (b.ageDays ?? 0) - (a.ageDays ?? 0) },
+  name: { label: 'by name', compare: (a, b) => a.name.localeCompare(b.name) },
+};
+
+function memoryButton(memory) {
+  const active = state.selected === memory.file;
+  return node('button', {
+    class: ui.memoryItem(active),
+    'data-memory': memory.file,
+    'data-active': active ? '' : null,
+    onclick: () => selectMemory(memory.file),
+  }, [
+    node('span', { class: ui.memoryTop }, [
+      node('span', { class: ui.memoryName, text: memory.name }),
+      node('span', { class: ui.typeBadge(memory.type), text: memory.type }),
+      memory.status !== 'indexed'
+        ? node('span', { class: ui.badge('warn'), text: memory.status })
+        : null,
+    ]),
+    memory.description ? node('span', { class: ui.memoryDesc, text: memory.description }) : null,
+    node('span', { class: ui.memoryFacts }, [
+      node('span', { class: ui.memoryFact((memory.ageDays ?? 0) > 180), text: formatAge(memory.ageDays) }),
+      node('span', { text: `${(memory.bytes / 1024).toFixed(1)}K` }),
+      node('span', { class: ui.memoryFact(!memory.inbound.length), text: `${memory.inbound.length} in` }),
+    ]),
+  ]);
+}
+
+function memoryRow(memory, onToggle) {
+  const row = node('div', { class: ui.listItemRow });
+  if (state.selecting) {
+    const box = node('input', { type: 'checkbox', class: ui.checkbox, 'aria-label': `Select ${memory.name}` });
+    box.checked = state.listSelection.has(memory.file);
+    box.addEventListener('change', () => {
+      if (box.checked) state.listSelection.add(memory.file);
+      else state.listSelection.delete(memory.file);
+      onToggle();
+    });
+    row.append(box);
+  }
+  row.append(memoryButton(memory));
+  return row;
+}
+
+function setSort(value) {
+  state.listSort = value;
+  localStorage.setItem('memoryListSort', value);
+  paint('tab');
+}
+
+function toolbar() {
+  const bar = node('div', { class: ui.listBar });
+  const sort = node('select', { class: ui.select, 'aria-label': 'Sort memories' });
+  for (const [key, config] of Object.entries(SORTS)) {
+    sort.append(node('option', { value: key, text: config.label }));
+  }
+  sort.value = state.listSort;
+  sort.onchange = () => setSort(sort.value);
+
+  const count = node('span', { class: ui.note });
+  const deleteButton = node('button', { class: ui.buttonDangerSmall });
+  const selectButton = node('button', {
+    class: ui.buttonSmall,
+    text: state.selecting ? 'Done' : 'Select',
+    onclick: () => {
+      state.selecting = !state.selecting;
+      if (!state.selecting) state.listSelection.clear();
+      paint('tab');
+    },
+  });
+
+  bar.append(sort, node('span', { class: ui.listSpacer }), count, selectButton);
+  if (state.selecting) bar.append(deleteButton);
+  deleteButton.onclick = () => openBulkDeleteDialog([...state.listSelection]);
+
+  const update = () => {
+    const size = state.listSelection.size;
+    count.textContent = size ? `${size} selected` : '';
+    deleteButton.textContent = `Delete ${size || ''}`.trim();
+    deleteButton.disabled = size === 0;
+  };
+  update();
+  return { bar, update };
+}
+
+export function renderMemoryList(container) {
+  const project = state.store;
+  const { bar, update } = toolbar();
+  container.append(bar);
+
+  const compare = SORTS[state.listSort].compare;
+  if (!compare) {
+    const groups = new Map();
+    for (const memory of project.memories) {
+      const key = memory.section || (memory.status === 'indexed' ? 'Index' : 'Not in the index');
+      if (!groups.has(key)) groups.set(key, []);
+      groups.get(key).push(memory);
+    }
+    for (const [section, memories] of groups) {
+      container.append(node('div', { class: ui.sectionLabel, text: `${section} · ${memories.length}` }));
+      for (const memory of memories) container.append(memoryRow(memory, update));
+    }
+    return;
+  }
+
+  for (const memory of [...project.memories].sort(compare)) {
+    container.append(memoryRow(memory, update));
+  }
+}

package/public/views/memory.mjs

@@ -0,0 +1,32 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { state } from '/state.mjs';
+import { paint } from '/bus.mjs';
+import { renderSegmented } from '/views/segments.mjs';
+import { renderMemories } from '/views/memories.mjs';
+import { renderIndex } from '/views/index.mjs';
+import { renderGraph } from '/graph.mjs';
+import { selectMemory } from '/store.mjs';
+
+function renderMemoryGraph(container) {
+  const wrap = node('div', { id: 'graph-wrap', class: ui.graphWrap });
+  container.append(wrap);
+  renderGraph(wrap, state.store.graph, {
+    selected: state.selected,
+    spread: state.spread,
+    onSelect: (file) => selectMemory(file),
+    onSpreadChange: (value) => {
+      state.spread = value;
+      localStorage.setItem('graphSpread', String(value));
+      paint('tab');
+    },
+  });
+}
+
+export function renderMemory(container) {
+  return renderSegmented(container, 'memory', {
+    list: renderMemories,
+    index: renderIndex,
+    graph: renderMemoryGraph,
+  });
+}

package/public/views/path-check.mjs

@@ -0,0 +1,103 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { api } from '/api.mjs';
+import { state } from '/state.mjs';
+import { isAt } from '/parts.mjs';
+import { paint } from '/bus.mjs';
+import { renderIssue } from '/views/issue.mjs';
+
+function storeHasProjectDir() {
+  return state.store.kind === 'auto'
+    ? state.store.resolvedBy !== 'unresolved'
+    : Boolean(state.store.projectPath);
+}
+
+const pathCheckKey = () => `pathCheck:${state.storeId}`;
+
+async function fetchPathCheck() {
+  const id = state.storeId;
+  let next;
+  try {
+    next = { running: false, data: await api(`/api/stores/${encodeURIComponent(id)}/path-check`) };
+  } catch (err) {
+    next = { running: false, error: err.message };
+  }
+  if (state.storeId !== id) return;
+  state.pathCheck = next;
+  if (isAt('cleanup')) paint('tab');
+}
+
+function startPathCheck({ remember = true } = {}) {
+  if (remember) localStorage.setItem(pathCheckKey(), '1');
+  state.pathCheck = { running: true };
+  fetchPathCheck();
+}
+
+function runPathCheck() {
+  startPathCheck();
+  paint('tab');
+}
+
+function stopPathCheck() {
+  localStorage.removeItem(pathCheckKey());
+  state.pathCheck = null;
+  paint('tab');
+}
+
+export function renderPathCheck(container) {
+  if (!storeHasProjectDir()) return;
+
+  if (!state.pathCheck && localStorage.getItem(pathCheckKey()) === '1') {
+    startPathCheck({ remember: false });
+  }
+  const check = state.pathCheck;
+
+  const head = node('div', { class: ui.issue(false) });
+  const body = node('div', { class: ui.issueBody });
+
+  if (!check) {
+    body.append(
+      node('div', { class: ui.issueTitle, text: 'Paths named in memories are not being checked' }),
+      node('div', { class: ui.issueDetail, text: 'Every other check on this tab reads only memory/. This one reads the project itself, to find memories naming files that no longer exist. It stays off until you ask, and is remembered per store.' }),
+    );
+    head.append(body, node('button', { class: ui.buttonSmall, text: 'Check against the repo', onclick: () => runPathCheck() }));
+    return container.append(head);
+  }
+
+  if (check.running) {
+    body.append(node('div', { class: ui.issueTitle, text: 'Checking paths against the repo…' }));
+    head.append(body);
+    return container.append(head);
+  }
+
+  if (check.error) {
+    body.append(
+      node('div', { class: ui.issueTitle, text: 'Path check could not run' }),
+      node('div', { class: ui.issueDetail, text: check.error }),
+    );
+    head.append(body, node('button', { class: ui.buttonSmall, text: 'Turn off', onclick: () => stopPathCheck() }));
+    return container.append(head);
+  }
+
+  const { checked, capped, missing, indexed, truncated } = check.data;
+  const scanned = `${indexed.toLocaleString()} files and folders scanned${truncated ? ', stopped at the index limit' : ''}`;
+  body.append(
+    node('div', { class: ui.issueTitle, text: missing.length
+      ? `${missing.length} of ${checked} paths named in memories match no file in the project`
+      : `All ${checked} paths named in memories still match a file` }),
+    node('div', { class: ui.issueDetail, text: capped
+      ? `${scanned}; stopped after the first ${checked} paths, so there may be more`
+      : scanned }),
+  );
+  if (missing.length) {
+    body.append(node('div', { class: ui.issueDetail, text: 'A pointer rather than a verdict: a file that moved reads the same as one the memory never got right.' }));
+  }
+  head.append(
+    body,
+    node('button', { class: ui.buttonSmall, text: 'Turn off', onclick: () => stopPathCheck() }),
+    node('button', { class: ui.buttonSmall, text: 'Re-check', onclick: () => runPathCheck() }),
+  );
+  container.append(head);
+
+  for (const item of missing) container.append(renderIssue(item, state.store.memories));
+}