groove-dev 0.27.206 → 0.27.208

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

@@ -58,6 +58,7 @@ import { AxomConnector } from './axom-connector.js';
 import { AxomServerManager } from './axom-server.js';
 import { AxomInstaller } from './axom-install.js';
 import { AxomRemote } from './axom-remote.js';
+import { AxomRuntimes } from './axom-runtimes.js';
 import { setProviderPaths } from './providers/index.js';
 
 const DEFAULT_PORT = 31415;
@@ -175,6 +176,7 @@ export class Daemon {
     this.axomServer = new AxomServerManager(this);
     this.axomInstaller = new AxomInstaller(this);
     this.axomRemote = new AxomRemote(this);
+    this.axomRuntimes = new AxomRuntimes(this);
     this.trajectoryCapture = null;
 
     // Hook teams.delete to clean up agent-loop session files
@@ -438,6 +440,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) {
@@ -636,10 +644,17 @@ export class Daemon {
         this.orchestrator.start();
         this.timeline.start();
         this.gateways.start();
-        this.axom.start();
+        this.axomRuntimes.start();
         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/axom.js

@@ -122,6 +122,79 @@ export function registerAxomRoutes(app, daemon) {
     }
   });
 
+  // ── Runtimes — the one entity (plans/axom-runtime-flow-redesign.md) ─────
+  // The GUI reasons about runtimes only; endpoints/instances/ssh are backends.
+
+  app.get('/api/axom/runtimes', async (req, res) => {
+    res.json(await daemon.axomRuntimes.status());
+  });
+
+  app.post('/api/axom/runtimes', (req, res) => {
+    try {
+      const rt = daemon.axomRuntimes.add(req.body);
+      if (req.body?.activate) daemon.axomRuntimes.activate(rt.id);
+      daemon.audit.log('axom.runtime.add', { id: rt.id, control: rt.control });
+      res.json(rt);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.patch('/api/axom/runtimes/:id', (req, res) => {
+    try {
+      res.json(daemon.axomRuntimes.update(req.params.id, req.body || {}));
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/axom/runtimes/:id', (req, res) => {
+    try {
+      daemon.axomRuntimes.remove(req.params.id);
+      daemon.audit.log('axom.runtime.remove', { id: req.params.id });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/axom/runtimes/:id/activate', (req, res) => {
+    try {
+      daemon.axomRuntimes.activate(req.params.id);
+      res.json({ ok: true, activeRuntimeId: req.params.id });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/axom/runtimes/:id/start', async (req, res) => {
+    try {
+      const result = await daemon.axomRuntimes.startRuntime(req.params.id);
+      daemon.audit.log('axom.runtime.start', { id: req.params.id });
+      res.json(result);
+    } catch (err) {
+      res.status(502).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/axom/runtimes/:id/stop', async (req, res) => {
+    try {
+      const result = await daemon.axomRuntimes.stopRuntime(req.params.id, { force: !!req.body?.force });
+      daemon.audit.log('axom.runtime.stop', { id: req.params.id });
+      res.json(result);
+    } catch (err) {
+      res.status(502).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/axom/runtimes/:id/heal', async (req, res) => {
+    try {
+      res.json(await daemon.axomRuntimes.heal(req.params.id));
+    } catch (err) {
+      res.status(502).json({ error: err.message });
+    }
+  });
+
   // ── Remote runtime control over SSH (manual only, never automatic) ──────
 
   app.get('/api/axom/remote', async (req, res) => {

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/src/routes/watch.js

@@ -20,6 +20,17 @@ export function registerWatchRoutes(app, daemon) {
       if (!who) return res.status(404).json({ error: `Unknown agent: ${agent}` });
 
       const watch = daemon.watcher.create(who.id, { command, until, label, timeoutMs, intervalMs });
+      if (watch.reattached) {
+        return res.json({
+          ok: true,
+          watchId: watch.id,
+          reattached: true,
+          message: `That command is ALREADY RUNNING under watch ${watch.id} ("${watch.label}") — `
+            + 'this request re-attached to it instead of starting a second copy. '
+            + 'Do NOT launch it again by hand. You will be resumed with the result when it finishes; '
+            + 'you can end your turn now.',
+        });
+      }
       res.json({
         ok: true,
         watchId: watch.id,

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

@@ -59,6 +59,28 @@ export class Watcher {
     if (!command && !until) throw new Error('Provide either "command" (run it) or "until" (poll it)');
     if (command && until) throw new Error('Provide only one of "command" or "until"');
 
+    // Re-attach, never re-execute. A daemon restart resumes the agent mid-turn,
+    // so it re-issues the watch it thinks never completed — and a second copy of
+    // a long job (training, benchmark) launched against the same working dir
+    // corrupts the first one's output and competes for the GPU. If an identical
+    // command is still running for this agent, hand back the existing watch.
+    // This is the daemon-side equivalent of an flock, and it has to live here
+    // because the agent cannot know a duplicate already exists.
+    if (command) {
+      const dup = [...this.watches.values()].find(
+        (w) => w.status === 'active'
+          && w.mode === 'command'
+          && w.command === command
+          && (w.agentName === agent.name || w.agentId === agentId)
+          && this._jobAlive(w),
+      );
+      if (dup) {
+        this.daemon.audit?.log('watch.duplicate', { id: dup.id, agent: agentId, label: dup.label });
+        console.log(`[Groove:Watcher] Re-attached to running watch ${dup.id} instead of re-running: ${dup.label}`);
+        return { ...this._public(dup), reattached: true };
+      }
+    }
+
     const active = [...this.watches.values()].filter((w) => w.agentId === agentId && w.status === 'active');
     if (active.length >= MAX_WATCHES_PER_AGENT) {
       throw new Error(`You already have ${MAX_WATCHES_PER_AGENT} active watches — cancel one before adding another`);
@@ -118,11 +140,14 @@ export class Watcher {
     // Run the command in a SUBSHELL so its own `exit N` can't kill the wrapper
     // before the sentinel is written; tee output to a file, then atomically
     // publish the exit code so the poller never sees a half-written value.
+    // Append rather than truncate: if this script is ever run twice, `>` would
+    // erase the first run's record — exactly the evidence you need to work out
+    // what happened. Appending keeps both.
     const script = [
       '#!/bin/sh',
       '(',
       watch.command,
-      `) > ${shq(watch.outFile)} 2>&1`,
+      `) >> ${shq(watch.outFile)} 2>&1`,
       `echo $? > ${shq(watch.statusFile)}.tmp && mv ${shq(watch.statusFile)}.tmp ${shq(watch.statusFile)}`,
       '',
     ].join('\n');
@@ -143,6 +168,16 @@ export class Watcher {
     }
   }
 
+  // Is this watch's detached job still running? Signal 0 tests for existence
+  // without delivering anything. A finished job (sentinel present) is not alive
+  // even if the pid happens to have been recycled by another process.
+  _jobAlive(watch) {
+    if (watch.mode !== 'command') return false;
+    if (watch.statusFile && existsSync(watch.statusFile)) return false; // already exited
+    if (!watch.pid) return false;
+    try { process.kill(watch.pid, 0); return true; } catch { return false; }
+  }
+
   // One poll iteration — checks for completion (sentinel for command mode, the
   // `until` command for until mode) and wakes the agent when it's met.
   _tick(watch) {
@@ -257,6 +292,7 @@ export class Watcher {
     if (!Array.isArray(data)) return 0;
 
     let rearmed = 0;
+    let lost = 0;
     const now = Date.now();
     for (const w of data) {
       // Drop stale finished watches; keep recent ones for history.
@@ -268,10 +304,27 @@ export class Watcher {
       }
       const watch = { ...w, _poll: null, _deadline: null };
       this.watches.set(watch.id, watch);
+
+      // A command watch whose job is gone with no exit sentinel died while the
+      // daemon was down. Polling it would just burn until the timeout and then
+      // report "may still be running" — say what actually happened instead.
+      if (watch.mode === 'command' && watch.pid
+          && !existsSync(watch.statusFile || '') && !this._jobAlive(watch)) {
+        lost++;
+        this._wake(watch, {
+          outcome: 'error',
+          summary: `The job for "${watch.label}" is no longer running and never recorded an exit code — `
+            + 'it was lost while the daemon was down. Check its output before assuming it finished.',
+          output: tailFile(watch.outFile, OUTPUT_TAIL),
+        });
+        continue;
+      }
+
       this._arm(watch);
       rearmed++;
     }
-    if (rearmed > 0) console.log(`[Groove:Watcher] Restored ${rearmed} active watch(es) after restart`);
+    if (rearmed > 0) console.log(`[Groove:Watcher] Re-attached to ${rearmed} running watch(es) after restart`);
+    if (lost > 0) console.log(`[Groove:Watcher] ${lost} watch(es) lost their job while the daemon was down`);
     this._persist();
     return rearmed;
   }

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

@@ -34,6 +34,8 @@ class MockBridge {
     this.shutdowns = [];
     this.messages = [];
     this.sinceSeen = []; // ?since values observed on WS connects
+    this.epochsSeen = [];
+    this.epoch = 'epoch-A';
     this.sockets = new Set();
   }
 
@@ -50,8 +52,12 @@ class MockBridge {
         ws.on('close', () => this.sockets.delete(ws));
         const since = url.searchParams.get('since');
         this.sinceSeen.push(since);
+        this.epochsSeen.push(url.searchParams.get('epoch'));
+        // §16.4: hello first; a stale client epoch voids `since` (full replay).
+        ws.send(JSON.stringify({ kind: 'ws_hello', payload: { epoch: this.epoch, since_honored: url.searchParams.get('epoch') === this.epoch } }));
+        const staleEpoch = url.searchParams.get('epoch') && url.searchParams.get('epoch') !== this.epoch;
         // Ring replay: everything after `since`, then live.
-        const from = since ? parseInt(since.slice(3), 10) : 0;
+        const from = (since && !staleEpoch) ? parseInt(since.slice(3), 10) : 0;
         for (const e of session.events) {
           if (parseInt(e.id.slice(3), 10) > from) ws.send(JSON.stringify(e));
         }
@@ -435,6 +441,43 @@ describe('AxomConnector', () => {
     assert.equal(latest.data.endpoints[0].sessions[0].live, false);
   });
 
+  it('§16.4: a changed epoch resets the cursor — a runtime restart is replayed, never swallowed', async () => {
+    connect();
+    await waitFor(() => connector.status().endpoints[0]?.sessions[0]?.watching);
+    bridge.emit('s-test0001', envelope(1, 'pipeline_start'));
+    bridge.emit('s-test0001', envelope(2, 'thought'));
+    await waitFor(() => daemon.broadcasts.filter((b) => b.type === 'axom:event').length === 2);
+
+    // Runtime "restarts": new epoch, event ids reset to 1, fresh history.
+    bridge.epoch = 'epoch-B';
+    bridge.sessions['s-test0001'].events = [envelope(1, 'pipeline_start', { fresh: true }), envelope(2, 'narration', { text: 'post-restart' })];
+    bridge.sessions['s-test0001'].socket.terminate();
+
+    // Reconnect: our epoch-A + since goes up, hello says epoch-B → we reset
+    // and take the full replay. Without the reset, monotonic dedup would
+    // silently drop both replayed events (ids <= lastSeq).
+    await waitFor(() => daemon.broadcasts.some((b) => b.type === 'axom:session:reset'), 5000);
+    await waitFor(() => daemon.broadcasts.filter((b) => b.type === 'axom:event' && b.envelope.payload?.fresh).length === 1, 5000);
+    const s = connector.status().endpoints[0].sessions[0];
+    assert.equal(s.buffered, 2); // the ring holds ONLY post-restart history
+    assert.ok(bridge.epochsSeen.includes('epoch-A')); // we did present the old epoch
+  });
+
+  it('recheck collapses a stale connected state the moment the runtime is gone', async () => {
+    connect();
+    await waitFor(() => connector.status().endpoints[0]?.status === 'connected');
+    daemon.broadcasts.length = 0;
+
+    // Runtime dies (a deliberate stop); without recheck the endpoint would
+    // stay 'connected' until the next scheduled session poll failed.
+    await bridge.close();
+    connector.recheck('local');
+    await waitFor(() => connector.status().endpoints[0]?.status === 'error');
+    // The transition broadcast rode the recheck — the GUI card moves with
+    // the verb, not with a poll.
+    assert.ok(daemon.broadcasts.some((b) => b.type === 'axom:status'));
+  });
+
   it('reports an unreachable endpoint honestly and recovers by retry', async () => {
     const deadUrl = bridge.url;
     const port = Number(new URL(deadUrl).port);