groove-dev 0.27.208 → 0.27.209

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.208",
+  "version": "0.27.209",
   "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.209",
   "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,25 @@ 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 || {}) } };
+}
+
+// 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 +58,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 +105,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 +136,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 +148,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 +280,168 @@ 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();
+  }
+
+  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() });
+    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.broadcastChats();
+    return { hidden: true, session, note: 'removed from the list; the conversation remains in Axom\'s memory' };
+  }
+
+  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 +460,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

@@ -158,6 +158,46 @@ 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() });
+  });
+
+  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);

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

@@ -75,6 +75,37 @@ describe('AxomRuntimes', () => {
     assert.equal(model.migrate(), false); // idempotent
   });
 
+  // Found in Ryan's live config: endpoints[] emptied by a disconnect, remote
+  // host still configured — the old rule dropped it and showed a first-run
+  // splash for a machine he had already set up.
+  it('migrates a configured remote host even with no endpoint entry beside it', () => {
+    daemon.config.axom = {
+      endpoints: [],
+      remote: { host: 'edgexpert-aaa6.local', user: 'axom', port: 8737, command: 'python3 -u -m axom.cli serve' },
+    };
+    model.migrate();
+    const [rt] = model.list();
+    assert.equal(rt.control, 'ssh');
+    assert.equal(rt.ssh.host, 'edgexpert-aaa6.local');
+    assert.equal(rt.url, 'http://127.0.0.1:8737');
+  });
+
+  it('retries a migration that produced nothing, but never re-derives a real one', () => {
+    // An earlier build wrote an empty runtimes[] and then early-returned
+    // forever on `Array.isArray` — the host stayed stranded across restarts.
+    daemon.config.axom = {
+      runtimes: [],
+      remote: { host: 'spark.local', user: 'axom', port: 8737 },
+    };
+    assert.equal(model.migrate(), true);
+    assert.equal(model.list().length, 1);
+    // Now it is marked done: a runtime the user removes must not resurrect.
+    assert.equal(model.migrate(), false);
+    model.remove('spark');
+    assert.equal(model.migrate(), false);
+    assert.equal(model.list().length, 0);
+  });
+
   it('migrates a lone endpoint into a connect-only runtime', () => {
     daemon.config.axom = { endpoints: [{ name: 'other', url: 'http://127.0.0.1:9999' }] };
     model.migrate();
@@ -89,7 +120,37 @@ describe('AxomRuntimes', () => {
     assert.ok(kinds.includes('tunnel')); // reachability follows lifecycle
     const cfg = daemon.calls.remote.find((c) => c[0] === 'start')[1];
     assert.equal(cfg.host, 'spark.local');
-    assert.equal(cfg.command, SSH_RT.launch.command); // spec passed VERBATIM
+    // Spec passed verbatim, with only the blessed env exported ahead of it.
+    assert.ok(cfg.command.endsWith(SSH_RT.launch.command));
+    assert.match(cfg.command, /^export AXOM_MAX_CTX='8192'; /);
+  });
+
+  // A spec must mean the same thing in every control mode. SSH previously
+  // honoured only `command`, so structured cwd/env vanished — the class of bug
+  // that boots a 2048-ctx runtime from a spec that asked for 8192.
+  it('composes launch cwd and env into the ssh command instead of dropping them', async () => {
+    model.add({
+      ...SSH_RT,
+      launch: {
+        command: 'python3 -u -m axom.cli serve --cpu',
+        cwd: '/home/axom/Desktop/Axom/axom-release',
+        env: { PYTHONPATH: 'model', AXOM_MAX_CTX: '8192' },
+      },
+    });
+    await model.startRuntime('spark');
+    const { command } = daemon.calls.remote.find((c) => c[0] === 'start')[1];
+    // export before cd: a `VAR=x` prefix would bind to `cd`, not the runtime.
+    assert.match(command, /export PYTHONPATH='model';/);
+    assert.match(command, /cd '\/home\/axom\/Desktop\/Axom\/axom-release' && python3/);
+    assert.match(command, /AXOM_MAX_CTX='8192'/);
+    assert.ok(command.endsWith('python3 -u -m axom.cli serve --cpu'));
+  });
+
+  it('rejects launch env that is not clean name/value pairs', () => {
+    assert.ok(validateRuntime({ ...SSH_RT, launch: { command: 'x', env: ['A=1'] } }));
+    assert.ok(validateRuntime({ ...SSH_RT, launch: { command: 'x', env: { 'BAD NAME': '1' } } }));
+    assert.ok(validateRuntime({ ...SSH_RT, launch: { command: 'x', env: { A: { nested: 1 } } } }));
+    assert.equal(validateRuntime({ ...SSH_RT, launch: { command: 'x', env: { AXOM_MAX_CTX: '8192' }, cwd: '/x' } }), null);
   });
 
   it('start dispatches by control: local spawns and adopts the resulting port as its URL', async () => {
@@ -136,6 +197,114 @@ describe('AxomRuntimes', () => {
     assert.equal(theirs.canHeal, false);
   });
 
+  // ── Mono-Axom (§10) ─────────────────────────────────────────────────────
+  // One Axom per machine; hooks are sessions, never processes.
+
+  it('a hook on a running runtime mints a session and starts nothing', 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');
+    assert.match(a.session, /^s-/);
+    assert.notEqual(a.session, b.session); // each hook is its own recency thread
+    assert.equal(a.launched, false);
+    assert.equal(daemon.calls.remote.filter((c) => c[0] === 'start').length, 0);
+  });
+
+  it('a hook launches from the blessed spec only when nothing is running', async () => {
+    model.add({ ...SSH_RT, url: 'http://127.0.0.1:1' });
+    fakeDaemon._remoteStatus = { running: false };
+    const h = await model.hook('spark');
+    delete fakeDaemon._remoteStatus;
+    assert.equal(h.launched, true);
+    assert.equal(daemon.calls.remote.filter((c) => c[0] === 'start').length, 1);
+    // The blessed env rides the launch — a 2048-ctx boot is the bug it prevents.
+    assert.match(daemon.calls.remote.find((c) => c[0] === 'start')[1].command, /AXOM_MAX_CTX='8192'/);
+  });
+
+  it('a hook that loses the lock race joins the winner instead of erroring', async () => {
+    model.add({ ...SSH_RT, url: 'http://127.0.0.1:1' });
+    let probes = 0;
+    fakeDaemon._remoteStatus = { running: false };
+    daemon.axomRemote.start = async () => { throw new Error('another instance holds the data-dir lock'); };
+    // The loser re-derives: by the time it asks again, the winner is up.
+    const realState = model.state.bind(model);
+    model.state = async (id) => (++probes >= 2 ? { state: 'connected', detail: null } : realState(id));
+    const h = await model.hook('spark');
+    delete fakeDaemon._remoteStatus;
+    assert.equal(h.launched, false);
+    assert.equal(h.wonBy, undefined); // hook() reports the session, not the race
+    assert.match(h.session, /^s-/);
+  });
+
+  it('a user-set env value beats the blessed default — GROOVE never edits a spec', async () => {
+    model.add({ ...SSH_RT, launch: { command: 'serve', env: { AXOM_MAX_CTX: '4096' } } });
+    await model.startRuntime('spark');
+    const { command } = daemon.calls.remote.find((c) => c[0] === 'start')[1];
+    assert.match(command, /AXOM_MAX_CTX='4096'/);
+    assert.doesNotMatch(command, /8192/);
+  });
+
+  it('reports the shared generation slot so concurrent hooks can queue honestly', async () => {
+    model.add(SSH_RT);
+    const sessions = new Map([
+      ['s-one', { id: 's-one', live: true }],
+      ['s-two', { id: 's-two', live: false }],
+    ]);
+    daemon.axom.endpoints.set('spark', { status: 'connected', sessions });
+    const { runtimes } = await model.status();
+    assert.equal(runtimes[0].generationBusy, true);
+    assert.equal(runtimes[0].generationHolder, 's-one');
+    sessions.get('s-one').live = false;
+    assert.equal(model.generation('spark').generationBusy, false);
+  });
+
+  it('refuses to hook a runtime on someone else\'s machine with an honest sentence', async () => {
+    model.add({ id: 'theirs', name: 'Theirs', url: 'http://127.0.0.1:1', control: 'none' });
+    await assert.rejects(() => model.hook('theirs'), /runs on another machine/);
+  });
+
+  // ── Chats — the persistent hook list ────────────────────────────────────
+
+  it('records every hook as a chat that survives a reload', async () => {
+    model.add(SSH_RT);
+    daemon.axom.endpoints.set('spark', { status: 'connected', sessions: new Map() });
+    const a = await model.hook('spark', { label: 'Research' });
+    await model.hook('spark');
+    assert.equal(a.label, 'Research');
+    assert.equal(model.chats().length, 2);
+    // A fresh model over the same config sees them — the list is daemon-side.
+    assert.equal(new AxomRuntimes(daemon).chats().length, 2);
+  });
+
+  it('deleting a chat hides it and never touches the conversation', async () => {
+    model.add(SSH_RT);
+    daemon.axom.endpoints.set('spark', { status: 'connected', sessions: new Map() });
+    const { session } = await model.hook('spark', { label: 'Scratch' });
+    const result = model.hideChat(session);
+    assert.equal(model.chats().length, 0);
+    assert.match(result.note, /remains in Axom's memory/);
+    // The row is REMEMBERED as hidden, so rejoining the same session — which
+    // the connector's /sessions poll will keep reporting — can't resurrect it.
+    await model.hook('spark', { session });
+    assert.equal(model.chats().length, 0);
+    assert.equal(model.getChat(session).hidden, true);
+  });
+
+  it('names the generation holder only when it is a chat we minted', async () => {
+    model.add(SSH_RT);
+    const sessions = new Map();
+    daemon.axom.endpoints.set('spark', { status: 'connected', sessions });
+    const { session } = await model.hook('spark', { label: 'Research' });
+    sessions.set(session, { id: session, live: true });
+    assert.equal(model.generation('spark').generationHolderLabel, 'Research');
+    // A session opened elsewhere (REPL, another client) gets no invented name.
+    sessions.clear();
+    sessions.set('s-foreign', { id: 's-foreign', live: true });
+    assert.equal(model.generation('spark').generationHolder, 's-foreign');
+    assert.equal(model.generation('spark').generationHolderLabel, null);
+  });
+
   it('keeps the connector in sync with the runtime list', () => {
     model.add(SSH_RT);
     model.remove('spark');