npm - @zoebuildsai/trace - Versions diffs - 1.5.0 - Mend

@zoebuildsai/trace 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (130) hide show

package/.gitignore +115 -0
package/.trace/progress.json +22 -0
package/README.md +466 -0
package/RELEASE-NOTES-1.5.0.md +410 -0
package/STATUS.md +245 -0
package/dist/auto-commit.d.ts +66 -0
package/dist/auto-commit.d.ts.map +1 -0
package/dist/auto-commit.js +180 -0
package/dist/auto-commit.js.map +1 -0
package/dist/cli.d.ts +7 -0
package/dist/cli.d.ts.map +1 -0
package/dist/cli.js +246 -0
package/dist/cli.js.map +1 -0
package/dist/commands.d.ts +46 -0
package/dist/commands.d.ts.map +1 -0
package/dist/commands.js +256 -0
package/dist/commands.js.map +1 -0
package/dist/diff.d.ts +23 -0
package/dist/diff.d.ts.map +1 -0
package/dist/diff.js +106 -0
package/dist/diff.js.map +1 -0
package/dist/github.d.ts.map +1 -0
package/dist/github.js.map +1 -0
package/dist/index-cache.d.ts +35 -0
package/dist/index-cache.d.ts.map +1 -0
package/dist/index-cache.js +114 -0
package/dist/index-cache.js.map +1 -0
package/dist/index.d.ts +15 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +25 -0
package/dist/index.js.map +1 -0
package/dist/storage.d.ts +45 -0
package/dist/storage.d.ts.map +1 -0
package/dist/storage.js +151 -0
package/dist/storage.js.map +1 -0
package/dist/sync.d.ts +60 -0
package/dist/sync.js +184 -0
package/dist/tags.d.ts +85 -0
package/dist/tags.d.ts.map +1 -0
package/dist/tags.js +219 -0
package/dist/tags.js.map +1 -0
package/dist/types.d.ts +102 -0
package/dist/types.d.ts.map +1 -0
package/dist/types.js +6 -0
package/dist/types.js.map +1 -0
package/docs/.nojekyll +0 -0
package/docs/README.md +73 -0
package/docs/_config.yml +2 -0
package/docs/index.html +960 -0
package/docs-website/package.json +20 -0
package/jest.config.js +21 -0
package/package.json +50 -0
package/scripts/init.ts +290 -0
package/src/agent-audit.ts +270 -0
package/src/agent-checkout.ts +227 -0
package/src/agent-coordination.ts +318 -0
package/src/async-queue.ts +203 -0
package/src/auto-branching.ts +279 -0
package/src/auto-commit.ts +166 -0
package/src/cherry-pick.ts +252 -0
package/src/chunked-upload.ts +224 -0
package/src/cli-v2.ts +335 -0
package/src/cli.ts +318 -0
package/src/cliff-detection.ts +232 -0
package/src/commands.ts +267 -0
package/src/commit-hash-system.ts +351 -0
package/src/compression.ts +176 -0
package/src/conflict-resolution-ui.ts +277 -0
package/src/conflict-visualization.ts +238 -0
package/src/diff-formatter.ts +184 -0
package/src/diff.ts +124 -0
package/src/distributed-coordination.ts +273 -0
package/src/git-interop.ts +316 -0
package/src/index-cache.ts +88 -0
package/src/index.ts +38 -0
package/src/merge-engine.ts +143 -0
package/src/message-search.ts +370 -0
package/src/performance-monitoring.ts +236 -0
package/src/rebase.ts +327 -0
package/src/rollback.ts +215 -0
package/src/semantic-grouping.ts +245 -0
package/src/stage-area.ts +324 -0
package/src/stash.ts +278 -0
package/src/storage.ts +131 -0
package/src/sync.ts +205 -0
package/src/tags.ts +244 -0
package/src/types.ts +119 -0
package/src/webhooks.ts +119 -0
package/src/workspace-isolation.ts +298 -0
package/tests/auto-commit.test.ts +308 -0
package/tests/checkout.test.ts +136 -0
package/tests/commit.test.ts +118 -0
package/tests/diff.test.ts +191 -0
package/tests/github.test.ts +94 -0
package/tests/integration.test.ts +267 -0
package/tests/log.test.ts +125 -0
package/tests/phase2-integration.test.ts +370 -0
package/tests/storage.test.ts +167 -0
package/tests/tags.test.ts +477 -0
package/tests/types.test.ts +75 -0
package/tests/v1.1/agent-audit.test.ts +472 -0
package/tests/v1.1/agent-coordination.test.ts +308 -0
package/tests/v1.1/async-queue.test.ts +253 -0
package/tests/v1.1/comprehensive.test.ts +521 -0
package/tests/v1.1/diff-formatter.test.ts +238 -0
package/tests/v1.1/integration.test.ts +389 -0
package/tests/v1.1/onboarding.test.ts +365 -0
package/tests/v1.1/rollback.test.ts +370 -0
package/tests/v1.1/semantic-grouping.test.ts +230 -0
package/tests/v1.2/chunked-upload.test.ts +301 -0
package/tests/v1.2/cliff-detection.test.ts +272 -0
package/tests/v1.2/commit-hash-system.test.ts +288 -0
package/tests/v1.2/compression.test.ts +220 -0
package/tests/v1.2/conflict-visualization.test.ts +263 -0
package/tests/v1.2/distributed.test.ts +261 -0
package/tests/v1.2/performance-monitoring.test.ts +328 -0
package/tests/v1.3/auto-branching.test.ts +270 -0
package/tests/v1.3/message-search.test.ts +264 -0
package/tests/v1.3/stage-area.test.ts +330 -0
package/tests/v1.3/stash-rebase-cherry-pick.test.ts +361 -0
package/tests/v1.4/cli.test.ts +171 -0
package/tests/v1.4/conflict-resolution-advanced.test.ts +429 -0
package/tests/v1.4/conflict-resolution-ui.test.ts +286 -0
package/tests/v1.4/workspace-isolation-advanced.test.ts +382 -0
package/tests/v1.4/workspace-isolation.test.ts +268 -0
package/tests/v1.5/agent-coordination.real.test.ts +401 -0
package/tests/v1.5/cli-v2.test.ts +354 -0
package/tests/v1.5/git-interop.real.test.ts +358 -0
package/tests/v1.5/integration-testing.real.test.ts +440 -0
package/tsconfig.json +26 -0

package/tests/v1.2/conflict-visualization.test.ts ADDED Viewed

@@ -0,0 +1,263 @@
+/**
+ * Conflict Visualization Tests
+ * Multiple output formats for merge conflicts
+ */
+import { ConflictVisualization, ConflictHunk } from '../../src/conflict-visualization';
+describe('ConflictVisualization', () => {
+  const mockHunks: ConflictHunk[] = [
+    {
+      startLine: 10,
+      endLine: 15,
+      ours: ['let x = 5', 'console.log(x)'],
+      theirs: ['let x = 10', 'console.log(x * 2)'],
+    },
+    {
+      startLine: 20,
+      endLine: 25,
+      ours: ['return result', 'return result;'],
+      theirs: ['return undefined', 'return null;'],
+    },
+  ];
+  describe('ASCII Rendering', () => {
+    test('renders conflict in ASCII format', () => {
+      const ascii = ConflictVisualization.toASCII('file.ts', mockHunks, 'agent-a', 'agent-b');
+      expect(typeof ascii).toBe('string');
+      expect(ascii).toContain('CONFLICT');
+      expect(ascii).toContain('file.ts');
+    });
+    test('includes both agent names', () => {
+      const ascii = ConflictVisualization.toASCII('file.ts', mockHunks, 'researcher', 'builder');
+      expect(ascii).toContain('researcher');
+      expect(ascii).toContain('builder');
+    });
+    test('includes conflict content', () => {
+      const ascii = ConflictVisualization.toASCII('file.ts', mockHunks, 'a', 'b');
+      expect(ascii).toContain('let x = 5');
+      expect(ascii).toContain('let x = 10');
+    });
+    test('shows line numbers', () => {
+      const ascii = ConflictVisualization.toASCII('file.ts', mockHunks, 'a', 'b');
+      expect(ascii).toContain('10');
+      expect(ascii).toContain('20');
+    });
+    test('handles multiple hunks', () => {
+      const ascii = ConflictVisualization.toASCII('file.ts', mockHunks, 'a', 'b');
+      expect(ascii).toContain('Conflict 1');
+      expect(ascii).toContain('Conflict 2');
+    });
+    test('handles empty hunks', () => {
+      const ascii = ConflictVisualization.toASCII('file.ts', [], 'a', 'b');
+      expect(ascii).toContain('CONFLICT');
+    });
+  });
+  describe('JSON Rendering', () => {
+    test('renders conflict as JSON', () => {
+      const json = ConflictVisualization.toJSON('file.ts', mockHunks, 'agent-a', 'agent-b');
+      const parsed = JSON.parse(json);
+      expect(parsed.file).toBe('file.ts');
+      expect(parsed.agentA).toBe('agent-a');
+      expect(parsed.agentB).toBe('agent-b');
+    });
+    test('includes hunks in JSON', () => {
+      const json = ConflictVisualization.toJSON('file.ts', mockHunks, 'a', 'b');
+      const parsed = JSON.parse(json);
+      expect(parsed.hunks).toHaveLength(2);
+    });
+    test('JSON includes metrics', () => {
+      const json = ConflictVisualization.toJSON('file.ts', mockHunks, 'a', 'b');
+      const parsed = JSON.parse(json);
+      expect(parsed.totalHunks).toBe(2);
+      expect(parsed.timestamp).toBeDefined();
+    });
+    test('JSON is valid and parseable', () => {
+      const json = ConflictVisualization.toJSON('file.ts', mockHunks, 'a', 'b');
+      expect(() => JSON.parse(json)).not.toThrow();
+    });
+  });
+  describe('HTML Rendering', () => {
+    test('renders conflict as HTML', () => {
+      const html = ConflictVisualization.toHTML('file.ts', mockHunks, 'agent-a', 'agent-b');
+      expect(html).toContain('<html>');
+      expect(html).toContain('</html>');
+    });
+    test('includes file name in HTML', () => {
+      const html = ConflictVisualization.toHTML('myfile.ts', mockHunks, 'a', 'b');
+      expect(html).toContain('myfile.ts');
+    });
+    test('includes CSS styling', () => {
+      const html = ConflictVisualization.toHTML('file.ts', mockHunks, 'a', 'b');
+      expect(html).toContain('<style>');
+    });
+    test('renders both versions side-by-side', () => {
+      const html = ConflictVisualization.toHTML('file.ts', mockHunks, 'agent-a', 'agent-b');
+      expect(html).toContain('agent-a');
+      expect(html).toContain('agent-b');
+    });
+  });
+  describe('Git Format Rendering', () => {
+    test('renders with git conflict markers', () => {
+      const git = ConflictVisualization.toGitFormat(mockHunks, 'agent-a', 'agent-b');
+      expect(git).toContain('<<<<<<< agent-a');
+      expect(git).toContain('=======');
+      expect(git).toContain('>>>>>>> agent-b');
+    });
+    test('includes all conflict content', () => {
+      const git = ConflictVisualization.toGitFormat(mockHunks, 'a', 'b');
+      expect(git).toContain('let x = 5');
+      expect(git).toContain('let x = 10');
+    });
+  });
+  describe('Git Marker Parsing', () => {
+    test('parses git conflict markers', () => {
+      const content = `
+before
+<<<<<<< agent-a
+our change
+=======
+their change
+>>>>>>> agent-b
+after`;
+      const hunks = ConflictVisualization.parseGitMarkers(content, 'agent-a', 'agent-b');
+      expect(hunks).toHaveLength(1);
+      expect(hunks[0].ours).toContain('our change');
+      expect(hunks[0].theirs).toContain('their change');
+    });
+    test('handles multiple conflicts', () => {
+      const content = `
+<<<<<<< a
+v1
+=======
+v2
+>>>>>>> b
+text
+<<<<<<< a
+x1
+=======
+x2
+>>>>>>> b`;
+      const hunks = ConflictVisualization.parseGitMarkers(content, 'a', 'b');
+      expect(hunks.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+  describe('Resolution Suggestions', () => {
+    test('suggests resolution based on shorter diff', () => {
+      const hunks: ConflictHunk[] = [
+        {
+          startLine: 1,
+          endLine: 5,
+          ours: ['short'],
+          theirs: ['very', 'long', 'content', 'here'],
+        },
+      ];
+      const winner = ConflictVisualization.suggestResolution(hunks, 'a', 'b');
+      expect(winner).toBe('a');
+    });
+    test('suggests other agent for longer diff', () => {
+      const hunks: ConflictHunk[] = [
+        {
+          startLine: 1,
+          endLine: 5,
+          ours: ['very', 'long', 'content'],
+          theirs: ['short'],
+        },
+      ];
+      const winner = ConflictVisualization.suggestResolution(hunks, 'agent-a', 'agent-b');
+      expect(winner).toBe('agent-b');
+    });
+  });
+  describe('Statistics', () => {
+    test('calculates conflict stats', () => {
+      const stats = ConflictVisualization.getStats(mockHunks);
+      expect(stats.totalHunks).toBe(2);
+      expect(stats.totalLinesInConflict).toBeGreaterThan(0);
+      expect(stats.avgHunkSize).toBeGreaterThan(0);
+    });
+    test('handles empty hunks', () => {
+      const stats = ConflictVisualization.getStats([]);
+      expect(stats.totalHunks).toBe(0);
+      expect(stats.totalLinesInConflict).toBe(0);
+      expect(stats.avgHunkSize).toBe(0);
+    });
+    test('calculates average hunk size', () => {
+      const stats = ConflictVisualization.getStats(mockHunks);
+      const expectedAvg = mockHunks.reduce((sum, h) => sum + h.ours.length + h.theirs.length, 0) / mockHunks.length;
+      expect(stats.avgHunkSize).toBe(expectedAvg);
+    });
+  });
+  describe('Large Conflict Handling', () => {
+    test('handles 100 conflict hunks', () => {
+      const hunks: ConflictHunk[] = [];
+      for (let i = 0; i < 100; i++) {
+        hunks.push({
+          startLine: i * 10,
+          endLine: (i + 1) * 10,
+          ours: [`our${i}`],
+          theirs: [`their${i}`],
+        });
+      }
+      const ascii = ConflictVisualization.toASCII('large.ts', hunks, 'a', 'b');
+      expect(ascii).toContain('Conflict 1');
+      expect(ascii).toContain('Conflict 100');
+    });
+    test('renders large conflicts to JSON', () => {
+      const hunks: ConflictHunk[] = Array(50).fill(null).map((_, i) => ({
+        startLine: i,
+        endLine: i + 1,
+        ours: [`line${i}a`],
+        theirs: [`line${i}b`],
+      }));
+      const json = ConflictVisualization.toJSON('file.ts', hunks, 'a', 'b');
+      const parsed = JSON.parse(json);
+      expect(parsed.hunks).toHaveLength(50);
+    });
+  });
+  describe('Format Consistency', () => {
+    test('all formats include same file name', () => {
+      const ascii = ConflictVisualization.toASCII('test.ts', mockHunks, 'a', 'b');
+      const json = ConflictVisualization.toJSON('test.ts', mockHunks, 'a', 'b');
+      const html = ConflictVisualization.toHTML('test.ts', mockHunks, 'a', 'b');
+      expect(ascii).toContain('test.ts');
+      expect(json).toContain('test.ts');
+      expect(html).toContain('test.ts');
+    });
+    test('all formats include agent names', () => {
+      const ascii = ConflictVisualization.toASCII('f.ts', mockHunks, 'researcher', 'builder');
+      const json = ConflictVisualization.toJSON('f.ts', mockHunks, 'researcher', 'builder');
+      const html = ConflictVisualization.toHTML('f.ts', mockHunks, 'researcher', 'builder');
+      expect(ascii).toContain('researcher');
+      expect(json).toContain('researcher');
+      expect(html).toContain('researcher');
+    });
+  });
+});

package/tests/v1.2/distributed.test.ts ADDED Viewed

@@ -0,0 +1,261 @@
+/**
+ * Distributed Coordination Tests
+ * Multi-machine agent collaboration
+ */
+import { DistributedCoordination } from '../../src/distributed-coordination';
+describe('DistributedCoordination', () => {
+  let coord: DistributedCoordination;
+  beforeEach(() => {
+    coord = new DistributedCoordination();
+  });
+  describe('Remote Agent Registration', () => {
+    test('registers remote agent', () => {
+      const agent = coord.registerRemoteAgent(
+        'agent-1',
+        'https://agent1.example.com/api',
+        'pubkey123'
+      );
+      expect(agent.agentId).toBe('agent-1');
+      expect(agent.status).toBe('offline');
+    });
+    test('stores agent endpoint', () => {
+      coord.registerRemoteAgent('a1', 'https://host1/api', 'key1');
+      const agent = coord.getAgentStatus('a1');
+      expect(agent?.endpoint).toBe('https://host1/api');
+    });
+    test('multiple agents', () => {
+      coord.registerRemoteAgent('a1', 'https://host1/api', 'key1');
+      coord.registerRemoteAgent('a2', 'https://host2/api', 'key2');
+      coord.registerRemoteAgent('a3', 'https://host3/api', 'key3');
+      const agents = coord.getAllAgents();
+      expect(agents).toHaveLength(3);
+    });
+  });
+  describe('Lock Requests', () => {
+    beforeEach(() => {
+      coord.registerRemoteAgent('a1', 'https://h1/api', 'k1');
+      coord.registerRemoteAgent('a2', 'https://h2/api', 'k2');
+    });
+    test('sends lock request', async () => {
+      const result = await coord.requestRemoteLock('a1', 'file.ts', 30000, 'sig1');
+      expect(result).toBe(true);
+    });
+    test('rejects lock for offline agent', async () => {
+      const result = await coord.requestRemoteLock('a1', 'file.ts', 30000, 'sig1');
+      expect(result).toBe(false);
+    });
+    test('grants lock', () => {
+      coord.updateHeartbeat('a1');
+      const result = coord.grantLock('a1', 'file.ts', 30000, 'sig1');
+      expect(result).toBe(true);
+    });
+    test('releases lock', () => {
+      const result = coord.releaseLock('a1', 'file.ts', 'sig1');
+      expect(result).toBe(true);
+    });
+  });
+  describe('Commit Broadcasting', () => {
+    beforeEach(() => {
+      coord.registerRemoteAgent('a1', 'https://h1/api', 'k1');
+      coord.registerRemoteAgent('a2', 'https://h2/api', 'k2');
+    });
+    test('broadcasts commit to all agents', () => {
+      const count = coord.broadcastCommit('a1', 'c1', ['f1.ts', 'f2.ts'], 'sig1');
+      expect(count).toBe(2);
+    });
+    test('records broadcast in message log', () => {
+      coord.broadcastCommit('a1', 'c1', ['f.ts'], 'sig1');
+      const log = coord.getMessageLog();
+      expect(log.length).toBeGreaterThan(0);
+      expect(log[0].type).toBe('commit');
+    });
+  });
+  describe('Collision Reporting', () => {
+    beforeEach(() => {
+      coord.registerRemoteAgent('a1', 'https://h1/api', 'k1');
+      coord.registerRemoteAgent('a2', 'https://h2/api', 'k2');
+    });
+    test('reports collision between agents', () => {
+      const result = coord.reportCollision('a1', 'a2', 'shared.ts', 'sig1');
+      expect(result).toBe(true);
+    });
+    test('collision logged in message log', () => {
+      coord.reportCollision('a1', 'a2', 'shared.ts', 'sig1');
+      const log = coord.getMessageLog();
+      expect(log.some(m => m.type === 'collision')).toBe(true);
+    });
+  });
+  describe('State Synchronization', () => {
+    beforeEach(() => {
+      coord.registerRemoteAgent('a1', 'https://h1/api', 'k1');
+    });
+    test('syncs agent state', () => {
+      const state = coord.syncState('a1', 'c1', 5);
+      expect(state.agentId).toBe('a1');
+      expect(state.filesChanged).toBe(5);
+      expect(state.status).toBe('synced');
+    });
+    test('tracks sync status per agent', () => {
+      coord.syncState('a1', 'c1', 3);
+      coord.syncState('a1', 'c2', 4);
+      const states = coord.getSyncStatus('a1');
+      expect(states.length).toBe(2);
+    });
+  });
+  describe('Heartbeat & Liveness', () => {
+    beforeEach(() => {
+      coord.registerRemoteAgent('a1', 'https://h1/api', 'k1');
+    });
+    test('updates heartbeat', () => {
+      const result = coord.updateHeartbeat('a1');
+      expect(result).toBe(true);
+      const agent = coord.getAgentStatus('a1');
+      expect(agent?.status).toBe('online');
+    });
+    test('detects offline agents', () => {
+      const before = Date.now();
+      // Simulate time passing
+      const offline = coord.detectOfflineAgents();
+      expect(Array.isArray(offline)).toBe(true);
+    });
+  });
+  describe('Message Verification', () => {
+    test('verifies message signature', () => {
+      const msg = {
+        type: 'commit' as const,
+        agentId: 'a1',
+        timestamp: Date.now(),
+        signature: 'sig123',
+        payload: {},
+      };
+      const valid = coord.verifyMessage(msg, 'pubkey');
+      expect(typeof valid).toBe('boolean');
+    });
+  });
+  describe('Message Log', () => {
+    beforeEach(() => {
+      coord.registerRemoteAgent('a1', 'https://h1/api', 'k1');
+      coord.registerRemoteAgent('a2', 'https://h2/api', 'k2');
+    });
+    test('logs all messages', () => {
+      coord.broadcastCommit('a1', 'c1', ['f.ts'], 'sig1');
+      coord.reportCollision('a2', 'a1', 'f.ts', 'sig2');
+      const log = coord.getMessageLog();
+      expect(log.length).toBe(2);
+    });
+    test('filters log by agent', () => {
+      coord.broadcastCommit('a1', 'c1', ['f.ts'], 'sig1');
+      coord.broadcastCommit('a2', 'c2', ['g.ts'], 'sig2');
+      const a1Log = coord.getMessageLog('a1');
+      expect(a1Log.every(m => m.agentId === 'a1')).toBe(true);
+    });
+  });
+  describe('Distributed Merge', () => {
+    beforeEach(() => {
+      coord.registerRemoteAgent('a1', 'https://h1/api', 'k1');
+      coord.registerRemoteAgent('a2', 'https://h2/api', 'k2');
+    });
+    test('resolves merge between agents', () => {
+      coord.syncState('a1', 'c1', 5);
+      coord.syncState('a2', 'c2', 3);
+      const result = coord.resolveMergeDistributed(
+        'file.ts',
+        'a1',
+        'a2',
+        'timestamp-priority'
+      );
+      expect(result.resolved).toBe(true);
+      expect(result.winner).toBeDefined();
+    });
+  });
+  describe('Performance', () => {
+    test('registers 100 agents quickly', () => {
+      const start = Date.now();
+      for (let i = 0; i < 100; i++) {
+        coord.registerRemoteAgent(`a${i}`, `https://h${i}/api`, `k${i}`);
+      }
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(100);
+    });
+    test('broadcasts to 100 agents quickly', () => {
+      for (let i = 0; i < 100; i++) {
+        coord.registerRemoteAgent(`a${i}`, `https://h${i}/api`, `k${i}`);
+      }
+      const start = Date.now();
+      coord.broadcastCommit('a0', 'c1', ['f.ts'], 'sig');
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(50);
+    });
+    test('handles 1000 messages in log', () => {
+      coord.registerRemoteAgent('a1', 'https://h1/api', 'k1');
+      const start = Date.now();
+      for (let i = 0; i < 1000; i++) {
+        coord.broadcastCommit('a1', `c${i}`, [`f${i}.ts`], `sig${i}`);
+      }
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(200);
+    });
+  });
+  describe('Multi-Agent Scenarios', () => {
+    test('handles 3 agents with collision', () => {
+      coord.registerRemoteAgent('a1', 'https://h1/api', 'k1');
+      coord.registerRemoteAgent('a2', 'https://h2/api', 'k2');
+      coord.registerRemoteAgent('a3', 'https://h3/api', 'k3');
+      coord.updateHeartbeat('a1');
+      coord.updateHeartbeat('a2');
+      coord.updateHeartbeat('a3');
+      coord.broadcastCommit('a1', 'c1', ['shared.ts'], 'sig1');
+      coord.reportCollision('a2', 'a1', 'shared.ts', 'sig2');
+      const log = coord.getMessageLog();
+      expect(log.length).toBe(2);
+    });
+    test('tracks all agents independently', () => {
+      for (let i = 0; i < 5; i++) {
+        coord.registerRemoteAgent(`a${i}`, `https://h${i}/api`, `k${i}`);
+        coord.syncState(`a${i}`, `c${i}`, i + 1);
+      }
+      for (let i = 0; i < 5; i++) {
+        const states = coord.getSyncStatus(`a${i}`);
+        expect(states.length).toBe(1);
+      }
+    });
+  });
+});