@kb-labs/qa-core 2.93.0 → 2.96.0

package/dist/index.js

@@ -1,1692 +1,701 @@
-import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, statSync } from 'fs';
-import { join, relative, dirname, resolve } from 'path';
-import { execSync, spawnSync } from 'child_process';
-import { createHash } from 'crypto';
-import { TRENDS_WINDOW, PATHS, HISTORY_MAX_ENTRIES, getCheckIcon, getCheckLabel, QA_DATA_DIR } from '@kb-labs/qa-contracts';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { randomUUID } from 'crypto';
+import { TRENDS_WINDOW, HISTORY_MAX_ENTRIES, PATHS } from '@kb-labs/qa-contracts';
 
-// src/runner/workspace.ts
-function getSubmoduleInfo(repoDir, repoName) {
-  const gitDir = join(repoDir, ".git");
-  if (!existsSync(gitDir)) {
-    return null;
-  }
-  try {
-    const commit = execSync("git rev-parse --short HEAD", {
-      cwd: repoDir,
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-      cwd: repoDir,
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const message = execSync("git log -1 --format=%s", {
-      cwd: repoDir,
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const statusOutput = execSync("git status --porcelain", {
-      cwd: repoDir,
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return {
-      name: repoName,
-      commit,
-      branch,
-      dirty: statusOutput.length > 0,
-      message
-    };
-  } catch {
-    return null;
-  }
-}
-function collectSubmoduleInfo(rootDir, repos) {
-  const result = {};
-  for (const repo of repos) {
-    const repoDir = join(rootDir, repo);
-    const info = getSubmoduleInfo(repoDir, repo);
-    if (info) {
-      result[repo] = info;
-    }
-  }
-  return result;
-}
-
-// src/runner/workspace.ts
-function hasWorkspace(dir) {
-  return existsSync(join(dir, "pnpm-workspace.yaml"));
-}
-function isDir(p) {
-  return existsSync(p) && statSync(p).isDirectory();
-}
-function buildCandidatesFromConfig(rootDir, paths) {
-  const candidates = [];
-  for (const pattern of paths) {
-    const parts = pattern.split("/");
-    if (parts.length === 2 && parts[1] === "*" && parts[0]) {
-      const categoryDir = join(rootDir, parts[0]);
-      if (!isDir(categoryDir)) {
-        continue;
-      }
-      try {
-        for (const sub of readdirSync(categoryDir)) {
-          if (sub.startsWith(".") || sub === "node_modules") {
-            continue;
-          }
-          const subPath = join(categoryDir, sub);
-          if (isDir(subPath) && hasWorkspace(subPath)) {
-            candidates.push(subPath);
-          }
-        }
-      } catch {
-      }
-    } else {
-      const exactPath = join(rootDir, pattern);
-      if (isDir(exactPath) && hasWorkspace(exactPath)) {
-        candidates.push(exactPath);
-      }
-    }
-  }
-  return candidates;
-}
-function buildCandidatesAutoScan(rootDir) {
-  const candidates = [];
-  for (const entry of readdirSync(rootDir)) {
-    if (entry.startsWith(".") || entry === "node_modules" || entry === "dist") {
-      continue;
-    }
-    const entryPath = join(rootDir, entry);
-    if (!isDir(entryPath)) {
-      continue;
-    }
-    if (hasWorkspace(entryPath)) {
-      candidates.push(entryPath);
-    } else {
-      try {
-        for (const sub of readdirSync(entryPath)) {
-          if (sub.startsWith(".") || sub === "node_modules") {
-            continue;
-          }
-          const subPath = join(entryPath, sub);
-          if (isDir(subPath) && hasWorkspace(subPath)) {
-            candidates.push(subPath);
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  return candidates;
-}
-function scanSubDir(parentDir, entryPath, repoName, rootDir, submodule, packages) {
-  if (!isDir(parentDir)) {
-    return;
-  }
-  for (const pkgDir of readdirSync(parentDir)) {
-    const pkgPath = join(parentDir, pkgDir);
-    const pkgJsonPath = join(pkgPath, "package.json");
-    if (!existsSync(pkgJsonPath)) {
-      continue;
-    }
-    try {
-      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-      packages.push({
-        name: pkgJson.name || pkgDir,
-        dir: pkgPath,
-        relativePath: relative(rootDir, pkgPath),
-        repo: repoName,
-        submodule
-      });
-    } catch {
-    }
-  }
-}
-function getWorkspacePackages(rootDir, filter, packagesConfig) {
-  const packages = [];
-  const submoduleCache = /* @__PURE__ */ new Map();
-  function getSubmoduleCached(entryPath, repoName) {
-    if (!submoduleCache.has(repoName)) {
-      submoduleCache.set(repoName, getSubmoduleInfo(entryPath, repoName));
-    }
-    return submoduleCache.get(repoName) ?? void 0;
-  }
-  const candidates = packagesConfig?.paths && packagesConfig.paths.length > 0 ? buildCandidatesFromConfig(rootDir, packagesConfig.paths) : buildCandidatesAutoScan(rootDir);
-  for (const entryPath of candidates) {
-    const repoName = relative(rootDir, entryPath);
-    const submodule = getSubmoduleCached(entryPath, repoName);
-    scanSubDir(join(entryPath, "packages"), entryPath, repoName, rootDir, submodule, packages);
-    scanSubDir(join(entryPath, "apps"), entryPath, repoName, rootDir, submodule, packages);
-  }
-  let filtered = packages;
-  if (packagesConfig?.include && packagesConfig.include.length > 0) {
-    filtered = filtered.filter(
-      (pkg) => packagesConfig.include.some((pattern) => matchesPattern(pkg.name, pkg.repo, pattern))
-    );
-  }
-  if (packagesConfig?.exclude && packagesConfig.exclude.length > 0) {
-    filtered = filtered.filter(
-      (pkg) => !packagesConfig.exclude.some((pattern) => matchesPattern(pkg.name, pkg.repo, pattern))
-    );
-  }
-  if (!filter) {
-    return filtered;
-  }
-  return filtered.filter((pkg) => {
-    if (filter.package && !pkg.name.includes(filter.package)) {
-      return false;
-    }
-    if (filter.repo && pkg.repo !== filter.repo) {
-      return false;
-    }
-    if (filter.scope) {
-      const scope = filter.scope.startsWith("@") ? filter.scope : `@${filter.scope}`;
-      if (!pkg.name.startsWith(scope)) {
-        return false;
-      }
-    }
-    return true;
-  });
-}
-function matchesPattern(name, repo, pattern) {
-  if (pattern.endsWith("/*")) {
-    const prefix = pattern.slice(0, -2);
-    return repo === prefix || repo.startsWith(prefix + "/");
-  }
-  if (pattern.endsWith("*")) {
-    return name.startsWith(pattern.slice(0, -1));
-  }
-  return name === pattern || repo === pattern;
-}
-function readWorkspaceDeps(pkgDir, workspaceNames) {
-  try {
-    const raw = readFileSync(join(pkgDir, "package.json"), "utf-8");
-    const pkgJson = JSON.parse(raw);
-    const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
-    return Object.keys(allDeps).filter((dep) => workspaceNames.has(dep));
-  } catch {
-    return [];
-  }
-}
-function buildDepGraph(packages) {
-  const nameMap = /* @__PURE__ */ new Map();
-  const workspaceNames = /* @__PURE__ */ new Set();
-  for (const pkg of packages) {
-    nameMap.set(pkg.name, pkg);
-    workspaceNames.add(pkg.name);
-  }
-  const inDegree = /* @__PURE__ */ new Map();
-  const dependents = /* @__PURE__ */ new Map();
-  for (const pkg of packages) {
-    inDegree.set(pkg.name, 0);
-    dependents.set(pkg.name, []);
-  }
-  for (const pkg of packages) {
-    const deps = readWorkspaceDeps(pkg.dir, workspaceNames);
-    inDegree.set(pkg.name, deps.length);
-    for (const dep of deps) {
-      dependents.get(dep).push(pkg.name);
+// src/devkit/devkit-discovery.ts
+function resolveDevkitBin(rootDir, configPath) {
+  if (configPath) {
+    const full = configPath.startsWith("/") ? configPath : join(rootDir, configPath);
+    if (!existsSync(full)) {
+      throw new Error(`devkitPath "${configPath}" not found at ${full}`);
     }
+    return full;
   }
-  return { nameMap, inDegree, dependents };
-}
-function computeBuildLayers(packages) {
-  if (packages.length === 0) {
-    return [];
+  const local = join(rootDir, "tools", "kb-devkit", "kb-devkit");
+  if (existsSync(local)) {
+    return local;
   }
-  const { nameMap, inDegree, dependents } = buildDepGraph(packages);
-  const layers = [];
-  const remaining = new Set(packages.map((p) => p.name));
-  while (remaining.size > 0) {
-    const layerNames = [];
-    for (const name of remaining) {
-      if ((inDegree.get(name) ?? 0) === 0) {
-        layerNames.push(name);
-      }
-    }
-    if (layerNames.length === 0) {
-      const circular = [...remaining].map((n) => nameMap.get(n)).filter(Boolean);
-      layers.push({ index: layers.length, packages: circular });
-      break;
-    }
-    layerNames.sort();
-    layers.push({ index: layers.length, packages: layerNames.map((n) => nameMap.get(n)) });
-    for (const name of layerNames) {
-      remaining.delete(name);
-      for (const dependent of dependents.get(name) ?? []) {
-        inDegree.set(dependent, (inDegree.get(dependent) ?? 0) - 1);
-      }
-    }
-  }
-  return layers;
-}
-function sortByBuildLayers(packages) {
-  return computeBuildLayers(packages).flatMap((l) => l.packages);
+  return "kb-devkit";
 }
 
-// src/runner/custom-check-runner.ts
-var ID_MAP = {
-  build: "build",
-  lint: "lint",
-  typecheck: "typeCheck",
-  "type-check": "typeCheck",
-  test: "test",
-  tests: "test"
-};
-function emptyResult() {
-  return { passed: [], failed: [], skipped: [], errors: {}, details: {} };
-}
-function runCommand(command, args, cwd, timeoutMs, extraEnv) {
-  try {
-    const env = extraEnv ? { ...process.env, ...extraEnv } : void 0;
-    const result = spawnSync(command, args, { cwd, timeout: timeoutMs, encoding: "utf-8", shell: false, env });
-    const stdout = result.stdout ?? "";
-    const stderr = result.stderr ?? "";
-    const exitCode = result.status ?? 1;
-    return { ok: exitCode === 0, stdout, stderr, exitCode };
-  } catch (e) {
-    return { ok: false, stdout: "", stderr: e instanceof Error ? e.message : String(e), exitCode: 1 };
-  }
-}
-function parseTypedOutput(stdout) {
-  try {
-    const parsed = JSON.parse(stdout);
-    if (typeof parsed === "object" && parsed !== null && "ok" in parsed) {
-      return {
-        ok: parsed.ok === true,
-        items: Array.isArray(parsed.items) ? parsed.items : []
-      };
+// src/devkit/devkit-adapter.ts
+var DevkitAdapter = class {
+  bin;
+  cwd;
+  shell;
+  timeout;
+  constructor(opts) {
+    this.bin = opts.binaryPath;
+    this.cwd = opts.cwd;
+    this.shell = opts.shell;
+    this.timeout = opts.timeoutMs ?? 6e5;
+  }
+  async run(tasks) {
+    if (tasks.length === 0) {
+      throw new Error("DevkitAdapter.run: tasks must not be empty");
+    }
+    return this.invoke(["run", ...tasks]);
+  }
+  async check() {
+    return this.invoke(["check"]);
+  }
+  async stats() {
+    return this.invoke(["stats"]);
+  }
+  async status() {
+    return this.invoke(["status"]);
+  }
+  async gate() {
+    return this.invoke(["gate"]);
+  }
+  async version() {
+    const result = await this.shell.exec(this.bin, ["--version"], {
+      cwd: this.cwd,
+      timeout: 5e3,
+      throwOnError: false
+    });
+    if (!result.ok) {
+      throw new Error(
+        `kb-devkit not found or not executable at "${this.bin}". Set QAPluginConfig.devkitPath or ensure kb-devkit is on PATH.`
+      );
     }
-  } catch {
+    return result.stdout.trim();
   }
-  return null;
-}
-function evaluate(check, stdout, stderr, exitCode) {
-  if ((check.parser ?? "exitcode") === "json") {
-    const typed = parseTypedOutput(stdout);
-    if (typed !== null) {
-      return typed.ok;
+  async invoke(args) {
+    const result = await this.shell.exec(this.bin, [...args, "--json"], {
+      cwd: this.cwd,
+      timeout: this.timeout,
+      throwOnError: false
+    });
+    if (result.code !== 0 && !result.stdout.trim()) {
+      throw new Error(
+        `kb-devkit ${args[0]} failed (exit ${result.code}): ${result.stderr.slice(0, 500)}`
+      );
     }
     try {
-      const parsed = JSON.parse(stdout);
-      return parsed.ok === true || parsed.success === true || parsed.status === "ok";
+      return JSON.parse(result.stdout);
     } catch {
-      return false;
-    }
-  }
-  return exitCode === 0;
-}
-function recordResult(bucket, key, passed, stdout, stderr, exitCode, check, canonicalId, onProgress, durationMs) {
-  if (passed) {
-    bucket.passed.push(key);
-    onProgress?.(canonicalId, key, "pass", durationMs);
-  } else {
-    bucket.failed.push(key);
-    bucket.errors[key] = stderr || stdout || `Exit code ${exitCode}`;
-    if ((check.parser ?? "exitcode") === "json") {
-      const typed = parseTypedOutput(stdout);
-      if (typed && typed.items.length > 0) {
-        bucket.details[key] = typed.items;
-      }
+      throw new Error(
+        `kb-devkit ${args[0]} produced non-JSON output (exit ${result.code}). stderr: ${result.stderr.slice(0, 300)}`
+      );
     }
-    onProgress?.(canonicalId, key, "fail", durationMs);
   }
-}
-function getDiffPackageDirs(rootDir, base, diffFilter) {
+};
+
+// src/devkit/git-capture.ts
+async function captureGit(shell, cwd) {
   try {
-    const filter = diffFilter ? `--diff-filter=${diffFilter}` : "";
-    const args = ["diff", filter, `${base}...HEAD`, "--name-only"].filter(Boolean);
-    const output = execSync(`git ${args.join(" ")}`, { cwd: rootDir, encoding: "utf-8" }).trim();
-    if (!output) {
-      return /* @__PURE__ */ new Set();
+    const [commitRes, branchRes, messageRes] = await Promise.all([
+      shell.exec("git", ["rev-parse", "--short", "HEAD"], { cwd, throwOnError: false }),
+      shell.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, throwOnError: false }),
+      shell.exec("git", ["log", "-1", "--format=%s"], { cwd, throwOnError: false })
+    ]);
+    if (!commitRes.ok) {
+      return void 0;
     }
-    return new Set(output.split("\n").map((f) => f.split("/")[0]).filter((s) => Boolean(s)));
+    return {
+      commit: commitRes.stdout.trim(),
+      branch: branchRes.stdout.trim() || "HEAD",
+      message: messageRes.stdout.trim()
+    };
   } catch {
-    return /* @__PURE__ */ new Set();
-  }
-}
-function filterPackagesByDiff(packages, rootDir, diffFilter, base) {
-  const touchedDirs = getDiffPackageDirs(rootDir, base, diffFilter);
-  if (touchedDirs.size === 0) {
-    return [];
-  }
-  return packages.filter((pkg) => {
-    const relParts = pkg.relativePath.split("/");
-    return relParts.some((_, i) => touchedDirs.has(relParts.slice(0, i + 1).join("/")));
-  });
-}
-function runInRepoRoot(check, canonicalId, resolvedArgs, rootDir, bucket, onProgress, diffBase) {
-  const startMs = Date.now();
-  const env = diffBase ? { KB_QA_BASE: diffBase } : void 0;
-  const { stderr, exitCode, stdout } = runCommand(check.command, resolvedArgs, rootDir, check.timeoutMs ?? 12e4, env);
-  recordResult(bucket, rootDir, evaluate(check, stdout, stderr, exitCode), stdout, stderr, exitCode, check, canonicalId, onProgress, Date.now() - startMs);
-}
-function runInScopePath(check, canonicalId, resolvedArgs, packages, rootDir, bucket, onProgress, diffBase) {
-  const seen = /* @__PURE__ */ new Set();
-  const env = diffBase ? { KB_QA_BASE: diffBase } : void 0;
-  for (const pkg of packages) {
-    if (seen.has(pkg.repo)) {
-      continue;
-    }
-    seen.add(pkg.repo);
-    const scopeDir = resolve(rootDir, pkg.repo);
-    if (!existsSync(scopeDir)) {
-      continue;
-    }
-    const startMs = Date.now();
-    const { stderr, exitCode, stdout } = runCommand(check.command, resolvedArgs, scopeDir, check.timeoutMs ?? 12e4, env);
-    recordResult(bucket, pkg.repo, evaluate(check, stdout, stderr, exitCode), stdout, stderr, exitCode, check, canonicalId, onProgress, Date.now() - startMs);
-  }
-}
-function getPnpmScriptName(check) {
-  if (check.command !== "pnpm") {
     return void 0;
   }
-  const args = check.args ?? [];
-  if (args[0] === "run" && args[1]) {
-    return args[1];
-  }
-  return void 0;
-}
-function hasNpmScript(pkgDir, scriptName) {
-  try {
-    const pkgJson = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf-8"));
-    return typeof pkgJson?.scripts?.[scriptName] === "string";
-  } catch {
-    return false;
-  }
-}
-function runPerPackage(check, canonicalId, resolvedArgs, packages, bucket, onProgress, diffBase) {
-  const sortedPackages = check.ordered ? sortByBuildLayers(packages) : packages;
-  const scriptName = getPnpmScriptName(check);
-  const env = diffBase ? { KB_QA_BASE: diffBase } : void 0;
-  for (const pkg of sortedPackages) {
-    if (scriptName && !hasNpmScript(pkg.dir, scriptName)) {
-      bucket.skipped.push(pkg.name);
-      onProgress?.(canonicalId, pkg.name, "skip");
-      continue;
-    }
-    const startMs = Date.now();
-    const { stderr, exitCode, stdout } = runCommand(check.command, resolvedArgs, pkg.dir, check.timeoutMs ?? 12e4, env);
-    recordResult(bucket, pkg.name, evaluate(check, stdout, stderr, exitCode), stdout, stderr, exitCode, check, canonicalId, onProgress, Date.now() - startMs);
-  }
-}
-function runCustomChecks(checks, packages, rootDir, onProgress, diffBase) {
-  const results = {};
-  for (const check of checks) {
-    const canonicalId = ID_MAP[check.id.toLowerCase()] ?? check.id;
-    if (!results[canonicalId]) {
-      results[canonicalId] = emptyResult();
-    }
-    const bucket = results[canonicalId];
-    const args = check.args ?? [];
-    const resolvedArgs = args.map(
-      (arg) => arg.match(/\.(sh|js|ts|mjs|cjs)$/) && !arg.startsWith("/") ? join(rootDir, arg) : arg
-    );
-    const runIn = check.runIn ?? "perPackage";
-    if (runIn === "repoRoot") {
-      runInRepoRoot(check, canonicalId, resolvedArgs, rootDir, bucket, onProgress, diffBase);
-    } else if (runIn === "scopePath") {
-      runInScopePath(check, canonicalId, resolvedArgs, packages, rootDir, bucket, onProgress, diffBase);
-    } else if (runIn === "diffOnly" || runIn === "newFiles") {
-      const base = diffBase ?? "main";
-      const diffFilter = runIn === "newFiles" ? "A" : "";
-      const filteredPackages = filterPackagesByDiff(packages, rootDir, diffFilter, base);
-      if (filteredPackages.length === 0) {
-        bucket.skipped.push(...packages.map((p) => p.name));
-        for (const pkg of packages) {
-          onProgress?.(canonicalId, pkg.name, "skip");
-        }
-      } else {
-        const filteredNames = new Set(filteredPackages.map((p) => p.name));
-        for (const pkg of packages) {
-          if (!filteredNames.has(pkg.name)) {
-            bucket.skipped.push(pkg.name);
-            onProgress?.(canonicalId, pkg.name, "skip");
-          }
-        }
-        runPerPackage(check, canonicalId, resolvedArgs, filteredPackages, bucket, onProgress, base);
-      }
-    } else {
-      runPerPackage(check, canonicalId, resolvedArgs, packages, bucket, onProgress);
-    }
-    if (Object.keys(bucket.details).length > 0) {
-      results[canonicalId].details = bucket.details;
-    }
-  }
-  return results;
 }
-function loadCache(rootDir) {
-  const cachePath = join(rootDir, PATHS.CACHE);
-  if (!existsSync(cachePath)) {
-    return {};
+function readJson(filePath) {
+  if (!existsSync(filePath)) {
+    return [];
   }
   try {
-    return JSON.parse(readFileSync(cachePath, "utf-8"));
+    return JSON.parse(readFileSync(filePath, "utf-8"));
   } catch {
-    return {};
+    return [];
   }
 }
-function saveCache(rootDir, cache) {
-  const cachePath = join(rootDir, PATHS.CACHE);
-  const dir = dirname(cachePath);
+function writeJson(filePath, data) {
+  const dir = dirname(filePath);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  writeFileSync(cachePath, JSON.stringify(cache, null, 2));
-}
-function computePackageHash(pkgDir) {
-  const hash = createHash("sha256");
-  const pkgJsonPath = join(pkgDir, "package.json");
-  if (existsSync(pkgJsonPath)) {
-    hash.update(readFileSync(pkgJsonPath));
-  }
-  const srcDir = join(pkgDir, "src");
-  if (existsSync(srcDir)) {
-    hashDirectory(srcDir, hash);
-  }
-  return hash.digest("hex");
-}
-function hashDirectory(dir, hash) {
-  const entries = readdirSync(dir).sort();
-  for (const entry of entries) {
-    const fullPath = join(dir, entry);
-    const stat = statSync(fullPath);
-    if (stat.isDirectory()) {
-      hashDirectory(fullPath, hash);
-    } else if (stat.isFile()) {
-      hash.update(fullPath);
-      hash.update(readFileSync(fullPath));
-    }
-  }
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
-function updateCacheEntry(pkgDir, pkgName, cache) {
-  const hash = computePackageHash(pkgDir);
+function buildMeta(durationMs, git, runContext) {
   return {
-    ...cache,
-    [pkgName]: { hash, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+    id: randomUUID(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs,
+    ...git ? { git } : {},
+    ...runContext ? { runContext } : {}
   };
 }
-function needsRebuild(pkgDir) {
-  const srcDir = join(pkgDir, "src");
-  const distDir = join(pkgDir, "dist");
-  if (!existsSync(distDir)) {
-    return true;
-  }
-  if (!existsSync(srcDir)) {
-    return false;
-  }
-  const srcMtime = getLatestMtime(srcDir);
-  const distMtime = getLatestMtime(distDir);
-  return srcMtime > distMtime;
-}
-function getLatestMtime(dir) {
-  let latest = 0;
-  try {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        latest = Math.max(latest, getLatestMtime(fullPath));
-      } else {
-        latest = Math.max(latest, statSync(fullPath).mtimeMs);
-      }
-    }
-  } catch {
-  }
-  return latest;
-}
-function runBuildCheck(options) {
-  const { packages, noCache, onProgress } = options;
-  const result = { passed: [], failed: [], skipped: [], errors: {} };
-  const sorted = sortByBuildLayers(packages);
-  for (const pkg of sorted) {
-    if (!noCache && !needsRebuild(pkg.dir)) {
-      result.skipped.push(pkg.name);
-      onProgress?.(pkg.name, "skip");
-      continue;
-    }
-    const startMs = Date.now();
-    try {
-      execSync("pnpm run build", {
-        cwd: pkg.dir,
-        encoding: "utf-8",
-        timeout: 12e4,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      const durationMs = Date.now() - startMs;
-      result.passed.push(pkg.name);
-      onProgress?.(pkg.name, "pass", durationMs);
-    } catch (err) {
-      const durationMs = Date.now() - startMs;
-      result.failed.push(pkg.name);
-      const spawnErr = err;
-      const rawErr = (spawnErr.stderr || spawnErr.stdout || spawnErr.message || "").trim();
-      result.errors[pkg.name] = rawErr.slice(0, 2e3) || `Build failed (exit code ${spawnErr.status ?? 1})`;
-      onProgress?.(pkg.name, "fail", durationMs);
-    }
-  }
-  return result;
-}
-function runLintCheck(options) {
-  const { packages, onProgress } = options;
-  const result = { passed: [], failed: [], skipped: [], errors: {} };
-  for (const pkg of packages) {
-    const srcDir = join(pkg.dir, "src");
-    if (!existsSync(srcDir)) {
-      result.skipped.push(pkg.name);
-      onProgress?.(pkg.name, "skip");
-      continue;
-    }
-    const startMs = Date.now();
-    try {
-      execSync("pnpm exec eslint .", {
-        cwd: pkg.dir,
-        encoding: "utf-8",
-        timeout: 6e4,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      result.passed.push(pkg.name);
-      onProgress?.(pkg.name, "pass", Date.now() - startMs);
-    } catch (err) {
-      result.failed.push(pkg.name);
-      const spawnErr = err;
-      const rawErr = (spawnErr.stdout || spawnErr.stderr || spawnErr.message || "").trim();
-      result.errors[pkg.name] = rawErr.slice(0, 2e3) || `Lint failed (exit code ${spawnErr.status ?? 1})`;
-      onProgress?.(pkg.name, "fail", Date.now() - startMs);
+var SnapshotStore = class {
+  rootDir;
+  maxEntries;
+  constructor(rootDir, maxEntries = HISTORY_MAX_ENTRIES) {
+    this.rootDir = rootDir;
+    this.maxEntries = maxEntries;
+  }
+  // ── Run snapshots ──────────────────────────────────────────────────────────
+  loadRunHistory() {
+    return readJson(join(this.rootDir, PATHS.SNAPSHOTS_RUN));
+  }
+  saveRun(raw, tasks, durationMs, git, runContext) {
+    const snap = {
+      ...buildMeta(durationMs, git, runContext),
+      kind: "run",
+      tasks,
+      raw
+    };
+    const history = this.loadRunHistory();
+    history.push(snap);
+    while (history.length > this.maxEntries) {
+      history.shift();
+    }
+    writeJson(join(this.rootDir, PATHS.SNAPSHOTS_RUN), history);
+    return snap;
+  }
+  latestRun() {
+    const h = this.loadRunHistory();
+    return h.length > 0 ? h[h.length - 1] : null;
+  }
+  // ── Check snapshots ────────────────────────────────────────────────────────
+  loadCheckHistory() {
+    return readJson(join(this.rootDir, PATHS.SNAPSHOTS_CHECK));
+  }
+  saveCheck(raw, durationMs, git, runContext) {
+    const snap = {
+      ...buildMeta(durationMs, git, runContext),
+      kind: "check",
+      raw
+    };
+    const history = this.loadCheckHistory();
+    history.push(snap);
+    while (history.length > this.maxEntries) {
+      history.shift();
+    }
+    writeJson(join(this.rootDir, PATHS.SNAPSHOTS_CHECK), history);
+    return snap;
+  }
+  latestCheck() {
+    const h = this.loadCheckHistory();
+    return h.length > 0 ? h[h.length - 1] : null;
+  }
+  // ── Stats snapshots ────────────────────────────────────────────────────────
+  loadStatsHistory() {
+    return readJson(join(this.rootDir, PATHS.SNAPSHOTS_STATS));
+  }
+  saveStats(raw, durationMs, git, runContext) {
+    const snap = {
+      ...buildMeta(durationMs, git, runContext),
+      kind: "stats",
+      raw
+    };
+    const history = this.loadStatsHistory();
+    history.push(snap);
+    while (history.length > this.maxEntries) {
+      history.shift();
+    }
+    writeJson(join(this.rootDir, PATHS.SNAPSHOTS_STATS), history);
+    return snap;
+  }
+  latestStats() {
+    const h = this.loadStatsHistory();
+    return h.length > 0 ? h[h.length - 1] : null;
+  }
+  // ── Gate snapshots ─────────────────────────────────────────────────────────
+  loadGateHistory() {
+    return readJson(join(this.rootDir, PATHS.SNAPSHOTS_GATE));
+  }
+  saveGate(raw, durationMs, git, runContext) {
+    const snap = {
+      ...buildMeta(durationMs, git, runContext),
+      kind: "gate",
+      raw
+    };
+    const history = this.loadGateHistory();
+    history.push(snap);
+    while (history.length > this.maxEntries) {
+      history.shift();
     }
+    writeJson(join(this.rootDir, PATHS.SNAPSHOTS_GATE), history);
+    return snap;
   }
-  return result;
-}
-function runTypeCheck(options) {
-  const { packages, onProgress } = options;
-  const result = { passed: [], failed: [], skipped: [], errors: {} };
-  for (const pkg of packages) {
-    const tsconfigPath = join(pkg.dir, "tsconfig.json");
-    if (!existsSync(tsconfigPath)) {
-      result.skipped.push(pkg.name);
-      onProgress?.(pkg.name, "skip");
-      continue;
-    }
-    const startMs = Date.now();
-    try {
-      execSync("pnpm exec tsc --noEmit", {
-        cwd: pkg.dir,
-        encoding: "utf-8",
-        timeout: 12e4,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      result.passed.push(pkg.name);
-      onProgress?.(pkg.name, "pass", Date.now() - startMs);
-    } catch (err) {
-      result.failed.push(pkg.name);
-      const spawnErr = err;
-      const rawErr = (spawnErr.stdout || spawnErr.stderr || spawnErr.message || "").trim();
-      result.errors[pkg.name] = rawErr.slice(0, 2e3) || `Type check failed (exit code ${spawnErr.status ?? 1})`;
-      onProgress?.(pkg.name, "fail", Date.now() - startMs);
+  // ── Baseline ───────────────────────────────────────────────────────────────
+  loadBaseline() {
+    const p = join(this.rootDir, PATHS.BASELINE);
+    if (!existsSync(p)) {
+      return null;
     }
-  }
-  return result;
-}
-function runTestCheck(options) {
-  const { packages, onProgress } = options;
-  const result = { passed: [], failed: [], skipped: [], errors: {} };
-  for (const pkg of packages) {
-    let pkgJson;
     try {
-      pkgJson = JSON.parse(
-        readFileSync(join(pkg.dir, "package.json"), "utf-8")
-      );
+      return JSON.parse(readFileSync(p, "utf-8"));
     } catch {
-      result.skipped.push(pkg.name);
-      onProgress?.(pkg.name, "skip");
-      continue;
-    }
-    if (!pkgJson.scripts?.test) {
-      result.skipped.push(pkg.name);
-      onProgress?.(pkg.name, "skip");
-      continue;
+      return null;
     }
-    const startMs = Date.now();
-    try {
-      execSync("pnpm run test", {
-        cwd: pkg.dir,
-        encoding: "utf-8",
-        timeout: 12e4,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      result.passed.push(pkg.name);
-      onProgress?.(pkg.name, "pass", Date.now() - startMs);
-    } catch (err) {
-      result.failed.push(pkg.name);
-      const spawnErr = err;
-      const rawErr = (spawnErr.stdout || spawnErr.stderr || spawnErr.message || "").trim();
-      result.errors[pkg.name] = rawErr.slice(0, 2e3) || `Test failed (exit code ${spawnErr.status ?? 1})`;
-      onProgress?.(pkg.name, "fail", Date.now() - startMs);
-    }
-  }
-  return result;
-}
-function saveLastRun(rootDir, results, packages, submodules) {
-  const filePath = join(rootDir, PATHS.LAST_RUN);
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
   }
-  const data = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    results,
-    packages: packages.map((p) => ({
-      name: p.name,
-      dir: p.dir,
-      relativePath: p.relativePath,
-      repo: p.repo,
-      submodule: p.submodule
-    })),
-    submodules
-  };
-  writeFileSync(filePath, JSON.stringify(data, null, 2));
-}
-function loadLastRun(rootDir) {
-  const filePath = join(rootDir, PATHS.LAST_RUN);
-  if (!existsSync(filePath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(readFileSync(filePath, "utf-8"));
-  } catch {
-    return null;
+  saveBaseline(check, stats, git) {
+    const baseline = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...git ? { git } : {},
+      check,
+      stats
+    };
+    writeJson(join(this.rootDir, PATHS.BASELINE), baseline);
+    return baseline;
   }
-}
-
-// src/runner/qa-orchestrator.ts
-var SKIP_ALIASES = {
-  types: "typecheck",
-  "type-check": "typecheck",
-  tests: "test"
 };
-function runBuiltinChecks(options, packages, skipSet, results) {
-  const { rootDir, noCache } = options;
-  if (!skipSet.has("build")) {
-    results.build = runBuildCheck({
-      packages,
-      noCache,
-      onProgress: (pkg, status, durationMs) => options.onProgress?.("build", pkg, status, durationMs)
-    });
-  }
-  if (!skipSet.has("lint")) {
-    results.lint = runLintCheck({
-      packages,
-      onProgress: (pkg, status, durationMs) => options.onProgress?.("lint", pkg, status, durationMs)
-    });
-  }
-  if (!skipSet.has("typecheck")) {
-    results.typeCheck = runTypeCheck({
-      packages,
-      onProgress: (pkg, status, durationMs) => options.onProgress?.("typeCheck", pkg, status, durationMs)
-    });
-  }
-  if (!skipSet.has("test")) {
-    results.test = runTestCheck({
-      packages,
-      onProgress: (pkg, status, durationMs) => options.onProgress?.("test", pkg, status, durationMs)
-    });
-  }
+function extractFailed(snap, task) {
+  return snap.raw.results.filter((r) => r.Task === task && !r.OK && !r.Cached).map((r) => r.Package);
 }
-async function runQA(options) {
-  const { rootDir, noCache } = options;
-  const skipSet = new Set(
-    (options.skipChecks ?? []).map((s) => SKIP_ALIASES[s.toLowerCase()] ?? s.toLowerCase())
-  );
-  const filter = { package: options.package, repo: options.repo, scope: options.scope };
-  const packages = getWorkspacePackages(rootDir, filter, options.packagesConfig);
-  let cache = noCache ? {} : loadCache(rootDir);
-  const results = {};
-  if (options.checks && options.checks.length > 0) {
-    const activeChecks = skipSet.size > 0 ? options.checks.filter((c) => !skipSet.has(c.id.toLowerCase())) : options.checks;
-    Object.assign(results, runCustomChecks(
-      activeChecks,
-      packages,
-      rootDir,
-      (checkId, pkg, status, durationMs) => {
-        options.onProgress?.(checkId, pkg, status, durationMs);
-      }
-    ));
-  } else {
-    runBuiltinChecks(options, packages, skipSet, results);
-  }
-  if (!noCache) {
-    for (const pkg of packages) {
-      cache = updateCacheEntry(pkg.dir, pkg.name, cache);
-    }
-    saveCache(rootDir, cache);
-  }
-  const submodules = {};
-  for (const pkg of packages) {
-    if (pkg.submodule && !submodules[pkg.repo]) {
-      submodules[pkg.repo] = pkg.submodule;
+function collectTasks(snapshots) {
+  const s = /* @__PURE__ */ new Set();
+  for (const snap of snapshots) {
+    for (const r of snap.raw.results) {
+      s.add(r.Task);
     }
   }
-  saveLastRun(rootDir, results, packages, Object.keys(submodules).length > 0 ? submodules : void 0);
-  return { results, packages };
-}
-function loadBaseline(rootDir) {
-  const path = join(rootDir, PATHS.BASELINE);
-  if (!existsSync(path)) {
-    return null;
-  }
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function saveBaseline(rootDir, snapshot) {
-  const path = join(rootDir, PATHS.BASELINE);
-  const dir = dirname(path);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(path, JSON.stringify(snapshot, null, 2));
-}
-function getGitInfo(rootDir) {
-  try {
-    const commit = execSync("git rev-parse --short HEAD", {
-      cwd: rootDir,
-      encoding: "utf-8"
-    }).trim();
-    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-      cwd: rootDir,
-      encoding: "utf-8"
-    }).trim();
-    return { commit, branch };
-  } catch {
-    return { commit: "unknown", branch: "unknown" };
-  }
-}
-function createBaselineFromResults(results, rootDir) {
-  const git = getGitInfo(rootDir);
-  const snapshot = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    git,
-    results: {}
-  };
-  for (const ct of Object.keys(results)) {
-    const r = results[ct];
-    snapshot.results[ct] = {
-      passed: r.passed.length,
-      failed: r.failed.length,
-      failedPackages: [...r.failed]
-    };
-  }
-  return snapshot;
-}
-async function captureBaseline(rootDir) {
-  const { results } = await runQA({ rootDir });
-  const snapshot = createBaselineFromResults(results, rootDir);
-  saveBaseline(rootDir, snapshot);
-  return snapshot;
-}
-
-// src/baseline/baseline-comparator.ts
-function compareWithBaseline(results, baseline) {
-  const diff = {};
-  const checkTypes = [.../* @__PURE__ */ new Set([...Object.keys(results), ...Object.keys(baseline.results)])];
-  for (const ct of checkTypes) {
-    const current = new Set(results[ct]?.failed ?? []);
-    const baselineFailed = new Set(baseline.results[ct]?.failedPackages ?? []);
-    const newFailures = [...current].filter((p) => !baselineFailed.has(p));
-    const fixed = [...baselineFailed].filter((p) => !current.has(p));
-    const stillFailing = [...current].filter((p) => baselineFailed.has(p));
-    diff[ct] = {
-      newFailures,
-      fixed,
-      stillFailing,
-      delta: current.size - baselineFailed.size
-    };
-  }
-  return diff;
-}
-function trendPath(rootDir, checkId) {
-  return join(rootDir, QA_DATA_DIR, "trends", `${checkId}.json`);
-}
-function loadTrendHistory(rootDir, checkId) {
-  const path = trendPath(rootDir, checkId);
-  if (!existsSync(path)) {
-    return [];
-  }
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function appendTrendEntry(rootDir, checkId, entry) {
-  const path = trendPath(rootDir, checkId);
-  const dir = dirname(path);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  const entries = loadTrendHistory(rootDir, checkId);
-  entries.push(entry);
-  while (entries.length > HISTORY_MAX_ENTRIES) {
-    entries.shift();
-  }
-  writeFileSync(path, JSON.stringify(entries, null, 2));
-}
-
-// src/history/history-store.ts
-function loadHistory(rootDir) {
-  const path = join(rootDir, PATHS.HISTORY);
-  if (!existsSync(path)) {
-    return [];
-  }
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function saveHistory(rootDir, entries) {
-  const path = join(rootDir, PATHS.HISTORY);
-  const dir = dirname(path);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(path, JSON.stringify(entries, null, 2));
+  return [...s];
 }
-function createHistoryEntry(results, rootDir, packages, runContext) {
-  let commit = "unknown";
-  let branch = "unknown";
-  let message = "";
-  try {
-    commit = execSync("git rev-parse --short HEAD", { cwd: rootDir, encoding: "utf-8" }).trim();
-    branch = execSync("git rev-parse --abbrev-ref HEAD", { cwd: rootDir, encoding: "utf-8" }).trim();
-    message = execSync("git log -1 --format=%s", { cwd: rootDir, encoding: "utf-8" }).trim();
-  } catch {
-  }
-  const hasFailures = Object.values(results).some((r) => r.failed.length > 0);
-  const summary = {};
-  const failedPackages = {};
-  for (const ct of Object.keys(results)) {
-    const r = results[ct];
-    summary[ct] = {
-      passed: r.passed.length,
-      failed: r.failed.length,
-      skipped: r.skipped.length
+function buildTimeSeries(snapshots, task) {
+  return snapshots.map((snap) => {
+    const results = snap.raw.results.filter((r) => r.Task === task);
+    const failed = results.filter((r) => !r.OK && !r.Cached).length;
+    const cached = results.filter((r) => r.Cached).length;
+    const passed = results.filter((r) => r.OK && !r.Cached).length;
+    return {
+      timestamp: snap.timestamp,
+      gitCommit: snap.git?.commit ?? "unknown",
+      gitBranch: snap.git?.branch ?? "unknown",
+      gitMessage: snap.git?.message ?? "",
+      failed,
+      cached,
+      passed,
+      total: results.length
     };
-    failedPackages[ct] = [...r.failed];
-  }
-  let submodules;
-  if (packages) {
-    const subs = {};
-    for (const pkg of packages) {
-      if (pkg.submodule && !subs[pkg.repo]) {
-        subs[pkg.repo] = pkg.submodule;
-      }
-    }
-    if (Object.keys(subs).length > 0) {
-      submodules = subs;
-    }
-  }
-  return {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    git: { commit, branch, message },
-    submodules,
-    status: hasFailures ? "failed" : "passed",
-    summary,
-    failedPackages,
-    ...runContext ? { runContext } : {}
-  };
-}
-function appendEntry(rootDir, entry, checks) {
-  const history = loadHistory(rootDir);
-  history.push(entry);
-  while (history.length > HISTORY_MAX_ENTRIES) {
-    history.shift();
-  }
-  saveHistory(rootDir, history);
-  if (checks) {
-    for (const check of checks) {
-      if (check.trending && entry.summary[check.id] !== void 0) {
-        appendTrendEntry(rootDir, check.id, entry);
-      }
-    }
-  }
+  });
 }
-function collectCheckTypes(entries) {
-  const s = /* @__PURE__ */ new Set();
-  for (const e of entries) {
-    for (const k of Object.keys(e.summary)) {
-      s.add(k);
+function buildChangelog(snapshots, task) {
+  const changelog = [];
+  for (let i = 1; i < snapshots.length; i++) {
+    const prev = snapshots[i - 1];
+    const curr = snapshots[i];
+    const prevFailed = new Set(extractFailed(prev, task));
+    const currFailed = extractFailed(curr, task);
+    const currFailedSet = new Set(currFailed);
+    const newFailures = currFailed.filter((p) => !prevFailed.has(p));
+    const fixed = [...prevFailed].filter((p) => !currFailedSet.has(p));
+    const delta = currFailed.length - prevFailed.size;
+    if (newFailures.length > 0 || fixed.length > 0) {
+      changelog.push({
+        timestamp: curr.timestamp,
+        gitCommit: curr.git?.commit ?? "unknown",
+        gitMessage: curr.git?.message ?? "",
+        newFailures,
+        fixed,
+        delta
+      });
     }
   }
-  return [...s];
+  return changelog;
 }
 function analyzeTrends(history, window = TRENDS_WINDOW) {
   if (history.length < 2) {
-    return [];
-  }
-  const windowEntries = history.slice(-window);
-  const first = windowEntries[0];
-  const last = windowEntries[windowEntries.length - 1];
-  const results = [];
-  for (const ct of collectCheckTypes([first, last])) {
-    const previous = first.summary[ct]?.failed ?? 0;
-    const current = last.summary[ct]?.failed ?? 0;
-    const delta = current - previous;
-    let trend;
-    if (delta > 0) {
-      trend = "regression";
-    } else if (delta < 0) {
-      trend = "improvement";
-    } else {
-      trend = "no-change";
-    }
-    results.push({ checkType: ct, label: getCheckLabel(ct), icon: getCheckIcon(ct), previous, current, delta, trend });
-  }
-  return results;
-}
-function analyzeEnrichedTrends(history, window = TRENDS_WINDOW) {
-  if (history.length < 2) {
-    return [];
-  }
-  const windowEntries = history.slice(-window);
-  const first = windowEntries[0];
-  const last = windowEntries[windowEntries.length - 1];
-  const results = [];
-  for (const ct of collectCheckTypes(windowEntries)) {
-    const timeSeries = windowEntries.map((entry) => ({
-      timestamp: entry.timestamp,
-      gitCommit: entry.git.commit,
-      gitBranch: entry.git.branch,
-      gitMessage: entry.git.message,
-      passed: entry.summary[ct]?.passed ?? 0,
-      failed: entry.summary[ct]?.failed ?? 0,
-      skipped: entry.summary[ct]?.skipped ?? 0
-    }));
-    const changelog = [];
-    const deltas = [];
-    for (let i = 1; i < windowEntries.length; i++) {
-      const prev = windowEntries[i - 1];
-      const curr = windowEntries[i];
-      const prevFailed = new Set(prev.failedPackages[ct] ?? []);
-      const currFailed = curr.failedPackages[ct] ?? [];
-      const currFailedSet = new Set(currFailed);
-      const newFailures = currFailed.filter((p) => !prevFailed.has(p));
-      const fixed = [...prevFailed].filter((p) => !currFailedSet.has(p));
-      const delta2 = currFailed.length - prevFailed.size;
-      deltas.push(delta2);
-      if (newFailures.length > 0 || fixed.length > 0) {
-        changelog.push({
-          timestamp: curr.timestamp,
-          gitCommit: curr.git.commit,
-          gitMessage: curr.git.message,
-          newFailures,
-          fixed,
-          delta: delta2
-        });
-      }
-    }
-    const previous = first.summary[ct]?.failed ?? 0;
-    const current = last.summary[ct]?.failed ?? 0;
+    return { window, historyCount: history.length, tasks: [] };
+  }
+  const windowSnaps = history.slice(-window);
+  const first = windowSnaps[0];
+  const last = windowSnaps[windowSnaps.length - 1];
+  const tasks = collectTasks(windowSnaps);
+  const taskTrends = tasks.map((task) => {
+    const timeSeries = buildTimeSeries(windowSnaps, task);
+    const changelog = buildChangelog(windowSnaps, task);
+    const previous = extractFailed(first, task).length;
+    const current = extractFailed(last, task).length;
     const delta = current - previous;
-    let trend;
-    if (delta > 0) {
-      trend = "regression";
-    } else if (delta < 0) {
-      trend = "improvement";
-    } else {
-      trend = "no-change";
-    }
-    const velocity = deltas.length > 0 ? deltas.reduce((sum, d) => sum + d, 0) / deltas.length : 0;
-    results.push({
-      checkType: ct,
-      label: getCheckLabel(ct),
-      icon: getCheckIcon(ct),
-      timeSeries,
-      changelog,
-      current,
-      previous,
-      delta,
-      trend,
-      velocity: Math.round(velocity * 100) / 100
-    });
-  }
-  return results;
+    const deltas = changelog.map((c) => c.delta);
+    const velocity = deltas.length > 0 ? Math.round(deltas.reduce((s, d) => s + d, 0) / deltas.length * 100) / 100 : 0;
+    const direction = delta > 0 ? "regression" : delta < 0 ? "improvement" : "no-change";
+    return { task, previous, current, delta, direction, velocity, timeSeries, changelog };
+  });
+  return { window, historyCount: history.length, tasks: taskTrends };
 }
 
-// src/history/regression-detector.ts
+// src/analysis/regression-detector.ts
 function detectRegressions(history) {
   if (history.length < 2) {
-    return { hasRegressions: false, regressions: [] };
+    return {
+      hasRegressions: false,
+      regressions: [],
+      comparedAt: { previous: "", current: "" }
+    };
   }
-  const previous = history[history.length - 2];
-  const current = history[history.length - 1];
+  const prev = history[history.length - 2];
+  const curr = history[history.length - 1];
+  const allTasks = /* @__PURE__ */ new Set([
+    ...prev.raw.results.map((r) => r.Task),
+    ...curr.raw.results.map((r) => r.Task)
+  ]);
   const regressions = [];
-  const checkTypes = [.../* @__PURE__ */ new Set([...Object.keys(previous.failedPackages), ...Object.keys(current.failedPackages)])];
-  for (const ct of checkTypes) {
-    const prevFailed = new Set(previous.failedPackages[ct] ?? []);
-    const currFailed = current.failedPackages[ct] ?? [];
+  for (const task of allTasks) {
+    const prevFailed = new Set(
+      prev.raw.results.filter((r) => r.Task === task && !r.OK && !r.Cached).map((r) => r.Package)
+    );
+    const currFailed = curr.raw.results.filter((r) => r.Task === task && !r.OK && !r.Cached).map((r) => r.Package);
     const newFailures = currFailed.filter((p) => !prevFailed.has(p));
-    const delta = currFailed.length - prevFailed.size;
     if (newFailures.length > 0) {
       regressions.push({
-        checkType: ct,
-        delta,
+        task,
+        delta: currFailed.length - prevFailed.size,
         newFailures
       });
     }
   }
   return {
     hasRegressions: regressions.length > 0,
-    regressions
+    regressions,
+    comparedAt: { previous: prev.timestamp, current: curr.timestamp }
   };
 }
 
-// src/history/package-timeline.ts
-function buildEntries(history, packageName) {
-  let repo = "unknown";
-  const entries = [];
-  for (let i = history.length - 1; i >= 0; i--) {
-    const h = history[i];
-    const checks = {};
-    let found = false;
-    for (const ct of Object.keys(h.summary)) {
-      const failedList = h.failedPackages[ct] ?? [];
-      const summaryEntry = h.summary[ct];
-      if (failedList.includes(packageName)) {
-        checks[ct] = "failed";
-        found = true;
-      } else if (summaryEntry && (summaryEntry.passed > 0 || summaryEntry.failed > 0)) {
-        checks[ct] = "passed";
-        found = true;
-      } else {
-        checks[ct] = "skipped";
-      }
+// src/analysis/baseline-comparator.ts
+function issueKey(pkg, check, message) {
+  return `${pkg}::${check}::${message}`;
+}
+function compareWithBaseline(currentCheck, currentStats, baseline) {
+  const baselineIssues = /* @__PURE__ */ new Map();
+  for (const [pkg, pkgData] of Object.entries(baseline.check.packages)) {
+    for (const issue of pkgData.issues ?? []) {
+      const key = issueKey(pkg, issue.check, issue.message);
+      baselineIssues.set(key, {
+        pkg,
+        check: issue.check,
+        status: "fixed",
+        severity: issue.severity,
+        message: issue.message
+      });
     }
-    if (!found) {
-      continue;
+  }
+  const currentIssues = /* @__PURE__ */ new Map();
+  for (const [pkg, pkgData] of Object.entries(currentCheck.packages)) {
+    for (const issue of pkgData.issues ?? []) {
+      const key = issueKey(pkg, issue.check, issue.message);
+      currentIssues.set(key, {
+        pkg,
+        check: issue.check,
+        status: "new",
+        severity: issue.severity,
+        message: issue.message
+      });
     }
-    let submoduleCommit;
-    if (h.submodules) {
-      for (const [repoName, info] of Object.entries(h.submodules)) {
-        if (repoName === repo || repo === "unknown") {
-          submoduleCommit = info.commit;
-          if (repo === "unknown") {
-            repo = repoName;
-          }
-        }
-      }
+  }
+  const newIssues = [];
+  const fixedIssues = [];
+  const persistingIssues = [];
+  for (const [key, issue] of currentIssues) {
+    if (baselineIssues.has(key)) {
+      persistingIssues.push({ ...issue, status: "persisting" });
+    } else {
+      newIssues.push({ ...issue, status: "new" });
     }
-    entries.push({
-      timestamp: h.timestamp,
-      git: h.git,
-      submoduleCommit,
-      checks
-    });
   }
-  return { entries, repo };
+  for (const [key, issue] of baselineIssues) {
+    if (!currentIssues.has(key)) {
+      fixedIssues.push({ ...issue, status: "fixed" });
+    }
+  }
+  return {
+    newIssues,
+    fixedIssues,
+    persistingIssues,
+    newIssueCount: newIssues.length,
+    fixedIssueCount: fixedIssues.length,
+    scoreDelta: currentStats.score - baseline.stats.score,
+    gradeDelta: `${baseline.stats.grade} \u2192 ${currentStats.grade}`
+  };
 }
-function computeFlakyScore(entries) {
-  const allCheckTypes = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    for (const k of Object.keys(entry.checks)) {
-      allCheckTypes.add(k);
+
+// src/analysis/package-timeline.ts
+function buildPackageTimeline(history, packageName) {
+  const entries = [];
+  for (const snap of [...history].reverse()) {
+    for (const r of snap.raw.results.filter((r2) => r2.Package === packageName)) {
+      entries.push({
+        timestamp: snap.timestamp,
+        gitCommit: snap.git?.commit ?? "unknown",
+        task: r.Task,
+        status: r.Cached ? "cached" : r.OK ? "passed" : "failed"
+      });
     }
   }
-  const flakyChecks = [];
+  const taskNames = [...new Set(entries.map((e) => e.task))];
   let totalFlips = 0;
   let totalTransitions = 0;
-  for (const ct of allCheckTypes) {
+  const flakyTasks = [];
+  for (const task of taskNames) {
+    const taskEntries = entries.filter((e) => e.task === task && e.status !== "cached");
     let flips = 0;
-    let transitions = 0;
-    for (let i = 1; i < entries.length; i++) {
-      const prev = entries[i - 1].checks[ct];
-      const curr = entries[i].checks[ct];
-      if (prev === "skipped" || curr === "skipped" || !prev || !curr) {
-        continue;
-      }
-      transitions++;
-      if (prev !== curr) {
+    for (let i = 1; i < taskEntries.length; i++) {
+      totalTransitions++;
+      if (taskEntries[i].status !== taskEntries[i - 1].status) {
         flips++;
+        totalFlips++;
       }
     }
-    if (transitions > 0 && flips / transitions > 0.3) {
-      flakyChecks.push(ct);
+    if (taskEntries.length > 1 && flips / (taskEntries.length - 1) > 0.3) {
+      flakyTasks.push(task);
     }
-    totalFlips += flips;
-    totalTransitions += transitions;
   }
-  return {
-    flakyScore: totalTransitions > 0 ? Math.min(1, totalFlips / totalTransitions) : 0,
-    flakyChecks
-  };
-}
-function computeStreak(entries) {
+  const flakyScore = totalTransitions > 0 ? Math.round(totalFlips / totalTransitions * 100) / 100 : 0;
   const latest = entries[0];
-  if (!latest) {
-    return { status: "passing", count: 0 };
-  }
-  const streakStatus = Object.values(latest.checks).some((v) => v === "failed") ? "failing" : "passing";
-  let count = 1;
-  for (let i = 1; i < entries.length; i++) {
-    const eFail = Object.values(entries[i].checks).some((v) => v === "failed");
-    if ((eFail ? "failing" : "passing") !== streakStatus) {
-      break;
+  let streakStatus = "passing";
+  let streakCount = 0;
+  if (latest) {
+    streakStatus = latest.status === "failed" ? "failing" : "passing";
+    streakCount = 1;
+    for (let i = 1; i < entries.length; i++) {
+      const s = entries[i].status === "failed" ? "failing" : "passing";
+      if (s !== streakStatus) {
+        break;
+      }
+      streakCount++;
     }
-    count++;
   }
-  return { status: streakStatus, count };
-}
-function getPackageTimeline(history, packageName) {
-  const { entries, repo } = buildEntries(history, packageName);
-  const { flakyScore, flakyChecks } = computeFlakyScore(entries);
   let firstFailure;
-  for (let i = entries.length - 1; i >= 0; i--) {
-    if (Object.values(entries[i].checks).some((v) => v === "failed")) {
-      firstFailure = entries[i].timestamp;
+  for (const e of [...entries].reverse()) {
+    if (e.status === "failed") {
+      firstFailure = e.timestamp;
+      break;
     }
   }
   return {
     packageName,
-    repo,
-    entries,
-    flakyScore: Math.round(flakyScore * 100) / 100,
-    flakyChecks,
-    firstFailure,
-    currentStreak: computeStreak(entries)
+    history: entries,
+    flakyScore,
+    flakyTasks,
+    currentStreak: { status: streakStatus, count: streakCount },
+    firstFailure
   };
 }
 
-// src/report/json-reporter.ts
-function buildJsonReport(results, diff, checks) {
-  const severityMap = {};
-  if (checks) {
-    for (const c of checks) {
-      severityMap[c.id] = c.severity ?? "blocker";
-    }
-  }
-  const hasBlockerFailures = Object.entries(results).some(([ct, r]) => {
-    const sev = severityMap[ct] ?? "blocker";
-    return sev !== "info" && sev !== "warning" && r.failed.length > 0;
-  });
-  const summary = {};
-  const failures = {};
-  const errors = {};
-  const blockers = [];
-  const warnings = [];
-  for (const ct of Object.keys(results)) {
-    const r = results[ct];
-    const total = r.passed.length + r.failed.length + r.skipped.length;
-    summary[ct] = {
-      total,
-      passed: r.passed.length,
-      failed: r.failed.length,
-      skipped: r.skipped.length
-    };
-    failures[ct] = [...r.failed];
-    errors[ct] = { ...r.errors };
-    if (r.failed.length > 0) {
-      const sev = severityMap[ct] ?? "blocker";
-      const items = r.failed.flatMap((target) => {
-        const detailItems = r.details?.[target];
-        if (detailItems && detailItems.length > 0) {
-          return detailItems;
-        }
-        const msg = r.errors[target];
-        return msg ? [{ target, message: msg }] : [{ target, message: `check ${ct} failed` }];
-      });
-      if (sev === "blocker") {
-        blockers.push({ check: ct, items });
-      } else if (sev === "warning") {
-        warnings.push({ check: ct, items });
-      }
-    }
-  }
-  return {
-    status: hasBlockerFailures ? "failed" : "passed",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    summary,
-    failures,
-    errors,
-    baseline: diff ?? null,
-    blockers,
-    warnings
-  };
-}
-function buildDetailedJsonReport(results, grouped, diff, checks) {
-  const base = buildJsonReport(results, diff, checks);
-  return { ...base, grouped };
-}
-function icon(ct) {
-  return getCheckIcon(ct);
-}
-function label(ct) {
-  return getCheckLabel(ct);
+// src/report/text-reporter.ts
+function formatTaskName(task) {
+  return task.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 }
-function buildBaselineDiffLines(diff) {
-  const lines = [];
-  for (const ct of Object.keys(diff)) {
-    const d = diff[ct];
-    if (d.newFailures.length > 0) {
-      lines.push(`${icon(ct)} ${label(ct)}: +${d.newFailures.length} new failures`);
-      for (const pkg of d.newFailures) {
-        lines.push(`     - ${pkg}`);
-      }
-    }
-    if (d.fixed.length > 0) {
-      lines.push(`${icon(ct)} ${label(ct)}: -${d.fixed.length} fixed`);
-    }
+function buildRunReport(snap) {
+  if (!snap) {
+    return [{ header: "Run", lines: ["No run data available."] }];
   }
-  return lines;
-}
-function buildRunReport(results, diff) {
   const sections = [];
-  const summaryLines = [];
-  let totalPassed = 0;
-  let totalFailed = 0;
-  let totalSkipped = 0;
-  for (const ct of Object.keys(results)) {
-    const r = results[ct];
-    const total = r.passed.length + r.failed.length + r.skipped.length;
-    const pct = total > 0 ? Math.round(r.passed.length / total * 100) : 100;
-    const status = r.failed.length === 0 ? "PASS" : "FAIL";
-    summaryLines.push(`${status} ${icon(ct)}  ${label(ct).padEnd(12)} ${r.passed.length}/${total} passed (${pct}%)`);
-    if (r.failed.length > 0) {
-      for (const pkg of r.failed.slice(0, 5)) {
-        summaryLines.push(`     - ${pkg}`);
+  const tasks = [...new Set(snap.raw.results.map((r) => r.Task))];
+  for (const task of tasks) {
+    const results = snap.raw.results.filter((r) => r.Task === task);
+    const passed = results.filter((r) => r.OK && !r.Cached).length;
+    const failed = results.filter((r) => !r.OK && !r.Cached).length;
+    const cached = results.filter((r) => r.Cached).length;
+    const failedPkgs = results.filter((r) => !r.OK && !r.Cached).map((r) => r.Package);
+    const lines = [`pass ${passed}  fail ${failed}  cached ${cached}`];
+    if (failedPkgs.length > 0) {
+      const shown = failedPkgs.slice(0, 5);
+      lines.push(...shown.map((p2) => `  \u2717 ${p2}`));
+      if (failedPkgs.length > 5) {
+        lines.push(`  ... ${failedPkgs.length - 5} more`);
       }
-      if (r.failed.length > 5) {
-        summaryLines.push(`     ... and ${r.failed.length - 5} more`);
-      }
-    }
-    totalPassed += r.passed.length;
-    totalFailed += r.failed.length;
-    totalSkipped += r.skipped.length;
-  }
-  sections.push({ header: "QA Summary Report", lines: summaryLines });
-  if (diff) {
-    const diffLines = buildBaselineDiffLines(diff);
-    if (diffLines.length > 0) {
-      sections.push({ header: "Baseline Comparison", lines: diffLines });
     }
+    sections.push({ header: formatTaskName(task), lines });
   }
+  const status = snap.raw.ok ? "passed" : "failed";
+  const { total, passed: p, failed: f, cached: c } = snap.raw.summary;
   sections.push({
-    header: "Totals",
-    lines: [`Total: ${totalPassed} passed, ${totalFailed} failed, ${totalSkipped} skipped`]
+    header: "Summary",
+    lines: [`${status.toUpperCase()}  total ${total}  pass ${p}  fail ${f}  cached ${c}  (${snap.raw.elapsed})`]
   });
   return sections;
 }
-function buildHistoryTable(history, limit = 20) {
-  const entries = history.slice(-limit);
-  const lines = [];
-  for (const entry of entries) {
-    const date = new Date(entry.timestamp).toLocaleDateString();
-    const status = entry.status === "passed" ? "PASS" : "FAIL";
-    const summary = Object.keys(entry.summary).map((ct) => {
-      const s = entry.summary[ct];
-      return `${icon(ct)} ${s.failed}F`;
-    }).join(" ");
-    lines.push(`${date} ${entry.git.commit} ${status} ${summary} ${entry.git.message.slice(0, 40)}`);
-  }
-  return [{ header: `QA History (last ${entries.length})`, lines }];
-}
-function buildTrendsReport(trends, history) {
-  if (trends.length === 0) {
-    return [{ header: "QA Trends", lines: ["Not enough history (need at least 2 entries)"] }];
-  }
-  const lines = [];
-  for (const t of trends) {
-    const arrow = t.delta > 0 ? `+${t.delta} (regression)` : t.delta < 0 ? `${t.delta} (improvement)` : "\u2192 no change";
-    lines.push(`${icon(t.checkType)} ${label(t.checkType).padEnd(12)} ${t.previous} \u2192 ${t.current}  ${arrow}`);
-  }
-  if (history.length >= 2) {
-    const first = history[Math.max(0, history.length - 10)];
-    const last = history[history.length - 1];
-    lines.push("");
-    lines.push(`Period: ${new Date(first.timestamp).toLocaleDateString()} \u2192 ${new Date(last.timestamp).toLocaleDateString()}`);
-  }
-  return [{ header: "QA Trends", lines }];
-}
-function buildRegressionsReport(result, history) {
-  if (history.length < 2) {
-    return [{ header: "Regression Detection", lines: ["Not enough history (need at least 2 entries)"] }];
-  }
-  const prev = history[history.length - 2];
-  const curr = history[history.length - 1];
-  const lines = [
-    `Comparing: ${prev.git.commit} \u2192 ${curr.git.commit}`,
-    ""
-  ];
-  if (!result.hasRegressions) {
-    lines.push("No regressions detected.");
-    return [{ header: "Regression Detection", lines }];
+function buildCheckReport(snap) {
+  if (!snap) {
+    return [{ header: "Check", lines: ["No check data available."] }];
   }
-  for (const r of result.regressions) {
-    lines.push(`${r.checkType}: +${r.newFailures.length} new failures`);
-    for (const pkg of r.newFailures) {
-      lines.push(`  - ${pkg}`);
+  const sections = [];
+  for (const [pkg, pkgData] of Object.entries(snap.raw.packages)) {
+    const issues = pkgData.issues ?? [];
+    if (issues.length === 0) {
+      continue;
     }
-  }
-  lines.push("");
-  lines.push("REGRESSIONS DETECTED!");
-  return [{ header: "Regression Detection", lines }];
-}
-function buildBaselineReport(baseline) {
-  if (!baseline) {
-    return [{ header: "Baseline Status", lines: ["No baseline captured yet. Run baseline:update first."] }];
-  }
-  const lines = [
-    `Captured: ${new Date(baseline.timestamp).toLocaleString()}`,
-    `Git: ${baseline.git.commit} (${baseline.git.branch})`,
-    ""
-  ];
-  for (const ct of Object.keys(baseline.results)) {
-    const r = baseline.results[ct];
-    lines.push(`${icon(ct)} ${label(ct).padEnd(12)} ${r.passed} passed, ${r.failed} failed`);
-    if (r.failedPackages.length > 0) {
-      const shown = r.failedPackages.slice(0, 3);
-      for (const pkg of shown) {
-        lines.push(`     - ${pkg}`);
-      }
-      if (r.failedPackages.length > 3) {
-        lines.push(`     ... and ${r.failedPackages.length - 3} more`);
-      }
+    const errors = issues.filter((i) => i.severity === "error").length;
+    const warnings = issues.filter((i) => i.severity === "warning").length;
+    const infos = issues.filter((i) => i.severity === "info").length;
+    const lines = [`errors ${errors}  warnings ${warnings}  info ${infos}`];
+    for (const issue of issues.slice(0, 5)) {
+      lines.push(`  [${issue.severity}] ${issue.check}: ${issue.message}`);
     }
-  }
-  return [{ header: "Baseline Status", lines }];
-}
-function checkTag(status, ct) {
-  const short = ct === "typeCheck" ? "types" : ct;
-  if (status === "failed") {
-    return short.toUpperCase();
-  }
-  if (status === "skipped") {
-    return `-${short}-`;
-  }
-  return short;
-}
-function getErrorPreview(raw) {
-  const errLines = raw.split("\n").filter((l) => l.trim().length > 0);
-  for (const el of errLines) {
-    const cleaned = el.replace(/^Command failed: .*/, "").trim();
-    if (cleaned.length > 0) {
-      return cleaned.replace(/\/[^\s]*\/kb-labs\//g, "").slice(0, 100);
+    if (issues.length > 5) {
+      lines.push(`  ... ${issues.length - 5} more`);
     }
+    sections.push({ header: pkg, lines });
   }
-  return "";
-}
-function renderPackageLines(pkg, lines) {
-  const hasFail = Object.values(pkg.checks).some((v) => v === "failed");
-  const status = hasFail ? "FAIL" : "PASS";
-  const tags = Object.keys(pkg.checks).map((ct) => checkTag(pkg.checks[ct], ct)).join(" ");
-  lines.push(`    ${status} ${pkg.name.padEnd(40)} ${tags}`);
-  if (hasFail) {
-    for (const ct of Object.keys(pkg.checks)) {
-      if (pkg.checks[ct] === "failed") {
-        const preview = getErrorPreview((pkg.errors[ct] ?? "").trim());
-        lines.push(`         ${ct}: ${preview || "failed"}`);
-      }
-    }
+  if (sections.length === 0) {
+    sections.push({ header: "Check", lines: ["All packages OK."] });
   }
+  return sections;
 }
-function renderCategoryLines(catKey, grouped) {
-  const cat = grouped.categories[catKey];
-  const lines = [`PASS ${cat.summary.passed} | FAIL ${cat.summary.failed}`, ""];
-  for (const repoKey of Object.keys(cat.repos).sort()) {
-    const repo = cat.repos[repoKey];
-    lines.push(`  ${repoKey} (${repo.summary.total} packages)`);
-    const sorted = [...repo.packages].sort((a, b) => {
-      const aFail = Object.values(a.checks).some((v) => v === "failed") ? 0 : 1;
-      const bFail = Object.values(b.checks).some((v) => v === "failed") ? 0 : 1;
-      if (aFail !== bFail) {
-        return aFail - bFail;
-      }
-      return a.name.localeCompare(b.name);
-    });
-    for (const pkg of sorted) {
-      renderPackageLines(pkg, lines);
-    }
-    lines.push("");
+function buildStatsReport(snap) {
+  if (!snap) {
+    return [{ header: "Stats", lines: ["No stats data available."] }];
   }
-  return lines;
-}
-function buildDetailedRunReport(grouped, diff) {
+  const { score, grade, summary, by_category, coverage } = snap.raw;
   const sections = [];
-  const categoryKeys = Object.keys(grouped.categories).sort((a, b) => {
-    if (a === "uncategorized") {
-      return 1;
-    }
-    if (b === "uncategorized") {
-      return -1;
-    }
-    return a.localeCompare(b);
-  });
-  for (const catKey of categoryKeys) {
-    const cat = grouped.categories[catKey];
-    sections.push({ header: `${cat.label} (${cat.summary.total} packages)`, lines: renderCategoryLines(catKey, grouped) });
-  }
-  if (diff) {
-    const diffLines = buildBaselineDiffLines(diff);
-    if (diffLines.length > 0) {
-      sections.push({ header: "Baseline Comparison", lines: diffLines });
-    }
-  }
-  let totalPassed = 0;
-  let totalFailed = 0;
-  for (const catKey of categoryKeys) {
-    totalPassed += grouped.categories[catKey].summary.passed;
-    totalFailed += grouped.categories[catKey].summary.failed;
-  }
   sections.push({
-    header: "Totals",
-    lines: [`Total: ${totalPassed} passed, ${totalFailed} failed (${categoryKeys.length} categories)`]
+    header: "Score",
+    lines: [`${score}/100  Grade: ${grade}  (${summary.healthy} healthy / ${summary.warning} warning / ${summary.error} error)`]
   });
-  return sections;
-}
-
-// src/report/grouped-reporter.ts
-function emptyGroupSummary(checkTypes) {
-  const checks = {};
-  for (const ct of checkTypes) {
-    checks[ct] = { passed: 0, failed: 0, skipped: 0 };
-  }
-  return { total: 0, passed: 0, failed: 0, checks };
-}
-function resolveCheckStatus(pkgName, ct, results) {
-  const r = results[ct];
-  if (!r) {
-    return "skipped";
-  }
-  if (r.failed.includes(pkgName)) {
-    return "failed";
-  }
-  if (r.passed.includes(pkgName)) {
-    return "passed";
+  const catLines = Object.entries(by_category).map(([cat, data]) => {
+    const pct = data.total > 0 ? Math.round(data.healthy / data.total * 100) : 0;
+    return `  ${cat.padEnd(20)} ${data.grade}  ${pct}%  (${data.healthy}/${data.total})`;
+  });
+  sections.push({ header: "By Category", lines: catLines });
+  if (Object.keys(coverage).length > 0) {
+    const covLines = Object.entries(coverage).map(([k, v]) => `  ${k.padEnd(20)} ${v.pct}%  (${v.pass}/${v.total})`);
+    sections.push({ header: "Coverage", lines: covLines });
   }
-  return "skipped";
+  return sections;
 }
-function buildPackageStatus(pkg, results, category) {
-  const checks = {};
-  const errors = {};
-  for (const ct of Object.keys(results)) {
-    checks[ct] = resolveCheckStatus(pkg.name, ct, results);
-    if (checks[ct] === "failed" && results[ct]?.errors[pkg.name]) {
-      errors[ct] = results[ct].errors[pkg.name];
-    }
-  }
-  return {
-    name: pkg.name,
-    repo: pkg.repo,
-    category,
-    checks,
-    errors
-  };
+function buildHistoryTable(history, limit = 20) {
+  const rows = [...history].reverse().slice(0, limit);
+  if (rows.length === 0) {
+    return [{ header: "History", lines: ["No history available."] }];
+  }
+  const lines = rows.map((snap) => {
+    const status = snap.raw.ok ? "pass" : "fail";
+    const tasks = snap.tasks.join(", ");
+    const commit = snap.git?.commit ?? "-------";
+    const date = new Date(snap.timestamp).toLocaleString();
+    return `  ${date}  ${commit}  ${status}  [${tasks}]`;
+  });
+  return [{ header: `History (last ${rows.length})`, lines }];
 }
-function addToSummary(summary, status) {
-  summary.total++;
-  const hasFail = Object.values(status.checks).some((v) => v === "failed");
-  if (hasFail) {
-    summary.failed++;
-  } else {
-    summary.passed++;
+function buildTrendsReport(analysis) {
+  if (analysis.tasks.length === 0) {
+    return [{ header: "Trends", lines: ["Not enough history for trend analysis."] }];
   }
-  for (const ct of Object.keys(status.checks)) {
-    const s = status.checks[ct];
-    if (!summary.checks[ct]) {
-      summary.checks[ct] = { passed: 0, failed: 0, skipped: 0 };
-    }
-    if (s === "passed") {
-      summary.checks[ct].passed++;
-    } else if (s === "failed") {
-      summary.checks[ct].failed++;
-    } else {
-      summary.checks[ct].skipped++;
-    }
-  }
-}
-function groupResults(results, packages, categoryMap, config) {
-  const checkTypes = Object.keys(results);
-  const grouped = { categories: {} };
-  for (const pkg of packages) {
-    const categoryKeys = categoryMap.get(pkg.name) ?? ["uncategorized"];
-    for (const categoryKey of categoryKeys) {
-      const status = buildPackageStatus(pkg, results, categoryKey);
-      if (!grouped.categories[categoryKey]) {
-        const label2 = categoryKey === "uncategorized" ? "Uncategorized" : config?.categories?.[categoryKey]?.label ?? categoryKey;
-        grouped.categories[categoryKey] = {
-          label: label2,
-          repos: {},
-          summary: emptyGroupSummary(checkTypes)
-        };
+  const sections = [];
+  for (const trend of analysis.tasks) {
+    const arrow = trend.direction === "regression" ? "\u2191" : trend.direction === "improvement" ? "\u2193" : "\u2192";
+    const lines = [
+      `${arrow} ${trend.direction}  prev ${trend.previous}  curr ${trend.current}  delta ${trend.delta > 0 ? "+" : ""}${trend.delta}  velocity ${trend.velocity}`
+    ];
+    if (trend.changelog.length > 0) {
+      const last = trend.changelog[trend.changelog.length - 1];
+      if (last.newFailures.length > 0) {
+        lines.push(`  last regression: ${last.newFailures.slice(0, 3).join(", ")}`);
       }
-      const categoryGroup = grouped.categories[categoryKey];
-      if (!categoryGroup.repos[pkg.repo]) {
-        categoryGroup.repos[pkg.repo] = {
-          packages: [],
-          summary: emptyGroupSummary(checkTypes)
-        };
+      if (last.fixed.length > 0) {
+        lines.push(`  last fixed: ${last.fixed.slice(0, 3).join(", ")}`);
       }
-      const repoGroup = categoryGroup.repos[pkg.repo];
-      repoGroup.packages.push(status);
-      addToSummary(repoGroup.summary, status);
-      addToSummary(categoryGroup.summary, status);
     }
+    sections.push({ header: formatTaskName(trend.task), lines });
   }
-  return grouped;
+  return sections;
 }
-
-// src/report/error-grouping.ts
-function extractPattern(errorText, checkType) {
-  if (checkType === "lint") {
-    const ruleMatch = errorText.match(/(\S+\/[\w-]+|no-[\w-]+)/);
-    if (ruleMatch?.[1]) {
-      return ruleMatch[1];
-    }
-  }
-  if (checkType === "typeCheck") {
-    const tsMatch = errorText.match(/TS(\d{4,5})/);
-    if (tsMatch) {
-      return `TS${tsMatch[1]}`;
-    }
-  }
-  if (checkType === "test") {
-    const failMatch = errorText.match(/FAIL\s+(\S+)/);
-    if (failMatch) {
-      return `FAIL: ${failMatch[1]}`;
-    }
-  }
-  if (checkType === "build") {
-    if (errorText.includes("Cannot find module")) {
-      return "Cannot find module";
-    }
-    if (errorText.includes("Module not found")) {
-      return "Module not found";
-    }
+function buildRegressionsReport(detection) {
+  if (!detection.hasRegressions) {
+    return [{ header: "Regressions", lines: ["No regressions detected."] }];
   }
-  const firstLine = errorText.split("\n").find((l) => l.trim().length > 0)?.trim() ?? "";
-  return firstLine.slice(0, 100) || "Unknown error";
+  const sections = [];
+  for (const reg of detection.regressions) {
+    const lines = [
+      `delta +${reg.delta}`,
+      ...reg.newFailures.slice(0, 5).map((p) => `  \u2717 ${p}`)
+    ];
+    if (reg.newFailures.length > 5) {
+      lines.push(`  ... ${reg.newFailures.length - 5} more`);
+    }
+    sections.push({ header: formatTaskName(reg.task), lines });
+  }
+  const prev = new Date(detection.comparedAt.previous).toLocaleString();
+  const curr = new Date(detection.comparedAt.current).toLocaleString();
+  sections.push({ header: "Compared", lines: [`${prev} \u2192 ${curr}`] });
+  return sections;
 }
-function groupErrors(results) {
-  const groupMap = /* @__PURE__ */ new Map();
-  let ungrouped = 0;
-  for (const ct of Object.keys(results)) {
-    const check = results[ct];
-    if (!check.errors) {
-      continue;
-    }
-    for (const [pkgName, errorText] of Object.entries(check.errors)) {
-      const pattern = extractPattern(errorText, ct);
-      const key = `${ct}::${pattern}`;
-      const existing = groupMap.get(key);
-      if (existing) {
-        existing.count++;
-        existing.packages.push(pkgName);
-      } else {
-        groupMap.set(key, {
-          pattern,
-          count: 1,
-          packages: [pkgName],
-          checkType: ct,
-          example: errorText.slice(0, 200)
-        });
-      }
+function buildBaselineReport(baseline) {
+  if (!baseline) {
+    return [{ header: "Baseline", lines: ["No baseline set. Run `qa baseline update` to set one."] }];
+  }
+  const { score, grade } = baseline.stats;
+  const totalIssues = Object.values(baseline.check.packages).reduce((sum, pkg) => sum + (pkg.issues?.length ?? 0), 0);
+  const commit = baseline.git?.commit ?? "unknown";
+  const date = new Date(baseline.timestamp).toLocaleString();
+  return [{
+    header: "Baseline",
+    lines: [`score ${score}/100  grade ${grade}  issues ${totalIssues}  commit ${commit}  set ${date}`]
+  }];
+}
+function buildBaselineDiffReport(diff) {
+  const sections = [];
+  const scoreDir = diff.scoreDelta > 0 ? "+" : "";
+  sections.push({
+    header: "Score Delta",
+    lines: [`${scoreDir}${diff.scoreDelta}  ${diff.gradeDelta}  new ${diff.newIssueCount}  fixed ${diff.fixedIssueCount}`]
+  });
+  if (diff.newIssues.length > 0) {
+    const lines = diff.newIssues.slice(0, 10).map((i) => `  [${i.severity}] ${i.pkg}  ${i.check}: ${i.message}`);
+    if (diff.newIssues.length > 10) {
+      lines.push(`  ... ${diff.newIssues.length - 10} more`);
     }
+    sections.push({ header: "New Issues", lines });
   }
-  const groups = [];
-  for (const group of groupMap.values()) {
-    if (group.count === 1) {
-      ungrouped++;
-    } else {
-      groups.push(group);
+  if (diff.fixedIssues.length > 0) {
+    const lines = diff.fixedIssues.slice(0, 10).map((i) => `  [${i.severity}] ${i.pkg}  ${i.check}: ${i.message}`);
+    if (diff.fixedIssues.length > 10) {
+      lines.push(`  ... ${diff.fixedIssues.length - 10} more`);
     }
+    sections.push({ header: "Fixed Issues", lines });
   }
-  groups.sort((a, b) => b.count - a.count);
-  return { groups, ungrouped };
+  if (diff.persistingIssues.length > 0) {
+    sections.push({ header: "Persisting Issues", lines: [`${diff.persistingIssues.length} issues unchanged`] });
+  }
+  return sections;
 }
 
-// src/categories/category-resolver.ts
-function matchesPattern2(packageName, repo, pattern) {
-  if (pattern.includes("/") && pattern.endsWith("/*")) {
-    const repoPrefix = pattern.slice(0, -2);
-    return repo === repoPrefix;
-  }
-  if (!pattern.includes("*")) {
-    return packageName === pattern;
-  }
-  const prefix = pattern.slice(0, pattern.indexOf("*"));
-  return packageName.startsWith(prefix);
+// src/report/json-reporter.ts
+function buildRunJsonReport(snap) {
+  return {
+    id: snap.id,
+    timestamp: snap.timestamp,
+    git: snap.git,
+    durationMs: snap.durationMs,
+    tasks: snap.tasks,
+    ok: snap.raw.ok,
+    elapsed: snap.raw.elapsed,
+    summary: snap.raw.summary,
+    results: snap.raw.results
+  };
 }
-function resolveCategories(packages, config) {
-  const map = /* @__PURE__ */ new Map();
-  if (!config?.categories) {
-    for (const pkg of packages) {
-      map.set(pkg.name, ["uncategorized"]);
-    }
-    return map;
-  }
-  const categoryEntries = Object.entries(config.categories);
-  for (const pkg of packages) {
-    const matched = [];
-    for (const [categoryKey, categoryConfig] of categoryEntries) {
-      for (const pattern of categoryConfig.packages) {
-        if (matchesPattern2(pkg.name, pkg.repo, pattern)) {
-          matched.push(categoryKey);
-          break;
-        }
-      }
-    }
-    map.set(pkg.name, matched.length > 0 ? matched : ["uncategorized"]);
-  }
-  return map;
+function buildCheckJsonReport(snap) {
+  return {
+    id: snap.id,
+    timestamp: snap.timestamp,
+    git: snap.git,
+    durationMs: snap.durationMs,
+    ok: snap.raw.ok,
+    packages: snap.raw.packages
+  };
+}
+function buildStatsJsonReport(snap) {
+  return {
+    id: snap.id,
+    timestamp: snap.timestamp,
+    git: snap.git,
+    durationMs: snap.durationMs,
+    ok: snap.raw.ok,
+    score: snap.raw.score,
+    grade: snap.raw.grade,
+    summary: snap.raw.summary,
+    by_category: snap.raw.by_category,
+    issues_by_type: snap.raw.issues_by_type,
+    coverage: snap.raw.coverage
+  };
 }
 
-export { analyzeEnrichedTrends, analyzeTrends, appendEntry, appendTrendEntry, buildBaselineReport, buildDetailedJsonReport, buildDetailedRunReport, buildHistoryTable, buildJsonReport, buildRegressionsReport, buildRunReport, buildTrendsReport, captureBaseline, collectSubmoduleInfo, compareWithBaseline, createBaselineFromResults, createHistoryEntry, detectRegressions, getPackageTimeline, getSubmoduleInfo, getWorkspacePackages, groupErrors, groupResults, loadBaseline, loadHistory, loadLastRun, loadTrendHistory, resolveCategories, runCustomChecks, runLintCheck, runQA, runTestCheck, runTypeCheck, saveBaseline, saveHistory, saveLastRun };
+export { DevkitAdapter, SnapshotStore, analyzeTrends, buildBaselineDiffReport, buildBaselineReport, buildCheckJsonReport, buildCheckReport, buildHistoryTable, buildPackageTimeline, buildRegressionsReport, buildRunJsonReport, buildRunReport, buildStatsJsonReport, buildStatsReport, buildTrendsReport, captureGit, compareWithBaseline, detectRegressions, formatTaskName, resolveDevkitBin };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map