groove-dev 0.27.209 → 0.27.211

package/CLAUDE.md

@@ -295,3 +295,11 @@ Audit-driven release. Multi-agent orchestration system with 7 coordination layer
 - Dashboard: routing donut, cache panel, context health gauges
 - Monitor/QC agent mode (stay active, loop)
 - Distribution: demo video, HN launch, Twitter content
+
+<!-- GROOVE:START -->
+## GROOVE Orchestration (auto-injected)
+Active agents: 0
+See AGENTS_REGISTRY.md for full agent state, the names of agents on other teams,
+and how to consult them directly (InnerChat).
+**Memory policy:** GROOVE manages project memory automatically. Do not read or write MEMORY.md or .groove/memory/ files directly.
+<!-- GROOVE:END -->

package/node_modules/@groove-dev/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.209",
+  "version": "0.27.211",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.209",
+  "version": "0.27.211",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/daemon/src/axom-connector.js

@@ -33,8 +33,16 @@ export const KNOWN_KINDS = Object.freeze([
   'narration', 'narration_dropped',
   'candidate_arrived', 'evidence_scored', 'champion_changed',
   'confidence_updated', 'verifier_verdict',
+  'resolution_delta', 'context_compile',
 ]);
 
+// Cosmetic, append-only chunks of an answer still being written. The terminal
+// `resolution` always follows with the authoritative text, so a delta is
+// worthless the moment it lands — keeping them would crowd the ring with
+// history that replay deliberately omits anyway (they are transient runtime
+// side, so a `?since` replay never returns them either).
+const TRANSIENT_KINDS = new Set(['resolution_delta']);
+
 const RING_SIZE = 4096;
 const SESSION_POLL_MS = 15000;
 const BACKOFF_BASE_MS = 1000;
@@ -243,13 +251,19 @@ export class AxomConnector {
       // Dedup on ring-buffer replay after reconnect — ids are monotonic.
       if (seq !== null && seq <= s.lastSeq) return;
       if (seq !== null) s.lastSeq = seq;
-      if (s.ring.length >= this.ringSize) {
-        s.ring.shift();
-        // The ring bounds memory, not delivery: overflow is counted, never
-        // silent, and every event still broadcasts — mirrors the runtime.
-        s.overflow += 1;
+      // Transient kinds broadcast but are never retained: they are superseded
+      // by a terminal event, and a backfilled tab must see the same history a
+      // reconnecting one does. `lastSeq` still advances above, so dedup and
+      // ordering are unaffected.
+      if (!TRANSIENT_KINDS.has(envelope.kind)) {
+        if (s.ring.length >= this.ringSize) {
+          s.ring.shift();
+          // The ring bounds memory, not delivery: overflow is counted, never
+          // silent, and every event still broadcasts — mirrors the runtime.
+          s.overflow += 1;
+        }
+        s.ring.push(envelope);
       }
-      s.ring.push(envelope);
       if (envelope.kind && !KNOWN_KINDS.includes(envelope.kind)) {
         s.unknownKinds[envelope.kind] = (s.unknownKinds[envelope.kind] || 0) + 1;
       }

package/node_modules/@groove-dev/daemon/src/axom-runtimes.js

@@ -32,6 +32,22 @@ function withBlessedEnv(launch) {
   return { ...launch, env: { ...BLESSED_ENV, ...(launch.env || {}) } };
 }
 
+// A chat title is the opening message, trimmed to a glanceable length. It is
+// a QUOTE, not a summary: GROOVE has no business paraphrasing what the user
+// said, and an em-dash ellipsis makes the truncation visible rather than
+// pretending the sentence ended there.
+const TITLE_MAX = 48;
+export function summarizeForTitle(text) {
+  if (typeof text !== 'string') return null;
+  const flat = text.replace(/\s+/g, ' ').trim();
+  if (!flat) return null;
+  if (flat.length <= TITLE_MAX) return flat;
+  // Prefer a word boundary so titles don't end mid-word.
+  const cut = flat.slice(0, TITLE_MAX);
+  const space = cut.lastIndexOf(' ');
+  return `${(space > TITLE_MAX * 0.6 ? cut.slice(0, space) : cut).trimEnd()}…`;
+}
+
 // Single-quote for a POSIX shell. The spec is the user's own, but it crosses
 // an ssh command line — an unquoted path or value must not be able to end the
 // command and start another.
@@ -329,13 +345,29 @@ export class AxomRuntimes {
     this._save();
   }
 
+  // A chat titles itself from what it started with — "Chat 3" tells you
+  // nothing when you have six of them. Only ever replaces a PLACEHOLDER title:
+  // a name the user typed, or one already derived from the opening message, is
+  // never overwritten by a later turn.
+  titleFromFirstMessage(session, text) {
+    const chat = this.getChat(session);
+    if (!chat || chat.titled || chat.renamed) return null;
+    const title = summarizeForTitle(text);
+    if (!title) return null;
+    this._putChat({ ...chat, label: title, titled: true });
+    this.broadcastChats();
+    return title;
+  }
+
   renameChat(session, label) {
     const chat = this.getChat(session);
     if (!chat) throw new Error(`no chat "${session}"`);
     if (typeof label !== 'string' || !label.trim() || label.length > 80) {
       throw new Error('label must be a non-empty string of at most 80 chars');
     }
-    this._putChat({ ...chat, label: label.trim() });
+    // `renamed` is sticky: once the user names a chat, no later auto-title
+    // may take it back.
+    this._putChat({ ...chat, label: label.trim(), renamed: true });
     this.broadcastChats();
     return this.getChat(session);
   }
@@ -348,10 +380,44 @@ export class AxomRuntimes {
     const chat = this.getChat(session);
     if (!chat) throw new Error(`no chat "${session}"`);
     this._putChat({ ...chat, hidden: true });
+    this._forgetPrompts(session);
+    this._save();
     this.broadcastChats();
     return { hidden: true, session, note: 'removed from the list; the conversation remains in Axom\'s memory' };
   }
 
+  // ── Prompts — what GROOVE sent, remembered where the events are ──────────
+  //
+  // The runtime's `pipeline_start` carries no prompt text, so the user's own
+  // words exist only in GROOVE. Keeping them in the browser meant a reload
+  // replayed every turn from the daemon's ring with its bubble gone — the
+  // answer with no question above it. This is OUR record of what WE sent, not
+  // invented telemetry, so the daemon is the right place for it.
+  recordPrompt(session, ref, text) {
+    if (!session || !ref) return null;
+    const all = this._cfg().prompts || {};
+    const forSession = (all[session] || []).filter((p) => p.ref !== ref);
+    // Bounded per session: a transcript this long is scrollback, not memory.
+    const next = [...forSession, { ref, text, ts: Date.now() }].slice(-200);
+    this._cfg().prompts = { ...all, [session]: next };
+    this._save();
+    return { ref, text };
+  }
+
+  prompts(session) {
+    return (this._cfg().prompts || {})[session] || [];
+  }
+
+  // A hidden chat's prompts go with it — the list is tidied, the ledger keeps
+  // the conversation itself.
+  _forgetPrompts(session) {
+    const all = this._cfg().prompts || {};
+    if (!all[session]) return;
+    const next = { ...all };
+    delete next[session];
+    this._cfg().prompts = next;
+  }
+
   broadcastChats() {
     this.daemon.broadcast({ type: 'axom:chats', data: { chats: this.chats() } });
   }

package/node_modules/@groove-dev/daemon/src/chatstore.js

@@ -141,21 +141,37 @@ export class ChatStore {
   }
 
   /**
-   * History for the GUI: live agents keyed by their CURRENT id (what the GUI
-   * looks up by), everything else under its stored name key so an agent
-   * respawned under the same name picks its history back up.
+   * History for the GUI: LIVE agents only, keyed by their current id (what the
+   * GUI looks up by). Buckets for agents that no longer exist stay on disk —
+   * a respawn under the same name picks them back up — but aren't shipped:
+   * they were 97% of a 5.6MB payload, which blew the browser's ~5MB
+   * localStorage quota and froze the local cache.
    */
   view() {
     const out = {};
-    const agents = this.daemon.registry?.getAll?.() || [];
-    const liveNames = new Map(agents.map((a) => [a.name, a.id]));
-    for (const [key, msgs] of Object.entries(this.history)) {
-      if (!Array.isArray(msgs) || !msgs.length) continue;
-      out[liveNames.get(key) || key] = msgs;
+    for (const agent of this.daemon.registry?.getAll?.() || []) {
+      const msgs = this.history[agent.name];
+      if (Array.isArray(msgs) && msgs.length) out[agent.id] = msgs;
     }
     return out;
   }
 
+  /**
+   * Drop the oldest buckets belonging to agents that no longer exist, so a
+   * long-lived daemon's store stays bounded. Live agents are never pruned.
+   */
+  prune(maxDeadBuckets = 200) {
+    const liveNames = new Set((this.daemon.registry?.getAll?.() || []).map((a) => a.name));
+    const dead = Object.keys(this.history)
+      .filter((k) => !liveNames.has(k))
+      .map((k) => [k, lastTs(this.history[k])])
+      .sort((x, y) => y[1] - x[1]);
+    if (dead.length <= maxDeadBuckets) return 0;
+    for (const [key] of dead.slice(maxDeadBuckets)) delete this.history[key];
+    this._scheduleSave();
+    return dead.length - maxDeadBuckets;
+  }
+
   getAll() {
     return this.history;
   }
@@ -178,18 +194,46 @@ export class ChatStore {
   }
 }
 
-// Union of two message arrays, deduped on (timestamp, from, text), time-sorted,
-// capped. Exported for tests and the migration path.
+function lastTs(msgs) {
+  return (Array.isArray(msgs) && msgs.length && msgs[msgs.length - 1]?.timestamp) || 0;
+}
+
+/**
+ * Union of two message arrays, time-sorted and capped.
+ *
+ * Messages carry a stable `id`. A streamed agent reply coalesces client-side
+ * into ONE growing message that keeps its id, so an id collision means "same
+ * message, later state" — we keep the longer text rather than accumulating a
+ * fragment per chunk. Messages without an id (older clients) fall back to a
+ * (timestamp, from, text) signature.
+ */
 export function mergeMessages(a, b) {
-  const seen = new Set();
+  const byId = new Map();
+  const bySig = new Set();
   const out = [];
+
   for (const m of [...(a || []), ...(b || [])]) {
     if (!m || typeof m !== 'object') continue;
+
+    if (m.id) {
+      const prev = byId.get(m.id);
+      if (!prev) {
+        byId.set(m.id, m);
+        out.push(m);
+      } else if (String(m.text || '').length > String(prev.text || '').length) {
+        // Same message, further along — replace in place.
+        out[out.indexOf(prev)] = m;
+        byId.set(m.id, m);
+      }
+      continue;
+    }
+
     const sig = `${m.timestamp}:${m.from}:${typeof m.text === 'string' ? m.text.slice(0, 200) : ''}`;
-    if (seen.has(sig)) continue;
-    seen.add(sig);
+    if (bySig.has(sig)) continue;
+    bySig.add(sig);
     out.push(m);
   }
+
   out.sort((x, y) => (x.timestamp || 0) - (y.timestamp || 0));
   return out.slice(-MAX_PER_AGENT);
 }

package/node_modules/@groove-dev/daemon/src/index.js

@@ -653,6 +653,8 @@ export class Daemon {
         try {
           const moved = this.chatStore.migrate();
           if (moved) console.log(`[chat] migrated ${moved} id-keyed histories to agent names`);
+          const pruned = this.chatStore.prune();
+          if (pruned) console.log(`[chat] pruned ${pruned} histories for long-gone agents`);
         } catch { /* best effort */ }
 
         // Regenerate the on-disk registry files once on boot. They otherwise

package/node_modules/@groove-dev/daemon/src/routes/axom.js

@@ -46,6 +46,16 @@ export function registerAxomRoutes(app, daemon) {
         return res.status(400).json({ error: 'clientRef must be a string of at most 64 chars' });
       }
       const result = await daemon.axom.message(endpoint, req.params.id, text, clientRef);
+      // Title the chat from its opening message — but only once the runtime
+      // ACCEPTED the turn. A message rejected with 409/413 never ran, so it
+      // must not name the conversation it failed to start.
+      if (result.status === 202) {
+        daemon.axomRuntimes.titleFromFirstMessage(req.params.id, text);
+        // Remember what we sent, keyed by the §15 ref the runtime echoes in
+        // pipeline_start. This is what lets a reloaded tab put the user's own
+        // words back above the answer instead of "prompt not identified".
+        if (clientRef) daemon.axomRuntimes.recordPrompt(req.params.id, clientRef, text);
+      }
       daemon.audit.log('axom.message', { session: req.params.id, chars: text.length, status: result.status });
       res.status(result.status).json(result.body);
     } catch (err) {
@@ -167,6 +177,13 @@ export function registerAxomRoutes(app, daemon) {
     res.json({ chats: daemon.axomRuntimes.chats() });
   });
 
+  // What GROOVE sent on this session, so a reloaded tab can restore the user's
+  // bubbles. Only ever OUR OWN sends — a turn started from the REPL or another
+  // client has no entry here and must still render without a bubble.
+  app.get('/api/axom/sessions/:id/prompts', (req, res) => {
+    res.json({ prompts: daemon.axomRuntimes.prompts(req.params.id) });
+  });
+
   app.patch('/api/axom/chats/:session', (req, res) => {
     try {
       res.json(daemon.axomRuntimes.renameChat(req.params.session, req.body?.label));

package/node_modules/@groove-dev/daemon/test/axom-connector.test.js

@@ -463,6 +463,47 @@ describe('AxomConnector', () => {
     assert.ok(bridge.epochsSeen.includes('epoch-A')); // we did present the old epoch
   });
 
+  // Streaming answers: deltas are cosmetic chunks superseded by the terminal
+  // `resolution`. They must reach the GUI live but never enter the ring — the
+  // runtime omits them from its own replay, so a backfilled tab and a
+  // reconnecting one must see identical history.
+  it('delivers resolution deltas live but keeps them out of the replay ring', async () => {
+    connect();
+    await waitFor(() => connector.status().endpoints[0]?.status === 'connected');
+    await waitFor(() => connector.status().endpoints[0]?.sessions[0]?.watching);
+
+    bridge.emit('s-test0001', envelope(1, 'pipeline_start'));
+    bridge.emit('s-test0001', envelope(2, 'resolution_delta', { firing_id: 'f1', content: 'Hello ', index: 0 }));
+    bridge.emit('s-test0001', envelope(3, 'resolution_delta', { firing_id: 'f1', content: 'world', index: 1 }));
+    bridge.emit('s-test0001', envelope(4, 'resolution', { content: 'Hello world.' }));
+
+    // Every delta still BROADCASTS — delivery is untouched.
+    await waitFor(() => daemon.broadcasts.filter((b) => b.type === 'axom:event').length === 4);
+    const kinds = daemon.broadcasts.filter((b) => b.type === 'axom:event').map((b) => b.envelope.kind);
+    assert.deepEqual(kinds, ['pipeline_start', 'resolution_delta', 'resolution_delta', 'resolution']);
+
+    // ...but the ring holds only the durable history.
+    const backfill = connector.events('local', 's-test0001');
+    assert.deepEqual(backfill.events.map((e) => e.kind), ['pipeline_start', 'resolution']);
+    // Excluded, not overflowed — dropping them is by design, not pressure.
+    assert.equal(connector.status().endpoints[0].sessions[0].overflow, 0);
+    // A known kind now, so it must not read as schema drift.
+    assert.equal(connector.status().endpoints[0].sessions[0].unknownKinds.resolution_delta, undefined);
+  });
+
+  it('a delta never breaks dedup for the events that follow it', async () => {
+    connect();
+    await waitFor(() => connector.status().endpoints[0]?.status === 'connected');
+    await waitFor(() => connector.status().endpoints[0]?.sessions[0]?.watching);
+    bridge.emit('s-test0001', envelope(1, 'resolution_delta', { firing_id: 'f1', content: 'x', index: 0 }));
+    bridge.emit('s-test0001', envelope(2, 'resolution', { content: 'x!' }));
+    await waitFor(() => daemon.broadcasts.filter((b) => b.type === 'axom:event').length === 2);
+    // Replaying an id at or below the delta's must still be suppressed.
+    bridge.emit('s-test0001', envelope(1, 'resolution_delta', { firing_id: 'f1', content: 'x', index: 0 }));
+    await new Promise((r) => setTimeout(r, 120));
+    assert.equal(daemon.broadcasts.filter((b) => b.type === 'axom:event').length, 2);
+  });
+
   it('recheck collapses a stale connected state the moment the runtime is gone', async () => {
     connect();
     await waitFor(() => connector.status().endpoints[0]?.status === 'connected');

package/node_modules/@groove-dev/daemon/test/axom-runtimes.test.js

@@ -291,6 +291,68 @@ describe('AxomRuntimes', () => {
     assert.equal(model.getChat(session).hidden, true);
   });
 
+  it('titles a chat from its opening message, quoting rather than paraphrasing', async () => {
+    model.add(SSH_RT);
+    daemon.axom.endpoints.set('spark', { status: 'connected', sessions: new Map() });
+    const { session } = await model.hook('spark');
+    assert.match(model.getChat(session).label, /^Chat /); // placeholder to start
+    model.titleFromFirstMessage(session, '  Hey good morning\n  Axom!  ');
+    assert.equal(model.getChat(session).label, 'Hey good morning Axom!');
+    // Only the FIRST message titles it — later turns don't rewrite history.
+    model.titleFromFirstMessage(session, 'something else entirely');
+    assert.equal(model.getChat(session).label, 'Hey good morning Axom!');
+  });
+
+  it('truncates a long opening message visibly and never mid-word', async () => {
+    model.add(SSH_RT);
+    daemon.axom.endpoints.set('spark', { status: 'connected', sessions: new Map() });
+    const { session } = await model.hook('spark');
+    model.titleFromFirstMessage(session, 'Can you walk me through how the memory ledger graduation policy actually works');
+    const { label } = model.getChat(session);
+    assert.ok(label.endsWith('…'));       // truncation is visible, not silent
+    assert.ok(label.length <= 49);
+    assert.doesNotMatch(label, / …$/);     // no dangling space before the ellipsis
+    assert.ok('Can you walk me through how the memory ledger graduation policy actually works'.startsWith(label.slice(0, -1)));
+  });
+
+  it('never lets an auto-title overwrite a name the user chose', async () => {
+    model.add(SSH_RT);
+    daemon.axom.endpoints.set('spark', { status: 'connected', sessions: new Map() });
+    const { session } = await model.hook('spark');
+    model.renameChat(session, 'Ledger work');
+    model.titleFromFirstMessage(session, 'Hey good morning Axom!');
+    assert.equal(model.getChat(session).label, 'Ledger work');
+  });
+
+  // The runtime's pipeline_start carries no prompt text, so the user's words
+  // exist only in GROOVE. Browser-only storage meant a reload replayed turns
+  // from the ring with their bubbles gone — the answer with no question.
+  it('remembers sent prompts by ref so a reloaded tab can restore bubbles', () => {
+    model.recordPrompt('s-1', 'g-aaa', 'Hey good morning Axom!');
+    model.recordPrompt('s-1', 'g-bbb', 'second one');
+    model.recordPrompt('s-2', 'g-ccc', 'other session');
+    assert.deepEqual(model.prompts('s-1').map((p) => p.ref), ['g-aaa', 'g-bbb']);
+    assert.equal(model.prompts('s-1')[0].text, 'Hey good morning Axom!');
+    assert.equal(model.prompts('s-2').length, 1); // sessions never bleed
+    // Survives a fresh model over the same config — that IS the reload case.
+    assert.equal(new AxomRuntimes(daemon).prompts('s-1').length, 2);
+    // Re-recording a ref replaces rather than duplicates.
+    model.recordPrompt('s-1', 'g-aaa', 'Hey good morning Axom!');
+    assert.equal(model.prompts('s-1').length, 2);
+  });
+
+  it('drops a hidden chat\'s prompts with it, and never another chat\'s', async () => {
+    model.add(SSH_RT);
+    daemon.axom.endpoints.set('spark', { status: 'connected', sessions: new Map() });
+    const a = await model.hook('spark');
+    const b = await model.hook('spark');
+    model.recordPrompt(a.session, 'g-a', 'mine');
+    model.recordPrompt(b.session, 'g-b', 'theirs');
+    model.hideChat(a.session);
+    assert.equal(model.prompts(a.session).length, 0);
+    assert.equal(model.prompts(b.session).length, 1);
+  });
+
   it('names the generation holder only when it is a chat we minted', async () => {
     model.add(SSH_RT);
     const sessions = new Map();

package/node_modules/@groove-dev/daemon/test/chatstore.test.js

@@ -81,13 +81,16 @@ describe('ChatStore', () => {
     assert.equal(store.getAll()['ghost-id'][0].text, 'unresolvable');
   });
 
-  it('view() keys live agents by CURRENT id and parks the rest by name', () => {
+  it('view() keys live agents by CURRENT id and omits departed ones', () => {
     store.append('a1', { from: 'user', text: 'live', timestamp: 1 });
     store.history['departed-agent'] = [{ from: 'user', text: 'old', timestamp: 2 }];
     const v = store.view();
     assert.equal(v.a1[0].text, 'live');            // fullstack-1 → its live id
     assert.equal(v['fullstack-1'], undefined);
-    assert.equal(v['departed-agent'][0].text, 'old'); // no live agent — name key
+    // Departed agents stay on disk but are not shipped — the payload used to
+    // be 97% dead agents, which blew the browser's localStorage quota.
+    assert.equal(v['departed-agent'], undefined);
+    assert.equal(store.getAll()['departed-agent'][0].text, 'old');
   });
 
   it('merge() is a union — a sparse client can never truncate server history', () => {
@@ -176,3 +179,65 @@ describe('mergeMessages', () => {
     assert.equal(merged.length, 2);
   });
 });
+
+describe('ChatStore — agent-reply persistence regression', () => {
+  let dir, daemon, store;
+
+  beforeEach(() => {
+    dir = mkdtempSync(resolve(tmpdir(), 'groove-chat-reg-'));
+    daemon = makeDaemon([{ id: 'live1', name: 'fullstack-1' }]);
+    daemon.grooveDir = dir;
+    store = new ChatStore(daemon);
+  });
+  afterEach(() => {
+    store.stop();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('upserts a coalescing streamed reply instead of accumulating fragments', () => {
+    // The GUI grows one message as chunks stream in, keeping its id.
+    store.merge('live1', [{ id: 'm1', from: 'agent', text: 'Part one', timestamp: 10 }]);
+    store.merge('live1', [{ id: 'm1', from: 'agent', text: 'Part one\n\nPart two', timestamp: 11 }]);
+    store.merge('live1', [{ id: 'm1', from: 'agent', text: 'Part one\n\nPart two\n\nPart three', timestamp: 12 }]);
+
+    const h = store.get('live1');
+    assert.equal(h.length, 1, 'one message, not one per chunk');
+    assert.equal(h[0].text, 'Part one\n\nPart two\n\nPart three');
+  });
+
+  it('never regresses a message to an earlier, shorter state', () => {
+    store.merge('live1', [{ id: 'm1', from: 'agent', text: 'full long reply', timestamp: 20 }]);
+    store.merge('live1', [{ id: 'm1', from: 'agent', text: 'full', timestamp: 19 }]); // stale client
+    assert.equal(store.get('live1')[0].text, 'full long reply');
+  });
+
+  it('view() ships only live agents — dead buckets stay on disk but off the wire', () => {
+    store.append('live1', { id: 'a', from: 'agent', text: 'hi', timestamp: 1 });
+    store.history['long-gone-agent'] = [{ id: 'b', from: 'agent', text: 'old', timestamp: 2 }];
+
+    const v = store.view();
+    assert.deepEqual(Object.keys(v), ['live1'], 'payload carries live agents only');
+    assert.ok(store.getAll()['long-gone-agent'], 'but the data is retained on disk');
+  });
+
+  it('a respawned agent with the same name picks its history back up', () => {
+    store.append('live1', { id: 'a', from: 'agent', text: 'earlier work', timestamp: 1 });
+    // Agent dies and is later recreated with a different id, same name.
+    daemon.registry.delete('live1');
+    daemon.registry.set({ id: 'live1-new', name: 'fullstack-1' });
+    assert.equal(store.view()['live1-new'][0].text, 'earlier work');
+  });
+
+  it('prune() bounds dead buckets and never touches live agents', () => {
+    store.append('live1', { id: 'a', from: 'agent', text: 'keep me', timestamp: 999 });
+    for (let i = 0; i < 10; i++) {
+      store.history[`dead-${i}`] = [{ id: `d${i}`, from: 'agent', text: 'x', timestamp: i }];
+    }
+    const removed = store.prune(4);
+    assert.equal(removed, 6);
+    assert.equal(store.get('live1')[0].text, 'keep me');
+    assert.equal(Object.keys(store.getAll()).filter((k) => k.startsWith('dead-')).length, 4);
+    // The survivors are the most recently active dead buckets.
+    assert.ok(store.getAll()['dead-9'] && !store.getAll()['dead-0']);
+  });
+});