claude-memory-admin 1.3.0 → 1.5.0

package/public/app.mjs

@@ -17,8 +17,14 @@ const state = {
   pruneSort: 'oldest',
   pruneSelection: new Set(),
   indexView: localStorage.getItem('memoryIndexView') === 'source' ? 'source' : 'rendered',
+  aux: { instructions: null, settings: null, sessions: null },
+  pathCheck: null,
 };
 
+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) {
@@ -88,16 +94,25 @@ function storeSubtitle(store) {
   return `${scope} · ${store.sublabel}`;
 }
 
+function issueTitle(store) {
+  const parts = [];
+  if (store.issueCount) parts.push(`${store.issueCount} in Health`);
+  if (store.context) parts.push(`${store.context} in Context`);
+  if (store.settings) parts.push(`${store.settings} in Settings`);
+  if (store.kind === 'auto' && store.resolvedBy === 'unresolved') {
+    parts.push('Real path could not be resolved - showing the raw folder name');
+  }
+  return parts.length ? `${store.dir}\n${parts.join(', ')}` : store.dir;
+}
+
 function storeButton(store) {
   const global = store.kind === 'global';
-  const health = global ? 'ok' : store.memoryCount === 0 ? 'none' : 'ok';
+  const health = !global && !store.hasMemoryDir ? 'none' : store.severity || 'ok';
   const off = store.autoMemory && store.autoMemory.known && !store.autoMemory.enabled;
   return node('button', {
     class: ui.storeItem({ active: store.id === state.storeId, empty: !global && !store.hasMemoryDir }),
     onclick: () => openStore(store.id),
-    title: store.kind === 'auto' && store.resolvedBy === 'unresolved'
-      ? 'Real path could not be resolved - showing the raw folder name'
-      : store.dir,
+    title: issueTitle(store),
   }, [
     node('span', { class: ui.storeRow }, [
       node('span', { class: ui.dot(health) }),
@@ -138,6 +153,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' },
@@ -154,18 +170,38 @@ 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);
-    if (tab.id === 'health' && state.store.health.issueCount) badge = String(state.store.health.issueCount);
     if (tab.id === 'trash' && state.store.trash.length) badge = String(state.store.trash.length);
-    if (tab.id === 'prune' && state.store.stats.index.overTarget) badge = '!';
+    if (tab.id === 'health' && state.store.health.issueCount) {
+      badge = String(state.store.health.issueCount);
+      tone = state.store.health.severity;
+    }
+    if (tab.id === 'prune' && state.store.stats.index.level !== 'ok') {
+      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);
+    }
+    if (tab.id === 'settings' && state.aux.settings?.problems.length) {
+      badge = String(state.aux.settings.problems.length);
+      tone = worstSeverity(state.aux.settings.problems);
+    }
 
     container.append(node('button', {
       class: ui.tab(state.tab === tab.id),
       onclick: () => { state.tab = tab.id; renderTabs(); renderTab(); },
     }, [
       document.createTextNode(tab.label),
-      badge ? node('span', { class: ui.tabBadge(tab.id === 'health' || tab.id === 'prune'), text: badge }) : null,
+      badge ? node('span', { class: ui.tabBadge(tone), text: badge }) : null,
     ]));
   }
 }
@@ -248,13 +284,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);
@@ -395,18 +434,22 @@ const CONTEXT_PROBLEMS = {
   'long-claude-md': (p) => [`${p.lines} lines, over the 200-line guidance`, `${p.file} - long files cost context every session and reduce adherence`],
   'agents-md-not-imported': (p) => ['AGENTS.md is not loaded', `${p.file} exists, but Claude Code reads CLAUDE.md. Import it with @AGENTS.md, or symlink it.`],
   'unreferenced-user-file': (p) => ['Nothing in the chain reaches this file', `${p.file} sits next to CLAUDE.md and loads nothing. Import it with @${p.file.split('/').pop()}, or delete it.`],
+  'duplicate-load': (p) => [`Loaded ${p.count} times: ${p.file}`, `reached from ${[...new Set(p.via)].join(' and ')} - every copy is read into context, so you pay ~${p.wastedTokens.toLocaleString()} extra tokens a session`],
+  'empty-instruction-file': (p) => ['Loads, but says nothing', `${p.file} is empty apart from its frontmatter, so it costs a read and contributes no instruction`],
 };
 
 async function renderContext(container) {
-  container.append(node('p', { class: ui.note, text: 'Reading instruction files…' }));
-  let data;
-  try {
-    data = await api(`/api/stores/${encodeURIComponent(state.storeId)}/instructions`);
-  } catch (err) {
-    container.textContent = '';
-    return container.append(node('p', { class: ui.note, text: err.message }));
+  let data = state.aux.instructions;
+  if (!data) {
+    container.append(node('p', { class: ui.note, text: 'Reading instruction files…' }));
+    try {
+      data = await api(`/api/stores/${encodeURIComponent(state.storeId)}/instructions`);
+    } catch (err) {
+      container.textContent = '';
+      return container.append(node('p', { class: ui.note, text: err.message }));
+    }
+    if (state.tab !== 'context') return;
   }
-  if (state.tab !== 'context') return;
   container.textContent = '';
 
   const global = state.store.kind === 'global';
@@ -434,8 +477,7 @@ async function renderContext(container) {
     for (const problem of data.problems) {
       const describe = CONTEXT_PROBLEMS[problem.kind];
       const [title, detail] = describe ? describe(problem) : [problem.kind, problem.file || ''];
-      const bad = problem.kind === 'missing' || problem.kind === 'invalid-glob' || problem.kind === 'glob-budget';
-      container.append(node('div', { class: ui.issue(bad) }, [
+      container.append(node('div', { class: ui.issue(problem.severity === 'bad') }, [
         node('div', { class: ui.issueBody }, [
           node('div', { class: ui.issueTitle, text: title }),
           node('div', { class: ui.issueDetail, text: detail }),
@@ -506,18 +548,135 @@ function issue(title, detail, { bad = false, action, secondary } = {}) {
   ]);
 }
 
+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') renderTab();
+}
+
+function startPathCheck({ remember = true } = {}) {
+  if (remember) localStorage.setItem(pathCheckKey(), '1');
+  state.pathCheck = { running: true };
+  fetchPathCheck();
+}
+
+function runPathCheck() {
+  startPathCheck();
+  renderTab();
+}
+
+function stopPathCheck() {
+  localStorage.removeItem(pathCheckKey());
+  state.pathCheck = null;
+  renderTab();
+}
+
+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));
+}
+
 function renderHealth(container) {
   const { health, memories } = state.store;
+
   if (!health.issues.length) {
     container.append(node('div', { class: ui.card }, [
       node('p', { class: ui.okLine, text: '\u2713 No consistency problems found.' }),
       node('p', { class: ui.noteTight, text: 'Every memory file is referenced by MEMORY.md, every pointer resolves, and every [[wikilink]] finds its target.' }),
     ]));
-    return;
+  } else {
+    for (const item of health.issues) container.append(renderIssue(item, memories));
   }
 
-  for (const item of health.issues) {
-    container.append(renderIssue(item, memories));
+  container.append(node('div', { class: ui.sectionLabel, text: 'Beyond the memory directory' }));
+  renderPathCheck(container);
+}
+
+function goToTab(id) {
+  state.tab = id;
+  renderTabs();
+  renderTab();
+}
+
+async function removeIndexLine(lineIndex, expectedText, done) {
+  if (!confirm(`Remove line ${lineIndex + 1} from MEMORY.md?\n\n${expectedText}`)) 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 });
   }
 }
 
@@ -533,19 +692,7 @@ function renderIssue(item, memories) {
         bad,
         action: {
           label: 'Remove pointer',
-          run: async () => {
-            if (!confirm(`Remove line ${entry.index + 1} from MEMORY.md?\n\n${entry.text}`)) return;
-            try {
-              await api(`/api/stores/${encodeURIComponent(state.storeId)}/index-line/delete`, {
-                method: 'POST',
-                body: JSON.stringify({ lineIndex: entry.index, expectedText: entry.text }),
-              });
-              toast('Pointer removed');
-              await openStore(state.storeId, { keepTab: true });
-            } catch (err) {
-              toast(err.message, { error: true });
-            }
-          },
+          run: () => removeIndexLine(entry.index, entry.text, 'Pointer removed'),
         },
       },
     );
@@ -627,16 +774,130 @@ function renderIssue(item, memories) {
     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: 'Open Prune',
-          run: () => { state.tab = 'prune'; renderTabs(); renderTab(); },
+          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));
 }
 
@@ -661,16 +922,169 @@ 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) {
-  container.append(node('p', { class: ui.note, text: 'Reading settings files…' }));
-  let data;
-  try {
-    data = await api(`/api/stores/${encodeURIComponent(state.storeId)}/settings`);
-  } catch (err) {
-    container.textContent = '';
-    return container.append(node('p', { class: ui.note, text: err.message }));
+  let data = state.aux.settings;
+  if (!data) {
+    container.append(node('p', { class: ui.note, text: 'Reading settings files…' }));
+    try {
+      data = await api(`/api/stores/${encodeURIComponent(state.storeId)}/settings`);
+    } catch (err) {
+      container.textContent = '';
+      return container.append(node('p', { class: ui.note, text: err.message }));
+    }
+    if (state.tab !== 'settings') return;
   }
-  if (state.tab !== 'settings') return;
   container.textContent = '';
 
   container.append(node('p', { class: ui.noteTight, text: 'What Claude Code would read for this store, in precedence order: managed policy first, then project and local settings, then your user file. This tab is read-only — it reports what is configured, it never changes it.' }));
@@ -684,7 +1098,7 @@ async function renderSettings(container) {
     for (const problem of data.problems) {
       const describe = SETTINGS_PROBLEMS[problem.kind];
       const [title, detail] = describe ? describe(problem) : [problem.kind, problem.file || ''];
-      container.append(node('div', { class: ui.issue(true) }, [
+      container.append(node('div', { class: ui.issue(problem.severity === 'bad') }, [
         node('div', { class: ui.issueBody }, [
           node('div', { class: ui.issueTitle, text: title }),
           node('div', { class: ui.issueDetail, text: detail }),
@@ -1707,6 +2121,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);
@@ -1743,9 +2158,65 @@ async function reloadStores() {
   const data = await api('/api/stores');
   state.stores = data.stores;
   renderStores();
+  sweepIssues();
   return data;
 }
 
+async function sweepIssues() {
+  let data;
+  try {
+    data = await api('/api/stores/issues');
+  } catch {
+    return;
+  }
+  const bySummary = new Map(data.stores.map((summary) => [summary.id, summary]));
+  for (const store of state.stores) Object.assign(store, bySummary.get(store.id) || {});
+  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;
@@ -1788,6 +2259,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'
@@ -1799,6 +2282,8 @@ function renderStoreHeader() {
 async function openStore(id, { keepTab = false } = {}) {
   if (id !== state.storeId) state.pruneSelection.clear();
   state.storeId = id;
+  state.aux = { instructions: null, settings: null, sessions: null };
+  state.pathCheck = null;
   if (!keepTab) {
     const opening = state.stores.find((store) => store.id === id);
     state.tab = opening && opening.kind === 'global' ? 'context' : 'memories';
@@ -1819,12 +2304,34 @@ async function openStore(id, { keepTab = false } = {}) {
   renderStoreHeader();
 
   const listed = state.stores.find((store) => store.id === id);
-  if (listed) listed.memoryCount = state.store.memories.length;
+  if (listed) {
+    listed.memoryCount = state.store.memories.length;
+    listed.issueCount = state.store.health.issueCount;
+    listed.severity = worst(state.store.health.severity, listed.context ? 'warn' : 'ok', listed.settings ? 'warn' : 'ok');
+  }
   renderStores();
 
   renderView();
   renderTabs();
   renderTab();
+
+  Promise.all([
+    api(`/api/stores/${encodeURIComponent(id)}/instructions`).catch(() => null),
+    api(`/api/stores/${encodeURIComponent(id)}/settings`).catch(() => null),
+  ]).then(([instructions, settings]) => {
+    if (state.storeId !== id) return;
+    state.aux = { instructions, settings };
+    renderTabs();
+    if (!listed) return;
+    listed.context = instructions ? instructions.problems.length : 0;
+    listed.settings = settings ? settings.problems.length : 0;
+    listed.severity = worst(
+      state.store.health.severity,
+      instructions ? worstSeverity(instructions.problems) : 'ok',
+      settings ? worstSeverity(settings.problems) : 'ok',
+    );
+    renderStores();
+  });
 }
 
 function applyCollapsed() {