groove-dev 0.27.185 → 0.27.186

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

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

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

@@ -1441,6 +1441,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       'qcThreshold', 'maxAgents', 'defaultProvider', 'defaultWorkingDir',
       'onboardingDismissed', 'defaultModel', 'defaultChatProvider', 'defaultChatModel',
       'dataSharingDismissed', 'replayCeiling', 'velocityCeiling', 'journalistModelTier',
+      'resumeBudgetChars',
     ];
     for (const key of Object.keys(req.body)) {
       if (!ALLOWED_KEYS.includes(key)) {

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

@@ -10,6 +10,12 @@ import { agentLogPath } from './process.js';
 const DEFAULT_INTERVAL = 300_000; // 5 minutes (safety-net fallback; event-driven triggers handle the normal case)
 const MAX_LOG_CHARS = 100_000; // ~25k tokens budget for synthesis input (captures 80-90% of recent activity)
 const DEBOUNCE_MS = 10_000; // requestSynthesis debounce window
+// Conversation carried across a rotation (~37K tokens at 150K chars). This is
+// deliberately generous: a rotation is the one lossy step in an infinite
+// session, and re-reading the recent dialogue once per rotation is far cheaper
+// than the degradation from an agent that forgot its own history. Tune via
+// config resumeBudgetChars (lower for cost-sensitive fleets).
+const DEFAULT_RESUME_BUDGET_CHARS = 150_000;
 
 export class Journalist {
   constructor(daemon) {
@@ -1061,7 +1067,51 @@ export class Journalist {
    *
    * Budget: keeps recent turns verbatim, summarizes oldest if over maxChars.
    */
-  extractConversationThread(agent, { maxChars = 60000 } = {}) {
+  extractConversationThread(agent, { maxChars } = {}) {
+    // Budget is configurable (resumeBudgetChars): this is the "how much memory
+    // survives a rotation" dial. Bigger costs more tokens per rotation but
+    // preserves more of the session; a rotation is lossy exactly here.
+    if (!maxChars) maxChars = this.daemon.config?.resumeBudgetChars ?? DEFAULT_RESUME_BUDGET_CHARS;
+    const merged = this._parseConversationTurns(agent);
+    if (!merged || merged.length === 0) return null;
+
+    // Build the thread — keep recent turns verbatim, truncate old ones if over budget
+    let thread = '';
+    const formatted = merged.map((t) => {
+      const label = t.role === 'user' ? 'USER' : 'CLAUDE';
+      return `[${label}]:\n${t.text}`;
+    });
+
+    // Start from the end (most recent) and work backwards to fill budget
+    const recentFirst = [...formatted].reverse();
+    const kept = [];
+    let totalLen = 0;
+
+    for (const entry of recentFirst) {
+      if (totalLen + entry.length > maxChars) {
+        // Truncate this entry to fit remaining budget
+        const remaining = maxChars - totalLen;
+        if (remaining > 200) {
+          kept.push(entry.slice(0, remaining) + '\n[...truncated]');
+        }
+        break;
+      }
+      kept.push(entry);
+      totalLen += entry.length;
+    }
+
+    // Reverse back to chronological order
+    kept.reverse();
+    thread = kept.join('\n\n---\n\n');
+
+    return thread;
+  }
+
+  /**
+   * Parse the full user↔assistant turn list from an agent's stream-json log.
+   * Returns merged turns in chronological order, or null if no log/turns.
+   */
+  _parseConversationTurns(agent) {
     const logPath = agentLogPath(this.daemon.grooveDir, agent);
     if (!existsSync(logPath)) return null;
 
@@ -1121,37 +1171,23 @@ export class Journalist {
         merged.push({ ...turn });
       }
     }
+    return merged;
+  }
 
-    // Build the thread — keep recent turns verbatim, truncate old ones if over budget
-    let thread = '';
-    const formatted = merged.map((t) => {
-      const label = t.role === 'user' ? 'USER' : 'CLAUDE';
-      return `[${label}]:\n${t.text}`;
-    });
-
-    // Start from the end (most recent) and work backwards to fill budget
-    const recentFirst = [...formatted].reverse();
-    const kept = [];
-    let totalLen = 0;
-
-    for (const entry of recentFirst) {
-      if (totalLen + entry.length > maxChars) {
-        // Truncate this entry to fit remaining budget
-        const remaining = maxChars - totalLen;
-        if (remaining > 200) {
-          kept.push(entry.slice(0, remaining) + '\n[...truncated]');
-        }
-        break;
-      }
-      kept.push(entry);
-      totalLen += entry.length;
-    }
-
-    // Reverse back to chronological order
-    kept.reverse();
-    thread = kept.join('\n\n---\n\n');
-
-    return thread;
+  /**
+   * The agent's ORIGINAL task, from the first substantial user message in the
+   * FULL log — never from the truncated resume window. When weeks of dialogue
+   * exceed the resume budget, the window holds only recent work; anchoring the
+   * task there makes the agent's identity drift onto whatever happened last.
+   * The name-keyed log spans all rotations, so the true origin is always here.
+   */
+  extractOriginalTask(agent) {
+    const merged = this._parseConversationTurns(agent);
+    if (!merged) return '';
+    const first = merged.find((t) => t.role === 'user' && t.text.trim().length >= 10);
+    if (!first) return '';
+    const text = first.text.trim();
+    return text.length > 500 ? text.slice(0, 500) + '...' : text;
   }
 
   /**
@@ -1159,15 +1195,17 @@ export class Journalist {
    * thread so a fresh agent picks up where the previous session left off.
    */
   buildConversationResumePrompt(agent, userMessage, { isRotation = false, reason } = {}) {
-    const thread = this.extractConversationThread(agent);
+    const budget = this.daemon.config?.resumeBudgetChars ?? DEFAULT_RESUME_BUDGET_CHARS;
+    const thread = this.extractConversationThread(agent, { maxChars: budget });
     if (!thread) return null;
 
     const constraints = this.daemon.memory?.getConstraintsMarkdown(2000) || '';
     const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 5, 1000, agent.scope, agent.teamId) || '';
 
-    // Extract the user's original task from the conversation — the first substantial
-    // user message is almost always the task assignment. This anchors the new agent.
-    const originalTask = this._extractOriginalTask(thread);
+    // Anchor the agent to its ORIGINAL task from the full log — the truncated
+    // thread's first message may be mid-project (or another agent's task) once
+    // history outgrows the budget. Fall back to the window only if the log parse fails.
+    const originalTask = this.extractOriginalTask(agent) || this._extractOriginalTask(thread);
 
     // Rotation and idle-resume need very different framing. During rotation the agent
     // has no new user message — it must continue the exact in-progress task without
@@ -1181,6 +1219,7 @@ export class Journalist {
       originalTask ? `Your task: ${originalTask}` : '',
       ``,
       `Rules:`,
+      `- NEVER mention the rotation, context refresh, restart, or any session discontinuity to the user — from the user's perspective you are one continuous agent and this refresh must be invisible`,
       `- Continue ONLY the task described in the conversation below`,
       `- Do NOT explore the codebase looking for other things to fix or improve`,
       `- Do NOT start new work that was not part of the original task`,
@@ -1210,14 +1249,16 @@ export class Journalist {
       isIdleResume ? `## New Message From User\n\n${userMessage}` : '',
       ``,
       isRotation
-        ? `Continue the in-progress task from the conversation above. Stay focused on that task only. Do not ask the user to repeat anything. If the task was already completed, state that and wait for new instructions.`
-        : `Continue seamlessly from the conversation above. You have the full context of what was discussed, what was tried, what worked and what didn't. Do not ask the user to repeat anything.`,
+        ? `Continue the in-progress task from the conversation above. Stay focused on that task only. Do not ask the user to repeat anything, and never reference this context refresh — continue as if the conversation above simply never stopped. If the task was already completed, state that and wait for new instructions.`
+        : `Continue seamlessly from the conversation above. You have the full context of what was discussed, what was tried, what worked and what didn't. Do not ask the user to repeat anything, and never mention the interruption or that you are resuming — to the user this is one continuous conversation.`,
     ].filter(Boolean).join('\n');
 
-    // Hard cap at 80K chars (~20K tokens) to leave plenty of room in context window
-    if (prompt.length > 80000) {
+    // Cap scales with the configured budget (framing adds constraints/discoveries
+    // on top of the thread) to leave room in the context window
+    const promptCap = budget + 20_000;
+    if (prompt.length > promptCap) {
       // Re-extract with smaller budget and rebuild
-      const smallerThread = this.extractConversationThread(agent, { maxChars: 40000 });
+      const smallerThread = this.extractConversationThread(agent, { maxChars: Math.floor(budget * 2 / 3) });
       if (smallerThread) {
         prompt = [
           `# Session Context Resume`,
@@ -1238,8 +1279,8 @@ export class Journalist {
           isIdleResume ? `## New Message From User\n\n${userMessage}` : '',
           ``,
           isRotation
-            ? `Continue the in-progress task only. Do not explore or start new work. If done, state that and wait.`
-            : `Continue seamlessly. Do not ask the user to repeat anything.`,
+            ? `Continue the in-progress task only. Do not explore or start new work. Never mention this context refresh to the user. If done, state that and wait.`
+            : `Continue seamlessly. Do not ask the user to repeat anything, and never mention the interruption — to the user this is one continuous conversation.`,
         ].filter(Boolean).join('\n');
       }
     }

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

@@ -18,7 +18,12 @@ const SCORE_HISTORY_MAX = 40;   // ~10 min at 15s intervals
 const COOLDOWN_MS = 5 * 60 * 1000;   // 5 minutes between rotations per agent
 const QUALITY_COOLDOWN_MS = 2 * 60 * 1000; // 2 minutes for quality degradation rotations
 const TOKEN_CEILING = 5_000_000;     // 5M tokens per agent (non-self-managing only)
-const REPLAY_CEILING = 0.50;         // Self-managing providers: rotate idle agents above this context usage
+// Self-managing providers: rotate idle agents above this context usage.
+// 0.80 favors context retention over cache-read cost — the conversation-resume
+// window is a slice of the full session, so every rotation is lossy; for
+// complex long-lived work that loss compounds faster than token savings pay off.
+// Lower via config (replayCeiling) for cost-sensitive fleets; 0 disables.
+const REPLAY_CEILING = 0.80;
 const VELOCITY_CEILING = 250_000;    // New (non-cache) tokens per window before force rotation
 const VELOCITY_WINDOW_MS = 5 * 60_000;
 const ROLE_MULTIPLIERS = {

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

@@ -234,6 +234,65 @@ describe('Journalist', () => {
     });
   });
 
+  describe('conversation resume', () => {
+    // Build a log whose first user message is the task assignment, followed by
+    // enough later dialogue that a small budget truncates the early turns away.
+    function writeLongConversation(grooveDir, agentName, originalTask, fillerTurns = 20) {
+      const lines = [
+        JSON.stringify({ type: 'user', message: { content: originalTask } }),
+        JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'Understood — starting on the original task now, here is my plan.' }] } }),
+      ];
+      for (let i = 0; i < fillerTurns; i++) {
+        lines.push(JSON.stringify({ type: 'user', message: { content: `Follow-up question number ${i}: ${'detail '.repeat(50)}` } }));
+        lines.push(JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: `Answer to follow-up ${i}: ${'context '.repeat(50)}` }] } }));
+      }
+      writeFileSync(join(grooveDir, 'logs', `${agentName}.log`), lines.join('\n'));
+    }
+
+    const agentFixture = {
+      id: 'arch-id-1', name: 'arch-1', role: 'backend',
+      provider: 'claude-code', scope: ['src/**'], workingDir: '/tmp',
+    };
+
+    it('rotation resume prompt forbids mentioning the rotation to the user', () => {
+      const { daemon, grooveDir } = createMockDaemon();
+      const journalist = new Journalist(daemon);
+      writeLongConversation(grooveDir, 'arch-1', 'Build the training pipeline', 2);
+
+      const prompt = journalist.buildConversationResumePrompt(agentFixture, '', { isRotation: true, reason: 'replay_ceiling' });
+
+      assert.ok(prompt, 'should build a resume prompt');
+      assert.ok(prompt.includes('NEVER mention the rotation'), 'must instruct the agent to keep the rotation invisible');
+    });
+
+    it('anchors the original task from the full log even when the thread window truncates it', () => {
+      const { daemon, grooveDir } = createMockDaemon();
+      // Small budget: only recent filler turns survive in the thread window
+      daemon.config = { resumeBudgetChars: 3000 };
+      const journalist = new Journalist(daemon);
+      const originalTask = 'Build a mixture-of-experts LLM training pipeline from scratch';
+      writeLongConversation(grooveDir, 'arch-1', originalTask, 20);
+
+      // Sanity: the truncated window no longer contains the original task
+      const thread = journalist.extractConversationThread(agentFixture);
+      assert.ok(thread, 'should extract a thread');
+      assert.ok(!thread.includes(originalTask), 'test setup: original task must be truncated out of the window');
+
+      const prompt = journalist.buildConversationResumePrompt(agentFixture, '', { isRotation: true, reason: 'replay_ceiling' });
+      assert.ok(prompt.includes(originalTask), 'original task must still anchor the prompt via the full log');
+    });
+
+    it('honors resumeBudgetChars config for the thread window', () => {
+      const { daemon, grooveDir } = createMockDaemon();
+      daemon.config = { resumeBudgetChars: 2000 };
+      const journalist = new Journalist(daemon);
+      writeLongConversation(grooveDir, 'arch-1', 'Build the training pipeline', 20);
+
+      const thread = journalist.extractConversationThread(agentFixture);
+      assert.ok(thread.length <= 2500, `thread should respect the configured budget, got ${thread.length}`);
+    });
+  });
+
   describe('status', () => {
     it('should report status correctly', () => {
       const { daemon } = createMockDaemon();

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

@@ -457,7 +457,7 @@ describe('Rotator', () => {
     const agent = {
       id: 'rc1', name: 'claude-chat', role: 'backend', status: 'running',
       provider: 'claude-code', scope: [], model: null,
-      tokensUsed: 100_000, contextUsage: 0.55, workingDir: '/tmp',
+      tokensUsed: 100_000, contextUsage: 0.85, workingDir: '/tmp',
       lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(), // idle 5 min
       spawnedAt: new Date(Date.now() - 600_000).toISOString(),
     };
@@ -470,22 +470,40 @@ describe('Rotator', () => {
     assert.equal(history[0].reason, 'replay_ceiling');
   });
 
+  it('should honor a configured replayCeiling below the default', async () => {
+    const agent = {
+      id: 'rc5', name: 'claude-cheap', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 100_000, contextUsage: 0.55, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+    mockDaemon.config = { replayCeiling: 0.5 };
+
+    await rotator.check();
+
+    const history = rotator.getHistory();
+    assert.equal(history.length, 1);
+    assert.equal(history[0].reason, 'replay_ceiling');
+  });
+
   it('should NOT replay-ceiling rotate below the ceiling or during cooldown', async () => {
     const agent = {
       id: 'rc2', name: 'claude-chat-2', role: 'backend', status: 'running',
       provider: 'claude-code', scope: [], model: null,
-      tokensUsed: 100_000, contextUsage: 0.45, workingDir: '/tmp',
+      tokensUsed: 100_000, contextUsage: 0.75, workingDir: '/tmp',
       lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(),
       spawnedAt: new Date(Date.now() - 600_000).toISOString(),
     };
     mockDaemon.registry.agents = [agent];
 
-    // Below ceiling — no rotation
+    // Below ceiling (0.75 < 0.80 default) — no rotation
     await rotator.check();
     assert.equal(rotator.getHistory().length, 0);
 
     // Above ceiling but on cooldown — still no rotation
-    agent.contextUsage = 0.60;
+    agent.contextUsage = 0.85;
     rotator.lastRotationTime.set('rc2', Date.now() - 60_000);
     await rotator.check();
     assert.equal(rotator.getHistory().length, 0);