groove-dev 0.27.210 → 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.210",
+  "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.210",
+  "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/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/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/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']);
+  });
+});