@delegance/claude-autopilot 1.0.0-alpha.6 → 1.0.0-alpha.7

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.0.0-alpha.7
+
+### Added
+
+- **`autopilot hook install`** — writes a `pre-push` git hook that runs `autoregress run` before every push; `hook uninstall` removes it; `hook status` shows current state; `--force` overwrites existing hook
+- **`autoregress diff`** — colored snapshot viewer showing line-by-line JSON diffs between current output and baselines; exits 1 if any diffs found (never modifies baselines — use `update` for that)
+- **`autoregress generate --files <list>`** — explicit comma-separated file list bypasses git detection; generates baselines for any src file on demand
+- **Real baselines** — `tests/snapshots/*.snap.ts` + baselines for `serializer.ts`, `import-scanner.ts`, `impact-selector.ts`, and `sarif.ts` — alpha.6 infrastructure now self-testing via snapshots
+
 ## 1.0.0-alpha.6
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delegance/claude-autopilot",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0-alpha.7",
   "type": "module",
   "description": "Claude Code automation pipeline: spec → plan → implement → validate → PR",
   "keywords": ["claude", "autopilot", "ai", "pipeline", "code-review", "cli"],

package/scripts/autoregress.ts

@@ -2,6 +2,7 @@
 // scripts/autoregress.ts
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import * as os from 'node:os';
 import { execSync, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { selectSnapshots } from '../src/snapshots/impact-selector.ts';
@@ -19,6 +20,22 @@ function loadJson<T>(p: string, fallback: T): T {
   try { return JSON.parse(fs.readFileSync(p, 'utf8')) as T; } catch { return fallback; }
 }
 
+export function diffBaselines(baselineJson: string, currentJson: string): string[] {
+  if (baselineJson === currentJson) return [];
+  const baselineLines = baselineJson.split('\n');
+  const currentLines = currentJson.split('\n');
+  const lines: string[] = [];
+  const maxLen = Math.max(baselineLines.length, currentLines.length);
+  for (let i = 0; i < maxLen; i++) {
+    const bLine = baselineLines[i];
+    const cLine = currentLines[i];
+    if (bLine === cLine) continue;
+    if (bLine !== undefined) lines.push(`- ${bLine}`);
+    if (cLine !== undefined) lines.push(`+ ${cLine}`);
+  }
+  return lines;
+}
+
 function getChangedFiles(since?: string): string[] | null {
   try {
     const base = since
@@ -155,12 +172,15 @@ Write a snapshot test file. Requirements:
 5. Baseline loading pattern (use slug {slug}):
    const SLUG = '{slug}';
    import { fileURLToPath } from 'node:url';
+   import * as path from 'node:path';
    const baselineRaw = process.env.CAPTURE_BASELINE === '1' ? '{}' : fs.readFileSync(fileURLToPath(new URL('./baselines/{slug}.json', import.meta.url)), 'utf8');
    const baseline = JSON.parse(baselineRaw);
    const captured: Record<string, unknown> = {};
    process.on('exit', () => {
      if (process.env.CAPTURE_BASELINE === '1') {
-       const p = fileURLToPath(new URL('./baselines/{slug}.json', import.meta.url));
+       const p = process.env.AUTOREGRESS_TEMP_BASELINE_DIR
+         ? path.join(process.env.AUTOREGRESS_TEMP_BASELINE_DIR, '{slug}.json')
+         : fileURLToPath(new URL('./baselines/{slug}.json', import.meta.url));
        fs.writeFileSync(p, JSON.stringify(captured, null, 2), 'utf8');
      }
    });
@@ -175,13 +195,24 @@ async function cmdGenerate(args: string[]): Promise<number> {
 
   const sinceIdx = args.indexOf('--since');
   const since = sinceIdx >= 0 ? args[sinceIdx + 1] : undefined;
-  const changed = getChangedFiles(since);
-  if (!changed) { console.error('[autoregress generate] could not determine changed files'); return 1; }
-
-  const srcFiles = changed.filter(f => f.startsWith('src/') && f.endsWith('.ts'));
-  if (srcFiles.length === 0) {
-    console.log('[autoregress generate] no src/*.ts files changed — nothing to generate');
-    return 0;
+  const filesIdx = args.indexOf('--files');
+  const filesArg = filesIdx >= 0 ? args[filesIdx + 1] : undefined;
+
+  let srcFiles: string[];
+  if (filesArg) {
+    srcFiles = filesArg.split(',').map(f => f.trim()).filter(f => f.startsWith('src/') && f.endsWith('.ts'));
+    if (srcFiles.length === 0) {
+      console.error('[autoregress generate] --files must contain at least one src/*.ts path');
+      return 1;
+    }
+  } else {
+    const changed = getChangedFiles(since);
+    if (!changed) { console.error('[autoregress generate] could not determine changed files'); return 1; }
+    srcFiles = changed.filter(f => f.startsWith('src/') && f.endsWith('.ts'));
+    if (srcFiles.length === 0) {
+      console.log('[autoregress generate] no src/*.ts files changed — nothing to generate');
+      return 0;
+    }
   }
 
   console.log(`[autoregress generate] generating snapshots for ${srcFiles.length} file(s)`);
@@ -257,12 +288,98 @@ async function cmdGenerate(args: string[]): Promise<number> {
   return 0;
 }
 
-const [,, subcmd, ...rest] = process.argv;
-switch (subcmd) {
-  case 'run': process.exit(cmdRun(rest)); break;
-  case 'update': process.exit(cmdUpdate(rest)); break;
-  case 'generate': process.exit(await cmdGenerate(rest)); break;
-  default:
-    console.error(`[autoregress] unknown subcommand: ${subcmd ?? '(none)'}`);
-    process.exit(1);
+function cmdDiff(args: string[]): number {
+  const runAll = args.includes('--all');
+  const snapIdx = args.indexOf('--snapshot');
+  const slug = snapIdx >= 0 ? args[snapIdx + 1] : undefined;
+  const sinceIdx = args.indexOf('--since');
+  const since = sinceIdx >= 0 ? args[sinceIdx + 1] : undefined;
+
+  const index = loadJson<Record<string, string[]>>(INDEX_PATH, {});
+  const importMap = loadJson<Record<string, string[]>>(IMPORT_MAP_PATH, {});
+  const snapFiles = slug
+    ? [path.join('tests', 'snapshots', `${slug}.snap.ts`)]
+    : allSnapFiles();
+
+  let selected: string[];
+  if (runAll || slug || snapFiles.length === 0) {
+    selected = snapFiles;
+  } else {
+    const changed = getChangedFiles(since);
+    selected = changed ? selectSnapshots(changed, snapFiles, index, importMap).selected : snapFiles;
+  }
+
+  if (selected.length === 0) {
+    console.log('[autoregress diff] no snapshots to diff');
+    return 0;
+  }
+
+  const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+  const red = useColor ? '\x1b[31m' : '';
+  const green = useColor ? '\x1b[32m' : '';
+  const reset = useColor ? '\x1b[0m' : '';
+
+  let changedCount = 0;
+  for (const snap of selected) {
+    const slug_ = path.basename(snap, '.snap.ts');
+    const baselinePath = path.join(BASELINES_DIR, `${slug_}.json`);
+
+    if (!fs.existsSync(baselinePath)) {
+      console.log(`  ${snap} — ${red}no baseline${reset}`);
+      continue;
+    }
+
+    const tmpBaselinesDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ar-diff-'));
+    const tmpBaselinePath = path.join(tmpBaselinesDir, `${slug_}.json`);
+    fs.copyFileSync(baselinePath, tmpBaselinePath);
+
+    const absSnap = path.join(ROOT, snap);
+    const captureResult = spawnSync('node', ['--test', '--import', 'tsx', absSnap], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: ROOT,
+      env: { ...process.env, CAPTURE_BASELINE: '1', AUTOREGRESS_TEMP_BASELINE_DIR: tmpBaselinesDir },
+    });
+
+    const baselineJson = fs.readFileSync(baselinePath, 'utf8');
+    const captureOk = fs.existsSync(tmpBaselinePath);
+    const currentJson = captureOk ? fs.readFileSync(tmpBaselinePath, 'utf8') : null;
+    if (!captureOk && captureResult.status !== 0) {
+      const stderr = captureResult.stderr?.toString().trim();
+      if (stderr) console.error(`    ${stderr.slice(0, 120)}`);
+    }
+    fs.rmSync(tmpBaselinesDir, { recursive: true, force: true });
+
+    if (!currentJson) {
+      console.log(`  ${snap} — ${red}capture failed${reset}`);
+      continue;
+    }
+
+    const diffLines = diffBaselines(baselineJson, currentJson);
+    if (diffLines.length === 0) {
+      console.log(`  ${snap} — ${green}✓ no changes${reset}`);
+    } else {
+      changedCount++;
+      console.log(`  ${snap}`);
+      for (const line of diffLines) {
+        if (line.startsWith('-')) console.log(`    ${red}${line}${reset}`);
+        else if (line.startsWith('+')) console.log(`    ${green}${line}${reset}`);
+        else console.log(`    ${line}`);
+      }
+    }
+  }
+
+  return changedCount > 0 ? 1 : 0;
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+  const [,, subcmd, ...rest] = process.argv;
+  switch (subcmd) {
+    case 'run': process.exit(cmdRun(rest)); break;
+    case 'update': process.exit(cmdUpdate(rest)); break;
+    case 'generate': process.exit(await cmdGenerate(rest)); break;
+    case 'diff': process.exit(cmdDiff(rest)); break;
+    default:
+      console.error(`[autoregress] unknown subcommand: ${subcmd ?? '(none)'}`);
+      process.exit(1);
+  }
 }

package/src/cli/hook.ts

@@ -0,0 +1,79 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+const HOOK_CONTENT = `#!/bin/sh
+# autopilot pre-push hook — runs impact-selected snapshots before push
+npx tsx scripts/autoregress.ts run
+`;
+
+function findGitDir(cwd: string): string | null {
+  let dir = path.resolve(cwd);
+  for (let i = 0; i < 10; i++) {
+    const candidate = path.join(dir, '.git');
+    if (fs.existsSync(candidate)) {
+      const stat = fs.statSync(candidate);
+      if (stat.isDirectory()) return candidate;
+      if (stat.isFile()) {
+        const content = fs.readFileSync(candidate, 'utf8');
+        const match = content.match(/^gitdir:\s*(.+)/m);
+        if (match) return path.resolve(dir, match[1]!.trim());
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+
+export async function runHook(
+  sub: string,
+  options: { cwd?: string; force?: boolean } = {},
+): Promise<number> {
+  const cwd = options.cwd ?? process.cwd();
+  const gitDir = findGitDir(cwd);
+
+  if (!gitDir) {
+    console.error('[hook] not inside a git repository');
+    return 1;
+  }
+
+  const hookPath = path.join(gitDir, 'hooks', 'pre-push');
+
+  switch (sub) {
+    case 'install': {
+      if (fs.existsSync(hookPath) && !options.force) {
+        console.error(`[hook] pre-push hook already exists at ${hookPath}`);
+        console.error('       Use --force to overwrite.');
+        return 1;
+      }
+      fs.mkdirSync(path.dirname(hookPath), { recursive: true });
+      fs.writeFileSync(hookPath, HOOK_CONTENT, 'utf8');
+      fs.chmodSync(hookPath, 0o755);
+      console.log(`[hook] installed pre-push hook at ${hookPath}`);
+      return 0;
+    }
+    case 'uninstall': {
+      if (!fs.existsSync(hookPath)) {
+        console.log('[hook] no pre-push hook installed');
+        return 0;
+      }
+      fs.rmSync(hookPath);
+      console.log(`[hook] removed ${hookPath}`);
+      return 0;
+    }
+    case 'status': {
+      if (fs.existsSync(hookPath)) {
+        console.log(`[hook] installed at ${hookPath}`);
+        console.log(fs.readFileSync(hookPath, 'utf8'));
+      } else {
+        console.log('[hook] not installed');
+      }
+      return 0;
+    }
+    default:
+      console.error(`[hook] unknown subcommand: ${sub}`);
+      console.error('Usage: autopilot hook <install|uninstall|status> [--force]');
+      return 1;
+  }
+}

package/src/cli/index.ts

@@ -118,6 +118,15 @@ switch (subcommand) {
     break;
   }
 
+  case 'hook': {
+    const { runHook } = await import('./hook.ts');
+    const hookSub = args[1] ?? 'status';
+    const force = boolFlag('force');
+    const code = await runHook(hookSub, { force });
+    process.exit(code);
+    break;
+  }
+
   default:
     console.error(`\x1b[31m[autopilot] Unknown subcommand: "${subcommand}"\x1b[0m`);
     printUsage();

package/tests/snapshots/baselines/src-formatters-sarif.json

@@ -0,0 +1,210 @@
+{
+  "normalizeSarifUri handles relative absolute and parent escaping paths": {
+    "rel": "src/index.ts",
+    "absInside": "lib/file.ts",
+    "absOutside": "/other/place/file.ts",
+    "dotted": "scripts/run.ts",
+    "windows": "folder/nested/file.ts"
+  },
+  "toSarif emits schema tool metadata rules and mapped severities": {
+    "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+    "version": "2.1.0",
+    "runs": [
+      {
+        "tool": {
+          "driver": {
+            "name": "claude-autopilot",
+            "version": "9.9.9",
+            "informationUri": "https://github.com/axledbetter/claude-autopilot",
+            "rules": [
+              {
+                "id": "no-secrets",
+                "name": "no-secrets",
+                "shortDescription": {
+                  "text": "no-secrets"
+                }
+              },
+              {
+                "id": "style-warning",
+                "name": "style-warning",
+                "shortDescription": {
+                  "text": "style-warning"
+                }
+              },
+              {
+                "id": "info-note",
+                "name": "info-note",
+                "shortDescription": {
+                  "text": "info-note"
+                }
+              }
+            ]
+          }
+        },
+        "results": [
+          {
+            "ruleId": "no-secrets",
+            "level": "error",
+            "message": {
+              "text": "Hardcoded secret detected"
+            },
+            "locations": [
+              {
+                "physicalLocation": {
+                  "artifactLocation": {
+                    "uri": "src/a.ts",
+                    "uriBaseId": "%SRCROOT%"
+                  },
+                  "region": {
+                    "startLine": 10
+                  }
+                }
+              }
+            ],
+            "fixes": [
+              {
+                "description": {
+                  "text": "Use environment variables"
+                }
+              }
+            ]
+          },
+          {
+            "ruleId": "style-warning",
+            "level": "warning",
+            "message": {
+              "text": "Potentially confusing naming"
+            },
+            "locations": [
+              {
+                "physicalLocation": {
+                  "artifactLocation": {
+                    "uri": "src/b.ts",
+                    "uriBaseId": "%SRCROOT%"
+                  },
+                  "region": {
+                    "startLine": 3
+                  }
+                }
+              }
+            ]
+          },
+          {
+            "ruleId": "info-note",
+            "level": "note",
+            "message": {
+              "text": "Informational hint"
+            },
+            "locations": [
+              {
+                "physicalLocation": {
+                  "artifactLocation": {
+                    "uri": "src/c.ts",
+                    "uriBaseId": "%SRCROOT%"
+                  }
+                }
+              }
+            ]
+          },
+          {
+            "ruleId": "no-secrets",
+            "level": "error",
+            "message": {
+              "text": "Another secret"
+            },
+            "locations": [
+              {
+                "physicalLocation": {
+                  "artifactLocation": {
+                    "uri": "src/d.ts",
+                    "uriBaseId": "%SRCROOT%"
+                  },
+                  "region": {
+                    "startLine": 20
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  "toSarif includes optional fix and region only when provided": {
+    "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+    "version": "2.1.0",
+    "runs": [
+      {
+        "tool": {
+          "driver": {
+            "name": "claude-autopilot",
+            "version": "1.2.3",
+            "informationUri": "https://github.com/axledbetter/claude-autopilot",
+            "rules": [
+              {
+                "id": "cat-a",
+                "name": "cat-a",
+                "shortDescription": {
+                  "text": "cat-a"
+                }
+              },
+              {
+                "id": "cat-b",
+                "name": "cat-b",
+                "shortDescription": {
+                  "text": "cat-b"
+                }
+              }
+            ]
+          }
+        },
+        "results": [
+          {
+            "ruleId": "cat-a",
+            "level": "warning",
+            "message": {
+              "text": "Has line and suggestion"
+            },
+            "locations": [
+              {
+                "physicalLocation": {
+                  "artifactLocation": {
+                    "uri": "src/with.ts",
+                    "uriBaseId": "%SRCROOT%"
+                  },
+                  "region": {
+                    "startLine": 42
+                  }
+                }
+              }
+            ],
+            "fixes": [
+              {
+                "description": {
+                  "text": "Apply quick fix"
+                }
+              }
+            ]
+          },
+          {
+            "ruleId": "cat-b",
+            "level": "warning",
+            "message": {
+              "text": "No line no suggestion"
+            },
+            "locations": [
+              {
+                "physicalLocation": {
+                  "artifactLocation": {
+                    "uri": "src/without.ts",
+                    "uriBaseId": "%SRCROOT%"
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+}

package/tests/snapshots/baselines/src-snapshots-impact-selector.json

@@ -0,0 +1,32 @@
+{
+  "volume override triggers full run": {
+    "selected": [
+      "a.snap",
+      "b.snap",
+      "c.snap"
+    ],
+    "fullRun": true,
+    "reason": "volume override (>10 files changed)"
+  },
+  "high-impact path match triggers full run": {
+    "selected": [
+      "x.snap",
+      "y.snap"
+    ],
+    "fullRun": true,
+    "reason": "high-impact path matched: src/core/pipeline/runner.ts"
+  },
+  "selects snapshots via direct and importer mapping": {
+    "selected": [
+      "snap-a.snap",
+      "snap-b.snap"
+    ],
+    "fullRun": false,
+    "reason": "2 snapshot(s) selected"
+  },
+  "returns no matches reason when nothing selected": {
+    "selected": [],
+    "fullRun": false,
+    "reason": "no snapshots matched changed files"
+  }
+}

package/tests/snapshots/baselines/src-snapshots-import-scanner.json

@@ -0,0 +1,21 @@
+{
+  "captures relative import and export-from edges": {
+    "feature/util.ts": [
+      "feature/index.ts"
+    ]
+  },
+  "ignores non-relative imports and deduplicates importers per target": {
+    "lib/shared.ts": [
+      "a.ts",
+      "b.ts"
+    ]
+  },
+  "excludes imports that resolve outside srcDir": {
+    "pkg/inside.ts": [
+      "pkg/consumer.ts"
+    ],
+    "outside.ts": [
+      "pkg/consumer.ts"
+    ]
+  }
+}

package/tests/snapshots/baselines/src-snapshots-serializer.json

@@ -0,0 +1,39 @@
+{
+  "normalizes timestamps uuids and cwd-prefixed paths": {
+    "id": "<uuid>",
+    "path": "src/index.ts",
+    "ts": "<timestamp>",
+    "untouched": "/other/place/file.ts"
+  },
+  "recursively normalizes arrays and nested objects": {
+    "items": [
+      "<timestamp>",
+      {
+        "file": "a/b.txt",
+        "uid": "<uuid>"
+      },
+      [
+        "plain",
+        "c/d.ts"
+      ]
+    ]
+  },
+  "sorts object keys deterministically at all levels": {
+    "a": {
+      "b": 2,
+      "c": 3,
+      "d": 4
+    },
+    "m": [
+      {
+        "x": 1,
+        "y": 2
+      },
+      {
+        "a": 1,
+        "b": 2
+      }
+    ],
+    "z": 1
+  }
+}

package/tests/snapshots/import-map.json

@@ -1 +1,138 @@
-{}
+{
+  "src/core/errors.ts": [
+    "src/adapters/loader.ts",
+    "src/adapters/review-engine/codex.ts",
+    "src/adapters/vcs-host/github.ts",
+    "src/core/config/loader.ts",
+    "src/core/config/preset-resolver.ts",
+    "src/core/runtime/lock.ts",
+    "src/core/runtime/state.ts",
+    "src/core/shell.ts"
+  ],
+  "src/adapters/base.ts": [
+    "src/adapters/loader.ts",
+    "src/adapters/migration-runner/supabase.ts",
+    "src/adapters/migration-runner/types.ts",
+    "src/adapters/review-bot-parser/declarative-base.ts",
+    "src/adapters/review-bot-parser/types.ts",
+    "src/adapters/review-engine/codex.ts",
+    "src/adapters/review-engine/types.ts",
+    "src/adapters/vcs-host/github.ts",
+    "src/adapters/vcs-host/types.ts",
+    "src/core/cache/cached-engine.ts"
+  ],
+  "src/core/shell.ts": [
+    "src/adapters/migration-runner/supabase.ts",
+    "src/adapters/vcs-host/github.ts",
+    "src/cli/preflight.ts",
+    "src/core/git/touched-files.ts"
+  ],
+  "src/adapters/migration-runner/types.ts": [
+    "src/adapters/migration-runner/supabase.ts"
+  ],
+  "src/adapters/review-bot-parser/declarative-base.ts": [
+    "src/adapters/review-bot-parser/cursor.ts"
+  ],
+  "src/core/findings/types.ts": [
+    "src/adapters/review-bot-parser/declarative-base.ts",
+    "src/adapters/review-bot-parser/types.ts",
+    "src/adapters/review-engine/codex.ts",
+    "src/adapters/review-engine/types.ts",
+    "src/core/findings/dedup.ts",
+    "src/core/phases/static-rules.ts",
+    "src/core/phases/tests.ts",
+    "src/core/pipeline/review-phase.ts",
+    "src/core/pipeline/run.ts",
+    "src/formatters/github-annotations.ts",
+    "src/formatters/sarif.ts"
+  ],
+  "src/adapters/vcs-host/types.ts": [
+    "src/adapters/review-bot-parser/declarative-base.ts",
+    "src/adapters/review-bot-parser/types.ts",
+    "src/adapters/vcs-host/github.ts"
+  ],
+  "src/adapters/review-bot-parser/types.ts": [
+    "src/adapters/review-bot-parser/declarative-base.ts"
+  ],
+  "src/adapters/review-engine/types.ts": [
+    "src/adapters/review-engine/codex.ts",
+    "src/cli/run.ts",
+    "src/cli/watch.ts",
+    "src/core/cache/cached-engine.ts",
+    "src/core/cache/review-cache.ts",
+    "src/core/chunking/index.ts",
+    "src/core/pipeline/review-phase.ts",
+    "src/core/pipeline/run.ts"
+  ],
+  "src/cli/init.ts": [
+    "src/cli/index.ts"
+  ],
+  "src/cli/run.ts": [
+    "src/cli/index.ts"
+  ],
+  "src/cli/watch.ts": [
+    "src/cli/index.ts"
+  ],
+  "src/core/config/loader.ts": [
+    "src/cli/run.ts",
+    "src/cli/watch.ts",
+    "src/core/config/preset-resolver.ts"
+  ],
+  "src/core/config/preset-resolver.ts": [
+    "src/cli/run.ts",
+    "src/cli/watch.ts"
+  ],
+  "src/adapters/loader.ts": [
+    "src/cli/run.ts",
+    "src/cli/watch.ts"
+  ],
+  "src/core/pipeline/run.ts": [
+    "src/cli/run.ts",
+    "src/cli/watch.ts",
+    "src/formatters/sarif.ts"
+  ],
+  "src/core/git/touched-files.ts": [
+    "src/cli/run.ts"
+  ],
+  "src/core/config/types.ts": [
+    "src/cli/run.ts",
+    "src/cli/watch.ts",
+    "src/core/chunking/index.ts",
+    "src/core/config/loader.ts",
+    "src/core/config/preset-resolver.ts",
+    "src/core/pipeline/review-phase.ts",
+    "src/core/pipeline/run.ts"
+  ],
+  "src/formatters/sarif.ts": [
+    "src/cli/run.ts",
+    "src/formatters/index.ts"
+  ],
+  "src/formatters/github-annotations.ts": [
+    "src/cli/run.ts",
+    "src/formatters/index.ts"
+  ],
+  "src/core/cache/review-cache.ts": [
+    "src/core/cache/cached-engine.ts"
+  ],
+  "src/core/config/schema.ts": [
+    "src/core/config/loader.ts"
+  ],
+  "src/core/logging/redaction.ts": [
+    "src/core/logging/ndjson-writer.ts"
+  ],
+  "src/core/findings/dedup.ts": [
+    "src/core/phases/static-rules.ts"
+  ],
+  "src/core/chunking/index.ts": [
+    "src/core/pipeline/review-phase.ts"
+  ],
+  "src/core/phases/static-rules.ts": [
+    "src/core/pipeline/run.ts"
+  ],
+  "src/core/phases/tests.ts": [
+    "src/core/pipeline/run.ts"
+  ],
+  "src/core/pipeline/review-phase.ts": [
+    "src/core/pipeline/run.ts"
+  ]
+}

package/tests/snapshots/index.json

@@ -1 +1,14 @@
-{}
+{
+  "tests/snapshots/src-formatters-sarif.snap.ts": [
+    "src/formatters/sarif.ts"
+  ],
+  "tests/snapshots/src-snapshots-impact-selector.snap.ts": [
+    "src/snapshots/impact-selector.ts"
+  ],
+  "tests/snapshots/src-snapshots-import-scanner.snap.ts": [
+    "src/snapshots/import-scanner.ts"
+  ],
+  "tests/snapshots/src-snapshots-serializer.snap.ts": [
+    "src/snapshots/serializer.ts"
+  ]
+}

package/tests/snapshots/src-formatters-sarif.snap.ts

@@ -0,0 +1,132 @@
+// @snapshot-for: src/formatters/sarif.ts
+// @generated-at: 2026-04-21T17:42:06.431Z
+// @source-commit: d207869
+// @generator-version: 1.0.0-alpha.6
+
+import fs from 'node:fs';
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+
+import { normalizeSarifUri, toSarif } from '../../src/formatters/sarif.ts';
+import { normalizeSnapshot } from '../../src/snapshots/serializer.ts';
+
+const SLUG = 'src-formatters-sarif';
+const baselineRaw =
+  process.env.CAPTURE_BASELINE === '1'
+    ? '{}'
+    : fs.readFileSync(
+        fileURLToPath(new URL('./baselines/src-formatters-sarif.json', import.meta.url)),
+        'utf8',
+      );
+const baseline = JSON.parse(baselineRaw);
+const captured: Record<string, unknown> = {};
+process.on('exit', () => {
+  if (process.env.CAPTURE_BASELINE === '1') {
+    const p = process.env.AUTOREGRESS_TEMP_BASELINE_DIR
+      ? path.join(process.env.AUTOREGRESS_TEMP_BASELINE_DIR, 'src-formatters-sarif.json')
+      : fileURLToPath(new URL('./baselines/src-formatters-sarif.json', import.meta.url));
+    fs.writeFileSync(p, JSON.stringify(captured, null, 2), 'utf8');
+  }
+});
+
+describe(SLUG, () => {
+  it('normalizeSarifUri handles relative absolute and parent escaping paths', () => {
+    const cwd = '/repo';
+    const result = {
+      rel: normalizeSarifUri('src/index.ts', cwd),
+      absInside: normalizeSarifUri('/repo/lib/file.ts', cwd),
+      absOutside: normalizeSarifUri('/other/place/file.ts', cwd),
+      dotted: normalizeSarifUri('./scripts/run.ts', cwd),
+      windows: normalizeSarifUri('folder\\nested\\file.ts', cwd),
+    };
+
+    if (process.env.CAPTURE_BASELINE === '1') {
+      captured['normalizeSarifUri handles relative absolute and parent escaping paths'] = result;
+      return;
+    }
+    assert.equal(
+      normalizeSnapshot(result),
+      normalizeSnapshot(baseline['normalizeSarifUri handles relative absolute and parent escaping paths']),
+    );
+  });
+
+  it('toSarif emits schema tool metadata rules and mapped severities', () => {
+    const runResult = {
+      allFindings: [
+        {
+          category: 'no-secrets',
+          severity: 'critical',
+          message: 'Hardcoded secret detected',
+          file: '/repo/src/a.ts',
+          line: 10,
+          suggestion: 'Use environment variables',
+        },
+        {
+          category: 'style-warning',
+          severity: 'warning',
+          message: 'Potentially confusing naming',
+          file: '/repo/src/b.ts',
+          line: 3,
+        },
+        {
+          category: 'info-note',
+          severity: 'info',
+          message: 'Informational hint',
+          file: '/repo/src/c.ts',
+        },
+        {
+          category: 'no-secrets',
+          severity: 'critical',
+          message: 'Another secret',
+          file: '/repo/src/d.ts',
+          line: 20,
+        },
+      ],
+    } as any;
+
+    const result = toSarif(runResult, { toolVersion: '9.9.9', cwd: '/repo' });
+
+    if (process.env.CAPTURE_BASELINE === '1') {
+      captured['toSarif emits schema tool metadata rules and mapped severities'] = result;
+      return;
+    }
+    assert.equal(
+      normalizeSnapshot(result),
+      normalizeSnapshot(baseline['toSarif emits schema tool metadata rules and mapped severities']),
+    );
+  });
+
+  it('toSarif includes optional fix and region only when provided', () => {
+    const runResult = {
+      allFindings: [
+        {
+          category: 'cat-a',
+          severity: 'warning',
+          message: 'Has line and suggestion',
+          file: 'src/with.ts',
+          line: 42,
+          suggestion: 'Apply quick fix',
+        },
+        {
+          category: 'cat-b',
+          severity: 'warning',
+          message: 'No line no suggestion',
+          file: 'src/without.ts',
+        },
+      ],
+    } as any;
+
+    const result = toSarif(runResult, { toolVersion: '1.2.3', cwd: '/repo' });
+
+    if (process.env.CAPTURE_BASELINE === '1') {
+      captured['toSarif includes optional fix and region only when provided'] = result;
+      return;
+    }
+    assert.equal(
+      normalizeSnapshot(result),
+      normalizeSnapshot(baseline['toSarif includes optional fix and region only when provided']),
+    );
+  });
+});

package/tests/snapshots/src-snapshots-impact-selector.snap.ts

@@ -0,0 +1,95 @@
+// @snapshot-for: src/snapshots/impact-selector.ts
+// @generated-at: 2026-04-21T17:42:06.431Z
+// @source-commit: d207869
+// @generator-version: 1.0.0-alpha.6
+
+import fs from 'node:fs';
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+
+import { selectSnapshots } from '../../src/snapshots/impact-selector.ts';
+import { normalizeSnapshot } from '../../src/snapshots/serializer.ts';
+
+const SLUG = 'src-snapshots-impact-selector';
+const baselineRaw = process.env.CAPTURE_BASELINE === '1' ? '{}' : fs.readFileSync(fileURLToPath(new URL('./baselines/src-snapshots-impact-selector.json', import.meta.url)), 'utf8');
+const baseline = JSON.parse(baselineRaw);
+const captured: Record<string, unknown> = {};
+
+process.on('exit', () => {
+  if (process.env.CAPTURE_BASELINE === '1') {
+    const p = process.env.AUTOREGRESS_TEMP_BASELINE_DIR
+      ? path.join(process.env.AUTOREGRESS_TEMP_BASELINE_DIR, 'src-snapshots-impact-selector.json')
+      : fileURLToPath(new URL('./baselines/src-snapshots-impact-selector.json', import.meta.url));
+    fs.writeFileSync(p, JSON.stringify(captured, null, 2), 'utf8');
+  }
+});
+
+describe(SLUG, () => {
+  it('volume override triggers full run', () => {
+    const changedFiles = Array.from({ length: 11 }, (_, i) => `src/feature/file-${i}.ts`);
+    const allSnapshotFiles = ['a.snap', 'b.snap', 'c.snap'];
+
+    const result = selectSnapshots(changedFiles, allSnapshotFiles, {}, {}, {});
+
+    if (process.env.CAPTURE_BASELINE === '1') {
+      captured['volume override triggers full run'] = result;
+      return;
+    }
+    assert.equal(normalizeSnapshot(result), normalizeSnapshot(baseline['volume override triggers full run']));
+  });
+
+  it('high-impact path match triggers full run', () => {
+    const changedFiles = ['src/core/pipeline/runner.ts'];
+    const allSnapshotFiles = ['x.snap', 'y.snap'];
+
+    const result = selectSnapshots(changedFiles, allSnapshotFiles, {}, {}, {});
+
+    if (process.env.CAPTURE_BASELINE === '1') {
+      captured['high-impact path match triggers full run'] = result;
+      return;
+    }
+    assert.equal(normalizeSnapshot(result), normalizeSnapshot(baseline['high-impact path match triggers full run']));
+  });
+
+  it('selects snapshots via direct and importer mapping', () => {
+    const changedFiles = ['src/features/a.ts'];
+    const allSnapshotFiles = ['snap-a.snap', 'snap-b.snap', 'snap-c.snap'];
+    const index = {
+      'snap-a.snap': ['src/features/a.ts'],
+      'snap-b.snap': ['src/features/b.ts'],
+      'snap-c.snap': ['src/features/c.ts'],
+    };
+    const importMap = {
+      'src/features/a.ts': ['src/features/b.ts'],
+    };
+
+    const result = selectSnapshots(changedFiles, allSnapshotFiles, index, importMap, {
+      highImpactPatterns: [],
+      volumeThreshold: 50,
+    });
+
+    if (process.env.CAPTURE_BASELINE === '1') {
+      captured['selects snapshots via direct and importer mapping'] = result;
+      return;
+    }
+    assert.equal(normalizeSnapshot(result), normalizeSnapshot(baseline['selects snapshots via direct and importer mapping']));
+  });
+
+  it('returns no matches reason when nothing selected', () => {
+    const result = selectSnapshots(
+      ['src/unknown/file.ts'],
+      ['only.snap'],
+      { 'only.snap': ['src/other/file.ts'] },
+      {},
+      { highImpactPatterns: [], volumeThreshold: 50 },
+    );
+
+    if (process.env.CAPTURE_BASELINE === '1') {
+      captured['returns no matches reason when nothing selected'] = result;
+      return;
+    }
+    assert.equal(normalizeSnapshot(result), normalizeSnapshot(baseline['returns no matches reason when nothing selected']));
+  });
+});

package/tests/snapshots/src-snapshots-import-scanner.snap.ts

@@ -0,0 +1,126 @@
+// @snapshot-for: src/snapshots/import-scanner.ts
+// @generated-at: 2026-04-21T17:42:06.431Z
+// @source-commit: d207869
+// @generator-version: 1.0.0-alpha.6
+
+import fs from 'node:fs';
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+
+import { buildImportMap } from '../../src/snapshots/import-scanner.ts';
+import { normalizeSnapshot } from '../../src/snapshots/serializer.ts';
+
+const SLUG = 'src-snapshots-import-scanner';
+void SLUG;
+const baselineRaw =
+  process.env.CAPTURE_BASELINE === '1'
+    ? '{}'
+    : fs.readFileSync(
+        fileURLToPath(new URL('./baselines/src-snapshots-import-scanner.json', import.meta.url)),
+        'utf8',
+      );
+const baseline = JSON.parse(baselineRaw);
+const captured: Record<string, unknown> = {};
+process.on('exit', () => {
+  if (process.env.CAPTURE_BASELINE === '1') {
+    const p = process.env.AUTOREGRESS_TEMP_BASELINE_DIR
+      ? path.join(process.env.AUTOREGRESS_TEMP_BASELINE_DIR, 'src-snapshots-import-scanner.json')
+      : fileURLToPath(new URL('./baselines/src-snapshots-import-scanner.json', import.meta.url));
+    fs.writeFileSync(p, JSON.stringify(captured, null, 2), 'utf8');
+  }
+});
+
+function mkTempDir(name: string): string {
+  return fs.mkdtempSync(path.join(process.cwd(), `.tmp-${name}-`));
+}
+
+describe('buildImportMap snapshots', () => {
+  it('captures relative import and export-from edges', () => {
+    const dir = mkTempDir('import-scanner-basic');
+    fs.mkdirSync(path.join(dir, 'feature'), { recursive: true });
+
+    fs.writeFileSync(
+      path.join(dir, 'feature', 'util.ts'),
+      `export const util = 1;\n`,
+      'utf8',
+    );
+    fs.writeFileSync(
+      path.join(dir, 'feature', 'index.ts'),
+      `import { util } from './util';
+export { util as u } from './util';
+`,
+      'utf8',
+    );
+
+    const result = buildImportMap(dir);
+
+    if (process.env.CAPTURE_BASELINE === '1') {
+      captured['captures relative import and export-from edges'] = result;
+      return;
+    }
+    assert.equal(
+      normalizeSnapshot(result),
+      normalizeSnapshot(baseline['captures relative import and export-from edges']),
+    );
+  });
+
+  it('ignores non-relative imports and deduplicates importers per target', () => {
+    const dir = mkTempDir('import-scanner-dedupe');
+    fs.mkdirSync(path.join(dir, 'lib'), { recursive: true });
+
+    fs.writeFileSync(path.join(dir, 'lib', 'shared.ts'), `export const x = 1;\n`, 'utf8');
+    fs.writeFileSync(
+      path.join(dir, 'a.ts'),
+      `import { readFileSync } from 'node:fs';
+import { x } from './lib/shared';
+import { y } from "./lib/shared";
+`,
+      'utf8',
+    );
+    fs.writeFileSync(
+      path.join(dir, 'b.ts'),
+      `export { x } from './lib/shared';\n`,
+      'utf8',
+    );
+
+    const result = buildImportMap(dir);
+
+    if (process.env.CAPTURE_BASELINE === '1') {
+      captured['ignores non-relative imports and deduplicates importers per target'] = result;
+      return;
+    }
+    assert.equal(
+      normalizeSnapshot(result),
+      normalizeSnapshot(baseline['ignores non-relative imports and deduplicates importers per target']),
+    );
+  });
+
+  it('excludes imports that resolve outside srcDir', () => {
+    const root = mkTempDir('import-scanner-outside');
+    const src = path.join(root, 'src');
+    fs.mkdirSync(path.join(src, 'pkg'), { recursive: true });
+
+    fs.writeFileSync(path.join(src, 'pkg', 'inside.ts'), `export const ok = true;\n`, 'utf8');
+    fs.writeFileSync(
+      path.join(src, 'pkg', 'consumer.ts'),
+      `import { ok } from './inside';
+import x from '../outside';
+import y from '../../totally-out';
+`,
+      'utf8',
+    );
+
+    const result = buildImportMap(src);
+
+    if (process.env.CAPTURE_BASELINE === '1') {
+      captured['excludes imports that resolve outside srcDir'] = result;
+      return;
+    }
+    assert.equal(
+      normalizeSnapshot(result),
+      normalizeSnapshot(baseline['excludes imports that resolve outside srcDir']),
+    );
+  });
+});

package/tests/snapshots/src-snapshots-serializer.snap.ts

@@ -0,0 +1,64 @@
+// @snapshot-for: src/snapshots/serializer.ts
+// @generated-at: 2026-04-21T17:42:06.431Z
+// @source-commit: d207869
+// @generator-version: 1.0.0-alpha.6
+
+import fs from 'node:fs';
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+import { normalizeSnapshot } from '../../src/snapshots/serializer.ts';
+
+const SLUG = 'src-snapshots-serializer';
+const baselineRaw = process.env.CAPTURE_BASELINE === '1' ? '{}' : fs.readFileSync(fileURLToPath(new URL('./baselines/src-snapshots-serializer.json', import.meta.url)), 'utf8');
+const baseline = JSON.parse(baselineRaw);
+const captured: Record<string, unknown> = {};
+process.on('exit', () => {
+  if (process.env.CAPTURE_BASELINE === '1') {
+    const p = process.env.AUTOREGRESS_TEMP_BASELINE_DIR
+      ? path.join(process.env.AUTOREGRESS_TEMP_BASELINE_DIR, 'src-snapshots-serializer.json')
+      : fileURLToPath(new URL('./baselines/src-snapshots-serializer.json', import.meta.url));
+    fs.writeFileSync(p, JSON.stringify(captured, null, 2), 'utf8');
+  }
+});
+
+describe('normalizeSnapshot', () => {
+  it('normalizes timestamps uuids and cwd-prefixed paths', () => {
+    const cwd = '/repo/project';
+    const result = JSON.parse(normalizeSnapshot({
+      ts: '2026-04-21T17:42:06.431Z',
+      id: '550e8400-e29b-41d4-a716-446655440000',
+      path: '/repo/project/src/index.ts',
+      untouched: '/other/place/file.ts',
+    }, cwd));
+
+    if (process.env.CAPTURE_BASELINE === '1') { captured['normalizes timestamps uuids and cwd-prefixed paths'] = result; return; }
+    assert.equal(normalizeSnapshot(result), normalizeSnapshot(baseline['normalizes timestamps uuids and cwd-prefixed paths']));
+  });
+
+  it('recursively normalizes arrays and nested objects', () => {
+    const cwd = '/work';
+    const result = JSON.parse(normalizeSnapshot({
+      items: [
+        '2024-01-02T03:04:05.000Z',
+        { uid: '123e4567-e89b-12d3-a456-426614174000', file: '/work/a/b.txt' },
+        ['plain', '/work/c/d.ts'],
+      ],
+    }, cwd));
+
+    if (process.env.CAPTURE_BASELINE === '1') { captured['recursively normalizes arrays and nested objects'] = result; return; }
+    assert.equal(normalizeSnapshot(result), normalizeSnapshot(baseline['recursively normalizes arrays and nested objects']));
+  });
+
+  it('sorts object keys deterministically at all levels', () => {
+    const result = JSON.parse(normalizeSnapshot({
+      z: 1,
+      a: { d: 4, b: 2, c: 3 },
+      m: [{ y: 2, x: 1 }, { b: 2, a: 1 }],
+    }));
+
+    if (process.env.CAPTURE_BASELINE === '1') { captured['sorts object keys deterministically at all levels'] = result; return; }
+    assert.equal(normalizeSnapshot(result), normalizeSnapshot(baseline['sorts object keys deterministically at all levels']));
+  });
+});