claude-memory-admin 1.8.0 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-memory-admin",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Browse, audit and prune the auto memory Claude Code keeps under ~/.claude/projects",
   "keywords": [
     "claude",

package/public/app.mjs

@@ -2,7 +2,7 @@ import { isDialogOpen } from '/dialog.mjs';
 import { el, node } from '/dom.mjs';
 import * as ui from '/ui.mjs';
 import { state } from '/state.mjs';
-import { toast } from '/api.mjs';
+import { api, toast } from '/api.mjs';
 import { register, paint } from '/bus.mjs';
 import { openStore, reloadStores } from '/store.mjs';
 import { renderStores } from '/views/stores.mjs';
@@ -76,6 +76,14 @@ function applyStyles() {
   }
 }
 
+async function refreshActiveSessions() {
+  try {
+    const data = await api('/api/stores/active');
+    state.activeSessions = data.sessions;
+    paint('stores', 'tabs', 'tab');
+  } catch { /* a failed poll just leaves the last-known state on screen */ }
+}
+
 function registerRegions() {
   register('stores', renderStores);
   register('header', renderStoreHeader);
@@ -144,6 +152,12 @@ async function init() {
   } catch (err) {
     toast(err.message, { error: true });
   }
+
+  refreshActiveSessions();
+  setInterval(refreshActiveSessions, 10000);
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'visible') refreshActiveSessions();
+  });
 }
 
 init();

package/public/state.mjs

@@ -43,6 +43,7 @@ export const state = {
   indexView: localStorage.getItem('memoryIndexView') === 'source' ? 'source' : 'rendered',
   aux: { instructions: null, settings: null, sessions: null, sessionDay: null, sessionFocus: null, tools: null },
   pathCheck: null,
+  activeSessions: [],
 };
 
 const RANK = { ok: 0, warn: 1, bad: 2 };

package/public/views/header.mjs

@@ -56,7 +56,10 @@ function segmentBadge(id) {
   }
   if (id === 'sessions') {
     const sessions = state.store.sessions;
-    return sessions ? { badge: String(sessions.count), tone: sessions.expiringCount ? 'warn' : 'neutral' } : {};
+    if (!sessions) return {};
+    const live = state.activeSessions.some((s) => s.storeId === state.store.id);
+    const badge = live ? `● ${sessions.count}` : String(sessions.count);
+    return { badge, tone: live ? 'ok' : sessions.expiringCount ? 'warn' : 'neutral' };
   }
   return {};
 }

package/public/views/sessions.mjs

@@ -20,11 +20,26 @@ export function focusSession(id) {
   goTo('environment', 'sessions');
 }
 
-function sessionRow(session, memoriesFrom, focused) {
+function agoLabel(ms) {
+  const seconds = Math.max(0, Math.round((Date.now() - ms) / 1000));
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  return `${Math.round(minutes / 60)}h ago`;
+}
+
+function sessionRow(session, memoriesFrom, focused, live) {
   const soon = session.expiresInDays !== null && session.expiresInDays <= 7;
   const caret = node('span', { class: ui.contextCaret, text: focused ? '\u25be' : '\u25b8' });
 
   const tags = [];
+  if (live) {
+    tags.push(node('span', {
+      class: ui.badge('ok'),
+      text: live.status === 'waiting' ? 'waiting' : live.status || 'active',
+      title: live.waitingFor || `updated ${agoLabel(live.updatedAt)}`,
+    }));
+  }
   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) {
@@ -196,8 +211,33 @@ export async function renderSessions(container) {
     paint('tab');
   };
 
+  const active = state.activeSessions.filter((s) => s.storeId === state.storeId);
+  const byId = new Map(active.map((s) => [s.sessionId, s]));
+
   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.' }));
 
+  if (active.length) {
+    const list = node('div', { class: ui.card });
+    for (const session of active) {
+      list.append(node('button', {
+        class: ui.contextRowButton,
+        onclick: () => focusSession(session.sessionId),
+      }, [
+        node('div', { class: ui.contextMain }, [
+          node('div', { class: ui.contextTags }, [
+            node('span', {
+              class: ui.badge('ok'),
+              text: session.status === 'waiting' ? 'waiting' : session.status || 'active',
+            }),
+          ]),
+          node('div', { class: ui.contextFile, text: session.name || session.sessionId }),
+        ]),
+        node('div', { class: ui.contextSize, text: session.waitingFor || agoLabel(session.updatedAt) }),
+      ]));
+    }
+    container.append(meterPanel('Active now', null, list));
+  }
+
   container.append(node('div', { class: ui.meter }, [
     node('div', { class: ui.meterTop }, [
       node('span', { class: ui.meterValue, text: String(data.count) }),
@@ -241,7 +281,7 @@ export async function renderSessions(container) {
   const card = node('div', { class: ui.card });
   let focused = null;
   for (const session of visible) {
-    const row = sessionRow(session, byOrigin.get(session.id) || [], session.id === focus);
+    const row = sessionRow(session, byOrigin.get(session.id) || [], session.id === focus, byId.get(session.id));
     if (session.id === focus) focused = row;
     card.append(row);
   }

package/public/views/stores.mjs

@@ -22,10 +22,17 @@ function issueTitle(store) {
   return parts.length ? `${store.dir}\n${parts.join(', ')}` : store.dir;
 }
 
+function activeTitle(active) {
+  const waiting = active.filter((s) => s.status === 'waiting').length;
+  const label = active.length === 1 ? '1 session' : `${active.length} sessions`;
+  return waiting ? `${label} - ${waiting} waiting for input` : `${label} ${active.length === 1 ? 'is' : 'are'} busy`;
+}
+
 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;
+  const active = state.activeSessions.filter((s) => s.storeId === store.id);
   return node('button', {
     class: ui.storeItem({ active: store.id === state.storeId, empty: !global && !store.hasMemoryDir }),
     onclick: () => openStore(store.id),
@@ -34,6 +41,7 @@ function storeButton(store) {
     node('span', { class: ui.storeRow }, [
       node('span', { class: ui.dot(health) }),
       node('span', { class: ui.storeName, text: store.label }),
+      active.length ? node('span', { class: ui.dot('ok'), title: activeTitle(active) }) : null,
       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) : '-' }),
     ]),

package/server.mjs

@@ -18,6 +18,7 @@ import { searchAll } from './src/search.mjs';
 import { verifyPaths } from './src/pathcheck.mjs';
 import { detectTools, toolReport } from './src/tools.mjs';
 import { sessionsWithSummaries, transcriptDir } from './src/sessions.mjs';
+import { readLiveSessions } from './src/liveSessions.mjs';
 import {
   addIndexEntry,
   addIndexEntryPreview,
@@ -242,6 +243,18 @@ async function handleApi(req, res, url) {
     return sendJson(res, 200, { stores: issueSweep() });
   }
 
+  // Same "ahead of requireStore" reasoning as the issues sweep above: real
+  // store ids always carry a "kind:" prefix, so "active" can never collide.
+  if (segments.length === 3 && segments[1] === 'stores' && segments[2] === 'active' && req.method === 'GET') {
+    const live = readLiveSessions();
+    const projectStores = listStores(ROOT).filter((s) => s.kind === 'auto' && s.pathExists);
+    const sessions = live.map((session) => ({
+      ...session,
+      storeId: projectStores.find((s) => s.path === session.cwd)?.id ?? null,
+    }));
+    return sendJson(res, 200, { sessions });
+  }
+
   if (segments[1] !== 'stores' || segments.length < 3) {
     return sendJson(res, 404, { error: 'Unknown endpoint' });
   }

package/src/liveSessions.mjs

@@ -0,0 +1,46 @@
+// The live-session registry Claude Code keeps at ~/.claude/sessions/<pid>.json,
+// one file per running `claude` process. This is distinct from the transcript
+// history in sessions.mjs: that reads what happened, this reads what is
+// happening right now.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== 'ESRCH';
+  }
+}
+
+/**
+ * Every session whose process is still running, newest-updated first. A file
+ * left behind by a process that has since exited is silently skipped rather
+ * than reported as stale - the registry itself is not this app's to clean up.
+ */
+export function readLiveSessions({ dir = path.join(os.homedir(), '.claude', 'sessions') } = {}) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const sessions = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+    let session;
+    try {
+      session = JSON.parse(fs.readFileSync(path.join(dir, entry.name), 'utf8'));
+    } catch {
+      continue;
+    }
+    if (!session || typeof session.pid !== 'number' || !isAlive(session.pid)) continue;
+    sessions.push(session);
+  }
+
+  return sessions.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+}