claude-memory-admin 1.5.1 → 1.6.0

package/public/views/search.mjs

@@ -0,0 +1,100 @@
+import * as ui from '/ui.mjs';
+import { el, node } from '/dom.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { paint } from '/bus.mjs';
+import { highlight, goTo } from '/parts.mjs';
+import { openStore } from '/store.mjs';
+
+let searchTimer = null;
+
+export function scheduleSearch(value) {
+  state.query = value;
+  clearTimeout(searchTimer);
+  if (!value.trim()) {
+    state.search = null;
+    paint('view');
+    return;
+  }
+  searchTimer = setTimeout(runSearch, 180);
+}
+
+async function runSearch() {
+  const query = state.query.trim();
+  if (!query) return;
+  try {
+    state.search = await api(`/api/search?q=${encodeURIComponent(query)}`);
+  } catch (err) {
+    return toast(err.message, { error: true });
+  }
+  paint('view');
+}
+
+export function renderSearch() {
+  const data = state.search;
+  const host = el('search-results');
+  host.textContent = '';
+  el('search-title').textContent = data.total
+    ? `${data.total} result${data.total === 1 ? '' : 's'} for "${state.query.trim()}"`
+    : `No results for "${state.query.trim()}"`;
+
+  if (!data.total && !data.stores.length) {
+    host.append(node('p', { class: ui.note, text: 'Nothing matched. Every word has to appear somewhere in a memory, so try fewer words.' }));
+    return;
+  }
+
+  for (const group of data.stores) {
+    const block = node('div', { class: ui.resultGroup });
+    block.append(node('div', { class: ui.sectionLabel, text: group.sublabel
+      ? `${group.label} · ${group.sublabel} · ${group.results.length}`
+      : `${group.label} · ${group.results.length}` }));
+
+    for (const result of group.results) {
+      const button = node('button', {
+        class: ui.result,
+        onclick: () => openFromSearch(group.id, result.file, 'list'),
+      });
+      const top = node('div', { class: ui.resultTop });
+      const name = node('span', { class: ui.resultName });
+      name.append(highlight(result.name, data.terms));
+      top.append(name, node('span', { class: ui.typeBadge(result.type), text: result.type }));
+      if (result.status !== 'indexed') top.append(node('span', { class: ui.badge('warn'), text: result.status }));
+      button.append(top);
+
+      if (result.snippet) {
+        const snippet = node('div', { class: ui.resultSnippet });
+        snippet.append(highlight(result.snippet.text, data.terms));
+        button.append(snippet);
+      }
+      button.append(node('div', { class: ui.resultWhere, text: `${result.file} · matched in ${result.fields.join(', ')}` }));
+      block.append(button);
+    }
+
+    for (const hit of group.indexHits) {
+      const button = node('button', {
+        class: ui.result,
+        onclick: () => openFromSearch(group.id, hit.file, 'index'),
+      });
+      button.append(node('div', { class: ui.resultWhere, text: `MEMORY.md line ${hit.index + 1}` }));
+      const line = node('div', { class: ui.resultSnippet });
+      line.append(highlight(hit.text.trim(), data.terms));
+      button.append(line);
+      block.append(button);
+    }
+    host.append(block);
+  }
+}
+
+async function openFromSearch(id, file, segment = 'list') {
+  clearSearch();
+  if (id !== state.storeId) await openStore(id);
+  if (file) state.selected = file;
+  goTo('memory', segment);
+}
+
+export function clearSearch() {
+  state.query = '';
+  state.search = null;
+  el('search').value = '';
+  paint('view');
+}

package/public/views/segments.mjs

@@ -0,0 +1,37 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { state } from '/state.mjs';
+import { goTo } from '/parts.mjs';
+import { segmentsFor } from '/views/header.mjs';
+
+export function segmentBar(tab) {
+  const segments = segmentsFor(tab);
+  if (segments.length < 2) return null;
+  return node('div', { class: ui.segmentBar }, [
+    node('div', { class: ui.segmentGroup, role: 'tablist' }, segments.map((seg) => node('button', {
+      class: ui.segment(state.segment[tab] === seg.id),
+      role: 'tab',
+      'aria-selected': String(state.segment[tab] === seg.id),
+      onclick: () => goTo(tab, seg.id),
+    }, [
+      document.createTextNode(seg.label),
+      seg.badge ? node('span', { class: ui.tabBadge(seg.tone) }, [document.createTextNode(seg.badge)]) : null,
+    ]))),
+  ]);
+}
+
+export function activeSegment(tab) {
+  const segments = segmentsFor(tab);
+  if (!segments.length) return null;
+  const current = state.segment[tab];
+  return segments.some((seg) => seg.id === current) ? current : segments[0].id;
+}
+
+export function renderSegmented(container, tab, views) {
+  const bar = segmentBar(tab);
+  if (bar) container.append(bar);
+  const host = node('div');
+  container.append(host);
+  const segment = activeSegment(tab);
+  return views[segment] ? views[segment](host) : null;
+}

package/public/views/sessions.mjs

@@ -0,0 +1,235 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { api } from '/api.mjs';
+import { state } from '/state.mjs';
+import { sizeLabel, sessionDate, isAt } from '/parts.mjs';
+import { selectMemory } from '/store.mjs';
+import { paint } from '/bus.mjs';
+
+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',
+};
+
+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` }),
+    ]),
+  ]);
+}
+
+const WEEKDAYS = ['Mon', '', 'Wed', '', 'Fri', '', ''];
+const LEVELS = [0, 1, 2, 3, 4];
+
+function dayLabel(cell) {
+  if (cell.count === 0) return `no sessions on ${cell.date}`;
+  return cell.count === 1 ? `1 session on ${cell.date}` : `${cell.count} sessions on ${cell.date}`;
+}
+
+function heatCell(cell, selected, onPick) {
+  if (cell.future) return node('span', { class: ui.heatBlank });
+  const label = dayLabel(cell);
+  const on = cell.date === selected;
+  return node('button', {
+    class: ui.heatTile(cell.level, on),
+    title: label,
+    'aria-label': label,
+    'aria-pressed': on ? 'true' : 'false',
+    onclick: () => onPick(on ? null : cell.date),
+  });
+}
+
+function activityGrid(heat, selected, onPick) {
+  const months = node('div', { class: ui.heatMonthRow });
+  for (const label of heat.months) {
+    months.append(node('div', { class: ui.heatMonthCell }, [
+      label ? node('span', { class: ui.heatMonthLabel, text: label }) : null,
+    ]));
+  }
+
+  const grid = node('div', { class: ui.heatGrid });
+  for (const week of heat.weeks) {
+    for (const cell of week) grid.append(heatCell(cell, selected, onPick));
+  }
+
+  const weekdays = node('div', { class: ui.heatDayCol });
+  for (const label of WEEKDAYS) weekdays.append(node('span', { class: ui.heatDayLabel, text: label }));
+
+  const legend = node('div', { class: ui.heatLegend }, [node('span', { text: 'Less' })]);
+  for (const level of LEVELS) legend.append(node('span', { class: ui.heatLegendSwatch(level) }));
+  legend.append(node('span', { text: 'More' }));
+
+  return node('div', { class: ui.heatBody }, [
+    weekdays,
+    node('div', { class: ui.heatMain }, [
+      node('div', { class: ui.heatScroll }, [months, grid]),
+      legend,
+    ]),
+  ]);
+}
+
+function meterPanel(title, aside, body) {
+  return node('div', { class: ui.meterPanel }, [
+    node('div', { class: ui.meterPanelHead }, [
+      node('span', { class: ui.meterPanelTitle, text: title }),
+      aside,
+    ]),
+    body,
+  ]);
+}
+
+export 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 (!isAt('environment', '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);
+  }
+
+  const selected = state.aux.sessionDay;
+  const pickDay = (date) => {
+    state.aux.sessionDay = date;
+    paint('tab');
+  };
+
+  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' }),
+    ]),
+    node('div', { class: ui.meterPanels }, [
+      meterPanel('Retention', null, retentionTrack(data.sessions, data.days)),
+      data.heat ? meterPanel('Activity', null, activityGrid(data.heat, selected, pickDay)) : null,
+    ]),
+    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.' }),
+  ]));
+
+  const visible = selected
+    ? data.sessions.filter((session) => session.modified.slice(0, 10) === selected)
+    : data.sessions;
+  const listHead = node('div', { class: ui.sectionLabelRow }, [
+    node('span', {
+      class: ui.sectionLabelInline,
+      text: selected ? `Sessions \u00b7 ${visible.length} on ${selected}` : `Sessions \u00b7 ${data.count}`,
+    }),
+  ]);
+  if (selected) {
+    listHead.append(node('button', {
+      class: ui.heatFilterClear,
+      text: 'show every day',
+      onclick: () => pickDay(null),
+    }));
+  }
+  container.append(listHead);
+  const card = node('div', { class: ui.card });
+  for (const session of visible) {
+    card.append(sessionRow(session, byOrigin.get(session.id) || []));
+  }
+  container.append(card);
+}

package/public/views/settings.mjs

@@ -0,0 +1,121 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { api } from '/api.mjs';
+import { state } from '/state.mjs';
+import { isAt } from '/parts.mjs';
+
+const SETTINGS_PROBLEMS = {
+  unparseable: (p) => [
+    `Not valid JSON: ${p.scope} settings`,
+    `${p.file} — Claude Code cannot read this file either, so every value in it is being ignored. ${p.detail}`,
+  ],
+  unreadable: (p) => [
+    `Cannot be read: ${p.scope} settings`,
+    `${p.file} — ${p.detail}`,
+  ],
+  'not-object': (p) => [
+    `Not a settings object: ${p.scope} settings`,
+    `${p.file} — ${p.detail}`,
+  ],
+  'invalid-auto-memory-directory': (p) => [
+    'autoMemoryDirectory cannot be used',
+    `${p.file} — ${p.detail}. Claude Code accepts only an absolute or ~/-prefixed path.`,
+  ],
+};
+
+const show = (value) => (value === undefined ? 'unset' : JSON.stringify(value));
+
+export async function renderSettings(container) {
+  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 (!isAt('environment', '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.' }));
+
+  if (!data.projectDir) {
+    container.append(node('p', { class: ui.subWarn, text: 'This store has no resolved project directory, so its project and local settings layers could not be consulted. Values below come from managed policy and your user file only.' }));
+  }
+
+  if (data.problems.length) {
+    container.append(node('div', { class: ui.sectionLabel, text: `Problems · ${data.problems.length}` }));
+    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(problem.severity === 'bad') }, [
+        node('div', { class: ui.issueBody }, [
+          node('div', { class: ui.issueTitle, text: title }),
+          node('div', { class: ui.issueDetail, text: detail }),
+        ]),
+      ]));
+    }
+  }
+
+  if (data.env.overrides) {
+    container.append(node('div', { class: ui.sectionLabel, text: 'Environment override' }));
+    container.append(node('div', { class: ui.issue(false) }, [
+      node('div', { class: ui.issueBody }, [
+        node('div', { class: ui.issueTitle, text: `${data.env.name}=${data.env.value}` }),
+        node('div', { class: ui.issueDetail, text: `Set in this shell, so it outranks every settings file and forces ${data.env.overrides} off. The store will not grow while it is set.` }),
+      ]),
+    ]));
+  }
+
+  for (const entry of data.keys) {
+    const card = node('div', { class: ui.card });
+    const head = node('div', { class: ui.settingsKeyHead }, [
+      node('span', { class: ui.settingsKeyName, text: entry.key }),
+      node('span', {
+        class: ui.settingsEffective,
+        text: entry.effective ? show(entry.effective.value) : `${show(entry.fallback)} (default)`,
+      }),
+    ]);
+    if (entry.effective) {
+      head.append(node('span', { class: ui.scopeBadge(entry.effective.scope), text: entry.effective.scope }));
+    }
+    card.append(head);
+    card.append(node('p', { class: ui.noteTight, text: entry.detail }));
+
+    if (entry.normalized !== undefined && entry.effective && entry.normalized !== entry.effective.value) {
+      card.append(node('div', { class: ui.issue(false) }, [
+        node('div', { class: ui.issueBody }, [
+          node('div', { class: ui.issueTitle, text: `Configured ${show(entry.effective.value)}, but ${show(entry.normalized)} applies` }),
+          node('div', { class: ui.issueDetail, text: 'Claude Code ignores a value it cannot use and falls back to the default.' }),
+        ]),
+      ]));
+    }
+
+    if (!entry.values.length) {
+      card.append(node('p', { class: ui.note, text: 'No settings file sets this, so the built-in default applies.' }));
+    } else {
+      for (const value of entry.values) {
+        card.append(node('div', { class: ui.settingsLayerRow }, [
+          node('span', { class: ui.scopeBadge(value.scope), text: value.scope }),
+          node('span', { class: ui.settingsLayerValue(value.wins), text: show(value.value) }),
+          node('span', { class: ui.settingsLayerFile, text: value.file }),
+          value.wins ? node('span', { class: ui.badge('ok'), text: 'wins' }) : null,
+        ]));
+      }
+    }
+    container.append(card);
+  }
+
+  container.append(node('div', { class: ui.sectionLabel, text: `Files consulted · ${data.layers.length}` }));
+  const files = node('div', { class: ui.card });
+  for (const layer of data.layers) {
+    files.append(node('div', { class: ui.settingsLayerRow }, [
+      node('span', { class: ui.scopeBadge(layer.scope), text: layer.scope }),
+      node('span', { class: ui.settingsLayerValue(layer.status === 'ok'), text: layer.status }),
+      node('span', { class: ui.settingsLayerFile, text: layer.file }),
+    ]));
+  }
+  container.append(files);
+}

package/public/views/stores.mjs

@@ -0,0 +1,65 @@
+import * as ui from '/ui.mjs';
+import { el, node } from '/dom.mjs';
+import { state } from '/state.mjs';
+import { openStore } from '/store.mjs';
+
+function storeSubtitle(store) {
+  if (store.kind === 'global') return store.dir;
+  if (store.kind === 'auto') return store.path;
+  const scope = store.kind === 'agent-user' ? 'user'
+    : store.kind === 'agent-project' ? 'project' : 'local';
+  return `${scope} · ${store.sublabel}`;
+}
+
+function issueTitle(store) {
+  const parts = [];
+  if (store.issueCount) parts.push(`${store.issueCount} to fix in Cleanup`);
+  const environment = (store.context || 0) + (store.settings || 0);
+  if (environment) parts.push(`${environment} in Environment`);
+  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 && !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: issueTitle(store),
+  }, [
+    node('span', { class: ui.storeRow }, [
+      node('span', { class: ui.dot(health) }),
+      node('span', { class: ui.storeName, text: store.label }),
+      off ? node('span', { class: ui.offMarker, text: 'off', title: 'Auto memory is disabled for this project' }) : null,
+      global ? null : node('span', { class: ui.storeCount, text: store.hasMemoryDir ? String(store.memoryCount) : '-' }),
+    ]),
+    node('span', { class: ui.storePath, text: storeSubtitle(store) }),
+  ]);
+}
+
+export function renderStores() {
+  const list = el('project-list');
+  list.textContent = '';
+
+  const visible = state.stores.filter((s) => s.kind === 'global' || state.showAll || s.hasMemoryDir);
+  if (!visible.length) {
+    list.append(node('p', { class: ui.note, text: 'No memory stores found.' }));
+    return;
+  }
+
+  const groups = [
+    ['Global', visible.filter((s) => s.kind === 'global')],
+    ['Projects', visible.filter((s) => s.kind === 'auto')],
+    ['Subagents', visible.filter((s) => s.kind !== 'auto' && s.kind !== 'global')],
+  ];
+
+  const filled = groups.filter(([, stores]) => stores.length);
+  for (const [title, stores] of filled) {
+    if (filled.length > 1) list.append(node('div', { class: ui.sidebarGroup, text: title }));
+    for (const store of stores) list.append(storeButton(store));
+  }
+}

package/public/views/worklist.mjs

@@ -0,0 +1,33 @@
+const COST_KINDS = new Set(['long-hook', 'hook-repeats-description', 'empty-section', 'index-continuation']);
+
+function rankOf(kind, severity) {
+  if (kind === 'past-cutoff') return 0;
+  if (severity === 'bad') return 1;
+  if (COST_KINDS.has(kind)) return 2;
+  if (kind === 'overlap') return 4;
+  return 3;
+}
+
+export function buildWorklist(store) {
+  if (!store || !store.stats) return [];
+  const items = [];
+  const { index } = store.stats;
+
+  for (const entry of index.cutoff?.droppedEntries ?? []) {
+    items.push({ kind: 'past-cutoff', severity: 'bad', entry });
+  }
+  for (const hook of index.longHooks) {
+    items.push({ kind: 'long-hook', severity: 'warn', hook });
+  }
+  for (const item of store.health.issues) {
+    if (item.kind === 'long-hooks') continue;
+    items.push(item);
+  }
+  for (const pair of store.duplicates) {
+    items.push({ kind: 'overlap', severity: 'warn', pair });
+  }
+
+  return items
+    .map((item) => ({ ...item, rank: rankOf(item.kind, item.severity) }))
+    .sort((a, b) => a.rank - b.rank);
+}

package/src/sessions.mjs

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { HEAD_READS, readHead } from './projects.mjs';
-import { cleanupPeriodDays } from './settings.mjs';
+import { cleanupPeriodDays, DEFAULT_CLEANUP_PERIOD_DAYS } from './settings.mjs';
 import { ageInDays } from './stats.mjs';
 
 export const EXPIRY_WARNING_DAYS = 7;
@@ -145,6 +145,73 @@ export function retention(sessions, { projectDir = null, now = Date.now() } = {}
   };
 }
 
+export const HEAT_WEEKS_MAX = 53;
+export const HEAT_LEVELS = 4;
+
+const DAY_MS = 86400000;
+const MONTH_LABELS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+const dayKey = (ms) => new Date(ms).toISOString().slice(0, 10);
+const startOfDay = (ms) => Math.floor(ms / DAY_MS) * DAY_MS;
+const mondayOf = (ms) => ms - ((new Date(ms).getUTCDay() + 6) % 7) * DAY_MS;
+const sundayOf = (ms) => ms + ((7 - new Date(ms).getUTCDay()) % 7) * DAY_MS;
+
+export function heatLevel(count, max) {
+  if (!count) return 0;
+  if (max <= HEAT_LEVELS) return count;
+  return Math.min(HEAT_LEVELS, Math.ceil((count / max) * HEAT_LEVELS));
+}
+
+export function heatmap(sessions, { days = DEFAULT_CLEANUP_PERIOD_DAYS, now = Date.now() } = {}) {
+  const today = startOfDay(now);
+  const counts = new Map();
+  for (const session of sessions) {
+    if (typeof session.modified !== 'string') continue;
+    const date = session.modified.slice(0, 10);
+    counts.set(date, (counts.get(date) || 0) + 1);
+  }
+
+  const span = Math.max(1, Math.round(days));
+  let earliest = today - (span - 1) * DAY_MS;
+  for (const date of counts.keys()) {
+    const at = Date.parse(`${date}T00:00:00.000Z`);
+    if (!Number.isNaN(at) && at < earliest) earliest = at;
+  }
+
+  const end = sundayOf(today);
+  let start = mondayOf(earliest);
+  if (Math.round((end + DAY_MS - start) / (7 * DAY_MS)) > HEAT_WEEKS_MAX) {
+    start = end - (HEAT_WEEKS_MAX * 7 - 1) * DAY_MS;
+  }
+
+  const max = counts.size ? Math.max(...counts.values()) : 0;
+  const weeks = [];
+  const months = [];
+  let labelled = null;
+  for (let monday = start; monday <= end; monday += 7 * DAY_MS) {
+    const week = [];
+    for (let offset = 0; offset < 7; offset += 1) {
+      const ms = monday + offset * DAY_MS;
+      const date = dayKey(ms);
+      const count = counts.get(date) || 0;
+      week.push({ date, count, level: heatLevel(count, max), future: ms > today });
+    }
+    const month = new Date(monday).getUTCMonth();
+    months.push(month === labelled ? null : MONTH_LABELS[month]);
+    labelled = month;
+    weeks.push(week);
+  }
+
+  return {
+    weeks,
+    months,
+    max,
+    total: [...counts.values()].reduce((sum, value) => sum + value, 0),
+    start: dayKey(start),
+    end: dayKey(end),
+  };
+}
+
 export function originSession(slugDir, sessionId) {
   if (typeof sessionId !== 'string' || !SESSION_ID.test(sessionId)) return null;
   const file = path.join(slugDir, `${sessionId}.jsonl`);
@@ -166,6 +233,7 @@ export function sessionsWithSummaries(slugDir, { projectDir = null, now = Date.n
   const report = retention(listSessions(slugDir), { projectDir, now });
   return {
     ...report,
+    heat: heatmap(report.sessions, { days: report.days, now }),
     sessions: report.sessions.map((session) => ({
       ...session,
       ...sessionSummary(session.file, { bytes: session.bytes }),