groove-dev 0.27.181 → 0.27.183

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

@@ -0,0 +1,108 @@
+// GROOVE — Agent Rename Migration Tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from 'fs';
+import { resolve } from 'path';
+import { tmpdir } from 'os';
+import { renameAgent } from '../src/rename.js';
+import { Registry } from '../src/registry.js';
+
+describe('renameAgent', () => {
+  let root, daemon, agent;
+
+  beforeEach(() => {
+    root = mkdtempSync(resolve(tmpdir(), 'groove-rename-'));
+    const grooveDir = resolve(root, '.groove');
+    mkdirSync(resolve(grooveDir, 'logs'), { recursive: true });
+    mkdirSync(resolve(grooveDir, 'personalities'), { recursive: true });
+    mkdirSync(resolve(root, 'agent-files'), { recursive: true });
+
+    const registry = new Registry({ save() {}, load() { return null; } });
+    daemon = {
+      registry,
+      grooveDir,
+      projectDir: root,
+      audit: { log() {} },
+    };
+    agent = registry.add({ role: 'fullstack', name: 'fullstack-1' });
+
+    writeFileSync(resolve(grooveDir, 'logs', 'fullstack-1.log'), 'session history');
+    writeFileSync(resolve(grooveDir, 'personalities', 'fullstack-1.md'), 'be terse');
+    mkdirSync(resolve(root, 'agent-files', 'fullstack-1'));
+    writeFileSync(resolve(root, 'agent-files', 'fullstack-1', 'notes.md'), 'notes');
+  });
+
+  afterEach(() => rmSync(root, { recursive: true, force: true }));
+
+  const p = {
+    log: (n) => resolve(root, '.groove', 'logs', `${n}.log`),
+    personality: (n) => resolve(root, '.groove', 'personalities', `${n}.md`),
+    files: (n) => resolve(root, 'agent-files', n),
+  };
+
+  it('migrates the log, personality and agent-files', () => {
+    renameAgent(daemon, agent.id, 'senior-dev');
+
+    assert.equal(daemon.registry.get(agent.id).name, 'senior-dev');
+
+    assert.ok(!existsSync(p.log('fullstack-1')), 'old log removed');
+    assert.equal(readFileSync(p.log('senior-dev'), 'utf8'), 'session history');
+
+    assert.ok(!existsSync(p.personality('fullstack-1')));
+    assert.equal(readFileSync(p.personality('senior-dev'), 'utf8'), 'be terse');
+
+    assert.ok(!existsSync(p.files('fullstack-1')));
+    assert.equal(readFileSync(resolve(p.files('senior-dev'), 'notes.md'), 'utf8'), 'notes');
+  });
+
+  it('rejects a name already taken by another agent', () => {
+    daemon.registry.add({ role: 'fullstack', name: 'fullstack-2' });
+    assert.throws(() => renameAgent(daemon, agent.id, 'fullstack-2'), /already exists/);
+
+    // Nothing moved — the original log must survive a rejected rename.
+    assert.equal(daemon.registry.get(agent.id).name, 'fullstack-1');
+    assert.equal(readFileSync(p.log('fullstack-1'), 'utf8'), 'session history');
+  });
+
+  it('rejects an empty name and no-ops an unchanged one', () => {
+    assert.throws(() => renameAgent(daemon, agent.id, '   '), /name is required/);
+    const same = renameAgent(daemon, agent.id, 'fullstack-1');
+    assert.equal(same.name, 'fullstack-1');
+    assert.equal(readFileSync(p.log('fullstack-1'), 'utf8'), 'session history');
+  });
+
+  it('throws for an unknown agent', () => {
+    assert.throws(() => renameAgent(daemon, 'nope', 'whatever'), /Agent not found/);
+  });
+
+  it('tolerates missing artifacts', () => {
+    rmSync(p.personality('fullstack-1'));
+    rmSync(p.files('fullstack-1'), { recursive: true });
+
+    renameAgent(daemon, agent.id, 'solo');
+    assert.equal(readFileSync(p.log('solo'), 'utf8'), 'session history');
+    assert.ok(!existsSync(p.personality('solo')));
+  });
+
+  it('rejects names that would escape their directory', () => {
+    // These become path segments (agent-files/<name>), so a separator or a
+    // dot-segment would write outside the intended directory.
+    for (const bad of ['front end/dev', '../escape', '..', 'a/../../b', 'has space']) {
+      assert.throws(() => renameAgent(daemon, agent.id, bad), /name may only contain|name must be/);
+    }
+    assert.equal(daemon.registry.get(agent.id).name, 'fullstack-1');
+    assert.ok(existsSync(p.log('fullstack-1')));
+  });
+
+  it('rejects an over-long name', () => {
+    assert.throws(() => renameAgent(daemon, agent.id, 'x'.repeat(65)), /64 characters/);
+  });
+
+  it('blocks a bare registry.update from renaming without migration', () => {
+    daemon.registry.update(agent.id, { name: 'sneaky' });
+    assert.equal(daemon.registry.get(agent.id).name, 'fullstack-1');
+    assert.ok(existsSync(p.log('fullstack-1')), 'log was never orphaned');
+  });
+});

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

@@ -452,4 +452,135 @@ describe('Rotator', () => {
     assert.equal(appendArgs.teamId, 'team-alpha');
     assert.equal(appendArgs.role, 'backend');
   });
+
+  it('should rotate idle Claude Code agent above the replay ceiling', async () => {
+    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',
+      lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(), // idle 5 min
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+
+    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',
+      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
+    await rotator.check();
+    assert.equal(rotator.getHistory().length, 0);
+
+    // Above ceiling but on cooldown — still no rotation
+    agent.contextUsage = 0.60;
+    rotator.lastRotationTime.set('rc2', Date.now() - 60_000);
+    await rotator.check();
+    assert.equal(rotator.getHistory().length, 0);
+  });
+
+  it('should block auto-rotation of a chat agent when no conversation thread is extractable', async () => {
+    const agent = {
+      id: 'rc3', name: 'claude-chat-3', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 100_000, contextUsage: 0.70, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+
+    // Agent has chat history, but journalist can't extract the thread
+    rotator.recordUserMessage('rc3');
+    mockDaemon.journalist.buildConversationResumePrompt = () => null;
+
+    const result = await rotator.rotate('rc3', { reason: 'replay_ceiling' });
+
+    assert.equal(result, null);
+    assert.equal(rotator.getHistory().length, 0);
+    const blocked = broadcasts.find((b) => b.type === 'rotation:blocked');
+    assert.ok(blocked, 'should broadcast rotation:blocked');
+    assert.equal(blocked.reason, 'no_conversation_thread');
+  });
+
+  it('should not let Instructions boilerplate defeat the low-confidence handoff guard', async () => {
+    const agent = {
+      id: 'rc4', name: 'claude-chat-4', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 100_000, contextUsage: 0.70, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+
+    // A content-free brief padded with the static Instructions block —
+    // this is exactly what generateHandoffBrief emits when logs are empty
+    mockDaemon.journalist.generateHandoffBrief = async () => [
+      '# Handoff Brief',
+      '- role: backend',
+      '## Instructions',
+      '',
+      'Continue and finish the in-progress task — deliver the output. Stay focused on that specific task only.',
+      '- Do NOT explore the codebase looking for other things to fix or improve',
+      '- Do NOT start new work outside the original task scope',
+      '- Do NOT act on TODO comments, code quality issues, or improvements you notice in passing',
+      '- If the task is already complete, report what was accomplished and STOP — await new instructions from the user',
+    ].join('\n');
+
+    const result = await rotator.rotate('rc4', { reason: 'replay_ceiling' });
+
+    assert.equal(result, null);
+    assert.equal(rotator.getHistory().length, 0);
+    const blocked = broadcasts.find((b) => b.type === 'rotation:blocked');
+    assert.ok(blocked, 'should broadcast rotation:blocked');
+    assert.equal(blocked.reason, 'low_confidence_handoff');
+  });
+
+  it('should force-rotate any provider on velocity ceiling', async () => {
+    const agent = {
+      id: 'v1', name: 'claude-runaway', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 400_000, contextUsage: 0.30, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5_000).toISOString(), // active
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+    mockDaemon.tokens.getVelocity = () => 300_000; // above 250K/5min default
+
+    // Even on cooldown — velocity is a safety override
+    rotator.lastRotationTime.set('v1', Date.now() - 60_000);
+
+    await rotator.check();
+
+    const history = rotator.getHistory();
+    assert.equal(history.length, 1);
+    assert.equal(history[0].reason, 'velocity_ceiling');
+  });
+
+  it('should not velocity-rotate under the ceiling', async () => {
+    const agent = {
+      id: 'v2', name: 'claude-normal', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 50_000, contextUsage: 0.30, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+    mockDaemon.tokens.getVelocity = () => 80_000;
+
+    await rotator.check();
+
+    assert.equal(rotator.getHistory().length, 0);
+  });
 });

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

@@ -61,6 +61,10 @@ describe('TokenTracker', () => {
     tracker.record('agent-1', 100);
     tracker.record('agent-2', 200);
 
+    // record() debounces disk writes (hot path); flush forces the pending save,
+    // mirroring what the daemon does on shutdown.
+    tracker.flush();
+
     const tracker2 = new TokenTracker(tmpDir);
     assert.equal(tracker2.getAgent('agent-1').total, 100);
     assert.equal(tracker2.getAgent('agent-2').total, 200);