@codeyam/codeyam-cli 0.1.0-bleeding-edge.8afd3ee → 0.1.0-staging.036391e

package/analyzer-template/.build-info.json

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2025-12-09T21:06:56.685Z",
-  "buildTime": 1765314416685,
-  "gitCommit": "8afd3ee021d3d54ad4b194a574ae3bcd6427b53f",
-  "nodeVersion": "v20.19.6",
-  "contentHash": "131ce1b86de761d815eb9d47d321d6959a13627b88b736f0e01a873d6f68e719",
-  "buildNumber": 47,
-  "semanticVersion": "0.1.47",
-  "version": "0.1.47 (2025-12-09T21:06+131ce1b)"
+  "buildTimestamp": "2026-02-10T15:50:47.182Z",
+  "buildTime": 1770738647182,
+  "gitCommit": "036391eb81237d8a0486ab9278a421ced43f450d",
+  "nodeVersion": "v20.20.0",
+  "contentHash": "3686880009968bee7de4a1974c22f64d417de53b5e8d46a51d7e88a017d4f2cc",
+  "buildNumber": 599,
+  "semanticVersion": "0.1.599",
+  "version": "0.1.599 (2026-02-10T15:50+3686880)"
 }

package/analyzer-template/common/execAsync.ts

@@ -1,12 +1,12 @@
 import {
   loadBackgroundJob,
   updateBackgroundJobProgress,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import * as fs from 'fs';
 import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
 
 import { loadEnv } from '~codeyam/utils/server';
-import { getGlobalProcessManager, ProcessType } from '../process';
+import { getGlobalProcessManager, ProcessType } from '~codeyam/process';
 
 loadEnv();
 

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[12/9/2025, 9:06:56 PM] > codeyam-combo@1.0.0 mergeDependencies
-[12/9/2025, 9:06:56 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[2/10/2026, 3:50:47 PM] > codeyam-combo@1.0.0 mergeDependencies
+[2/10/2026, 3:50:47 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[12/9/2025, 9:06:56 PM] Merged dependencies into root package.json
+[2/10/2026, 3:50:47 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -7,63 +7,68 @@
     "build": "tsc && node ./scripts/postbuild.cjs"
   },
   "dependencies": {
-    "@aws-sdk/client-cloudwatch-logs": "^3.940.0",
-    "@aws-sdk/client-cloudfront": "^3.899.0",
-    "@aws-sdk/client-codebuild": "^3.940.0",
-    "@aws-sdk/client-dynamodb": "^3.899.0",
+    "@aws-sdk/client-cloudwatch-logs": "^3.980.0",
+    "@aws-sdk/client-cloudfront": "^3.966.0",
+    "@aws-sdk/client-codebuild": "^3.948.0",
+    "@aws-sdk/client-dynamodb": "^3.956.0",
     "@aws-sdk/client-ec2": "^3.899.0",
-    "@aws-sdk/client-ecr": "^3.946.0",
-    "@aws-sdk/client-ecs": "^3.937.0",
-    "@aws-sdk/client-s3": "^3.899.0",
-    "@aws-sdk/client-sqs": "^3.940.0",
-    "@aws-sdk/lib-storage": "^3.899.0",
-    "@aws-sdk/util-dynamodb": "^3.902.0",
+    "@aws-sdk/client-ecr": "^3.948.0",
+    "@aws-sdk/client-ecs": "^3.956.0",
+    "@aws-sdk/client-s3": "^3.940.0",
+    "@aws-sdk/client-sqs": "^3.956.0",
+    "@aws-sdk/lib-storage": "^3.975.0",
+    "@aws-sdk/util-dynamodb": "^3.971.0",
     "@octokit/auth-app": "^8.1.0",
     "@octokit/rest": "^22.0.0",
     "@sendgrid/mail": "^8.1.4",
-    "@supabase/supabase-js": "2.52.1",
+    "@supabase/supabase-js": "2.88.0",
     "domhandler": "^5.0.3",
     "dotenv": "^17.2.3",
-    "express": "^5.2.0",
+    "express": "^5.2.1",
     "get-port": "^7.1.0",
     "htmlparser2": "^10.0.0",
     "jest": "^30.2.0",
-    "jsdom": "^26.1.0",
+    "jsdom": "^27.4.0",
     "jsonc-parser": "^3.2.1",
-    "lru-cache": "^11.2.4",
-    "openai": "^6.9.0",
+    "lru-cache": "^11.2.5",
+    "openai": "^6.16.0",
     "p-queue": "^8.1.0",
-    "p-retry": "^6.2.1",
+    "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
     "pixelmatch": "^5.3.0",
-    "playwright": "^1.56.1",
+    "playwright": "1.58.0",
     "sharp": "^0.34.5",
     "simple-git": "^3.28.0",
-    "undici": "^7.16.0",
+    "undici": "^7.18.2",
     "uuid": "^11.1.0",
     "pluralize": "^8.0.0",
-    "@anthropic-ai/sdk": "^0.71.0",
-    "@octokit/request": "^10.0.3",
+    "yargs": "^18.0.0",
+    "json5": "^2.2.3",
+    "@anthropic-ai/sdk": "^0.74.0",
+    "@aws-sdk/s3-request-presigner": "^3.940.0",
     "better-sqlite3": "^12.4.1",
     "fetch-retry": "^6.0.0",
-    "kysely": "^0.28.5",
+    "kysely": "^0.28.11",
     "pg": "^8.16.3",
+    "@octokit/request": "^10.0.3",
     "lucide-react": "^0.556.0",
     "react-resizable": "^3.0.5"
   },
   "devDependencies": {
     "typescript": "^5.9.3",
     "@jest/types": "^30.2.0",
-    "@types/jsdom": "^21.1.7",
-    "@octokit/types": "^15.0.0",
+    "@types/node": "^25.0.2",
+    "@types/yargs": "^17.0.34",
+    "@types/jsdom": "^27.0.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",
     "@types/pg": "^8.15.5",
     "@types/ws": "^8.18.1",
-    "@types/react": "^18.0.0",
-    "@types/react-dom": "^18.0.0",
+    "@octokit/types": "^16.0.0",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
     "@types/react-resizable": "^3.0.7",
-    "react": "^18.0.0",
-    "react-dom": "^18.0.0"
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3"
   }
 }

package/analyzer-template/packages/ai/index.ts

@@ -13,7 +13,6 @@ export { default as generateEntityDocumentation } from './src/lib/generateEntity
 export { default as generateChangesEntityDocumentation } from './src/lib/generateChangesEntityDocumentation';
 export { default as codeQualityEntityAnalysis } from './src/lib/codeQualityEntityAnalysis';
 export { default as summarizeDiff } from './src/lib/summarizeDiff';
-export { default as generateEntityDataMap } from './src/lib/generateEntityDataMap';
 export { default as generateEntityDataStructure } from './src/lib/generateEntityDataStructure';
 export { default as generateEntityScenarios } from './src/lib/generateEntityScenarios';
 export {
@@ -22,8 +21,7 @@ export {
 } from './src/lib/generateEntityScenarioData';
 export { default as generateChangesEntityScenarios } from './src/lib/generateChangesEntityScenarios';
 export { default as generateChangesEntityScenarioData } from './src/lib/generateChangesEntityScenarioData';
-export { default as generateEntityKeyAttributes } from './src/lib/generateEntityKeyAttributes';
-export { default as generateChangesEntityKeyAttributes } from './src/lib/generateChangesEntityKeyAttributes';
+export { default as generateExecutionFlows } from './src/lib/generateExecutionFlows';
 export {
   default as guessScenarioDataFromName,
   type GuessScenarioDataFromNameArgs,
@@ -31,6 +29,7 @@ export {
 export {
   default as guessScenarioDataFromDescription,
   type GuessScenarioDataFromDescriptionArgs,
+  type ExecutionFlowSelection,
 } from './src/lib/guessScenarioDataFromDescription';
 export { default as generateBranchSummary } from './src/lib/generateBranchSummary';
 export { default as extractOverlappingMocks } from './src/lib/extractOverlappingMocks';
@@ -41,7 +40,10 @@ export { default as describeCodeChange } from './src/lib/describeCodeChange';
 export { default as validateTypeStructure } from './src/lib/validateTypeStructure';
 export { default as validateDataStructure } from './src/lib/validateDataStructure';
 export { default as isolateScopes } from './src/lib/isolateScopes';
-export { default as analyzeScope } from './src/lib/analyzeScope';
+export {
+  default as analyzeScope,
+  destroyWorkerPool,
+} from './src/lib/analyzeScope';
 export { default as logOrderedMap } from './src/lib/logOrderedMap';
 export {
   default as splitOutsideParentheses,
@@ -50,12 +52,19 @@ export {
   functionArguments,
 } from './src/lib/splitOutsideParentheses';
 export { cleanKnownObjectFunctionsFromMapping } from './src/lib/dataStructure/helpers/cleanKnownObjectFunctions';
-export { clearAttributesFromMapping } from './src/lib/dataStructure/helpers/cleanNonObjectFunctions';
+export {
+  clearAttributesFromMapping,
+  removeDuplicateFunctionCalls,
+} from './src/lib/dataStructure/helpers/cleanNonObjectFunctions';
 export { default as convertDotNotation } from './src/lib/dataStructure/helpers/convertDotNotation';
+export { default as convertTypeAnnotationsToValues } from './src/lib/dataStructure/helpers/convertTypeAnnotationsToValues';
 export { default as cleanOutBoundary } from './src/lib/cleanOutBoundary';
-export { fillInDirectSchemaGapsAndUnknowns } from './src/lib/dataStructure/helpers/fillInSchemaGapsAndUnknowns';
+export {
+  fillInDirectSchemaGapsAndUnknowns,
+  buildSchemaIndexes,
+  type SchemaIndexes,
+} from './src/lib/dataStructure/helpers/fillInSchemaGapsAndUnknowns';
 export { default as deduplicateFunctionSchemas } from './src/lib/dataStructure/helpers/deduplicateFunctionSchemas';
-export { default as gatherRelevantDependentKeyAttributes } from './src/lib/gatherRelevantDependentKeyAttributes';
 export { default as getConditionalUsagesFromCode } from './src/lib/getConditionalUsagesFromCode';
 export type {
   ScopeInfo,
@@ -67,6 +76,7 @@ export type {
   SerializableFunctionCallInfo,
   SerializableFunctionResult,
   SerializableScopeVariable,
+  EnrichedConditionalUsage,
 } from './src/lib/worker/SerializableDataStructure';
 export {
   getExternalFunctionCallInfo,
@@ -75,10 +85,19 @@ export {
   getUsageEquivalencies,
   getSourceEquivalencies,
   getEquivalentSignatureVariables,
+  getConditionalUsages,
+  getConditionalEffects,
+  getCompoundConditionals,
+  getChildBoundaryGatingConditions,
+  getJsxRenderingUsages,
 } from './src/lib/worker/SerializableDataStructure';
 export { parseJsonSafe } from './src/lib/parsers/parseJsonSafe';
 export { default as completionCall } from './src/lib/completionCall';
 
+// NOTE: E2E data tracking utilities (e2eDataTracking.ts) are NOT exported here
+// because they use Node.js 'crypto' module which breaks browser builds.
+// Import directly from '~codeyam/ai/src/lib/e2eDataTracking' when needed in Node.js tests.
+
 // Wrapper detection
 export { default as detectWrapperRequirements } from './src/lib/wrapperDetection/detectWrapperRequirements';
 export { KNOWN_LIBRARY_HOOKS } from './src/lib/wrapperDetection/knownLibraryHooks';

package/analyzer-template/packages/ai/package.json

@@ -9,14 +9,14 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.71.0",
-    "jsdom": "^26.1.0",
+    "@anthropic-ai/sdk": "^0.74.0",
+    "jsdom": "^27.4.0",
     "p-queue": "^8.1.0",
-    "p-retry": "^6.2.1",
+    "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
-    "lru-cache": "^11.2.4"
+    "lru-cache": "^11.2.5"
   },
   "devDependencies": {
-    "@types/jsdom": "^21.1.7"
+    "@types/jsdom": "^27.0.0"
   }
 }

package/analyzer-template/packages/ai/scripts/ai-test-matrix.mjs

@@ -0,0 +1,424 @@
+#!/usr/bin/env node
+/**
+ * AI Test Matrix Runner
+ *
+ * Runs AI test suites across multiple models with configurable concurrency.
+ * Outputs JSON results for analysis.
+ *
+ * Usage:
+ *   node packages/ai/scripts/ai-test-matrix.mjs [options]
+ *
+ * Options:
+ *   --test, -t       Test file pattern (default: all ai_tests)
+ *   --models, -m     Comma-separated model list (default: see MODELS below)
+ *   --runs, -r       Number of runs per model (default: 1, useful for flakiness detection)
+ *   --concurrency    Max concurrent test runs (default: 4)
+ *   --output, -o     Output file for results JSON (default: stdout)
+ *
+ * Examples:
+ *   node packages/ai/scripts/ai-test-matrix.mjs -t generateStatementAnalysis
+ *   node packages/ai/scripts/ai-test-matrix.mjs -m "gpt-4.1-mini,claude-sonnet-4-20250514" -r 3
+ */
+
+import { spawn } from 'node:child_process';
+import { writeFile } from 'node:fs/promises';
+import { parseArgs } from 'node:util';
+
+const MODELS = [
+  // OpenAI
+  'openai/gpt-5',
+  'openai/gpt-5-mini',
+  'openai/gpt-5-nano',
+  'openai/gpt-4.1',
+  'openai/gpt-4.1-mini',
+  'openai/gpt-4o',
+  'openai/gpt-4o-mini',
+
+  // Groq
+  'openai/gpt-oss-120b-groq',
+
+  // DeepInfra
+  'openai/gpt-oss-120b-deepinfra',
+  'qwen/qwen3-235b-instruct-deepinfra',
+  'qwen/qwen3-coder-480b-instruct-deepinfra',
+  'google/gemini-2.5-pro-deepinfra',
+  'google/gemini-2.5-flash-deepinfra',
+
+  // OpenRouter
+  'google/gemini-2.5-flash-lite-openrouter',
+  'meta-llama/llama-4-maverick-openrouter',
+  'deepseek/v3.1-terminus-openrouter',
+
+  // Anthropic
+  'anthropic/claude-4.5-haiku',
+  'anthropic/claude-4.5-sonnet',
+  'anthropic/claude-4.5-opus',
+];
+
+const AI_TESTS_DIR = 'packages/ai/src/lib/__tests__/ai_tests';
+
+// Tests excluded from default runs (low signal-to-noise ratio)
+const EXCLUDED_TESTS = [
+  'generateStatementAnalysis',
+  'generateEntityDataStructure',
+];
+
+const HELP_TEXT = `
+AI Test Matrix Runner
+
+Runs AI test suites across multiple models with configurable concurrency.
+Outputs JSON results for analysis.
+
+Usage:
+  node packages/ai/scripts/ai-test-matrix.mjs [options]
+
+Options:
+  --test, -t       Test file pattern (default: all ai_tests)
+  --models, -m     Comma-separated model list (default: ${MODELS.join(', ')})
+  --runs, -r       Number of runs per model (default: 1, useful for flakiness detection)
+  --concurrency    Max concurrent test runs (default: 4)
+  --output, -o     Output file for results JSON (default: stdout)
+  --help, -h       Show this help message
+
+Examples:
+  node packages/ai/scripts/ai-test-matrix.mjs -t generateStatementAnalysis
+  node packages/ai/scripts/ai-test-matrix.mjs -m "gpt-4.1-mini,claude-sonnet-4-20250514" -r 3
+`;
+
+function parseCliArgs() {
+  const { values } = parseArgs({
+    options: {
+      test: { type: 'string', short: 't', default: '' },
+      models: { type: 'string', short: 'm', default: '' },
+      runs: { type: 'string', short: 'r', default: '1' },
+      concurrency: { type: 'string', default: '4' },
+      output: { type: 'string', short: 'o', default: '' },
+      help: { type: 'boolean', short: 'h', default: false },
+    },
+  });
+
+  if (values.help) {
+    console.log(HELP_TEXT);
+    process.exit(0);
+  }
+
+  return {
+    testPattern: values.test || '',
+    models: values.models ? values.models.split(',').map((m) => m.trim()) : MODELS,
+    runs: parseInt(values.runs, 10),
+    concurrency: parseInt(values.concurrency, 10),
+    outputFile: values.output || '',
+  };
+}
+
+/**
+ * Run jest with JSON output and return parsed results
+ */
+async function runJest(model, testPattern, ignorePatterns = []) {
+  const testPath = testPattern
+    ? `${AI_TESTS_DIR}/${testPattern}.test.ts`
+    : AI_TESTS_DIR;
+
+  const jestArgs = ['jest', '--config', 'jest.config.ai.ts', '--json', testPath];
+
+  // Add --testPathIgnorePatterns for excluded tests
+  for (const pattern of ignorePatterns) {
+    jestArgs.push('--testPathIgnorePatterns', pattern);
+  }
+
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const proc = spawn('npx', jestArgs, {
+        env: { ...process.env, CODEYAM_TEST_MODEL: model },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }
+    );
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (exitCode) => {
+      const duration = Date.now() - startTime;
+
+      // Jest outputs JSON to stdout, but may include non-JSON lines
+      // Find the JSON object in the output
+      let jsonResult = null;
+      try {
+        const jsonMatch = stdout.match(/^\{[\s\S]*\}$/m);
+        if (jsonMatch) {
+          jsonResult = JSON.parse(jsonMatch[0]);
+        }
+      } catch {
+        // JSON parse failed
+      }
+
+      if (jsonResult) {
+        resolve({
+          success: exitCode === 0,
+          model,
+          duration,
+          numTotalTests: jsonResult.numTotalTests,
+          numPassedTests: jsonResult.numPassedTests,
+          numFailedTests: jsonResult.numFailedTests,
+          testResults: jsonResult.testResults.map((tr) => {
+            const passed = tr.assertionResults.filter((ar) => ar.status === 'passed').length;
+            const failed = tr.assertionResults.filter((ar) => ar.status === 'failed').length;
+            return {
+              file: tr.name.replace(/.*ai_tests\//, ''),
+              passed,
+              failed,
+              failures: tr.assertionResults
+                .filter((ar) => ar.status === 'failed')
+                .map((ar) => ({
+                  name: ar.title,
+                  message: ar.failureMessages?.[0]?.slice(0, 500) || '',
+                })),
+            };
+          }),
+        });
+      } else {
+        resolve({
+          success: false,
+          model,
+          duration,
+          error: 'Failed to parse Jest JSON output',
+          stderr: stderr.slice(0, 1000),
+        });
+      }
+    });
+  });
+}
+
+/**
+ * Run tasks with limited concurrency
+ */
+async function runWithConcurrency(tasks, concurrency) {
+  const results = [];
+  const executing = new Set();
+
+  for (const task of tasks) {
+    const promise = task().then((result) => {
+      executing.delete(promise);
+      return result;
+    });
+    executing.add(promise);
+    results.push(promise);
+
+    if (executing.size >= concurrency) {
+      await Promise.race(executing);
+    }
+  }
+
+  return Promise.all(results);
+}
+
+/**
+ * Aggregate results for summary statistics
+ */
+function aggregateResults(results, models, runs) {
+  const byModel = {};
+
+  for (const model of models) {
+    const modelResults = results.filter((r) => r.model === model);
+    const cleanRuns = modelResults.filter((r) => r.numFailedTests === 0).length;
+    const totalPassed = modelResults.reduce((sum, r) => sum + (r.numPassedTests || 0), 0);
+    const totalTests = modelResults.reduce((sum, r) => sum + (r.numTotalTests || 0), 0);
+
+    byModel[model] = {
+      runs: modelResults.length,
+      cleanRuns,
+      testsTotal: totalTests,
+      testsPassed: totalPassed,
+      testPassRate: totalTests > 0 ? ((totalPassed / totalTests) * 100).toFixed(1) + '%' : 'N/A',
+      avgDuration: Math.round(
+        modelResults.reduce((sum, r) => sum + r.duration, 0) / modelResults.length
+      ),
+      // Flakiness: tests that passed in some runs but failed in others
+      flakyTests: runs > 1 ? findFlakyTests(modelResults) : [],
+    };
+  }
+
+  return byModel;
+}
+
+/**
+ * Find tests that passed in some runs but failed in others
+ */
+function findFlakyTests(modelResults) {
+  const testOutcomes = new Map();
+
+  for (const result of modelResults) {
+    if (!result.testResults) continue;
+
+    for (const tr of result.testResults) {
+      for (const failure of tr.failures || []) {
+        const key = `${tr.file}:${failure.name}`;
+        if (!testOutcomes.has(key)) {
+          testOutcomes.set(key, { passed: 0, failed: 0 });
+        }
+        testOutcomes.get(key).failed++;
+      }
+    }
+  }
+
+  // Mark passed for tests not in failures
+  const totalRuns = modelResults.length;
+  const flaky = [];
+
+  for (const [test, outcomes] of testOutcomes) {
+    outcomes.passed = totalRuns - outcomes.failed;
+    if (outcomes.passed > 0 && outcomes.failed > 0) {
+      flaky.push({
+        test,
+        passRate: ((outcomes.passed / totalRuns) * 100).toFixed(0) + '%',
+      });
+    }
+  }
+
+  return flaky;
+}
+
+async function main() {
+  const config = parseCliArgs();
+
+  console.error(`🧪 AI Test Matrix Runner`);
+  console.error(`   Models: ${config.models.join(', ')}`);
+  console.error(`   Runs per model: ${config.runs}`);
+  console.error(`   Concurrency: ${config.concurrency}`);
+  console.error(`   Test pattern: ${config.testPattern || '(all ai_tests)'}`);
+
+  // When running all tests (no specific pattern), exclude noisy tests
+  const ignorePatterns = config.testPattern ? [] : EXCLUDED_TESTS;
+  if (ignorePatterns.length > 0) {
+    console.error(`   Excluding: ${ignorePatterns.join(', ')}`);
+  }
+  console.error('');
+
+  // Build task list
+  const tasks = [];
+  for (const model of config.models) {
+    for (let run = 0; run < config.runs; run++) {
+      tasks.push(async () => {
+        const runLabel = config.runs > 1 ? ` (run ${run + 1}/${config.runs})` : '';
+        console.error(`⏳ Starting: ${model}${runLabel}`);
+        const result = await runJest(model, config.testPattern, ignorePatterns);
+        const status = result.numFailedTests === 0 ? '✅' : '❌';
+        console.error(
+          `${status} Finished: ${model}${runLabel} - ${result.numPassedTests}/${result.numTotalTests} passed (${result.duration}ms)`
+        );
+        return { ...result, runIndex: run };
+      });
+    }
+  }
+
+  const results = await runWithConcurrency(tasks, config.concurrency);
+  const summary = aggregateResults(results, config.models, config.runs);
+
+  const output = {
+    timestamp: new Date().toISOString(),
+    config: {
+      testPattern: config.testPattern || '(all)',
+      models: config.models,
+      runs: config.runs,
+    },
+    summary,
+    results,
+  };
+
+  const jsonOutput = JSON.stringify(output, null, 2);
+
+  if (config.outputFile) {
+    await writeFile(config.outputFile, jsonOutput);
+    console.error(`\n📄 Results written to ${config.outputFile}`);
+  } else {
+    console.log(jsonOutput);
+  }
+
+  // Print summary table to stderr
+  console.error('\n📊 Summary:');
+  console.error('─'.repeat(70));
+  for (const [model, stats] of Object.entries(summary)) {
+    console.error(
+      `${model.padEnd(40)} ${stats.testPassRate.padStart(6)} (${stats.testsPassed}/${stats.testsTotal}) | ${stats.avgDuration}ms`
+    );
+    if (stats.flakyTests.length > 0) {
+      console.error(`   ⚠️  Flaky: ${stats.flakyTests.map((f) => f.test).join(', ')}`);
+    }
+  }
+  console.error('─'.repeat(70));
+
+  // Print matrix view (models × test files)
+  printMatrix(results, config.models);
+}
+
+/**
+ * Print a matrix view: test files (rows) × models (columns)
+ */
+function printMatrix(results, models) {
+  // Collect all test files across all results
+  const testFiles = new Set();
+  for (const result of results) {
+    if (!result.testResults) continue;
+    for (const tr of result.testResults) {
+      testFiles.add(tr.file);
+    }
+  }
+
+  if (testFiles.size === 0) return;
+
+  const sortedFiles = [...testFiles].sort();
+
+  // Compute column widths
+  const fileColWidth = Math.max(30, ...sortedFiles.map((f) => f.replace('.test.ts', '').length + 2));
+  const modelColWidth = 12;
+
+  // Shorten model names for display
+  const shortModelName = (m) => {
+    const parts = m.split('/');
+    return parts[parts.length - 1].slice(0, modelColWidth - 1);
+  };
+
+  console.error('\n📋 Matrix (test files × models):');
+  console.error('─'.repeat(fileColWidth + models.length * (modelColWidth + 1)));
+
+  // Header row
+  const header = ''.padEnd(fileColWidth) + models.map((m) => shortModelName(m).padStart(modelColWidth)).join(' ');
+  console.error(header);
+  console.error('─'.repeat(fileColWidth + models.length * (modelColWidth + 1)));
+
+  // Data rows
+  for (const file of sortedFiles) {
+    const shortFile = file.replace('.test.ts', '');
+    let row = shortFile.padEnd(fileColWidth);
+
+    for (const model of models) {
+      // Find result for this model (use first run if multiple)
+      const result = results.find((r) => r.model === model);
+      const tr = result?.testResults?.find((t) => t.file === file);
+
+      if (tr) {
+        const total = tr.passed + tr.failed;
+        const cell = `${tr.passed}/${total}`;
+        row += cell.padStart(modelColWidth) + ' ';
+      } else {
+        row += '-'.padStart(modelColWidth) + ' ';
+      }
+    }
+
+    console.error(row);
+  }
+
+  console.error('─'.repeat(fileColWidth + models.length * (modelColWidth + 1)));
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});