groove-dev 0.27.183 → 0.27.185

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

@@ -1,32 +1,28 @@
 // GROOVE — InnerChat Tests
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { describe, it, beforeEach } from 'node:test';
+import { describe, it, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { InnerChat } from '../src/innerchat.js';
+import { InnerChat, MAX_EXCHANGES } 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).
+// Mirrors the daemon surface deliverInstruction touches. `_loops` marks an
+// interactive loop, `_running` a busy CLI agent; anything in neither is
+// stopped (resume path, which mints a new id).
 function makeDaemon() {
   const broadcasts = [];
   const audits = [];
-  const sentMessages = [];
-  const queuedMessages = [];
+  const sent = [];
+  const queued = [];
   const resumes = [];
-
   let idCounter = 0;
 
   return {
-    broadcasts,
-    audits,
-    sentMessages,
-    queuedMessages,
-    resumes,
+    broadcasts, audits, sent, queued, resumes,
     registry: {
       _agents: new Map(),
       get(id) { return this._agents.get(id) || null; },
-      add(agent) { this._agents.set(agent.id, agent); },
+      getAll() { return [...this._agents.values()]; },
+      add(agent) { this._agents.set(agent.id, agent); return agent; },
       remove(id) { this._agents.delete(id); },
       flushPendingRemovals() {},
       update() {},
@@ -37,14 +33,8 @@ function makeDaemon() {
       _running: new Set(),
       hasAgentLoop(id) { return this._loops.has(id); },
       isRunning(id) { return this._running.has(id); },
-      async sendMessage(id, msg, source) {
-        sentMessages.push({ id, msg, source });
-        return true;
-      },
-      queueMessage(id, msg) {
-        queuedMessages.push({ id, msg });
-      },
-      // Resume mints a new agent id, exactly as the real one does.
+      async sendMessage(id, msg) { sent.push({ id, msg }); return true; },
+      queueMessage(id, msg) { queued.push({ id, msg }); },
       async resume(id, msg) {
         const old = this._agentsRef.get(id);
         const fresh = { ...old, id: `${id}-r${++idCounter}` };
@@ -62,228 +52,281 @@ function makeDaemon() {
   };
 }
 
-function wire(daemon) {
-  daemon.processes._agentsRef = daemon.registry._agents;
-  daemon.rotator._daemon = daemon;
-}
-
 const result = (text) => ({ type: 'result', data: text });
+const tick = () => new Promise((r) => setImmediate(r));
 
 describe('InnerChat', () => {
-  let daemon;
-  let innerchat;
+  let daemon, innerchat;
 
   beforeEach(() => {
     daemon = makeDaemon();
-    wire(daemon);
+    daemon.processes._agentsRef = daemon.registry._agents;
+    daemon.rotator._daemon = daemon;
     innerchat = new InnerChat(daemon);
     daemon.innerchat = innerchat;
 
-    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');
+    for (const [id, name] of [['a1', 'fullstack-1'], ['a2', 'fullstack-14']]) {
+      daemon.registry.add({ id, name, role: 'fullstack', provider: 'claude-code' });
+      daemon.processes._loops.add(id);
+      daemon.processes._running.add(id);
+    }
   });
 
-  // ── Sending ───────────────────────────────────────────────
+  // Clear any un-awaited ask/tell timers so the runner can exit.
+  afterEach(() => innerchat.stop());
+
+  // ── The blocking round trip ───────────────────────────────
 
-  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('blocks until the target answers, then resolves with the reply', async () => {
+    const pending = innerchat.ask('a1', 'a2', 'What endpoint shape?');
 
-    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');
+    let settled = false;
+    pending.then(() => { settled = true; });
+    await tick();
+    assert.equal(settled, false, 'must not resolve before an answer arrives');
 
-    const delivered = daemon.sentMessages.at(-1);
+    const delivered = daemon.sent.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\?/);
-  });
+    assert.match(delivered.msg, /fullstack-1 \(fullstack\) is asking you a question/);
+    assert.match(delivered.msg, /BLOCKED waiting on your answer/);
+
+    innerchat.onAgentOutput('a2', result('REST, /api/v2/orders'));
+    const res = await pending;
 
-  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/);
+    assert.equal(res.reply, 'REST, /api/v2/orders');
+    assert.equal(res.exchanges, 1);
+    assert.equal(res.remaining, MAX_EXCHANGES - 1);
   });
 
-  it('rejects an unknown threadId', async () => {
-    await assert.rejects(() => innerchat.send('a1', 'a2', 'hi', 'bogus'), /not found/);
+  it('ignores non-result and empty output while waiting', async () => {
+    const pending = innerchat.ask('a1', 'a2', 'What shape?');
+    await tick();
+
+    innerchat.onAgentOutput('a2', { type: 'assistant', data: 'thinking…' });
+    innerchat.onAgentOutput('a2', result('   '));
+    await tick();
+
+    assert.ok(innerchat.getPending('a2'), 'still waiting');
+    innerchat.onAgentOutput('a2', result('done'));
+    assert.equal((await pending).reply, 'done');
   });
 
-  // ── Reply capture and auto-forward ────────────────────────
+  it('skips the in-flight result when the question queued behind live work', async () => {
+    daemon.processes._loops.delete('a2'); // running, no loop → queued
+    const pending = innerchat.ask('a1', 'a2', 'What shape?');
+    await tick();
+    assert.equal(daemon.queued.at(-1).id, 'a2');
 
-  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));
+    innerchat.onAgentOutput('a2', result('finished the PREVIOUS task'));
+    await tick();
+    assert.ok(innerchat.getPending('a2'), 'prior task result must not be taken as the answer');
 
-    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/);
+    innerchat.onAgentOutput('a2', result('the actual answer'));
+    assert.equal((await pending).reply, 'the actual answer');
   });
 
-  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);
+  // ── Guardrails ────────────────────────────────────────────
+
+  it('refuses a call that would deadlock and says how to resolve it', async () => {
+    const outbound = innerchat.ask('a1', 'a2', 'question for 14');
+    await tick();
+
+    // a2 tries to ask a1 back while a1 is blocked on a2.
+    await assert.rejects(
+      () => innerchat.ask('a2', 'a1', 'counter-question'),
+      /waiting for YOUR answer/,
+    );
+
+    innerchat.onAgentOutput('a2', result('fine'));
+    await outbound;
   });
 
-  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));
+  it('refuses a second concurrent question to a busy target', async () => {
+    daemon.registry.add({ id: 'a3', name: 'fullstack-9', role: 'fullstack', provider: 'claude-code' });
+    daemon.processes._loops.add('a3');
+    daemon.processes._running.add('a3');
 
-    assert.equal(daemon.sentMessages.at(-1).id, 'a2', 'no forward should have happened');
-    assert.ok(innerchat.getPending('a2'), 'relay is still outstanding');
+    const first = innerchat.ask('a1', 'a2', 'q1');
+    await tick();
+    await assert.rejects(() => innerchat.ask('a3', 'a2', 'q2'), /already answering/);
+
+    innerchat.onAgentOutput('a2', result('a'));
+    await first;
+  });
+
+  it('enforces the exchange cap and tells the agent to report', async () => {
+    for (let i = 0; i < MAX_EXCHANGES; i++) {
+      const p = innerchat.ask('a1', 'a2', `q${i}`);
+      await tick();
+      innerchat.onAgentOutput('a2', result(`a${i}`));
+      await p;
+    }
+    await assert.rejects(
+      () => innerchat.ask('a1', 'a2', 'one more'),
+      new RegExp(`${MAX_EXCHANGES}-exchange limit`),
+    );
   });
 
-  it('captures a reply only once', async () => {
-    await innerchat.send('a1', 'a2', 'What shape?');
-    innerchat.onAgentOutput('a2', result('first'));
-    innerchat.onAgentOutput('a2', result('second'));
-    await new Promise((r) => setImmediate(r));
+  it('counts exchanges down across a continuing conversation', async () => {
+    const p1 = innerchat.ask('a1', 'a2', 'q1');
+    await tick(); innerchat.onAgentOutput('a2', result('a1'));
+    const r1 = await p1;
+
+    const p2 = innerchat.ask('a1', 'a2', 'q2');
+    await tick(); innerchat.onAgentOutput('a2', result('a2'));
+    const r2 = await p2;
 
-    const forwards = daemon.sentMessages.filter((m) => /InnerChat reply/.test(m.msg));
-    assert.equal(forwards.length, 1);
-    assert.match(forwards[0].msg, /first/);
+    assert.equal(r1.threadId, r2.threadId, 'same conversation continues');
+    assert.equal(r2.exchanges, 2);
+    assert.equal(r2.remaining, MAX_EXCHANGES - 2);
   });
 
-  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?');
-    assert.equal(daemon.queuedMessages.at(-1).id, 'a2');
+  it('times out rather than blocking forever', async () => {
+    await assert.rejects(
+      () => innerchat.ask('a1', 'a2', 'silence', { timeoutMs: 20 }),
+      /No answer within/,
+    );
+    // The slot must be released, or the pair is wedged for good.
+    assert.equal(innerchat.getPending('a2'), null);
+    assert.equal(innerchat.blockedOn.get('a1'), undefined);
+  });
 
-    // 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);
+  it('unblocks the asker when the target dies mid-question', async () => {
+    const pending = innerchat.ask('a1', 'a2', 'q');
+    await tick();
+    innerchat.onAgentGone('a2', 'crashed');
+    await assert.rejects(() => pending, /crashed before answering/);
+    assert.equal(innerchat.blockedOn.get('a1'), undefined);
+  });
 
-    // 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('rejects unknown, self-addressed and empty asks', async () => {
+    await assert.rejects(() => innerchat.ask('nope', 'a2', 'x'), /not found/);
+    await assert.rejects(() => innerchat.ask('a1', 'nope', 'x'), /not found/);
+    await assert.rejects(() => innerchat.ask('a1', 'a1', 'x'), /cannot ask itself/);
+    await assert.rejects(() => innerchat.ask('a1', 'a2', '  '), /message is required/);
   });
 
-  // ── Stopped agents / id remapping ─────────────────────────
+  it('surfaces a delivery failure as an unreachable error', async () => {
+    daemon.processes.sendMessage = async () => { throw new Error('pipe closed'); };
+    await assert.rejects(() => innerchat.ask('a1', 'a2', 'x'), /Could not reach fullstack-14: pipe closed/);
+    assert.equal(innerchat.blockedOn.get('a1'), undefined);
+  });
 
-  it('resumes a stopped target and tracks it under its new id', async () => {
+  // ── Stopped targets / id remapping ────────────────────────
+
+  it('resumes a stopped target and matches the answer on 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;
+    const pending = innerchat.ask('a1', 'a2', 'ping');
+    await tick();
 
+    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');
+    assert.ok(innerchat.getPending(newId), '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/);
+    assert.equal((await pending).reply, 'pong');
   });
 
-  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));
+  // ── Conversation context ──────────────────────────────────
 
-    const resume = daemon.resumes.at(-1);
-    assert.equal(resume.id, 'a1');
-    assert.match(resume.msg, /InnerChat reply from fullstack-14/);
-  });
+  it('replays prior turns so neither side re-explains', async () => {
+    const p1 = innerchat.ask('a1', 'a2', 'What shape?');
+    await tick(); innerchat.onAgentOutput('a2', result('REST'));
+    await p1;
 
-  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 p2 = innerchat.ask('a1', 'a2', 'Versioned?');
+    await tick();
+    const msg = daemon.sent.at(-1).msg;
+    assert.match(msg, /Earlier in this conversation/);
+    assert.match(msg, /fullstack-1: What shape\?/);
+    assert.match(msg, /fullstack-14: REST/);
+    assert.match(msg, /Versioned\?/);
 
-    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');
+    innerchat.onAgentOutput('a2', result('v2'));
+    await p2;
   });
 
-  // ── 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\?/);
+  it('broadcasts and audits both directions', async () => {
+    const p = innerchat.ask('a1', 'a2', 'q');
+    await tick();
+    innerchat.onAgentOutput('a2', result('a'));
+    await p;
 
-    assert.equal(innerchat.getThreads().length, 1, 'reused the existing thread');
-    assert.equal(first.thread.turns.length, 3);
+    const turns = daemon.broadcasts.filter((b) => b.type === 'innerchat:turn');
+    assert.equal(turns.length, 2);
+    assert.equal(turns[0].data.turn.kind, 'ask');
+    assert.equal(turns[1].data.turn.kind, 'answer');
+    assert.ok(daemon.audits.some((a) => a.type === 'innerchat.ask'));
+    assert.ok(daemon.audits.some((a) => a.type === 'innerchat.answer'));
   });
 
-  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');
-
-    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);
+  // ── tell: non-blocking send ───────────────────────────────
 
-    innerchat.onAgentOutput('a3', result('answer from 9'));
-    await new Promise((r) => setImmediate(r));
+  it('tell returns immediately without waiting for a reply', async () => {
+    const res = await innerchat.tell('a1', 'a2', 'heads up, spec is on disk');
+    assert.equal(res.delivered, true);
+    assert.ok(res.threadId);
 
-    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');
+    // Delivered, framed as non-blocking.
+    const msg = daemon.sent.at(-1);
+    assert.equal(msg.id, 'a2');
+    assert.match(msg.msg, /sent you a message/);
+    assert.match(msg.msg, /NOT blocked/);
   });
 
-  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');
+  it('routes an async reply back to the sender, resuming it if needed', async () => {
+    await innerchat.tell('a1', 'a2', 'when you get a sec, confirm the error shape');
+    // a1 ended its turn: stopped, no loop.
+    daemon.processes._loops.delete('a1');
+    daemon.processes._running.delete('a1');
 
-    await innerchat.send('a1', 'a2', 'hi');
-    await innerchat.send('a1', 'a3', 'hi');
+    innerchat.onAgentOutput('a2', result('confirmed: {code, message}'));
+    await tick();
 
-    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);
+    // Reply delivered to a1 — via resume, since it had ended.
+    const resume = daemon.resumes.at(-1);
+    assert.equal(resume.id, 'a1');
+    assert.match(resume.msg, /InnerChat reply from fullstack-14/);
+    assert.match(resume.msg, /confirmed: \{code, message\}/);
+    assert.match(resume.msg, /you were not blocking/);
   });
 
-  // ── Broadcast & audit ─────────────────────────────────────
+  it('does not block the sender or set blockedOn for a tell', async () => {
+    await innerchat.tell('a1', 'a2', 'fyi');
+    assert.equal(innerchat.blockedOn.get('a1'), undefined);
+    assert.ok(innerchat.getPending('a2'), 'still capturing the eventual reply');
+  });
 
-  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));
+  it('a tell to a target already awaited is refused', async () => {
+    // Left blocking; afterEach stop() rejects it — swallow so it isn't unhandled.
+    innerchat.ask('a1', 'a2', 'blocking q').catch(() => {});
+    await tick();
+    await assert.rejects(() => innerchat.tell('a1', 'a2', 'second'), /unanswered message/);
+  });
 
-    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');
+  it('ask and tell share the exchange budget', async () => {
+    const r1 = await innerchat.tell('a1', 'a2', 'one');
+    assert.equal(r1.exchanges, 1);
+    // a2 replies to the tell, freeing the slot.
+    innerchat.onAgentOutput('a2', result('ok'));
+    await tick();
+
+    const p = innerchat.ask('a1', 'a2', 'two');
+    await tick();
+    innerchat.onAgentOutput('a2', result('answer'));
+    const r2 = await p;
+    assert.equal(r2.exchanges, 2, 'tell + ask both count');
+  });
 
-    assert.ok(daemon.audits.some((a) => a.type === 'innerchat.send'));
-    assert.ok(daemon.audits.some((a) => a.type === 'innerchat.reply'));
+  it('an async sender that vanishes is dropped quietly', async () => {
+    await innerchat.tell('a1', 'a2', 'x');
+    daemon.registry._agents.delete('a1'); // sender gone entirely
+    // Reply arrives with nobody to route to — must not throw.
+    innerchat.onAgentOutput('a2', result('late answer'));
+    await tick();
+    assert.equal(innerchat.getPending('a2'), null);
   });
 });

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

@@ -185,6 +185,59 @@ describe('Teams', () => {
     assert.ok(teams2.list().some((t) => t.name === 'Persistent'));
   });
 
+  describe('reorder', () => {
+    it('reorders the list and persists it', () => {
+      const a = teams.create('Alpha');
+      const b = teams.create('Bravo');
+      const c = teams.create('Charlie');
+      const def = teams.getDefault();
+
+      teams.reorder([c.id, a.id, b.id, def.id]);
+      assert.deepEqual(teams.list().map((t) => t.name), ['Charlie', 'Alpha', 'Bravo', 'Default']);
+
+      // Order is the persisted array order, so it survives a reload.
+      const reloaded = new Teams(daemon);
+      assert.deepEqual(reloaded.list().map((t) => t.name), ['Charlie', 'Alpha', 'Bravo', 'Default']);
+    });
+
+    it('keeps teams missing from the given order rather than dropping them', () => {
+      const a = teams.create('Alpha');
+      const b = teams.create('Bravo');
+      const before = teams.list().length;
+
+      // A stale client sends only the ids it knew about.
+      teams.reorder([b.id, a.id]);
+
+      assert.equal(teams.list().length, before);
+      assert.deepEqual(teams.list().map((t) => t.name), ['Bravo', 'Alpha', 'Default']);
+    });
+
+    it('ignores unknown and duplicated ids', () => {
+      const a = teams.create('Alpha');
+      const before = teams.list().length;
+
+      teams.reorder([a.id, 'does-not-exist', a.id]);
+
+      assert.equal(teams.list().length, before);
+      assert.equal(teams.list()[0].name, 'Alpha');
+    });
+
+    it('rejects a non-array', () => {
+      assert.throws(() => teams.reorder('nope'), /must be an array/);
+      assert.throws(() => teams.reorder(undefined), /must be an array/);
+    });
+
+    it('broadcasts the new order', () => {
+      const a = teams.create('Alpha');
+      broadcasts.length = 0;
+      teams.reorder([a.id]);
+
+      const evt = broadcasts.find((b) => b.type === 'teams:reordered');
+      assert.ok(evt, 'teams:reordered was broadcast');
+      assert.equal(evt.teams[0].name, 'Alpha');
+    });
+  });
+
   it('should provide backward compat stubs', () => {
     // onAgentChange is a no-op
     teams.onAgentChange();