groove-dev 0.27.205 → 0.27.207

package/node_modules/@groove-dev/gui/dist/index.html

@@ -6,7 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="icon" type="image/png" href="/favicon.png" />
     <title>Groove GUI</title>
-    <script type="module" crossorigin src="/assets/index-vrFP3bO0.js"></script>
+    <script type="module" crossorigin src="/assets/index-OzNfp6-Y.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-26L3JoZv.js">
     <link rel="modulepreload" crossorigin href="/assets/reactflow-DoBZjiHE.js">
     <link rel="modulepreload" crossorigin href="/assets/codemirror-BYKpdS2W.js">

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/gui",
-  "version": "0.27.205",
+  "version": "0.27.207",
   "description": "GROOVE GUI — visual agent control plane",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groove-dev",
-  "version": "0.27.205",
+  "version": "0.27.207",
   "description": "Open-source agent orchestration layer — the AI company OS. Local model agent engine (GGUF/Ollama/llama-server), HuggingFace model browser, MCP integrations (Slack, Gmail, Stripe, 15+), agent scheduling (cron), business roles (CMO, CFO, EA). GUI dashboard, multi-agent coordination, zero cold-start, infinite sessions. Works with Claude Code, Codex, Gemini CLI, Ollama, any local model.",
   "license": "FSL-1.1-Apache-2.0",
   "author": "Groove Dev <hello@groovedev.ai> (https://groovedev.ai)",

package/packages/cli/package.json

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

package/packages/daemon/package.json

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

package/packages/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/packages/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/packages/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/packages/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 });
   });