groove-dev 0.27.0 → 0.27.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## v0.27.1 — Seamless rotation hotfix (2026-04-12)
+
+Fixes a severe UX regression where planner and other exploration-heavy agents auto-rotated on legitimate activity, breaking the "infinite sessions" promise.
+
+**The bug**
+Running a planner on a new project triggered `runaway_velocity` rotation at 2M tokens / 5min — which is normal behavior for a planner reading a codebase. The rotation killed the chat panel, reset the agent, and made the session feel broken. The whole point of context rotation is that it should be invisible to the user.
+
+**Fixes**
+
+- **Role-based safety multipliers.** Planners, fullstack auditors, analysts, and security roles now have much higher velocity/ceiling thresholds by default. Planner gets 10× (effective 15M/5min), fullstack/security get 4×, analyst 5×. Implementers (backend, frontend) stay at 1×. User-overridable via `safety.roleMultipliers` config.
+- **Handoff brief rewritten for seamless continuation.** The agent is no longer told "this is a context rotation, the previous session is being replaced." It's now instructed to continue the conversation naturally — no greetings, no "resuming", no announcement. From the user's side, the conversation never paused.
+- **User's recent messages included in the brief.** Previously the new agent had no memory of what the user was asking for. Now the last 5 user messages to this agent are carried forward so the conversation resumes with full context.
+- **Chat history always migrates on rotation.** Previously only migrated when the user had the old agent's detail panel open — if they'd navigated away, chat was orphaned forever. Now migrates unconditionally for all agent-keyed state (chat, activity log, token timeline, draft input). Persisted to localStorage immediately.
+- **Rotation toasts silenced.** "Rotating..." and "Rotated, saved X tokens" toasts removed from the default flow. Rotations still fully visible in the dashboard Intel panel for users who want to see them.
+
+Tests: 218 → 221 (+3 covering planner multiplier and config overrides).
+
 ## v0.27.0 — Audit-driven release: visibility, safety, Layer 7 memory (2026-04-12)
 
 Backend audit after a 275M-token stress test revealed three classes of gaps: blind spots (invisible tokens), unvalidated claims (hardcoded coefficients posing as measurements), and missing memory (every new agent started from scratch). This release closes all three.

package/CLAUDE.md

@@ -263,3 +263,10 @@ Audit-driven release. Multi-agent orchestration system with 7 coordination layer
 - Dashboard: routing donut, cache panel, context health gauges
 - Monitor/QC agent mode (stay active, loop)
 - Distribution: demo video, HN launch, Twitter content
+
+<!-- GROOVE:START -->
+## GROOVE Orchestration (auto-injected)
+Active agents: 0
+See AGENTS_REGISTRY.md for full agent state.
+**Memory policy:** Ignore auto-memory. Do not read or write MEMORY.md. GROOVE manages all context.
+<!-- GROOVE:END -->

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

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

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

@@ -689,12 +689,31 @@ export class Journalist {
     // with, decided, and solved — not just what the current session did.
     const recentChain = this.daemon.memory?.getRecentHandoffMarkdown(agent.role, 3, 3000) || '';
 
+    // Pull the user's recent messages to this agent so the new instance
+    // can continue the conversation naturally instead of restarting it.
+    // Without this, the user feels like their chat was lost.
+    const allFeedback = this.getUserFeedback() || [];
+    const agentFeedback = allFeedback
+      .filter((fb) => fb.agentId === agent.id || fb.agentName === agent.name)
+      .slice(-5);
+    const conversationSummary = agentFeedback.length > 0
+      ? agentFeedback.map((fb) => `- "${fb.message}"`).join('\n')
+      : '';
+
     return [
-      `# Agent Handoff Brief`,
+      `# Session Continuation`,
+      ``,
+      `You are **${agent.name}** (role: ${agent.role}). This is an internal context refresh — `,
+      `the conversation with the user is ongoing and must feel seamless to them. They cannot see this brief.`,
+      ``,
+      `## CRITICAL: Continue Seamlessly`,
       ``,
-      `You are continuing the work of **${agent.name}** (role: ${agent.role}).`,
-      `This is a context rotation — the previous session is being replaced to keep context fresh.`,
+      `Do NOT announce a restart, rotation, or resumption. Do NOT greet the user. Do NOT say `,
+      `"resuming", "continuing from where I left off", "let me check state again", or anything `,
+      `that signals a break in the conversation. The user's next message should be answered as `,
+      `if the last turn of conversation just happened — because from their side, it did.`,
       ``,
+      conversationSummary ? `## Recent User Messages (what they've been asking for)\n\n${conversationSummary}\n` : '',
       recentChain ? `## Rotation History (recent)\n\n${recentChain}\n` : '',
       `## Your Identity`,
       `- Role: ${agent.role}`,
@@ -702,7 +721,7 @@ export class Journalist {
       `- Provider: ${agent.provider}`,
       agent.workingDir ? `- Working directory: ${agent.workingDir}` : '',
       ``,
-      `## Previous Session`,
+      `## Session State`,
       `- Tokens used: ${agent.tokensUsed}`,
       `- Tool calls: ${entries.filter((e) => e.type === 'tool').length}`,
       ``,
@@ -713,12 +732,13 @@ export class Journalist {
       ``,
       projectMap ? projectMap.slice(0, 10000) : 'No project map available yet.',
       ``,
-      `## Instructions`,
+      `## How to Respond`,
       ``,
-      `Continue the work from where the previous session left off.`,
-      `Review AGENTS_REGISTRY.md for team awareness.`,
-      agent.workingDir ? `Stay within your working directory: ${agent.workingDir}` : '',
-      agent.prompt ? `\nOriginal task: ${agent.prompt}` : '',
+      `Wait for the user's next message, then answer it directly. If they asked a question or gave `,
+      `an instruction in the Recent User Messages section above and it's still unanswered, address `,
+      `that naturally. Match the tone and continuity of a conversation that never paused.`,
+      agent.workingDir ? `Stay within your working directory: ${agent.workingDir}.` : '',
+      agent.prompt ? `\nOriginal task context: ${agent.prompt}` : '',
     ].filter(Boolean).join('\n');
   }
 

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

@@ -136,6 +136,27 @@ export class Rotator extends EventEmitter {
     return result;
   }
 
+  // Per-role safety multipliers. Exploration-heavy roles burn tokens fast
+  // by design (reading codebases, searching files) — a planner running
+  // normally can hit 2M+ tokens in 5 min just reading. One-size-fits-all
+  // thresholds produce false positives on exactly the roles that need to
+  // read fast. Multipliers scale both the velocity threshold and the
+  // instance ceiling. User can override via config.safety.roleMultipliers.
+  _getRoleMultiplier(role) {
+    const safety = this.daemon.config?.safety;
+    const overrides = safety?.roleMultipliers || {};
+    if (overrides[role] != null) return overrides[role];
+    // Defaults tuned from observed legitimate velocity
+    const defaults = {
+      planner: 10,    // heavy exploration — effectively exempt in practice
+      fullstack: 4,   // QC auditors read broadly
+      analyst: 5,     // research/analysis roles
+      security: 4,    // audit roles
+      docs: 1,        // focused edits
+    };
+    return defaults[role] || 1;
+  }
+
   // Safety triggers — runaway agent detection. Scoped to `spawnedAt` so
   // a rotation doesn't re-trigger on inherited cumulative tokens.
   _checkSafetyTriggers(agent) {
@@ -143,8 +164,11 @@ export class Rotator extends EventEmitter {
     if (!safety || safety.autoRotate === false) return null;
     if (!this.daemon.tokens || !agent.spawnedAt) return null;
 
+    const multiplier = this._getRoleMultiplier(agent.role);
     const spawnedAtMs = new Date(agent.spawnedAt).getTime();
-    const ceiling = safety.tokenCeilingPerAgent;
+
+    const baseCeiling = safety.tokenCeilingPerAgent;
+    const ceiling = baseCeiling > 0 ? Math.round(baseCeiling * multiplier) : 0;
     if (ceiling > 0) {
       const instanceTokens = this.daemon.tokens.getTokensInWindow(agent.id, spawnedAtMs);
       if (instanceTokens >= ceiling) {
@@ -152,12 +176,16 @@ export class Rotator extends EventEmitter {
           reason: 'token_limit_exceeded',
           instanceTokens,
           ceiling,
+          multiplier,
         };
       }
     }
 
     const windowMs = (safety.velocityWindowSeconds || 300) * 1000;
-    const velocityThreshold = safety.velocityTokenThreshold;
+    const baseVelocityThreshold = safety.velocityTokenThreshold;
+    const velocityThreshold = baseVelocityThreshold > 0
+      ? Math.round(baseVelocityThreshold * multiplier)
+      : 0;
     if (velocityThreshold > 0) {
       const velocity = this.daemon.tokens.getVelocity(agent.id, windowMs);
       if (velocity >= velocityThreshold) {
@@ -166,6 +194,7 @@ export class Rotator extends EventEmitter {
           velocity,
           windowMs,
           threshold: velocityThreshold,
+          multiplier,
         };
       }
     }

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

@@ -168,7 +168,7 @@ describe('Journalist', () => {
   });
 
   describe('generateHandoffBrief', () => {
-    it('should generate a handoff brief for context rotation', async () => {
+    it('should generate a handoff brief for seamless session continuation', async () => {
       const { daemon, grooveDir } = createMockDaemon();
       const journalist = new Journalist(daemon);
 
@@ -192,7 +192,10 @@ describe('Journalist', () => {
       const brief = await journalist.generateHandoffBrief(agent);
 
       assert.ok(brief.includes('backend-1'));
-      assert.ok(brief.includes('context rotation'));
+      // The brief must NOT tell the agent to announce a rotation/restart —
+      // seamless infinite sessions require the agent to continue naturally.
+      assert.ok(brief.includes('seamless') || brief.includes('Continue'));
+      assert.ok(!brief.includes('previous session is being replaced'));
       assert.ok(brief.includes('src/api/**'));
       assert.ok(brief.includes('5000'));
       assert.ok(brief.includes('Build the auth API'));

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

@@ -256,6 +256,54 @@ describe('Rotator', () => {
       assert.equal(trigger, null);
     });
 
+    it('planner gets a 10x multiplier so normal exploration does not trigger', () => {
+      mockDaemon.config = {
+        safety: {
+          autoRotate: true,
+          tokenCeilingPerAgent: 5_000_000,
+          velocityWindowSeconds: 300,
+          velocityTokenThreshold: 1_500_000,
+        },
+      };
+      // 2M in 5min would have triggered under v0.27.0 defaults (user bug report)
+      mockDaemon.tokens.getTokensInWindow = () => 3_000_000;
+      mockDaemon.tokens.getVelocity = () => 2_053_414;
+      const trigger = rotator._checkSafetyTriggers(mkAgent({ role: 'planner' }));
+      assert.equal(trigger, null, 'planner should NOT trigger on 2M velocity');
+    });
+
+    it('planner still triggers on genuinely runaway velocity (>15M per 5min)', () => {
+      mockDaemon.config = {
+        safety: {
+          autoRotate: true,
+          tokenCeilingPerAgent: 5_000_000,
+          velocityWindowSeconds: 300,
+          velocityTokenThreshold: 1_500_000,
+        },
+      };
+      mockDaemon.tokens.getTokensInWindow = () => 1_000_000;
+      mockDaemon.tokens.getVelocity = () => 20_000_000;
+      const trigger = rotator._checkSafetyTriggers(mkAgent({ role: 'planner' }));
+      assert.equal(trigger.reason, 'runaway_velocity');
+      assert.equal(trigger.threshold, 15_000_000, 'planner threshold = 1.5M × 10');
+    });
+
+    it('role multipliers are config-overridable', () => {
+      mockDaemon.config = {
+        safety: {
+          autoRotate: true,
+          tokenCeilingPerAgent: 1_000_000,
+          velocityWindowSeconds: 300,
+          velocityTokenThreshold: 500_000,
+          roleMultipliers: { backend: 2, frontend: 2 },
+        },
+      };
+      mockDaemon.tokens.getTokensInWindow = () => 1_500_000; // above base ceiling
+      mockDaemon.tokens.getVelocity = () => 0;
+      const backendTrigger = rotator._checkSafetyTriggers(mkAgent({ role: 'backend' }));
+      assert.equal(backendTrigger, null, 'backend with 2x multiplier should allow 2M ceiling');
+    });
+
     it('stats track safety-triggered rotations separately', async () => {
       mockDaemon.registry.agents = [mkAgent({ tokensUsed: 1_200_000 })];
       await rotator.rotate('a1', {