claude-memory-admin 1.4.0 → 1.5.1

package/public/app.mjs

@@ -1,5 +1,7 @@
 import { renderGraph } from '/graph.mjs';
 import { renderMarkdown } from '/markdown.mjs';
+import { confirmDialog, isDialogOpen, openDialog } from '/dialog.mjs';
+import { el, node } from '/dom.mjs';
 import * as ui from '/ui.mjs';
 
 const state = {
@@ -17,7 +19,7 @@ const state = {
   pruneSort: 'oldest',
   pruneSelection: new Set(),
   indexView: localStorage.getItem('memoryIndexView') === 'source' ? 'source' : 'rendered',
-  aux: { instructions: null, settings: null },
+  aux: { instructions: null, settings: null, sessions: null },
   pathCheck: null,
 };
 
@@ -25,8 +27,6 @@ const RANK = { ok: 0, warn: 1, bad: 2 };
 const worst = (...severities) => severities.reduce((a, b) => (RANK[b] > RANK[a] ? b : a), 'ok');
 const worstSeverity = (items) => (!items.length ? 'ok' : items.some((item) => item.severity === 'bad') ? 'bad' : 'warn');
 
-const el = (id) => document.getElementById(id);
-
 async function api(path, options) {
   const response = await fetch(path, {
     headers: { 'content-type': 'application/json' },
@@ -38,32 +38,17 @@ async function api(path, options) {
 }
 
 function toast(message, { error = false, action } = {}) {
-  const node = document.createElement('div');
-  node.className = ui.toast(error);
-  node.append(document.createTextNode(message));
+  const element = node('div', { class: ui.toast(error) });
+  element.append(document.createTextNode(message));
   if (action) {
-    const button = document.createElement('button');
-    button.className = ui.toastAction;
-    button.textContent = action.label;
-    button.onclick = () => { node.remove(); action.run(); };
-    node.append(button);
+    element.append(node('button', {
+      class: ui.toastAction,
+      text: action.label,
+      onclick: () => { element.remove(); action.run(); },
+    }));
   }
-  el('toast-root').append(node);
-  setTimeout(() => node.remove(), action ? 12000 : 4500);
-}
-
-function node(tag, props = {}, children = []) {
-  const element = document.createElement(tag);
-  for (const [key, value] of Object.entries(props)) {
-    if (key === 'class') element.className = value;
-    else if (key === 'text') element.textContent = value;
-    else if (key.startsWith('on')) element.addEventListener(key.slice(2).toLowerCase(), value);
-    else if (value !== null && value !== undefined) element.setAttribute(key, value);
-  }
-  for (const child of [].concat(children)) {
-    if (child) element.append(child);
-  }
-  return element;
+  el('toast-root').append(element);
+  setTimeout(() => element.remove(), action ? 12000 : 4500);
 }
 
 function memoryLookup(project) {
@@ -153,6 +138,7 @@ const TABS = [
   { id: 'graph', label: 'Graph' },
   { id: 'prune', label: 'Prune' },
   { id: 'context', label: 'Context' },
+  { id: 'sessions', label: 'Sessions' },
   { id: 'health', label: 'Health' },
   { id: 'settings', label: 'Settings' },
   { id: 'trash', label: 'Trash' },
@@ -169,6 +155,7 @@ function renderTabs() {
   for (const tab of TABS) {
     if (global && tab.id !== 'context') continue;
     if (!global && tab.id === 'context' && !hasProjectDir) continue;
+    if (tab.id === 'sessions' && !state.store.sessions?.count) continue;
     let badge = null;
     let tone = 'neutral';
     if (tab.id === 'memories') badge = String(state.store.memories.length);
@@ -181,6 +168,10 @@ function renderTabs() {
       badge = '!';
       tone = state.store.stats.index.level === 'over' ? 'bad' : 'warn';
     }
+    if (tab.id === 'sessions' && state.store.sessions) {
+      badge = String(state.store.sessions.count);
+      if (state.store.sessions.expiringCount) tone = 'warn';
+    }
     if (tab.id === 'context' && state.aux.instructions?.problems.length) {
       badge = String(state.aux.instructions.problems.length);
       tone = worstSeverity(state.aux.instructions.problems);
@@ -278,13 +269,16 @@ function renderDetail() {
   ];
   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') rows.push([key, value]);
+    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);
@@ -658,7 +652,19 @@ function goToTab(id) {
 }
 
 async function removeIndexLine(lineIndex, expectedText, done) {
-  if (!confirm(`Remove line ${lineIndex + 1} from MEMORY.md?\n\n${expectedText}`)) return;
+  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',
@@ -700,7 +706,21 @@ function renderIssue(item, memories) {
         action: {
           label: 'Remove link',
           run: async () => {
-            if (!confirm(`Remove [[${link.target}]] from ${link.from}?\n\nThe link markup goes, the words stay:\n  "see [[${link.target}]]"  ->  "see ${link.target}"\n\nA copy of the file is kept in the trash, so this can be undone.`)) return;
+            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',
@@ -863,6 +883,32 @@ function renderIssue(item, memories) {
     );
   }
 
+  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));
 }
 
@@ -887,6 +933,157 @@ const SETTINGS_PROBLEMS = {
 
 const show = (value) => (value === undefined ? 'unset' : JSON.stringify(value));
 
+const TITLE_SOURCE = {
+  'ai-title': 'title Claude Code generated for this session',
+  slug: 'session slug, no generated title found in the part read',
+  prompt: 'first prompt, no generated title found in the part read',
+};
+
+const sizeLabel = (bytes) => (bytes >= 1048576
+  ? `${(bytes / 1048576).toFixed(1)} MB`
+  : `${(bytes / 1024).toFixed(1)} KB`);
+
+function sessionDate(iso) {
+  return iso ? iso.replace('T', ' ').replace(/\..*$/, '') : 'unknown';
+}
+
+function sessionRow(session, memoriesFrom) {
+  const soon = session.expiresInDays !== null && session.expiresInDays <= 7;
+  const caret = node('span', { class: ui.contextCaret, text: '\u25b8' });
+
+  const tags = [];
+  if (session.gitBranch) tags.push(node('span', { class: ui.badge('neutral'), text: session.gitBranch }));
+  if (session.model) tags.push(node('span', { class: ui.badge('neutral'), text: session.model }));
+  if (session.expiresInDays !== null) {
+    tags.push(node('span', {
+      class: ui.badge(soon ? 'warn' : 'neutral'),
+      text: session.expiresInDays === 0 ? 'due to be swept' : `swept in ${session.expiresInDays}d`,
+    }));
+  }
+  for (const memory of memoriesFrom) {
+    tags.push(node('span', { class: ui.badge('project'), text: memory.name }));
+  }
+
+  const body = node('div', { class: ui.contextBody, hidden: true });
+  const facts = node('dl', { class: ui.metaList });
+  const rows = [
+    ['session', session.id],
+    ['last active', `${sessionDate(session.modified)}  (file mtime)`],
+    ['size', sizeLabel(session.bytes)],
+  ];
+  if (session.cwd) rows.push(['cwd', session.cwd]);
+  if (session.version) rows.push(['version', session.version]);
+  if (session.titleFrom) rows.push(['title from', TITLE_SOURCE[session.titleFrom] || session.titleFrom]);
+  for (const [key, value] of rows) {
+    facts.append(node('dt', { class: ui.metaKey, text: key }), node('dd', { class: ui.metaValue, text: value }));
+  }
+  body.append(facts);
+  if (session.prompt) {
+    body.append(node('div', { class: ui.sectionLabel, text: 'Opened with' }));
+    body.append(node('p', { class: ui.note, text: session.prompt }));
+  }
+  if (memoriesFrom.length) {
+    body.append(node('div', { class: ui.sectionLabel, text: 'Memories written here' }));
+    const chips = node('div', { class: ui.linkRow });
+    for (const memory of memoriesFrom) {
+      chips.append(node('button', {
+        class: ui.chip(true),
+        text: memory.name,
+        onclick: () => selectMemory(memory.file),
+      }));
+    }
+    body.append(chips);
+  }
+
+  const button = node('button', {
+    class: ui.contextRowButton,
+    'aria-expanded': 'false',
+    onclick: (event) => {
+      const open = body.hidden;
+      body.hidden = !open;
+      caret.textContent = open ? '\u25be' : '\u25b8';
+      event.currentTarget.setAttribute('aria-expanded', open ? 'true' : 'false');
+    },
+  }, [
+    node('div', { class: ui.contextMain }, [
+      node('div', { class: ui.contextTags }, tags),
+      node('div', { class: ui.contextFile }, [caret, document.createTextNode(session.title || session.id)]),
+    ]),
+    node('div', { class: ui.contextSize, text: sessionDate(session.modified).slice(0, 10) }),
+  ]);
+
+  return node('div', {}, [button, body]);
+}
+
+function retentionTrack(sessions, days) {
+  const track = node('div', { class: ui.retentionTrack }, [node('span', { class: ui.retentionSweep })]);
+  for (const session of sessions) {
+    if (session.expiresInDays === null) continue;
+    const share = days > 0 ? Math.min(1, session.expiresInDays / days) : 1;
+    track.append(node('span', {
+      class: ui.retentionTick(session.expiresInDays <= 7),
+      style: `left: ${(share * 100).toFixed(2)}%`,
+      title: `${session.title || session.id}\nswept in ${session.expiresInDays} days`,
+    }));
+  }
+  return node('div', {}, [
+    track,
+    node('div', { class: ui.retentionScale }, [
+      node('span', { text: 'swept' }),
+      node('span', { text: `today · kept ${days} days` }),
+    ]),
+  ]);
+}
+
+async function renderSessions(container) {
+  let data = state.aux.sessions;
+  if (!data) {
+    container.append(node('p', { class: ui.note, text: 'Reading session transcripts\u2026' }));
+    try {
+      data = await api(`/api/stores/${encodeURIComponent(state.storeId)}/sessions`);
+    } catch (err) {
+      container.textContent = '';
+      return container.append(node('p', { class: ui.note, text: err.message }));
+    }
+    if (state.tab !== 'sessions') return;
+    state.aux.sessions = data;
+  }
+  container.textContent = '';
+
+  const byOrigin = new Map();
+  for (const memory of state.store.memories) {
+    if (!memory.origin?.present) continue;
+    if (!byOrigin.has(memory.origin.sessionId)) byOrigin.set(memory.origin.sessionId, []);
+    byOrigin.get(memory.origin.sessionId).push(memory);
+  }
+
+  container.append(node('p', { class: ui.noteTight, text: 'The transcripts sitting beside this store\u2019s memory. Claude Code deletes them once they pass the retention period and never touches memory/, so this is the evidence that expires while the memories stay. This tab only reads, and only the head of each file - nothing here deletes a transcript.' }));
+
+  container.append(node('div', { class: ui.meter }, [
+    node('div', { class: ui.meterTop }, [
+      node('span', { class: ui.meterValue, text: String(data.count) }),
+      node('span', { class: ui.meterUnit, text: data.count === 1 ? 'session kept' : 'sessions kept' }),
+    ]),
+    retentionTrack(data.sessions, data.days),
+    node('div', { class: ui.meterFacts }, [
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: sizeLabel(data.bytes) }), document.createTextNode(' on disk')]),
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: `${data.days} days` }), document.createTextNode(' retention (cleanupPeriodDays)')]),
+      node('span', {}, [
+        node('b', { class: ui.meterFactValue, text: data.evidenceExpiresInDays === null ? '-' : `${data.evidenceExpiresInDays} days` }),
+        document.createTextNode(' until the last proof of this path goes'),
+      ]),
+    ]),
+    node('p', { class: ui.meterNote, text: 'Sweep dates come from each file\u2019s mtime, which any copy or restore resets, so they are an estimate of when Claude Code will drop them rather than something the transcript recorded about itself.' }),
+  ]));
+
+  container.append(node('div', { class: ui.sectionLabel, text: `Sessions \u00b7 ${data.count}` }));
+  const card = node('div', { class: ui.card });
+  for (const session of data.sessions) {
+    card.append(sessionRow(session, byOrigin.get(session.id) || []));
+  }
+  container.append(card);
+}
+
 async function renderSettings(container) {
   let data = state.aux.settings;
   if (!data) {
@@ -1060,7 +1257,7 @@ function openHookEditor(row, lineIndex) {
   field.select();
 }
 
-function openMoveDialog(entry) {
+async function openMoveDialog(entry) {
   const current = indexEntryAt(entry.index);
   if (!current) return toast('MEMORY.md has changed - reload and try again', { error: true });
 
@@ -1070,40 +1267,31 @@ function openMoveDialog(entry) {
   picker.append(node('option', { value: '', text: 'Top of MEMORY.md' }));
   for (const section of sections) picker.append(node('option', { value: section, text: `Start of "${section}"` }));
 
-  const body = node('div', { class: ui.modalBody }, [
-    node('p', { class: ui.noteTight, text: `"${current.title}" sits at line ${current.index + 1}, past the cutoff at line ${cutoff ? cutoff.rawLine + 1 : '-'}, so Claude never loads it. Moving it up puts it back inside the loaded part of the index - which pushes whatever is now last past the cutoff instead.` }),
-    node('div', { class: ui.willBlock }, [
-      node('div', { class: ui.willTitle, text: 'Will move' }),
-      node('div', { class: ui.willItem('keep'), text: current.text }),
-    ]),
-    node('label', { class: ui.willTitle, text: 'Move to' }),
-    picker,
-  ]);
-
-  const modal = node('div', { class: ui.modal }, [
-    node('header', { class: ui.modalHead }, [node('h3', { class: ui.modalTitle, text: 'Move this entry above the cutoff' })]),
-    body,
-    node('footer', { class: ui.modalFoot }, [
-      node('button', { class: ui.button(), text: 'Cancel', onclick: closeModal }),
-      node('button', {
-        class: ui.button({ tone: 'primary' }),
-        text: 'Move',
-        onclick: async () => {
-          closeModal();
-          await runIndexEdit(
-            'index/move',
-            picker.value
-              ? { lineIndex: current.index, expectedText: current.text, section: picker.value }
-              : { lineIndex: current.index, expectedText: current.text, top: true },
-            () => 'Entry moved',
-          );
-        },
-      }),
-    ]),
-  ]);
-
-  const backdrop = node('div', { class: ui.modalBackdrop, onclick: (event) => { if (event.target === backdrop) closeModal(); } }, [modal]);
-  el('modal-root').append(backdrop);
+  const go = await openDialog({
+    title: 'Move this entry above the cutoff',
+    body: [
+      node('p', { class: ui.noteTight, text: `"${current.title}" sits at line ${current.index + 1}, past the cutoff at line ${cutoff ? cutoff.rawLine + 1 : '-'}, so Claude never loads it. Moving it up puts it back inside the loaded part of the index - which pushes whatever is now last past the cutoff instead.` }),
+      node('div', { class: ui.willBlock }, [
+        node('div', { class: ui.willTitle, text: 'Will move' }),
+        node('div', { class: ui.willItem('keep'), text: current.text }),
+      ]),
+      node('label', { class: ui.willTitle, text: 'Move to' }),
+      picker,
+    ],
+    actions: [
+      { label: 'Cancel' },
+      { label: 'Move', tone: 'primary', value: true },
+    ],
+  });
+  if (!go) return;
+
+  await runIndexEdit(
+    'index/move',
+    picker.value
+      ? { lineIndex: current.index, expectedText: current.text, section: picker.value }
+      : { lineIndex: current.index, expectedText: current.text, top: true },
+    () => 'Entry moved',
+  );
 }
 
 async function openAddEntryDialog(file) {
@@ -1117,8 +1305,8 @@ async function openAddEntryDialog(file) {
     return toast(err.message, { error: true });
   }
 
-  const title = node('input', { type: 'text', class: ui.pathInput, spellcheck: 'false' });
-  title.value = preview.name;
+  const titleInput = node('input', { type: 'text', class: ui.pathInput, spellcheck: 'false' });
+  titleInput.value = preview.name;
   const hook = node('textarea', { class: ui.textArea, spellcheck: 'false' });
   hook.value = preview.description;
 
@@ -1129,54 +1317,44 @@ async function openAddEntryDialog(file) {
 
   const line = node('div', { class: ui.willItem('keep') });
   const update = () => {
-    const label = title.value.trim().replace(/[[\]]/g, '') || preview.name;
+    const label = titleInput.value.trim().replace(/[[\]]/g, '') || preview.name;
     const text = hook.value.trim();
     line.textContent = text ? `- [${label}](${file}) — ${text}` : `- [${label}](${file})`;
   };
-  title.addEventListener('input', update);
+  titleInput.addEventListener('input', update);
   hook.addEventListener('input', update);
   update();
 
-  const body = node('div', { class: ui.modalBody }, [
-    node('p', { class: ui.noteTight, text: preview.hasIndex
-      ? 'MEMORY.md is loaded at the start of every session, so a memory with no bullet here is one Claude never sees. This adds one line and nothing else.'
-      : 'This project has no MEMORY.md yet. Adding this entry creates one.' }),
-    node('label', { class: ui.willTitle, text: 'Title' }),
-    title,
-    node('label', { class: ui.willTitle, text: 'Hook' }),
-    hook,
-    node('label', { class: ui.willTitle, text: 'Section' }),
-    picker,
-    node('div', { class: ui.willBlock }, [
-      node('div', { class: ui.willTitle, text: 'Will be added' }),
-      line,
-    ]),
-  ]);
-
-  const modal = node('div', { class: ui.modal }, [
-    node('header', { class: ui.modalHead }, [node('h3', { class: ui.modalTitle, text: `Add ${file} to MEMORY.md` })]),
-    body,
-    node('footer', { class: ui.modalFoot }, [
-      node('button', { class: ui.button(), text: 'Cancel', onclick: closeModal }),
-      node('button', {
-        class: ui.button({ tone: 'primary' }),
-        text: 'Add entry',
-        onclick: async () => {
-          closeModal();
-          await runIndexEdit(
-            'index/add',
-            { file, section: picker.value || null, title: title.value, hook: hook.value },
-            () => 'Added to MEMORY.md',
-          );
-        },
-      }),
-    ]),
-  ]);
+  const go = await openDialog({
+    title: `Add ${file} to MEMORY.md`,
+    body: [
+      node('p', { class: ui.noteTight, text: preview.hasIndex
+        ? 'MEMORY.md is loaded at the start of every session, so a memory with no bullet here is one Claude never sees. This adds one line and nothing else.'
+        : 'This project has no MEMORY.md yet. Adding this entry creates one.' }),
+      node('label', { class: ui.willTitle, text: 'Title' }),
+      titleInput,
+      node('label', { class: ui.willTitle, text: 'Hook' }),
+      hook,
+      node('label', { class: ui.willTitle, text: 'Section' }),
+      picker,
+      node('div', { class: ui.willBlock }, [
+        node('div', { class: ui.willTitle, text: 'Will be added' }),
+        line,
+      ]),
+    ],
+    actions: [
+      { label: 'Cancel' },
+      { label: 'Add entry', tone: 'primary', value: true },
+    ],
+    focus: titleInput,
+  });
+  if (!go) return;
 
-  const backdrop = node('div', { class: ui.modalBackdrop, onclick: (event) => { if (event.target === backdrop) closeModal(); } }, [modal]);
-  el('modal-root').append(backdrop);
-  title.focus();
-  title.select();
+  await runIndexEdit(
+    'index/add',
+    { file, section: picker.value || null, title: titleInput.value, hook: hook.value },
+    () => 'Added to MEMORY.md',
+  );
 }
 
 async function openMergeDialog(into, from) {
@@ -1193,8 +1371,8 @@ async function openMergeDialog(into, from) {
   const heading = node('input', { type: 'text', class: ui.pathInput, spellcheck: 'false' });
   heading.value = preview.heading;
 
-  const body = node('div', { class: ui.modalBody });
-  body.append(node('p', { class: ui.noteTight, text: `Everything in "${preview.fromName}" moves into "${preview.intoName}" under a new heading, and "${preview.fromName}" goes to the trash. This rewrites prose, which nothing else in this app does - the whole operation is one undo.` }));
+  const body = [];
+  body.push(node('p', { class: ui.noteTight, text: `Everything in "${preview.fromName}" moves into "${preview.intoName}" under a new heading, and "${preview.fromName}" goes to the trash. This rewrites prose, which nothing else in this app does - the whole operation is one undo.` }));
 
   const changes = node('div', { class: ui.willBlock }, [node('div', { class: ui.willTitle, text: 'Will change' })]);
   changes.append(node('div', { class: ui.willItem('keep'), text: `${preview.into}  +  ${preview.bodyLines} line(s) from ${preview.from}` }));
@@ -1204,7 +1382,7 @@ async function openMergeDialog(into, from) {
   for (const link of preview.selfLinks) {
     changes.append(node('div', { class: ui.willItem('keep'), text: `${preview.into}  [[${link}]]  →  plain text, to avoid a self-link` }));
   }
-  body.append(changes);
+  body.push(changes);
 
   const removals = node('div', { class: ui.willBlock }, [node('div', { class: ui.willTitle, text: 'Will be removed' })]);
   removals.append(node('div', { class: ui.willItem('remove'), text: `memory/${preview.from}  →  memory/.trash/` }));
@@ -1214,7 +1392,7 @@ async function openMergeDialog(into, from) {
   if (!preview.indexLines.length) {
     removals.append(node('div', { class: ui.willItem(), text: 'MEMORY.md has no index bullet for the source - nothing to remove there.' }));
   }
-  body.append(removals);
+  body.push(removals);
 
   if (preview.inlineRefs.length) {
     const kept = node('div', { class: ui.willBlock }, [
@@ -1223,45 +1401,35 @@ async function openMergeDialog(into, from) {
     for (const ref of preview.inlineRefs) {
       kept.append(node('div', { class: ui.willItem('keep'), text: `MEMORY.md line ${ref.index + 1}:  ${ref.text}` }));
     }
-    body.append(kept);
+    body.push(kept);
   }
 
-  body.append(node('label', { class: ui.willTitle, text: 'Heading for the merged section' }), heading);
+  body.push(node('label', { class: ui.willTitle, text: 'Heading for the merged section' }), heading);
 
-  const modal = node('div', { class: ui.modal }, [
-    node('header', { class: ui.modalHead }, [
-      node('h3', { class: ui.modalTitle, text: `Merge "${preview.fromName}" into "${preview.intoName}"?` }),
-    ]),
+  const go = await openDialog({
+    title: `Merge "${preview.fromName}" into "${preview.intoName}"?`,
     body,
-    node('footer', { class: ui.modalFoot }, [
-      node('button', { class: ui.button(), text: 'Cancel', onclick: closeModal }),
-      node('button', {
-        class: ui.button({ tone: 'primary' }),
-        text: 'Merge',
-        onclick: async () => {
-          closeModal();
-          try {
-            const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/merge`, {
-              method: 'POST',
-              body: JSON.stringify({ into, from, heading: heading.value }),
-            });
-            if (state.selected === from) state.selected = into;
-            await openStore(state.storeId, { keepTab: true });
-            toast(`Merged into ${preview.intoName}`, {
-              action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) },
-            });
-          } catch (err) {
-            toast(err.message, { error: true });
-          }
-        },
-      }),
-    ]),
-  ]);
+    actions: [
+      { label: 'Cancel' },
+      { label: 'Merge', tone: 'primary', value: true },
+    ],
+    focus: heading,
+  });
+  if (!go) return;
 
-  const backdrop = node('div', { class: ui.modalBackdrop, onclick: (event) => { if (event.target === backdrop) closeModal(); } }, [modal]);
-  el('modal-root').append(backdrop);
-  heading.focus();
-  heading.select();
+  try {
+    const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/merge`, {
+      method: 'POST',
+      body: JSON.stringify({ into, from, heading: heading.value }),
+    });
+    if (state.selected === from) state.selected = into;
+    await openStore(state.storeId, { keepTab: true });
+    toast(`Merged into ${preview.intoName}`, {
+      action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) },
+    });
+  } catch (err) {
+    toast(err.message, { error: true });
+  }
 }
 
 async function restoreFromTrash(id) {
@@ -1312,10 +1480,6 @@ function renderTrash(container) {
   }
 }
 
-function closeModal() {
-  el('modal-root').textContent = '';
-}
-
 async function openDeleteDialog(file) {
   let preview;
   try {
@@ -1327,7 +1491,7 @@ async function openDeleteDialog(file) {
     return toast(err.message, { error: true });
   }
 
-  const body = node('div', { class: ui.modalBody });
+  const body = [];
 
   const removals = node('div', { class: ui.willBlock }, [node('div', { class: ui.willTitle, text: 'Will be removed' })]);
   removals.append(node('div', { class: ui.willItem('remove'), text: `memory/${preview.file}  →  memory/.trash/` }));
@@ -1337,14 +1501,14 @@ async function openDeleteDialog(file) {
   if (!preview.indexLines.length && preview.hasIndex) {
     removals.append(node('div', { class: ui.willItem(), text: 'MEMORY.md has no index bullet for this file - nothing to unlink there.' }));
   }
-  body.append(removals);
+  body.push(removals);
 
   if (preview.inlineRefs.length) {
     const kept = node('div', { class: ui.willBlock }, [node('div', { class: ui.willTitle, text: 'Left untouched - mentioned inside prose, so you may want to fix these by hand' })]);
     for (const ref of preview.inlineRefs) {
       kept.append(node('div', { class: ui.willItem('keep'), text: `MEMORY.md line ${ref.index + 1}:  ${ref.text}` }));
     }
-    body.append(kept);
+    body.push(kept);
   }
 
   const cascade = new Set();
@@ -1380,7 +1544,7 @@ async function openDeleteDialog(file) {
     }
     block.append(list);
     block.append(node('p', { class: ui.noteTight, text: 'Tick any you also want deleted - they go to the trash together and restore as one step.' }));
-    body.append(block);
+    body.push(block);
 
     selectAll.onclick = (event) => {
       event.preventDefault();
@@ -1392,52 +1556,39 @@ async function openDeleteDialog(file) {
     };
   }
 
-  body.append(node('p', { class: ui.noteTight, text: 'The file moves to memory/.trash/ with a restore record, so this can be undone.' }));
-
-  const confirmButton = node('button', {
-    class: ui.button({ tone: 'danger' }),
-    text: 'Delete',
-    onclick: async () => {
-      closeModal();
-      try {
-        const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/delete`, {
-          method: 'POST',
-          body: JSON.stringify({ file, alsoDelete: [...cascade] }),
-        });
-        if (state.selected === file || cascade.has(state.selected)) state.selected = null;
-        await openStore(state.storeId, { keepTab: true });
-        const count = result.record.files.length;
-        toast(count > 1 ? `Deleted ${count} memories` : `Deleted "${result.record.label || file}"`, {
-          action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) },
-        });
-      } catch (err) {
-        toast(err.message, { error: true });
-      }
-    },
-  });
+  body.push(node('p', { class: ui.noteTight, text: 'The file moves to memory/.trash/ with a restore record, so this can be undone.' }));
 
-  const modal = node('div', { class: ui.modal }, [
-    node('header', { class: ui.modalHead }, [
-      node('h3', { class: ui.modalTitle, text: `Delete "${preview.name || preview.file}"?` }),
-      node('p', { class: ui.note, text: preview.description || '' }),
-    ]),
+  const remove = { label: 'Delete', tone: 'danger', value: true };
+  const answer = openDialog({
+    title: `Delete "${preview.name || preview.file}"?`,
+    subtitle: preview.description || '',
     body,
-    node('footer', { class: ui.modalFoot }, [
-      node('button', { class: ui.button(), text: 'Cancel', onclick: closeModal }),
-      confirmButton,
-    ]),
-  ]);
-
-  const backdrop = node('div', { class: ui.modalBackdrop, onclick: (event) => { if (event.target === backdrop) closeModal(); } }, [modal]);
-  el('modal-root').append(backdrop);
+    actions: [{ label: 'Cancel' }, remove],
+  });
   updateButton();
+  if (!await answer) return;
+
+  try {
+    const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/delete`, {
+      method: 'POST',
+      body: JSON.stringify({ file, alsoDelete: [...cascade] }),
+    });
+    if (state.selected === file || cascade.has(state.selected)) state.selected = null;
+    await openStore(state.storeId, { keepTab: true });
+    const count = result.record.files.length;
+    toast(count > 1 ? `Deleted ${count} memories` : `Deleted "${result.record.label || file}"`, {
+      action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) },
+    });
+  } catch (err) {
+    toast(err.message, { error: true });
+  }
 
   function updateButton() {
-    confirmButton.textContent = cascade.size ? `Delete ${cascade.size + 1} memories` : 'Delete';
+    remove.el.textContent = cascade.size ? `Delete ${cascade.size + 1} memories` : 'Delete';
   }
 }
 
-function openRememberPathDialog() {
+async function openRememberPathDialog() {
   const store = state.store;
   const input = node('input', {
     type: 'text',
@@ -1447,44 +1598,42 @@ function openRememberPathDialog() {
     spellcheck: 'false',
   });
 
-  const body = node('div', { class: ui.modalBody }, [
-    node('p', { class: ui.note, text: `The folder on disk is "${store.slug}", and its name is a lossy encoding of a path. No session transcript remains to recover the real one from, so tell it once and it will be used from now on.` }),
-    input,
-    node('p', { class: ui.noteTight, text: 'Saved to ~/.claude-memory-admin/paths.json. That file records slugs and folder paths only, never memory content, and is the one thing this app writes outside a memory/ directory.' }),
-  ]);
-
-  const modal = node('div', { class: ui.modal }, [
-    node('header', { class: ui.modalHead }, [node('h3', { class: ui.modalTitle, text: 'Remember this project\u2019s path' })]),
-    body,
-    node('footer', { class: ui.modalFoot }, [
-      node('button', { class: ui.button(), text: 'Cancel', onclick: closeModal }),
-      node('button', {
-        class: ui.button({ tone: 'primary' }),
-        text: 'Remember',
-        onclick: async () => {
+  const remembered = await openDialog({
+    title: 'Remember this project\u2019s path',
+    body: [
+      node('p', { class: ui.note, text: `The folder on disk is "${store.slug}", and its name is a lossy encoding of a path. No session transcript remains to recover the real one from, so tell it once and it will be used from now on.` }),
+      input,
+      node('p', { class: ui.noteTight, text: 'Saved to ~/.claude-memory-admin/paths.json. That file records slugs and folder paths only, never memory content, and is the one thing this app writes outside a memory/ directory.' }),
+    ],
+    actions: [
+      { label: 'Cancel' },
+      {
+        label: 'Remember',
+        tone: 'primary',
+        value: true,
+        guard: async () => {
           const value = input.value.trim();
-          if (!value) return;
+          if (!value) return false;
           try {
             await api(`/api/stores/${encodeURIComponent(state.storeId)}/path/remember`, {
               method: 'POST',
               body: JSON.stringify({ path: value }),
             });
           } catch (err) {
-            return toast(err.message, { error: true });
+            toast(err.message, { error: true });
+            return false;
           }
-          closeModal();
-          await reloadStores();
-          await openStore(state.storeId, { keepTab: true });
-          toast(`Remembered ${value}`);
+          return true;
         },
-      }),
-    ]),
-  ]);
+      },
+    ],
+    focus: input,
+  });
+  if (!remembered) return;
 
-  const backdrop = node('div', { class: ui.modalBackdrop, onclick: (event) => { if (event.target === backdrop) closeModal(); } }, [modal]);
-  el('modal-root').append(backdrop);
-  input.focus();
-  input.select();
+  await reloadStores();
+  await openStore(state.storeId, { keepTab: true });
+  toast(`Remembered ${input.value.trim()}`);
 }
 
 async function forgetProjectPath() {
@@ -1510,7 +1659,7 @@ async function openStoreDeleteDialog() {
     return toast('This store has no memory to delete');
   }
 
-  const body = node('div', { class: ui.modalBody });
+  const body = [];
   const removals = node('div', { class: ui.willBlock }, [node('div', { class: ui.willTitle, text: 'Will be removed' })]);
   if (preview.hasIndex) {
     removals.append(node('div', { class: ui.willItem('remove'), text: `MEMORY.md  (${preview.indexLines} lines)  →  memory/.trash/` }));
@@ -1518,51 +1667,42 @@ async function openStoreDeleteDialog() {
   for (const entry of preview.files) {
     removals.append(node('div', { class: ui.willItem('remove'), text: `${entry.file}  →  memory/.trash/` }));
   }
-  body.append(removals);
+  body.push(removals);
 
-  body.append(node('div', { class: ui.willBlock }, [
+  body.push(node('div', { class: ui.willBlock }, [
     node('div', { class: ui.willTitle, text: 'Will be kept' }),
     node('div', { class: ui.willItem('keep'), text: state.store.kind === 'auto'
       ? 'Session transcripts (*.jsonl) and the project folder itself'
       : 'The agent-memory folder itself, and every other agent\u2019s memory' }),
   ]));
 
-  body.append(node('p', { class: ui.noteTight, text: 'Everything moves to .trash/ inside the store as one restore point, so it can be put back in a single step from the Trash tab.' }));
+  body.push(node('p', { class: ui.noteTight, text: 'Everything moves to .trash/ inside the store as one restore point, so it can be put back in a single step from the Trash tab.' }));
 
   if (state.store.kind === 'agent-project') {
-    body.append(node('p', { class: ui.subWarn, text: 'This store is checked into the repository. Deleting from it changes tracked files, and will show up in git status.' }));
+    body.push(node('p', { class: ui.subWarn, text: 'This store is checked into the repository. Deleting from it changes tracked files, and will show up in git status.' }));
   }
 
-  const modal = node('div', { class: ui.modal }, [
-    node('header', { class: ui.modalHead }, [
-      node('h3', { class: ui.modalTitle, text: `Delete all memory for ${state.store.label}?` }),
-      node('p', { class: ui.note, text: `${preview.files.length} memories${preview.hasIndex ? ' + MEMORY.md' : ''}` }),
-    ]),
+  const go = await openDialog({
+    title: `Delete all memory for ${state.store.label}?`,
+    subtitle: `${preview.files.length} memories${preview.hasIndex ? ' + MEMORY.md' : ''}`,
     body,
-    node('footer', { class: ui.modalFoot }, [
-      node('button', { class: ui.button(), text: 'Cancel', onclick: closeModal }),
-      node('button', {
-        class: ui.button({ tone: 'danger' }),
-        text: `Delete ${preview.files.length + (preview.hasIndex ? 1 : 0)} files`,
-        onclick: async () => {
-          closeModal();
-          try {
-            const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/project/delete`, { method: 'POST' });
-            state.selected = null;
-            await openStore(state.storeId, { keepTab: true });
-            toast(`Cleared ${state.store.label}`, {
-              action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) },
-            });
-          } catch (err) {
-            toast(err.message, { error: true });
-          }
-        },
-      }),
-    ]),
-  ]);
+    actions: [
+      { label: 'Cancel' },
+      { label: `Delete ${preview.files.length + (preview.hasIndex ? 1 : 0)} files`, tone: 'danger', value: true },
+    ],
+  });
+  if (!go) return;
 
-  const backdrop = node('div', { class: ui.modalBackdrop, onclick: (event) => { if (event.target === backdrop) closeModal(); } }, [modal]);
-  el('modal-root').append(backdrop);
+  try {
+    const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/project/delete`, { method: 'POST' });
+    state.selected = null;
+    await openStore(state.storeId, { keepTab: true });
+    toast(`Cleared ${state.store.label}`, {
+      action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) },
+    });
+  } catch (err) {
+    toast(err.message, { error: true });
+  }
 }
 
 function highlight(text, terms) {
@@ -1772,12 +1912,12 @@ async function openBulkDeleteDialog(files) {
   if (!files.length) return;
   const memories = files.map((file) => state.store.memories.find((m) => m.file === file)).filter(Boolean);
 
-  const body = node('div', { class: ui.modalBody });
+  const body = [];
   const removals = node('div', { class: ui.willBlock }, [node('div', { class: ui.willTitle, text: `${memories.length} memories will be trashed` })]);
   for (const memory of memories) {
     removals.append(node('div', { class: ui.willItem('remove'), text: `${memory.file}${memory.entry ? `  ·  MEMORY.md line ${memory.entry.index + 1}` : '  ·  not in the index'}` }));
   }
-  body.append(removals);
+  body.push(removals);
 
   const doomed = new Set(files);
   const breaking = [];
@@ -1789,41 +1929,35 @@ async function openBulkDeleteDialog(files) {
   if (breaking.length) {
     const block = node('div', { class: ui.willBlock }, [node('div', { class: ui.willTitle, text: `${breaking.length} link(s) from memories you are keeping will break` })]);
     for (const link of breaking) block.append(node('div', { class: ui.willItem('keep'), text: `${link.from}  →  [[${link.target}]]` }));
-    body.append(block);
+    body.push(block);
   }
 
-  body.append(node('p', { class: ui.noteTight, text: 'All of them go to memory/.trash/ as one restore point.' }));
+  body.push(node('p', { class: ui.noteTight, text: 'All of them go to memory/.trash/ as one restore point.' }));
 
-  const modal = node('div', { class: ui.modal }, [
-    node('header', { class: ui.modalHead }, [node('h3', { class: ui.modalTitle, text: `Delete ${memories.length} memories?` })]),
+  const go = await openDialog({
+    title: `Delete ${memories.length} memories?`,
     body,
-    node('footer', { class: ui.modalFoot }, [
-      node('button', { class: ui.button(), text: 'Cancel', onclick: closeModal }),
-      node('button', {
-        class: ui.button({ tone: 'danger' }),
-        text: `Delete ${memories.length}`,
-        onclick: async () => {
-          closeModal();
-          try {
-            const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/delete-many`, {
-              method: 'POST',
-              body: JSON.stringify({ files, label: `${memories.length} pruned memories` }),
-            });
-            state.pruneSelection.clear();
-            if (doomed.has(state.selected)) state.selected = null;
-            await openStore(state.storeId, { keepTab: true });
-            toast(`Deleted ${memories.length} memories`, {
-              action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) },
-            });
-          } catch (err) {
-            toast(err.message, { error: true });
-          }
-        },
-      }),
-    ]),
-  ]);
-  const backdrop = node('div', { class: ui.modalBackdrop, onclick: (event) => { if (event.target === backdrop) closeModal(); } }, [modal]);
-  el('modal-root').append(backdrop);
+    actions: [
+      { label: 'Cancel' },
+      { label: `Delete ${memories.length}`, tone: 'danger', value: true },
+    ],
+  });
+  if (!go) return;
+
+  try {
+    const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/delete-many`, {
+      method: 'POST',
+      body: JSON.stringify({ files, label: `${memories.length} pruned memories` }),
+    });
+    state.pruneSelection.clear();
+    if (doomed.has(state.selected)) state.selected = null;
+    await openStore(state.storeId, { keepTab: true });
+    toast(`Deleted ${memories.length} memories`, {
+      action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) },
+    });
+  } catch (err) {
+    toast(err.message, { error: true });
+  }
 }
 
 let searchTimer = null;
@@ -1935,6 +2069,7 @@ function renderTab() {
   if (state.tab === 'memories') renderMemories(container);
   else if (state.tab === 'prune') renderPrune(container);
   else if (state.tab === 'context') renderContext(container);
+  else if (state.tab === 'sessions') renderSessions(container);
   else if (state.tab === 'index') renderIndex(container);
   else if (state.tab === 'health') renderHealth(container);
   else if (state.tab === 'settings') renderSettings(container);
@@ -1987,6 +2122,49 @@ async function sweepIssues() {
   renderStores();
 }
 
+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;
+}
+
+async function loadSessionsForProvenance() {
+  if (state.aux.sessions || !state.store?.sessions?.count) return;
+  const id = state.storeId;
+  try {
+    const data = await api(`/api/stores/${encodeURIComponent(id)}/sessions`);
+    if (state.storeId !== id) return;
+    state.aux.sessions = data;
+    renderTab();
+  } catch {
+    return;
+  }
+}
+
 function renderStoreHeader() {
   const store = state.store;
   el('project-title').textContent = store.label;
@@ -2029,6 +2207,18 @@ function renderStoreHeader() {
     ]));
   }
 
+  const evidence = store.sessions?.evidenceExpiresInDays;
+  if (!store.sessions?.remembered
+      && (store.resolvedBy === 'transcript' || store.resolvedBy === 'repo-root')
+      && typeof evidence === 'number' && evidence <= 14) {
+    sub.append(node('span', { class: ui.subWarn }, [
+      document.createTextNode(evidence === 0
+        ? 'the last transcript proving this path is due to be swept - the store keeps its memories and loses its name  '
+        : `the last transcript proving this path is swept in ${evidence} days, and nothing else records it  `),
+      node('button', { class: ui.linkButton, text: 'Remember path\u2026', onclick: openRememberPathDialog }),
+    ]));
+  }
+
   const auto = store.autoMemory;
   if (auto && auto.known && !auto.enabled) {
     sub.append(node('span', { class: ui.subWarn, text: auto.scope === 'env'
@@ -2040,7 +2230,7 @@ function renderStoreHeader() {
 async function openStore(id, { keepTab = false } = {}) {
   if (id !== state.storeId) state.pruneSelection.clear();
   state.storeId = id;
-  state.aux = { instructions: null, settings: null };
+  state.aux = { instructions: null, settings: null, sessions: null };
   state.pathCheck = null;
   if (!keepTab) {
     const opening = state.stores.find((store) => store.id === id);
@@ -2151,6 +2341,7 @@ async function init() {
     paintTheme();
   });
   document.addEventListener('keydown', (event) => {
+    if (isDialogOpen()) return;
     const typing = /^(INPUT|TEXTAREA|SELECT)$/.test(event.target.tagName);
     if (event.key === '/' && !typing) {
       event.preventDefault();
@@ -2165,8 +2356,7 @@ async function init() {
       return;
     }
     if (event.key === 'Escape') {
-      if (el('modal-root').firstChild) closeModal();
-      else if (state.search !== null) clearSearch();
+      if (state.search !== null) clearSearch();
       else if (!state.collapsed) setCollapsed(true);
     }
   });