@cnrai/pave 0.3.35 → 0.3.51

package/test/agent-post-stream-idle.test.js

@@ -1,762 +0,0 @@
-#!/usr/bin/env node
-/**
- * Tests for post-stream idle verification fix (Issue #97)
- *
- * Verifies that after sendMessageAndStream returns, the agent loop
- * calls waitForSessionIdle before sleeping, preventing "Session still busy"
- * / HTTP 409 errors in the next iteration.
- *
- * Run with: node test/agent-post-stream-idle.test.js
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// ============================================================================
-// Test Utilities
-// ============================================================================
-
-function runTest(name, testFn) {
-  try {
-    testFn();
-    console.log(`\u2705 ${name}`);
-  } catch (error) {
-    console.log(`\u274C ${name}: ${error.message}`);
-    process.exitCode = 1;
-  }
-}
-
-function assertEqual(actual, expected, message) {
-  if (actual !== expected) {
-    throw new Error(`${message}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
-  }
-}
-
-function assertTrue(value, message) {
-  if (!value) {
-    throw new Error(`${message}: expected truthy value, got ${JSON.stringify(value)}`);
-  }
-}
-
-// ============================================================================
-// Structural Tests - Verify the fix exists in index.js
-// ============================================================================
-
-console.log('Running agent-post-stream-idle.test.js...');
-console.log('\n=== Structural Tests: Post-Stream Idle Check ===');
-
-const indexPath = path.join(__dirname, '..', 'index.js');
-const indexContent = fs.readFileSync(indexPath, 'utf8');
-
-runTest('index.js should contain waitForSessionIdle function', () => {
-  assertTrue(
-    indexContent.includes('async function waitForSessionIdle('),
-    'waitForSessionIdle function should be defined',
-  );
-});
-
-runTest('waitForSessionIdle should return idle status and wait info', () => {
-  // Verify the function returns the expected shape using regex to tolerate
-  // formatting/whitespace changes (per Copilot review feedback)
-  const hasIdleTrueReturn = /return\s*{\s*idle\s*:\s*true\s*,\s*waited\s*,\s*waitTimeMs\s*}/.test(indexContent);
-  const hasIdleFalseReturn = /return\s*{\s*idle\s*:\s*false\s*,\s*waited\s*,\s*waitTimeMs\s*:/.test(indexContent);
-
-  assertTrue(
-    hasIdleTrueReturn,
-    'should return idle:true with waited and waitTimeMs',
-  );
-  assertTrue(
-    hasIdleFalseReturn,
-    'should return idle:false on timeout',
-  );
-});
-
-runTest('Agent loop should have post-stream idle check after sendMessageAndStream', () => {
-  // Assert on stable code structure rather than comment text:
-  // Verify waitForSessionIdle is called between sendMessageAndStream and the sleep log.
-  // Use handleAgentCommand as anchor to find the agent loop's send call (not the
-  // sendMessageAndStream function definition earlier in the file).
-  const agentHandlerIdx = indexContent.indexOf('async function handleAgentCommand');
-  assertTrue(agentHandlerIdx >= 0, 'handleAgentCommand function should exist');
-
-  const sendIdx = indexContent.indexOf('await sendMessageAndStream(', agentHandlerIdx);
-  assertTrue(sendIdx > agentHandlerIdx, 'agent loop should await sendMessageAndStream');
-
-  const sleepIdx = indexContent.indexOf('Sleeping for', sendIdx);
-  assertTrue(sleepIdx > sendIdx, 'agent loop should log Sleeping for after sendMessageAndStream');
-
-  const idleIdx = indexContent.indexOf('waitForSessionIdle', sendIdx);
-  assertTrue(
-    idleIdx > sendIdx && idleIdx < sleepIdx,
-    'agent loop should call waitForSessionIdle between sendMessageAndStream and Sleeping for',
-  );
-});
-
-runTest('Post-stream idle check should use 30 second timeout (#271)', () => {
-  // Verify the waitForSessionIdle call between sendMessageAndStream and
-  // Sleeping for uses a 30 second (30 * 1000 ms) timeout — reduced from
-  // 10 minutes per issue #271 (HTTP 500 recovery).
-  const agentHandlerIdx = indexContent.indexOf('async function handleAgentCommand');
-  const sendIdx = indexContent.indexOf('await sendMessageAndStream(', agentHandlerIdx);
-  assertTrue(sendIdx > agentHandlerIdx, 'agent loop should await sendMessageAndStream');
-
-  const sleepIdx = indexContent.indexOf('Sleeping for', sendIdx);
-  assertTrue(sleepIdx > sendIdx, 'Sleeping for marker should exist after sendMessageAndStream');
-
-  const idleIdx = indexContent.indexOf('waitForSessionIdle', sendIdx);
-  assertTrue(idleIdx > sendIdx && idleIdx < sleepIdx, 'waitForSessionIdle should exist between send and sleep');
-
-  const postStreamSection = indexContent.substring(idleIdx, sleepIdx);
-  assertTrue(
-    postStreamSection.includes('30 * 1000'),
-    'post-stream idle check should use 30 second timeout (reduced from 10 minutes per #271)',
-  );
-});
-
-runTest('Post-stream idle check should use 1000ms poll interval (#271)', () => {
-  const agentHandlerIdx = indexContent.indexOf('async function handleAgentCommand');
-  const sendIdx = indexContent.indexOf('await sendMessageAndStream(', agentHandlerIdx);
-  assertTrue(sendIdx > agentHandlerIdx, 'agent loop should await sendMessageAndStream');
-
-  const sleepIdx = indexContent.indexOf('Sleeping for', sendIdx);
-  assertTrue(sleepIdx > sendIdx, 'Sleeping for marker should exist after sendMessageAndStream');
-
-  const idleIdx = indexContent.indexOf('waitForSessionIdle', sendIdx);
-  assertTrue(idleIdx > sendIdx && idleIdx < sleepIdx, 'waitForSessionIdle should exist between send and sleep');
-
-  const postStreamSection = indexContent.substring(idleIdx, sleepIdx);
-  assertTrue(
-    postStreamSection.includes('pollIntervalMs: 1000'),
-    'post-stream idle check should poll every 1000ms (increased frequency per #271)',
-  );
-});
-
-runTest('Post-stream idle check should log wait time when session was still processing', () => {
-  assertTrue(
-    indexContent.includes('Session was still processing after stream ended'),
-    'should log informative message when session was still processing after successful wait',
-  );
-  assertTrue(
-    indexContent.includes('Session did not become idle after stream ended'),
-    'should log warning when session timed out and did not become idle',
-  );
-  assertTrue(
-    indexContent.includes('Could not verify session idle state after stream ended'),
-    'should log distinct warning when status check failed with an error',
-  );
-});
-
-runTest('Post-stream idle check occurs BEFORE sleep, AFTER sendMessageAndStream in agent loop', () => {
-  // The postSendCheck variable is unique to the agent loop, so find it and
-  // verify it appears between sendMessageAndStream and signalAwareSleep
-  // Use the postSendCheck as anchor since it only exists in the agent handler
-  const postCheckIdx = indexContent.indexOf('postSendCheck');
-  assertTrue(postCheckIdx > 0, 'postSendCheck should exist');
-
-  // Find the sendMessageAndStream call that precedes postSendCheck
-  // (search backwards from postSendCheck)
-  const beforePostCheck = indexContent.substring(0, postCheckIdx);
-  const sendMsgIdx = beforePostCheck.lastIndexOf('await sendMessageAndStream(');
-  assertTrue(sendMsgIdx > 0, 'sendMessageAndStream should precede postSendCheck');
-
-  // Find the signalAwareSleep that follows postSendCheck
-  const sleepIdx = indexContent.indexOf('signalAwareSleep(', postCheckIdx);
-  assertTrue(sleepIdx > 0, 'signalAwareSleep should follow postSendCheck');
-
-  assertTrue(
-    sendMsgIdx < postCheckIdx && postCheckIdx < sleepIdx,
-    'order should be: sendMessageAndStream -> postSendCheck -> signalAwareSleep',
-  );
-});
-
-runTest('Post-stream idle check is gated to skip only HTTP 409 rejections', () => {
-  // The post-stream idle check should run for all cases EXCEPT when
-  // sendMessageAndStream threw with HTTP 409 (session busy), since the
-  // server definitively rejected the request. For non-409 errors (e.g.,
-  // SSE connection drops), the server may still be processing.
-  assertTrue(
-    indexContent.includes('let sendRejectedAs409 = false'),
-    'sendRejectedAs409 flag should be declared as false before try block',
-  );
-  assertTrue(
-    indexContent.includes('sendRejectedAs409 = true'),
-    'sendRejectedAs409 should be set to true in the 409 catch branch',
-  );
-  assertTrue(
-    indexContent.includes('if (!sendRejectedAs409)'),
-    'post-stream idle check should be gated by !sendRejectedAs409 flag',
-  );
-
-  // Verify sendRejectedAs409 = true is inside the catch block (409 handling)
-  const agentHandlerIdx = indexContent.indexOf('async function handleAgentCommand');
-  const sendMsgIdx = indexContent.indexOf('await sendMessageAndStream(', agentHandlerIdx);
-  const catchIdx = indexContent.indexOf('} catch (err)', sendMsgIdx);
-  const rejectedIdx = indexContent.indexOf('sendRejectedAs409 = true', catchIdx);
-  assertTrue(rejectedIdx > catchIdx, 'sendRejectedAs409=true should be inside the catch block');
-
-  // Verify if (!sendRejectedAs409) comes AFTER the catch block
-  const ifNotRejectedIdx = indexContent.indexOf('if (!sendRejectedAs409)', catchIdx);
-  assertTrue(ifNotRejectedIdx > catchIdx, 'if (!sendRejectedAs409) gate should come after the catch block');
-});
-
-runTest('Pre-send idle check should still exist (belt-and-suspenders)', () => {
-  // Locate the pre-send waitForSessionIdle call in the agent handler.
-  // It should appear before the main sendMessageAndStream call in the loop.
-  const agentHandlerIdx = indexContent.indexOf('async function handleAgentCommand');
-  assertTrue(agentHandlerIdx >= 0, 'handleAgentCommand function should exist');
-
-  const sendMsgIdx = indexContent.indexOf('await sendMessageAndStream(', agentHandlerIdx);
-  assertTrue(sendMsgIdx > agentHandlerIdx, 'sendMessageAndStream should exist in agent handler');
-
-  // The pre-send waitForSessionIdle call should appear between handleAgentCommand and sendMessageAndStream
-  const preSendSection = indexContent.substring(agentHandlerIdx, sendMsgIdx);
-  assertTrue(
-    preSendSection.includes('waitForSessionIdle'),
-    'pre-send waitForSessionIdle call should exist before sendMessageAndStream',
-  );
-});
-
-runTest('Pre-send uses shorter timeout (5 min) vs post-stream (10 min)', () => {
-  // Find the pre-send waitForSessionIdle call (the one before sendMessageAndStream)
-  const agentHandlerIdx = indexContent.indexOf('async function handleAgentCommand');
-  const sendMsgIdx = indexContent.indexOf('await sendMessageAndStream(', agentHandlerIdx);
-  const preSendSection = indexContent.substring(agentHandlerIdx, sendMsgIdx);
-
-  assertTrue(
-    preSendSection.includes('5 * 60 * 1000'),
-    'pre-send check should use 5 minute timeout',
-  );
-});
-
-// ============================================================================
-// waitForSessionIdle Unit Tests (functional simulation)
-// ============================================================================
-
-console.log('\n=== Functional Tests: waitForSessionIdle behavior ===');
-
-/**
- * Simulates waitForSessionIdle with a stubbed httpRequest.
- * Mirrors the actual function logic from index.js.
- * Fully synchronous — uses simulated elapsed time instead of real timers.
- */
-function simulateWaitForSessionIdle(statusSequence, options = {}) {
-  const { maxWaitMs = 5000, pollIntervalMs = 50, verbose = false } = options;
-  let simulatedElapsedMs = 0;
-  let waited = false;
-  let pollCount = 0;
-  const logs = [];
-
-  for (const status of statusSequence) {
-    pollCount++;
-
-    // Simulate an error during status check (mirrors the catch branch in production)
-    if (status && typeof status === 'object' && status.type === 'error') {
-      return { idle: true, waited, waitTimeMs: simulatedElapsedMs, error: status.message || 'Unknown error', pollCount, logs };
-    }
-
-    // Simulate the idle check
-    if (!status || (typeof status === 'object' && status.type === 'idle')) {
-      return { idle: true, waited, waitTimeMs: simulatedElapsedMs, pollCount, logs };
-    }
-
-    // Session is busy
-    if (!waited) {
-      waited = true;
-      if (verbose) {
-        logs.push('Session is busy, waiting for idle...');
-      }
-    }
-
-    // Simulate poll interval elapsed
-    simulatedElapsedMs += pollIntervalMs;
-
-    // Check timeout
-    if (simulatedElapsedMs >= maxWaitMs) {
-      return { idle: false, waited, waitTimeMs: simulatedElapsedMs, timedOut: true, pollCount, logs };
-    }
-  }
-
-  // Exhausted status sequence without becoming idle
-  return { idle: false, waited, waitTimeMs: simulatedElapsedMs, pollCount, logs };
-}
-
-/**
- * Simulates the agent loop's post-stream behavior.
- * Shows that the idle check after sendMessageAndStream prevents
- * sleeping while the session is still busy.
- * Fully synchronous — no real timers needed.
- */
-function simulateAgentLoopIteration(options = {}) {
-  const {
-    sendMessageSuccess = true,
-    sendThrew = false, // true = sendMessageAndStream threw
-    sendThrew409 = false, // true = threw specifically with 409
-    sessionStatusAfterSend = [null], // null = idle
-    verbose = false,
-    maxWaitMs = 5000,
-    pollIntervalMs = 50,
-  } = options;
-
-  const logs = [];
-  const actions = [];
-  let postSendCheck = null;
-
-  // Simulate sendMessageAndStream
-  actions.push('sendMessageAndStream');
-  let sendRejectedAs409 = false;
-  if (sendThrew) {
-    if (sendThrew409) {
-      // sendMessageAndStream threw with HTTP 409
-      sendRejectedAs409 = true;
-      logs.push('Error: Session is busy (HTTP 409)');
-    } else {
-      // sendMessageAndStream threw with non-409 error (e.g., SSE connection drop)
-      logs.push('Error: Connection reset');
-    }
-  } else {
-    if (!sendMessageSuccess) {
-      logs.push('Error in iteration');
-    }
-  }
-
-  // Post-stream idle check (the fix from this PR)
-  // Run for all cases EXCEPT 409 rejections, matching the
-  // `if (!sendRejectedAs409)` gate in production code.
-  if (!sendRejectedAs409) {
-    actions.push('postStreamIdleCheck');
-    postSendCheck = simulateWaitForSessionIdle(sessionStatusAfterSend, {
-      verbose,
-      maxWaitMs,
-      pollIntervalMs,
-    });
-
-    if (postSendCheck.error) {
-      // Status check failed — assumed idle, but warn operator
-      logs.push(`Could not verify session idle state after stream ended: ${postSendCheck.error}`);
-    } else if (postSendCheck.waited) {
-      const waitedSeconds = Math.round(postSendCheck.waitTimeMs / 1000);
-      if (postSendCheck.idle) {
-        logs.push(`Session was still processing after stream ended, waited ${waitedSeconds}s for idle`);
-      } else {
-        const timedOutFlag = postSendCheck.timedOut ? ' (timed out waiting for idle)' : '';
-        logs.push(`Session did not become idle after stream ended, waited ${waitedSeconds}s${timedOutFlag}`);
-      }
-    }
-  }
-
-  // Sleep
-  actions.push('sleep');
-
-  return {
-    actions,
-    logs,
-    postSendCheck,
-    sendRejectedAs409,
-    sleptWhileBusy: postSendCheck ? (postSendCheck.waited && !postSendCheck.idle) : false,
-  };
-}
-
-// All simulations are fully synchronous — no async IIFE needed.
-// This ensures the test runner can track pass/fail reliably.
-
-runTest('Session already idle: should return immediately without waiting', () => {
-  const result = simulateWaitForSessionIdle([null]); // null = idle
-  assertEqual(result.idle, true, 'should report idle');
-  assertEqual(result.waited, false, 'should not have waited');
-  assertEqual(result.pollCount, 1, 'should poll only once');
-});
-
-runTest('Session busy then idle: should wait and report', () => {
-  const result = simulateWaitForSessionIdle([
-    { type: 'busy' },
-    { type: 'busy' },
-    null, // becomes idle
-  ], { verbose: true });
-
-  assertEqual(result.idle, true, 'should report idle');
-  assertEqual(result.waited, true, 'should have waited');
-  assertEqual(result.pollCount, 3, 'should poll 3 times');
-  assertTrue(result.logs.length > 0, 'should have logged wait message');
-});
-
-runTest('Session stays busy: should timeout', () => {
-  const result = simulateWaitForSessionIdle([
-    { type: 'busy' },
-    { type: 'busy' },
-    { type: 'busy' },
-    { type: 'busy' },
-    { type: 'busy' },
-  ], { maxWaitMs: 100, pollIntervalMs: 30 });
-
-  assertEqual(result.idle, false, 'should report not idle');
-  assertEqual(result.waited, true, 'should have waited');
-});
-
-runTest('Agent loop: session idle after stream - no extra wait', () => {
-  const result = simulateAgentLoopIteration({
-    sessionStatusAfterSend: [null], // Immediately idle
-  });
-
-  assertEqual(result.postSendCheck.waited, false, 'should not have waited');
-  assertEqual(result.postSendCheck.idle, true, 'should be idle');
-  assertEqual(result.sleptWhileBusy, false, 'should not sleep while busy');
-  // Verify correct action order
-  assertEqual(result.actions[0], 'sendMessageAndStream', 'first action');
-  assertEqual(result.actions[1], 'postStreamIdleCheck', 'second action');
-  assertEqual(result.actions[2], 'sleep', 'third action');
-});
-
-runTest('Agent loop: session busy after stream - waits before sleep', () => {
-  const result = simulateAgentLoopIteration({
-    sessionStatusAfterSend: [
-      { type: 'busy' }, // SSE stream ended but server still processing
-      { type: 'busy' },
-      null, // Server finishes
-    ],
-  });
-
-  assertEqual(result.postSendCheck.waited, true, 'should have waited');
-  assertEqual(result.postSendCheck.idle, true, 'should eventually become idle');
-  assertEqual(result.sleptWhileBusy, false, 'should not sleep while busy');
-  assertTrue(
-    result.logs.some((l) => l.includes('Session was still processing')),
-    'should log that session was still processing',
-  );
-});
-
-runTest('Agent loop: session hangs - timeout prevents infinite block', () => {
-  const result = simulateAgentLoopIteration({
-    sessionStatusAfterSend: [
-      { type: 'busy' },
-      { type: 'busy' },
-      { type: 'busy' },
-      { type: 'busy' },
-      { type: 'busy' },
-    ],
-    maxWaitMs: 100,
-    pollIntervalMs: 30,
-  });
-
-  assertEqual(result.postSendCheck.waited, true, 'should have waited');
-  assertEqual(result.postSendCheck.idle, false, 'should report not idle after timeout');
-  // Still proceeds to sleep (timeout is a safety valve, not a blocker)
-  assertEqual(result.actions[2], 'sleep', 'should still proceed to sleep after timeout');
-  // Should produce a warning about not becoming idle
-  assertTrue(
-    result.logs.some((l) => l.includes('Session did not become idle')),
-    'should warn that session did not become idle',
-  );
-});
-
-runTest('Agent loop: HTTP 409 rejection skips idle check', () => {
-  const result = simulateAgentLoopIteration({
-    sendThrew: true,
-    sendThrew409: true,
-    sessionStatusAfterSend: [{ type: 'busy' }, null],
-  });
-
-  // When sendMessageAndStream threw with 409, the server definitively
-  // rejected our request, so the post-stream idle check is unnecessary.
-  assertEqual(result.sendRejectedAs409, true, 'sendRejectedAs409 should be true');
-  assertTrue(
-    !result.actions.includes('postStreamIdleCheck'),
-    'should NOT perform post-stream idle check when 409 rejected',
-  );
-  assertEqual(result.postSendCheck, null, 'postSendCheck should be null when skipped');
-  // Should still proceed to sleep
-  assertTrue(
-    result.actions.includes('sleep'),
-    'should still proceed to sleep after 409 rejection',
-  );
-});
-
-runTest('Agent loop: non-409 throw still gets idle check', () => {
-  // When sendMessageAndStream threw with a non-409 error (e.g., SSE connection
-  // drop after POST accepted), the server may still be processing, so we
-  // should still check idle.
-  const result = simulateAgentLoopIteration({
-    sendThrew: true,
-    sendThrew409: false,
-    sessionStatusAfterSend: [{ type: 'busy' }, null],
-  });
-
-  assertEqual(result.sendRejectedAs409, false, 'sendRejectedAs409 should be false for non-409');
-  assertTrue(
-    result.actions.includes('postStreamIdleCheck'),
-    'should perform post-stream idle check for non-409 errors',
-  );
-});
-
-runTest('Agent loop: sendMessageAndStream resolved with error still gets idle check', () => {
-  // When sendMessageAndStream resolves (even with response.success=false),
-  // the server may have partially processed the request, so we still check idle.
-  const result = simulateAgentLoopIteration({
-    sendMessageSuccess: false,
-    sendThrew: false,
-    sessionStatusAfterSend: [{ type: 'busy' }, null],
-  });
-
-  assertEqual(result.sendRejectedAs409, false, 'sendRejectedAs409 should be false when resolved');
-  assertTrue(
-    result.actions.includes('postStreamIdleCheck'),
-    'should still perform post-stream idle check when send resolved with error',
-  );
-});
-
-runTest('Agent loop: status check error produces distinct warning', () => {
-  // When waitForSessionIdle fails to check status (e.g., server unreachable),
-  // it returns { idle: true, error: '...' }. The agent loop should produce
-  // a distinct diagnostic message rather than the normal "waited Xs for idle" log.
-  const result = simulateAgentLoopIteration({
-    sendMessageSuccess: true,
-    sessionStatusAfterSend: [{ type: 'error', message: 'ECONNREFUSED' }],
-  });
-
-  assertTrue(
-    result.actions.includes('postStreamIdleCheck'),
-    'should perform post-stream idle check',
-  );
-  assertEqual(result.postSendCheck.idle, true, 'error case assumes idle');
-  assertTrue(
-    typeof result.postSendCheck.error === 'string',
-    'should have an error field',
-  );
-  // The log should contain the distinct error warning, not the normal waited message
-  assertTrue(
-    result.logs.some((l) => { return l.includes('Could not verify session idle state'); }),
-    'should log distinct error warning',
-  );
-  assertTrue(
-    !result.logs.some((l) => { return l.includes('waited') && l.includes('for idle'); }),
-    'should NOT log the normal "waited for idle" message on error',
-  );
-});
-
-// ============================================================================
-// SSE premature close scenario test
-// ============================================================================
-
-console.log('\n=== Scenario Tests: SSE premature close ===');
-
-runTest('Scenario: SSE stream ends during long tool execution', () => {
-  // This simulates the exact bug from issue #97:
-  // 1. Agent sends message, SSE stream starts
-  // 2. Server starts executing a long tool (e.g., multi-file edit)
-  // 3. SSE connection drops (network issue on iSH)
-  // 4. sendMessageAndStream resolves (sseRes.on('end') calls finish(true))
-  // 5. WITHOUT FIX: agent sleeps, next iteration gets 409
-  // 6. WITH FIX: post-stream idle check catches that server is still busy
-
-  const result = simulateAgentLoopIteration({
-    sendMessageSuccess: true,
-    sessionStatusAfterSend: [
-      { type: 'busy', elapsed: 5000 }, // Server still running tool
-      { type: 'busy', elapsed: 10000 }, // Still processing...
-      { type: 'busy', elapsed: 15000 }, // Almost done...
-      null, // Tool execution complete
-    ],
-  });
-
-  // The post-stream check caught the still-busy session
-  assertEqual(result.postSendCheck.waited, true, 'should detect session was still busy');
-  assertEqual(result.postSendCheck.idle, true, 'should eventually see idle');
-  assertEqual(result.sleptWhileBusy, false, 'should NOT sleep while session is busy');
-
-  // Verify the fix logged that it caught a premature stream end
-  assertTrue(
-    result.logs.some((l) => l.includes('Session was still processing after stream ended')),
-    'should log that it caught the premature stream end',
-  );
-});
-
-runTest('Scenario: SSE connection drop after POST accepted (non-409 throw)', () => {
-  // This scenario: POST was accepted, server started processing, but SSE
-  // connection dropped causing sendMessageAndStream to throw a non-409 error.
-  // The idle check should still run because the server may still be working.
-  const result = simulateAgentLoopIteration({
-    sendThrew: true,
-    sendThrew409: false,
-    sessionStatusAfterSend: [
-      { type: 'busy' }, // Server still processing after connection drop
-      { type: 'busy' },
-      null, // Server finishes
-    ],
-  });
-
-  assertTrue(
-    result.actions.includes('postStreamIdleCheck'),
-    'should still check idle after non-409 connection error',
-  );
-  assertEqual(result.postSendCheck.waited, true, 'should have waited for idle');
-  assertEqual(result.postSendCheck.idle, true, 'should eventually become idle');
-});
-
-runTest('Scenario: Normal completion - no performance regression', () => {
-  // When everything works correctly, the post-stream check should be
-  // essentially free in terms of logic: one poll, session is already idle,
-  // and it returns immediately without extra waiting or logging.
-  const result = simulateAgentLoopIteration({
-    sendMessageSuccess: true,
-    sessionStatusAfterSend: [null], // Already idle (normal case)
-  });
-
-  assertEqual(result.postSendCheck.waited, false, 'should not wait when already idle');
-  assertEqual(result.postSendCheck.pollCount, 1, 'should only poll once');
-  assertEqual(result.logs.length, 0, 'should produce no extra log output in normal case');
-});
-
-// ============================================================================
-// SSE Timeout & Cleanup Tests (Issue #189/#190)
-// ============================================================================
-
-console.log('\n=== SSE Timeout & Cleanup Tests ===');
-
-runTest('SSE idle timeout value is set to 5 minutes', () => {
-  assertTrue(indexContent.includes('SSE_IDLE_TIMEOUT_MS = 5 * 60 * 1000'), 'Should configure SSE_IDLE_TIMEOUT_MS as 5 minutes');
-});
-
-runTest('SSE timeout handle is stored in a variable', () => {
-  assertTrue(
-    indexContent.includes('sseTimeout = setTimeout'),
-    'SSE timeout handle should be stored in sseTimeout variable',
-  );
-});
-
-runTest('SSE timeout is cleared in finish()', () => {
-  assertTrue(
-    indexContent.includes('clearTimeout(sseTimeout)'),
-    'finish() should clear the SSE timeout',
-  );
-});
-
-runTest('SSE timeout is unref\'d to not keep process alive', () => {
-  assertTrue(
-    indexContent.includes('sseTimeout.unref'),
-    'SSE timeout should be unref\'d',
-  );
-});
-
-runTest('SSE timeout rejects with error (not silent success)', () => {
-  assertTrue(
-    indexContent.includes('rejectWithCleanup') && indexContent.includes('safety timeout'),
-    'SSE timeout should reject with a descriptive timeout error',
-  );
-});
-
-runTest('resetSseTimeout helper exists and is called from processEvent (issue #216)', () => {
-  assertTrue(
-    indexContent.includes('const resetSseTimeout'),
-    'Should have resetSseTimeout helper function',
-  );
-  // processEvent should call resetSseTimeout to reset on every SSE event
-  const processEventIdx = indexContent.indexOf('const processEvent');
-  assertTrue(processEventIdx > -1, 'Should find processEvent');
-  const processEventBody = indexContent.substring(processEventIdx, processEventIdx + 500);
-  assertTrue(
-    processEventBody.includes('resetSseTimeout()'),
-    'processEvent should call resetSseTimeout() to reset idle timer on every SSE event',
-  );
-});
-
-runTest('Initial SSE timeout uses resetSseTimeout (not inline setTimeout)', () => {
-  // After sseReq.end(), the initial timeout should use the shared resetSseTimeout()
-  const reqEndIdx = indexContent.indexOf('sseReq.end()');
-  assertTrue(reqEndIdx > -1, 'Should find sseReq.end()');
-  const afterReqEnd = indexContent.substring(reqEndIdx, reqEndIdx + 500);
-  assertTrue(
-    afterReqEnd.includes('resetSseTimeout()'),
-    'Initial timeout after sseReq.end() should use resetSseTimeout()',
-  );
-});
-
-runTest('Error paths use rejectWithCleanup to clear timeout', () => {
-  assertTrue(
-    indexContent.includes('rejectWithCleanup'),
-    'Should have rejectWithCleanup helper',
-  );
-  // Find the sendMessageAndStream function body
-  const fnIdx = indexContent.indexOf('function sendMessageAndStream');
-  assertTrue(fnIdx > -1, 'Should find sendMessageAndStream');
-  const fnBody = indexContent.substring(fnIdx, fnIdx + 8000);
-  // Remove the rejectWithCleanup definition itself (which contains reject(err))
-  const withoutDef = fnBody.replace(/const rejectWithCleanup[\s\S]*?};/, '');
-  // Any remaining bare reject() calls would be a bug
-  const bareReject = withoutDef.match(/[^a-zA-Z]reject\s*\(/g);
-  assertTrue(
-    !bareReject,
-    'All reject calls should use rejectWithCleanup, found bare reject(): ' + (bareReject ? bareReject.length : 0),
-  );
-});
-
-runTest('cleanup() destroys POST request to prevent socket leaks', () => {
-  // postReq should be tracked in outer scope and destroyed in cleanup()
-  const fnIdx = indexContent.indexOf('function sendMessageAndStream');
-  assertTrue(fnIdx > -1, 'Should find sendMessageAndStream');
-  const fnBody = indexContent.substring(fnIdx, fnIdx + 12000);
-  // postReq should be declared in outer scope (let postReq)
-  assertTrue(
-    fnBody.includes('let postReq'),
-    'postReq should be declared in outer scope with let',
-  );
-  // cleanup should destroy postReq
-  const cleanupIdx = fnBody.indexOf('const cleanup');
-  assertTrue(cleanupIdx > -1, 'Should find cleanup function');
-  const cleanupBody = fnBody.substring(cleanupIdx, cleanupIdx + 400);
-  assertTrue(
-    cleanupBody.includes('postReq') && cleanupBody.includes('destroy'),
-    'cleanup() should destroy postReq to prevent socket leaks',
-  );
-});
-
-runTest('SSE cooldown runs in finally block (both success and error paths)', () => {
-  // The 500ms cooldown should be in a finally block so it runs on error paths too
-  const agentHandlerIdx = indexContent.indexOf('async function handleAgentCommand');
-  const sendMsgIdx = indexContent.indexOf('await sendMessageAndStream(', agentHandlerIdx);
-  assertTrue(sendMsgIdx > agentHandlerIdx, 'sendMessageAndStream should exist in agent handler');
-  // Find the catch and finally blocks near the sendMessageAndStream call
-  const catchIdx = indexContent.indexOf('catch (err)', sendMsgIdx);
-  assertTrue(catchIdx > sendMsgIdx, 'should have catch block after sendMessageAndStream');
-  const finallyIdx = indexContent.indexOf('finally {', catchIdx);
-  assertTrue(finallyIdx > catchIdx, 'should have finally block after catch');
-  // Use 800-char window to accommodate multi-line comments in the finally body
-  const finallyBody = indexContent.substring(finallyIdx, finallyIdx + 800);
-  assertTrue(
-    finallyBody.includes('setTimeout(resolve, 500)'),
-    '500ms cooldown should be inside finally block',
-  );
-});
-
-// ============================================================================
-// handleChatCommand server cleanup (Issue #190 review)
-// ============================================================================
-
-console.log('\n=== handleChatCommand Server Cleanup Tests ===');
-
-runTest('handleChatCommand closes server in finally block (not just success path)', () => {
-  const chatIdx = indexContent.indexOf('async function handleChatCommand');
-  assertTrue(chatIdx > -1, 'Should find handleChatCommand');
-  // Find the startServer call inside handleChatCommand
-  const startSrvIdx = indexContent.indexOf('startServer(', chatIdx);
-  assertTrue(startSrvIdx > chatIdx, 'handleChatCommand should call startServer');
-  // Find the finally block after the try/catch
-  const catchIdx = indexContent.indexOf('catch (err)', startSrvIdx);
-  assertTrue(catchIdx > startSrvIdx, 'should have catch block');
-  const finallyIdx = indexContent.indexOf('finally {', catchIdx);
-  assertTrue(finallyIdx > catchIdx, 'should have finally block after catch in handleChatCommand');
-  const finallyBody = indexContent.substring(finallyIdx, finallyIdx + 500);
-  assertTrue(
-    finallyBody.includes('server.close()'),
-    'finally block should close server to prevent listener leaks',
-  );
-});
-
-// ============================================================================
-// Final Summary
-// ============================================================================
-
-console.log('\n=== All Test Sections Complete ===');
-if (process.exitCode === 1) {
-  console.log('Some tests failed.');
-} else {
-  console.log('All tests passed!');
-}