@elench/testkit 0.1.149 → 0.1.151

package/lib/regressions/index.mjs

@@ -3,117 +3,152 @@ 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 writeRegressionCaseStoreDocument(filePath, document) {
+  fs.writeFileSync(filePath, `${JSON.stringify(serializeRegressionCaseStore(document), null, 2)}\n`);
 }
 
-export function loadRegressionCatalogDocument(filePath, relativePath = filePath) {
+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) {
-        const absolutePath = path.join(productDir, fingerprint.path);
-        if (!fs.existsSync(absolutePath)) {
-          errors.push(`Missing matched file: ${fingerprint.path} (${entry.id})`);
+        if (fingerprint.path) {
+          const absolutePath = path.join(productDir, fingerprint.path);
+          if (!fs.existsSync(absolutePath)) {
+            errors.push(`Missing matched file: ${fingerprint.path} (${regressionCase.id})`);
+          }
+        } else if (!fingerprint.pathGlob) {
+          errors.push(`Missing matched file: ${fingerprint.path} (${regressionCase.id})`);
         }
       }
 
       const fingerprintKey = [
-        entry.id,
+        regressionCase.id,
         fingerprint.service || "",
         fingerprint.type || "",
-        fingerprint.path,
+        fingerprint.path || "",
+        fingerprint.pathGlob || "",
         fingerprint.failureKey || "",
         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);
 
-      if (
-        !fingerprint.path.includes("__testkit__") ||
-        !fingerprint.path.endsWith(".testkit.ts")
-      ) {
+      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: ${fingerprint.path} (${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)
@@ -121,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}`);
     }
   }
 
@@ -135,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}`,
@@ -167,8 +210,8 @@ export function renderRegressionCatalogMarkdown(document) {
 
     for (const fingerprint of entry.fingerprints) {
       lines.push(
-        `  - \`${fingerprint.path}\`${fingerprint.failureKey ? ` — \`${fingerprint.failureKey}\`` : ""}${
-          fingerprint.errorIncludes ? ` — error contains \`${fingerprint.errorIncludes}\`` : ""
+        `  - \`${fingerprint.path || fingerprint.pathGlob}\`${fingerprint.failureKey ? ` - \`${fingerprint.failureKey}\`` : ""}${
+          fingerprint.errorIncludes ? ` - error contains \`${fingerprint.errorIncludes}\`` : ""
         }`
       );
     }
@@ -179,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)
   );
@@ -192,7 +237,8 @@ export function matchesRegressionEntry(entry, fileSummary) {
 export function matchesRegressionFingerprint(fingerprint, fileSummary) {
   if (fingerprint.service && fingerprint.service !== fileSummary.service) return false;
   if (fingerprint.type && fingerprint.type !== fileSummary.type) return false;
-  if (fingerprint.path !== fileSummary.path) return false;
+  if (fingerprint.path && fingerprint.path !== fileSummary.path) return false;
+  if (fingerprint.pathGlob && !globMatches(fingerprint.pathGlob, fileSummary.path)) return false;
   if (fingerprint.failureKey) {
     const failureKeys = Array.isArray(fileSummary.failureDetails)
       ? fileSummary.failureDetails.flatMap((detail) => [detail?.key, detail?.title].filter(Boolean))
@@ -209,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`);
@@ -229,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),
   };
 }
 
@@ -254,15 +311,39 @@ 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`);
   }
 
-  const pathValue = requireNonEmptyString(fingerprint.path, `${label}.path`);
-  const normalized = {
-    path: pathValue,
-  };
+  const pathValue = normalizeOptionalString(fingerprint.path);
+  const pathGlob = normalizeOptionalString(fingerprint.pathGlob);
+  if ((pathValue ? 1 : 0) + (pathGlob ? 1 : 0) !== 1) {
+    throw new Error(`${label} must specify exactly one of path or pathGlob`);
+  }
+  const normalized = pathValue ? { path: pathValue } : { pathGlob };
 
   const service = normalizeOptionalString(fingerprint.service);
   if (service) normalized.service = service;
@@ -276,9 +357,41 @@ function normalizeRegressionFingerprint(fingerprint, label) {
   const errorIncludes = normalizeOptionalString(fingerprint.errorIncludes);
   if (errorIncludes) normalized.errorIncludes = errorIncludes;
 
+  if (pathGlob && (!normalized.service || !normalized.type || (!normalized.failureKey && !normalized.errorIncludes))) {
+    throw new Error(`${label}.pathGlob requires service, type, and failureKey or errorIncludes`);
+  }
+
   return normalized;
 }
 
+function globMatches(pattern, value) {
+  return globToRegExp(pattern).test(String(value || ""));
+}
+
+function globToRegExp(pattern) {
+  let source = "^";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    const next = pattern[index + 1];
+    if (char === "*" && next === "*") {
+      source += ".*";
+      index += 1;
+    } else if (char === "*") {
+      source += "[^/]*";
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += escapeRegExp(char);
+    }
+  }
+  source += "$";
+  return new RegExp(source);
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
 function parseStatusArtifact(value) {
   if (!value || typeof value !== "object") {
     return { tests: [] };

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;
+}