groove-dev 0.27.182 → 0.27.183

package/node_modules/@groove-dev/daemon/src/routes/agents.js

@@ -5,6 +5,8 @@ import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSy
 import { validateAgentConfig, validateReasoningEffort, validateVerbosity } from '../validate.js';
 import { ROLE_INTEGRATIONS, wrapWithRoleReminder } from '../process.js';
 import { getProvider } from '../providers/index.js';
+import { deliverInstruction } from '../deliver.js';
+import { renameAgent } from '../rename.js';
 
 export function registerAgentRoutes(app, daemon) {
   // List all agents
@@ -56,9 +58,21 @@ export function registerAgentRoutes(app, daemon) {
 
   // Update agent
   app.patch('/api/agents/:id', (req, res) => {
-    const agent = daemon.registry.update(req.params.id, req.body);
-    if (!agent) return res.status(404).json({ error: 'Agent not found' });
-    res.json(agent);
+    try {
+      const { name, ...rest } = req.body || {};
+
+      // Renames migrate name-keyed files, so they can't go through the plain
+      // field update — registry.update ignores `name` without the opt-in.
+      let agent = daemon.registry.get(req.params.id);
+      if (!agent) return res.status(404).json({ error: 'Agent not found' });
+
+      if (Object.keys(rest).length) agent = daemon.registry.update(req.params.id, rest);
+      if (typeof name === 'string') agent = renameAgent(daemon, req.params.id, name);
+
+      res.json(agent);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
   });
 
   // Kill an agent (add ?purge=true to also remove from registry)
@@ -426,104 +440,12 @@ export function registerAgentRoutes(app, daemon) {
         }
       }
 
-      // Record user feedback so the journalist can include it in future agent context
-      if (daemon.journalist) daemon.journalist.recordUserFeedback(agent, finalMessage);
-      if (daemon.rotator) daemon.rotator.recordUserMessage(req.params.id);
-
-      // Agent loop path — send message directly to the running loop
-      const wrappedMessage = wrapWithRoleReminder(agent.role, finalMessage);
-      if (daemon.processes.hasAgentLoop(req.params.id)) {
-        const sent = await daemon.processes.sendMessage(req.params.id, wrappedMessage);
-        if (sent) {
-          daemon.audit.log('agent.chat', { id: req.params.id });
-          return res.json({ id: agent.id, status: 'message_sent' });
-        }
-        // Loop exists but not running — fall through to resume/rotate
-      }
-
-      // One-shot providers (groove-network): kill any running instance and
-      // respawn with the user's message as --prompt. No handoff brief, no
-      // session resume, no message queue — each chat message is a fresh spawn.
-      const provider = getProvider(agent.provider);
-      if (provider?.constructor?.isOneShot) {
-        const oldConfig = { ...agent };
-        if (daemon.processes.isRunning(req.params.id)) {
-          await daemon.processes.kill(req.params.id);
-        }
-        daemon.registry.remove(req.params.id, { silent: true });
-        daemon.locks.release(req.params.id);
-
-        let newAgent;
-        try {
-          newAgent = await daemon.processes.spawn({
-            role: oldConfig.role,
-            scope: oldConfig.scope,
-            provider: oldConfig.provider,
-            model: oldConfig.model,
-            prompt: finalMessage,
-            permission: oldConfig.permission || 'full',
-            workingDir: oldConfig.workingDir,
-            name: oldConfig.name,
-            teamId: oldConfig.teamId,
-          });
-        } catch (spawnErr) {
-          daemon.registry.flushPendingRemovals();
-          throw spawnErr;
-        }
-        daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed: false });
-        return res.json(newAgent);
-      }
-
-      // Non-interactive CLI providers (e.g. Gemini): respawn with the new
-      // message as the prompt, preserving original introContext. These providers
-      // run one prompt per spawn and cannot resume sessions.
-      if (provider?.constructor?.nonInteractive && !daemon.processes.isRunning(req.params.id)) {
-        const oldConfig = { ...agent };
-        daemon.registry.remove(req.params.id, { silent: true });
-        daemon.locks.release(req.params.id);
-
-        let newAgent;
-        try {
-          newAgent = await daemon.processes.spawn({
-            role: oldConfig.role,
-            scope: oldConfig.scope,
-            provider: oldConfig.provider,
-            model: oldConfig.model,
-            prompt: finalMessage,
-            introContext: oldConfig.introContext,
-            permission: oldConfig.permission || 'full',
-            workingDir: oldConfig.workingDir,
-            name: oldConfig.name,
-            teamId: oldConfig.teamId,
-          });
-        } catch (spawnErr) {
-          daemon.registry.flushPendingRemovals();
-          throw spawnErr;
-        }
-        daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed: false });
-        return res.json(newAgent);
-      }
-
-      // Running CLI agent (no loop) — queue the message for delivery after
-      // the current task completes instead of killing and respawning.
-      if (daemon.processes.isRunning(req.params.id)) {
-        daemon.processes.queueMessage(req.params.id, wrappedMessage);
-        daemon.audit.log('agent.chat.queued', { id: req.params.id });
-        return res.json({ id: agent.id, status: 'message_queued' });
-      }
+      const result = await deliverInstruction(daemon, req.params.id, finalMessage);
 
-      // CLI agent path — session resume or rotation.
-      // Force rotation (fresh session + handoff brief) past the resume ceiling:
-      // reviving a >5M-token claude session has crashed the CLI mid-HTTP-parse
-      // (V8 fatal in JsonStringifier) — the rotator's handoff brief sidesteps that.
-      const SESSION_RESUME_CEILING = 5_000_000;
-      const resumed = !!agent.sessionId && (agent.tokensUsed || 0) < SESSION_RESUME_CEILING;
-      const newAgent = resumed
-        ? await daemon.processes.resume(req.params.id, wrappedMessage)
-        : await daemon.rotator.rotate(req.params.id, { additionalPrompt: wrappedMessage });
-
-      daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed });
-      res.json(newAgent);
+      // Respawn paths return the fresh agent record; in-place delivery just
+      // acknowledges with a status the GUI uses to show queued vs sent.
+      if (result.agent && result.agentId !== req.params.id) return res.json(result.agent);
+      res.json({ id: agent.id, status: result.status });
     } catch (err) {
       res.status(400).json({ error: err.message });
     }

package/node_modules/@groove-dev/daemon/src/routes/innerchat.js

@@ -1,30 +1,33 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 export function registerInnerChatRoutes(app, daemon) {
+  // Relay a message from one agent to another. Opens a thread, or continues
+  // an existing one when threadId is supplied.
   app.post('/api/innerchat/send', async (req, res) => {
     try {
-      const { from, to, message } = req.body;
+      const { from, to, message, threadId } = req.body;
       if (!from || typeof from !== 'string') return res.status(400).json({ error: 'from (agent ID) is required' });
       if (!to || typeof to !== 'string') return res.status(400).json({ error: 'to (agent ID) is required' });
       if (!message || typeof message !== 'string' || !message.trim()) return res.status(400).json({ error: 'message is required' });
       if (from === to) return res.status(400).json({ error: 'cannot send a message to yourself' });
+      if (threadId && typeof threadId !== 'string') return res.status(400).json({ error: 'threadId must be a string' });
 
-      const msg = await daemon.innerchat.send(from, to, message.trim());
-      res.json(msg);
+      const result = await daemon.innerchat.send(from, to, message.trim(), threadId || null);
+      res.json(result);
     } catch (err) {
       res.status(400).json({ error: err.message });
     }
   });
 
-  app.get('/api/innerchat/messages', (req, res) => {
+  app.get('/api/innerchat/threads', (req, res) => {
     const { agentId } = req.query;
-    res.json({ messages: daemon.innerchat.getMessages(agentId || null) });
+    res.json({ threads: daemon.innerchat.getThreads(agentId || null) });
   });
 
-  app.get('/api/innerchat/messages/:id', (req, res) => {
-    const msg = daemon.innerchat.getMessage(req.params.id);
-    if (!msg) return res.status(404).json({ error: 'Message not found' });
-    res.json(msg);
+  app.get('/api/innerchat/threads/:id', (req, res) => {
+    const thread = daemon.innerchat.getThread(req.params.id);
+    if (!thread) return res.status(404).json({ error: 'Thread not found' });
+    res.json(thread);
   });
 
   app.get('/api/innerchat/pending/:agentId', (req, res) => {

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

@@ -148,11 +148,17 @@ export class Teams {
           renameSync(oldWorkingDir, newWorkingDir);
           team.workingDir = newWorkingDir;
 
-          // Update all agents in this team with the new working directory
+          // Repoint every agent under the old tree, not just those sitting at
+          // its root — an agent in a subdirectory would otherwise keep a path
+          // that no longer exists.
           const agents = this.daemon.registry.getAll().filter((a) => a.teamId === id);
           for (const agent of agents) {
+            if (!agent.workingDir) continue;
             if (agent.workingDir === oldWorkingDir) {
               this.daemon.registry.update(agent.id, { workingDir: newWorkingDir });
+            } else if (agent.workingDir.startsWith(`${oldWorkingDir}/`)) {
+              const suffix = agent.workingDir.slice(oldWorkingDir.length);
+              this.daemon.registry.update(agent.id, { workingDir: `${newWorkingDir}${suffix}` });
             }
           }
         } catch (err) {

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'));
   });
 });