groove-dev 0.27.181 → 0.27.183

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

@@ -12,6 +12,14 @@ const COLD_START_PER_FILE = 15;
 const COLD_START_PER_DIR = 40;
 // Estimated tokens wasted per file conflict (agent discovers, backs off, retries)
 const CONFLICT_OVERHEAD = 500;
+// Max per-agent session records kept. Aggregates are cumulative and unaffected;
+// windowed queries (getVelocity/getTokensInWindow) only need the recent tail,
+// which 500 records covers by orders of magnitude. Uncapped, tokens.json grew
+// to 13.8MB and was rewritten on every assistant stream event.
+const SESSION_CAP = 500;
+// Debounce window for persisting to disk. record() fires per assistant event —
+// writing the full ledger each time is a hot-path full-file rewrite.
+const SAVE_DEBOUNCE_MS = 5_000;
 
 export class TokenTracker {
   constructor(grooveDir) {
@@ -23,6 +31,7 @@ export class TokenTracker {
     this.coldStartsSkipped = 0;
     this.projectFiles = 0;   // Set from indexer stats
     this.projectDirs = 0;
+    this._saveTimer = null;
     this.load();
   }
 
@@ -47,6 +56,7 @@ export class TokenTracker {
           if (!entry.totalDurationMs) entry.totalDurationMs = 0;
           if (!entry.totalTurns) entry.totalTurns = 0;
           if (!entry.modelDistribution) entry.modelDistribution = {};
+          this._capSessions(entry);
         }
       } catch {
         this.usage = {};
@@ -55,6 +65,10 @@ export class TokenTracker {
   }
 
   save() {
+    if (this._saveTimer) {
+      clearTimeout(this._saveTimer);
+      this._saveTimer = null;
+    }
     writeFileSync(this.path, JSON.stringify({
       usage: this.usage,
       rotationSavings: this.rotationSavings,
@@ -64,6 +78,30 @@ export class TokenTracker {
     }, null, 2));
   }
 
+  // Debounced persistence for hot-path recording. In-memory state is always
+  // current; at most SAVE_DEBOUNCE_MS of records are at risk on a crash.
+  _scheduleSave() {
+    if (this._saveTimer) return;
+    this._saveTimer = setTimeout(() => {
+      this._saveTimer = null;
+      try { this.save(); } catch { /* best-effort */ }
+    }, SAVE_DEBOUNCE_MS);
+    this._saveTimer.unref?.();
+  }
+
+  // Write any pending debounced state to disk. Call on daemon shutdown.
+  flush() {
+    if (this._saveTimer) {
+      try { this.save(); } catch { /* best-effort */ }
+    }
+  }
+
+  _capSessions(entry) {
+    if (Array.isArray(entry.sessions) && entry.sessions.length > SESSION_CAP) {
+      entry.sessions.splice(0, entry.sessions.length - SESSION_CAP);
+    }
+  }
+
   _initAgent(agentId) {
     if (!this.usage[agentId]) {
       this.usage[agentId] = {
@@ -89,7 +127,8 @@ export class TokenTracker {
     if (typeof detail === 'number') {
       entry.total += detail;
       entry.sessions.push({ tokens: detail, timestamp: new Date().toISOString() });
-      this.save();
+      this._capSessions(entry);
+      this._scheduleSave();
       return;
     }
 
@@ -121,8 +160,9 @@ export class TokenTracker {
       projectRoot: detail.projectRoot || null,
       timestamp: new Date().toISOString(),
     });
+    this._capSessions(entry);
 
-    this.save();
+    this._scheduleSave();
   }
 
   // Sum tokens recorded for an agent since a given timestamp.
@@ -152,25 +192,25 @@ export class TokenTracker {
     if (costUsd) entry.totalCostUsd += costUsd;
     if (durationMs) entry.totalDurationMs += durationMs;
     if (turns) entry.totalTurns += turns;
-    this.save();
+    this._scheduleSave();
   }
 
   // Record that a rotation saved context tokens
   recordRotation(agentId, tokensBefore) {
     this.rotationSavings += Math.round(tokensBefore * 0.3); // ~30% of context was degraded
-    this.save();
+    this._scheduleSave();
   }
 
   // Record that a conflict was prevented (scope enforcement)
   recordConflictPrevented() {
     this.conflictsPrevented++;
-    this.save();
+    this._scheduleSave();
   }
 
   // Record that a cold-start was skipped (Journalist provided context)
   recordColdStartSkipped() {
     this.coldStartsSkipped++;
-    this.save();
+    this._scheduleSave();
   }
 
   // Set project size from indexer for dynamic cold-start estimation

package/node_modules/@groove-dev/daemon/test/claude-code-provider.test.js

@@ -69,6 +69,58 @@ describe('ClaudeCodeProvider result parsing', () => {
   });
 });
 
+describe('ClaudeCodeProvider resume handshake (CLI >= 2.1.212)', () => {
+  // The 0-turn no-op result the CLI emits ~180ms into --resume reconciliation.
+  const HANDSHAKE = JSON.stringify({
+    type: 'result', subtype: 'success', is_error: false,
+    duration_ms: 186, duration_api_ms: 0, num_turns: 0, total_cost_usd: 0,
+  });
+  const ABORT = JSON.stringify({
+    type: 'result', subtype: 'error_during_execution', is_error: true,
+    duration_ms: 5126, duration_api_ms: 0, num_turns: 2, total_cost_usd: 0,
+    terminal_reason: 'aborted_streaming',
+  });
+
+  // This is the gate the daemon uses to decide whether a result means "the
+  // turn completed". Treating the handshake as a completion arms a 5s
+  // force-kill that SIGTERMs the process mid-turn.
+  const reachedModel = (o) => o.apiDurationMs === undefined || o.apiDurationMs > 0;
+
+  it('does not count the resume handshake as a completed turn', () => {
+    const out = provider.parseOutput(HANDSHAKE);
+    assert.equal(out.isError, false);
+    assert.equal(reachedModel(out), false,
+      'handshake must not arm the force-kill or clear the queued message');
+  });
+
+  it('counts a real turn as completed', () => {
+    const out = provider.parseOutput(JSON.stringify({
+      type: 'result', subtype: 'success', is_error: false,
+      duration_ms: 17850, duration_api_ms: 17672, num_turns: 3, total_cost_usd: 0.42,
+    }));
+    assert.equal(reachedModel(out), true);
+  });
+
+  it('providers without an API duration still count as completed', () => {
+    // codex / gemini / ollama don't report duration_api_ms — they must be
+    // unaffected by the guard.
+    const out = provider.parseOutput(JSON.stringify({
+      type: 'result', subtype: 'success', duration_ms: 1200, num_turns: 1,
+    }));
+    assert.equal(out.apiDurationMs, undefined);
+    assert.equal(reachedModel(out), true);
+  });
+
+  // Regression: taking the first result in a chunk let the handshake mask a
+  // subsequent abort, so the failure looked like a clean completion.
+  it('surfaces the abort when a chunk carries handshake + abort together', () => {
+    const out = provider.parseOutput(`${HANDSHAKE}\n${ABORT}`);
+    assert.equal(out.isError, true, 'abort must win over the no-op success result');
+    assert.equal(out.terminalReason, 'aborted_streaming');
+    assert.equal(reachedModel(out), false);
+  });
+});
+
 describe('ClaudeCodeProvider models', () => {
   it('offers Fable 5', () => {
     assert.ok(ClaudeCodeProvider.models.some((m) => m.id === 'claude-fable-5'));

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

@@ -5,22 +5,33 @@ import { describe, it, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { InnerChat } from '../src/innerchat.js';
 
+// Mirrors the daemon surface deliverInstruction touches. Agents live in the
+// registry; `_loops` marks an interactive loop, `_running` a busy CLI agent,
+// and anything in neither is stopped (resume path, which mints a new id).
 function makeDaemon() {
   const broadcasts = [];
   const audits = [];
   const sentMessages = [];
   const queuedMessages = [];
+  const resumes = [];
+
+  let idCounter = 0;
 
   return {
     broadcasts,
     audits,
     sentMessages,
     queuedMessages,
+    resumes,
     registry: {
       _agents: new Map(),
       get(id) { return this._agents.get(id) || null; },
       add(agent) { this._agents.set(agent.id, agent); },
+      remove(id) { this._agents.delete(id); },
+      flushPendingRemovals() {},
+      update() {},
     },
+    locks: { release() {} },
     processes: {
       _loops: new Set(),
       _running: new Set(),
@@ -33,171 +44,246 @@ function makeDaemon() {
       queueMessage(id, msg) {
         queuedMessages.push({ id, msg });
       },
+      // Resume mints a new agent id, exactly as the real one does.
+      async resume(id, msg) {
+        const old = this._agentsRef.get(id);
+        const fresh = { ...old, id: `${id}-r${++idCounter}` };
+        this._agentsRef.delete(id);
+        this._agentsRef.set(fresh.id, fresh);
+        resumes.push({ id, msg, newId: fresh.id });
+        return fresh;
+      },
+    },
+    rotator: {
+      async rotate(id, opts) { return this._daemon.processes.resume(id, opts.additionalPrompt); },
     },
     broadcast(msg) { broadcasts.push(msg); },
     audit: { log(type, data) { audits.push({ type, data }); } },
   };
 }
 
+function wire(daemon) {
+  daemon.processes._agentsRef = daemon.registry._agents;
+  daemon.rotator._daemon = daemon;
+}
+
+const result = (text) => ({ type: 'result', data: text });
+
 describe('InnerChat', () => {
   let daemon;
   let innerchat;
 
   beforeEach(() => {
     daemon = makeDaemon();
+    wire(daemon);
     innerchat = new InnerChat(daemon);
     daemon.innerchat = innerchat;
 
-    daemon.registry.add({ id: 'a1', name: 'fullstack-1', role: 'fullstack' });
-    daemon.registry.add({ id: 'a2', name: 'fullstack-14', role: 'fullstack' });
+    daemon.registry.add({ id: 'a1', name: 'fullstack-1', role: 'fullstack', provider: 'claude-code' });
+    daemon.registry.add({ id: 'a2', name: 'fullstack-14', role: 'fullstack', provider: 'claude-code' });
+    daemon.processes._loops.add('a1');
+    daemon.processes._running.add('a1');
     daemon.processes._loops.add('a2');
     daemon.processes._running.add('a2');
   });
 
-  it('should send a message between agents', async () => {
-    const msg = await innerchat.send('a1', 'a2', 'What endpoint shape are you using?');
-    assert.ok(msg.id);
-    assert.equal(msg.from.id, 'a1');
-    assert.equal(msg.from.name, 'fullstack-1');
-    assert.equal(msg.to.id, 'a2');
-    assert.equal(msg.to.name, 'fullstack-14');
-    assert.equal(msg.message, 'What endpoint shape are you using?');
-    assert.equal(msg.response, null);
-    assert.equal(msg.status, 'delivered');
-  });
+  // ── Sending ───────────────────────────────────────────────
 
-  it('should deliver via sendMessage when agent has loop', async () => {
-    await innerchat.send('a1', 'a2', 'Hello');
-    assert.equal(daemon.sentMessages.length, 1);
-    assert.equal(daemon.sentMessages[0].id, 'a2');
-    assert.ok(daemon.sentMessages[0].msg.includes('InnerChat from fullstack-1'));
-    assert.ok(daemon.sentMessages[0].msg.includes('Hello'));
-  });
+  it('opens a thread and delivers the relay to the target', async () => {
+    const { thread, turn } = await innerchat.send('a1', 'a2', 'What endpoint shape are you using?');
 
-  it('should queue when agent is running but no loop', async () => {
-    daemon.processes._loops.delete('a2');
-    await innerchat.send('a1', 'a2', 'Hello');
-    assert.equal(daemon.queuedMessages.length, 1);
-    assert.equal(daemon.queuedMessages[0].id, 'a2');
+    assert.ok(thread.id);
+    assert.equal(thread.status, 'awaiting_reply');
+    assert.equal(thread.turns.length, 1);
+    assert.equal(turn.kind, 'relay');
+    assert.equal(turn.from.id, 'a1');
+    assert.equal(turn.to.id, 'a2');
+
+    const delivered = daemon.sentMessages.at(-1);
+    assert.equal(delivered.id, 'a2');
+    assert.match(delivered.msg, /InnerChat from fullstack-1/);
+    assert.match(delivered.msg, /What endpoint shape are you using\?/);
   });
 
-  it('should throw when target agent is not running', async () => {
-    daemon.processes._running.delete('a2');
-    daemon.processes._loops.delete('a2');
-    await assert.rejects(() => innerchat.send('a1', 'a2', 'Hello'), /not running/);
+  it('rejects unknown, self-addressed, and empty relays', async () => {
+    await assert.rejects(() => innerchat.send('nope', 'a2', 'hi'), /not found/);
+    await assert.rejects(() => innerchat.send('a1', 'nope', 'hi'), /not found/);
+    await assert.rejects(() => innerchat.send('a1', 'a1', 'hi'), /itself/);
+    await assert.rejects(() => innerchat.send('a1', 'a2', '   '), /message is required/);
   });
 
-  it('should throw when sender does not exist', async () => {
-    await assert.rejects(() => innerchat.send('unknown', 'a2', 'Hello'), /not found/);
+  it('rejects an unknown threadId', async () => {
+    await assert.rejects(() => innerchat.send('a1', 'a2', 'hi', 'bogus'), /not found/);
   });
 
-  it('should throw when sending to self', async () => {
-    // The route validates this, but let's verify it's caught
-    daemon.processes._loops.add('a1');
-    daemon.processes._running.add('a1');
-    const msg = await innerchat.send('a1', 'a1', 'Hello');
-    assert.ok(msg.id);
+  // ── Reply capture and auto-forward ────────────────────────
+
+  it('forwards the reply back to the asker automatically', async () => {
+    await innerchat.send('a1', 'a2', 'What shape?');
+    innerchat.onAgentOutput('a2', result('REST, /api/v2/orders'));
+    await new Promise((r) => setImmediate(r));
+
+    const forwarded = daemon.sentMessages.at(-1);
+    assert.equal(forwarded.id, 'a1');
+    assert.match(forwarded.msg, /InnerChat reply from fullstack-14/);
+    assert.match(forwarded.msg, /REST, \/api\/v2\/orders/);
   });
 
-  it('should broadcast innerchat:sent on send', async () => {
-    await innerchat.send('a1', 'a2', 'Hello');
-    const sent = daemon.broadcasts.find(b => b.type === 'innerchat:sent');
-    assert.ok(sent);
-    assert.equal(sent.data.message, 'Hello');
+  it('ignores output from agents with no relay outstanding', () => {
+    const before = daemon.sentMessages.length;
+    innerchat.onAgentOutput('a2', result('unrelated work'));
+    assert.equal(daemon.sentMessages.length, before);
   });
 
-  it('should capture response on agent output', async () => {
-    const msg = await innerchat.send('a1', 'a2', 'What shape?');
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'GET /api/projects/:id returns { id, name }' });
-    assert.equal(msg.status, 'responded');
-    assert.equal(msg.response, 'GET /api/projects/:id returns { id, name }');
-    assert.ok(msg.respondedAt);
+  it('ignores non-result and empty output', async () => {
+    await innerchat.send('a1', 'a2', 'What shape?');
+    innerchat.onAgentOutput('a2', { type: 'assistant', data: 'thinking...' });
+    innerchat.onAgentOutput('a2', result('   '));
+    await new Promise((r) => setImmediate(r));
+
+    assert.equal(daemon.sentMessages.at(-1).id, 'a2', 'no forward should have happened');
+    assert.ok(innerchat.getPending('a2'), 'relay is still outstanding');
   });
 
-  it('should relay response back to sender', async () => {
-    daemon.processes._loops.add('a1');
-    daemon.processes._running.add('a1');
+  it('captures a reply only once', async () => {
     await innerchat.send('a1', 'a2', 'What shape?');
-    daemon.sentMessages.length = 0;
+    innerchat.onAgentOutput('a2', result('first'));
+    innerchat.onAgentOutput('a2', result('second'));
+    await new Promise((r) => setImmediate(r));
 
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'The answer' });
-    assert.equal(daemon.sentMessages.length, 1);
-    assert.equal(daemon.sentMessages[0].id, 'a1');
-    assert.ok(daemon.sentMessages[0].msg.includes('InnerChat reply from fullstack-14'));
-    assert.ok(daemon.sentMessages[0].msg.includes('The answer'));
+    const forwards = daemon.sentMessages.filter((m) => /InnerChat reply/.test(m.msg));
+    assert.equal(forwards.length, 1);
+    assert.match(forwards[0].msg, /first/);
   });
 
-  it('should ignore non-result output', async () => {
+  it('skips the in-flight result when the relay was queued behind live work', async () => {
+    // No loop, but running → the relay queues behind the current task.
+    daemon.processes._loops.delete('a2');
     await innerchat.send('a1', 'a2', 'What shape?');
-    innerchat.onAgentOutput('a2', { type: 'activity', subtype: 'stream', data: 'partial...' });
-    const msg = innerchat.getMessage(innerchat.getMessages()[0].id);
-    assert.equal(msg.status, 'delivered');
-    assert.equal(msg.response, null);
+    assert.equal(daemon.queuedMessages.at(-1).id, 'a2');
+
+    // This result belongs to the task that was already underway.
+    innerchat.onAgentOutput('a2', result('finished the previous task'));
+    await new Promise((r) => setImmediate(r));
+    assert.equal(daemon.sentMessages.filter((m) => /InnerChat reply/.test(m.msg)).length, 0);
+
+    // This one is the actual answer.
+    innerchat.onAgentOutput('a2', result('REST, /api/v2/orders'));
+    await new Promise((r) => setImmediate(r));
+    const forwarded = daemon.sentMessages.at(-1);
+    assert.equal(forwarded.id, 'a1');
+    assert.match(forwarded.msg, /REST, \/api\/v2\/orders/);
   });
 
-  it('should ignore output from agents with no pending question', () => {
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'Some output' });
-    assert.equal(daemon.broadcasts.length, 0);
+  // ── Stopped agents / id remapping ─────────────────────────
+
+  it('resumes a stopped target and tracks it under its new id', async () => {
+    daemon.processes._loops.delete('a2');
+    daemon.processes._running.delete('a2');
+
+    const { thread, turn } = await innerchat.send('a1', 'a2', 'ping');
+    const newId = daemon.resumes.at(-1).newId;
+
+    assert.notEqual(newId, 'a2');
+    assert.equal(turn.to.id, newId);
+    assert.ok(thread.participants.some((p) => p.id === newId));
+    assert.equal(innerchat.getPending('a2'), null, 'old id no longer tracked');
+    assert.ok(innerchat.getPending(newId), 'reply is awaited on the new id');
+
+    // The reply arrives on the new id and still forwards correctly.
+    daemon.processes._loops.add(newId);
+    innerchat.onAgentOutput(newId, result('pong'));
+    await new Promise((r) => setImmediate(r));
+    assert.match(daemon.sentMessages.at(-1).msg, /pong/);
   });
 
-  it('should extract text from array-format output', async () => {
-    await innerchat.send('a1', 'a2', 'Hello');
-    innerchat.onAgentOutput('a2', {
-      type: 'result',
-      data: [
-        { type: 'text', text: 'Part 1' },
-        { type: 'tool_use', name: 'Read', input: {} },
-        { type: 'text', text: 'Part 2' },
-      ],
-    });
-    const msg = innerchat.getMessages()[0];
-    assert.equal(msg.response, 'Part 1\nPart 2');
+  it('resumes a stopped asker to deliver the reply', async () => {
+    await innerchat.send('a1', 'a2', 'What shape?');
+    daemon.processes._loops.delete('a1');
+    daemon.processes._running.delete('a1');
+
+    innerchat.onAgentOutput('a2', result('REST'));
+    await new Promise((r) => setImmediate(r));
+
+    const resume = daemon.resumes.at(-1);
+    assert.equal(resume.id, 'a1');
+    assert.match(resume.msg, /InnerChat reply from fullstack-14/);
   });
 
-  it('should broadcast innerchat:response on response', async () => {
-    await innerchat.send('a1', 'a2', 'Hello');
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'Response here' });
-    const resp = daemon.broadcasts.find(b => b.type === 'innerchat:response');
-    assert.ok(resp);
-    assert.equal(resp.data.response, 'Response here');
+  it('marks the turn failed when delivery throws', async () => {
+    daemon.processes.sendMessage = async () => { throw new Error('pipe closed'); };
+    await assert.rejects(() => innerchat.send('a1', 'a2', 'ping'), /pipe closed/);
+
+    const thread = innerchat.getThreads('a1')[0];
+    assert.equal(thread.status, 'failed');
+    assert.equal(thread.turns[0].status, 'failed');
+    assert.equal(thread.turns[0].error, 'pipe closed');
   });
 
-  it('should list messages filtered by agent', async () => {
-    daemon.processes._loops.add('a1');
-    daemon.processes._running.add('a1');
-    daemon.registry.add({ id: 'a3', name: 'backend-1', role: 'backend' });
+  // ── Threads ───────────────────────────────────────────────
+
+  it('continues a thread and replays prior turns as context', async () => {
+    const first = await innerchat.send('a1', 'a2', 'What shape?');
+    innerchat.onAgentOutput('a2', result('REST'));
+    await new Promise((r) => setImmediate(r));
+
+    await innerchat.send('a1', 'a2', 'Versioned?', first.thread.id);
+
+    const relay = daemon.sentMessages.filter((m) => /InnerChat from/.test(m.msg)).at(-1);
+    assert.match(relay.msg, /Earlier in this conversation/);
+    assert.match(relay.msg, /fullstack-1: What shape\?/);
+    assert.match(relay.msg, /fullstack-14: REST/);
+    assert.match(relay.msg, /Versioned\?/);
+
+    assert.equal(innerchat.getThreads().length, 1, 'reused the existing thread');
+    assert.equal(first.thread.turns.length, 3);
+  });
+
+  it('keeps concurrent relays to different agents separate', async () => {
+    daemon.registry.add({ id: 'a3', name: 'fullstack-9', role: 'fullstack', provider: 'claude-code' });
     daemon.processes._loops.add('a3');
     daemon.processes._running.add('a3');
 
-    await innerchat.send('a1', 'a2', 'Message 1');
-    await innerchat.send('a1', 'a3', 'Message 2');
+    const one = await innerchat.send('a1', 'a2', 'question for 14');
+    const two = await innerchat.send('a1', 'a3', 'question for 9');
+    assert.notEqual(one.thread.id, two.thread.id);
 
-    assert.equal(innerchat.getMessages().length, 2);
-    assert.equal(innerchat.getMessages('a2').length, 1);
-    assert.equal(innerchat.getMessages('a3').length, 1);
-    assert.equal(innerchat.getMessages('a1').length, 2);
-  });
+    innerchat.onAgentOutput('a3', result('answer from 9'));
+    await new Promise((r) => setImmediate(r));
 
-  it('should return pending question for agent', async () => {
-    assert.equal(innerchat.getPending('a2'), null);
-    await innerchat.send('a1', 'a2', 'Question?');
-    const pending = innerchat.getPending('a2');
-    assert.ok(pending);
-    assert.equal(pending.message, 'Question?');
+    assert.equal(two.thread.turns.at(-1).text, 'answer from 9');
+    assert.equal(one.thread.turns.length, 1, 'the other thread is untouched');
+    assert.ok(innerchat.getPending('a2'), 'still awaiting the first reply');
   });
 
-  it('should clear pending after response', async () => {
-    await innerchat.send('a1', 'a2', 'Question?');
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'Answer' });
-    assert.equal(innerchat.getPending('a2'), null);
+  it('filters threads by participant', async () => {
+    daemon.registry.add({ id: 'a3', name: 'fullstack-9', role: 'fullstack', provider: 'claude-code' });
+    daemon.processes._loops.add('a3');
+    daemon.processes._running.add('a3');
+
+    await innerchat.send('a1', 'a2', 'hi');
+    await innerchat.send('a1', 'a3', 'hi');
+
+    assert.equal(innerchat.getThreads().length, 2);
+    assert.equal(innerchat.getThreads('a1').length, 2);
+    assert.equal(innerchat.getThreads('a2').length, 1);
+    assert.equal(innerchat.getThreads('a3').length, 1);
+    assert.equal(innerchat.getThreads('nobody').length, 0);
   });
 
-  it('should audit send and response events', async () => {
-    await innerchat.send('a1', 'a2', 'Hello');
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'Reply' });
-    const sendAudit = daemon.audits.find(a => a.type === 'innerchat.send');
-    const respAudit = daemon.audits.find(a => a.type === 'innerchat.response');
-    assert.ok(sendAudit);
-    assert.ok(respAudit);
+  // ── Broadcast & audit ─────────────────────────────────────
+
+  it('broadcasts and audits both hops', async () => {
+    await innerchat.send('a1', 'a2', 'What shape?');
+    innerchat.onAgentOutput('a2', result('REST'));
+    await new Promise((r) => setImmediate(r));
+
+    const turns = daemon.broadcasts.filter((b) => b.type === 'innerchat:turn');
+    assert.equal(turns.length, 2);
+    assert.equal(turns[0].data.turn.kind, 'relay');
+    assert.equal(turns[1].data.turn.kind, 'reply');
+
+    assert.ok(daemon.audits.some((a) => a.type === 'innerchat.send'));
+    assert.ok(daemon.audits.some((a) => a.type === 'innerchat.reply'));
   });
 });

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

@@ -174,13 +174,15 @@ describe('Journalist', () => {
       const { daemon, grooveDir } = createMockDaemon();
       const journalist = new Journalist(daemon);
 
-      // Create a mock log — filename must match agent.id ('a1')
+      // Create a mock log — filename must match agent.name ('backend-1'),
+      // mirroring the writer in process.js (logs are keyed by sanitized name
+      // so rotated agents keep appending to the same file)
       const logLines = [
         JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', name: 'Write', input: { file_path: 'src/api/auth.js' } }] } }),
         JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', name: 'Edit', input: { file_path: 'src/api/users.js', old_string: 'old', new_string: 'new' } }] } }),
         JSON.stringify({ type: 'user', message: { content: 'Add JWT middleware to the auth route' } }),
       ].join('\n');
-      writeFileSync(join(grooveDir, 'logs', 'a1.log'), logLines);
+      writeFileSync(join(grooveDir, 'logs', 'backend-1.log'), logLines);
 
       const agent = {
         id: 'a1', name: 'backend-1', role: 'backend',