@cnrai/pave 0.3.35 → 0.3.51

package/test/auto-compaction.test.js

@@ -1,941 +0,0 @@
-#!/usr/bin/env node
-/**
- * Unit tests for auto-compaction feature
- * Tests model parsing and compaction response handling logic
- * Run with: node test/auto-compaction.test.js
- */
-
-// ============================================================================
-// Import shared helper with sandbox fallback
-// ============================================================================
-// Try to import from lib/compaction.js first (normal Node execution).
-// Fall back to inline implementation for sandbox environments where the
-// relative require path doesn't work (test files are copied to temp directory).
-let parseModelForCompaction;
-try {
-  const compaction = require('../lib/compaction');
-  parseModelForCompaction = compaction.parseModelForCompaction;
-} catch (e) {
-  // Fallback for sandbox: simplified inline version of lib/compaction.js.
-  // This uses hardcoded defaults (no env var support) since sandbox tests
-  // cannot modify process.env. See lib/compaction.js for the canonical
-  // implementation with full PAVE_COMPACT_MODEL/PAVE_MODEL precedence.
-  const KNOWN_COMPACTION_MODELS = [
-    'claude-opus-4.5',
-    'claude-opus-4.6',
-    'claude-sonnet-4', // Canonical model advertised in CLI help
-    'claude-sonnet-4.5',
-    'claude-sonnet-4.6',
-    'claude-3-5-sonnet-20241022',
-    'claude-3-5-haiku-20241022',
-    'claude-3-opus-20240229',
-    'gpt-4',
-    'gpt-4-turbo',
-    'gpt-3.5-turbo',
-  ];
-  const DEFAULT_PROVIDER_ID = 'github-copilot';
-  const DEFAULT_MODEL_ID = 'claude-opus-4.5';
-
-  parseModelForCompaction = function (model) {
-    let providerID = DEFAULT_PROVIDER_ID;
-    let modelID = DEFAULT_MODEL_ID;
-
-    if (model) {
-      if (model.includes('/')) {
-        const parts = model.split('/');
-        providerID = parts[0];
-        modelID = parts.slice(1).join('/');
-      } else {
-        modelID = model;
-      }
-    }
-
-    const compactionModelID = KNOWN_COMPACTION_MODELS.includes(modelID) ? modelID : DEFAULT_MODEL_ID;
-    return { providerID, modelID, compactionModelID };
-  };
-}
-
-// Simple URL parser for testing (avoids dependency on 'url' module in sandboxed environments)
-function parseURL(urlString) {
-  // Extract pathname and search from URL string
-  const match = urlString.match(/^https?:\/\/[^\/]+(\/[^?]*)?(\?.*)?$/);
-  if (!match) return { pathname: '/', search: '' };
-  return {
-    pathname: match[1] || '/',
-    search: match[2] || '',
-  };
-}
-
-function runTest(name, testFn) {
-  try {
-    testFn();
-    console.log(`✅ ${name}`);
-  } catch (error) {
-    console.log(`❌ ${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 assertDeepEqual(actual, expected, message) {
-  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-    throw new Error(`${message}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
-  }
-}
-
-/**
- * Alias for parseModelForCompaction - matches the test naming convention
- */
-const parseModelString = parseModelForCompaction;
-
-/**
- * Extract compaction fields from API response
- * This mirrors the field access pattern used in handleChatCommand
- */
-function extractCompactionFields(compactionCheck) {
-  if (!compactionCheck) {
-    return { needed: false, totalTokens: undefined, threshold: undefined };
-  }
-
-  return {
-    needed: compactionCheck.needed || false,
-    totalTokens: compactionCheck.totalTokens,
-    threshold: compactionCheck.usage?.limits?.threshold,
-  };
-}
-
-/**
- * Calculate token savings safely
- * Returns null if values are invalid or savings is not positive
- */
-function calculateTokenSavings(originalTokens, summaryTokens) {
-  const summary = summaryTokens || 0;
-  const saved = originalTokens - summary;
-
-  if (!originalTokens || saved <= 0) {
-    return null;
-  }
-
-  return { originalTokens, summaryTokens: summary, savedTokens: saved };
-}
-
-// ============== Model Parsing Tests ==============
-
-runTest('parseModelString: should return defaults when model is undefined', () => {
-  const result = parseModelString(undefined);
-  assertEqual(result.providerID, 'github-copilot', 'providerID');
-  assertEqual(result.modelID, 'claude-opus-4.5', 'modelID');
-});
-
-runTest('parseModelString: should return defaults when model is empty string', () => {
-  const result = parseModelString('');
-  assertEqual(result.providerID, 'github-copilot', 'providerID');
-  assertEqual(result.modelID, 'claude-opus-4.5', 'modelID');
-});
-
-runTest('parseModelString: should parse provider/model format correctly', () => {
-  const result = parseModelString('github-copilot/claude-sonnet-4');
-  assertEqual(result.providerID, 'github-copilot', 'providerID');
-  assertEqual(result.modelID, 'claude-sonnet-4', 'modelID');
-});
-
-runTest('parseModelString: should handle model without provider (uses default provider)', () => {
-  const result = parseModelString('gpt-4');
-  assertEqual(result.providerID, 'github-copilot', 'providerID');
-  assertEqual(result.modelID, 'gpt-4', 'modelID');
-});
-
-runTest('parseModelString: should handle models with multiple slashes', () => {
-  const result = parseModelString('openai/gpt-4/turbo');
-  assertEqual(result.providerID, 'openai', 'providerID');
-  assertEqual(result.modelID, 'gpt-4/turbo', 'modelID');
-});
-
-runTest('parseModelString: should handle different providers', () => {
-  const result = parseModelString('anthropic/claude-3-opus');
-  assertEqual(result.providerID, 'anthropic', 'providerID');
-  assertEqual(result.modelID, 'claude-3-opus', 'modelID');
-});
-
-// ============== Compaction Response Field Tests ==============
-
-runTest('extractCompactionFields: should handle null response', () => {
-  const result = extractCompactionFields(null);
-  assertEqual(result.needed, false, 'needed');
-  assertEqual(result.totalTokens, undefined, 'totalTokens');
-  assertEqual(result.threshold, undefined, 'threshold');
-});
-
-runTest('extractCompactionFields: should extract fields from valid response', () => {
-  const response = {
-    needed: true,
-    totalTokens: 150000,
-    usage: {
-      limits: {
-        threshold: 100000,
-      },
-    },
-  };
-  const result = extractCompactionFields(response);
-  assertEqual(result.needed, true, 'needed');
-  assertEqual(result.totalTokens, 150000, 'totalTokens');
-  assertEqual(result.threshold, 100000, 'threshold');
-});
-
-runTest('extractCompactionFields: should handle response without usage.limits', () => {
-  const response = {
-    needed: false,
-    totalTokens: 50000,
-  };
-  const result = extractCompactionFields(response);
-  assertEqual(result.needed, false, 'needed');
-  assertEqual(result.totalTokens, 50000, 'totalTokens');
-  assertEqual(result.threshold, undefined, 'threshold');
-});
-
-runTest('extractCompactionFields: should use correct field name "needed" not "needsCompaction"', () => {
-  // This test ensures we use the correct API field name
-  const responseWithWrongField = {
-    needsCompaction: true, // Wrong field name
-    totalTokens: 150000,
-  };
-  const result = extractCompactionFields(responseWithWrongField);
-  assertEqual(result.needed, false, 'needed should be false when using wrong field name');
-});
-
-// ============== Token Savings Calculation Tests ==============
-
-runTest('calculateTokenSavings: should return null when originalTokens is undefined', () => {
-  const result = calculateTokenSavings(undefined, 1000);
-  assertEqual(result, null, 'result');
-});
-
-runTest('calculateTokenSavings: should return null when originalTokens is 0', () => {
-  const result = calculateTokenSavings(0, 1000);
-  assertEqual(result, null, 'result');
-});
-
-runTest('calculateTokenSavings: should return null when savings is negative', () => {
-  const result = calculateTokenSavings(1000, 2000);
-  assertEqual(result, null, 'result');
-});
-
-runTest('calculateTokenSavings: should return null when savings is zero', () => {
-  const result = calculateTokenSavings(1000, 1000);
-  assertEqual(result, null, 'result');
-});
-
-runTest('calculateTokenSavings: should calculate positive savings correctly', () => {
-  const result = calculateTokenSavings(150000, 5000);
-  assertDeepEqual(result, {
-    originalTokens: 150000,
-    summaryTokens: 5000,
-    savedTokens: 145000,
-  }, 'result');
-});
-
-runTest('calculateTokenSavings: should handle undefined summaryTokens as 0', () => {
-  const result = calculateTokenSavings(100000, undefined);
-  assertDeepEqual(result, {
-    originalTokens: 100000,
-    summaryTokens: 0,
-    savedTokens: 100000,
-  }, 'result');
-});
-
-runTest('calculateTokenSavings: should handle null summaryTokens as 0', () => {
-  const result = calculateTokenSavings(100000, null);
-  assertDeepEqual(result, {
-    originalTokens: 100000,
-    summaryTokens: 0,
-    savedTokens: 100000,
-  }, 'result');
-});
-
-// ============== URL Query String Tests ==============
-
-runTest('URL should include query string in path', () => {
-  // This test verifies the fix for httpRequest not including urlObj.search
-  const url = 'http://localhost:4096/api/sessions/123/compaction/check?modelID=claude-opus-4.5';
-  const urlObj = parseURL(url);
-  const path = urlObj.pathname + urlObj.search;
-
-  assertEqual(path, '/api/sessions/123/compaction/check?modelID=claude-opus-4.5', 'path should include query string');
-});
-
-runTest('URL path should work with encoded query parameters', () => {
-  const modelID = 'claude-sonnet-4';
-  const url = `http://localhost:4096/api/sessions/123/compaction/check?modelID=${encodeURIComponent(modelID)}`;
-  const urlObj = parseURL(url);
-  const path = urlObj.pathname + urlObj.search;
-
-  assertEqual(path, '/api/sessions/123/compaction/check?modelID=claude-sonnet-4', 'path should include encoded query');
-});
-
-runTest('URL path should handle special characters in modelID', () => {
-  const modelID = 'gpt-4/turbo';
-  const url = `http://localhost:4096/api/sessions/123/compaction/check?modelID=${encodeURIComponent(modelID)}`;
-  const urlObj = parseURL(url);
-  const path = urlObj.pathname + urlObj.search;
-
-  assertEqual(path, '/api/sessions/123/compaction/check?modelID=gpt-4%2Fturbo', 'path should properly encode slashes');
-});
-
-// ============== Integration Tests with Stubbed httpRequest ==============
-
-/**
- * Simulates the auto-compaction flow with stubbed httpRequest
- * This tests the integration between compaction check and compact operations
- */
-async function runAsyncTest(name, testFn) {
-  try {
-    await testFn();
-    console.log(`✅ ${name}`);
-  } catch (error) {
-    console.log(`❌ ${name}: ${error.message}`);
-    process.exitCode = 1;
-  }
-}
-
-/**
- * Simulates the auto-compaction flow logic from handleChatCommand
- * Uses stubbed httpRequest to verify correct API calls are made
- */
-async function simulateAutoCompaction(options) {
-  const {
-    httpRequestStub,
-    serverUrl = 'http://localhost:4096',
-    sessionId = 'test-session-123',
-    model = 'github-copilot/claude-sonnet-4',
-    verbose = false,
-    isNewSession = false, // Track if session was just created (skips compaction check)
-  } = options;
-
-  const logs = [];
-  const mockConsoleError = (msg) => logs.push(msg);
-
-  // Use shared helper for model parsing (same as production code)
-  const { providerID, modelID, compactionModelID } = parseModelString(model);
-
-  let currentSessionId = sessionId;
-  let compactionCheck = null;
-  let compactionResult = null;
-  const apiCalls = [];
-  let compactionSkipped = false; // Track if compaction was skipped due to new session
-
-  // Step 1: Check if compaction is needed (uses compactionModelID, not raw modelID)
-  // Skip compaction check on new session - no messages exist yet,
-  // so the server would always return needed: false (wasted HTTP round-trip)
-  if (!isNewSession) {
-    try {
-      const checkUrl = `${serverUrl}/api/sessions/${currentSessionId}/compaction/check?modelID=${encodeURIComponent(compactionModelID)}`;
-      apiCalls.push({ method: 'GET', url: checkUrl, originalModelID: modelID, compactionModelID });
-      compactionCheck = await httpRequestStub(checkUrl, 'GET');
-    } catch (checkError) {
-      if (verbose) {
-        mockConsoleError(`Compaction check failed: ${checkError.message}`);
-      }
-    }
-  } else {
-    compactionSkipped = true;
-  }
-
-  // Step 2: Perform compaction if needed
-  if (compactionCheck && compactionCheck.needed) {
-    const threshold = compactionCheck.usage?.limits?.threshold;
-    if (verbose) {
-      mockConsoleError(`Auto-compaction triggered: ${compactionCheck.totalTokens} > ${threshold} tokens`);
-    }
-
-    try {
-      const compactUrl = `${serverUrl}/api/sessions/${currentSessionId}/compaction/compact`;
-      const compactBody = {
-        title: `Auto-compacted Session (${new Date().toISOString().split('T')[0]})`,
-        auto: true,
-        force: false,
-        model: { providerID, modelID },
-      };
-      apiCalls.push({ method: 'POST', url: compactUrl, body: compactBody });
-      compactionResult = await httpRequestStub(compactUrl, 'POST', compactBody);
-
-      if (compactionResult && compactionResult.success) {
-        // Validate newSessionID before switching - keep original if invalid
-        const newSessionID = compactionResult.newSessionID;
-        if (!newSessionID || typeof newSessionID !== 'string' || newSessionID.trim() === '') {
-          // Always show this warning (not gated by verbose) - matches production
-          mockConsoleError(`Auto-compaction warning: server returned success but invalid newSessionID, keeping original session`);
-          // Continue with original session
-        } else {
-          // Switch to the new compacted session
-          const originalTokens = compactionCheck.totalTokens;
-          currentSessionId = newSessionID;
-
-          // Calculate token savings - check for actual summaryTokens availability
-          // Don't use || 0 fallback so we can detect when summaryTokens is not provided
-          const summaryTokens = compactionResult.summaryTokens;
-          const hasSummaryTokens = typeof summaryTokens === 'number';
-          const savedTokens = hasSummaryTokens ? originalTokens - summaryTokens : 0;
-
-          if (verbose) {
-            mockConsoleError(`Auto-compaction completed: switched to session ${currentSessionId}`);
-            if (originalTokens && savedTokens > 0) {
-              mockConsoleError(`Saved ${savedTokens} tokens`);
-            }
-          } else {
-            if (originalTokens && hasSummaryTokens) {
-              mockConsoleError(`Auto-compacted conversation (${originalTokens} → ${summaryTokens} tokens)`);
-            } else {
-              mockConsoleError(`Auto-compacted conversation to new session`);
-            }
-          }
-        }
-      } else {
-        // Always show compaction failure warnings (not gated by verbose)
-        mockConsoleError(`Auto-compaction failed: ${compactionResult?.error || 'unknown error'}`);
-      }
-    } catch (compactError) {
-      // Always show compaction failure warnings (not gated by verbose)
-      mockConsoleError(`Compaction execution failed: ${compactError.message}`);
-    }
-  } else if (verbose && compactionCheck) {
-    const totalTokens = compactionCheck.totalTokens;
-    const threshold = compactionCheck.usage?.limits?.threshold;
-    if (typeof totalTokens === 'number' && typeof threshold === 'number') {
-      mockConsoleError(`No compaction needed: ${totalTokens}/${threshold} tokens`);
-    } else if (compactionCheck.reason || compactionCheck.error) {
-      mockConsoleError(`Compaction check: ${compactionCheck.reason || compactionCheck.error}`);
-    }
-  }
-
-  return {
-    sessionId: currentSessionId,
-    apiCalls,
-    logs,
-    compactionCheck,
-    compactionResult,
-    compactionSkipped, // True if compaction was skipped due to new session
-  };
-}
-
-// Wrap all async tests in a main function to ensure proper awaiting
-async function runIntegrationTests() {
-  // Integration test: Full compaction flow
-  await runAsyncTest('Integration: should call correct APIs when compaction is needed', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return {
-          needed: true,
-          totalTokens: 150000,
-          usage: { limits: { threshold: 100000 } },
-        };
-      }
-      if (url.includes('/compaction/compact')) {
-        return {
-          success: true,
-          newSessionID: 'new-compacted-session-456',
-          summaryTokens: 5000,
-        };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      model: 'github-copilot/gpt-4', // Use a known model from the registry
-    });
-
-    assertEqual(result.apiCalls.length, 2, 'should make 2 API calls');
-    assertEqual(result.apiCalls[0].method, 'GET', 'first call should be GET');
-    if (!result.apiCalls[0].url.includes('/compaction/check')) {
-      throw new Error('first call should be to compaction/check');
-    }
-    if (!result.apiCalls[0].url.includes('modelID=gpt-4')) {
-      throw new Error('check URL should include parsed modelID');
-    }
-    assertEqual(result.apiCalls[1].method, 'POST', 'second call should be POST');
-    if (!result.apiCalls[1].url.includes('/compaction/compact')) {
-      throw new Error('second call should be to compaction/compact');
-    }
-    assertEqual(result.apiCalls[1].body.model.providerID, 'github-copilot', 'compact body should have providerID');
-    assertEqual(result.apiCalls[1].body.model.modelID, 'gpt-4', 'compact body should have modelID');
-    assertEqual(result.sessionId, 'new-compacted-session-456', 'session should be updated');
-  });
-
-  // Integration test: New session optimization - skip compaction check
-  await runAsyncTest('Integration: should skip compaction check for new session', async () => {
-    const httpRequestStub = async (url, method, body) => {
-    // This should NOT be called for new session
-      throw new Error(`Unexpected API call: ${url} - should have been skipped for new session`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      isNewSession: true, // New session flag
-    });
-
-    assertEqual(result.apiCalls.length, 0, 'should make no API calls for new session');
-    assertEqual(result.compactionSkipped, true, 'compactionSkipped should be true');
-    assertEqual(result.compactionCheck, null, 'compactionCheck should be null');
-    assertEqual(result.sessionId, 'test-session-123', 'session should not change');
-  });
-
-  // Integration test: Existing session should still check compaction
-  await runAsyncTest('Integration: should check compaction for existing session', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return { needed: false, totalTokens: 50000, usage: { limits: { threshold: 100000 } } };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      isNewSession: false, // Existing session (default)
-    });
-
-    assertEqual(result.apiCalls.length, 1, 'should make 1 API call for existing session');
-    assertEqual(result.compactionSkipped, false, 'compactionSkipped should be false');
-    assertEqual(result.compactionCheck.needed, false, 'compactionCheck should have response');
-  });
-
-  // Integration test: No compaction needed
-  await runAsyncTest('Integration: should only call check API when compaction not needed', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return {
-          needed: false,
-          totalTokens: 50000,
-          usage: { limits: { threshold: 100000 } },
-        };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      verbose: true,
-    });
-
-    assertEqual(result.apiCalls.length, 1, 'should make only 1 API call');
-    assertEqual(result.sessionId, 'test-session-123', 'session should not change');
-    if (!result.logs.some((l) => l.includes('No compaction needed'))) {
-      throw new Error('should log "No compaction needed"');
-    }
-  });
-
-  // Integration test: Check fails gracefully
-  await runAsyncTest('Integration: should continue when check fails', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        throw new Error('Network error');
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      verbose: true,
-    });
-
-    assertEqual(result.apiCalls.length, 1, 'should attempt 1 API call');
-    assertEqual(result.sessionId, 'test-session-123', 'session should not change');
-    if (!result.logs.some((l) => l.includes('Compaction check failed'))) {
-      throw new Error('should log "Compaction check failed"');
-    }
-  });
-
-  // Integration test: Compact fails gracefully
-  await runAsyncTest('Integration: should continue when compact fails', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return {
-          needed: true,
-          totalTokens: 150000,
-          usage: { limits: { threshold: 100000 } },
-        };
-      }
-      if (url.includes('/compaction/compact')) {
-        throw new Error('Server error 500');
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      verbose: true,
-    });
-
-    assertEqual(result.apiCalls.length, 2, 'should attempt 2 API calls');
-    assertEqual(result.sessionId, 'test-session-123', 'session should not change on failure');
-    if (!result.logs.some((l) => l.includes('Compaction execution failed'))) {
-      throw new Error('should log "Compaction execution failed" (not "check failed")');
-    }
-  });
-
-  // Integration test: Verbose logging with undefined values
-  await runAsyncTest('Integration: should not log undefined/undefined when check returns error', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return {
-          needed: false,
-          reason: 'Session not found',
-          error: 'SESSION_NOT_FOUND',
-        };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      verbose: true,
-    });
-
-    // Should not log "undefined/undefined tokens"
-    if (result.logs.some((l) => l.includes('undefined'))) {
-      throw new Error('should not log undefined values');
-    }
-    // Should log the reason/error instead
-    if (!result.logs.some((l) => l.includes('SESSION_NOT_FOUND') || l.includes('Session not found'))) {
-      throw new Error('should log error reason when available');
-    }
-  });
-
-  // Integration test: Model parsing in API calls
-  await runAsyncTest('Integration: should parse model-only format correctly', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return { needed: false, totalTokens: 1000, usage: { limits: { threshold: 100000 } } };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      model: 'gpt-4', // No provider prefix
-    });
-
-    // Should use default provider and the provided model
-    if (!result.apiCalls[0].url.includes('modelID=gpt-4')) {
-      throw new Error('should use model name from input');
-    }
-  });
-
-  // Integration test: Unknown model should fallback to known model for compaction check
-  await runAsyncTest('Integration: should fallback to known model for unknown modelID', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return { needed: false, totalTokens: 1000, usage: { limits: { threshold: 100000 } } };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    // Simulate with unknown model - should fallback to known model
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      model: 'github-copilot/some-unknown-model',
-    });
-
-    assertEqual(result.apiCalls.length, 1, 'should make 1 API call');
-
-    // Verify the fallback: URL should use claude-opus-4.5 (fallback), not some-unknown-model
-    const checkUrl = result.apiCalls[0].url;
-    if (checkUrl.includes('modelID=some-unknown-model')) {
-      throw new Error('should NOT use unknown model in URL');
-    }
-    if (!checkUrl.includes('modelID=claude-opus-4.5')) {
-      throw new Error('should use fallback model claude-opus-4.5 in URL');
-    }
-
-    // Also verify via apiCalls metadata
-    assertEqual(result.apiCalls[0].originalModelID, 'some-unknown-model', 'should track original model');
-    assertEqual(result.apiCalls[0].compactionModelID, 'claude-opus-4.5', 'should use fallback for compaction');
-  });
-
-  // Integration test: Known model should NOT fallback
-  await runAsyncTest('Integration: should use known model directly without fallback', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return { needed: false, totalTokens: 1000, usage: { limits: { threshold: 100000 } } };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    // Use a known model - should use it directly
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      model: 'github-copilot/gpt-4',
-    });
-
-    // Verify the URL uses gpt-4 directly (no fallback)
-    const checkUrl = result.apiCalls[0].url;
-    if (!checkUrl.includes('modelID=gpt-4')) {
-      throw new Error('should use known model gpt-4 directly in URL');
-    }
-    assertEqual(result.apiCalls[0].originalModelID, 'gpt-4', 'original model');
-    assertEqual(result.apiCalls[0].compactionModelID, 'gpt-4', 'should NOT fallback for known model');
-  });
-
-  // Integration test: Should not switch session if newSessionID is invalid
-  await runAsyncTest('Integration: should keep original session if newSessionID is invalid', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return {
-          needed: true,
-          totalTokens: 150000,
-          usage: { limits: { threshold: 100000 } },
-        };
-      }
-      if (url.includes('/compaction/compact')) {
-        // Server returns success but with empty/invalid newSessionID
-        return {
-          success: true,
-          newSessionID: '', // Invalid!
-          summaryTokens: 5000,
-        };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      verbose: true,
-    });
-
-    // Session should NOT change when newSessionID is invalid
-    assertEqual(result.sessionId, 'test-session-123', 'session should not change with invalid newSessionID');
-    // Should log a warning
-    if (!result.logs.some((l) => l.includes('invalid newSessionID') || l.includes('keeping original'))) {
-      throw new Error('should log warning about invalid newSessionID');
-    }
-  });
-
-  // ============================================================================
-  // Non-verbose failure path tests
-  // These tests verify that compaction failure messages are always shown,
-  // even when verbose is false. This ensures future changes don't accidentally
-  // re-introduce verbose-gating on the failure paths.
-  // ============================================================================
-
-  // Test: Non-verbose mode - compaction execution failure should always be shown
-  await runAsyncTest('Integration: should always show execution failure even when verbose is false', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return { needed: true, totalTokens: 150000, usage: { limits: { threshold: 100000 } } };
-      }
-      if (url.includes('/compaction/compact')) {
-        throw new Error('Network timeout');
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      verbose: false, // Non-verbose mode
-    });
-
-    // Should always show execution failure message even without verbose
-    if (!result.logs.some((l) => l.includes('Compaction execution failed'))) {
-      throw new Error(`should show execution failure message even in non-verbose mode, got: ${result.logs.join(', ')}`);
-    }
-    if (!result.logs.some((l) => l.includes('Network timeout'))) {
-      throw new Error(`should include error message, got: ${result.logs.join(', ')}`);
-    }
-  });
-
-  // Test: Non-verbose mode - compaction API failure should always be shown
-  await runAsyncTest('Integration: should always show API failure even when verbose is false', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return { needed: true, totalTokens: 150000, usage: { limits: { threshold: 100000 } } };
-      }
-      if (url.includes('/compaction/compact')) {
-        // Server returns success: false with an error
-        return { success: false, error: 'Compaction service unavailable' };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      verbose: false, // Non-verbose mode
-    });
-
-    // Should always show compaction failure message even without verbose
-    if (!result.logs.some((l) => l.includes('Auto-compaction failed'))) {
-      throw new Error(`should show compaction failure message even in non-verbose mode, got: ${result.logs.join(', ')}`);
-    }
-    if (!result.logs.some((l) => l.includes('Compaction service unavailable'))) {
-      throw new Error(`should include error message, got: ${result.logs.join(', ')}`);
-    }
-  });
-
-  // Test: Non-verbose mode - invalid newSessionID warning should always be shown
-  await runAsyncTest('Integration: should always show invalid newSessionID warning even when verbose is false', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return { needed: true, totalTokens: 150000, usage: { limits: { threshold: 100000 } } };
-      }
-      if (url.includes('/compaction/compact')) {
-        // Server returns success but with null/invalid newSessionID
-        return { success: true, newSessionID: null };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      verbose: false, // Non-verbose mode
-    });
-
-    // Should always show invalid session warning even without verbose
-    if (!result.logs.some((l) => l.includes('invalid newSessionID'))) {
-      throw new Error(`should show invalid newSessionID warning even in non-verbose mode, got: ${result.logs.join(', ')}`);
-    }
-    // Should keep original session
-    assertEqual(result.sessionId, 'test-session-123', 'should not change session when newSessionID is invalid');
-  });
-
-  // Test: Non-verbose mode - empty string newSessionID should also trigger warning
-  await runAsyncTest('Integration: should always show warning for empty string newSessionID when verbose is false', async () => {
-    const httpRequestStub = async (url, method, body) => {
-      if (url.includes('/compaction/check')) {
-        return { needed: true, totalTokens: 150000, usage: { limits: { threshold: 100000 } } };
-      }
-      if (url.includes('/compaction/compact')) {
-        // Server returns success but with empty string newSessionID
-        return { success: true, newSessionID: '   ' };
-      }
-      throw new Error(`Unexpected API call: ${url}`);
-    };
-
-    const result = await simulateAutoCompaction({
-      httpRequestStub,
-      verbose: false, // Non-verbose mode
-    });
-
-    // Should always show invalid session warning even without verbose
-    if (!result.logs.some((l) => l.includes('invalid newSessionID'))) {
-      throw new Error(`should show invalid newSessionID warning for empty string even in non-verbose mode, got: ${result.logs.join(', ')}`);
-    }
-    // Should keep original session
-    assertEqual(result.sessionId, 'test-session-123', 'should not change session when newSessionID is empty string');
-  });
-}
-
-// Run sync tests first, then async tests with proper awaiting
-console.log('\n✓ Auto-compaction unit tests completed');
-
-// ============================================================================
-// Env var precedence tests (only run when lib/compaction.js is available)
-// ============================================================================
-try {
-  const compaction = require('../lib/compaction');
-  const { getDefaultModelIDForCompaction, getDefaultProviderIDForCompaction } = compaction;
-
-  console.log('\n=== Env Var Precedence Tests ===');
-
-  // Save original env vars
-  const origPaveModel = process.env.PAVE_MODEL;
-  const origPaveCompactModel = process.env.PAVE_COMPACT_MODEL;
-
-  function cleanTestEnv() {
-    delete process.env.PAVE_MODEL;
-    delete process.env.PAVE_COMPACT_MODEL;
-  }
-
-  function restoreTestEnv() {
-    if (origPaveModel !== undefined) process.env.PAVE_MODEL = origPaveModel;
-    else delete process.env.PAVE_MODEL;
-    if (origPaveCompactModel !== undefined) process.env.PAVE_COMPACT_MODEL = origPaveCompactModel;
-    else delete process.env.PAVE_COMPACT_MODEL;
-  }
-
-  // Check if process.env mutation works in this environment
-  let canMutateEnv = false;
-  try {
-    cleanTestEnv();
-    process.env.__PAVE_TEST_PROBE = 'yes';
-    if (process.env.__PAVE_TEST_PROBE === 'yes') {
-      canMutateEnv = true;
-    }
-    delete process.env.__PAVE_TEST_PROBE;
-  } catch (e) {
-    canMutateEnv = false;
-  }
-
-  // Test: no env vars -> hardcoded defaults (always works)
-  cleanTestEnv();
-  runTest('Env: no env vars -> hardcoded default model', () => {
-    assertEqual(getDefaultModelIDForCompaction(), 'claude-opus-4.5', 'default model');
-  });
-
-  cleanTestEnv();
-  runTest('Env: no env vars -> hardcoded default provider', () => {
-    assertEqual(getDefaultProviderIDForCompaction(), 'github-copilot', 'default provider');
-  });
-
-  try {
-    if (canMutateEnv) {
-      // Test: PAVE_MODEL sets default
-      cleanTestEnv();
-      process.env.PAVE_MODEL = 'github-copilot/claude-sonnet-4.6';
-      runTest('Env: PAVE_MODEL sets model', () => {
-        assertEqual(getDefaultModelIDForCompaction(), 'claude-sonnet-4.6', 'model from PAVE_MODEL');
-      });
-
-      cleanTestEnv();
-      process.env.PAVE_MODEL = 'github-copilot/claude-sonnet-4.6';
-      runTest('Env: PAVE_MODEL sets provider', () => {
-        assertEqual(getDefaultProviderIDForCompaction(), 'github-copilot', 'provider from PAVE_MODEL');
-      });
-
-      // Test: PAVE_COMPACT_MODEL takes precedence
-      cleanTestEnv();
-      process.env.PAVE_MODEL = 'github-copilot/claude-opus-4.6';
-      process.env.PAVE_COMPACT_MODEL = 'github-copilot/claude-sonnet-4';
-      runTest('Env: PAVE_COMPACT_MODEL takes precedence over PAVE_MODEL', () => {
-        assertEqual(getDefaultModelIDForCompaction(), 'claude-sonnet-4', 'compact model wins');
-      });
-
-      // Test: bare model ID defaults to github-copilot
-      cleanTestEnv();
-      process.env.PAVE_COMPACT_MODEL = 'claude-sonnet-4.5';
-      runTest('Env: bare PAVE_COMPACT_MODEL uses default provider', () => {
-        assertEqual(getDefaultProviderIDForCompaction(), 'github-copilot', 'bare model -> default provider');
-      });
-
-      // Test: malformed spec falls back
-      cleanTestEnv();
-      process.env.PAVE_COMPACT_MODEL = 'provider/';
-      runTest('Env: malformed PAVE_COMPACT_MODEL falls back to hardcoded', () => {
-        assertEqual(getDefaultModelIDForCompaction(), 'claude-opus-4.5', 'malformed -> hardcoded');
-      });
-
-      cleanTestEnv();
-      process.env.PAVE_COMPACT_MODEL = '/claude-opus-4.5';
-      runTest('Env: /model format falls back to default provider', () => {
-        assertEqual(getDefaultProviderIDForCompaction(), 'github-copilot', '/model -> default provider');
-      });
-    } else {
-      console.log('  (skipping env mutation tests - process.env is read-only in this environment)');
-    }
-  } finally {
-    restoreTestEnv();
-  }
-  console.log('✓ Env var precedence tests completed');
-} catch (e) {
-  console.log('\n⚠️  Skipping env var precedence tests (lib/compaction.js not available in sandbox)');
-}
-
-// Run integration tests with proper await
-runIntegrationTests().then(() => {
-  console.log('✓ Integration tests with stubbed httpRequest completed');
-}).catch((err) => {
-  console.error('Integration tests failed:', err.message);
-  process.exitCode = 1;
-});