@cnrai/pave 0.3.35 → 0.3.51

package/test/agent-comm.test.js

@@ -1,598 +0,0 @@
-#!/usr/bin/env node
-/**
- * Tests for agent communication tools (Issue #203)
- * Phase 6: agent_send and agent_list tools
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-const registryPath = path.join(__dirname, '..', 'lib', 'agent-registry.js');
-const registry = require(registryPath);
-
-const agentCommPath = path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'tools', 'agent-comm.js');
-const agentComm = require(agentCommPath);
-
-const testDir = path.join(os.tmpdir(), 'pave-test-agent-comm-' + (process.pid || Date.now()));
-
-// Detect whether filesystem operations work (sandbox may lack mkdirSync)
-let canMkdir = false;
-try {
-  if (typeof fs.mkdirSync === 'function') {
-    fs.mkdirSync(testDir, { recursive: true });
-    canMkdir = true;
-    try { fs.rmSync(testDir, { recursive: true }); } catch (_) {}
-  }
-} catch (_) {}
-
-let passed = 0;
-let failed = 0;
-
-function assert(condition, msg) {
-  if (!condition) throw new Error('Assertion failed: ' + msg);
-}
-
-function runTest(name, fn) {
-  try {
-    fn();
-    console.log('\u2705 ' + name);
-    passed++;
-  } catch (e) {
-    console.log('\u274C ' + name + ': ' + e.message);
-    failed++;
-  }
-}
-
-function resetTestDir() {
-  if (!canMkdir) return false;
-  try { fs.rmSync(testDir, { recursive: true }); } catch (e) {}
-  try { fs.mkdirSync(testDir, { recursive: true }); } catch (e) {}
-  registry.setAgentsDir(testDir);
-  return true;
-}
-
-function cleanup() {
-  try { fs.rmSync(testDir, { recursive: true }); } catch (e) {}
-  registry.resetAgentsDir();
-  // Clear rate limit map between tests
-  agentComm._rateLimitMap.clear();
-}
-
-// ============================================================
-// Registration
-// ============================================================
-
-runTest('isAgentCommRegistered: false before registration', () => {
-  // Clear any prior registration
-  agentComm.registerAgentComm(null, null);
-  assert(agentComm.isAgentCommRegistered() === false, 'should be false');
-});
-
-runTest('registerAgentComm: sets registry and agent name', () => {
-  agentComm.registerAgentComm(registry, 'test-sender');
-  assert(agentComm.isAgentCommRegistered() === true, 'should be true after registration');
-});
-
-runTest('getAgentCommTools: returns 3 tools when registered', () => {
-  agentComm.registerAgentComm({ listAgents() { return []; }, isAgentAlive() { return { alive: false, status: null }; }, resolveAgentName() { return { error: 'not found' }; }, writeInboxMessage() {}, writeInterrupt() {}, readStatus() { return null; } }, 'test-agent');
-  const tools = agentComm.getAgentCommTools();
-  assert(tools.length === 3, 'should have 3 tools, got ' + tools.length);
-  assert(tools[0].function.name === 'agent_send', 'first tool should be agent_send');
-  assert(tools[1].function.name === 'agent_list', 'second tool should be agent_list');
-  assert(tools[2].function.name === 'agent_spawn', 'third tool should be agent_spawn');
-});
-
-runTest('getAgentCommTools: returns empty when not registered', () => {
-  agentComm.registerAgentComm(null, null);
-  const tools = agentComm.getAgentCommTools();
-  assert(tools.length === 0, 'should have 0 tools when not registered');
-});
-
-// ============================================================
-// agent_send: validation
-// ============================================================
-
-resetTestDir();
-agentComm.registerAgentComm(registry, 'sender-agent');
-
-runTest('agent_send: rejects missing agent', () => {
-  const result = agentComm.executeAgentSend({ message: 'hello' }, 'test1');
-  assert(result.success === false, 'should fail');
-  assert(result.error.indexOf('agent') !== -1, 'error should mention agent');
-});
-
-runTest('agent_send: rejects missing message', () => {
-  const result = agentComm.executeAgentSend({ agent: 'target' }, 'test2');
-  assert(result.success === false, 'should fail');
-  assert(result.error.indexOf('message') !== -1, 'error should mention message');
-});
-
-runTest('agent_send: rejects sending to self (exact name)', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  registry.claimAgent('sender-agent'); registry.writeStatus('sender-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-  const result = agentComm.executeAgentSend({ agent: 'sender-agent', message: 'hello' }, 'test3');
-  assert(result.success === false, 'should fail');
-  assert(result.error.indexOf('yourself') !== -1, 'error should mention self-send');
-});
-
-runTest('agent_send: rejects sending to self via prefix', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  agentComm._rateLimitMap.clear();
-  registry.claimAgent('sender-agent'); registry.writeStatus('sender-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-  // Use prefix 'sender' which should resolve to 'sender-agent' (self)
-  const result = agentComm.executeAgentSend({ agent: 'sender', message: 'hello' }, 'test3b');
-  assert(result.success === false, 'should fail when prefix resolves to self');
-  assert(result.error.indexOf('yourself') !== -1, 'error should mention self-send');
-});
-
-runTest('agent_send: rejects invalid priority', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  registry.claimAgent('target-agent'); registry.writeStatus('target-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-  const result = agentComm.executeAgentSend({
-    agent: 'target-agent',
-    message: 'hello',
-    priority: 'critical',
-  }, 'test4');
-  assert(result.success === false, 'should fail');
-  assert(result.error.indexOf('priority') !== -1, 'error should mention priority');
-});
-
-runTest('agent_send: rejects nonexistent agent', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  const result = agentComm.executeAgentSend({
-    agent: 'nonexistent-agent-xyz',
-    message: 'hello',
-  }, 'test5');
-  assert(result.success === false, 'should fail');
-  assert(result.error.indexOf('not found') !== -1, 'error should mention not found');
-});
-
-// ============================================================
-// agent_send: normal message
-// ============================================================
-
-runTest('agent_send: sends normal message to inbox', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  agentComm._rateLimitMap.clear();
-  registry.claimAgent('target-agent'); registry.writeStatus('target-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-  const result = agentComm.executeAgentSend({
-    agent: 'target-agent',
-    message: 'please review PR #42',
-  }, 'test6');
-  assert(result.success === true, 'should succeed: ' + (result.error || ''));
-  assert(result.message.indexOf('target-agent') !== -1, 'should mention target');
-
-  // Verify the message was written to inbox
-  assert(registry.inboxHasMessages('target-agent'), 'inbox should have messages');
-  const inbox = registry.drainInbox('target-agent');
-  assert(inbox.messages.length === 1, 'should have 1 message');
-  assert(inbox.messages[0].message === 'please review PR #42', 'message content should match');
-  assert(inbox.messages[0].from === 'sender-agent', 'from should be sender agent');
-});
-
-runTest('agent_send: sends high priority message', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  agentComm._rateLimitMap.clear();
-  registry.claimAgent('target-agent'); registry.writeStatus('target-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-  agentComm.executeAgentSend({
-    agent: 'target-agent',
-    message: 'urgent task',
-    priority: 'high',
-  }, 'test7');
-  const inbox = registry.drainInbox('target-agent');
-  assert(inbox.messages[0].priority === 'high', 'priority should be high');
-});
-
-// ============================================================
-// agent_send: urgent interrupt
-// ============================================================
-
-runTest('agent_send: sends urgent interrupt', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  agentComm._rateLimitMap.clear();
-  registry.claimAgent('target-agent'); registry.writeStatus('target-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-  const result = agentComm.executeAgentSend({
-    agent: 'target-agent',
-    message: 'production is down!',
-    urgent: true,
-  }, 'test8');
-  assert(result.success === true, 'should succeed');
-  assert(result.message.indexOf('Urgent') !== -1 || result.message.indexOf('urgent') !== -1,
-    'should mention urgent');
-
-  // Verify interrupt was written
-  assert(registry.hasInterrupt('target-agent'), 'should have interrupt');
-  const interrupt = registry.readInterrupt('target-agent');
-  assert(interrupt.message === 'production is down!', 'interrupt message should match');
-  assert(interrupt.from === 'sender-agent', 'from should be sender agent');
-});
-
-// ============================================================
-// agent_send: rate limiting
-// ============================================================
-
-runTest('agent_send: rate limits after 10 messages', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  agentComm._rateLimitMap.clear();
-  registry.claimAgent('target-agent'); registry.writeStatus('target-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-
-  // Send 10 messages (should all succeed)
-  for (let i = 0; i < 10; i++) {
-    const result = agentComm.executeAgentSend({
-      agent: 'target-agent',
-      message: 'msg ' + i,
-    }, 'rate-' + i);
-    assert(result.success === true, 'message ' + i + ' should succeed');
-  }
-
-  // 11th should be rate limited
-  const result = agentComm.executeAgentSend({
-    agent: 'target-agent',
-    message: 'msg 10',
-  }, 'rate-10');
-  assert(result.success === false, 'should be rate limited');
-  assert(result.error.indexOf('Rate limited') !== -1, 'error should mention rate limit');
-});
-
-runTest('_checkRateLimit: resets after window expires', () => {
-  agentComm._rateLimitMap.clear();
-  // Manually set an expired window
-  agentComm._rateLimitMap.set('old-agent', {
-    count: 10,
-    windowStart: Date.now() - (agentComm.RATE_LIMIT_WINDOW_MS + 1000),
-  });
-  const check = agentComm._checkRateLimit('old-agent');
-  assert(check.allowed === true, 'should be allowed after window expires');
-});
-
-// ============================================================
-// agent_list
-// ============================================================
-
-runTest('agent_list: returns empty array when no agents', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  const result = agentComm.executeAgentList({}, 'list1');
-  assert(result.success === true, 'should succeed');
-  assert(Array.isArray(result.agents), 'agents should be array');
-  assert(result.count === 0, 'should have 0 agents');
-});
-
-runTest('agent_list: returns registered agents with status', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  registry.claimAgent('agent-a');
-  registry.writeStatus('agent-a', {
-    state: 'working',
-    pid: process.pid,
-    iteration: 5,
-    startedAt: Date.now() - 60000,
-  });
-  registry.claimAgent('agent-b');
-  registry.writeStatus('agent-b', {
-    state: 'sleeping',
-    pid: process.pid,
-    iteration: 3,
-    startedAt: Date.now() - 30000,
-  });
-
-  const result = agentComm.executeAgentList({}, 'list2');
-  assert(result.success === true, 'should succeed');
-  assert(result.count >= 2, 'should have at least 2 agents');
-
-  // Find agent-a
-  const agentA = result.agents.find((a) => { return a.name === 'agent-a'; });
-  assert(agentA, 'should find agent-a');
-  assert(agentA.state === 'working', 'agent-a state should be working');
-  assert(agentA.iteration === 5, 'agent-a iteration should be 5');
-  assert(agentA.uptime !== null, 'agent-a should have uptime');
-});
-
-runTest('agent_list: marks self agent', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  registry.claimAgent('sender-agent'); registry.writeStatus('sender-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-  registry.writeStatus('sender-agent', {
-    state: 'working',
-    pid: process.pid,
-    iteration: 1,
-    startedAt: Date.now(),
-  });
-
-  const result = agentComm.executeAgentList({}, 'list3');
-  const self = result.agents.find((a) => { return a.name === 'sender-agent'; });
-  assert(self, 'should find sender-agent');
-  assert(self.isSelf === true, 'sender-agent should have isSelf=true');
-  assert(result.self === 'sender-agent', 'result.self should be sender-agent');
-});
-
-runTest('agent_list: fails when not registered', () => {
-  agentComm.registerAgentComm(null, null);
-  const result = agentComm.executeAgentList({}, 'list4');
-  assert(result.success === false, 'should fail');
-  assert(result.error.indexOf('not available') !== -1, 'error should mention not available');
-  // Re-register for remaining tests
-  agentComm.registerAgentComm(registry, 'sender-agent');
-});
-
-// ============================================================
-// Tool registration in tools/index.js (source inspection)
-// ============================================================
-
-runTest('tools/index.js imports agent-comm module', () => {
-  const source = fs.readFileSync(path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'tools', 'index.js'), 'utf8');
-  assert(source.indexOf("require(\"./agent-comm\")") !== -1 || source.indexOf("require('./agent-comm')") !== -1,
-    'should import agent-comm');
-});
-
-runTest('tools/index.js includes agent comm tools in getTools()', () => {
-  const source = fs.readFileSync(path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'tools', 'index.js'), 'utf8');
-  assert(source.indexOf('getAgentCommTools') !== -1, 'should call getAgentCommTools in getTools()');
-  assert(source.indexOf('agentCommTools') !== -1, 'should spread agentCommTools into allTools');
-});
-
-runTest('tools/index.js dispatches agent_send in executeTool()', () => {
-  const source = fs.readFileSync(path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'tools', 'index.js'), 'utf8');
-  assert(source.indexOf('"agent_send"') !== -1, 'should have agent_send case');
-  assert(source.indexOf('executeAgentSend') !== -1, 'should call executeAgentSend');
-});
-
-runTest('tools/index.js dispatches agent_list in executeTool()', () => {
-  const source = fs.readFileSync(path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'tools', 'index.js'), 'utf8');
-  assert(source.indexOf('"agent_list"') !== -1, 'should have agent_list case');
-  assert(source.indexOf('executeAgentList') !== -1, 'should call executeAgentList');
-});
-
-runTest('tools/index.js exports registerAgentComm', () => {
-  const source = fs.readFileSync(path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'tools', 'index.js'), 'utf8');
-  assert(source.indexOf('registerAgentComm') !== -1, 'should export registerAgentComm');
-});
-
-// ============================================================
-// Agent loop registration (source inspection)
-// ============================================================
-
-runTest('pave/index.js registers agent comm tools after server start', () => {
-  const source = fs.readFileSync(path.join(__dirname, '..', 'index.js'), 'utf8');
-  assert(source.indexOf('registerAgentComm') !== -1, 'should call registerAgentComm');
-  assert(source.indexOf('registerAgentComm(registry, agentName)') !== -1,
-    'should pass registry and agentName');
-});
-
-runTest('pave/index.js surfaces registration failure as warning', () => {
-  const source = fs.readFileSync(path.join(__dirname, '..', 'index.js'), 'utf8');
-  assert(source.indexOf('agent_send/agent_list will be unavailable') !== -1,
-    'should warn about unavailable tools on failure');
-});
-
-// ============================================================
-// agent-comm.js tool definitions
-// ============================================================
-
-runTest('agent_send tool has correct parameters', () => {
-  agentComm.registerAgentComm(registry, 'test');
-  const tools = agentComm.getAgentCommTools();
-  const sendTool = tools.find((t) => { return t.function.name === 'agent_send'; });
-  assert(sendTool, 'should find agent_send');
-  const params = sendTool.function.parameters.properties;
-  assert(params.agent, 'should have agent param');
-  assert(params.message, 'should have message param');
-  assert(params.priority, 'should have priority param');
-  assert(params.urgent, 'should have urgent param');
-  const required = sendTool.function.parameters.required;
-  assert(required.indexOf('agent') !== -1, 'agent should be required');
-  assert(required.indexOf('message') !== -1, 'message should be required');
-});
-
-runTest('agent_list tool has no required parameters', () => {
-  const tools = agentComm.getAgentCommTools();
-  const listTool = tools.find((t) => { return t.function.name === 'agent_list'; });
-  assert(listTool, 'should find agent_list');
-  assert(!listTool.function.parameters.required || listTool.function.parameters.required.length === 0,
-    'should have no required params');
-});
-
-// ============================================================
-// Fix: _senderAgentName normalization (Issue #240)
-// ============================================================
-
-runTest('registerAgentComm: normalizes sender name via sanitizeName', () => {
-  if (!canMkdir) return;
-  // Register with unsanitized name (e.g. "PAVE Agent" with spaces and uppercase)
-  agentComm.registerAgentComm(registry, 'PAVE Agent');
-  assert(agentComm.isAgentCommRegistered(), 'should be registered');
-
-  // The internal _senderAgentName should now be sanitized
-  // We can verify by checking self-send rejection
-  resetTestDir();
-  registry.claimAgent('pave-agent');
-  registry.writeStatus('pave-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-
-  const result = agentComm.executeAgentSend({ agent: 'pave-agent', message: 'test' }, 'norm1');
-  assert(result.success === false, 'should reject self-send with sanitized name');
-  assert(result.error.indexOf('yourself') !== -1, 'error should mention self-send');
-
-  // Restore
-  agentComm.registerAgentComm(registry, 'sender-agent');
-});
-
-runTest('agent_send: self-send works with raw name like "My Bot 123"', () => {
-  if (!canMkdir) return;
-  agentComm.registerAgentComm(registry, 'My Bot 123');
-  resetTestDir();
-  agentComm._rateLimitMap.clear();
-
-  // sanitizeName('My Bot 123') should produce 'my-bot-123'
-  registry.claimAgent('my-bot-123');
-  registry.writeStatus('my-bot-123', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-
-  const result = agentComm.executeAgentSend({ agent: 'my-bot-123', message: 'hello' }, 'norm2');
-  assert(result.success === false, 'should reject self-send');
-  assert(result.error.indexOf('yourself') !== -1, 'error should mention self-send');
-
-  agentComm.registerAgentComm(registry, 'sender-agent');
-});
-
-runTest('agent_list: isSelf works with unsanitized registration name', () => {
-  if (!canMkdir) return;
-  agentComm.registerAgentComm(registry, 'PAVE Agent');
-  resetTestDir();
-
-  registry.claimAgent('pave-agent');
-  registry.writeStatus('pave-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-
-  const result = agentComm.executeAgentList({}, 'norm3');
-  const self = result.agents.find((a) => { return a.name === 'pave-agent'; });
-  assert(self, 'should find pave-agent');
-  assert(self.isSelf === true, 'pave-agent should have isSelf=true when registered as "PAVE Agent"');
-  assert(result.self === 'pave-agent', 'result.self should be sanitized name');
-
-  agentComm.registerAgentComm(registry, 'sender-agent');
-});
-
-runTest('agent_send: from field uses sanitized name', () => {
-  if (!canMkdir) return;
-  agentComm.registerAgentComm(registry, 'My Agent');
-  resetTestDir();
-  agentComm._rateLimitMap.clear();
-
-  registry.claimAgent('target-bot');
-  registry.writeStatus('target-bot', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-
-  const result = agentComm.executeAgentSend({ agent: 'target-bot', message: 'hello' }, 'norm4');
-  assert(result.success === true, 'should succeed sending to other agent');
-
-  // Check the inbox message has sanitized from field
-  const inbox = registry.drainInbox('target-bot');
-  assert(inbox.messages.length > 0, 'should have inbox message');
-  assert(inbox.messages[0].from === 'my-agent', 'from field should be sanitized: ' + inbox.messages[0].from);
-
-  agentComm.registerAgentComm(registry, 'sender-agent');
-});
-
-// ============================================================
-// Issue #246: agent_list .message and handler.js fallback
-// ============================================================
-
-runTest('agent_list: returns .message with human-readable summary', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  agentComm.registerAgentComm(registry, 'sender-agent');
-  registry.claimAgent('agent-a');
-  registry.writeStatus('agent-a', { state: 'working', pid: process.pid, iteration: 5, startedAt: Date.now() - 60000 });
-  registry.claimAgent('agent-b');
-  registry.writeStatus('agent-b', { state: 'sleeping', pid: process.pid, iteration: 3, startedAt: Date.now() - 30000 });
-
-  const result = agentComm.executeAgentList({}, 'list-msg1');
-  assert(result.message, 'should have .message property');
-  assert(typeof result.message === 'string', '.message should be a string');
-  assert(result.message.indexOf('agent(s) found') !== -1, 'message should contain "agent(s) found"');
-  assert(result.message.indexOf('agent-a') !== -1, 'message should mention agent-a');
-  assert(result.message.indexOf('agent-b') !== -1, 'message should mention agent-b');
-  assert(result.message.indexOf('working') !== -1, 'message should include state');
-  assert(result.message.indexOf('iter=') !== -1, 'message should include iteration');
-  assert(result.message.indexOf('uptime=') !== -1, 'message should include uptime');
-});
-
-runTest('agent_list: .message with 0 agents', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  agentComm.registerAgentComm(registry, 'sender-agent');
-  const result = agentComm.executeAgentList({}, 'list-msg2');
-  assert(result.message, 'should have .message even with 0 agents');
-  assert(result.message.indexOf('0 agent(s) found') !== -1, 'message should say 0 agents');
-});
-
-runTest('agent_list: .message marks self agent with [you]', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  agentComm.registerAgentComm(registry, 'sender-agent');
-  registry.claimAgent('sender-agent');
-  registry.writeStatus('sender-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-
-  const result = agentComm.executeAgentList({}, 'list-msg3');
-  assert(result.message.indexOf('[you]') !== -1, 'message should mark self with [you]');
-});
-
-runTest('agent_list: .message shows alive/dead status', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  agentComm.registerAgentComm(registry, 'sender-agent');
-  registry.claimAgent('agent-x');
-  registry.writeStatus('agent-x', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-
-  const result = agentComm.executeAgentList({}, 'list-msg4');
-  const agentX = result.agents.find((a) => { return a.name === 'agent-x'; });
-  if (agentX && agentX.alive) {
-    assert(result.message.indexOf('alive') !== -1, 'message should show alive when PID is running');
-  } else {
-    assert(result.message.indexOf('dead') !== -1, 'message should show dead when PID is not running');
-  }
-});
-
-runTest('agent_send urgent: message mentions inbox bypass', () => {
-  if (!canMkdir) return;
-  resetTestDir();
-  agentComm.registerAgentComm(registry, 'sender-agent');
-  agentComm._rateLimitMap.clear();
-  registry.claimAgent('target-agent');
-  registry.writeStatus('target-agent', { state: 'working', pid: process.pid, iteration: 1, startedAt: Date.now() });
-
-  const result = agentComm.executeAgentSend({
-    agent: 'target-agent',
-    message: 'urgent task!',
-    urgent: true,
-  }, 'urgent-msg1');
-  assert(result.success === true, 'should succeed');
-  assert(result.message.indexOf('bypass') !== -1 || result.message.indexOf('Bypass') !== -1,
-    'urgent success message should mention bypassing inbox');
-});
-
-runTest('handler.js: generic JSON.stringify fallback before "(no output)"', () => {
-  const handlerSource = fs.readFileSync(
-    path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'prompt', 'handler.js'), 'utf8');
-  // Search whole file with regex for resilience against formatting changes
-  const stringifyPattern = /JSON\.stringify\s*\(\s*toolResult\s*\)/;
-  assert(stringifyPattern.test(handlerSource), 'should have JSON.stringify(toolResult) fallback');
-  assert(handlerSource.indexOf('"(no output)"') !== -1, 'should still have (no output) as last resort');
-  // Verify ordering: stringify comes before "(no output)"
-  const stringifyMatch = handlerSource.match(stringifyPattern);
-  const noOutputIdx = handlerSource.indexOf('"(no output)"');
-  assert(stringifyMatch.index < noOutputIdx, 'JSON.stringify fallback should come before (no output)');
-});
-
-runTest('handler.js: fallback guards with typeof and try/catch', () => {
-  const handlerSource = fs.readFileSync(
-    path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'prompt', 'handler.js'), 'utf8');
-  // Use regex to tolerate whitespace/formatting variations
-  const typeofObjectGuard = /typeof\s+toolResult\s*===\s*['"]object['"]/;
-  assert(typeofObjectGuard.test(handlerSource), 'should guard JSON.stringify with typeof object check');
-  // Verify try/catch wraps the stringify to handle circular refs/BigInt
-  const tryCatchPattern = /try\s*\{[^}]*JSON\.stringify\s*\(\s*toolResult\s*\)[^}]*\}\s*catch/;
-  assert(tryCatchPattern.test(handlerSource), 'should wrap JSON.stringify in try/catch for safety');
-  // Catch branch should use lightweight valid JSON (keys only), not String(toolResult)
-  assert(handlerSource.indexOf('String(toolResult)') === -1 ||
-    handlerSource.indexOf('String(toolResult)') > handlerSource.indexOf('"(no output)"'),
-  'catch branch should not use String(toolResult) before (no output)');
-  // Should produce valid JSON in catch branch via JSON.stringify({keys: keys})
-  assert(/JSON\.stringify\s*\(\s*\{\s*keys[\s:,}]/.test(handlerSource),
-    'catch branch should emit valid JSON with top-level keys');
-});
-
-// ============================================================
-// Cleanup & Summary
-// ============================================================
-
-cleanup();
-
-console.log('\nTotal: ' + (passed + failed) + ', Passed: ' + passed + ', Failed: ' + failed);
-if (failed > 0) process.exitCode = 1;