groove-dev 0.27.214 → 0.27.215

package/CLAUDE.md

@@ -134,6 +134,7 @@ groove agents             — list agents
 groove status             — daemon status
 groove nuke               — kill all + stop
 groove rotate <id>        — context rotation (kill + respawn with handoff brief)
+groove handoff <id>       — succession: fresh agent interviews this one via InnerChat, then takes over
 groove team create <name> — create a new team
 groove team rename <id>   — rename a team
 groove team list          — list teams
@@ -167,6 +168,7 @@ All endpoints on `http://localhost:31415/api/`. CORS restricted to localhost. 50
 | Health | GET | /api/health, /api/status | Health check, daemon status |
 | Agents | GET/POST/DELETE | /api/agents, /api/agents/:id | Agent CRUD, detail, update |
 | Agent Actions | POST | /api/agents/:id/rotate, instruct, query | Rotation, instructions, queries |
+| Succession | POST | /api/agents/:id/handoff, /api/handoff/:id/complete | Spawn successor + interview, retire predecessor |
 | Agent Routing | GET | /api/agents/:id/routing/recommend | Model routing recommendations |
 | Teams | GET/POST | /api/teams | List, create teams |
 | Teams | PATCH/DELETE | /api/teams/:id | Rename, delete teams |

package/node_modules/@groove-dev/cli/bin/groove.js

@@ -12,6 +12,7 @@ import { agents } from '../src/commands/agents.js';
 import { status } from '../src/commands/status.js';
 import { nuke } from '../src/commands/nuke.js';
 import { rotate } from '../src/commands/rotate.js';
+import { handoff } from '../src/commands/handoff.js';
 import { teamCreate, teamSave, teamLoad, teamList, teamDelete, teamRename, teamExport, teamImport } from '../src/commands/team.js';
 import { approvals, approve, reject } from '../src/commands/approve.js';
 import { providers, setKey } from '../src/commands/providers.js';
@@ -99,6 +100,13 @@ program
   .description('Rotate an agent (kill + respawn with fresh context)')
   .action(rotate);
 
+program
+  .command('handoff <id>')
+  .description('Succession: spawn a fresh agent that interviews this one, then takes over')
+  .option('--name <name>', 'successor name (default: <agent>-successor)')
+  .option('--no-keep-name', 'successor keeps its own name instead of inheriting')
+  .action(handoff);
+
 // Teams
 const team = program.command('team').description('Manage agent teams');
 team.command('create <name>').description('Create a new team').action(teamCreate);

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

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

package/node_modules/@groove-dev/cli/src/commands/handoff.js

@@ -0,0 +1,22 @@
+// GROOVE CLI — handoff command (succession to a fresh agent)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+export async function handoff(id, options = {}) {
+  try {
+    console.log(chalk.yellow(`  Preparing succession dossier for ${id}...`));
+    const record = await apiCall('POST', `/api/agents/${id}/handoff`, {
+      name: options.name,
+      inheritName: options.keepName !== false,
+    });
+    console.log(chalk.green(`  Succession started.`));
+    console.log(`  ${chalk.bold(record.successorName)} is interviewing ${chalk.bold(record.predecessorName)} over InnerChat.`);
+    console.log(`  When done it will retire the predecessor${record.inheritName ? ` and take over the name "${record.predecessorName}"` : ''}.`);
+    console.log(chalk.dim(`  Handoff id: ${record.id}`));
+  } catch (err) {
+    console.error(chalk.red('  Handoff failed:'), err.message);
+    process.exit(1);
+  }
+}

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

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

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

@@ -4,7 +4,8 @@
 import { createServer as createHttpServer, request as httpProxyRequest } from 'http';
 import { createServer as createNetServer } from 'net';
 import { execFileSync } from 'child_process';
-import { resolve } from 'path';
+import { resolve, dirname, basename } from 'path';
+import { homedir } from 'os';
 import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, readdirSync, rmdirSync, rmSync, statSync } from 'fs';
 import express from 'express';
 import { WebSocketServer } from 'ws';
@@ -630,6 +631,22 @@ export class Daemon {
         // Read back actual port (critical for port 0 / dynamic allocation)
         this.port = this.server.address().port;
         writeFileSync(this.pidFile, String(process.pid));
+
+        // Anchor for restart tooling. grooveDir — the daemon's entire world of
+        // teams/agents/state — is derived from the cwd `groove start` ran in.
+        // Remote restart paths (tunnel autoStart, upgrades, the desktop shell)
+        // each guess a cwd; a wrong guess boots a fresh empty .groove that
+        // looks exactly like total data loss. Record where this world lives at
+        // a FIXED path so every restarter can re-enter it instead of guessing.
+        // Staging/override daemons (custom GROOVE_DIR) skip this — they must
+        // not hijack the anchor of the real daemon.
+        try {
+          if (basename(this.grooveDir) === '.groove') {
+            const anchorHome = resolve(homedir(), '.groove');
+            mkdirSync(anchorHome, { recursive: true });
+            writeFileSync(resolve(anchorHome, 'last-run-dir'), dirname(this.grooveDir));
+          }
+        } catch { /* non-fatal */ }
         // Write actual port and host so CLI can find us
         writeFileSync(resolve(this.grooveDir, 'daemon.port'), String(this.port));
         writeFileSync(resolve(this.grooveDir, 'daemon.host'), this.host);

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

@@ -1057,6 +1057,34 @@ export class Journalist {
     return brief;
   }
 
+  /**
+   * Succession dossier — the deep version of the handoff brief, for handing a
+   * long-lived agent's role to a NEW agent. The regular brief is recency-biased
+   * by design (last 3 chain entries, current session); after weeks of work the
+   * older accumulated knowledge matters just as much. The dossier adds the full
+   * handoff chain and the project decision log, and its reader is expected to
+   * fill remaining gaps by interviewing the predecessor directly.
+   */
+  async generateSuccessionDossier(agent) {
+    const brief = await this.generateHandoffBrief(agent, { reason: 'succession' });
+
+    // The whole chain (up to the retained 10 generations), not the last 3.
+    const fullChain = this.daemon.memory?.getRecentHandoffMarkdown(
+      agent.role, 10, 12000, agent.workingDir, agent.teamId,
+    ) || '';
+
+    let decisions = '';
+    try {
+      const p = resolve(this.daemon.projectDir, 'GROOVE_DECISIONS.md');
+      if (existsSync(p)) decisions = readFileSync(p, 'utf8').slice(0, 8000);
+    } catch { /* optional */ }
+
+    const parts = [brief];
+    if (fullChain) parts.push(`## Full Rotation History (oldest knowledge — read it, it is why things are the way they are)\n\n${fullChain}`);
+    if (decisions) parts.push(`## Project Decision Log\n\n${decisions}`);
+    return parts.join('\n\n');
+  }
+
   // --- Conversation Thread Extraction (for idle resume) ---
 
   /**

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

@@ -4,7 +4,9 @@
 import { EventEmitter } from 'events';
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
+import { randomUUID } from 'crypto';
 import { getProvider } from './providers/index.js';
+import { deliverInstruction } from './deliver.js';
 
 const DEFAULT_THRESHOLD = 0.65;      // For non-self-managing providers (was 0.75)
 const HARD_CEILING = 0.80;           // Force rotate (was 0.85) — only for non-self-managing
@@ -40,6 +42,7 @@ export class Rotator extends EventEmitter {
     this.interval = null;
     this.rotationHistory = [];
     this.rotating = new Set();
+    this.handoffs = new Map(); // handoffId -> { predecessorId, successorId, status, ... }
     this.lastRotationTime = new Map(); // agentId -> timestamp of last rotation
     this._lastContextState = new Map(); // agentId -> { contextUsage, timestamp }
     this.compactionCounts = new Map(); // agentId -> number of natural compactions
@@ -638,6 +641,182 @@ export class Rotator extends EventEmitter {
     }
   }
 
+  // ── Succession handoff ─────────────────────────────────────────
+  //
+  // Rotation replaces an agent with a same-name clone and is recency-biased —
+  // right for context pressure, wrong for retiring a long-lived agent. A
+  // succession spawns the successor ALONGSIDE the still-running predecessor,
+  // seeded with a deep dossier, and mandates an InnerChat interview before the
+  // predecessor is retired. The interview is the point: after weeks of work
+  // the highest-bandwidth transfer is questions answered by the agent that
+  // still remembers, not any summary.
+
+  async successionHandoff(agentId, options = {}) {
+    const registry = this.daemon.registry;
+    const agent = registry.get(agentId);
+    if (!agent) throw new Error('Agent not found');
+    if (this.rotating.has(agentId)) throw new Error('Agent is mid-rotation — try again shortly');
+    for (const h of this.handoffs.values()) {
+      if (h.status === 'interviewing' && (h.predecessorId === agentId || h.successorId === agentId)) {
+        throw new Error('A handoff is already in progress for this agent');
+      }
+    }
+
+    const handoffId = randomUUID().slice(0, 12);
+    const dossier = await this.daemon.journalist.generateSuccessionDossier(agent);
+
+    // Persist to the chain up front — even a failed handoff leaves the record.
+    if (this.daemon.memory) {
+      this.daemon.memory.appendHandoffBrief(agent.role, {
+        timestamp: new Date().toISOString(),
+        agentId: agent.id,
+        newAgentId: null,
+        reason: 'succession',
+        oldTokens: agent.tokensUsed,
+        contextUsage: agent.contextUsage,
+        brief: dossier.slice(0, 6000),
+      }, agent.workingDir, agent.teamId);
+    }
+
+    const inheritName = options.inheritName !== false;
+    const successorName = (options.name && String(options.name).trim())
+      || `${agent.name}-successor`;
+    const port = this.daemon.port || 31415;
+
+    const prompt = [
+      `# SUCCESSION — you are taking over from ${agent.name}`,
+      ``,
+      `${agent.name} has been working this role for a long time and is being retired`,
+      `for context degradation. You are its successor. Its accumulated knowledge is`,
+      `below; its live memory is still available for a short window — use it.`,
+      ``,
+      dossier,
+      ``,
+      `## Step 1 — Interview your predecessor (do this FIRST)`,
+      ``,
+      `${agent.name} is still running and has been told to expect your questions.`,
+      `Ask via InnerChat (blocking; run in the foreground):`,
+      ``,
+      '```bash',
+      `curl -s http://localhost:${port}/api/innerchat/ask -X POST -H 'Content-Type: application/json' \\`,
+      `  -d '{"from":"${successorName}","to":"${agent.name}","message":"YOUR_QUESTION"}'`,
+      '```',
+      ``,
+      `Ask about: work currently in flight and exactly where it stands; fragile or`,
+      `dangerous areas; unwritten conventions the dossier missed; what it planned to`,
+      `do next and why. Several focused rounds beat one broad one. The exchange`,
+      `budget is shared — stop when answers stop teaching you.`,
+      ``,
+      `## Step 2 — Declare takeover`,
+      ``,
+      `When you have what you need (interview done or predecessor unresponsive):`,
+      ``,
+      '```bash',
+      `curl -s -X POST http://localhost:${port}/api/handoff/${handoffId}/complete`,
+      '```',
+      ``,
+      `This retires ${agent.name}${inheritName ? ` and renames you to "${agent.name}"` : ''}. Then continue the work — you own it now.`,
+      `Do NOT start new work before completing both steps.`,
+    ].join('\n');
+
+    const successor = await this.daemon.processes.spawn({
+      role: agent.role,
+      scope: agent.scope,
+      provider: options.provider || agent.provider,
+      model: options.model || agent.model,
+      prompt,
+      permission: agent.permission || 'full',
+      workingDir: agent.workingDir,
+      name: successorName,
+      teamId: agent.teamId,
+    });
+
+    // Survives a daemon restart: /complete can reconstruct from this metadata.
+    registry.update(successor.id, {
+      metadata: {
+        ...(successor.metadata || {}),
+        handoff: { handoffId, predecessorId: agent.id, predecessorName: agent.name, inheritName },
+      },
+    });
+
+    const record = {
+      id: handoffId,
+      predecessorId: agent.id,
+      predecessorName: agent.name,
+      successorId: successor.id,
+      successorName: successor.name || successorName,
+      inheritName,
+      status: 'interviewing',
+      startedAt: new Date().toISOString(),
+    };
+    this.handoffs.set(handoffId, record);
+
+    // Heads-up to the predecessor — best effort; InnerChat will wake it anyway.
+    deliverInstruction(this.daemon, agent.id,
+      `[Succession] ${record.successorName} is taking over your role. It will interview you `
+      + `over InnerChat shortly. Answer its questions completely and concretely — in-flight work, `
+      + `fragile areas, unwritten conventions, planned next steps. Do NOT start new work. `
+      + `Anything only you know must get said now; after the interview you will be retired.`,
+      { recordFeedback: false },
+    ).catch((err) => console.warn(`  Rotator: could not brief predecessor ${agent.name}: ${err.message}`));
+
+    this.daemon.audit?.log('agent.handoff.start', { handoffId, predecessor: agent.id, successor: successor.id });
+    this.daemon.broadcast({ type: 'handoff:started', data: record });
+    if (this.daemon.timeline) {
+      this.daemon.timeline.recordEvent('handoff', {
+        agentId: successor.id, oldAgentId: agent.id,
+        agentName: record.successorName, role: agent.role, reason: 'succession',
+      });
+    }
+    return record;
+  }
+
+  async completeHandoff(handoffId) {
+    const registry = this.daemon.registry;
+    let record = this.handoffs.get(handoffId);
+    if (!record) {
+      // Daemon restarted mid-handoff — reconstruct from successor metadata.
+      const successor = registry.getAll().find((a) => a.metadata?.handoff?.handoffId === handoffId);
+      if (!successor) throw new Error('Handoff not found');
+      const h = successor.metadata.handoff;
+      record = {
+        id: handoffId, predecessorId: h.predecessorId, predecessorName: h.predecessorName,
+        successorId: successor.id, successorName: successor.name,
+        inheritName: h.inheritName, status: 'interviewing', startedAt: null,
+      };
+    }
+    if (record.status === 'complete') return record;
+
+    const successor = registry.get(record.successorId);
+    if (!successor) throw new Error('Successor no longer exists — cannot complete handoff');
+
+    const predecessor = registry.get(record.predecessorId);
+    if (predecessor) {
+      try { await this.daemon.processes.kill(predecessor.id); } catch { /* already dead */ }
+      registry.remove(predecessor.id);
+      this.daemon.locks?.release(predecessor.id);
+    }
+
+    if (record.inheritName && predecessor) {
+      registry.update(successor.id, { name: record.predecessorName });
+      record.successorName = record.predecessorName;
+    }
+    // Clear the marker — the successor is now just a normal agent.
+    const meta = { ...(successor.metadata || {}) };
+    delete meta.handoff;
+    registry.update(successor.id, { metadata: meta });
+
+    record.status = 'complete';
+    record.completedAt = new Date().toISOString();
+    this.handoffs.set(handoffId, record);
+
+    this.daemon.audit?.log('agent.handoff.complete', {
+      handoffId, predecessor: record.predecessorId, successor: record.successorId,
+    });
+    this.daemon.broadcast({ type: 'handoff:completed', data: record });
+    return record;
+  }
+
   _schedulePostRotationCheck(newAgentId, oldQualityScore, record) {
     // Wait for the new agent to accumulate MIN_EVENTS classifier events,
     // checking every 15s for up to 5 minutes (20 checks)

package/node_modules/@groove-dev/daemon/src/routes/agents.js

@@ -246,6 +246,31 @@ export function registerAgentRoutes(app, daemon) {
     }
   });
 
+  // Succession handoff — spawn a fresh successor alongside a degrading agent,
+  // seeded with a deep dossier; it interviews the predecessor over InnerChat,
+  // then calls /api/handoff/:id/complete to retire it and take over.
+  app.post('/api/agents/:id/handoff', async (req, res) => {
+    try {
+      const { name, inheritName, model, provider } = req.body || {};
+      const record = await daemon.rotator.successionHandoff(req.params.id, {
+        name, inheritName, model, provider,
+      });
+      res.json(record);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  // Called by the successor itself when it has finished interviewing.
+  app.post('/api/handoff/:handoffId/complete', async (req, res) => {
+    try {
+      const record = await daemon.rotator.completeHandoff(req.params.handoffId);
+      res.json(record);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
   // Instruct an agent — send message to agent loop, resume session, or rotate
   // Agent loop = direct message to running loop (local models)
   // Resume = zero cold-start (uses --resume SESSION_ID)

package/node_modules/@groove-dev/daemon/src/tunnel-manager.js

@@ -4,7 +4,8 @@
 import { execFileSync, spawn } from 'child_process';
 import { existsSync, writeFileSync, readFileSync, statSync } from 'fs';
 import { resolve } from 'path';
-import { createConnection } from 'net';
+import { createConnection, isIP } from 'net';
+import { lookup } from 'dns/promises';
 import crypto from 'crypto';
 
 function getLocalVersion() {
@@ -15,6 +16,13 @@ function getLocalVersion() {
 }
 
 const REMOTE_PORT = 31415;
+
+// Every remote `groove start` must run from the directory of the daemon's
+// EXISTING world (grooveDir is derived from cwd). The remote daemon records
+// that directory in ~/.groove/last-run-dir on each boot; starting anywhere
+// else boots a fresh empty .groove — which reads as "all my teams are gone".
+// Falls back to $HOME (matching old behavior) when no anchor exists yet.
+const ANCHOR_CD = `cd "$(cat "$HOME/.groove/last-run-dir" 2>/dev/null || echo "$HOME")" 2>/dev/null || cd "$HOME"; `;
 const DEFAULT_LOCAL_PORT = 31416;
 const MAX_PORT_ATTEMPTS = 10;
 const HEALTH_INTERVAL = 30000;
@@ -60,6 +68,49 @@ function isPermissionError(output) {
 
 const PERMISSION_HINT = 'npm global install requires write access. Either install Node via nvm (recommended) or configure passwordless sudo for npm on the remote server.';
 
+// A hostname can resolve to several addresses on different interfaces — a
+// dual-homed LAN box (wired + Wi-Fi) advertises all of them over mDNS, and ssh
+// just takes the resolver's first pick. Landing on a weak Wi-Fi address gives
+// a tunnel that dies of keepalive timeout minutes later, and every reconnect
+// re-rolls the dice. Probe all candidates with a TCP handshake to the ssh port
+// and take the fastest responder — on a LAN that reliably picks wired over
+// Wi-Fi. Falls back to the original hostname if resolution or every probe
+// fails, so behavior is unchanged for the cases that already worked.
+export async function resolveBestAddress(host, port = 22, probeTimeoutMs = 2500) {
+  if (isIP(host)) return host; // literal IP — nothing to choose
+  let addrs;
+  try {
+    addrs = await lookup(host, { all: true, verbatim: true });
+  } catch { return host; }
+  if (!Array.isArray(addrs) || addrs.length <= 1) return host;
+
+  const handshake = (address) => new Promise((res) => {
+    const started = Date.now();
+    let sock;
+    try { sock = createConnection({ host: address, port }); } catch { return res(null); }
+    sock.setTimeout(probeTimeoutMs);
+    sock.on('connect', () => { sock.destroy(); res(Date.now() - started); });
+    sock.on('error', () => res(null));
+    sock.on('timeout', () => { sock.destroy(); res(null); });
+  });
+
+  // Median of three handshakes per address: one lucky round-trip can make a
+  // weak link look fine, but a flaky link rarely wins three in a row — a
+  // single retransmit (or drop, scored as the timeout) sinks its median.
+  const probe = async (address) => {
+    const times = [];
+    for (let i = 0; i < 3; i++) times.push(await handshake(address));
+    const scored = times.map((t) => (t === null ? probeTimeoutMs : t)).sort((a, b) => a - b);
+    if (times.every((t) => t === null)) return null; // never connected at all
+    return { address, ms: scored[1] };
+  };
+
+  const results = (await Promise.all(addrs.map((a) => probe(a.address)))).filter(Boolean);
+  if (results.length === 0) return host;
+  results.sort((a, b) => a.ms - b.ms);
+  return results[0].address;
+}
+
 export class TunnelManager {
   constructor(daemon) {
     this.daemon = daemon;
@@ -302,7 +353,7 @@ export class TunnelManager {
     const config = this.saved.get(id);
     if (!config) throw new Error(`Remote ${id} not found`);
 
-    const target = `${config.user}@${config.host}`;
+    const target = `${config.user}@${await resolveBestAddress(config.host, config.port || 22)}`;
     const keyArgs = config.sshKeyPath ? ['-i', config.sshKeyPath] : [];
 
     try {
@@ -418,18 +469,28 @@ export class TunnelManager {
     } else {
       localPort = await this._findAvailablePort();
     }
-    const target = `${config.user}@${config.host}`;
+    // Multi-homed hosts (mDNS names especially): pick the address that actually
+    // answers fastest instead of letting the resolver gamble on an interface.
+    const connectHost = await resolveBestAddress(config.host, config.port || 22);
+    if (connectHost !== config.host) {
+      console.log(`[Groove:Tunnel] ${config.name}: ${config.host} → ${connectHost} (fastest responding address)`);
+    }
+    const target = `${config.user}@${connectHost}`;
     const keyArgs = config.sshKeyPath ? ['-i', config.sshKeyPath] : [];
+    // Keep the host key pinned to the NAME when we connect by address, so every
+    // address of the same box shares one known_hosts entry.
+    const aliasArgs = connectHost !== config.host ? ['-o', `HostKeyAlias=${config.host}`] : [];
 
     const sshArgs = [
       '-N',
       '-L', `127.0.0.1:${localPort}:localhost:${REMOTE_PORT}`,
       '-p', String(config.port || 22),
-      '-o', 'ServerAliveInterval=30',
-      '-o', 'ServerAliveCountMax=3',
+      '-o', 'ServerAliveInterval=15',
+      '-o', 'ServerAliveCountMax=4',
       '-o', 'ExitOnForwardFailure=yes',
       '-o', 'StrictHostKeyChecking=accept-new',
       '-o', 'GSSAPIAuthentication=no',
+      ...aliasArgs,
       ...keyArgs,
       target,
     ];
@@ -635,7 +696,7 @@ export class TunnelManager {
       }
 
       // Restart remote daemon — fire and forget the SSH, verify through the tunnel
-      const cdPrefix = config.projectDir ? `cd "${config.projectDir}" && ` : '';
+      const cdPrefix = config.projectDir ? `cd "${config.projectDir}" && ` : ANCHOR_CD;
       try {
         execFileSync('ssh', [...sshBase, sshCmd(`kill $(lsof -t -i:${REMOTE_PORT}) 2>/dev/null || true; sleep 1; ${cdPrefix}GROOVE_BIN=$(which groove) && nohup "$GROOVE_BIN" start > /tmp/groove-daemon.log 2>&1 < /dev/null & disown`)], {
           encoding: 'utf8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'],
@@ -742,7 +803,7 @@ export class TunnelManager {
     const config = this.saved.get(id);
     if (!config) throw new Error(`Remote ${id} not found`);
 
-    const target = `${config.user}@${config.host}`;
+    const target = `${config.user}@${await resolveBestAddress(config.host, config.port || 22)}`;
     const keyArgs = config.sshKeyPath ? ['-i', config.sshKeyPath] : [];
 
     // Build the remote bash command:
@@ -752,7 +813,7 @@ export class TunnelManager {
     //   4. explicitly POST /api/project-dir so the daemon's projectDir matches
     //      config.projectDir even if the backgrounded cwd didn't stick (this
     //      also updates the editor root used for /api/browse, /api/files/*)
-    const cdPrefix = config.projectDir ? `cd "${config.projectDir}" && ` : '';
+    const cdPrefix = config.projectDir ? `cd "${config.projectDir}" && ` : ANCHOR_CD;
     const setProjectDir = config.projectDir
       ? `curl -sf -X POST -H 'Content-Type: application/json' --data '{"path":"${config.projectDir}"}' http://localhost:${REMOTE_PORT}/api/project-dir > /dev/null 2>&1 || true; `
       : '';
@@ -874,7 +935,7 @@ export class TunnelManager {
     try {
       const result = execFileSync('ssh', [
         ...sshBase,
-        remoteCmd(`GROOVE_BIN=$(which groove) && nohup "$GROOVE_BIN" start > /tmp/groove-daemon.log 2>&1 < /dev/null & disown; sleep 5; curl -sf http://localhost:${REMOTE_PORT}/api/health > /dev/null && echo __DAEMON_OK__ || (echo __DAEMON_FAIL__; tail -20 /tmp/groove-daemon.log 2>/dev/null)`),
+        remoteCmd(`${ANCHOR_CD}GROOVE_BIN=$(which groove) && nohup "$GROOVE_BIN" start > /tmp/groove-daemon.log 2>&1 < /dev/null & disown; sleep 5; curl -sf http://localhost:${REMOTE_PORT}/api/health > /dev/null && echo __DAEMON_OK__ || (echo __DAEMON_FAIL__; tail -20 /tmp/groove-daemon.log 2>/dev/null)`),
       ], {
         encoding: 'utf8',
         timeout: 45000,
@@ -944,7 +1005,7 @@ export class TunnelManager {
     }).trim();
     const installedVer = verOutput.replace(/[^0-9.]/g, '') || verOutput.trim();
 
-    const restartCmd = `kill $(lsof -t -i:${REMOTE_PORT}) 2>/dev/null || true; sleep 2; GROOVE_BIN=$(which groove) && nohup "$GROOVE_BIN" start > /tmp/groove-daemon.log 2>&1 < /dev/null & disown; sleep 4; curl -sf http://localhost:${REMOTE_PORT}/api/status`;
+    const restartCmd = `kill $(lsof -t -i:${REMOTE_PORT}) 2>/dev/null || true; sleep 2; ${ANCHOR_CD}GROOVE_BIN=$(which groove) && nohup "$GROOVE_BIN" start > /tmp/groove-daemon.log 2>&1 < /dev/null & disown; sleep 4; curl -sf http://localhost:${REMOTE_PORT}/api/status`;
     const restartResult = execFileSync('ssh', [...sshBase, sshCmd(restartCmd)], {
       encoding: 'utf8',
       timeout: 60000,

package/node_modules/@groove-dev/daemon/test/rotator.test.js

@@ -601,4 +601,90 @@ describe('Rotator', () => {
 
     assert.equal(rotator.getHistory().length, 0);
   });
+
+  // ── Succession handoff ─────────────────────────────────────────
+
+  function seedForHandoff() {
+    const agent = {
+      id: 'old1', name: 'veteran', role: 'fullstack',
+      provider: 'claude-code', scope: null, model: null,
+      tokensUsed: 900_000, contextUsage: 0.7,
+      workingDir: '/tmp', teamId: 't1', prompt: 'Long-running work',
+    };
+    mockDaemon.registry.agents = [agent];
+    mockDaemon.journalist.generateSuccessionDossier = async () =>
+      '## Dossier\nEverything the veteran knows, in depth.';
+    let spawnCount = 0;
+    mockDaemon.processes.spawn = async (config) => {
+      spawnCount++;
+      const spawned = { id: 'succ' + spawnCount, ...config };
+      mockDaemon.registry.agents.push(spawned);
+      return spawned;
+    };
+    return agent;
+  }
+
+  it('succession spawns the successor ALONGSIDE the predecessor', async () => {
+    seedForHandoff();
+    const record = await rotator.successionHandoff('old1');
+
+    assert.equal(record.status, 'interviewing');
+    const ids = mockDaemon.registry.agents.map((a) => a.id);
+    assert.ok(ids.includes('old1'), 'predecessor still alive during the interview');
+    assert.ok(ids.includes(record.successorId), 'successor exists');
+
+    const successor = mockDaemon.registry.agents.find((a) => a.id === record.successorId);
+    assert.equal(successor.name, 'veteran-successor');
+    assert.ok(successor.prompt.includes('Dossier'), 'successor got the dossier');
+    assert.ok(successor.prompt.includes('innerchat/ask'), 'successor told to interview');
+    assert.ok(successor.prompt.includes(`/api/handoff/${record.id}/complete`), 'successor told how to declare takeover');
+    assert.equal(successor.metadata.handoff.predecessorId, 'old1');
+    assert.ok(broadcasts.some((b) => b.type === 'handoff:started'));
+  });
+
+  it('complete retires the predecessor and hands over the name', async () => {
+    seedForHandoff();
+    const record = await rotator.successionHandoff('old1');
+    const done = await rotator.completeHandoff(record.id);
+
+    assert.equal(done.status, 'complete');
+    const ids = mockDaemon.registry.agents.map((a) => a.id);
+    assert.ok(!ids.includes('old1'), 'predecessor retired');
+    const successor = mockDaemon.registry.agents.find((a) => a.id === record.successorId);
+    assert.equal(successor.name, 'veteran', 'successor inherited the name');
+    assert.equal(successor.metadata.handoff, undefined, 'handoff marker cleared');
+    assert.ok(broadcasts.some((b) => b.type === 'handoff:completed'));
+  });
+
+  it('inheritName:false keeps the successor name', async () => {
+    seedForHandoff();
+    const record = await rotator.successionHandoff('old1', { name: 'fresh-eyes', inheritName: false });
+    await rotator.completeHandoff(record.id);
+    const successor = mockDaemon.registry.agents.find((a) => a.id === record.successorId);
+    assert.equal(successor.name, 'fresh-eyes');
+  });
+
+  it('complete survives a daemon restart (reconstructs from successor metadata)', async () => {
+    seedForHandoff();
+    const record = await rotator.successionHandoff('old1');
+    rotator.handoffs.clear(); // simulate restart wiping in-memory state
+
+    const done = await rotator.completeHandoff(record.id);
+    assert.equal(done.status, 'complete');
+    assert.ok(!mockDaemon.registry.agents.some((a) => a.id === 'old1'), 'predecessor still retired');
+  });
+
+  it('blocks a second handoff while one is interviewing', async () => {
+    seedForHandoff();
+    await rotator.successionHandoff('old1');
+    await assert.rejects(() => rotator.successionHandoff('old1'), /already in progress/);
+  });
+
+  it('completing twice is idempotent', async () => {
+    seedForHandoff();
+    const record = await rotator.successionHandoff('old1');
+    await rotator.completeHandoff(record.id);
+    const again = await rotator.completeHandoff(record.id);
+    assert.equal(again.status, 'complete');
+  });
 });