groove-dev 0.27.165 → 0.27.168

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

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

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

@@ -110,13 +110,43 @@ export class AdaptiveThresholds {
     const selfManages = options.selfManagesContext ?? false;
     let score = 70; // Baseline: decent session
 
-    // Error rate: -5 per error normally, -2 for self-managing (errors during debugging are expected)
+    // --- Error-related penalties ---
+    // For self-managing providers, errorCount/errorTrend/repetitions are often
+    // correlated: running scripts that produce error output triggers all three.
+    // Cap the combined penalty so one root cause can't stack across signals.
     const errorCount = signals.errorCount || 0;
-    score -= errorCount * (selfManages ? 2 : 5);
-
-    // Repetitions: 3+ Write/Edit to the same file in a sliding window
+    const toolOutputErrors = signals.toolOutputErrors || 0;
     const repetitions = signals.repetitions || 0;
-    score -= Math.min(repetitions * 6, 30);
+    const errorTrend = signals.errorTrend || 0;
+
+    let errorPenalty, repetitionPenalty, errorTrendPenalty;
+
+    if (selfManages) {
+      // Tool output errors (is_error on tool results from scripts/tests) get
+      // a reduced rate — they're normal workflow, not agent failures
+      const agentErrors = errorCount - toolOutputErrors;
+      errorPenalty = (Math.max(agentErrors, 0) * 2) + (toolOutputErrors * 1);
+      repetitionPenalty = Math.min(repetitions * 6, 30);
+      errorTrendPenalty = errorTrend > 0 ? errorTrend * 3 : 0;
+
+      // Cap: all error-related signals combined max -35 for self-managing
+      const totalErrorRelated = errorPenalty + repetitionPenalty + errorTrendPenalty;
+      if (totalErrorRelated > 35) {
+        const scale = 35 / totalErrorRelated;
+        errorPenalty = Math.round(errorPenalty * scale);
+        repetitionPenalty = Math.round(repetitionPenalty * scale);
+        errorTrendPenalty = Math.round(errorTrendPenalty * scale);
+      }
+    } else {
+      errorPenalty = errorCount * 5;
+      repetitionPenalty = Math.min(repetitions * 6, 30);
+      errorTrendPenalty = errorTrend > 0 ? errorTrend * 6 : 0;
+    }
+
+    score -= errorPenalty;
+    score -= repetitionPenalty;
+    score -= errorTrendPenalty;
+    if (errorTrend < 0) score += 3; // Errors decreasing = good
 
     // Out-of-scope access: each violation costs 10 points
     const scopeViolations = signals.scopeViolations || 0;
@@ -134,11 +164,6 @@ export class AdaptiveThresholds {
     const fileChurn = signals.fileChurn || 0;
     score -= fileChurn * 10;
 
-    // Error trend: increasing errors in second half = degradation
-    const errorTrend = signals.errorTrend || 0;
-    if (errorTrend > 0) score -= errorTrend * (selfManages ? 3 : 6);
-    if (errorTrend < 0) score += 3;
-
     // Files written: productivity signal
     const filesWritten = signals.filesWritten || 0;
     score += Math.min(filesWritten * 2, 10); // Cap at +10
@@ -182,6 +207,7 @@ export class AdaptiveThresholds {
   extractSignals(entries, agentScope) {
     const signals = {
       errorCount: 0,
+      toolOutputErrors: 0,  // is_error tool results (script output, test failures — not agent errors)
       repetitions: 0,
       scopeViolations: 0,
       toolCalls: 0,
@@ -208,6 +234,7 @@ export class AdaptiveThresholds {
 
       if (entry.type === 'error') {
         signals.errorCount++;
+        if (entry.source === 'tool_output') signals.toolOutputErrors++;
       }
 
       // Track assistant output lengths for decay detection

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

@@ -63,7 +63,9 @@ export class TaskClassifier {
         }
         if (block.type === 'tool_result') {
           if (block.is_error) {
-            window.push({ type: 'error', timestamp: Date.now() });
+            // Tag source so the quality scorer can distinguish tool output errors
+            // (script failures, test output) from agent behavioral errors
+            window.push({ type: 'error', source: 'tool_output', timestamp: Date.now() });
             extracted = true;
           }
         }

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

@@ -312,16 +312,17 @@ export class Daemon {
 
     // Single unified registry change listener (broadcast + file I/O + coordination)
     this.registry.on('change', (delta) => {
-      if (delta && delta.removed) {
-        this.broadcast({ type: 'state:delta', data: { changed: [], removed: delta.removed } });
-      } else if (delta && delta.changed) {
-        const changedAgents = delta.changed
-          .map((id) => this.registry.get(id))
-          .filter(Boolean);
-        this.broadcast({ type: 'state:delta', data: { changed: enrichAgents(changedAgents), removed: [] } });
-      } else {
-        // Fallback: full state broadcast
+      if (!delta || (!delta.removed && !delta.changed)) {
         this.broadcast({ type: 'state', data: enrichAgents(this.registry.getAll()) });
+      } else {
+        const data = { changed: [], removed: [] };
+        if (delta.removed?.length) data.removed = delta.removed;
+        if (delta.changed?.length) {
+          data.changed = enrichAgents(delta.changed.map((id) => this.registry.get(id)).filter(Boolean));
+        }
+        if (data.changed.length > 0 || data.removed.length > 0) {
+          this.broadcast({ type: 'state:delta', data });
+        }
       }
       _debouncedRegistryIo();
       this.teams.onAgentChange();

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

@@ -206,6 +206,14 @@ export class MemoryStore {
 
     const nextN = (chain[0]?.rotationN || 0) + 1;
 
+    // Strip sections that embed previous chain content to prevent recursive
+    // nesting — each chain entry should contain only its OWN brief, not copies
+    // of all prior briefs. The "Rotation History" and "Known Issues" sections
+    // are the primary vectors for this duplication.
+    let briefText = entry.brief || '(no brief)';
+    briefText = briefText.replace(/## Rotation History[\s\S]*?(?=## [A-Z]|$)/, '').trim();
+    briefText = briefText.replace(/## Known Issues & Fixes[\s\S]*?(?=## [A-Z]|$)/, '').trim();
+
     const block = [
       `## Rotation ${nextN} — ${entry.timestamp || new Date().toISOString()} (${entry.agentId || '?'} → ${entry.newAgentId || '?'})`,
       `**Reason:** ${entry.reason || 'unknown'}`,
@@ -213,7 +221,7 @@ export class MemoryStore {
       entry.contextUsage != null ? `**Context at rotation:** ${Math.round(entry.contextUsage * 100)}%` : '',
       '',
       '**Brief summary:**',
-      truncate(entry.brief || '(no brief)', HANDOFF_BRIEF_MAX_CHARS),
+      truncate(briefText, HANDOFF_BRIEF_MAX_CHARS),
       '',
     ].filter(Boolean).join('\n');
 

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

@@ -1975,7 +1975,7 @@ For normal file edits within your scope, proceed without review.
 
       if (existing && (existing.status === 'completed' || existing.status === 'stopped' || existing.status === 'crashed' || existing.status === 'killed')) {
         config.name = existing.name;
-        registry.remove(existing.id);
+        registry.remove(existing.id, { silent: true });
         this.daemon.locks.release(existing.id);
       }
 
@@ -2516,11 +2516,13 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
     const config = { ...agent };
     const sessionId = agent.sessionId;
 
-    // Stop if running, then remove old entry so we can re-register with same name
+    // Stop if running, then remove old entry so we can re-register with same name.
+    // Silent removal: the add() below will flush both removed+changed in one broadcast,
+    // preventing the GUI from seeing an empty agents list between remove and re-add.
     if (this.handles.has(agentId)) {
       await this.kill(agentId);
     }
-    registry.remove(agentId);
+    registry.remove(agentId, { silent: true });
     locks.release(agentId);
 
     // Build resume command
@@ -2648,7 +2650,7 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
     if (this.handles.has(agentId)) {
       await this.kill(agentId);
     }
-    registry.remove(agentId);
+    registry.remove(agentId, { silent: true });
     locks.release(agentId);
 
     const newAgent = await this.spawn({
@@ -2698,7 +2700,7 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
     if (this.handles.has(agentId)) {
       await this.kill(agentId);
     }
-    registry.remove(agentId);
+    registry.remove(agentId, { silent: true });
     locks.release(agentId);
 
     const newAgent = registry.add({
@@ -3005,6 +3007,10 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
     const agent = this.daemon.registry.get(agentId);
     const wrapped = agent ? wrapWithRoleReminder(agent.role, message) : message;
 
+    if (source === 'user' && this.daemon.rotator) {
+      this.daemon.rotator.recordUserMessage(agentId);
+    }
+
     if (this.daemon.trajectoryCapture) {
       try { this.daemon.trajectoryCapture.onUserMessage(agentId, message, source); } catch (e) { /* fail silent */ }
     }
@@ -3025,6 +3031,9 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
     const agent = this.daemon.registry.get(agentId);
     const wrapped = agent ? wrapWithRoleReminder(agent.role, message) : message;
     this.pendingMessages.set(agentId, { message: wrapped, timestamp: Date.now() });
+    if (this.daemon.rotator) {
+      this.daemon.rotator.recordUserMessage(agentId);
+    }
     this.daemon.broadcast({ type: 'agent:message_queued', agentId, message: wrapped });
   }
 

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

@@ -12,6 +12,7 @@ export class Registry extends EventEmitter {
     this.state = state;
     this.agents = new Map();
     this._counters = new Map();
+    this._pendingRemovals = [];
     this._initCounters();
   }
 
@@ -62,7 +63,10 @@ export class Registry extends EventEmitter {
     };
 
     this.agents.set(agent.id, agent);
-    this.emit('change', { changed: [agent.id] });
+    const removed = this._pendingRemovals.splice(0);
+    const delta = { changed: [agent.id] };
+    if (removed.length > 0) delta.removed = removed;
+    this.emit('change', delta);
     return agent;
   }
 
@@ -89,15 +93,26 @@ export class Registry extends EventEmitter {
     return agent;
   }
 
-  remove(id) {
+  remove(id, { silent = false } = {}) {
     const agent = this.agents.get(id);
     if (!agent) return false;
 
     this.agents.delete(id);
-    this.emit('change', { removed: [id] });
+    if (silent) {
+      this._pendingRemovals.push(id);
+    } else {
+      this.emit('change', { removed: [id] });
+    }
     return true;
   }
 
+  flushPendingRemovals() {
+    const removed = this._pendingRemovals.splice(0);
+    if (removed.length > 0) {
+      this.emit('change', { removed });
+    }
+  }
+
   findByRole(role) {
     return this.getAll().filter((a) => a.role === role);
   }

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

@@ -35,6 +35,7 @@ export class Rotator extends EventEmitter {
     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
+    this.userMessageTimes = new Map(); // agentId -> timestamp of last user message
     this.enabled = false;
     this.liveScores = {};
     this.scoreHistory = {};
@@ -118,6 +119,10 @@ export class Rotator extends EventEmitter {
     this.enabled = false;
   }
 
+  recordUserMessage(agentId) {
+    this.userMessageTimes.set(agentId, Date.now());
+  }
+
   _isOnCooldown(agentId, cooldownMs = COOLDOWN_MS) {
     const lastTime = this.lastRotationTime.get(agentId);
     if (!lastTime) return false;
@@ -284,14 +289,13 @@ export class Rotator extends EventEmitter {
       if (this._isOnCooldown(agent.id, QUALITY_COOLDOWN_MS)) continue;
 
       // Effective quality threshold depends on provider type.
-      // Self-managing providers (Claude Code): threshold = 15. Only rotate on
-      // truly catastrophic degradation. Normal debugging naturally produces
-      // errors, retries, and bash repetitions — the scoring model treats these
-      // as degradation but they're expected behavior during investigation.
-      // A threshold of 40 (the default) kills debugging sessions at ~8 minutes.
+      // Self-managing providers (Claude Code): threshold = 25. Only rotate on
+      // severe degradation. Normal debugging naturally produces errors, retries,
+      // and bash repetitions — the scoring model treats these as degradation
+      // but they're expected behavior during investigation.
       let effectiveQualityThreshold;
       if (selfManagesContext) {
-        effectiveQualityThreshold = 15;
+        effectiveQualityThreshold = 25;
       } else {
         effectiveQualityThreshold = QUALITY_THRESHOLD;
         if (compactions >= 3) effectiveQualityThreshold = 55;
@@ -300,10 +304,27 @@ export class Rotator extends EventEmitter {
         }
       }
 
+      // Context-awareness guard for self-managing providers: if the provider
+      // recently compacted and context is low, it's managing itself — the
+      // quality score alone is too unreliable to override that.
+      if (selfManagesContext && agent.contextUsage < 0.6) {
+        continue;
+      }
+
+      // User-activity guard: if the user sent a message recently, the cost of
+      // disrupting the session is much higher than letting it continue. Require
+      // catastrophic degradation (score < 5) before rotating.
+      const lastUserMsg = this.userMessageTimes.get(agent.id);
+      const userActiveRecently = lastUserMsg && (Date.now() - lastUserMsg) < 5 * 60 * 1000;
+      if (userActiveRecently) {
+        effectiveQualityThreshold = 5;
+      }
+
       const quality = this.scoreLiveSession(agent);
       if (quality.hasEnoughData && quality.score < effectiveQualityThreshold) {
         // For self-managing providers, effectiveQualityThreshold IS the severe
-        // threshold (15) — any score below it is catastrophic, rotate immediately.
+        // threshold (25, or 5 if user is active) — any score below it is
+        // catastrophic, rotate immediately.
         // For others, severe = < 25, moderate = 25-40/55.
         const severeThreshold = selfManagesContext ? effectiveQualityThreshold : 25;
         if (quality.score < severeThreshold) {
@@ -331,12 +352,36 @@ export class Rotator extends EventEmitter {
     }
   }
 
+  _detectIdleLoop(agentName) {
+    const thirtyMinAgo = Date.now() - 30 * 60 * 1000;
+    const recentLowToken = this.rotationHistory.filter(r =>
+      r.agentName === agentName &&
+      new Date(r.timestamp).getTime() > thirtyMinAgo &&
+      (r.oldTokens || 0) < 2000
+    );
+    return recentLowToken.length >= 3;
+  }
+
   async rotate(agentId, options = {}) {
     const { registry, processes, journalist } = this.daemon;
     const agent = registry.get(agentId);
     if (!agent) throw new Error(`Agent ${agentId} not found`);
     if (this.rotating.has(agentId)) throw new Error(`Agent ${agentId} is already rotating`);
 
+    // Idle rotation loop detection: if this agent name has completed 3+ times
+    // in the last 30 minutes with minimal tokens, the system is spinning — each
+    // replacement arrives blind, does nothing, and completes. Stop the cycle.
+    if (this._detectIdleLoop(agent.name)) {
+      console.warn(`  Rotator: ${agent.name} is in an idle rotation loop (3+ low-token rotations in 30 min). Skipping respawn — waiting for user input.`);
+      this.daemon.broadcast({
+        type: 'rotation:blocked',
+        agentId,
+        agentName: agent.name,
+        reason: 'idle_loop_detected',
+      });
+      return null;
+    }
+
     this.rotating.add(agentId);
 
     this.daemon.broadcast({
@@ -386,6 +431,30 @@ export class Rotator extends EventEmitter {
         }
       }
 
+      // Brief quality validation: if an AUTOMATIC rotation produces a brief
+      // with too little meaningful content, the new agent will arrive blind.
+      // Block it rather than spawning an agent that can't continue the work.
+      // Manual rotations (user-requested) are never blocked — the user accepts the risk.
+      const isAutoRotation = options.reason && options.reason !== 'manual';
+      if (isAutoRotation && !usedConversationThread) {
+        const briefContent = brief
+          .replace(/^#.*$/gm, '')           // strip markdown headers
+          .replace(/^[-*].*role:.*$/gim, '') // strip metadata lines
+          .replace(/^\s*$/gm, '')           // strip blank lines
+          .trim();
+        if (briefContent.length < 200) {
+          console.warn(`  Rotator: ${agent.name} handoff brief has only ${briefContent.length} chars of content — low-confidence handoff, skipping rotation`);
+          this.rotating.delete(agentId);
+          this.daemon.broadcast({
+            type: 'rotation:blocked',
+            agentId,
+            agentName: agent.name,
+            reason: 'low_confidence_handoff',
+          });
+          return null;
+        }
+      }
+
       if (agent.role === 'planner' && !brief.includes('PLANNING ONLY')) {
         brief = 'CRITICAL: You are a PLANNING ONLY agent. Do NOT implement code. Route all work to your team via .groove/recommended-team.json.\n\n' + brief;
       }
@@ -423,9 +492,10 @@ export class Rotator extends EventEmitter {
       const respawnModel = routingMode.mode === 'auto' ? 'auto' : agent.model;
 
       // Remove old agent BEFORE spawning so registry.add() won't dedup the name
-      // (appending "-2", "-2-2", etc.). Save config in case we need to re-add on failure.
+      // (appending "-2", "-2-2", etc.). Silent removal: the spawn's registry.add()
+      // will flush both removed+changed in one broadcast, preventing GUI flicker.
       const savedConfig = { ...agent };
-      registry.remove(agentId);
+      registry.remove(agentId, { silent: true });
       this.daemon.locks.release(agentId);
 
       let newAgent;
@@ -443,7 +513,8 @@ export class Rotator extends EventEmitter {
           isRotation: true,
         });
       } catch (spawnErr) {
-        // Spawn failed — re-add old agent so the user can see and retry.
+        // Spawn failed — flush the silent removal so GUI sees it, then re-add.
+        registry.flushPendingRemovals();
         registry.add({
           role: savedConfig.role, scope: savedConfig.scope, provider: savedConfig.provider,
           model: savedConfig.model, prompt: savedConfig.prompt, permission: savedConfig.permission,

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

@@ -428,6 +428,7 @@ export function registerAgentRoutes(app, daemon) {
 
       // Record user feedback so the journalist can include it in future agent context
       if (daemon.journalist) daemon.journalist.recordUserFeedback(agent, finalMessage);
+      if (daemon.rotator) daemon.rotator.recordUserMessage(req.params.id);
 
       // Agent loop path — send message directly to the running loop
       const wrappedMessage = wrapWithRoleReminder(agent.role, finalMessage);
@@ -449,20 +450,26 @@ export function registerAgentRoutes(app, daemon) {
         if (daemon.processes.isRunning(req.params.id)) {
           await daemon.processes.kill(req.params.id);
         }
-        daemon.registry.remove(req.params.id);
+        daemon.registry.remove(req.params.id, { silent: true });
         daemon.locks.release(req.params.id);
 
-        const newAgent = await daemon.processes.spawn({
-          role: oldConfig.role,
-          scope: oldConfig.scope,
-          provider: oldConfig.provider,
-          model: oldConfig.model,
-          prompt: finalMessage,
-          permission: oldConfig.permission || 'full',
-          workingDir: oldConfig.workingDir,
-          name: oldConfig.name,
-          teamId: oldConfig.teamId,
-        });
+        let newAgent;
+        try {
+          newAgent = await daemon.processes.spawn({
+            role: oldConfig.role,
+            scope: oldConfig.scope,
+            provider: oldConfig.provider,
+            model: oldConfig.model,
+            prompt: finalMessage,
+            permission: oldConfig.permission || 'full',
+            workingDir: oldConfig.workingDir,
+            name: oldConfig.name,
+            teamId: oldConfig.teamId,
+          });
+        } catch (spawnErr) {
+          daemon.registry.flushPendingRemovals();
+          throw spawnErr;
+        }
         daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed: false });
         return res.json(newAgent);
       }
@@ -472,21 +479,27 @@ export function registerAgentRoutes(app, daemon) {
       // run one prompt per spawn and cannot resume sessions.
       if (provider?.constructor?.nonInteractive && !daemon.processes.isRunning(req.params.id)) {
         const oldConfig = { ...agent };
-        daemon.registry.remove(req.params.id);
+        daemon.registry.remove(req.params.id, { silent: true });
         daemon.locks.release(req.params.id);
 
-        const newAgent = await daemon.processes.spawn({
-          role: oldConfig.role,
-          scope: oldConfig.scope,
-          provider: oldConfig.provider,
-          model: oldConfig.model,
-          prompt: finalMessage,
-          introContext: oldConfig.introContext,
-          permission: oldConfig.permission || 'full',
-          workingDir: oldConfig.workingDir,
-          name: oldConfig.name,
-          teamId: oldConfig.teamId,
-        });
+        let newAgent;
+        try {
+          newAgent = await daemon.processes.spawn({
+            role: oldConfig.role,
+            scope: oldConfig.scope,
+            provider: oldConfig.provider,
+            model: oldConfig.model,
+            prompt: finalMessage,
+            introContext: oldConfig.introContext,
+            permission: oldConfig.permission || 'full',
+            workingDir: oldConfig.workingDir,
+            name: oldConfig.name,
+            teamId: oldConfig.teamId,
+          });
+        } catch (spawnErr) {
+          daemon.registry.flushPendingRemovals();
+          throw spawnErr;
+        }
         daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed: false });
         return res.json(newAgent);
       }

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

@@ -479,6 +479,10 @@ export class TunnelManager {
       // Remote is behind npm — upgrade
       this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'upgrading', from: remoteVer, to: npmVer } });
 
+      const target = `${config.user}@${config.host}`;
+      const keyArgs = config.sshKeyPath ? ['-i', config.sshKeyPath] : [];
+      const sshBase = [...keyArgs, '-p', String(config.port || 22), '-o', 'ConnectTimeout=10', '-o', 'BatchMode=yes', target];
+
       const installCmd = npmGlobalInstall(`groove-dev@${npmVer}`, config.user);
       const cleanupCmd = 'rm -rf $(npm root -g)/.groove-dev-* $(npm root -g)/groove-dev 2>/dev/null || true';
 
@@ -496,40 +500,43 @@ export class TunnelManager {
         }
       }
 
-      // Restart remote daemon
+      // Restart remote daemon — fire and forget the SSH, verify through the tunnel
       const cdPrefix = config.projectDir ? `cd "${config.projectDir}" && ` : '';
-      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; `
-        : '';
-      const restartCmd = `kill $(lsof -t -i:${REMOTE_PORT}) 2>/dev/null || true; sleep 2; ${cdPrefix}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 && (${setProjectDir}true) || true`;
-      execFileSync('ssh', [...sshBase, sshCmd(restartCmd)], {
-        encoding: 'utf8', timeout: 60000, stdio: ['pipe', 'pipe', 'pipe'],
-      });
+      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'],
+        });
+      } catch { /* SSH may close before nohup finishes — that's fine */ }
 
-      // Verify through tunnel
+      // Wait for daemon to come back up through the existing tunnel
+      this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'starting' } });
       let daemonVer = null;
-      for (let i = 0; i < 3; i++) {
+      for (let i = 0; i < 8; i++) {
+        await new Promise(r => setTimeout(r, 2000));
         try {
-          const check = await fetch(`http://localhost:${localPort}/api/status`, {
-            signal: AbortSignal.timeout(3000),
-          });
+          const check = await fetch(`http://localhost:${localPort}/api/status`, { signal: AbortSignal.timeout(3000) });
           if (check.ok) {
             daemonVer = (await check.json()).version || null;
             break;
           }
-        } catch { /* retry */ }
-        await new Promise(r => setTimeout(r, 2000));
+        } catch { /* not up yet */ }
       }
 
-      const localVer = getLocalVersion();
-      if (daemonVer) {
-        this.daemon.broadcast({ type: 'tunnel.version-info', data: { id, localVersion: localVer, remoteVersion: daemonVer, match: daemonVer === localVer } });
-      } else {
-        this.daemon.broadcast({ type: 'tunnel.upgrade-failed', data: { id, error: 'Daemon did not respond after restart', from: remoteVer, attempted: npmVer } });
+      if (config.projectDir && daemonVer) {
+        try {
+          await fetch(`http://localhost:${localPort}/api/project-dir`, {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ path: config.projectDir }),
+            signal: AbortSignal.timeout(3000),
+          });
+        } catch { /* best effort */ }
       }
 
+      const localVer = getLocalVersion();
+      this.daemon.broadcast({ type: 'tunnel.version-info', data: { id, localVersion: localVer, remoteVersion: daemonVer || npmVer, match: (daemonVer || npmVer) === localVer } });
       this.daemon.audit.log('tunnel.upgrade', { id, from: remoteVer, to: daemonVer || npmVer });
     } catch (err) {
+      // Upgrade failed but tunnel may still work — check before reporting failure
       try {
         const verify = await fetch(`http://localhost:${localPort}/api/status`, { signal: AbortSignal.timeout(5000) });
         if (verify.ok) {
@@ -537,7 +544,7 @@ export class TunnelManager {
           this.daemon.broadcast({ type: 'tunnel.version-info', data: { id, localVersion: getLocalVersion(), remoteVersion: verifyData.version, match: false } });
           return;
         }
-      } catch { /* tunnel verification failed */ }
+      } catch { /* tunnel down */ }
       this.daemon.broadcast({ type: 'tunnel.upgrade-failed', data: { id, error: err.message } });
     }
   }

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

@@ -29,7 +29,7 @@ describe('Rotator', () => {
       },
       journalist: {
         async generateHandoffBrief(agent, options = {}) {
-          return `Handoff brief for ${agent.name}`;
+          return `## Handoff Brief\nAgent ${agent.name} was working on backend tasks in the project. The agent completed several file edits and ran tests successfully. Key context: the agent was modifying API routes and updating validation logic. Resume from where this agent left off and continue the implementation.`;
         },
       },
       memory: {