refactor: rename Stage5Module → ProcessedModule throughout

Remove legacy "Stage 5" terminology from all code identifiers.
The pipeline has 4 orchestrator stages; the internal sub-phases
inside parallel-processing are not independently numbered stages.

Author: KristjanESPERANTO

docs/pipeline/check-modules-rule-registry.schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Check Modules Rule Registry",
   "type": "object",
-  "description": "Schema describing the rule registry consumed by the Stage 5 check-modules implementation.",
+  "description": "Schema describing the rule registry consumed by the check-modules implementation.",
   "additionalProperties": false,
   "properties": {
     "schemaVersion": {

scripts/aggregate-catalogue.ts

@@ -6,7 +6,7 @@ import process from "node:process";
 import { resolve } from "node:path";
 import { writePublishedCatalogueOutputs } from "./shared/module-catalogue-output.ts";
 
-interface Stage5Module {
+interface ProcessedModule {
   id: string;
   [key: string]: unknown;
 }
@@ -48,19 +48,19 @@ interface AggregateLogger {
   warn: (message: string, data?: unknown) => void;
 }
 
-type OutputWriter = (stage5Modules: Stage5Module[], projectRoot: string) => Promise<OutputResult | OutputPaths> | OutputResult | OutputPaths;
+type OutputWriter = (processedModules: ProcessedModule[], projectRoot: string) => Promise<OutputResult | OutputPaths> | OutputResult | OutputPaths;
 
 interface RunAggregateCatalogueOptions {
   outputWriter?: OutputWriter | null;
   projectRoot?: string;
   runLogger?: AggregateLogger;
-  stage5Modules: Stage5Module[];
+  processedModules: ProcessedModule[];
 }
 
 export interface AggregateCatalogueResult {
   changeSummary: ChangeSummary | null;
   outputPaths: OutputPaths | null;
-  stage5ModulesCount: number;
+  processedModulesCount: number;
   stats?: unknown;
   wroteOutputs: boolean;
 }
@@ -100,17 +100,17 @@ function normalizeOutputDetails(outputResult: OutputResult | OutputPaths | null)
 }
 
 export async function runAggregateCatalogue({
-  stage5Modules,
+  processedModules,
   projectRoot = PROJECT_ROOT,
   outputWriter = writePublishedCatalogueOutputs,
   runLogger = logger
 }: RunAggregateCatalogueOptions): Promise<AggregateCatalogueResult> {
-  if (!Array.isArray(stage5Modules)) {
-    throw new TypeError("runAggregateCatalogue requires stage5Modules from the in-memory pipeline handoff");
+  if (!Array.isArray(processedModules)) {
+    throw new TypeError("runAggregateCatalogue requires processedModules from the in-memory pipeline handoff");
   }
 
   const outputResult = outputWriter
-    ? await outputWriter(stage5Modules, projectRoot)
+    ? await outputWriter(processedModules, projectRoot)
     : null;
 
   const outputDetails = normalizeOutputDetails(outputResult);
@@ -133,19 +133,19 @@ export async function runAggregateCatalogue({
     }
   }
 
-  runLogger.info(`Aggregated ${stage5Modules.length} module(s) into published catalogue outputs`);
+  runLogger.info(`Aggregated ${processedModules.length} module(s) into published catalogue outputs`);
   return {
     changeSummary: outputDetails.changeSummary,
     outputPaths: outputDetails.outputPaths,
-    stage5ModulesCount: stage5Modules.length,
+    processedModulesCount: processedModules.length,
     stats: outputDetails.stats,
     wroteOutputs: outputDetails.wroteOutputs
   };
 }
 
 async function main(): Promise<void> {
   try {
-    throw new Error("aggregate-catalogue must be executed via the orchestrator; direct stage-5 file input is no longer supported");
+    throw new Error("aggregate-catalogue must be executed via the orchestrator; direct per-module file input is no longer supported");
   }
   catch (error) {
     logger.error("Fatal error:", getErrorMessage(error));

scripts/check-modules/__tests__/result-markdown.test.js

@@ -3,7 +3,7 @@ import { describe, it } from "node:test";
 import { strict as assert } from "node:assert";
 
 describe("result-markdown", () => {
-  it("collects issue summaries from stage-5 modules", () => {
+  it("collects issue summaries from processed modules", () => {
     const summaries = collectIssueSummaries([
       {
         name: "MMM-Example",

scripts/check-modules/module-analyzer.ts

@@ -359,7 +359,7 @@ function searchRegexInFile(content: string, pattern: RegExp): boolean {
 
 /**
  * Analyze a module for issues and recommendations.
- * This is the core analysis function for Stage 5 of the pipeline.
+ * This is the core analysis function for the parallel-processing stage.
  */
 export async function analyzeModule(
   modulePath: string,

scripts/check-modules/result-markdown.ts

@@ -14,7 +14,7 @@ export interface IssueSummary {
   url?: string;
 }
 
-interface Stage5ModuleLike {
+interface ProcessedModuleLike {
   issues?: boolean | string[] | string | null;
   maintainer?: string;
   name?: string;
@@ -39,7 +39,7 @@ export function collectIssueSummaries(modules: unknown[]): IssueSummary[] {
       return [];
     }
 
-    const stageModule = module as Stage5ModuleLike;
+    const stageModule = module as ProcessedModuleLike;
     const issues = normalizeIssuesInput(stageModule.issues);
 
     if (issues.length === 0 || typeof stageModule.name !== "string" || typeof stageModule.maintainer !== "string") {

scripts/fixtures/updateBaselineShas.ts

@@ -62,7 +62,7 @@ function updateFixtureFile({ slug, repo, lastCommit }: BaselineFixture, sha: str
   }
   const raw = fs.readFileSync(fixturePath, "utf8");
 
-  const snapshotLine = `- Snapshot reference: Stage 5 dataset as of 2025-09-28 (\`lastCommit\`: ${lastCommit})`;
+  const snapshotLine = `- Snapshot reference: processed module dataset as of 2025-09-28 (\`lastCommit\`: ${lastCommit})`;
   const updated = raw
     .replace(/- Snapshot reference:.*\n/u, `${snapshotLine}\n`)
     .replace(/- Upstream commit SHA:.*\n/u, `- Upstream commit SHA: \`${sha}\` (HEAD at update time for ${repo})\n`);

scripts/generate-result-markdown.ts

@@ -25,7 +25,7 @@ interface GenerateResultMarkdownOptions {
   projectRoot?: string;
   resultPath?: string;
   runLogger?: ResultMarkdownLogger;
-  stage5Modules?: unknown[];
+  processedModules?: unknown[];
   stats?: ResultMarkdownStats;
 }
 
@@ -36,17 +36,17 @@ export async function runGenerateResultMarkdown({
   projectRoot = PROJECT_ROOT,
   resultPath,
   runLogger = logger,
-  stage5Modules,
+  processedModules,
   stats
 }: GenerateResultMarkdownOptions = {}): Promise<{ issueCount: number; outputPath: string }> {
-  if (!Array.isArray(stage5Modules)) {
-    throw new TypeError("runGenerateResultMarkdown requires stage5Modules from the in-memory pipeline handoff");
+  if (!Array.isArray(processedModules)) {
+    throw new TypeError("runGenerateResultMarkdown requires processedModules from the in-memory pipeline handoff");
   }
 
   const outputPath = resultPath ?? resolve(projectRoot, "website", "result.md");
   const resolvedStats = stats
     ?? await readJson<ResultMarkdownStats>(resolve(projectRoot, "website", "data", "stats.json"));
-  const summaries = collectIssueSummaries(stage5Modules);
+  const summaries = collectIssueSummaries(processedModules);
   const markdown = buildResultMarkdown(resolvedStats, summaries);
 
   await ensureDirectory(dirname(outputPath));
@@ -60,7 +60,7 @@ export async function runGenerateResultMarkdown({
 }
 
 async function main(): Promise<void> {
-  throw new Error("generate-result-markdown must be executed via the orchestrator; direct stage-5 file input is no longer supported");
+  throw new Error("generate-result-markdown must be executed via the orchestrator; direct per-module file input is no longer supported");
 }
 
 const currentFile = fileURLToPath(import.meta.url);

scripts/orchestrator/__tests__/in-process-stage-runner.test.js

@@ -27,20 +27,20 @@ test("runStagesSequentially passes modules in memory across collect, parallel, a
   ];
   let capturedModules = null;
   let capturedParallelOutputWriter = "unset";
-  let capturedStage5Modules = null;
+  let capturedProcessedModules = null;
 
   const stageRunner = createInProcessStageRunner({
     projectRoot: "/virtual/project",
     stageRuntimes: {
       aggregateCatalogue: (options) => {
-        capturedStage5Modules = options.stage5Modules;
+        capturedProcessedModules = options.processedModules;
         return Promise.resolve({
           outputPaths: {
             modulesJsonPath: "/virtual/project/website/data/modules.json",
             modulesMinPath: "/virtual/project/website/data/modules.min.json",
             statsPath: "/virtual/project/website/data/stats.json"
           },
-          stage5ModulesCount: options.stage5Modules.length
+          processedModulesCount: options.processedModules.length
         });
       },
       collectMetadata: () => Promise.resolve({ modules }),
@@ -49,7 +49,7 @@ test("runStagesSequentially passes modules in memory across collect, parallel, a
         capturedParallelOutputWriter = options.outputWriter;
         return Promise.resolve({
           results: options.modules.map(module => ({ ...module, fromCache: false, status: "success" })),
-          stage5Modules: options.modules
+          processedModules: options.modules
         });
       },
       writeSkippedModules: () => Promise.resolve()
@@ -84,7 +84,7 @@ test("runStagesSequentially passes modules in memory across collect, parallel, a
 
   assert.deepStrictEqual(capturedModules, modules);
   assert.strictEqual(capturedParallelOutputWriter, null);
-  assert.deepStrictEqual(capturedStage5Modules, modules);
+  assert.deepStrictEqual(capturedProcessedModules, modules);
   assert.strictEqual(completedStages.length, 3);
   assert.strictEqual(completedStages[0].stage.id, "collect-metadata");
   assert.strictEqual(completedStages[1].stage.id, "parallel-processing");
@@ -114,7 +114,7 @@ test("runStagesSequentially clears buffered artifacts after filtered collect+par
         capturedParallelOutputWriter = options.outputWriter;
         return Promise.resolve({
           results: options.modules.map(module => ({ ...module, fromCache: false, status: "success" })),
-          stage5Modules: options.modules
+          processedModules: options.modules
         });
       },
       writeSkippedModules: () => Promise.resolve()
@@ -179,7 +179,7 @@ test("runStagesSequentially passes aggregate stats in memory to result markdown
           modulesMinPath: "/virtual/project/website/data/modules.min.json",
           statsPath: "/virtual/project/website/data/stats.json"
         },
-        stage5ModulesCount: 1,
+        processedModulesCount: 1,
         stats,
         wroteOutputs: true
       }),
@@ -193,7 +193,7 @@ test("runStagesSequentially passes aggregate stats in memory to result markdown
       },
       parallelProcessing: () => Promise.resolve({
         results: modules.map(module => ({ ...module, fromCache: false, status: "success" })),
-        stage5Modules: modules
+        processedModules: modules
       }),
       writeSkippedModules: () => Promise.resolve()
     }
@@ -233,7 +233,7 @@ test("runStagesSequentially passes aggregate stats in memory to result markdown
   assert.strictEqual(completedStages.length, 4);
   assert.deepStrictEqual(capturedMarkdownOptions, {
     projectRoot: "/virtual/project",
-    stage5Modules: modules,
+    processedModules: modules,
     stats
   });
   assert.deepStrictEqual(stageRunner.getBufferedArtifactIds(), []);

scripts/orchestrator/in-process-stage-runner.ts

@@ -13,7 +13,7 @@ interface StageRuntimeOverrides {
   aggregateCatalogue?: (options: Record<string, unknown>) => Promise<unknown>;
   collectMetadata?: (options: Record<string, unknown>) => Promise<{ modules: unknown[] }>;
   generateResultMarkdown?: (options: Record<string, unknown>) => Promise<unknown>;
-  parallelProcessing?: (options: Record<string, unknown>) => Promise<{ results?: unknown[]; stage5Modules: unknown[] }>;
+  parallelProcessing?: (options: Record<string, unknown>) => Promise<{ results?: unknown[]; processedModules: unknown[] }>;
   writeSkippedModules?: (results: unknown[], projectRoot: string) => Promise<void>;
 }
 
@@ -68,16 +68,16 @@ export function createInProcessStageRunner({
         artifactStore.delete("modules-stage-2");
       }
 
-      artifactStore.set("modules-stage-5", result.stage5Modules);
+      artifactStore.set("modules-processed", result.processedModules);
       await writeSkippedModules(result.results ?? [], runRoot);
       return true;
     }
 
-    if (stage.id === "aggregate-catalogue" && artifactStore.has("modules-stage-5")) {
-      const stage5Modules = artifactStore.get("modules-stage-5") as unknown[];
+    if (stage.id === "aggregate-catalogue" && artifactStore.has("modules-processed")) {
+      const processedModules = artifactStore.get("modules-processed") as unknown[];
       const aggregateOptions = {
         projectRoot: runRoot,
-        stage5Modules: stage5Modules as never
+        processedModules: processedModules as never
       };
 
       const aggregateResult = await aggregateCatalogue(aggregateOptions);
@@ -93,20 +93,20 @@ export function createInProcessStageRunner({
       return true;
     }
 
-    if (stage.id === "generate-result-markdown" && artifactStore.has("modules-stage-5") && artifactStore.has("stats-json")) {
-      const stage5Modules = artifactStore.get("modules-stage-5");
+    if (stage.id === "generate-result-markdown" && artifactStore.has("modules-processed") && artifactStore.has("stats-json")) {
+      const processedModules = artifactStore.get("modules-processed");
       const stats = artifactStore.get("stats-json");
       const markdownOptions: Record<string, unknown> = {
         projectRoot: runRoot,
-        stage5Modules,
+        processedModules,
         stats
       };
 
       try {
         await generateResultMarkdown(markdownOptions);
       }
       finally {
-        artifactStore.delete("modules-stage-5");
+        artifactStore.delete("modules-processed");
         artifactStore.delete("stats-json");
       }
 

scripts/parallel-processing.ts

@@ -8,7 +8,7 @@
  */
 
 import { MODULE_ANALYSIS_CACHE_SCHEMA_VERSION, buildModuleAnalysisCacheKey, createModuleAnalysisCache, getProjectRevision, normalizeModuleAnalysisCheckGroups, resolveModuleAnalysisCachePath } from "../scripts/shared/module-analysis-cache.ts";
-import { toStage5Module } from "../scripts/shared/module-catalogue-output.ts";
+import { toProcessedModule } from "../scripts/shared/module-catalogue-output.ts";
 import { WorkerPool } from "../pipeline/workers/worker-pool.ts";
 import { cpus } from "node:os";
 import { createLogger } from "../scripts/shared/logger.ts";
@@ -99,7 +99,7 @@ export interface ParallelProcessingResult {
   failedCount: number;
   results: ModuleResult[];
   skippedCount: number;
-  stage5Modules: unknown[];
+  processedModules: unknown[];
   successCount: number;
 }
 
@@ -314,7 +314,7 @@ function buildMergedModules(modules: Stage2Module[], results: ModuleResult[]): M
   });
 }
 
-function summarizeResults(results: ModuleResult[], durationMs: number): Omit<ParallelProcessingResult, "durationMs" | "results" | "stage5Modules"> {
+function summarizeResults(results: ModuleResult[], durationMs: number): Omit<ParallelProcessingResult, "durationMs" | "results" | "processedModules"> {
   const successCount = results.filter(result => result.status === "success").length;
   const failedCount = results.filter(result => result.status === "failed").length;
   const skippedCount = results.filter(result => result.status === "skipped").length;
@@ -330,7 +330,7 @@ function summarizeResults(results: ModuleResult[], durationMs: number): Omit<Par
   };
 }
 
-function logProcessingSummary(results: ModuleResult[], durationMs: number, runLogger: ParallelLogger): Omit<ParallelProcessingResult, "durationMs" | "results" | "stage5Modules"> {
+function logProcessingSummary(results: ModuleResult[], durationMs: number, runLogger: ParallelLogger): Omit<ParallelProcessingResult, "durationMs" | "results" | "processedModules"> {
   const summary = summarizeResults(results, durationMs);
 
   runLogger.info("\n========== Processing Complete ==========");
@@ -360,7 +360,7 @@ function logProcessingSummary(results: ModuleResult[], durationMs: number, runLo
  * @param {string|null} [options.catalogueRevision] Catalogue revision override
  * @param {object|null} [options.workerPool] Injected worker pool for tests/future orchestrator wiring
  * @param {object} [options.runLogger] Logger implementation
- * @returns {Promise<object>} Summary, results, and generated stage5 modules
+ * @returns {Promise<object>} Summary, results, and generated processed modules
  */
 export async function runParallelProcessing({
   modules,
@@ -469,15 +469,15 @@ export async function runParallelProcessing({
   }
 
   const mergedModules = buildMergedModules(modules, results);
-  const stage5Modules = mergedModules.map(module => toStage5Module(module));
+  const processedModules = mergedModules.map(module => toProcessedModule(module));
   const durationMs = Date.now() - startTime;
   const summary = logProcessingSummary(results, durationMs, runLogger);
 
   return {
     ...summary,
     durationMs,
     results,
-    stage5Modules
+    processedModules
   };
 }