claude-memory-admin 1.5.1 → 1.5.2

package/public/bus.mjs

@@ -0,0 +1,7 @@
+const regions = new Map();
+
+export const register = (name, render) => regions.set(name, render);
+
+export const paint = (...names) => {
+  for (const name of names) regions.get(name)?.();
+};

package/public/dialogs/add-entry.mjs

@@ -0,0 +1,69 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { openDialog } from '/dialog.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { runIndexEdit } from '/views/index.mjs';
+
+export async function openAddEntryDialog(file) {
+  let preview;
+  try {
+    preview = await api(`/api/stores/${encodeURIComponent(state.storeId)}/index/add-preview`, {
+      method: 'POST',
+      body: JSON.stringify({ file }),
+    });
+  } catch (err) {
+    return toast(err.message, { error: true });
+  }
+
+  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;
+
+  const picker = node('select', { class: ui.select });
+  for (const section of preview.sections) picker.append(node('option', { value: section, text: section }));
+  picker.append(node('option', { value: '', text: 'End of MEMORY.md' }));
+  if (preview.sections.length) picker.value = preview.sections[preview.sections.length - 1];
+
+  const line = node('div', { class: ui.willItem('keep') });
+  const update = () => {
+    const label = titleInput.value.trim().replace(/[[\]]/g, '') || preview.name;
+    const text = hook.value.trim();
+    line.textContent = text ? `- [${label}](${file}) — ${text}` : `- [${label}](${file})`;
+  };
+  titleInput.addEventListener('input', update);
+  hook.addEventListener('input', update);
+  update();
+
+  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;
+
+  await runIndexEdit(
+    'index/add',
+    { file, section: picker.value || null, title: titleInput.value, hook: hook.value },
+    () => 'Added to MEMORY.md',
+  );
+}

package/public/dialogs/bulk-delete.mjs

@@ -0,0 +1,58 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { openDialog } from '/dialog.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { openStore, restoreFromTrash } from '/store.mjs';
+
+export 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 = [];
+  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.push(removals);
+
+  const doomed = new Set(files);
+  const breaking = [];
+  for (const memory of memories) {
+    for (const link of memory.inbound) {
+      if (!doomed.has(link.from)) breaking.push({ from: link.from, target: link.target });
+    }
+  }
+  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.push(block);
+  }
+
+  body.push(node('p', { class: ui.noteTight, text: 'All of them go to memory/.trash/ as one restore point.' }));
+
+  const go = await openDialog({
+    title: `Delete ${memories.length} memories?`,
+    body,
+    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 });
+  }
+}

package/public/dialogs/delete.mjs

@@ -0,0 +1,114 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { openDialog } from '/dialog.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { openStore, restoreFromTrash } from '/store.mjs';
+
+export async function openDeleteDialog(file) {
+  let preview;
+  try {
+    preview = await api(`/api/stores/${encodeURIComponent(state.storeId)}/delete-preview`, {
+      method: 'POST',
+      body: JSON.stringify({ file }),
+    });
+  } catch (err) {
+    return toast(err.message, { error: true });
+  }
+
+  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/` }));
+  for (const line of [...preview.indexLines, ...preview.continuations]) {
+    removals.append(node('div', { class: ui.willItem('remove'), text: `MEMORY.md line ${line.index + 1}:  ${line.text}` }));
+  }
+  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.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.push(kept);
+  }
+
+  const cascade = new Set();
+  if (preview.inboundWikilinks.length) {
+    const block = node('div', { class: ui.willBlock });
+    const selectAll = node('button', { class: ui.linkButton, text: 'select all' });
+    block.append(node('div', { class: ui.cascadeHead }, [
+      node('div', { class: ui.willTitle, text: `${preview.inboundWikilinks.length} memory(s) link here and will break` }),
+      selectAll,
+    ]));
+
+    const list = node('div', { class: ui.cascadeList });
+    const rows = [];
+    for (const link of preview.inboundWikilinks) {
+      const box = node('input', { type: 'checkbox', class: ui.checkbox });
+      const row = node('label', { class: ui.cascadeRow(false) }, [
+        box,
+        node('span', { class: ui.cascadeText }, [
+          node('span', { class: ui.cascadeName, text: link.fromName || link.from }),
+          node('span', { class: ui.cascadeDetail, text: link.indexLine
+            ? `${link.from} · MEMORY.md line ${link.indexLine.index + 1}`
+            : `${link.from} · not in the index` }),
+        ]),
+      ]);
+      box.addEventListener('change', () => {
+        row.className = ui.cascadeRow(box.checked);
+        if (box.checked) cascade.add(link.from);
+        else cascade.delete(link.from);
+        updateButton();
+      });
+      rows.push({ box, row });
+      list.append(row);
+    }
+    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.push(block);
+
+    selectAll.onclick = (event) => {
+      event.preventDefault();
+      const turnOn = rows.some((r) => !r.box.checked);
+      for (const { box } of rows) {
+        if (box.checked !== turnOn) { box.checked = turnOn; box.dispatchEvent(new Event('change')); }
+      }
+      selectAll.textContent = turnOn ? 'select none' : 'select all';
+    };
+  }
+
+  body.push(node('p', { class: ui.noteTight, text: 'The file moves to memory/.trash/ with a restore record, so this can be undone.' }));
+
+  const remove = { label: 'Delete', tone: 'danger', value: true };
+  const answer = openDialog({
+    title: `Delete "${preview.name || preview.file}"?`,
+    subtitle: preview.description || '',
+    body,
+    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() {
+    remove.el.textContent = cascade.size ? `Delete ${cascade.size + 1} memories` : 'Delete';
+  }
+}

package/public/dialogs/hook-editor.mjs

@@ -0,0 +1,54 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { state } from '/state.mjs';
+import { toast } from '/api.mjs';
+import { paint } from '/bus.mjs';
+import { byteLength } from '/parts.mjs';
+import { indexEntryAt, runIndexEdit } from '/views/index.mjs';
+
+export function openHookEditor(row, lineIndex) {
+  const entry = indexEntryAt(lineIndex);
+  if (!entry) return toast('MEMORY.md has changed - reload and try again', { error: true });
+
+  const stats = state.store.stats.index;
+  const editor = node('div', { class: ui.hookEditor });
+  const field = node('textarea', { class: ui.textArea, spellcheck: 'false' });
+  field.value = entry.hook;
+
+  const counter = node('span');
+  const projection = node('span');
+  const readout = node('div', { class: ui.charCount }, [counter, projection]);
+
+  const save = node('button', { class: ui.buttonPrimarySmall, text: 'Save' });
+  const cancel = node('button', { class: ui.buttonSmall, text: 'Cancel', onclick: () => paint('tab') });
+
+  function update() {
+    const next = field.value.trim();
+    const delta = byteLength(next) - byteLength(entry.hook);
+    const projected = Math.max(stats.linePercent, ((stats.bytes + delta) / stats.byteLimit) * 100);
+
+    counter.textContent = `${next.length} characters, was ${entry.hook.length}`;
+    projection.textContent = `index ${Math.round(stats.worstPercent)}% → ${Math.round(projected)}%`;
+    readout.className = next.length > 200 ? ui.charCountOver : ui.charCount;
+    save.disabled = next === entry.hook;
+  }
+
+  field.addEventListener('input', update);
+  save.onclick = () => runIndexEdit(
+    'index/hook',
+    { lineIndex, expectedText: entry.text, hook: field.value },
+    () => 'Hook shortened',
+  );
+
+  editor.append(
+    node('div', { class: ui.willTitle, text: 'Hook' }),
+    field,
+    readout,
+    node('div', { class: ui.hookEditorFoot }, [cancel, save]),
+  );
+  row.textContent = '';
+  row.append(editor);
+  update();
+  field.focus();
+  field.select();
+}

package/public/dialogs/merge.mjs

@@ -0,0 +1,81 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { openDialog } from '/dialog.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { openStore, restoreFromTrash } from '/store.mjs';
+
+export async function openMergeDialog(into, from) {
+  let preview;
+  try {
+    preview = await api(`/api/stores/${encodeURIComponent(state.storeId)}/merge-preview`, {
+      method: 'POST',
+      body: JSON.stringify({ into, from }),
+    });
+  } catch (err) {
+    return toast(err.message, { error: true });
+  }
+
+  const heading = node('input', { type: 'text', class: ui.pathInput, spellcheck: 'false' });
+  heading.value = preview.heading;
+
+  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}` }));
+  for (const entry of preview.inbound) {
+    changes.append(node('div', { class: ui.willItem('keep'), text: `${entry.file}  ${entry.targets.map((t) => `[[${t}]]`).join(' ')}  →  [[${preview.intoName}]]` }));
+  }
+  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.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/` }));
+  for (const line of preview.indexLines) {
+    removals.append(node('div', { class: ui.willItem('remove'), text: `MEMORY.md line ${line.index + 1}:  ${line.text}` }));
+  }
+  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.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.push(kept);
+  }
+
+  body.push(node('label', { class: ui.willTitle, text: 'Heading for the merged section' }), heading);
+
+  const go = await openDialog({
+    title: `Merge "${preview.fromName}" into "${preview.intoName}"?`,
+    body,
+    actions: [
+      { label: 'Cancel' },
+      { label: 'Merge', tone: 'primary', value: true },
+    ],
+    focus: heading,
+  });
+  if (!go) return;
+
+  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 });
+  }
+}

package/public/dialogs/move.mjs

@@ -0,0 +1,43 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { openDialog } from '/dialog.mjs';
+import { state } from '/state.mjs';
+import { toast } from '/api.mjs';
+import { indexEntryAt, sectionsAbove, runIndexEdit } from '/views/index.mjs';
+
+export async function openMoveDialog(entry) {
+  const current = indexEntryAt(entry.index);
+  if (!current) return toast('MEMORY.md has changed - reload and try again', { error: true });
+
+  const { cutoff } = state.store.stats.index;
+  const sections = sectionsAbove(cutoff ? cutoff.rawLine : null);
+  const picker = node('select', { class: ui.select });
+  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 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',
+  );
+}

package/public/dialogs/remember-path.mjs

@@ -0,0 +1,65 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { openDialog } from '/dialog.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { openStore, reloadStores } from '/store.mjs';
+
+export async function openRememberPathDialog() {
+  const store = state.store;
+  const input = node('input', {
+    type: 'text',
+    class: ui.pathInput,
+    value: store.guess || '',
+    placeholder: '/Users/you/repos/the-project',
+    spellcheck: 'false',
+  });
+
+  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 false;
+          try {
+            await api(`/api/stores/${encodeURIComponent(state.storeId)}/path/remember`, {
+              method: 'POST',
+              body: JSON.stringify({ path: value }),
+            });
+          } catch (err) {
+            toast(err.message, { error: true });
+            return false;
+          }
+          return true;
+        },
+      },
+    ],
+    focus: input,
+  });
+  if (!remembered) return;
+
+  await reloadStores();
+  await openStore(state.storeId, { keepTab: true });
+  toast(`Remembered ${input.value.trim()}`);
+}
+
+export async function forgetProjectPath() {
+  try {
+    await api(`/api/stores/${encodeURIComponent(state.storeId)}/path/forget`, { method: 'POST' });
+  } catch (err) {
+    return toast(err.message, { error: true });
+  }
+  await reloadStores();
+  await openStore(state.storeId, { keepTab: true });
+  toast('Forgot the remembered path');
+}

package/public/dialogs/store-delete.mjs

@@ -0,0 +1,64 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { openDialog } from '/dialog.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { openStore, restoreFromTrash } from '/store.mjs';
+
+export async function openStoreDeleteDialog() {
+  let preview;
+  try {
+    preview = await api(`/api/stores/${encodeURIComponent(state.storeId)}/project/delete-preview`, { method: 'POST' });
+  } catch (err) {
+    return toast(err.message, { error: true });
+  }
+
+  if (!preview.files.length && !preview.hasIndex) {
+    return toast('This store has no memory to delete');
+  }
+
+  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/` }));
+  }
+  for (const entry of preview.files) {
+    removals.append(node('div', { class: ui.willItem('remove'), text: `${entry.file}  →  memory/.trash/` }));
+  }
+  body.push(removals);
+
+  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.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.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 go = await openDialog({
+    title: `Delete all memory for ${state.store.label}?`,
+    subtitle: `${preview.files.length} memories${preview.hasIndex ? ' + MEMORY.md' : ''}`,
+    body,
+    actions: [
+      { label: 'Cancel' },
+      { label: `Delete ${preview.files.length + (preview.hasIndex ? 1 : 0)} files`, tone: 'danger', value: true },
+    ],
+  });
+  if (!go) return;
+
+  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 });
+  }
+}

package/public/parts.mjs

@@ -0,0 +1,58 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { state } from '/state.mjs';
+import { paint } from '/bus.mjs';
+
+export function issue(title, detail, { bad = false, action, secondary } = {}) {
+  return node('div', { class: ui.issue(bad) }, [
+    node('div', { class: ui.issueBody }, [
+      node('div', { class: ui.issueTitle, text: title }),
+      node('div', { class: ui.issueDetail, text: detail }),
+    ]),
+    secondary ? node('button', { class: ui.buttonSmall, text: secondary.label, onclick: secondary.run }) : null,
+    action ? node('button', { class: ui.buttonSmall, text: action.label, onclick: action.run }) : null,
+  ]);
+}
+
+export function goToTab(id) {
+  state.tab = id;
+  paint('tabs', 'tab');
+}
+
+export function cutMarker(cutoff) {
+  return node('div', { class: ui.cutLine }, [
+    node('span', { class: ui.cutLabel, text: `not loaded past here — ${cutoff.droppedLines} lines dropped on ${cutoff.by}` }),
+  ]);
+}
+
+export function highlight(text, terms) {
+  const wrapper = node('span');
+  if (!terms.length) { wrapper.textContent = text; return wrapper; }
+  const pattern = new RegExp(`(${terms.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')})`, 'ig');
+  let last = 0;
+  for (const match of text.matchAll(pattern)) {
+    if (match.index > last) wrapper.append(document.createTextNode(text.slice(last, match.index)));
+    wrapper.append(node('mark', { class: ui.resultMark, text: match[0] }));
+    last = match.index + match[0].length;
+  }
+  if (last < text.length) wrapper.append(document.createTextNode(text.slice(last)));
+  return wrapper;
+}
+
+export function formatAge(days) {
+  if (days === null || days === undefined) return 'undated';
+  if (days < 1) return 'today';
+  if (days < 31) return `${days}d`;
+  if (days < 365) return `${Math.round(days / 30)}mo`;
+  return `${(days / 365).toFixed(1)}y`;
+}
+
+export const sizeLabel = (bytes) => (bytes >= 1048576
+  ? `${(bytes / 1048576).toFixed(1)} MB`
+  : `${(bytes / 1024).toFixed(1)} KB`);
+
+export function sessionDate(iso) {
+  return iso ? iso.replace('T', ' ').replace(/\..*$/, '') : 'unknown';
+}
+
+export const byteLength = (text) => new TextEncoder().encode(text).length;

package/public/state.mjs

@@ -0,0 +1,22 @@
+export const state = {
+  stores: [],
+  storeId: null,
+  store: null,
+  tab: 'memories',
+  selected: null,
+  showAll: false,
+  collapsed: localStorage.getItem('sidebarCollapsed') === '1',
+  theme: document.documentElement.dataset.theme === 'dark' ? 'dark' : 'light',
+  spread: Number(localStorage.getItem('graphSpread')) || 1.6,
+  query: '',
+  search: null,
+  pruneSort: 'oldest',
+  pruneSelection: new Set(),
+  indexView: localStorage.getItem('memoryIndexView') === 'source' ? 'source' : 'rendered',
+  aux: { instructions: null, settings: null, sessions: null, sessionDay: null },
+  pathCheck: null,
+};
+
+const RANK = { ok: 0, warn: 1, bad: 2 };
+export const worst = (...severities) => severities.reduce((a, b) => (RANK[b] > RANK[a] ? b : a), 'ok');
+export const worstSeverity = (items) => (!items.length ? 'ok' : items.some((item) => item.severity === 'bad') ? 'bad' : 'warn');