@beignet/cli 0.0.41 → 0.0.42

package/src/inspect.ts

@@ -1,4 +1,4 @@
-import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { parseProviderPackageMetadata } from "@beignet/core/providers";
 import { createPainter } from "./ansi.js";
@@ -15,6 +15,18 @@ import {
   type ResolvedBeignetConfig,
   resolveConfig,
 } from "./config.js";
+import {
+  applyPlannedDoctorFixes,
+  createDoctorFixPlan,
+  type DoctorFixApplyResult,
+  type DoctorFixOperationId,
+  type DoctorFixPlan,
+  type InspectFix,
+  type PlannedDoctorFixOperation,
+  type PlannedDoctorFixPlan,
+  planDoctorFixFileChange,
+  publicDoctorFixPlan,
+} from "./doctor-fixes.js";
 import {
   formatGithubAnnotation,
   type GithubAnnotationSeverity,
@@ -55,6 +67,7 @@ import {
 import {
   currentGeneratedPackageScripts,
   externalVersions,
+  isLegacyGeneratedPackageScript,
   legacyGeneratedPackageScripts,
 } from "./templates/shared.js";
 import { testSupportTemplateFiles } from "./templates/testing.js";
@@ -119,14 +132,7 @@ export type InspectDiagnostic = {
   contract?: string;
 };
 
-/**
- * Automatic doctor fix that was applied.
- */
-export type InspectFix = {
-  code: string;
-  message: string;
-  file: string;
-};
+export type { InspectFix } from "./doctor-fixes.js";
 
 /**
  * Detected app convention and missing convention files.
@@ -157,6 +163,18 @@ export type InspectAppResult = {
   fixes: InspectFix[];
 };
 
+/** Read-only doctor fix plan paired with the diagnostics it was derived from. */
+export type DoctorFixPlanResult = DoctorFixPlan & {
+  convention: InspectConvention;
+  diagnostics: InspectDiagnostic[];
+};
+
+/** Post-apply inspection paired with the guarded plan metadata that ran. */
+export type DoctorFixInspectionResult = InspectAppResult & {
+  planId: string;
+  operationIds: DoctorFixOperationId[];
+};
+
 type RouteExport = {
   method: HttpMethod;
   handlerFile: string;
@@ -235,9 +253,66 @@ export async function inspectApp(
   };
 }
 
+/** Options for guarded all-or-selected doctor fix application. */
+export type ApplyDoctorFixPlanOptions = InspectAppOptions & {
+  planId: string;
+  fixIds?: readonly DoctorFixOperationId[];
+};
+
+/** Plan every currently available low-risk doctor repair without writing. */
+export async function planDoctorFixes(
+  options: InspectAppOptions = {},
+): Promise<DoctorFixPlanResult> {
+  const plan = publicDoctorFixPlan(await buildDoctorFixPlan(options));
+  const inspected = await inspectApp(options);
+  return {
+    ...plan,
+    convention: inspected.convention,
+    diagnostics: inspected.diagnostics,
+  };
+}
+
+/** Apply a current doctor fix plan after verifying its plan ID. */
+export async function applyDoctorFixPlan(
+  options: ApplyDoctorFixPlanOptions,
+): Promise<DoctorFixApplyResult> {
+  const plan = await buildDoctorFixPlan(options);
+  if (plan.planId !== options.planId) {
+    throw new Error(
+      "Doctor fix plan is stale because the available repairs changed. No files were changed; run beignet doctor --fix --dry-run again.",
+    );
+  }
+  return applyPlannedDoctorFixes(plan, options.fixIds);
+}
+
 export async function applyDoctorFixes(
   options: InspectAppOptions = {},
 ): Promise<InspectFix[]> {
+  return (await applyDoctorFixesWithResult(options)).fixes;
+}
+
+export async function applyDoctorFixesWithResult(
+  options: InspectAppOptions = {},
+): Promise<DoctorFixApplyResult> {
+  const plan = await buildDoctorFixPlan(options);
+  return applyPlannedDoctorFixes(plan);
+}
+
+export function createDoctorFixInspectionResult(
+  inspected: InspectAppResult,
+  applied: DoctorFixApplyResult,
+): DoctorFixInspectionResult {
+  return {
+    ...inspected,
+    planId: applied.planId,
+    operationIds: applied.operationIds,
+    fixes: applied.fixes,
+  };
+}
+
+async function buildDoctorFixPlan(
+  options: InspectAppOptions = {},
+): Promise<PlannedDoctorFixPlan> {
   const targetDir = path.resolve(options.cwd ?? process.cwd());
   await assertDirectory(targetDir);
 
@@ -253,44 +328,63 @@ export async function applyDoctorFixes(
     config,
     contracts,
   );
-  const fixes: InspectFix[] = [];
+  const operations: PlannedDoctorFixOperation[] = [];
 
-  const packageFix = await fixPackageScripts(targetDir, files, convention);
-  if (packageFix) fixes.push(packageFix);
+  const packageFix = await planPackageScripts(targetDir, files, convention);
+  if (packageFix) operations.push(packageFix);
 
-  const routeGroupFix = await fixUnregisteredRouteGroups(
+  const routeGroupFix = await planUnregisteredRouteGroups(
     targetDir,
     files,
     config,
   );
-  if (routeGroupFix) fixes.push(routeGroupFix);
+  if (routeGroupFix) operations.push(routeGroupFix);
 
   const drift = await workflowRegistrationDrift(targetDir, files, config);
 
-  const scheduleFix = await fixUnregisteredSchedules(
+  if (config.paths.schedules === config.paths.tasks) {
+    const workflowFix = await planCoLocatedScheduleAndTaskRegistries(
+      targetDir,
+      files,
+      drift,
+      config,
+    );
+    if (workflowFix) operations.push(workflowFix);
+  } else {
+    const scheduleFix = await planUnregisteredSchedules(
+      targetDir,
+      files,
+      drift,
+      config,
+    );
+    if (scheduleFix) operations.push(scheduleFix);
+
+    const taskFix = await planUnregisteredTasks(
+      targetDir,
+      files,
+      drift,
+      config,
+    );
+    if (taskFix) operations.push(taskFix);
+  }
+
+  const outboxFix = await planUnregisteredOutboxEntries(
     targetDir,
     files,
     drift,
     config,
   );
-  if (scheduleFix) fixes.push(scheduleFix);
+  if (outboxFix) operations.push(outboxFix);
 
-  const taskFix = await fixUnregisteredTasks(targetDir, files, drift, config);
-  if (taskFix) fixes.push(taskFix);
-
-  fixes.push(
-    ...(await fixUnregisteredOutboxEntries(targetDir, files, drift, config)),
-  );
-
-  const listenerFix = await fixUnregisteredListeners(
+  const listenerFix = await planUnregisteredListeners(
     targetDir,
     files,
     drift,
     config,
   );
-  if (listenerFix) fixes.push(listenerFix);
+  if (listenerFix) operations.push(listenerFix);
 
-  const openApiFix = await fixDirectOpenApiArrayDrift(
+  const openApiFix = await planDirectOpenApiArrayDrift(
     targetDir,
     files,
     config,
@@ -298,9 +392,13 @@ export async function applyDoctorFixes(
     contracts,
     matchedRoutes,
   );
-  if (openApiFix) fixes.push(openApiFix);
+  if (openApiFix) operations.push(openApiFix);
 
-  return fixes;
+  return createDoctorFixPlan({
+    targetDir,
+    strict: Boolean(options.strict),
+    operations,
+  });
 }
 
 /**
@@ -329,12 +427,97 @@ export function formatRoutes(result: InspectAppResult): string {
   ]);
 }
 
+/**
+ * Format a read-only doctor fix plan with exact patches and apply commands.
+ */
+export function formatDoctorFixPlan(
+  plan: DoctorFixPlanResult,
+  options: { color?: boolean } = {},
+): string {
+  const paint = createPainter(options.color);
+  const lines: string[] = [];
+  if (plan.operations.length === 0) {
+    lines.push(`No applicable Beignet fixes found in ${plan.targetDir}.`);
+  } else {
+    const strictFlag = plan.strict ? " --strict" : "";
+    lines.push(
+      `Planned ${plan.operations.length} Beignet fix operation${plan.operations.length === 1 ? "" : "s"} in ${plan.targetDir}:`,
+      "",
+    );
+    for (const operation of plan.operations) {
+      lines.push(
+        `${paint("PLAN", "cyan")} ${operation.id}`,
+        ...operation.fixes.map(
+          (fix) => `  ${fix.code} ${fix.file}\n    ${fix.message}`,
+        ),
+        ...operation.changes.flatMap((change) => [
+          `  ${change.kind === "create" ? "Create" : "Update"} ${change.file}`,
+          change.patch.trimEnd(),
+        ]),
+        "",
+      );
+    }
+
+    lines.push(
+      `Plan ID: ${plan.planId}`,
+      "",
+      "Apply the complete plan:",
+      `  beignet doctor --fix${strictFlag} --plan ${plan.planId}`,
+      "",
+      "Apply selected operations:",
+      `  beignet doctor --fix${strictFlag} --plan ${plan.planId} --only ${plan.operations.map((operation) => operation.id).join(",")}`,
+    );
+  }
+
+  lines.push(
+    "",
+    formatDoctorResult(
+      {
+        targetDir: plan.targetDir,
+        strict: plan.strict,
+        diagnostics: plan.diagnostics,
+        fixes: [],
+      },
+      options,
+    ),
+  );
+  return lines.join("\n");
+}
+
+/**
+ * Format planned fixes as GitHub Actions notice annotations.
+ */
+export function formatDoctorFixPlanGithub(plan: DoctorFixPlanResult): string {
+  return [
+    ...plan.operations.map((operation) =>
+      formatGithubAnnotation({
+        severity: "notice",
+        file: operation.changes[0]?.file,
+        message: `${operation.id}: ${operation.fixes.map((fix) => fix.message).join(" ")} Plan ${plan.planId}.`,
+      }),
+    ),
+    ...formatDoctorDiagnosticsGithub(plan.diagnostics),
+  ].join("\n");
+}
+
+type DoctorFormatResult = Pick<
+  InspectAppResult,
+  "targetDir" | "strict" | "diagnostics" | "fixes"
+>;
+
 /**
  * Format doctor diagnostics and applied fixes for CLI output.
  */
 export function formatDoctor(
   result: InspectAppResult,
   options: { color?: boolean } = {},
+): string {
+  return formatDoctorResult(result, options);
+}
+
+function formatDoctorResult(
+  result: DoctorFormatResult,
+  options: { color?: boolean } = {},
 ): string {
   const paint = createPainter(options.color);
   const fixLines =
@@ -456,7 +639,7 @@ function productionHardeningChecklist(
   ];
 }
 
-function formatDoctorFooter(result: InspectAppResult): string {
+function formatDoctorFooter(result: DoctorFormatResult): string {
   const count = (severity: InspectDiagnostic["severity"]) =>
     result.diagnostics.filter((diagnostic) => diagnostic.severity === severity)
       .length;
@@ -469,15 +652,19 @@ function formatDoctorFooter(result: InspectAppResult): string {
  * Format doctor diagnostics as GitHub Actions annotations.
  */
 export function formatDoctorGithub(result: InspectAppResult): string {
-  return result.diagnostics
-    .map((diagnostic) =>
-      formatGithubAnnotation({
-        severity: githubAnnotationSeverity(diagnostic.severity),
-        file: diagnostic.file,
-        message: `${diagnostic.code}: ${diagnostic.message}`,
-      }),
-    )
-    .join("\n");
+  return formatDoctorDiagnosticsGithub(result.diagnostics).join("\n");
+}
+
+function formatDoctorDiagnosticsGithub(
+  diagnostics: InspectDiagnostic[],
+): string[] {
+  return diagnostics.map((diagnostic) =>
+    formatGithubAnnotation({
+      severity: githubAnnotationSeverity(diagnostic.severity),
+      file: diagnostic.file,
+      message: `${diagnostic.code}: ${diagnostic.message}`,
+    }),
+  );
 }
 
 function githubAnnotationSeverity(
@@ -6020,8 +6207,7 @@ async function inspectPackageScripts(
       severity: "warning",
       code: "BEIGNET_PACKAGE_TEST_SCRIPT_MISSING",
       file: "package.json",
-      message:
-        'package.json does not define a test script. Add "test": "tsx lib/beignet-test-runner.ts" or run beignet doctor --fix.',
+      message: `package.json does not define a test script. Add "test": "${currentGeneratedPackageScripts.test}" or run beignet doctor --fix.`,
     });
   }
 
@@ -6033,7 +6219,7 @@ async function inspectPackageScripts(
       severity: "warning",
       code: "BEIGNET_PACKAGE_SCRIPT_LEGACY",
       file: "package.json",
-      message: `package.json still uses legacy generated Bun scripts for ${legacyScripts.join(", ")}. Run beignet doctor --fix to migrate them to package-manager-neutral tsx scripts.`,
+      message: `package.json still uses legacy generated scripts for ${legacyScripts.join(", ")}. Run beignet doctor --fix to migrate them to the current package-manager-neutral scripts.`,
     });
   }
 
@@ -6067,11 +6253,11 @@ async function inspectPackageScripts(
   return diagnostics;
 }
 
-async function fixPackageScripts(
+async function planPackageScripts(
   targetDir: string,
   files: string[],
   convention: InspectConvention,
-): Promise<InspectFix | undefined> {
+): Promise<PlannedDoctorFixOperation | undefined> {
   if (!convention.resourceGenerator || !files.includes("package.json")) {
     return undefined;
   }
@@ -6097,10 +6283,8 @@ async function fixPackageScripts(
   }
 
   if (!hasDirectBunTestImports) {
-    for (const [name, legacyCommand] of Object.entries(
-      legacyGeneratedPackageScripts,
-    )) {
-      if (packageJson.scripts[name] === legacyCommand) {
+    for (const name of Object.keys(legacyGeneratedPackageScripts)) {
+      if (isLegacyGeneratedPackageScript(name, packageJson.scripts[name])) {
         packageJson.scripts[name] = currentGeneratedPackageScripts[name];
         if (!updatedScripts.includes(name)) updatedScripts.push(name);
       }
@@ -6118,29 +6302,25 @@ async function fixPackageScripts(
   }
 
   const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
-  const createdSupportFiles = await createMissingTestSupportFiles(
-    targetDir,
-    files,
-    packageJson.scripts.test === currentGeneratedPackageScripts.test,
-  );
+  const createdSupportFiles =
+    packageJson.scripts.test === currentGeneratedPackageScripts.test
+      ? missingTestSupportFiles(files)
+      : [];
 
   if (next === original && createdSupportFiles.length === 0) return undefined;
 
-  if (next !== original) await writeFile(filePath, next);
-
+  let fix: InspectFix | undefined;
   if (addedTestScript) {
-    return {
+    fix = {
       code: "BEIGNET_PACKAGE_TEST_SCRIPT_MISSING",
       file: "package.json",
       message:
         createdSupportFiles.length > 0
-          ? `Added "test": "tsx lib/beignet-test-runner.ts" and ${createdSupportFiles.join(", ")}.`
-          : 'Added "test": "tsx lib/beignet-test-runner.ts".',
+          ? `Added "test": "${currentGeneratedPackageScripts.test}" and ${createdSupportFiles.join(", ")}.`
+          : `Added "test": "${currentGeneratedPackageScripts.test}".`,
     };
-  }
-
-  if (updatedScripts.length > 0) {
-    return {
+  } else if (updatedScripts.length > 0) {
+    fix = {
       code: "BEIGNET_PACKAGE_SCRIPT_LEGACY",
       file: "package.json",
       message: packageScriptFixMessage(
@@ -6149,31 +6329,48 @@ async function fixPackageScripts(
         addedTsx,
       ),
     };
-  }
-
-  if (createdSupportFiles.length > 0) {
-    return {
+  } else if (createdSupportFiles.length > 0) {
+    fix = {
       code: "BEIGNET_PACKAGE_TEST_SUPPORT_MISSING",
       file: "package.json",
       message: `Restored ${createdSupportFiles.join(", ")}.`,
     };
-  }
-
-  if (addedTsx) {
-    return {
+  } else if (addedTsx) {
+    fix = {
       code: "BEIGNET_PACKAGE_TSX_DEPENDENCY_MISSING",
       file: "package.json",
       message: 'Added "tsx" to devDependencies.',
     };
   }
 
-  return undefined;
+  if (!fix) return undefined;
+
+  return {
+    id: "package.repair-generated-support",
+    fixes: [fix],
+    changes: [
+      ...(next === original
+        ? []
+        : [
+            planDoctorFixFileChange({
+              file: "package.json",
+              before: original,
+              after: next,
+            }),
+          ]),
+      ...testSupportTemplateFiles
+        .filter((file) => createdSupportFiles.includes(file.path))
+        .map((file) =>
+          planDoctorFixFileChange({ file: file.path, after: file.content }),
+        ),
+    ],
+  };
 }
 
 function legacyGeneratedScriptNames(scripts: Record<string, string>): string[] {
-  return Object.entries(legacyGeneratedPackageScripts)
-    .filter(([name, command]) => scripts[name] === command)
-    .map(([name]) => name);
+  return Object.keys(legacyGeneratedPackageScripts).filter((name) =>
+    isLegacyGeneratedPackageScript(name, scripts[name]),
+  );
 }
 
 async function appUsesDirectBunTestImports(
@@ -6194,7 +6391,8 @@ function hasCurrentGeneratedTsxScript(
 ): boolean {
   return Object.values(currentGeneratedPackageScripts).some(
     (command) =>
-      command.startsWith("tsx ") && Object.values(scripts).includes(command),
+      (command.startsWith("tsx ") || command.includes("--import tsx")) &&
+      Object.values(scripts).includes(command),
   );
 }
 
@@ -6204,23 +6402,6 @@ function missingTestSupportFiles(files: string[]): string[] {
     .filter((file) => !files.includes(file));
 }
 
-async function createMissingTestSupportFiles(
-  targetDir: string,
-  files: string[],
-  shouldCreate: boolean,
-): Promise<string[]> {
-  if (!shouldCreate) return [];
-  const createdSupportFiles: string[] = [];
-  for (const file of testSupportTemplateFiles) {
-    if (files.includes(file.path)) continue;
-    const destination = path.join(targetDir, file.path);
-    await mkdir(path.dirname(destination), { recursive: true });
-    await writeFile(destination, file.content);
-    createdSupportFiles.push(file.path);
-  }
-  return createdSupportFiles;
-}
-
 function packageScriptFixMessage(
   updatedScripts: string[],
   createdSupportFiles: string[],
@@ -6727,14 +6908,14 @@ function findRouteGroupContract(
   );
 }
 
-async function fixDirectOpenApiArrayDrift(
+async function planDirectOpenApiArrayDrift(
   targetDir: string,
   files: string[],
   config: ResolvedBeignetConfig,
   convention: InspectConvention,
   contracts: InspectedContract[],
   matchedRoutes: MatchedRoutesResult,
-): Promise<InspectFix | undefined> {
+): Promise<PlannedDoctorFixOperation | undefined> {
   const routePath = path.join(targetDir, config.paths.openapiRoute);
   let source: string;
   try {
@@ -6777,21 +6958,32 @@ async function fixDirectOpenApiArrayDrift(
   )}`;
   if (next === source) return undefined;
 
-  await writeFile(routePath, next);
   return {
-    code: "BEIGNET_OPENAPI_MISSING",
-    file: config.paths.openapiRoute,
-    message: `Added ${missingContracts
-      .map((contract) => contract.exportName)
-      .join(", ")} to the direct createOpenAPIHandler contract array.`,
+    id: "openapi.register-missing",
+    fixes: [
+      {
+        code: "BEIGNET_OPENAPI_MISSING",
+        file: config.paths.openapiRoute,
+        message: `Added ${missingContracts
+          .map((contract) => contract.exportName)
+          .join(", ")} to the direct createOpenAPIHandler contract array.`,
+      },
+    ],
+    changes: [
+      planDoctorFixFileChange({
+        file: config.paths.openapiRoute,
+        before: source,
+        after: next,
+      }),
+    ],
   };
 }
 
-async function fixUnregisteredRouteGroups(
+async function planUnregisteredRouteGroups(
   targetDir: string,
   files: string[],
   config: ResolvedBeignetConfig,
-): Promise<InspectFix | undefined> {
+): Promise<PlannedDoctorFixOperation | undefined> {
   if (!files.includes(config.paths.server)) return undefined;
 
   const routeGroups = await readFeatureRouteGroups(targetDir, files, config);
@@ -6862,25 +7054,36 @@ async function fixUnregisteredRouteGroups(
   )}`;
   if (next === original) return undefined;
 
-  await writeFile(targetPath, next);
   return {
-    code: "BEIGNET_ROUTE_GROUP_UNREGISTERED",
-    file: targetFile,
-    message: `Registered ${groupsToAppend
-      .map((routeGroup) => routeGroup.name)
-      .join(", ")} in the central route list.`,
+    id: "routes.register-missing",
+    fixes: [
+      {
+        code: "BEIGNET_ROUTE_GROUP_UNREGISTERED",
+        file: targetFile,
+        message: `Registered ${groupsToAppend
+          .map((routeGroup) => routeGroup.name)
+          .join(", ")} in the central route list.`,
+      },
+    ],
+    changes: [
+      planDoctorFixFileChange({
+        file: targetFile,
+        before: original,
+        after: next,
+      }),
+    ],
   };
 }
 
-async function fixUnregisteredSchedules(
+async function planUnregisteredSchedules(
   targetDir: string,
   files: string[],
   drift: WorkflowRegistrationDrift,
   config: ResolvedBeignetConfig,
-): Promise<InspectFix | undefined> {
+): Promise<PlannedDoctorFixOperation | undefined> {
   if (!drift.schedules.centralExists) return undefined;
 
-  return applyWorkflowRegistryFix({
+  return planWorkflowRegistryOperation("schedules.register-missing", {
     targetDir,
     files,
     centralFile: config.paths.schedules,
@@ -6893,15 +7096,15 @@ async function fixUnregisteredSchedules(
   });
 }
 
-async function fixUnregisteredTasks(
+async function planUnregisteredTasks(
   targetDir: string,
   files: string[],
   drift: WorkflowRegistrationDrift,
   config: ResolvedBeignetConfig,
-): Promise<InspectFix | undefined> {
+): Promise<PlannedDoctorFixOperation | undefined> {
   if (!drift.tasks.centralExists) return undefined;
 
-  return applyWorkflowRegistryFix({
+  return planWorkflowRegistryOperation("tasks.register-missing", {
     targetDir,
     files,
     centralFile: config.paths.tasks,
@@ -6915,6 +7118,84 @@ async function fixUnregisteredTasks(
   });
 }
 
+async function planCoLocatedScheduleAndTaskRegistries(
+  targetDir: string,
+  files: string[],
+  drift: WorkflowRegistrationDrift,
+  config: ResolvedBeignetConfig,
+): Promise<PlannedDoctorFixOperation | undefined> {
+  if (!drift.schedules.centralExists || !drift.tasks.centralExists) {
+    return undefined;
+  }
+
+  const centralFile = config.paths.schedules;
+  let original: string;
+  try {
+    original = await readFile(path.join(targetDir, centralFile), "utf8");
+  } catch {
+    return undefined;
+  }
+
+  let next = original;
+  const fixes: InspectFix[] = [];
+  const repairedKinds: Array<"schedules" | "tasks"> = [];
+
+  const scheduleEdit = planWorkflowRegistryEdit({
+    files,
+    centralFile,
+    source: next,
+    unregistered: drift.schedules.unregistered,
+    code: "BEIGNET_SCHEDULE_UNREGISTERED",
+    listName: "the schedules array",
+    importSpecifier: (indexFile) => `@/${modulePath(indexFile)}`,
+    append: (source, entry, importLine) =>
+      appendToNamedArray(source, "schedules", entry, importLine),
+  });
+  if (scheduleEdit) {
+    next = scheduleEdit.after;
+    fixes.push(scheduleEdit.fix);
+    repairedKinds.push("schedules");
+  }
+
+  const taskEdit = planWorkflowRegistryEdit({
+    files,
+    centralFile,
+    source: next,
+    unregistered: drift.tasks.unregistered,
+    code: "BEIGNET_TASK_UNREGISTERED",
+    listName: "defineTasks([...])",
+    importSpecifier: (indexFile) => relativeModule(centralFile, indexFile),
+    append: (source, entry, importLine) =>
+      appendToNamedArray(source, "tasks", entry, importLine),
+  });
+  if (taskEdit) {
+    next = taskEdit.after;
+    fixes.push(taskEdit.fix);
+    repairedKinds.push("tasks");
+  }
+
+  if (fixes.length === 0 || next === original) return undefined;
+
+  const id: DoctorFixOperationId =
+    repairedKinds.length === 2
+      ? "workflows.register-missing"
+      : repairedKinds[0] === "schedules"
+        ? "schedules.register-missing"
+        : "tasks.register-missing";
+
+  return {
+    id,
+    fixes,
+    changes: [
+      planDoctorFixFileChange({
+        file: centralFile,
+        before: original,
+        after: next,
+      }),
+    ],
+  };
+}
+
 /**
  * Wire fully unregistered feature listener registries into the central
  * listener registry and ensure the providers file registers that central
@@ -6926,12 +7207,12 @@ async function fixUnregisteredTasks(
  * register against, or when the registry name is already imported from another
  * file. The diagnostic stays in every bail case.
  */
-async function fixUnregisteredListeners(
+async function planUnregisteredListeners(
   targetDir: string,
   files: string[],
   drift: WorkflowRegistrationDrift,
   config: ResolvedBeignetConfig,
-): Promise<InspectFix | undefined> {
+): Promise<PlannedDoctorFixOperation | undefined> {
   const candidates = drift.listeners.unregistered.filter(
     (entry) => entry.fullyUnregistered,
   );
@@ -7028,32 +7309,61 @@ async function fixUnregisteredListeners(
     return undefined;
   }
 
-  await mkdir(path.dirname(listenersPath), { recursive: true });
-  await writeFile(listenersPath, nextListeners);
-  if (nextProviders !== originalProviders) {
-    await writeFile(providersPath, nextProviders);
-  }
   return {
-    code: "BEIGNET_LISTENER_UNREGISTERED",
-    file: listenersFile,
-    message: `Registered ${candidateNames.join(", ")} in ${listenersFile} and wired listeners with registerListeners(...) in ${providersFile}.`,
+    id: "listeners.register-missing",
+    fixes: [
+      {
+        code: "BEIGNET_LISTENER_UNREGISTERED",
+        file: listenersFile,
+        message: `Registered ${candidateNames.join(", ")} in ${listenersFile} and wired listeners with registerListeners(...) in ${providersFile}.`,
+      },
+    ],
+    changes: [
+      ...(nextListeners === originalListeners
+        ? []
+        : [
+            planDoctorFixFileChange({
+              file: listenersFile,
+              before: originalListeners,
+              after: nextListeners,
+            }),
+          ]),
+      ...(nextProviders === originalProviders
+        ? []
+        : [
+            planDoctorFixFileChange({
+              file: providersFile,
+              before: originalProviders,
+              after: nextProviders,
+            }),
+          ]),
+    ],
   };
 }
 
-async function fixUnregisteredOutboxEntries(
+async function planUnregisteredOutboxEntries(
   targetDir: string,
   files: string[],
   drift: WorkflowRegistrationDrift,
   config: ResolvedBeignetConfig,
-): Promise<InspectFix[]> {
-  if (!drift.outbox.exists) return [];
+): Promise<PlannedDoctorFixOperation | undefined> {
+  if (!drift.outbox.exists) return undefined;
+
+  const outboxPath = path.join(targetDir, config.paths.outbox);
+  let original: string;
+  try {
+    original = await readFile(outboxPath, "utf8");
+  } catch {
+    return undefined;
+  }
 
+  let next = original;
   const fixes: InspectFix[] = [];
 
-  const eventFix = await applyWorkflowRegistryFix({
-    targetDir,
+  const eventFix = planWorkflowRegistryEdit({
     files,
     centralFile: config.paths.outbox,
+    source: next,
     unregistered: drift.outbox.events,
     code: "BEIGNET_OUTBOX_EVENT_UNREGISTERED",
     listName: "the outbox events list",
@@ -7061,12 +7371,15 @@ async function fixUnregisteredOutboxEntries(
     append: (source, entry, importLine) =>
       appendToOutboxRegistryArray(source, "events", entry, importLine),
   });
-  if (eventFix) fixes.push(eventFix);
+  if (eventFix) {
+    next = eventFix.after;
+    fixes.push(eventFix.fix);
+  }
 
-  const jobFix = await applyWorkflowRegistryFix({
-    targetDir,
+  const jobFix = planWorkflowRegistryEdit({
     files,
     centralFile: config.paths.outbox,
+    source: next,
     unregistered: drift.outbox.jobs,
     code: "BEIGNET_OUTBOX_JOB_UNREGISTERED",
     listName: "the outbox jobs list",
@@ -7074,9 +7387,23 @@ async function fixUnregisteredOutboxEntries(
     append: (source, entry, importLine) =>
       appendToOutboxRegistryArray(source, "jobs", entry, importLine),
   });
-  if (jobFix) fixes.push(jobFix);
+  if (jobFix) {
+    next = jobFix.after;
+    fixes.push(jobFix.fix);
+  }
 
-  return fixes;
+  if (fixes.length === 0 || next === original) return undefined;
+  return {
+    id: "outbox.register-missing",
+    fixes,
+    changes: [
+      planDoctorFixFileChange({
+        file: config.paths.outbox,
+        before: original,
+        after: next,
+      }),
+    ],
+  };
 }
 
 /**
@@ -7088,7 +7415,7 @@ async function fixUnregisteredOutboxEntries(
  * some members are already individually registered (appending the registry
  * spread would run those members twice). The diagnostic stays in that case.
  */
-async function applyWorkflowRegistryFix(options: {
+type WorkflowRegistryPlanOptions = {
   targetDir: string;
   files: string[];
   centralFile: string;
@@ -7097,12 +7424,12 @@ async function applyWorkflowRegistryFix(options: {
   listName: string;
   importSpecifier: (indexFile: string) => string;
   append: (source: string, entry: string, importLine?: string) => AppendResult;
-}): Promise<InspectFix | undefined> {
-  const candidates = options.unregistered.filter(
-    (entry) => entry.fullyUnregistered,
-  );
-  if (candidates.length === 0) return undefined;
+};
 
+async function planWorkflowRegistryOperation(
+  id: DoctorFixOperationId,
+  options: WorkflowRegistryPlanOptions,
+): Promise<PlannedDoctorFixOperation | undefined> {
   const centralPath = path.join(options.targetDir, options.centralFile);
   let original: string;
   try {
@@ -7111,7 +7438,30 @@ async function applyWorkflowRegistryFix(options: {
     return undefined;
   }
 
-  let next = original;
+  const edit = planWorkflowRegistryEdit({ ...options, source: original });
+  if (!edit) return undefined;
+  return {
+    id,
+    fixes: [edit.fix],
+    changes: [
+      planDoctorFixFileChange({
+        file: options.centralFile,
+        before: original,
+        after: edit.after,
+      }),
+    ],
+  };
+}
+
+function planWorkflowRegistryEdit(
+  options: Omit<WorkflowRegistryPlanOptions, "targetDir"> & { source: string },
+): { after: string; fix: InspectFix } | undefined {
+  const candidates = options.unregistered.filter(
+    (entry) => entry.fullyUnregistered,
+  );
+  if (candidates.length === 0) return undefined;
+
+  let next = options.source;
   const registeredNames: string[] = [];
 
   for (const { registry } of candidates) {
@@ -7143,13 +7493,15 @@ async function applyWorkflowRegistryFix(options: {
     }
   }
 
-  if (next === original || registeredNames.length === 0) return undefined;
+  if (next === options.source || registeredNames.length === 0) return undefined;
 
-  await writeFile(centralPath, next);
   return {
-    code: options.code,
-    file: options.centralFile,
-    message: `Registered ${registeredNames.join(", ")} in ${options.listName}.`,
+    after: next,
+    fix: {
+      code: options.code,
+      file: options.centralFile,
+      message: `Registered ${registeredNames.join(", ")} in ${options.listName}.`,
+    },
   };
 }