groove-dev 0.27.208 → 0.27.210

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.208",
+  "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.208",
+  "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

@@ -20,6 +20,41 @@ import { validateEndpoint } from './axom-connector.js';
 import { validateRemote } from './axom-remote.js';
 import { saveConfig } from './firstrun.js';
 
+// The blessed launch spec's env (SPARK_DEV_SETUP.md / §10). These change
+// runtime BEHAVIOUR, not just paths — a spec missing AXOM_MAX_CTX boots a
+// 2048-ctx runtime that looks fine and answers worse. Applied as DEFAULTS
+// only: a value the user set in their own spec always wins, because "GROOVE
+// never edits a spec's flags" is the standing ruling.
+export const BLESSED_ENV = { AXOM_MAX_CTX: '8192' };
+
+function withBlessedEnv(launch) {
+  if (!launch?.command) return 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.
+function shellQuote(s) {
+  return `'${String(s).replace(/'/g, `'\\''`)}'`;
+}
+
 export function validateRuntime(rt) {
   if (!rt || typeof rt !== 'object') return 'runtime must be an object';
   if (!rt.id || !/^[a-zA-Z0-9_-]{1,40}$/.test(rt.id)) return 'invalid runtime id';
@@ -39,6 +74,18 @@ export function validateRuntime(rt) {
       || rt.launch.command.length === 0 || rt.launch.command.length > 500) {
       return 'launch.command must be a non-empty string of at most 500 chars';
     }
+    if (rt.launch.cwd !== undefined && typeof rt.launch.cwd !== 'string') {
+      return 'launch.cwd must be a string';
+    }
+    if (rt.launch.env !== undefined) {
+      if (typeof rt.launch.env !== 'object' || rt.launch.env === null || Array.isArray(rt.launch.env)) {
+        return 'launch.env must be an object of name/value pairs';
+      }
+      for (const [k, v] of Object.entries(rt.launch.env)) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) return `invalid env var name "${k}"`;
+        if (typeof v !== 'string' && typeof v !== 'number') return `env var "${k}" must be a string or number`;
+      }
+    }
   }
   return null;
 }
@@ -74,13 +121,26 @@ export class AxomRuntimes {
   // are kept until the model proves out — compat routes still read them.
   migrate() {
     const cfg = this._cfg();
-    if (Array.isArray(cfg.runtimes)) return false;
+    // Marker, not mere presence of the array: an earlier migration could write
+    // an EMPTY runtimes[] and then never retry, stranding a configured host
+    // behind a first-run splash forever. Re-run until it produces something or
+    // there is genuinely nothing legacy left to fold.
+    if (cfg.runtimesMigrated) return false;
+    if (Array.isArray(cfg.runtimes) && cfg.runtimes.length) {
+      cfg.runtimesMigrated = true;
+      return false;
+    }
     const runtimes = [];
     const remote = cfg.remote || null;
     const ep = (cfg.endpoints || [])[0] || null;
-    if (ep && remote && ep.url.endsWith(`:${remote.port || 8737}`)) {
+    // A remote host is a configured runtime whether or not an endpoint entry
+    // survives beside it — the endpoint list gets cleared by a disconnect, and
+    // dropping the host on that basis would strand a machine the user set up
+    // and show them a first-run splash instead.
+    if (remote?.host && (!ep || ep.url.endsWith(`:${remote.port || 8737}`))) {
       runtimes.push({
-        id: 'spark', name: remote.host.split('.')[0] || 'Remote', url: ep.url,
+        id: 'spark', name: remote.host.split('.')[0] || 'Remote',
+        url: ep?.url || `http://127.0.0.1:${remote.port || 8737}`,
         control: 'ssh',
         ssh: { host: remote.host, user: remote.user, sshPort: remote.sshPort, autoTunnel: true },
         launch: remote.command ? { command: remote.command } : undefined,
@@ -92,7 +152,10 @@ export class AxomRuntimes {
       runtimes.push({ id: ep.name || 'axom', name, url: ep.url, control: 'none' });
     }
     cfg.runtimes = runtimes;
-    if (runtimes.length && !cfg.activeRuntimeId) cfg.activeRuntimeId = runtimes[0].id;
+    if (runtimes.length) {
+      cfg.runtimesMigrated = true;
+      if (!cfg.activeRuntimeId) cfg.activeRuntimeId = runtimes[0].id;
+    }
     return true;
   }
 
@@ -101,7 +164,9 @@ export class AxomRuntimes {
   }
 
   start() {
-    this.migrate();
+    // Persist it: an unsaved migration re-derives on every boot, so a runtime
+    // the user later removed would come back from the legacy keys each time.
+    if (this.migrate()) this._save();
     this._syncConnector();
   }
 
@@ -231,20 +296,218 @@ export class AxomRuntimes {
         canStart: rt.control !== 'none' && derived.state === 'stopped',
         canStop: rt.control !== 'none' && (derived.state === 'connected' || derived.state === 'running'),
         canHeal: rt.control === 'ssh' && derived.state === 'unreachable',
+        ...this.generation(rt.id),
       };
     }));
     return { runtimes, activeRuntimeId: this.activeId() };
   }
 
+  // ── Mono-Axom (§10) ───────────────────────────────────────────────────────
+  //
+  // One Axom per user per machine. Every hook — a selector entry, a tab, a new
+  // chat — is a fresh SESSION on the one runtime, never a second process. The
+  // §14 lockfile is the enforcement mechanism, so racing hooks are safe: the
+  // loser is refused cleanly and joins the winner's runtime.
+
+  // Until multi-sequence lands, hooks share ONE generation slot. Concurrent
+  // work queues, and the UI is required to say so rather than looking hung.
+  generation(id) {
+    const ep = this.daemon.axom.endpoints.get(id);
+    const busySession = (ep?.sessions ? [...ep.sessions.values()] : []).find((s) => s.live);
+    return {
+      generationBusy: !!busySession,
+      generationHolder: busySession?.id || null,
+      // The holder's human name, if it is a chat this GROOVE minted. A session
+      // opened elsewhere (the REPL, another client) has none — the UI says
+      // "another session" rather than inventing one.
+      generationHolderLabel: busySession ? (this.getChat(busySession.id)?.label || null) : null,
+    };
+  }
+
+  // ── Chats — the persistent hook list ─────────────────────────────────────
+  //
+  // A chat is a named hook. It lives in daemon config, not the browser: tunnel
+  // ports move, tabs reload, and a chat list that evaporates on refresh reads
+  // as data loss even though the ledger kept everything.
+
+  chats() {
+    return (this._cfg().chats || []).filter((c) => !c.hidden);
+  }
+
+  getChat(session) {
+    return (this._cfg().chats || []).find((c) => c.session === session) || null;
+  }
+
+  _putChat(chat) {
+    const all = this._cfg().chats || [];
+    const i = all.findIndex((c) => c.session === chat.session);
+    this._cfg().chats = i >= 0 ? all.map((c) => (c.session === chat.session ? chat : c)) : [...all, chat];
+    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');
+    }
+    // `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);
+  }
+
+  // Hide, never delete. The conversation lives in the runtime's ledger and is
+  // the user's memory — GROOVE tidying its own list must never be able to
+  // destroy it. The session id is REMEMBERED so the connector's /sessions poll
+  // can't resurrect the row the user just cleared away.
+  hideChat(session) {
+    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() } });
+  }
+
+  // Idempotent by design: if the runtime already answers, this is a no-op. We
+  // never start a second process to satisfy a hook.
+  async ensureRunning(id) {
+    const { state } = await this.state(id);
+    if (state === 'connected' || state === 'running') return { started: false, alreadyRunning: true };
+    const rt = this.get(id);
+    if (rt.control === 'none') {
+      throw new Error(`"${rt.name}" runs on another machine — start it there, then hook in`);
+    }
+    try {
+      const result = await this.startRuntime(id);
+      return { ...result, started: result.started !== false };
+    } catch (err) {
+      // A racing hook that lost the §14 lock has NOT failed: the runtime it
+      // wanted is up, someone else just got there first. Re-derive rather
+      // than surfacing a lock error the user can do nothing about.
+      const after = await this.state(id);
+      if (after.state === 'connected' || after.state === 'running') {
+        return { started: false, alreadyRunning: true, wonBy: 'another hook' };
+      }
+      throw err;
+    }
+  }
+
+  async hook(id, { session, label } = {}) {
+    const rt = this.get(id || this.activeId());
+    if (!rt) throw new Error('no Axom runtime configured');
+    const launch = await this.ensureRunning(rt.id);
+    // §9: a hook mints its own session id — its own recency thread under the
+    // one identity. Callers may pass one to rejoin an existing thread.
+    const sessionId = session || `s-${Math.random().toString(36).slice(2, 10)}`;
+    // Persist the hook as a chat so the list survives a refresh. Rejoining an
+    // existing session must NOT un-hide a chat the user cleared away.
+    const existing = this.getChat(sessionId);
+    if (!existing) {
+      this._putChat({
+        session: sessionId,
+        runtimeId: rt.id,
+        label: label || `Chat ${this.chats().length + 1}`,
+        createdAt: Date.now(),
+      });
+    } else if (label && !existing.hidden) {
+      this._putChat({ ...existing, label });
+    }
+    this.broadcastChats();
+    this.broadcastStatus();
+    return {
+      runtimeId: rt.id,
+      name: rt.name,
+      url: rt.url,
+      session: sessionId,
+      label: this.getChat(sessionId)?.label || null,
+      launched: !!launch.started,
+      ...this.generation(rt.id),
+    };
+  }
+
   // ── Verbs — dispatch on control, never guess ─────────────────────────────
 
+  // A launch spec must mean exactly one thing in every control mode. The local
+  // path gets {cwd, env} as real spawn options; SSH has only a command string,
+  // so compose them INTO it here rather than dropping them — a spec whose env
+  // is silently ignored launches a subtly different runtime (wrong context
+  // window, wrong tree) while reporting success. Found in the wild: a spec
+  // without AXOM_MAX_CTX booted a 2048-ctx instance.
+  _sshCommand(rt) {
+    const launch = withBlessedEnv(rt.launch);
+    if (!launch?.command) return undefined;
+    const parts = [];
+    // `export`, not a `VAR=x prog` prefix: real specs are COMPOUND shell lines
+    // ("cd /x && prog"), and a prefix binds only to the first word — the var
+    // would decorate `cd` and never reach the runtime. Caught by its own test.
+    for (const [k, v] of Object.entries(launch.env || {})) {
+      parts.push(`export ${k}=${shellQuote(String(v))}; `);
+    }
+    if (launch.cwd) parts.push(`cd ${shellQuote(launch.cwd)} && `);
+    return `${parts.join('')}${launch.command}`;
+  }
+
   _sshCfg(rt) {
     let port = 8737;
     try { port = Number(new URL(rt.url).port) || 8737; } catch { /* default */ }
     return {
       ...rt.ssh,
       port,
-      command: rt.launch?.command,
+      command: this._sshCommand(rt),
       logPath: rt.logPath,
     };
   }
@@ -263,7 +526,7 @@ export class AxomRuntimes {
     }
     // local: the spawned port becomes the runtime's URL.
     const instance = await this.daemon.axomServer.start(rt.id, {
-      launch: rt.launch,
+      launch: withBlessedEnv(rt.launch) || { env: { ...BLESSED_ENV } },
       dataDir: rt.dataDir,
     });
     this.update(id, { url: `http://127.0.0.1:${instance.port}` });

package/node_modules/@groove-dev/daemon/src/axom-server.js

@@ -151,7 +151,9 @@ export class AxomServerManager {
     this.instances.set(id, instance);
     this._broadcast();
 
-    const launch = opts.launch || { command: this._command() };
+    // A spec may carry env/cwd without naming a command (the caller wanted the
+    // configured binary plus the blessed env) — fill the command, keep the rest.
+    const launch = { ...opts.launch, command: opts.launch?.command || this._command() };
     let proc;
     try {
       if (launch.cwd || launch.env || /\s/.test(launch.command)) {

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) {
@@ -158,6 +168,53 @@ export function registerAxomRoutes(app, daemon) {
     }
   });
 
+  // Mono-Axom (§10): a hook is a fresh session on the ONE runtime — never a
+  // second process. Used by the agent selector, new tabs, and new chats alike.
+  // Chats are named hooks, persisted daemon-side so the list survives a
+  // refresh. Removing one HIDES it — the conversation is the user's memory and
+  // lives in the runtime's ledger; GROOVE tidying its list never destroys it.
+  app.get('/api/axom/chats', (req, res) => {
+    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));
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/axom/chats/:session', (req, res) => {
+    try {
+      const result = daemon.axomRuntimes.hideChat(req.params.session);
+      daemon.audit.log('axom.chat.hide', { session: req.params.session });
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/axom/hook', async (req, res) => {
+    try {
+      const result = await daemon.axomRuntimes.hook(req.body?.runtimeId, {
+        session: req.body?.session,
+        label: req.body?.label,
+      });
+      daemon.audit.log('axom.hook', { runtime: result.runtimeId, session: result.session });
+      res.json(result);
+    } catch (err) {
+      res.status(502).json({ error: err.message });
+    }
+  });
+
   app.post('/api/axom/runtimes/:id/activate', (req, res) => {
     try {
       daemon.axomRuntimes.activate(req.params.id);