claude-memory-admin 1.5.1 → 1.5.2

package/public/views/index.mjs

@@ -0,0 +1,122 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { renderMarkdown } from '/markdown.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { paint } from '/bus.mjs';
+import { openStore, selectMemory, restoreFromTrash } from '/store.mjs';
+import { cutMarker } from '/parts.mjs';
+import { memoryLookup, openTarget } from '/views/memories.mjs';
+
+const INDEX_VIEWS = [
+  { id: 'rendered', label: 'Rendered' },
+  { id: 'source', label: 'Source' },
+];
+
+function setIndexView(view) {
+  state.indexView = view;
+  localStorage.setItem('memoryIndexView', view);
+  paint('tab');
+}
+
+function indexViewPicker() {
+  return node('div', { class: ui.segmentGroup, role: 'tablist' }, INDEX_VIEWS.map((view) => node('button', {
+    class: ui.segment(state.indexView === view.id),
+    text: view.label,
+    role: 'tab',
+    'aria-selected': String(state.indexView === view.id),
+    onclick: () => setIndexView(view.id),
+  })));
+}
+
+export function renderIndex(container) {
+  const project = state.store;
+  if (!project.hasIndex) {
+    container.append(node('p', { class: ui.note, text: 'This project has no MEMORY.md.' }));
+    return;
+  }
+
+  const card = node('div', { class: ui.card });
+  card.append(node('div', { class: ui.cardHeadRow }, [
+    node('p', { class: ui.note, text: `${project.index.entries.length} index entries · ${project.index.lines.length} lines` }),
+    indexViewPicker(),
+  ]));
+
+  if (state.indexView === 'source') renderIndexSource(card, project);
+  else renderIndexRendered(card, project);
+
+  container.append(card);
+}
+
+function renderIndexRendered(card, project) {
+  const { cutoff } = project.stats.index;
+  const files = new Set(project.memories.map((memory) => memory.file));
+  const byName = memoryLookup(project);
+  const options = {
+    resolveWikilink: (target) => openTarget(byName.get(target)),
+    resolveHref: (href) => openTarget(files.has(href) ? href : null),
+  };
+
+  const lines = project.index.raw.split('\n');
+  const loaded = node('div', { class: ui.prose });
+  renderMarkdown(loaded, cutoff ? lines.slice(0, cutoff.rawLine).join('\n') : project.index.raw, options);
+  card.append(loaded);
+
+  if (!cutoff) return;
+  card.append(cutMarker(cutoff));
+  const dropped = node('div', { class: ui.proseDim });
+  renderMarkdown(dropped, lines.slice(cutoff.rawLine).join('\n'), options);
+  card.append(dropped);
+}
+
+function renderIndexSource(card, project) {
+  const missing = new Set(project.health.danglingIndex.map((d) => d.index));
+  const { cutoff } = project.stats.index;
+
+  for (const line of project.index.lines) {
+    if (cutoff && line.index === cutoff.rawLine) card.append(cutMarker(cutoff));
+
+    const dangling = missing.has(line.index);
+    const dropped = Boolean(cutoff) && line.index >= cutoff.rawLine;
+    const clickable = line.kind === 'index' && !dangling;
+    const content = node('span', {
+      class: ui.indexLineText({ kind: line.kind, clickable, dropped }),
+      text: line.text || ' ',
+    });
+    if (clickable) content.onclick = () => selectMemory(line.file);
+
+    card.append(node('div', { class: ui.indexLine({ dangling, dropped }) }, [
+      node('span', { class: ui.indexLineNumber, text: String(line.index + 1) }),
+      content,
+    ]));
+  }
+}
+
+export function indexEntryAt(lineIndex) {
+  return state.store.index?.entries.find((entry) => entry.index === lineIndex) || null;
+}
+
+export function sectionsAbove(limit) {
+  const seen = [];
+  for (const line of state.store.index?.lines || []) {
+    if (line.kind !== 'heading') continue;
+    if (limit !== null && line.index >= limit) continue;
+    if (line.section && !seen.includes(line.section)) seen.push(line.section);
+  }
+  return seen;
+}
+
+export async function runIndexEdit(action, body, message) {
+  try {
+    const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(body),
+    });
+    await openStore(state.storeId, { keepTab: true });
+    toast(message(result), { action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) } });
+    return result;
+  } catch (err) {
+    toast(err.message, { error: true });
+    return null;
+  }
+}

package/public/views/issue.mjs

@@ -0,0 +1,270 @@
+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, goToTab } from '/parts.mjs';
+import { openStore, selectMemory, restoreFromTrash } from '/store.mjs';
+import { openDeleteDialog } from '/dialogs/delete.mjs';
+import { openAddEntryDialog } from '/dialogs/add-entry.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 === 'long-hooks') {
+    return issue(
+      `${item.count} index hook${item.count === 1 ? '' : 's'} over 200 characters`,
+      `longest is ${item.longest.hookLength} chars on "${item.longest.title}" - hooks load every session, so these are the cheapest thing to trim.`,
+      {
+        bad,
+        action: { label: 'Open Prune', run: () => goToTab('prune') },
+      },
+    );
+  }
+
+  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') {
+    return 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) },
+        action: { label: 'Open Prune', run: () => goToTab('prune') },
+      },
+    );
+  }
+
+  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: () => goToTab('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: () => goToTab('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,183 @@
+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 { goToTab, sessionDate } from '/parts.mjs';
+import { openDeleteDialog } from '/dialogs/delete.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)),
+  });
+}
+
+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,
+  ]);
+}
+
+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');
+  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) {
+    left.append(node('div', { class: ui.sectionLabel, text: `${section} · ${memories.length}` }));
+    for (const memory of memories) left.append(memoryButton(memory));
+  }
+
+  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 the Sessions tab',
+      onclick: () => goToTab('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/path-check.mjs

@@ -0,0 +1,102 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { api } from '/api.mjs';
+import { state } from '/state.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 (state.tab === 'health') 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));
+}