@elench/testkit 0.1.149 → 0.1.151

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

package/lib/runner/formatting.mjs

@@ -1,4 +1,4 @@
-import { findMatchingRegressionEntries } from "../regressions/index.mjs";
+import { findMatchingRegressionCases } from "../regressions/index.mjs";
 import { buildRegressionSyncSummaryLines } from "../regressions/github.mjs";
 
 export function formatDuration(durationMs) {
@@ -70,8 +70,8 @@ export function buildRunSummaryData(results, durationMs, regressionReport = null
     newRegressions: regressionSummary?.newRegressions || 0,
     knownRegressions: regressionSummary?.knownRegressions || 0,
     fixedKnownRegressions: regressionSummary?.fixedKnownRegressions || 0,
-    catalogStale: regressionSummary?.catalogStale || 0,
-    catalogSyncUnavailable: Boolean(regressionSummary?.catalogSyncUnavailable),
+    staleCases: regressionSummary?.staleCases || 0,
+    syncUnavailable: Boolean(regressionSummary?.syncUnavailable),
     usedStaleCache: Boolean(regressionSummary?.usedStaleCache),
   };
 }
@@ -100,11 +100,11 @@ export function buildCompactRunSummaryLines(
   if (summary.fixedKnownRegressions > 0) {
     lines.push(`Fixed known regressions: ${summary.fixedKnownRegressions}`);
   }
-  if (summary.catalogStale > 0) {
-    lines.push(`Catalog stale: ${summary.catalogStale}`);
+  if (summary.staleCases > 0) {
+    lines.push(`Case store stale: ${summary.staleCases}`);
   }
-  if (summary.catalogSyncUnavailable) {
-    lines.push("Catalog sync unavailable");
+  if (summary.syncUnavailable) {
+    lines.push("Case store sync unavailable");
   }
 
   lines.push("");
@@ -186,11 +186,11 @@ export function buildDebugRunSummaryLines(results, durationMs, regressionReport
   }
 
   const regressionSyncLines = buildRegressionSyncSummaryLines(
-    regressionReport?.catalog?.configured ? {
+    regressionReport?.caseStore?.configured ? {
       summary: {
         byCode: {
-          closed_but_failing: regressionReport.summary.catalogStale,
-          validation_unavailable: regressionReport.summary.catalogSyncUnavailable ? 1 : 0,
+          closed_but_failing: regressionReport.summary.staleCases,
+          validation_unavailable: regressionReport.summary.syncUnavailable ? 1 : 0,
           used_stale_cache: regressionReport.summary.usedStaleCache ? 1 : 0,
         },
       },
@@ -209,7 +209,7 @@ export function buildDebugRunSummaryLines(results, durationMs, regressionReport
   return lines;
 }
 
-export function buildFailurePresentation(fileSummary, regressionCatalog = null) {
+export function buildFailurePresentation(fileSummary, regressionCaseStore = null) {
   const rankedDetails = rankFailureDetails(fileSummary.failureDetails || []);
   const primaryDetail = rankedDetails[0] || null;
   const fallbackMessages = rankedDetails
@@ -221,7 +221,7 @@ export function buildFailurePresentation(fileSummary, regressionCatalog = null)
   const responseLine = formatFailureResponsePreview(primaryDetail);
   if (responseLine) details.push(responseLine);
 
-  const regressionLine = formatInlineRegressionLine(fileSummary, regressionCatalog);
+  const regressionLine = formatInlineRegressionLine(fileSummary, regressionCaseStore);
   if (regressionLine) details.push(regressionLine);
 
   const requestLine = formatFailureRequestHint(primaryDetail);
@@ -318,13 +318,14 @@ function formatFailureRequestHint(detail) {
   return `request: ${method} ${path}`;
 }
 
-function formatInlineRegressionLine(fileSummary, regressionCatalog) {
-  if (!regressionCatalog) return "regression: new";
-  const matches = findMatchingRegressionEntries(regressionCatalog, fileSummary);
+function formatInlineRegressionLine(fileSummary, regressionCaseStore) {
+  if (!regressionCaseStore) return "regression: new";
+  const matches = findMatchingRegressionCases(regressionCaseStore, fileSummary);
   if (matches.length === 0) return "regression: new";
 
   const entry = matches[0];
-  return `regression: known #${entry.issue.number} ${entry.classification}`;
+  const issue = entry.issue ? ` #${entry.issue.number}` : "";
+  return `regression: known${issue} ${entry.classification}`;
 }
 
 function isThresholdWrapperMessage(message) {

package/lib/runner/orchestrator.mjs

@@ -12,7 +12,7 @@ import {
   recordGraphError,
   recordTaskOutcome,
 } from "./results.mjs";
-import { loadRegressionCatalogConfig } from "./regressions.mjs";
+import { loadRegressionCaseStoreConfig } from "./regressions.mjs";
 import { formatError } from "./formatting.mjs";
 import {
   loadTimings,
@@ -58,12 +58,12 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
     },
     testkitVersion: readPackageMetadata().version,
   };
-  const regressionCatalog = loadRegressionCatalogConfig(
+  const regressionCaseStore = loadRegressionCaseStoreConfig(
     productDir,
     configs[0]?.testkit?.regressions || null
   );
   const reporter = opts.reporter || null;
-  reporter?.setRegressionCatalog?.(regressionCatalog);
+  reporter?.setRegressionCaseStore?.(regressionCaseStore);
   const logRegistry = createRunLogRegistry(productDir);
   const workerState = {
     workerCount: 0,
@@ -128,7 +128,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
       const history = loadHistory(productDir);
       const graphs = buildRuntimeGraphs(executedPlans);
       const queue = buildScheduledQueue(executedPlans, graphs, { timings, history });
-      runSelection.planning = buildRunPlanningMetadata(queue);
+      runSelection.planning = buildRunPlanningMetadata(queue, graphs);
       writeLiveSnapshot();
       reporter?.setTotalFileCount?.(queue.length);
       for (const task of queue) {
@@ -213,8 +213,9 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
       metadata,
       logRegistry,
       setupRegistry,
-      regressionCatalog,
+      regressionCaseStore,
       regressionSyncConfig: configs[0]?.testkit?.regressions?.sync || null,
+      regressionWorkflowConfig: configs[0]?.testkit?.regressions?.workflow || null,
       telemetry,
       reporter,
       writeStatus: opts.writeStatus,

package/lib/runner/planning.mjs

@@ -3,6 +3,7 @@ import {
   matchesSuiteSelectors,
   suiteSelectionType,
 } from "./suite-selection.mjs";
+import { materializeDatabaseConfig } from "../config/database-materialization.mjs";
 
 const TYPE_ORDER = ["ui", "e2e", "scenario", "integration", "dal", "load"];
 
@@ -122,6 +123,7 @@ export function buildRuntimeGraphs(servicePlans) {
       dirName: buildGraphDirName(plan.runtimeNames),
       instanceCount: plan.config.testkit.runtime.instances,
       maxConcurrentTasks: resolveGraphMaxConcurrentTasks(plan.runtimeConfigs),
+      resourceReservations: buildGraphResourceReservations(plan.runtimeConfigs),
     };
     graphs.push(graph);
     graphByRuntimeKey.set(plan.runtimeKey, graph);
@@ -137,6 +139,44 @@ export function buildRuntimeGraphs(servicePlans) {
   }));
 }
 
+export function buildGraphResourceReservations(runtimeConfigs) {
+  const reservations = new Map();
+
+  for (const config of runtimeConfigs) {
+    const db = materializeDatabaseConfig(config.testkit.database, config.name);
+    if (!db) continue;
+    const key = postgresBudgetKey(db);
+    const existing = reservations.get(key) || {
+      key,
+      kind: "postgres",
+      scope: db.provider === "resource" ? "resource" : "local",
+      resourceName: db.provider === "resource" ? db.resource : "local",
+      capacity: db.maxConnections,
+      reserved: db.reservedConnections || 0,
+      perRuntime: 0,
+      services: [],
+    };
+    existing.capacity = Math.max(existing.capacity || 0, db.maxConnections || 0);
+    existing.reserved = Math.max(existing.reserved || 0, db.reservedConnections || 0);
+    existing.perRuntime += db.runtimeConnections || 1;
+    existing.services.push(config.name);
+    reservations.set(key, existing);
+  }
+
+  return [...reservations.values()]
+    .map((reservation) => ({
+      ...reservation,
+      available: Math.max(0, (reservation.capacity || 0) - (reservation.reserved || 0)),
+      services: [...new Set(reservation.services)].sort(),
+    }))
+    .sort((left, right) => left.key.localeCompare(right.key));
+}
+
+function postgresBudgetKey(db) {
+  if (db.provider === "resource") return `postgres:resource:${db.resource}`;
+  return "postgres:local";
+}
+
 export function claimNextTask(queue, preferredGraphKey, isRunnable = () => true) {
   if (queue.length === 0) return null;
 

package/lib/runner/regressions.mjs

@@ -1,24 +1,27 @@
 import {
   buildRegressionFileIdentity,
-  findMatchingRegressionEntries,
-  loadRegressionCatalogConfig,
+  findMatchingRegressionCases,
+  loadRegressionCaseStoreConfig,
+  writeRegressionCaseStoreDocument,
 } from "../regressions/index.mjs";
 
-export { loadRegressionCatalogConfig };
+export { loadRegressionCaseStoreConfig };
 
 export function applyRegressionAnalysisToArtifacts(
   runArtifact,
   statusArtifact,
-  regressionCatalog,
+  regressionCaseStore,
   regressionSync
 ) {
   const runEntries = extractRunFileEntries(runArtifact);
   const statusEntries = extractStatusFileEntries(statusArtifact);
   const fileSummaries = new Map();
-  const syncById = new Map((regressionSync?.entries || []).map((entry) => [entry.id, entry]));
-  const staleEntryIds = new Set();
+  const syncById = new Map((regressionSync?.cases || []).map((entry) => [entry.id, entry]));
+  const staleCaseIds = new Set();
   const newRegressionDrafts = [];
   const fixedRegressionDrafts = [];
+  const workflowActions = [];
+  let caseStoreChanged = false;
 
   for (const entry of [...runEntries, ...statusEntries]) {
     const key = buildRegressionFileIdentity(entry.service, entry.type, entry.path);
@@ -37,23 +40,64 @@ export function applyRegressionAnalysisToArtifacts(
   const diagnosesByFileKey = new Map();
 
   for (const fileSummary of fileSummaries.values()) {
-    const diagnosis = buildFileDiagnosis(fileSummary, regressionCatalog, syncById);
+    const diagnosis = buildFileDiagnosis(fileSummary, regressionCaseStore, syncById);
     const fileKey = buildRegressionFileIdentity(
       fileSummary.service,
       fileSummary.type,
       fileSummary.path
     );
     diagnosesByFileKey.set(fileKey, diagnosis);
-    for (const entry of diagnosis.entries) {
-      if (entry.catalogFindings.length > 0) {
-        staleEntryIds.add(entry.id);
+    for (const entry of diagnosis.cases) {
+      if (entry.syncFindings.length > 0) {
+        staleCaseIds.add(entry.id);
       }
     }
     if (diagnosis.status === "new_regression") {
-      newRegressionDrafts.push(buildNewRegressionDraft(fileSummary, regressionCatalog));
+      const draft = buildNewRegressionDraft(fileSummary, regressionCaseStore);
+      newRegressionDrafts.push(draft);
+      if (regressionCaseStore) {
+        const createdCase = createCaseFromDraft(draft);
+        if (!caseIdSet(regressionCaseStore).has(createdCase.id)) {
+          regressionCaseStore.cases.push(createdCase);
+          caseStoreChanged = true;
+          workflowActions.push({
+            type: "create_case",
+            caseId: createdCase.id,
+            reason: "new_regression",
+            status: "applied",
+            tests: [testRef(fileSummary)],
+          });
+        }
+      }
     }
     if (diagnosis.status === "fixed_known_regression") {
-      for (const entry of diagnosis.entries) {
+      for (const entry of diagnosis.cases) {
+        const sourceCase = findCaseById(regressionCaseStore, entry.id);
+        if (sourceCase) {
+          const nextLifecycle = {
+            ...(sourceCase.lifecycle || {}),
+            lastVerifiedAt: new Date().toISOString(),
+            cleanRunCount: Number(sourceCase.lifecycle?.cleanRunCount || 0) + 1,
+          };
+          const previousState = JSON.stringify({
+            state: sourceCase.state,
+            lifecycle: sourceCase.lifecycle || {},
+          });
+          sourceCase.state = "fixed_pending_verification";
+          sourceCase.lifecycle = nextLifecycle;
+          caseStoreChanged = caseStoreChanged || previousState !== JSON.stringify({
+            state: sourceCase.state,
+            lifecycle: sourceCase.lifecycle || {},
+          });
+          workflowActions.push({
+            type: "mark_fixed_pending_verification",
+            caseId: entry.id,
+            issue: entry.issue,
+            reason: "matched_case_passed",
+            status: "applied",
+            tests: [testRef(fileSummary)],
+          });
+        }
         fixedRegressionDrafts.push({
           id: entry.id,
           issue: entry.issue,
@@ -62,6 +106,31 @@ export function applyRegressionAnalysisToArtifacts(
         });
       }
     }
+    if (diagnosis.status === "known_regression") {
+      for (const entry of diagnosis.cases) {
+        const sourceCase = findCaseById(regressionCaseStore, entry.id);
+        if (!sourceCase) continue;
+        const nextLifecycle = {
+          ...(sourceCase.lifecycle || {}),
+          cleanRunCount: 0,
+        };
+        if (sourceCase.state !== "active" || JSON.stringify(sourceCase.lifecycle || {}) !== JSON.stringify(nextLifecycle)) {
+          sourceCase.state = "active";
+          sourceCase.lifecycle = nextLifecycle;
+          caseStoreChanged = true;
+        }
+        if (entry.syncStatus === "closed_but_failing") {
+          workflowActions.push({
+            type: "reopen_issue",
+            caseId: entry.id,
+            issue: entry.issue,
+            reason: "closed_issue_reproduced",
+            status: "suggested",
+            tests: [testRef(fileSummary)],
+          });
+        }
+      }
+    }
   }
 
   for (const entry of [...runEntries, ...statusEntries]) {
@@ -74,32 +143,47 @@ export function applyRegressionAnalysisToArtifacts(
   const summaryTests = statusArtifact?.tests || runEntries;
   const report = buildRegressionReport(
     summaryTests,
-    regressionCatalog,
+    regressionCaseStore,
     regressionSync,
     diagnosesByFileKey,
-    staleEntryIds,
+    staleCaseIds,
     newRegressionDrafts,
-    fixedRegressionDrafts
+    fixedRegressionDrafts,
+    workflowActions
   );
 
   runArtifact.regressions = report;
+  runArtifact.summary = {
+    ...(runArtifact.summary || {}),
+    regressions: report.summary,
+  };
   if (statusArtifact) {
     statusArtifact.regressions = report;
+    statusArtifact.summary = {
+      ...(statusArtifact.summary || {}),
+      regressions: report.summary,
+    };
   }
 
-  return { runArtifact, statusArtifact, regressionReport: report };
+  return {
+    runArtifact,
+    statusArtifact,
+    regressionReport: report,
+    regressionCaseStore: regressionCaseStore,
+    regressionCaseStoreChanged: caseStoreChanged,
+  };
 }
 
-function buildFileDiagnosis(fileSummary, regressionCatalog, syncById) {
-  const matchedEntries = regressionCatalog
-    ? findMatchingRegressionEntries(regressionCatalog, fileSummary)
+function buildFileDiagnosis(fileSummary, regressionCaseStore, syncById) {
+  const matchedEntries = regressionCaseStore
+    ? findMatchingRegressionCases(regressionCaseStore, fileSummary)
     : [];
   const status = resolveDiagnosisStatus(fileSummary.status, matchedEntries.length);
 
   return {
     status,
     classifications: [...new Set(matchedEntries.map((entry) => entry.classification))].sort(),
-    entries: matchedEntries.map((entry) => toDiagnosisEntry(entry, syncById.get(entry.id) || null)),
+    cases: matchedEntries.map((entry) => toDiagnosisEntry(entry, syncById.get(entry.id) || null)),
   };
 }
 
@@ -119,6 +203,7 @@ function resolveDiagnosisStatus(fileStatus, matchCount) {
 function toDiagnosisEntry(entry, syncEntry) {
   return {
     id: entry.id,
+    state: entry.state,
     classification: entry.classification,
     issue: entry.issue,
     summary: entry.summary,
@@ -126,25 +211,26 @@ function toDiagnosisEntry(entry, syncEntry) {
     lastReviewedAt: entry.lastReviewedAt,
     github: syncEntry?.github || null,
     syncStatus: syncEntry?.status || null,
-    catalogFindings: Array.isArray(syncEntry?.findings) ? syncEntry.findings : [],
+    syncFindings: Array.isArray(syncEntry?.findings) ? syncEntry.findings : [],
   };
 }
 
 function buildRegressionReport(
   tests,
-  regressionCatalog,
+  regressionCaseStore,
   regressionSync,
   diagnosesByFileKey,
-  staleEntryIds,
+  staleCaseIds,
   newRegressionDrafts,
-  fixedRegressionDrafts
+  fixedRegressionDrafts,
+  workflowActions = []
 ) {
   const summary = {
     newRegressions: 0,
     knownRegressions: 0,
     fixedKnownRegressions: 0,
-    catalogStale: staleEntryIds.size,
-    catalogSyncUnavailable: (regressionSync?.summary?.byCode?.validation_unavailable || 0) > 0,
+    staleCases: staleCaseIds.size,
+    syncUnavailable: (regressionSync?.summary?.byCode?.validation_unavailable || 0) > 0,
     usedStaleCache: (regressionSync?.summary?.byCode?.used_stale_cache || 0) > 0,
   };
 
@@ -169,10 +255,14 @@ function buildRegressionReport(
 
   return {
     summary,
-    catalog: {
-      configured: Boolean(regressionCatalog),
-      entryCount: regressionCatalog?.entries?.length || 0,
-      staleEntries: (regressionSync?.entries || []).filter((entry) =>
+    workflow: {
+      actions: workflowActions,
+      summary: summarizeWorkflowActions(workflowActions),
+    },
+    caseStore: {
+      configured: Boolean(regressionCaseStore),
+      caseCount: regressionCaseStore?.cases?.length || 0,
+      staleCases: (regressionSync?.cases || []).filter((entry) =>
         Array.isArray(entry.findings) && entry.findings.length > 0
       ),
       findings: regressionSync?.findings || [],
@@ -180,7 +270,7 @@ function buildRegressionReport(
         mode: regressionSync?.mode || null,
         checkedAt: regressionSync?.checkedAt || null,
         usedStaleCache: summary.usedStaleCache,
-        unavailable: summary.catalogSyncUnavailable,
+        unavailable: summary.syncUnavailable,
       },
     },
     drafts: {
@@ -190,12 +280,12 @@ function buildRegressionReport(
   };
 }
 
-function buildNewRegressionDraft(fileSummary, regressionCatalog) {
+function buildNewRegressionDraft(fileSummary, regressionCaseStore) {
   return {
     id: suggestRegressionId(fileSummary),
     classification: suggestRegressionClassification(fileSummary),
     issue: {
-      repo: regressionCatalog?.issueRepo || null,
+      repo: regressionCaseStore?.issueRepo || null,
       number: null,
     },
     summary: suggestRegressionSummary(fileSummary),
@@ -211,6 +301,29 @@ function buildNewRegressionDraft(fileSummary, regressionCatalog) {
   };
 }
 
+function createCaseFromDraft(draft) {
+  const now = new Date().toISOString();
+  return {
+    id: draft.id,
+    state: "untriaged",
+    classification: draft.classification,
+    issue: null,
+    summary: draft.summary,
+    cause: draft.cause,
+    lastReviewedAt: now.slice(0, 10),
+    fingerprints: draft.fingerprints,
+    lifecycle: {
+      firstSeenAt: now,
+      lastSeenAt: now,
+      cleanRunCount: 0,
+    },
+    coverage: {
+      required: true,
+      status: "covered_reproducing",
+    },
+  };
+}
+
 function suggestRegressionId(fileSummary) {
   const base = `${fileSummary.service}-${fileSummary.type}-${fileSummary.path}`
     .toLowerCase()
@@ -269,6 +382,43 @@ function dedupeDraftsById(entries) {
   return [...map.values()];
 }
 
+function caseIdSet(regressionCaseStore) {
+  return new Set((regressionCaseStore?.cases || []).map((entry) => entry.id));
+}
+
+function findCaseById(regressionCaseStore, id) {
+  return (regressionCaseStore?.cases || []).find((entry) => entry.id === id) || null;
+}
+
+function testRef(fileSummary) {
+  return {
+    service: fileSummary.service,
+    type: fileSummary.type,
+    path: fileSummary.path,
+    status: fileSummary.status,
+  };
+}
+
+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;
+}
+
+export function persistRegressionCaseStoreIfChanged(productDir, regressionCaseStore, changed) {
+  if (!changed || !regressionCaseStore?.__filePath) return false;
+  writeRegressionCaseStoreDocument(regressionCaseStore.__filePath, regressionCaseStore);
+  return true;
+}
+
 function extractRunFileEntries(runArtifact) {
   const entries = [];
 

package/lib/runner/reporting.mjs

@@ -77,7 +77,7 @@ export function buildStatusArtifact({
     scope.serviceFilter === null;
 
   return {
-    schemaVersion: 8,
+    schemaVersion: 9,
     source: "testkit",
     notice: "Generated file. Do not edit manually.",
     product: {

package/lib/runner/run-finalization.mjs

@@ -1,11 +1,15 @@
 import { buildRunArtifact, buildStatusArtifact } from "./reporting.mjs";
-import { applyRegressionAnalysisToArtifacts } from "./regressions.mjs";
+import {
+  applyRegressionAnalysisToArtifacts,
+  persistRegressionCaseStoreIfChanged,
+} from "./regressions.mjs";
 import { writeRunArtifact, writeStatusArtifact } from "./artifacts.mjs";
 import { summarizeDbBackend } from "./results.mjs";
 import { formatError } from "./formatting.mjs";
 import { uploadTelemetryArtifact } from "../telemetry/index.mjs";
 import { loadHistory, saveHistory, updateHistoryFromRunArtifact } from "../history/index.mjs";
 import { shouldFailRegressionSync, validateRegressionIssues } from "../regressions/github.mjs";
+import { executeRegressionWorkflowActions } from "../regressions/workflow.mjs";
 
 export async function finalizeRunArtifacts({
   productDir,
@@ -22,8 +26,9 @@ export async function finalizeRunArtifacts({
   metadata,
   logRegistry,
   setupRegistry,
-  regressionCatalog,
+  regressionCaseStore,
   regressionSyncConfig,
+  regressionWorkflowConfig,
   telemetry,
   reporter,
   writeStatus,
@@ -65,7 +70,7 @@ export async function finalizeRunArtifacts({
     : null;
   const regressionSync = await validateRegressionIssues({
     productDir,
-    document: regressionCatalog,
+    document: regressionCaseStore,
     runArtifact,
     statusArtifact,
     config: regressionSyncConfig,
@@ -74,14 +79,39 @@ export async function finalizeRunArtifacts({
   const enrichedArtifacts = applyRegressionAnalysisToArtifacts(
     runArtifact,
     statusArtifact,
-    regressionCatalog,
+    regressionCaseStore,
     regressionSync
   );
+  const workflowResult = await executeRegressionWorkflowActions({
+    productDir,
+    caseStore: enrichedArtifacts.regressionCaseStore,
+    report: enrichedArtifacts.regressionReport,
+    workflowConfig: regressionWorkflowConfig,
+    gitMetadata: metadata.git,
+  });
+  const caseStoreChanged = enrichedArtifacts.regressionCaseStoreChanged || workflowResult.changed;
+  enrichedArtifacts.runArtifact.regressions = enrichedArtifacts.regressionReport;
+  enrichedArtifacts.runArtifact.summary = {
+    ...(enrichedArtifacts.runArtifact.summary || {}),
+    regressions: enrichedArtifacts.regressionReport.summary,
+  };
+  if (enrichedArtifacts.statusArtifact) {
+    enrichedArtifacts.statusArtifact.regressions = enrichedArtifacts.regressionReport;
+    enrichedArtifacts.statusArtifact.summary = {
+      ...(enrichedArtifacts.statusArtifact.summary || {}),
+      regressions: enrichedArtifacts.regressionReport.summary,
+    };
+  }
 
   writeRunArtifact(productDir, enrichedArtifacts.runArtifact);
   if (writeStatus) {
     writeStatusArtifact(productDir, enrichedArtifacts.statusArtifact);
   }
+  persistRegressionCaseStoreIfChanged(
+    productDir,
+    enrichedArtifacts.regressionCaseStore,
+    caseStoreChanged
+  );
   const nextHistory = updateHistoryFromRunArtifact(
     loadHistory(productDir),
     enrichedArtifacts.runArtifact,