groove-dev 0.27.209 → 0.27.210

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

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

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/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-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();