@vitronai/themis 0.1.0-beta.0 → 0.1.0-beta.2

package/src/artifacts.js

@@ -6,6 +6,9 @@ const LAST_RUN_FILE = 'last-run.json';
 const FAILED_TESTS_FILE = 'failed-tests.json';
 const RUN_DIFF_FILE = 'run-diff.json';
 const RUN_HISTORY_FILE = 'run-history.json';
+const FIX_HANDOFF_FILE = 'fix-handoff.json';
+const GENERATE_MAP_FILE = 'generate-map.json';
+const GENERATE_BACKLOG_FILE = 'generate-backlog.json';
 
 function writeRunArtifacts(cwd, result) {
   const artifactDir = path.join(cwd, ARTIFACT_DIR);
@@ -19,7 +22,8 @@ function writeRunArtifacts(cwd, result) {
     lastRun: path.join(ARTIFACT_DIR, LAST_RUN_FILE),
     failedTests: path.join(ARTIFACT_DIR, FAILED_TESTS_FILE),
     runDiff: path.join(ARTIFACT_DIR, RUN_DIFF_FILE),
-    runHistory: path.join(ARTIFACT_DIR, RUN_HISTORY_FILE)
+    runHistory: path.join(ARTIFACT_DIR, RUN_HISTORY_FILE),
+    fixHandoff: path.join(ARTIFACT_DIR, FIX_HANDOFF_FILE)
   };
 
   result.artifacts = {
@@ -79,13 +83,26 @@ function writeRunArtifacts(cwd, result) {
   });
   fs.writeFileSync(historyPath, `${stringifyArtifact(nextHistory)}\n`, 'utf8');
 
+  const fixHandoffPath = path.join(artifactDir, FIX_HANDOFF_FILE);
+  let fixHandoff = null;
+  if (failedTests.length > 0) {
+    fixHandoff = buildFixHandoffPayload(cwd, result, {
+      runId,
+      failedTests,
+      relativePaths
+    });
+    fs.writeFileSync(fixHandoffPath, `${stringifyArtifact(fixHandoff)}\n`, 'utf8');
+  }
+
   return {
     runPath,
     failuresPath,
     diffPath,
     historyPath,
+    fixHandoffPath,
     failuresPayload,
-    comparison
+    comparison,
+    fixHandoff
   };
 }
 
@@ -193,6 +210,167 @@ function readJsonIfExists(filePath) {
   }
 }
 
+function buildFixHandoffPayload(cwd, result, context) {
+  const generateMap = readJsonIfExists(path.join(cwd, ARTIFACT_DIR, GENERATE_MAP_FILE));
+  const generateBacklog = readJsonIfExists(path.join(cwd, ARTIFACT_DIR, GENERATE_BACKLOG_FILE));
+  const mapEntries = Array.isArray(generateMap && generateMap.entries) ? generateMap.entries : [];
+  const backlogItems = Array.isArray(generateBacklog && generateBacklog.items) ? generateBacklog.items : [];
+  const byGeneratedTest = new Map();
+
+  for (const entry of mapEntries) {
+    if (!entry || !entry.testFile) {
+      continue;
+    }
+    byGeneratedTest.set(path.resolve(cwd, entry.testFile), entry);
+  }
+
+  const groupedItems = new Map();
+  for (const failedTest of context.failedTests) {
+    const generatedEntry = byGeneratedTest.get(path.resolve(failedTest.file));
+    if (!generatedEntry) {
+      continue;
+    }
+
+    const reason = String(failedTest.message || '');
+    const category = classifyFixCategory(reason);
+    const backlogMatch = backlogItems.find((item) => item && item.sourceFile === generatedEntry.sourceFile);
+    const groupKey = `${generatedEntry.testFile}:${category}`;
+    if (groupedItems.has(groupKey)) {
+      const existing = groupedItems.get(groupKey);
+      existing.failureCount += 1;
+      existing.failedTests.push(failedTest.fullName);
+      continue;
+    }
+
+    groupedItems.set(groupKey, {
+      file: failedTest.file,
+      name: failedTest.name,
+      fullName: failedTest.fullName,
+      message: reason,
+      testFile: generatedEntry.testFile,
+      sourceFile: generatedEntry.sourceFile,
+      moduleKind: generatedEntry.moduleKind,
+      confidence: generatedEntry.confidence,
+      scenarios: Array.isArray(generatedEntry.scenarios) ? generatedEntry.scenarios.map((scenario) => scenario.kind) : [],
+      hintsFile: generatedEntry.hintsFile || (backlogMatch ? backlogMatch.hintsFile : null),
+      category,
+      failureCount: 1,
+      failedTests: [failedTest.fullName],
+      repairStrategy: resolveRepairStrategy(category, generatedEntry, backlogMatch),
+      candidateFiles: buildFixCandidateFiles(generatedEntry, backlogMatch),
+      suggestedAction: resolveFixAction(category, generatedEntry, backlogMatch),
+      suggestedCommand: resolveFixCommand(category, generatedEntry, backlogMatch),
+      autofixCommand: resolveAutofixCommand(category, generatedEntry, backlogMatch)
+    });
+  }
+
+  const items = [...groupedItems.values()];
+
+  const summary = {
+    totalFailures: Number(result.summary?.failed || 0),
+    generatedFailures: items.length,
+    staleSources: items.filter((item) => item.category === 'source-drift').length,
+    contractFailures: items.filter((item) => item.category === 'generated-contract-failure').length
+  };
+
+  return {
+    schema: 'themis.fix.handoff.v1',
+    runId: context.runId,
+    createdAt: new Date().toISOString(),
+    summary,
+    artifacts: {
+      failedTests: context.relativePaths.failedTests,
+      generateMap: path.join(ARTIFACT_DIR, GENERATE_MAP_FILE),
+      generateBacklog: path.join(ARTIFACT_DIR, GENERATE_BACKLOG_FILE),
+      fixHandoff: context.relativePaths.fixHandoff
+    },
+    items,
+    nextActions: buildFixNextActions(summary)
+  };
+}
+
+function classifyFixCategory(message) {
+  const lower = String(message || '').toLowerCase();
+  if (
+    lower.includes('generated from source file has changed since scan')
+    || (lower.includes('stale') && lower.includes('npx themis generate'))
+  ) {
+    return 'source-drift';
+  }
+  return 'generated-contract-failure';
+}
+
+function resolveFixAction(category, entry, backlogMatch) {
+  if (category === 'source-drift') {
+    return `Regenerate the generated test for ${entry.sourceFile}.`;
+  }
+  if (backlogMatch && backlogMatch.suggestedAction) {
+    return backlogMatch.suggestedAction;
+  }
+  return `Inspect the generated contract and supporting hints for ${entry.sourceFile}.`;
+}
+
+function resolveFixCommand(category, entry, backlogMatch) {
+  if (backlogMatch && backlogMatch.suggestedCommand) {
+    return backlogMatch.suggestedCommand;
+  }
+  if (entry && entry.sourceFile) {
+    return `npx themis generate ${entry.sourceFile} --update`;
+  }
+  return null;
+}
+
+function resolveAutofixCommand(category, entry, backlogMatch) {
+  if (backlogMatch && backlogMatch.suggestedCommand) {
+    return backlogMatch.suggestedCommand;
+  }
+  if (category === 'source-drift' && entry && entry.sourceFile) {
+    return `npx themis generate ${entry.sourceFile} --update && npx themis test --match ${JSON.stringify(path.basename(entry.testFile || entry.sourceFile))}`;
+  }
+  if (entry && entry.sourceFile) {
+    return `npx themis generate ${entry.sourceFile} --update`;
+  }
+  return null;
+}
+
+function resolveRepairStrategy(category, entry, backlogMatch) {
+  if (category === 'source-drift') {
+    return 'regenerate-source';
+  }
+  if (backlogMatch && backlogMatch.hintsFile) {
+    return 'tighten-hints';
+  }
+  return 'inspect-contract';
+}
+
+function buildFixCandidateFiles(entry, backlogMatch) {
+  const files = [];
+  if (entry && entry.sourceFile) {
+    files.push(entry.sourceFile);
+  }
+  if (entry && entry.testFile) {
+    files.push(entry.testFile);
+  }
+  if (entry && entry.hintsFile) {
+    files.push(entry.hintsFile);
+  } else if (backlogMatch && backlogMatch.hintsFile) {
+    files.push(backlogMatch.hintsFile);
+  }
+  return [...new Set(files)];
+}
+
+function buildFixNextActions(summary) {
+  const actions = [];
+  if (summary.generatedFailures > 0) {
+    actions.push('Review .themis/fix-handoff.json and start with source-drift items.');
+    actions.push('Regenerate narrow targets before rerunning the full suite.');
+  }
+  if (summary.generatedFailures === 0) {
+    actions.push('No generated-test repair work was detected in this run.');
+  }
+  return actions;
+}
+
 function roundDuration(value) {
   return Math.round(Number(value || 0) * 100) / 100;
 }

package/src/cli.js

@@ -1,8 +1,11 @@
+const path = require('path');
 const { loadConfig } = require('./config');
 const { discoverTests } = require('./discovery');
 const { runTests } = require('./runner');
 const { printSpec, printJson, printAgent, printNext, writeHtmlReport } = require('./reporter');
 const { runInit } = require('./init');
+const { runMigrate } = require('./migrate');
+const { generateTestsFromSource, writeGenerateArtifacts } = require('./generate');
 const { writeRunArtifacts, readFailedTestsArtifact } = require('./artifacts');
 const { buildStabilityReport, hasStabilityBreaches } = require('./stability');
 const { verdictReveal } = require('./verdict');
@@ -22,14 +25,103 @@ async function main(argv) {
     return;
   }
 
+  if (command === 'generate' || command === 'scan') {
+    const flags = parseGenerateFlags(argv.slice(1));
+    if (!flags.json) {
+      printBanner('next');
+    }
+    const summary = generateTestsFromSource(cwd, {
+      targetDir: flags.targetDir || 'src',
+      outputDir: flags.outputDir,
+      force: Boolean(flags.force),
+      strict: Boolean(flags.strict),
+      writeHints: Boolean(flags.writeHints),
+      review: Boolean(flags.review),
+      update: Boolean(flags.update),
+      clean: Boolean(flags.clean),
+      changed: Boolean(flags.changed),
+      plan: Boolean(flags.plan),
+      failOnSkips: Boolean(flags.failOnSkips),
+      failOnConflicts: Boolean(flags.failOnConflicts),
+      requireConfidence: flags.requireConfidence || null,
+      scenario: flags.scenario || null,
+      minConfidence: flags.minConfidence || null,
+      files: flags.files || null,
+      matchSource: flags.matchSource || null,
+      matchExport: flags.matchExport || null,
+      include: flags.include || null,
+      exclude: flags.exclude || null
+    });
+    const { payload } = writeGenerateArtifacts(summary, cwd);
+    if (flags.json) {
+      console.log(JSON.stringify(payload));
+      if (summary.gates.failed) {
+        process.exitCode = 1;
+      }
+      return;
+    }
+    printGenerateSummary(summary, cwd);
+    if (summary.gates.failed) {
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (command === 'migrate') {
+    const migrateFlags = parseMigrateFlags(argv.slice(1));
+    const result = runMigrate(cwd, migrateFlags.source, migrateFlags);
+    console.log(`Themis migration scaffold created for ${result.source}.`);
+    console.log(`Config: ${formatCliPath(cwd, result.configPath)}`);
+    console.log(`Setup: ${formatCliPath(cwd, result.setupPath)}`);
+    console.log(`Compat: ${formatCliPath(cwd, result.compatPath)}`);
+    if (result.packageUpdated && result.packageJsonPath) {
+      console.log(`Scripts: updated ${formatCliPath(cwd, result.packageJsonPath)} with test:themis`);
+    }
+    if (result.rewriteImports) {
+      console.log(`Imports: rewrote ${result.rewrittenFiles.length} file(s) to local Themis compatibility imports.`);
+    }
+    console.log('Runtime compatibility is enabled for @jest/globals, vitest, and @testing-library/react imports.');
+    console.log('Next: run npx themis test or npm run test:themis');
+    return;
+  }
+
   if (command !== 'test') {
     printUsage();
     process.exitCode = 1;
     return;
   }
 
-  const config = loadConfig(cwd);
   const flags = parseFlags(argv.slice(1));
+  const watchIsolation = flags.watch ? (flags.isolation || 'in-process') : flags.isolation;
+  const watchCache = flags.watch ? (flags.cache !== undefined ? flags.cache : watchIsolation === 'in-process') : flags.cache;
+  if (watchIsolation) {
+    validateIsolation(watchIsolation);
+  }
+  if (flags.watch) {
+    await runWatchMode({
+      cwd,
+      cliArgs: argv.slice(1),
+      inProcess: watchIsolation === 'in-process',
+      executeInProcess: async (cliArgs) => {
+        const rerunFlags = parseFlags(cliArgs);
+        rerunFlags.watch = false;
+        if (!rerunFlags.isolation && watchIsolation) {
+          rerunFlags.isolation = watchIsolation;
+        }
+        if (rerunFlags.cache === undefined && watchCache !== undefined) {
+          rerunFlags.cache = watchCache;
+        }
+        await executeTestRun(cwd, rerunFlags);
+      }
+    });
+    return;
+  }
+
+  await executeTestRun(cwd, flags);
+}
+
+async function executeTestRun(cwd, flags) {
+  const config = loadConfig(cwd);
 
   if (flags.match) {
     validateRegex(flags.match);
@@ -43,12 +135,8 @@ async function main(argv) {
   validateStabilityRuns(flags.stability);
   const environment = resolveEnvironment(flags, config);
   validateEnvironment(environment, flags.environment, config.environment);
-  if (flags.watch) {
-    await runWatchMode({
-      cwd,
-      cliArgs: argv.slice(1)
-    });
-    return;
+  if (flags.isolation) {
+    validateIsolation(flags.isolation);
   }
   printBanner(reporter);
   const maxWorkers = resolveWorkerCount(flags.workers, config.maxWorkers);
@@ -96,7 +184,8 @@ async function main(argv) {
       environment,
       setupFiles: config.setupFiles,
       tsconfigPath: config.tsconfigPath,
-      updateSnapshots: Boolean(flags.updateSnapshots)
+      isolation: flags.isolation || 'worker',
+      cache: Boolean(flags.cache)
     });
     runResults.push(runResult);
   }
@@ -200,8 +289,7 @@ function parseFlags(args) {
       continue;
     }
     if (token === '-u' || token === '--update-snapshots') {
-      flags.updateSnapshots = true;
-      continue;
+      throw new Error('Snapshots have been removed from Themis. Replace -u/--update-snapshots with direct assertions or generated contract flows.');
     }
     if (token === '--reporter') {
       flags.reporter = requireFlagValue(args, i, '--reporter');
@@ -238,7 +326,146 @@ function parseFlags(args) {
       i += 1;
       continue;
     }
+    if (token === '--isolation') {
+      flags.isolation = requireFlagValue(args, i, '--isolation');
+      i += 1;
+      continue;
+    }
+    if (token === '--cache') {
+      flags.cache = true;
+      continue;
+    }
+    if (token.startsWith('-')) {
+      throw new Error(`Unsupported test option: ${token}`);
+    }
+  }
+  return flags;
+}
+
+function parseMigrateFlags(args) {
+  const flags = {
+    source: args[0],
+    rewriteImports: false
+  };
+
+  for (let i = 1; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === '--rewrite-imports') {
+      flags.rewriteImports = true;
+    }
+  }
+
+  return flags;
+}
+
+function parseGenerateFlags(args) {
+  const flags = {};
+
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === '--json') {
+      flags.json = true;
+      continue;
+    }
+    if (token === '--plan') {
+      flags.plan = true;
+      flags.review = true;
+      flags.json = true;
+      continue;
+    }
+    if (token === '--output') {
+      flags.outputDir = requireFlagValue(args, i, '--output');
+      i += 1;
+      continue;
+    }
+    if (token === '--write-hints') {
+      flags.writeHints = true;
+      continue;
+    }
+    if (token === '--files') {
+      flags.files = requireFlagValue(args, i, '--files');
+      i += 1;
+      continue;
+    }
+    if (token === '--match-source') {
+      flags.matchSource = requireFlagValue(args, i, '--match-source');
+      i += 1;
+      continue;
+    }
+    if (token === '--match-export') {
+      flags.matchExport = requireFlagValue(args, i, '--match-export');
+      i += 1;
+      continue;
+    }
+    if (token === '--scenario') {
+      flags.scenario = requireFlagValue(args, i, '--scenario');
+      i += 1;
+      continue;
+    }
+    if (token === '--require-confidence') {
+      flags.requireConfidence = requireFlagValue(args, i, '--require-confidence');
+      i += 1;
+      continue;
+    }
+    if (token === '--min-confidence') {
+      flags.minConfidence = requireFlagValue(args, i, '--min-confidence');
+      i += 1;
+      continue;
+    }
+    if (token === '--include') {
+      flags.include = requireFlagValue(args, i, '--include');
+      i += 1;
+      continue;
+    }
+    if (token === '--exclude') {
+      flags.exclude = requireFlagValue(args, i, '--exclude');
+      i += 1;
+      continue;
+    }
+    if (token === '--force') {
+      flags.force = true;
+      continue;
+    }
+    if (token === '--strict') {
+      flags.strict = true;
+      continue;
+    }
+    if (token === '--fail-on-skips') {
+      flags.failOnSkips = true;
+      continue;
+    }
+    if (token === '--fail-on-conflicts') {
+      flags.failOnConflicts = true;
+      continue;
+    }
+    if (token === '--review') {
+      flags.review = true;
+      continue;
+    }
+    if (token === '--update') {
+      flags.update = true;
+      continue;
+    }
+    if (token === '--clean') {
+      flags.clean = true;
+      continue;
+    }
+    if (token === '--changed') {
+      flags.changed = true;
+      continue;
+    }
+    if (token.startsWith('--')) {
+      throw new Error(
+        'Unsupported generate option: ' + token +
+        '. Use --json, --plan, --output <dir>, --files <paths>, --match-source <regex>, --match-export <regex>, --scenario <name>, --min-confidence <level>, --require-confidence <level>, --include <regex>, --exclude <regex>, --force, --strict, --write-hints, --fail-on-skips, --fail-on-conflicts, --review, --update, --clean, or --changed.'
+      );
+    }
+    if (flags.targetDir) {
+      throw new Error(`Unexpected extra argument: ${token}`);
+    }
+    flags.targetDir = token;
   }
+
   return flags;
 }
 
@@ -299,6 +526,13 @@ function validateWorkerCount(flagValue, configValue) {
   throw new Error(`Invalid config maxWorkers value: ${String(configValue)}. Use a positive integer.`);
 }
 
+function validateIsolation(value) {
+  if (value === 'worker' || value === 'in-process') {
+    return;
+  }
+  throw new Error(`Unsupported --isolation value: ${value}. Use one of: worker, in-process.`);
+}
+
 function resolveWorkerCount(flagValue, configValue) {
   const sourceValue = flagValue !== undefined ? flagValue : configValue;
   return Number(sourceValue);
@@ -326,7 +560,152 @@ function printUsage() {
   console.log('Usage: themis <command> [options]');
   console.log('Commands:');
   console.log('  init                    Create themis.config.json and sample tests');
-  console.log('  test [--json] [--agent] [--next] [--reporter spec|next|json|agent|html] [--workers N] [--stability N] [--environment node|jsdom] [-w|--watch] [-u|--update-snapshots] [--html-output path] [--match regex] [--rerun-failed] [--no-memes] [--lexicon classic|themis]');
+  console.log('  generate [path]         Scan source files and generate Themis contract tests');
+  console.log('                         Options: [--json] [--plan] [--output path] [--files a,b] [--match-source regex] [--match-export regex] [--scenario name] [--min-confidence level] [--require-confidence level] [--include regex] [--exclude regex] [--review] [--update] [--clean] [--changed] [--force] [--strict] [--write-hints] [--fail-on-skips] [--fail-on-conflicts]');
+  console.log('  scan [path]             Alias for generate');
+  console.log('  migrate <jest|vitest> [--rewrite-imports]   Scaffold an incremental migration bridge for existing suites');
+  console.log('  test [--json] [--agent] [--next] [--reporter spec|next|json|agent|html] [--workers N] [--stability N] [--environment node|jsdom] [--isolation worker|in-process] [--cache] [-w|--watch] [--html-output path] [--match regex] [--rerun-failed] [--no-memes] [--lexicon classic|themis]');
+}
+
+function printGenerateSummary(summary, cwd) {
+  const target = formatCliPath(cwd, summary.targetDir);
+  const output = formatCliPath(cwd, summary.outputDir);
+  console.log('THEMIS CODE SCAN COMPLETE');
+  console.log(`  target: ${target}`);
+  console.log(`  output: ${output}`);
+  console.log(`  scanned: ${summary.scannedFiles.length}`);
+  console.log(`  generated: ${summary.generatedFiles.length}`);
+  console.log(`  created: ${summary.createdFiles.length}`);
+  console.log(`  updated: ${summary.updatedFiles.length}`);
+  console.log(`  unchanged: ${summary.unchangedFiles.length}`);
+  console.log(`  removed: ${summary.removedFiles.length}`);
+  console.log(`  skipped: ${summary.skippedFiles.length}`);
+  console.log(`  conflicts: ${summary.conflictFiles.length}`);
+
+  if (summary.plan || summary.review || summary.update || summary.clean || summary.changed || summary.writeHints) {
+    console.log('');
+    console.log('Mode');
+    console.log(`  plan: ${summary.plan ? 'yes' : 'no'}`);
+    console.log(`  review: ${summary.review ? 'yes' : 'no'}`);
+    console.log(`  update: ${summary.update ? 'yes' : 'no'}`);
+    console.log(`  clean: ${summary.clean ? 'yes' : 'no'}`);
+    console.log(`  changed: ${summary.changed ? 'yes' : 'no'}`);
+    console.log(`  write-hints: ${summary.writeHints ? 'yes' : 'no'}`);
+  }
+
+  if (summary.filters.scenario || summary.filters.minConfidence) {
+    console.log('');
+    console.log('Steering');
+    console.log(`  scenario: ${summary.filters.scenario || '(any)'}`);
+    console.log(`  min-confidence: ${summary.filters.minConfidence || '(any)'}`);
+  }
+
+  if (summary.gates.failed || summary.gates.strict || summary.gates.failOnSkips || summary.gates.requireConfidence) {
+    console.log('');
+    console.log('Gates');
+    console.log(`  strict: ${summary.gates.strict ? 'yes' : 'no'}`);
+    console.log(`  fail-on-skips: ${summary.gates.failOnSkips ? 'yes' : 'no'}`);
+    console.log(`  fail-on-conflicts: ${summary.gates.failOnConflicts ? 'yes' : 'no'}`);
+    console.log(`  require-confidence: ${summary.gates.requireConfidence || '(none)'}`);
+    console.log(`  status: ${summary.gates.failed ? 'failed' : 'passed'}`);
+  }
+
+  if (summary.generatedFiles.length > 0) {
+    console.log('');
+    console.log('Selected Generated Files');
+    for (const file of summary.generatedFiles.slice(0, 10)) {
+      console.log(`  ${formatCliPath(cwd, file)}`);
+    }
+    if (summary.generatedFiles.length > 10) {
+      console.log(`  ... ${summary.generatedFiles.length - 10} more`);
+    }
+  }
+
+  if (summary.removedFiles.length > 0) {
+    console.log('');
+    console.log('Removed Files');
+    for (const file of summary.removedFiles.slice(0, 10)) {
+      console.log(`  ${formatCliPath(cwd, file)}`);
+    }
+    if (summary.removedFiles.length > 10) {
+      console.log(`  ... ${summary.removedFiles.length - 10} more`);
+    }
+  }
+
+  if (summary.skippedFiles.length > 0) {
+    console.log('');
+    console.log('Skipped Files');
+    for (const entry of summary.skippedFiles.slice(0, 5)) {
+      console.log(`  ${formatCliPath(cwd, entry.file)} (${entry.reason})`);
+    }
+    if (summary.skippedFiles.length > 5) {
+      console.log(`  ... ${summary.skippedFiles.length - 5} more`);
+    }
+  }
+
+  if (summary.conflictFiles.length > 0) {
+    console.log('');
+    console.log('Conflicting Files');
+    for (const file of summary.conflictFiles.slice(0, 5)) {
+      console.log(`  ${formatCliPath(cwd, file)}`);
+    }
+    if (summary.conflictFiles.length > 5) {
+      console.log(`  ... ${summary.conflictFiles.length - 5} more`);
+    }
+  }
+
+  if (summary.hintFiles.created.length > 0 || summary.hintFiles.updated.length > 0 || summary.hintFiles.unchanged.length > 0) {
+    console.log('');
+    console.log('Hint Files');
+    console.log(`  created: ${summary.hintFiles.created.length}`);
+    console.log(`  updated: ${summary.hintFiles.updated.length}`);
+    console.log(`  unchanged: ${summary.hintFiles.unchanged.length}`);
+    for (const file of [...summary.hintFiles.created, ...summary.hintFiles.updated].slice(0, 5)) {
+      console.log(`  ${formatCliPath(cwd, file)}`);
+    }
+  }
+
+  if (summary.backlog.summary.total > 0) {
+    console.log('');
+    console.log('Backlog');
+    console.log(`  total: ${summary.backlog.summary.total}`);
+    console.log(`  errors: ${summary.backlog.summary.errors}`);
+    console.log(`  warnings: ${summary.backlog.summary.warnings}`);
+    for (const item of summary.backlog.items.slice(0, 5)) {
+      console.log(`  ${item.severity.toUpperCase()} ${formatCliPath(cwd, item.sourceFile)} (${item.reason})`);
+    }
+    if (summary.backlog.items.length > 5) {
+      console.log(`  ... ${summary.backlog.items.length - 5} more`);
+    }
+  }
+
+  if (summary.gates.failed) {
+    console.log('');
+    console.log('Gate Failures');
+    for (const failure of summary.gates.failures) {
+      console.log(`  ${failure.code}: ${failure.message}`);
+    }
+  }
+
+  console.log('');
+  console.log('Prompt');
+  console.log(`  ${summary.prompt}`);
+
+  console.log('');
+  console.log('Artifacts');
+  console.log(`  ${formatCliPath(cwd, summary.artifacts.generateResult)}`);
+  console.log(`  ${formatCliPath(cwd, summary.artifacts.generateHandoff)}`);
+  console.log(`  ${formatCliPath(cwd, summary.artifacts.generateBacklog)}`);
+  console.log(`  ${formatCliPath(cwd, summary.artifacts.generateMap)}`);
+
+  console.log('');
+  console.log('Next Step');
+  console.log(`  Run: ${summary.review ? summary.gates.failed ? 'resolve backlog items, rerun generate, then npx themis test' : 'npx themis generate ' + target + ' && npx themis test' : summary.gates.failed ? 'resolve backlog items, rerun generate, then npx themis test' : 'npx themis test'}`);
+}
+
+function formatCliPath(cwd, targetPath) {
+  const relative = path.relative(cwd, targetPath);
+  return relative && !relative.startsWith('..') ? relative.split(path.sep).join('/') : targetPath;
 }
 
 function printBanner(reporter) {