groove-dev 0.26.38 → 0.27.0

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

@@ -162,4 +162,112 @@ describe('Rotator', () => {
     assert.equal(stats.totalRotations, 2);
     assert.equal(stats.totalTokensSaved, 8000);
   });
+
+  describe('safety triggers', () => {
+    const SPAWNED = new Date(Date.now() - 60_000).toISOString(); // spawned 1 min ago
+
+    function mkAgent(overrides = {}) {
+      return {
+        id: 'a1', name: 'backend-1', role: 'backend',
+        provider: 'claude-code', scope: [], model: null,
+        tokensUsed: 0, contextUsage: 0.1, workingDir: '/tmp',
+        spawnedAt: SPAWNED, status: 'running',
+        ...overrides,
+      };
+    }
+
+    it('returns null when safety config is missing', () => {
+      mockDaemon.config = undefined;
+      const trigger = rotator._checkSafetyTriggers(mkAgent());
+      assert.equal(trigger, null);
+    });
+
+    it('returns null when autoRotate is disabled', () => {
+      mockDaemon.config = { safety: { autoRotate: false, tokenCeilingPerAgent: 100 } };
+      mockDaemon.tokens.getTokensInWindow = () => 1000;
+      const trigger = rotator._checkSafetyTriggers(mkAgent());
+      assert.equal(trigger, null);
+    });
+
+    it('fires token_limit_exceeded when instance tokens hit ceiling', () => {
+      mockDaemon.config = {
+        safety: {
+          autoRotate: true,
+          tokenCeilingPerAgent: 1_000_000,
+          velocityWindowSeconds: 300,
+          velocityTokenThreshold: 2_000_000,
+        },
+      };
+      mockDaemon.tokens.getTokensInWindow = () => 1_200_000;
+      mockDaemon.tokens.getVelocity = () => 0;
+
+      const trigger = rotator._checkSafetyTriggers(mkAgent());
+      assert.equal(trigger.reason, 'token_limit_exceeded');
+      assert.equal(trigger.instanceTokens, 1_200_000);
+      assert.equal(trigger.ceiling, 1_000_000);
+    });
+
+    it('fires runaway_velocity when recent burn exceeds threshold', () => {
+      mockDaemon.config = {
+        safety: {
+          autoRotate: true,
+          tokenCeilingPerAgent: 10_000_000,
+          velocityWindowSeconds: 300,
+          velocityTokenThreshold: 1_000_000,
+        },
+      };
+      mockDaemon.tokens.getTokensInWindow = () => 500_000; // under ceiling
+      mockDaemon.tokens.getVelocity = () => 1_500_000;
+
+      const trigger = rotator._checkSafetyTriggers(mkAgent());
+      assert.equal(trigger.reason, 'runaway_velocity');
+      assert.equal(trigger.velocity, 1_500_000);
+      assert.equal(trigger.threshold, 1_000_000);
+      assert.equal(trigger.windowMs, 300_000);
+    });
+
+    it('ceiling check takes priority over velocity check', () => {
+      mockDaemon.config = {
+        safety: {
+          autoRotate: true,
+          tokenCeilingPerAgent: 1_000_000,
+          velocityWindowSeconds: 300,
+          velocityTokenThreshold: 1_000_000,
+        },
+      };
+      mockDaemon.tokens.getTokensInWindow = () => 2_000_000;
+      mockDaemon.tokens.getVelocity = () => 2_000_000;
+      const trigger = rotator._checkSafetyTriggers(mkAgent());
+      assert.equal(trigger.reason, 'token_limit_exceeded');
+    });
+
+    it('returns null when neither threshold hit', () => {
+      mockDaemon.config = {
+        safety: {
+          autoRotate: true,
+          tokenCeilingPerAgent: 5_000_000,
+          velocityWindowSeconds: 300,
+          velocityTokenThreshold: 1_500_000,
+        },
+      };
+      mockDaemon.tokens.getTokensInWindow = () => 100_000;
+      mockDaemon.tokens.getVelocity = () => 10_000;
+      const trigger = rotator._checkSafetyTriggers(mkAgent());
+      assert.equal(trigger, null);
+    });
+
+    it('stats track safety-triggered rotations separately', async () => {
+      mockDaemon.registry.agents = [mkAgent({ tokensUsed: 1_200_000 })];
+      await rotator.rotate('a1', {
+        reason: 'token_limit_exceeded',
+        instanceTokens: 1_200_000,
+        ceiling: 1_000_000,
+      });
+
+      const stats = rotator.getStats();
+      assert.equal(stats.tokenLimitRotations, 1);
+      assert.equal(stats.velocityRotations, 0);
+      assert.equal(stats.totalRotations, 1);
+    });
+  });
 });

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

@@ -93,4 +93,68 @@ describe('ModelRouter', () => {
     assert.equal(status.modes.AUTO, 'auto');
     assert.equal(status.modes.AUTO_FLOOR, 'auto-floor');
   });
+
+  describe('getSuggestion (downshift only, never auto-applied)', () => {
+    beforeEach(() => {
+      // Mock registry returns an agent on claude-code with heavy model
+      mockDaemon.registry.get = (id) => ({
+        id,
+        provider: 'claude-code',
+        model: 'claude-opus-4-6',
+        role: 'backend',
+      });
+    });
+
+    it('returns null when agent not found', () => {
+      mockDaemon.registry.get = () => null;
+      assert.equal(router.getSuggestion('missing'), null);
+    });
+
+    it('returns null when classifier has too few events', () => {
+      // Add a handful — below the 40-event threshold
+      for (let i = 0; i < 10; i++) {
+        mockDaemon.classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `f${i}.js` });
+      }
+      assert.equal(router.getSuggestion('agent-1'), null);
+    });
+
+    it('suggests a lighter model when classification is light with enough data', () => {
+      for (let i = 0; i < 50; i++) {
+        mockDaemon.classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `f${i}.js` });
+      }
+      const s = router.getSuggestion('agent-1');
+      assert.ok(s, 'expected a suggestion');
+      assert.equal(s.classifiedTier, 'light');
+      assert.equal(s.currentModel.tier, 'heavy');
+      assert.ok(['medium', 'light'].includes(s.suggestedModel.tier));
+    });
+
+    it('does not suggest upshift (never silently escalates)', () => {
+      // Heavy-signal events
+      for (let i = 0; i < 50; i++) {
+        mockDaemon.classifier.addEvent('agent-1', {
+          type: 'tool', tool: 'Edit', input: `f${i}.js`, data: 'complex refactor migrate schema',
+        });
+      }
+      // Current model is already heavy; never suggest going heavier
+      const s = router.getSuggestion('agent-1');
+      // Either null (no lower tier) or only suggests lighter
+      if (s) {
+        const tierRank = { heavy: 3, medium: 2, light: 1 };
+        assert.ok(tierRank[s.suggestedModel.tier] < tierRank[s.currentModel.tier]);
+      }
+    });
+
+    it('returns null when current model already matches classification', () => {
+      mockDaemon.registry.get = (id) => ({
+        id, provider: 'claude-code',
+        model: 'claude-haiku-4-5-20251001', // light tier
+        role: 'backend',
+      });
+      for (let i = 0; i < 50; i++) {
+        mockDaemon.classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `f${i}.js` });
+      }
+      assert.equal(router.getSuggestion('agent-1'), null);
+    });
+  });
 });

package/node_modules/@groove-dev/daemon/test/slides-engine.test.js

@@ -0,0 +1,230 @@
+// GROOVE — Slides Layout Engine Tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const require = createRequire(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const engine = require(resolve(__dirname, '../templates/groove-slides.cjs'));
+
+describe('slides-engine / LAYOUT', () => {
+  it('exposes frozen constants with the documented 16:9 safe zone', () => {
+    assert.equal(engine.LAYOUT.SLIDE_W, 10);
+    assert.equal(engine.LAYOUT.SLIDE_H, 5.625);
+    assert.equal(engine.LAYOUT.SAFE_BOT, 5.125);
+    assert.equal(engine.LAYOUT.CONTENT_START, 0.65);
+    assert.throws(() => { engine.LAYOUT.SLIDE_W = 99; }, /read only|Cannot assign/i);
+  });
+});
+
+describe('slides-engine / estimateTextHeight', () => {
+  it('returns single-line height for short text', () => {
+    const h = engine.estimateTextHeight('Hello', 18, 5.0);
+    const lineH = (18 * 1.3) / 72;
+    assert.ok(Math.abs(h - lineH) < 0.01, `expected ~${lineH}, got ${h}`);
+  });
+
+  it('accounts for word wrap on long text in a narrow box', () => {
+    const short = engine.estimateTextHeight('One two', 24, 8.0);
+    const long = engine.estimateTextHeight(
+      'This sentence is long enough to wrap across multiple lines in a narrow box',
+      24, 2.0,
+    );
+    assert.ok(long > short * 2, `long (${long}) should be at least 2× short (${short})`);
+  });
+
+  it('respects explicit newlines', () => {
+    const h = engine.estimateTextHeight('one\ntwo\nthree', 12, 8.0);
+    const lineH = (12 * 1.3) / 72;
+    assert.ok(h >= lineH * 3 - 0.01, `expected ≥ 3 lines, got ${h}`);
+  });
+
+  it('does not divide by zero on empty text', () => {
+    assert.ok(engine.estimateTextHeight('', 18, 5.0) > 0);
+  });
+});
+
+describe('slides-engine / fitFontSize', () => {
+  it('returns maxSize when text already fits', () => {
+    const size = engine.fitFontSize('Short', 48, 18, 8.0, 2.0);
+    assert.equal(size, 48);
+  });
+
+  it('shrinks text to fit a constrained box', () => {
+    const long = 'AI coding tools are broken at the multi-agent level.';
+    const fitted = engine.fitFontSize(long, 48, 18, 5.5, 0.85, { bold: true });
+    assert.ok(fitted < 48, `should have shrunk from 48, got ${fitted}`);
+    const needed = engine.estimateTextHeight(long, fitted, 5.5, { bold: true });
+    assert.ok(needed <= 0.85, `fitted size ${fitted} still overflows: needs ${needed}`);
+  });
+
+  it('returns minSize when even that does not fit', () => {
+    const impossibleText = 'a '.repeat(500);
+    const size = engine.fitFontSize(impossibleText, 48, 10, 1.0, 0.3);
+    assert.equal(size, 10);
+  });
+});
+
+describe('slides-engine / checkCollisions', () => {
+  it('detects overlapping rectangles', () => {
+    const issues = engine.checkCollisions([
+      { name: 'a', x: 0, y: 0, w: 2, h: 1 },
+      { name: 'b', x: 1, y: 0.5, w: 2, h: 1 },
+    ]);
+    assert.equal(issues.length, 1);
+    assert.match(issues[0], /OVERLAP/);
+  });
+
+  it('returns empty for non-overlapping rectangles', () => {
+    const issues = engine.checkCollisions([
+      { name: 'a', x: 0, y: 0, w: 2, h: 1 },
+      { name: 'b', x: 3, y: 0, w: 2, h: 1 },
+    ]);
+    assert.deepEqual(issues, []);
+  });
+
+  it('ignores skipCollision flag — no bypasses allowed', () => {
+    const issues = engine.checkCollisions([
+      { name: 'a', x: 0, y: 0, w: 2, h: 1, skipCollision: true },
+      { name: 'b', x: 1, y: 0.5, w: 2, h: 1, skipCollision: true },
+    ]);
+    assert.equal(issues.length, 1, 'skipCollision flag must not bypass the check');
+  });
+});
+
+describe('slides-engine / checkBounds', () => {
+  it('flags elements that overflow the safe bottom', () => {
+    const issues = engine.checkBounds([
+      { name: 'footer', x: 0.6, y: 5.0, w: 8.8, h: 0.5 },
+    ]);
+    assert.equal(issues.length, 1);
+    assert.match(issues[0], /BOTTOM-OVERFLOW/);
+  });
+
+  it('flags top / left / right overflow', () => {
+    const issues = engine.checkBounds([
+      { name: 'above', x: 0.6, y: -0.1, w: 1, h: 0.2 },
+      { name: 'leftOut', x: -0.5, y: 1, w: 0.3, h: 0.2 },
+      { name: 'rightOut', x: 9.8, y: 1, w: 0.5, h: 0.2 },
+    ]);
+    assert.ok(issues.some((m) => /TOP-OVERFLOW/.test(m)));
+    assert.ok(issues.some((m) => /LEFT-OVERFLOW/.test(m)));
+    assert.ok(issues.some((m) => /RIGHT-OVERFLOW/.test(m)));
+  });
+
+  it('ignores skipBounds flag — no bypasses allowed', () => {
+    const issues = engine.checkBounds([
+      { name: 'footer', x: 0.6, y: 5.0, w: 8.8, h: 0.5, skipBounds: true },
+    ]);
+    assert.equal(issues.length, 1, 'skipBounds flag must not bypass the check');
+  });
+});
+
+describe('slides-engine / checkTextWrap', () => {
+  it('flags text that needs more height than its box', () => {
+    const issues = engine.checkTextWrap([
+      { name: 'title', x: 0, y: 0, w: 5.5, h: 0.85,
+        text: 'AI coding tools are broken at the multi-agent level.',
+        fontSize: 38, bold: true },
+    ]);
+    assert.equal(issues.length, 1);
+    assert.match(issues[0], /TEXT-WRAP/);
+  });
+
+  it('does NOT bypass check on shrinkText — that flag is ignored', () => {
+    const issues = engine.checkTextWrap([
+      { name: 'title', x: 0, y: 0, w: 5.5, h: 0.85,
+        text: 'AI coding tools are broken at the multi-agent level.',
+        fontSize: 38, bold: true, shrinkText: true },
+    ]);
+    assert.equal(issues.length, 1, 'shrinkText must NOT exempt an element from the wrap check');
+  });
+
+  it('passes when text fits', () => {
+    const issues = engine.checkTextWrap([
+      { name: 'label', x: 0, y: 0, w: 5.0, h: 0.3,
+        text: 'WHY THIS MATTERS', fontSize: 11, bold: true },
+    ]);
+    assert.deepEqual(issues, []);
+  });
+});
+
+describe('slides-engine / hardGate', () => {
+  it('returns quietly on an empty / valid deck', () => {
+    // Capture stdout
+    const origLog = console.log;
+    const logs = [];
+    console.log = (msg) => logs.push(String(msg));
+    try {
+      engine.hardGate([
+        ['slide-1', [{ name: 'title', x: 0.6, y: 0.65, w: 8.8, h: 1.0,
+          text: 'Hello world', fontSize: 24, bold: true }]],
+      ]);
+    } finally {
+      console.log = origLog;
+    }
+    assert.ok(logs.some((l) => /Layout gate passed/.test(l)));
+  });
+
+  it('calls process.exit(1) when any issue is found', () => {
+    const origExit = process.exit;
+    const origError = console.error;
+    let exitCode = null;
+    process.exit = (code) => { exitCode = code; throw new Error('__exit__'); };
+    console.error = () => {};
+    try {
+      engine.hardGate([
+        ['slide-1', [
+          { name: 'a', x: 0, y: 0, w: 2, h: 1 },
+          { name: 'b', x: 1, y: 0.5, w: 2, h: 1 },
+        ]],
+      ]);
+      assert.fail('hardGate should have exited');
+    } catch (e) {
+      if (e.message !== '__exit__') throw e;
+    } finally {
+      process.exit = origExit;
+      console.error = origError;
+    }
+    assert.equal(exitCode, 1);
+  });
+});
+
+describe('slides-engine / tracker', () => {
+  it('collects placed elements in order', () => {
+    const { track, placed } = engine.tracker();
+    track('a', { x: 0, y: 0, w: 1, h: 1 });
+    track('b', { x: 2, y: 0, w: 1, h: 1 });
+    assert.equal(placed.length, 2);
+    assert.equal(placed[0].name, 'a');
+    assert.equal(placed[1].name, 'b');
+  });
+
+  it('returns the opts object so it can be spread into addText', () => {
+    const { track } = engine.tracker();
+    const opts = track('a', { x: 0, y: 0, w: 1, h: 1, fontSize: 14 });
+    assert.equal(opts.fontSize, 14);
+  });
+
+  it('rejects skipCollision / skipBounds / skipWrap flags with a clear error', () => {
+    const { track } = engine.tracker();
+    for (const flag of ['skipCollision', 'skipBounds', 'skipWrap']) {
+      assert.throws(
+        () => track('a', { x: 0, y: 0, w: 1, h: 1, [flag]: true }),
+        new RegExp(`"${flag}" is not a supported option`),
+        `${flag} must be rejected by tracker`,
+      );
+    }
+  });
+
+  it('rejects non-finite coordinates', () => {
+    const { track } = engine.tracker();
+    assert.throws(() => track('a', { x: NaN, y: 0, w: 1, h: 1 }));
+    assert.throws(() => track('a', { x: 0, y: Infinity, w: 1, h: 1 }));
+    assert.throws(() => track('a', { x: 0, y: 0, w: 'wide', h: 1 }));
+  });
+});

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

@@ -109,4 +109,82 @@ describe('TokenTracker', () => {
     assert.ok(summary.savings.percentage > 0);
     assert.ok(summary.savings.estimatedWithoutGroove > summary.totalTokens);
   });
+
+  it('cache hit rate returns 0 when no cacheable tokens exist', () => {
+    tracker.record('agent-1', { tokens: 1000, inputTokens: 1000 });
+    const summary = tracker.getSummary();
+    assert.equal(summary.cacheHitRate, 0);
+    assert.equal(tracker.getCacheHitRate(), 0);
+  });
+
+  it('cache hit rate excludes fresh input tokens from denominator', () => {
+    // 800 cache reads + 200 cache creation = 1000 cacheable → 80% hit rate.
+    // Fresh inputTokens must NOT inflate the denominator.
+    tracker.record('agent-1', {
+      tokens: 6000,
+      inputTokens: 5000,
+      cacheReadTokens: 800,
+      cacheCreationTokens: 200,
+    });
+    const summary = tracker.getSummary();
+    assert.equal(summary.cacheHitRate, 0.8);
+  });
+
+  it('cache hit rate is 1.0 when all cacheable tokens are reads', () => {
+    tracker.record('agent-1', {
+      tokens: 1000,
+      cacheReadTokens: 1000,
+      cacheCreationTokens: 0,
+    });
+    assert.equal(tracker.getCacheHitRate(), 1.0);
+  });
+
+  it('internal reserved IDs (__prefix) are segregated from user agents', () => {
+    tracker.record('agent-1', { tokens: 1000, inputTokens: 1000 });
+    tracker.record('agent-2', { tokens: 500, inputTokens: 500 });
+    tracker.record('__journalist__', { tokens: 300, inputTokens: 300 });
+    tracker.record('__pm__', { tokens: 200, inputTokens: 200 });
+
+    const summary = tracker.getSummary();
+    // perAgent excludes internal IDs
+    assert.equal(summary.perAgent.length, 2);
+    assert.ok(summary.perAgent.every((a) => !a.agentId.startsWith('__')));
+    // agentCount reflects user-facing agents only
+    assert.equal(summary.agentCount, 2);
+    // Internal overhead is exposed separately
+    assert.equal(summary.internalOverhead.tokens, 500);
+    assert.equal(summary.internalOverhead.components['__journalist__'].tokens, 300);
+    assert.equal(summary.internalOverhead.components['__pm__'].tokens, 200);
+    // totalTokens still includes internal (reflects real billing)
+    assert.equal(summary.totalTokens, 2000);
+  });
+
+  it('empty internalOverhead when no internal IDs recorded', () => {
+    tracker.record('agent-1', { tokens: 100 });
+    const summary = tracker.getSummary();
+    assert.equal(summary.internalOverhead.tokens, 0);
+    assert.deepEqual(summary.internalOverhead.components, {});
+  });
+
+  it('getTokensInWindow returns 0 for unknown agent', () => {
+    assert.equal(tracker.getTokensInWindow('nonexistent', 0), 0);
+  });
+
+  it('getTokensInWindow sums sessions since a given timestamp', () => {
+    tracker.record('agent-1', { tokens: 100 });
+    tracker.record('agent-1', { tokens: 200 });
+    tracker.record('agent-1', { tokens: 300 });
+    // sinceTs = 0 captures all
+    assert.equal(tracker.getTokensInWindow('agent-1', 0), 600);
+    // sinceTs = now + 10s captures nothing
+    assert.equal(tracker.getTokensInWindow('agent-1', Date.now() + 10_000), 0);
+  });
+
+  it('getVelocity returns tokens in a rolling window', () => {
+    tracker.record('agent-1', { tokens: 1000 });
+    // Large window captures the recent recording
+    assert.equal(tracker.getVelocity('agent-1', 60_000), 1000);
+    // Empty tracker returns 0
+    assert.equal(tracker.getVelocity('unknown-agent', 60_000), 0);
+  });
 });