@elench/testkit 0.1.150 → 0.1.151

package/lib/regressions/index.mjs

@@ -3,90 +3,121 @@ import path from "path";
 
 const CLASSIFICATIONS = new Set([
   "expected_failure",
+  "flaky",
+  "harness_bug",
   "infra",
   "product_bug",
   "stale_test",
   "test_bug",
 ]);
 
-export function loadRegressionCatalogConfig(productDir, config) {
+const CASE_STATES = new Set([
+  "active",
+  "coverage_missing",
+  "fixed_pending_verification",
+  "fix_claimed",
+  "resolved",
+  "untriaged",
+]);
+
+export function loadRegressionCaseStoreConfig(productDir, config) {
   const relativePath = config?.file;
   if (!relativePath) return null;
 
   const absolutePath = path.resolve(productDir, relativePath);
   if (!fs.existsSync(absolutePath)) {
-    throw new Error(`Regression catalog not found: ${relativePath}`);
+    throw new Error(`Regression case store not found: ${relativePath}`);
   }
 
-  return loadRegressionCatalogDocument(absolutePath, relativePath);
+  const document = loadRegressionCaseStoreDocument(absolutePath, relativePath);
+  Object.defineProperty(document, "__filePath", {
+    value: absolutePath,
+    enumerable: false,
+    configurable: false,
+  });
+  return document;
 }
 
-export function loadRegressionCatalogDocument(filePath, relativePath = filePath) {
+export function writeRegressionCaseStoreDocument(filePath, document) {
+  fs.writeFileSync(filePath, `${JSON.stringify(serializeRegressionCaseStore(document), null, 2)}\n`);
+}
+
+export function serializeRegressionCaseStore(document) {
+  const normalized = normalizeRegressionCaseStoreDocument(document);
+  return {
+    schemaVersion: 2,
+    issueRepo: normalized.issueRepo,
+    cases: normalized.cases,
+  };
+}
+
+export function loadRegressionCaseStoreDocument(filePath, relativePath = filePath) {
   let parsed;
   try {
     parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
   } catch (error) {
     throw new Error(
-      `Could not parse regression catalog ${relativePath}: ${formatErrorMessage(error)}`
+      `Could not parse regression case store ${relativePath}: ${formatErrorMessage(error)}`
     );
   }
 
-  return normalizeRegressionCatalogDocument(parsed, relativePath);
+  return normalizeRegressionCaseStoreDocument(parsed, relativePath);
 }
 
-export function normalizeRegressionCatalogDocument(document, relativePath = "regression catalog") {
+export function normalizeRegressionCaseStoreDocument(document, relativePath = "regression case store") {
   if (!document || typeof document !== "object") {
     throw new Error(`${relativePath} must contain a JSON object`);
   }
-  if (document.schemaVersion !== 1) {
-    throw new Error(`${relativePath} schemaVersion must be 1`);
+  if (document.schemaVersion !== 2) {
+    throw new Error(`${relativePath} schemaVersion must be 2`);
   }
-  if (!Array.isArray(document.entries)) {
-    throw new Error(`${relativePath} entries must be an array`);
+  if (!Array.isArray(document.cases)) {
+    throw new Error(`${relativePath} cases must be an array`);
   }
 
   const ids = new Set();
-  const entries = document.entries.map((entry, index) => {
-    const normalized = normalizeRegressionEntry(entry, `${relativePath} entries[${index}]`);
+  const cases = document.cases.map((entry, index) => {
+    const normalized = normalizeRegressionCase(entry, `${relativePath} cases[${index}]`);
     if (ids.has(normalized.id)) {
-      throw new Error(`${relativePath} has duplicate entry id "${normalized.id}"`);
+      throw new Error(`${relativePath} has duplicate case id "${normalized.id}"`);
     }
     ids.add(normalized.id);
     return normalized;
   });
 
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     issueRepo: normalizeOptionalString(document.issueRepo),
-    entries,
+    cases,
   };
 }
 
-export function validateRegressionCatalogDocument(
+export function validateRegressionCaseStoreDocument(
   document,
   { productDir, statusArtifactPath, statusArtifact } = {}
 ) {
+  const normalizedDocument = normalizeRegressionCaseStoreDocument(document);
   const errors = [];
   const warnings = [];
   const fingerprintKeys = new Set();
   let fingerprintCount = 0;
 
-  for (const entry of document.entries) {
-    for (const fingerprint of entry.fingerprints) {
+  for (const regressionCase of normalizedDocument.cases) {
+    for (const fingerprint of regressionCase.fingerprints) {
       fingerprintCount += 1;
       if (productDir) {
         if (fingerprint.path) {
           const absolutePath = path.join(productDir, fingerprint.path);
           if (!fs.existsSync(absolutePath)) {
-            errors.push(`Missing matched file: ${fingerprint.path} (${entry.id})`);
+            errors.push(`Missing matched file: ${fingerprint.path} (${regressionCase.id})`);
           }
         } else if (!fingerprint.pathGlob) {
-          errors.push(`Missing matched file: ${fingerprint.path} (${entry.id})`);
+          errors.push(`Missing matched file: ${fingerprint.path} (${regressionCase.id})`);
         }
       }
 
       const fingerprintKey = [
-        entry.id,
+        regressionCase.id,
         fingerprint.service || "",
         fingerprint.type || "",
         fingerprint.path || "",
@@ -95,28 +126,29 @@ export function validateRegressionCatalogDocument(
         fingerprint.errorIncludes || "",
       ].join("::");
       if (fingerprintKeys.has(fingerprintKey)) {
-        errors.push(`Duplicate fingerprint selector in ${entry.id}: ${fingerprint.path}`);
+        errors.push(`Duplicate fingerprint selector in ${regressionCase.id}: ${fingerprint.path}`);
       }
       fingerprintKeys.add(fingerprintKey);
 
       const displayPath = fingerprint.path || fingerprint.pathGlob;
       if (!displayPath.includes("__testkit__") || !displayPath.endsWith(".testkit.ts")) {
         warnings.push(
-          `Fingerprint path does not look like a testkit file: ${displayPath} (${entry.id})`
+          `Fingerprint path does not look like a testkit file: ${displayPath} (${regressionCase.id})`
         );
       }
     }
 
-    if (document.issueRepo && entry.issue.repo !== document.issueRepo) {
+    if (
+      normalizedDocument.issueRepo &&
+      regressionCase.issue &&
+      regressionCase.issue.repo !== normalizedDocument.issueRepo
+    ) {
       warnings.push(
-        `Entry ${entry.id} uses issue repo ${entry.issue.repo} instead of document issueRepo ${document.issueRepo}`
+        `Case ${regressionCase.id} uses issue repo ${regressionCase.issue.repo} instead of document issueRepo ${normalizedDocument.issueRepo}`
       );
     }
   }
 
-  let failedTests = 0;
-  let diagnosedFailedTests = 0;
-  let newFailedTests = 0;
   const parsedStatusArtifact = statusArtifact
     ? parseStatusArtifact(statusArtifact)
     : statusArtifactPath && fs.existsSync(statusArtifactPath)
@@ -124,13 +156,14 @@ export function validateRegressionCatalogDocument(
       : { tests: [] };
 
   const failed = parsedStatusArtifact.tests.filter((test) => test.status === "failed");
-  failedTests = failed.length;
+  let diagnosedFailedTests = 0;
+  let newFailedTests = 0;
   for (const test of failed) {
-    if (findMatchingRegressionEntries(document, test).length > 0) {
+    if (findMatchingRegressionCases(normalizedDocument, test).length > 0) {
       diagnosedFailedTests += 1;
     } else {
       newFailedTests += 1;
-      warnings.push(`New failing test not yet in regression catalog: ${test.path}`);
+      warnings.push(`New failing test not yet in regression case store: ${test.path}`);
     }
   }
 
@@ -138,30 +171,37 @@ export function validateRegressionCatalogDocument(
     errors,
     warnings,
     stats: {
-      entries: document.entries.length,
+      cases: normalizedDocument.cases.length,
       fingerprints: fingerprintCount,
-      failedTests,
+      failedTests: failed.length,
       diagnosedFailedTests,
       newFailedTests,
     },
   };
 }
 
-export function renderRegressionCatalogMarkdown(document) {
+export function renderRegressionCaseStoreMarkdown(document) {
+  const normalizedDocument = normalizeRegressionCaseStoreDocument(document);
+  const issueRefs = new Set(
+    normalizedDocument.cases
+      .map((entry) => entry.issue ? `${entry.issue.repo}#${entry.issue.number}` : null)
+      .filter(Boolean)
+  );
   const lines = [
-    "# Regression Catalog",
+    "# Regression Cases",
     "",
     "Canonical source: `testkit.regressions.json`",
     "",
-    `Tracked regressions: ${document.entries.length}`,
-    `Tracked issue references: ${new Set(document.entries.map((entry) => entry.issue.number)).size}`,
+    `Tracked cases: ${normalizedDocument.cases.length}`,
+    `Tracked issue references: ${issueRefs.size}`,
     "",
   ];
 
-  document.entries.forEach((entry, index) => {
+  normalizedDocument.cases.forEach((entry, index) => {
     lines.push(
-      `## ${index + 1}. ${entry.summary} — #${entry.issue.number}`,
+      `## ${index + 1}. ${entry.summary}${entry.issue ? ` - #${entry.issue.number}` : ""}`,
       "",
+      `- State: \`${entry.state}\``,
       `- Classification: \`${entry.classification}\``,
       `- Cause: ${entry.cause}`,
       `- Last reviewed: ${entry.lastReviewedAt}`,
@@ -170,8 +210,8 @@ export function renderRegressionCatalogMarkdown(document) {
 
     for (const fingerprint of entry.fingerprints) {
       lines.push(
-        `  - \`${fingerprint.path || fingerprint.pathGlob}\`${fingerprint.failureKey ? ` — \`${fingerprint.failureKey}\`` : ""}${
-          fingerprint.errorIncludes ? ` — error contains \`${fingerprint.errorIncludes}\`` : ""
+        `  - \`${fingerprint.path || fingerprint.pathGlob}\`${fingerprint.failureKey ? ` - \`${fingerprint.failureKey}\`` : ""}${
+          fingerprint.errorIncludes ? ` - error contains \`${fingerprint.errorIncludes}\`` : ""
         }`
       );
     }
@@ -182,11 +222,13 @@ export function renderRegressionCatalogMarkdown(document) {
   return `${lines.join("\n").trimEnd()}\n`;
 }
 
-export function findMatchingRegressionEntries(document, fileSummary) {
-  return document.entries.filter((entry) => matchesRegressionEntry(entry, fileSummary));
+export function findMatchingRegressionCases(document, fileSummary) {
+  return (document?.cases || []).filter((entry) =>
+    matchesRegressionCase(entry, fileSummary)
+  );
 }
 
-export function matchesRegressionEntry(entry, fileSummary) {
+export function matchesRegressionCase(entry, fileSummary) {
   return entry.fingerprints.some((fingerprint) =>
     matchesRegressionFingerprint(fingerprint, fileSummary)
   );
@@ -213,17 +255,24 @@ export function buildRegressionFileIdentity(service, type, filePath) {
   return `${service}::${type}::${filePath}`;
 }
 
-function normalizeRegressionEntry(entry, label) {
+export function issueRefToString(issue) {
+  if (!issue) return null;
+  return `${issue.repo}#${issue.number}`;
+}
+
+function normalizeRegressionCase(entry, label) {
   if (!entry || typeof entry !== "object") {
     throw new Error(`${label} must be an object`);
   }
 
   const id = requireNonEmptyString(entry.id, `${label}.id`);
+  const state = requireEnumValue(entry.state || "active", CASE_STATES, `${label}.state`);
   const classification = requireEnumValue(
     entry.classification,
     CLASSIFICATIONS,
     `${label}.classification`
   );
+  const owner = normalizeOptionalString(entry.owner);
   const summary = requireNonEmptyString(entry.summary, `${label}.summary`);
   const cause = requireNonEmptyString(entry.cause, `${label}.cause`);
   const lastReviewedAt = requireNonEmptyString(entry.lastReviewedAt, `${label}.lastReviewedAt`);
@@ -233,14 +282,18 @@ function normalizeRegressionEntry(entry, label) {
 
   return {
     id,
+    state,
     classification,
-    issue: normalizeRegressionIssue(entry.issue, `${label}.issue`),
+    ...(owner ? { owner } : {}),
+    issue: entry.issue == null ? null : normalizeRegressionIssue(entry.issue, `${label}.issue`),
     summary,
     cause,
     lastReviewedAt,
     fingerprints: entry.fingerprints.map((fingerprint, index) =>
       normalizeRegressionFingerprint(fingerprint, `${label}.fingerprints[${index}]`)
     ),
+    lifecycle: normalizeLifecycle(entry.lifecycle),
+    coverage: normalizeCoverage(entry.coverage),
   };
 }
 
@@ -258,6 +311,28 @@ function normalizeRegressionIssue(issue, label) {
   return { repo, number };
 }
 
+function normalizeLifecycle(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return {
+    ...(normalizeOptionalString(value.firstSeenAt) ? { firstSeenAt: normalizeOptionalString(value.firstSeenAt) } : {}),
+    ...(normalizeOptionalString(value.lastSeenAt) ? { lastSeenAt: normalizeOptionalString(value.lastSeenAt) } : {}),
+    ...(normalizeOptionalString(value.lastVerifiedAt) ? { lastVerifiedAt: normalizeOptionalString(value.lastVerifiedAt) } : {}),
+    ...(normalizeOptionalString(value.resolvedAt) ? { resolvedAt: normalizeOptionalString(value.resolvedAt) } : {}),
+    ...(value.cleanRunCount != null ? { cleanRunCount: Math.max(0, Number(value.cleanRunCount) || 0) } : {}),
+    ...(value.fixClaim && typeof value.fixClaim === "object" && !Array.isArray(value.fixClaim)
+      ? { fixClaim: { ...value.fixClaim } }
+      : {}),
+  };
+}
+
+function normalizeCoverage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return {
+    ...(typeof value.required === "boolean" ? { required: value.required } : {}),
+    ...(normalizeOptionalString(value.status) ? { status: normalizeOptionalString(value.status) } : {}),
+  };
+}
+
 function normalizeRegressionFingerprint(fingerprint, label) {
   if (!fingerprint || typeof fingerprint !== "object") {
     throw new Error(`${label} must be an object`);

package/lib/regressions/workflow.mjs

@@ -0,0 +1,266 @@
+import { execFileSync } from "child_process";
+import { createDefaultGitHubIssueTransport } from "./github-transport.mjs";
+
+const STRONG_FIX_RE = /\b(?:fixe[sd]?|close[sd]?|resolve[sd]?)\s+((?:[\w.-]+\/[\w.-]+)?#\d+)/giu;
+const WEAK_REF_RE = /\b(?:refs?|references?|related to)\s+((?:[\w.-]+\/[\w.-]+)?#\d+)/giu;
+
+export function parseIssueReferences(text, defaultRepo = null) {
+  const refs = [];
+  collectRefs(refs, text, STRONG_FIX_RE, "fix");
+  collectRefs(refs, text, WEAK_REF_RE, "reference");
+  const seen = new Set();
+  return refs
+    .map((ref) => normalizeIssueRef(ref, defaultRepo))
+    .filter(Boolean)
+    .filter((ref) => {
+      const key = `${ref.kind}:${ref.repo}#${ref.number}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+}
+
+export function collectLocalFixClaims(productDir, gitMetadata = {}) {
+  const defaultRepo = gitMetadata?.repoSlug || null;
+  const messages = [];
+  try {
+    messages.push(execFileSync("git", ["log", "-20", "--pretty=%B"], {
+      cwd: productDir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }));
+  } catch {
+    return [];
+  }
+  return parseIssueReferences(messages.join("\n"), defaultRepo).filter((ref) => ref.kind === "fix");
+}
+
+export async function executeRegressionWorkflowActions({
+  productDir,
+  caseStore,
+  report,
+  workflowConfig,
+  gitMetadata,
+  env = process.env,
+}) {
+  if (!caseStore || !report || !workflowConfig || workflowConfig.mode === "off") {
+    return { changed: false, actions: [] };
+  }
+
+  const actions = [];
+  let changed = false;
+  const transport = await maybeCreateGitHubTransport(workflowConfig, env);
+
+  if (workflowConfig?.github?.read !== false && transport?.fetchOpenBugIssues && caseStore.issueRepo) {
+    try {
+      const openBugIssues = await transport.fetchOpenBugIssues(caseStore.issueRepo, {
+        labels: workflowConfig.github?.bugLabels || ["bug"],
+      });
+      const coverage = await reconcileBugIssueCoverage({
+        caseStore,
+        issuesByNumber: openBugIssues,
+        issueRepo: caseStore.issueRepo,
+      });
+      if (coverage.changed) changed = true;
+      actions.push(...coverage.actions);
+    } catch (error) {
+      actions.push({
+        type: "sync_bug_coverage",
+        reason: "github_bug_issue_fetch_failed",
+        status: "suggested",
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  const fixClaims = collectLocalFixClaims(productDir, gitMetadata);
+  const cases = caseStore.cases || [];
+  const issueToCase = new Map(
+    cases
+      .filter((entry) => entry.issue)
+      .map((entry) => [`${entry.issue.repo}#${entry.issue.number}`, entry])
+  );
+
+  for (const claim of fixClaims) {
+    const regressionCase = issueToCase.get(`${claim.repo}#${claim.number}`);
+    if (!regressionCase) continue;
+    const previousState = JSON.stringify({
+      state: regressionCase.state,
+      lifecycle: regressionCase.lifecycle || {},
+    });
+    regressionCase.lifecycle = {
+      ...(regressionCase.lifecycle || {}),
+      fixClaim: {
+        repo: claim.repo,
+        number: claim.number,
+        source: "git",
+        observedAt: new Date().toISOString(),
+      },
+    };
+    if (regressionCase.state === "active") regressionCase.state = "fix_claimed";
+    changed = changed || previousState !== JSON.stringify({
+      state: regressionCase.state,
+      lifecycle: regressionCase.lifecycle || {},
+    });
+    actions.push({
+      type: "record_fix_claim",
+      caseId: regressionCase.id,
+      issue: regressionCase.issue,
+      reason: "commit_message_fix_reference",
+      status: "applied",
+    });
+  }
+
+  if (workflowConfig?.github?.write && transport) {
+    const writeResult = await executeGitHubWriteActions({ transport, caseStore, report, actions, workflowConfig });
+    if (writeResult.changed) changed = true;
+  }
+
+  if (actions.length > 0) {
+    report.workflow = report.workflow || { actions: [], summary: { applied: 0, suggested: 0, byType: {} } };
+    report.workflow.actions = [...(report.workflow.actions || []), ...actions];
+    report.workflow.summary = summarizeWorkflowActions(report.workflow.actions);
+  }
+
+  return { changed: changed || actions.some((action) => action.status === "applied"), actions };
+}
+
+export async function reconcileBugIssueCoverage({ caseStore, issuesByNumber, issueRepo }) {
+  const actions = [];
+  if (!caseStore || !issuesByNumber || issuesByNumber.size === 0) return { changed: false, actions };
+  const cases = caseStore.cases || [];
+  const coveredIssueNumbers = new Set(cases.filter((entry) => entry.issue).map((entry) => entry.issue.number));
+
+  for (const [number, issue] of issuesByNumber.entries()) {
+    if (coveredIssueNumbers.has(number)) continue;
+    const id = `github-bug-${number}`;
+    if (cases.some((entry) => entry.id === id)) continue;
+    cases.push({
+      id,
+      state: "coverage_missing",
+      classification: "product_bug",
+      issue: { repo: issue.repo || issueRepo, number },
+      summary: issue.title || `Bug #${number} lacks regression coverage`,
+      cause: "Open GitHub bug issue has no linked Testkit regression case.",
+      lastReviewedAt: new Date().toISOString().slice(0, 10),
+      fingerprints: [{ pathGlob: "**/__testkit__/*.testkit.ts", service: "unknown", type: "int", errorIncludes: id }],
+      lifecycle: {},
+      coverage: { required: true, status: "coverage_missing" },
+    });
+    actions.push({
+      type: "record_missing_bug_coverage",
+      caseId: id,
+      issue: { repo: issue.repo || issueRepo, number },
+      reason: "open_bug_issue_without_case",
+      status: "applied",
+    });
+  }
+
+  return { changed: actions.length > 0, actions };
+}
+
+async function executeGitHubWriteActions({ transport, caseStore, report, actions, workflowConfig }) {
+  const cases = caseStore.cases || [];
+  const caseById = new Map(cases.map((entry) => [entry.id, entry]));
+  let changed = false;
+
+  for (const action of report.workflow?.actions || []) {
+    if (action.status !== "suggested") continue;
+    if (action.type === "reopen_issue" && workflowConfig.github.reopenIssues !== "never" && action.issue) {
+      await transport.updateIssueState(action.issue.repo, action.issue.number, "open");
+      changed = true;
+      actions.push({ ...action, status: "applied" });
+      continue;
+    }
+  }
+
+  if (workflowConfig.github.closeIssues === "after_stability_window") {
+    const requiredCleanRuns = workflowConfig.stability?.cleanRunsBeforeClose || 3;
+    for (const regressionCase of cases) {
+      if (regressionCase.state !== "fixed_pending_verification" || !regressionCase.issue) continue;
+      if (Number(regressionCase.lifecycle?.cleanRunCount || 0) < requiredCleanRuns) continue;
+      await transport.updateIssueState(regressionCase.issue.repo, regressionCase.issue.number, "closed");
+      regressionCase.state = "resolved";
+      regressionCase.lifecycle = {
+        ...(regressionCase.lifecycle || {}),
+        resolvedAt: new Date().toISOString(),
+      };
+      changed = true;
+      actions.push({
+        type: "close_issue",
+        caseId: regressionCase.id,
+        issue: regressionCase.issue,
+        reason: "stability_window_clean",
+        status: "applied",
+      });
+    }
+  }
+
+  for (const action of report.workflow?.actions || []) {
+    if (action.type !== "create_case" || action.status !== "applied") continue;
+    const regressionCase = caseById.get(action.caseId);
+    if (!regressionCase || regressionCase.issue || workflowConfig.github.createIssues === "never") continue;
+    if (regressionCase.classification === "infra" && workflowConfig.evidence?.requireForIssueCreation) continue;
+    const repo = caseStore.issueRepo;
+    if (!repo) continue;
+    const issue = await transport.createIssue(repo, {
+      title: regressionCase.summary,
+      body: buildIssueBody(regressionCase, action),
+      labels: workflowConfig.github.issueLabels || workflowConfig.github.bugLabels || ["bug"],
+    });
+    if (issue?.number) {
+      regressionCase.issue = { repo, number: issue.number };
+      regressionCase.state = "active";
+      changed = true;
+      actions.push({
+        type: "create_issue",
+        caseId: regressionCase.id,
+        issue: regressionCase.issue,
+        reason: "new_confirmed_regression",
+        status: "applied",
+      });
+    }
+  }
+  return { changed };
+}
+
+async function maybeCreateGitHubTransport(workflowConfig, env) {
+  if (workflowConfig?.github?.read === false && !workflowConfig?.github?.write) return null;
+  return createDefaultGitHubIssueTransport(env, {
+    apiBaseUrl: workflowConfig?.github?.apiBaseUrl,
+  });
+}
+
+function buildIssueBody(regressionCase, action) {
+  return [
+    regressionCase.cause,
+    "",
+    "Testkit evidence:",
+    ...(action.tests || []).map((test) => `- ${test.service} ${test.type} ${test.path}: ${test.status}`),
+  ].join("\n");
+}
+
+function collectRefs(refs, text, pattern, kind) {
+  for (const match of String(text || "").matchAll(pattern)) {
+    refs.push({ raw: match[1], kind });
+  }
+}
+
+function normalizeIssueRef(ref, defaultRepo) {
+  const match = String(ref.raw || "").match(/^(?:(?<repo>[\w.-]+\/[\w.-]+))?#(?<number>\d+)$/u);
+  if (!match) return null;
+  const repo = match.groups.repo || defaultRepo;
+  const number = Number(match.groups.number);
+  if (!repo || !Number.isInteger(number)) return null;
+  return { kind: ref.kind, repo, number };
+}
+
+function summarizeWorkflowActions(actions) {
+  const summary = { applied: 0, suggested: 0, byType: {} };
+  for (const action of actions) {
+    if (action.status === "applied") summary.applied += 1;
+    if (action.status === "suggested") summary.suggested += 1;
+    summary.byType[action.type] = (summary.byType[action.type] || 0) + 1;
+  }
+  return summary;
+}

package/lib/results/artifacts.mjs

@@ -295,23 +295,24 @@ function formatDiagnosis(diagnosis) {
   if (diagnosis.classifications?.length) {
     lines.push(`classification: ${diagnosis.classifications.join(", ")}`);
   }
-  for (const entry of diagnosis.entries || []) {
-    lines.push(`issue: ${entry.issue.repo}#${entry.issue.number}`);
+  for (const entry of diagnosis.cases || []) {
+    lines.push(`case: ${entry.id}`);
+    if (entry.issue) lines.push(`issue: ${entry.issue.repo}#${entry.issue.number}`);
     lines.push(`summary: ${entry.summary}`);
     if (entry.github?.url) lines.push(`url: ${entry.github.url}`);
     if (entry.github?.state) {
       lines.push(`github state: ${entry.github.state}${entry.github.cached ? " (cache)" : ""}`);
     }
-    if (entry.syncStatus) lines.push(`catalog status: ${entry.syncStatus}`);
-    if (entry.catalogFindings?.length) {
-      for (const finding of entry.catalogFindings.slice(0, 3)) {
-        lines.push(`catalog finding: ${finding.message}`);
+    if (entry.syncStatus) lines.push(`case status: ${entry.syncStatus}`);
+    if (entry.syncFindings?.length) {
+      for (const finding of entry.syncFindings.slice(0, 3)) {
+        lines.push(`case finding: ${finding.message}`);
       }
     }
     break;
   }
   if (diagnosis.status === "new_regression") {
-    lines.push("next: review .testkit/results/latest.json drafts.newRegressions for a prepared catalog entry");
+    lines.push("next: review .testkit/results/latest.json drafts.newRegressions for a prepared case");
   }
   return lines;
 }