groove-dev 0.27.206 → 0.27.207

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.206",
+  "version": "0.27.207",
   "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.206",
+  "version": "0.27.207",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -9,14 +9,21 @@ const MAX_PER_AGENT = 200;
 const SAVE_DEBOUNCE_MS = 1500;
 
 /**
- * Server-side chat history.
+ * Server-side chat history, keyed by AGENT NAME.
  *
- * The GUI used to keep chat history only in the browser's localStorage, which
- * is scoped per origin (scheme://host:PORT). For a remote GUI reached over an
- * SSH tunnel the local port changes across reconnects, so the origin — and thus
- * the entire chat store — changed out from under the user, stranding history on
- * old ports. Keeping it on the daemon makes it independent of port, origin, and
- * even which machine connects: reconnect from anywhere and the chats are there.
+ * Two hard-won identity lessons live here:
+ *
+ * 1. localStorage is per-origin (scheme://host:PORT), and a tunnelled GUI's
+ *    port changes across reconnects — so history kept only in the browser gets
+ *    stranded on dead origins. Hence a server-side store at all.
+ *
+ * 2. Agent IDs are NOT stable: every rotation/resume mints a new id. A store
+ *    keyed by id fragments on every rotation — the full history stays under
+ *    the dead id while the new id starts near-empty, and a reconnect then
+ *    "restores" that near-empty stub over the user's real history. The agent
+ *    NAME survives rotation (the Watch system keys by name for the same
+ *    reason), so name is the identity here. IDs are accepted at the API edge
+ *    and resolved immediately.
  */
 export class ChatStore {
   constructor(daemon) {
@@ -36,6 +43,50 @@ export class ChatStore {
     return {};
   }
 
+  // Resolve an id-or-name to the stable storage key (the agent's name).
+  // Unknown refs are used verbatim so nothing is ever dropped — an orphaned
+  // id key re-merges at boot once its agent is known, or stays parked.
+  _keyFor(ref) {
+    if (!ref) return null;
+    const byId = this.daemon.registry?.get?.(ref);
+    if (byId?.name) return byId.name;
+    return String(ref);
+  }
+
+  /**
+   * Fold any id-keyed entries into their agent's name key. Runs at boot (after
+   * registry restore) so stores written by the old id-keyed code reattach to
+   * the agent wherever the id is still resolvable.
+   */
+  migrate() {
+    const agents = this.daemon.registry?.getAll?.() || [];
+    const byId = new Map(agents.map((a) => [a.id, a]));
+    let moved = 0;
+    for (const key of Object.keys(this.history)) {
+      const agent = byId.get(key);
+      if (!agent || agent.name === key) continue;
+      this.history[agent.name] = mergeMessages(this.history[agent.name], this.history[key]);
+      delete this.history[key];
+      moved += 1;
+    }
+    if (moved) this._scheduleSave();
+    return moved;
+  }
+
+  /**
+   * Rotation-time hook: an entry parked under a dead id (written by the old
+   * id-keyed code, or by an old GUI posting under ids) follows the agent to
+   * its new identity.
+   */
+  remap(oldRef, newRef) {
+    const oldKey = String(oldRef);
+    const newKey = this._keyFor(newRef);
+    if (!newKey || oldKey === newKey || !this.history[oldKey]) return;
+    this.history[newKey] = mergeMessages(this.history[newKey], this.history[oldKey]);
+    delete this.history[oldKey];
+    this._scheduleSave();
+  }
+
   _scheduleSave() {
     if (this._saveTimer) return;
     this._saveTimer = setTimeout(() => {
@@ -64,35 +115,59 @@ export class ChatStore {
     return out;
   }
 
-  append(agentId, message) {
-    if (!agentId) return;
+  append(ref, message) {
+    const key = this._keyFor(ref);
+    if (!key) return;
     const clean = this._clean(message);
     if (!clean) return;
-    const arr = this.history[agentId] || [];
+    const arr = this.history[key] || [];
     arr.push(clean);
-    this.history[agentId] = arr.slice(-MAX_PER_AGENT);
+    this.history[key] = arr.slice(-MAX_PER_AGENT);
     this._scheduleSave();
   }
 
-  // Replace an agent's whole history — used when the GUI syncs a batch (e.g.
-  // messages it recorded while briefly disconnected).
-  replace(agentId, messages) {
-    if (!agentId || !Array.isArray(messages)) return;
-    this.history[agentId] = messages.map((m) => this._clean(m)).filter(Boolean).slice(-MAX_PER_AGENT);
+  /**
+   * Merge a batch from a client. This is a UNION by (timestamp, from, text) —
+   * never a replace — so a browser holding messages the server missed adds
+   * them, and a browser with less than the server can never truncate it.
+   * A "restore" must be incapable of destroying what it restores from.
+   */
+  merge(ref, messages) {
+    const key = this._keyFor(ref);
+    if (!key || !Array.isArray(messages)) return;
+    const incoming = messages.map((m) => this._clean(m)).filter(Boolean);
+    this.history[key] = mergeMessages(this.history[key], incoming);
     this._scheduleSave();
   }
 
+  /**
+   * 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.
+   */
+  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;
+    }
+    return out;
+  }
+
   getAll() {
     return this.history;
   }
 
-  get(agentId) {
-    return this.history[agentId] || [];
+  get(ref) {
+    return this.history[this._keyFor(ref)] || [];
   }
 
-  remove(agentId) {
-    if (this.history[agentId]) {
-      delete this.history[agentId];
+  remove(ref) {
+    const key = this._keyFor(ref);
+    if (key && this.history[key]) {
+      delete this.history[key];
       this._scheduleSave();
     }
   }
@@ -102,3 +177,19 @@ export class ChatStore {
     this._saveNow();
   }
 }
+
+// Union of two message arrays, deduped on (timestamp, from, text), time-sorted,
+// capped. Exported for tests and the migration path.
+export function mergeMessages(a, b) {
+  const seen = new Set();
+  const out = [];
+  for (const m of [...(a || []), ...(b || [])]) {
+    if (!m || typeof m !== 'object') continue;
+    const sig = `${m.timestamp}:${m.from}:${typeof m.text === 'string' ? m.text.slice(0, 200) : ''}`;
+    if (seen.has(sig)) continue;
+    seen.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

@@ -438,6 +438,12 @@ export class Daemon {
   }
 
   broadcast(message) {
+    // Every rotation/resume path announces itself here — the one chokepoint
+    // for "this agent has a new id". Chat history parked under the dead id
+    // (stale client posts, pre-migration data) follows the agent.
+    if (message.type === 'rotation:complete' && message.oldAgentId && message.agentId) {
+      try { this.chatStore.remap(message.oldAgentId, message.agentId); } catch { /* best effort */ }
+    }
     if (!this.wss) return;
     const payload = JSON.stringify(message);
     for (const client of this.wss.clients) {
@@ -640,6 +646,13 @@ export class Daemon {
         this.federation.initialize();
         this._startGarbageCollector();
 
+        // Fold id-keyed chat history into name keys now that the registry is
+        // restored — reattaches histories written by the old id-keyed store.
+        try {
+          const moved = this.chatStore.migrate();
+          if (moved) console.log(`[chat] migrated ${moved} id-keyed histories to agent names`);
+        } catch { /* best effort */ }
+
         // Regenerate the on-disk registry files once on boot. They otherwise
         // only refresh on a registry change, so a daemon upgraded with new
         // agent-facing docs (InnerChat, Watch) would serve stale AGENTS_REGISTRY.md

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

@@ -89,6 +89,10 @@ export function registerAgentRoutes(app, daemon) {
       // Killed/completed agents stay visible so the user can review output.
       const purge = req.query.purge === 'true';
       if (purge) {
+        // Clear chat history while the id still resolves to a name — the
+        // store is name-keyed, and a purged name's history must not haunt a
+        // future agent spawned under the same name.
+        try { daemon.chatStore.remove(agent.name); } catch { /* best effort */ }
         daemon.registry.remove(req.params.id);
       }
 

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

@@ -4,7 +4,9 @@ export function registerChatHistoryRoutes(app, daemon) {
   // Full history for all agents — the GUI loads this on connect so chats are
   // present regardless of which origin/port the tunnel came up on.
   app.get('/api/chat-history', (req, res) => {
-    res.json({ history: daemon.chatStore.getAll() });
+    // view() keys live agents by their CURRENT id — ids churn on rotation, so
+    // the store itself is name-keyed and this translates at the edge.
+    res.json({ history: daemon.chatStore.view() });
   });
 
   // Append a single message for an agent.
@@ -17,13 +19,14 @@ export function registerChatHistoryRoutes(app, daemon) {
     res.json({ ok: true });
   });
 
-  // Replace an agent's whole history (batch sync).
+  // Batch sync from a client. A UNION, deliberately not a replace — a client
+  // can add messages the server missed but can never truncate server history.
   app.put('/api/chat-history/:agentId', (req, res) => {
     const { messages } = req.body || {};
     if (!Array.isArray(messages)) {
       return res.status(400).json({ error: 'messages array required' });
     }
-    daemon.chatStore.replace(req.params.agentId, messages);
+    daemon.chatStore.merge(req.params.agentId, messages);
     res.json({ ok: true });
   });
 

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

@@ -6,28 +6,101 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { resolve } from 'path';
-import { ChatStore } from '../src/chatstore.js';
+import { ChatStore, mergeMessages } from '../src/chatstore.js';
+
+// Minimal registry: id -> {id, name}. Lets tests exercise the id→name
+// resolution that makes history survive rotation.
+function makeDaemon(agents = []) {
+  const map = new Map(agents.map((a) => [a.id, a]));
+  return {
+    grooveDir: null, // set per test
+    registry: {
+      _map: map,
+      get(id) { return map.get(id) || null; },
+      getAll() { return [...map.values()]; },
+      set(a) { map.set(a.id, a); },
+      delete(id) { map.delete(id); },
+    },
+  };
+}
 
 describe('ChatStore', () => {
-  let dir, store;
+  let dir, daemon, store;
 
   beforeEach(() => {
     dir = mkdtempSync(resolve(tmpdir(), 'groove-chat-'));
-    store = new ChatStore({ grooveDir: dir });
+    daemon = makeDaemon([{ id: 'a1', name: 'fullstack-1' }, { id: 'a2', name: 'planner-1' }]);
+    daemon.grooveDir = dir;
+    store = new ChatStore(daemon);
   });
   afterEach(() => {
     store.stop();
     try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
   });
 
-  it('appends and returns per-agent history', () => {
+  it('appends under the agent NAME when given an id', () => {
     store.append('a1', { from: 'user', text: 'hello', timestamp: 1 });
-    store.append('a1', { from: 'agent', text: 'hi', timestamp: 2 });
-    store.append('a2', { from: 'user', text: 'other', timestamp: 3 });
+    store.append('fullstack-1', { from: 'agent', text: 'hi', timestamp: 2 });
+
+    // Both routes land in one bucket — the name.
+    assert.deepEqual(store.get('a1').map((m) => m.text), ['hello', 'hi']);
+    assert.deepEqual(store.getAll()['fullstack-1'].map((m) => m.text), ['hello', 'hi']);
+    assert.equal(store.getAll().a1, undefined);
+  });
+
+  it('history survives rotation: new id, same name, same history', () => {
+    store.append('a1', { from: 'user', text: 'before rotation', timestamp: 1 });
+
+    // Rotation mints a new id; the name is stable.
+    daemon.registry.delete('a1');
+    daemon.registry.set({ id: 'a1-r9', name: 'fullstack-1' });
+
+    store.append('a1-r9', { from: 'agent', text: 'after rotation', timestamp: 2 });
+    assert.deepEqual(store.get('a1-r9').map((m) => m.text), ['before rotation', 'after rotation']);
+  });
+
+  it('remap() folds a dead-id entry into the live agent', () => {
+    // Simulates data written under an id while the registry didn't know it
+    // (stale client post mid-rotation) — the rotation:complete hook remaps it.
+    store.history['dead-id'] = [{ from: 'user', text: 'stranded', timestamp: 1 }];
+    store.remap('dead-id', 'a1');
+    assert.equal(store.history['dead-id'], undefined);
+    assert.deepEqual(store.get('a1').map((m) => m.text), ['stranded']);
+  });
+
+  it('migrate() reattaches id-keyed histories from the old store format', () => {
+    store.history = {
+      a1: [{ from: 'user', text: 'legacy', timestamp: 1 }],
+      'fullstack-1': [{ from: 'agent', text: 'current', timestamp: 2 }],
+      'ghost-id': [{ from: 'user', text: 'unresolvable', timestamp: 3 }],
+    };
+    const moved = store.migrate();
+    assert.equal(moved, 1);
+    assert.deepEqual(store.getAll()['fullstack-1'].map((m) => m.text), ['legacy', 'current']);
+    // Unresolvable keys are parked, never dropped.
+    assert.equal(store.getAll()['ghost-id'][0].text, 'unresolvable');
+  });
 
-    assert.equal(store.get('a1').length, 2);
-    assert.equal(store.get('a2').length, 1);
-    assert.deepEqual(store.getAll().a1.map((m) => m.text), ['hello', 'hi']);
+  it('view() keys live agents by CURRENT id and parks the rest by name', () => {
+    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
+  });
+
+  it('merge() is a union — a sparse client can never truncate server history', () => {
+    for (let i = 0; i < 10; i++) store.append('a1', { from: 'user', text: `m${i}`, timestamp: i });
+    // Client syncs only 2 messages (1 duplicate, 1 new).
+    store.merge('a1', [
+      { from: 'user', text: 'm3', timestamp: 3 },
+      { from: 'agent', text: 'fresh', timestamp: 99 },
+    ]);
+    const texts = store.get('a1').map((m) => m.text);
+    assert.equal(texts.length, 11);
+    assert.equal(texts.at(-1), 'fresh');
+    assert.ok(texts.includes('m0') && texts.includes('m9'));
   });
 
   it('strips attachment data URLs but keeps metadata', () => {
@@ -44,7 +117,7 @@ describe('ChatStore', () => {
     store.append('a1', { from: 'user', text: 'durable', timestamp: 1 });
     store.stop(); // flushes synchronously
 
-    const reloaded = new ChatStore({ grooveDir: dir });
+    const reloaded = new ChatStore(daemon);
     assert.equal(reloaded.get('a1')[0].text, 'durable');
     reloaded.stop();
   });
@@ -55,7 +128,7 @@ describe('ChatStore', () => {
     assert.ok(existsSync(resolve(dir, 'chat-history.json')));
     assert.ok(!existsSync(resolve(dir, 'chat-history.json.tmp')));
     const onDisk = JSON.parse(readFileSync(resolve(dir, 'chat-history.json'), 'utf8'));
-    assert.equal(onDisk.a1[0].text, 'x');
+    assert.equal(onDisk['fullstack-1'][0].text, 'x');
   });
 
   it('caps per-agent history', () => {
@@ -66,21 +139,40 @@ describe('ChatStore', () => {
     assert.equal(h.at(-1).text, 'm249');
   });
 
-  it('replace() swaps an agent history wholesale', () => {
-    store.append('a1', { from: 'user', text: 'old' });
-    store.replace('a1', [{ from: 'user', text: 'new1' }, { from: 'agent', text: 'new2' }]);
-    assert.deepEqual(store.get('a1').map((m) => m.text), ['new1', 'new2']);
-  });
-
-  it('remove() deletes an agent history', () => {
+  it('remove() deletes by name so a purge cannot haunt a future same-name agent', () => {
     store.append('a1', { from: 'user', text: 'x' });
-    store.remove('a1');
+    store.remove('fullstack-1');
     assert.equal(store.get('a1').length, 0);
   });
 
+  it('works without a registry (refs pass through verbatim)', () => {
+    const bare = new ChatStore({ grooveDir: mkdtempSync(resolve(tmpdir(), 'groove-chat-bare-')) });
+    bare.append('some-id', { from: 'user', text: 'x', timestamp: 1 });
+    assert.equal(bare.get('some-id')[0].text, 'x');
+    bare.stop();
+  });
+
   it('starts empty when the file is missing or corrupt', () => {
     const empty = new ChatStore({ grooveDir: mkdtempSync(resolve(tmpdir(), 'groove-chat-empty-')) });
     assert.deepEqual(empty.getAll(), {});
     empty.stop();
   });
 });
+
+describe('mergeMessages', () => {
+  it('dedupes on (timestamp, from, text) and sorts by time', () => {
+    const merged = mergeMessages(
+      [{ from: 'u', text: 'b', timestamp: 2 }, { from: 'u', text: 'a', timestamp: 1 }],
+      [{ from: 'u', text: 'a', timestamp: 1 }, { from: 'u', text: 'c', timestamp: 3 }],
+    );
+    assert.deepEqual(merged.map((m) => m.text), ['a', 'b', 'c']);
+  });
+
+  it('treats same text at different timestamps as distinct messages', () => {
+    const merged = mergeMessages(
+      [{ from: 'u', text: 'ok', timestamp: 1 }],
+      [{ from: 'u', text: 'ok', timestamp: 2 }],
+    );
+    assert.equal(merged.length, 2);
+  });
+});