@rehearsal-db/core 0.1.0-beta.4 → 0.1.0-beta.6

package/scripts/operations/rehearsal/rehearsal_cli.mjs

@@ -36,9 +36,11 @@ import {
 import { createSyntheticBaselineFromFiles } from "../../lib/rehearsal/baseline_builder.mjs";
 import {
   applyBaselinePreparation,
+  inspectBaselineInputFiles,
   planBaselinePreparation,
   summarizeBaselinePreparation,
 } from "../../lib/rehearsal/baseline_preparation.mjs";
+import { discoverBaselineInputFiles } from "../../lib/rehearsal/input_discovery.mjs";
 import {
   applyRehearsalSetup,
   inspectRehearsalNodeRuntime,
@@ -49,8 +51,11 @@ import { formatCount } from "../../lib/rehearsal/human_output.mjs";
 import {
   applyReviewedPolicy,
   completePolicyDraft,
+  createSafeTablePreset,
   readReviewablePolicyDraft,
+  suggestPolicyExceptionColumns,
 } from "../../lib/rehearsal/policy_review.mjs";
+import { collectRehearsalSupportReport } from "../../lib/rehearsal/support_report.mjs";
 
 const packageRoot = fileURLToPath(new URL("../../..", import.meta.url));
 const projectRoot = process.cwd();
@@ -75,6 +80,7 @@ const parseArguments = (arguments_) => {
     recordsPath: undefined,
     ledgerPath: undefined,
     assetsPath: undefined,
+    target: undefined,
   };
   const positionals = [];
   for (const argument of arguments_) {
@@ -95,6 +101,8 @@ const parseArguments = (arguments_) => {
       flags.ledgerPath = argument.slice("--ledger=".length);
     } else if (argument.startsWith("--assets=")) {
       flags.assetsPath = argument.slice("--assets=".length);
+    } else if (argument.startsWith("--target=")) {
+      flags.target = argument.slice("--target=".length);
     } else if (argument.startsWith("--")) {
       throw new Error(`Unknown Rehearsal option: ${argument}.`);
     } else positionals.push(argument);
@@ -269,10 +277,16 @@ const formatDuration = (durationMs) =>
     ? `${Math.round(durationMs)}ms`
     : `${(durationMs / 1_000).toFixed(1)}s`;
 
-const promptForChoice = async ({ message, options, flags = {} }) => {
+const promptForChoice = async ({
+  message,
+  options,
+  flags = {},
+  optionsAlreadyShown = false,
+}) => {
   if (useStyledPrompts(flags)) {
     const selected = await prompts.select({
       message,
+      maxItems: options.length,
       options: options.map((option) => ({
         value: option,
         label: option.label,
@@ -283,6 +297,18 @@ const promptForChoice = async ({ message, options, flags = {} }) => {
       ? options.find((option) => option.command === "exit")
       : selected;
   }
+  if (!optionsAlreadyShown) {
+    console.log(
+      [
+        "",
+        ...options.map(
+          (option, index) =>
+            `  ${index === 0 ? "›" : " "} ${index + 1}. ${option.label}${option.hint ? ` — ${option.hint}` : ""}`,
+        ),
+        "",
+      ].join("\n"),
+    );
+  }
   const prompt = createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -341,7 +367,7 @@ const promptForPath = async ({
       placeholder: defaultValue ?? (optional ? "Leave blank for none" : ""),
       defaultValue,
       validate: (value) => {
-        const resolved = String(value ?? defaultValue ?? "").trim();
+        const resolved = String(value || defaultValue || "").trim();
         if (!optional && !resolved) return "Enter a value.";
         return resolved && validate ? validate(resolved) : undefined;
       },
@@ -375,16 +401,107 @@ const promptForPath = async ({
   }
 };
 
+const promptForDiscoveredPath = async ({
+  message,
+  candidates,
+  optional = false,
+  flags,
+}) => {
+  if (candidates.length === 0) {
+    return promptForPath({ message, optional, flags });
+  }
+  const noneValue = "\0none";
+  const manualValue = "\0manual";
+  const selected = await promptForSelection({
+    message,
+    flags,
+    options: [
+      ...(optional
+        ? [
+            {
+              label: "No storage assets",
+              hint: "Continue without an asset manifest",
+              value: noneValue,
+            },
+          ]
+        : []),
+      ...candidates.map((path) => ({ label: path, value: path })),
+      { label: "Enter another path", value: manualValue },
+    ],
+  });
+  if (!selected || selected === noneValue) return undefined;
+  if (selected !== manualValue) return selected;
+  return promptForPath({ message, optional, flags });
+};
+
 const promptForSelection = async ({ message, options, flags }) => {
   const selected = await promptForChoice({ message, options, flags });
   return selected?.value;
 };
 
-const firstExistingPath = async (candidates) => {
-  for (const candidate of candidates) {
-    if (await pathExists(join(projectRoot, candidate))) return candidate;
+const promptForMultipleChoice = async ({
+  message,
+  options,
+  initialValues = [],
+  flags,
+}) => {
+  if (useStyledPrompts(flags)) {
+    const selected = await prompts.multiselect({
+      message,
+      options: options.map((option) => ({
+        value: option.value,
+        label: option.label,
+        hint: option.hint,
+      })),
+      initialValues,
+      required: false,
+    });
+    return prompts.isCancel(selected) ? undefined : selected;
+  }
+  const initial = new Set(initialValues);
+  console.log("");
+  console.log(message);
+  for (const [index, option] of options.entries()) {
+    console.log(
+      `  ${index + 1}. ${option.label}${initial.has(option.value) ? " (suggested)" : ""}`,
+    );
+  }
+  const defaultNumbers = options
+    .map((option, index) => (initial.has(option.value) ? index + 1 : undefined))
+    .filter(Boolean)
+    .join(",");
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    while (true) {
+      const suffix = defaultNumbers ? ` [${defaultNumbers}]` : " [none]";
+      const answer = (
+        await prompt.question(
+          `Choose comma-separated numbers, all, or none${suffix}: `,
+        )
+      )
+        .trim()
+        .toLowerCase();
+      if (!answer) return [...initialValues];
+      if (answer === "none") return [];
+      if (answer === "all") return options.map((option) => option.value);
+      const indexes = answer.split(",").map((value) => Number(value.trim()));
+      if (
+        indexes.length > 0 &&
+        indexes.every(
+          (index) =>
+            Number.isInteger(index) && index >= 1 && index <= options.length,
+        )
+      ) {
+        return [...new Set(indexes)].map((index) => options[index - 1].value);
+      }
+      console.log(`Choose numbers from 1 to ${options.length}, all, or none.`);
+    }
+  } finally {
+    prompt.close();
   }
-  return undefined;
 };
 
 const inspectGuidedProject = async (planOptions) => {
@@ -405,6 +522,7 @@ const inspectGuidedProject = async (planOptions) => {
       detected,
       node,
       config: "missing",
+      target: detected.hasSupabaseConfig ? "supabase" : "postgresql",
       baseline: false,
       runtime: false,
     };
@@ -417,6 +535,7 @@ const inspectGuidedProject = async (planOptions) => {
       detected,
       node,
       config: "invalid",
+      target: undefined,
       configPath,
       configError: redactDiagnosticValue(String(error?.message ?? error)),
       baseline: false,
@@ -447,6 +566,7 @@ const inspectGuidedProject = async (planOptions) => {
     detected,
     node,
     config: "valid",
+    target: loaded.config.runtime.target,
     configPath,
     baseline: Boolean(migrationSummary),
     policy,
@@ -467,116 +587,180 @@ const reviewPolicyInteractively = async ({ state, flags }) => {
     (total, table) => total + (table.columns?.length ?? 0),
     0,
   );
-  let reviewedColumns = 0;
+  const tableSummaries = [];
+  let individuallyReviewed = 0;
   if (useStyledPrompts(flags)) {
     prompts.note(
       [
-        `${formatCount(totalColumns, "column")} require explicit review.`,
+        `${formatCount(totalColumns, "column")} across ${formatCount(draft.tables.length, "table")} require explicit review.`,
         "No row values are displayed or changed by this step.",
-        "The safest replacement-oriented choices appear first.",
+        "Safe defaults replace values, mark generated NEVER and identity NO, and set no foreign key.",
+        "Likely structural columns start selected for individual review.",
       ].join("\n"),
       "Review the script",
     );
   }
+  const reviewColumn = async ({ table, column }) => {
+    individuallyReviewed += 1;
+    const label = `${table}.${column}`;
+    const action = await promptForSelection({
+      message: `${label}: how should this value be handled?`,
+      flags,
+      options: [
+        {
+          label: "Replace with synthetic data",
+          hint: "Safest default",
+          value: "REPLACE WITH SYNTHETIC",
+        },
+        {
+          label: "Pseudonymize consistently",
+          hint: "Stable links without original values",
+          value: "PSEUDONYMIZE",
+        },
+        {
+          label: "Derive a safe value",
+          value: "DERIVE",
+        },
+        { label: "Exclude this field", value: "EXCLUDE" },
+        {
+          label: "Keep exactly",
+          hint: "Only for values explicitly safe to retain",
+          value: "KEEP EXACTLY",
+        },
+      ],
+    });
+    if (!action) throw new Error("Policy review was cancelled.");
+    const generated = await promptForSelection({
+      message: `${label}: is this column always database-generated?`,
+      flags,
+      options: [
+        { label: "No", value: "NEVER" },
+        { label: "Yes", value: "ALWAYS" },
+      ],
+    });
+    if (!generated) throw new Error("Policy review was cancelled.");
+    const identity = await promptForSelection({
+      message: `${label}: is this an identity column?`,
+      flags,
+      options: [
+        { label: "No", value: "NO" },
+        { label: "Yes", value: "YES" },
+      ],
+    });
+    if (!identity) throw new Error("Policy review was cancelled.");
+    const hasForeignKey = await promptForConfirmation(
+      `${label}: does this column reference another table?`,
+      flags,
+      { cancelValue: null },
+    );
+    if (hasForeignKey === null) {
+      throw new Error("Policy review was cancelled.");
+    }
+    let foreignKey = null;
+    if (hasForeignKey) {
+      const schema = await promptForPath({
+        message: `${label}: referenced schema`,
+        defaultValue: "public",
+        flags,
+        validate: (value) =>
+          /^[a-z][a-z0-9_]{0,62}$/u.test(value)
+            ? undefined
+            : "Use a lowercase PostgreSQL identifier.",
+      });
+      const referencedTable = await promptForPath({
+        message: `${label}: referenced table`,
+        flags,
+        validate: (value) =>
+          /^[a-z][a-z0-9_]{0,62}$/u.test(value)
+            ? undefined
+            : "Use a lowercase PostgreSQL identifier.",
+      });
+      const referencedColumn = await promptForPath({
+        message: `${label}: referenced column`,
+        flags,
+        validate: (value) =>
+          /^[a-z][a-z0-9_]{0,62}$/u.test(value)
+            ? undefined
+            : "Use a lowercase PostgreSQL identifier.",
+      });
+      if (!schema || !referencedTable || !referencedColumn) {
+        throw new Error("Policy review was cancelled.");
+      }
+      foreignKey = {
+        schema,
+        table: referencedTable,
+        column: referencedColumn,
+      };
+    }
+    return { action, generated, identity, foreignKey };
+  };
   const policy = await completePolicyDraft({
     draft,
-    reviewColumn: async ({ table, column }) => {
-      reviewedColumns += 1;
-      const label = `${table}.${column} (${reviewedColumns}/${totalColumns})`;
-      const action = await promptForSelection({
-        message: `${label}: how should this value be handled?`,
+    reviewColumn,
+    reviewTable: async ({ table, columns }) => {
+      if (columns.length === 1) {
+        tableSummaries.push({ table, defaulted: 0, individual: 1 });
+        return {};
+      }
+      const mode = await promptForSelection({
+        message: `${table}: how would you like to review ${formatCount(columns.length, "column")}?`,
         flags,
         options: [
           {
-            label: "Replace with synthetic data",
-            hint: "Safest default",
-            value: "REPLACE WITH SYNTHETIC",
-          },
-          {
-            label: "Pseudonymize consistently",
-            hint: "Stable links without original values",
-            value: "PSEUDONYMIZE",
+            label: "Use safe defaults, then review exceptions",
+            hint: "Best for larger tables",
+            value: "preset",
           },
           {
-            label: "Derive a safe value",
-            value: "DERIVE",
-          },
-          { label: "Exclude this field", value: "EXCLUDE" },
-          {
-            label: "Keep exactly",
-            hint: "Only for values explicitly safe to retain",
-            value: "KEEP EXACTLY",
+            label: "Review every column individually",
+            value: "individual",
           },
         ],
       });
-      if (!action) throw new Error("Policy review was cancelled.");
-      const generated = await promptForSelection({
-        message: `${label}: is this column always database-generated?`,
+      if (!mode) throw new Error("Policy review was cancelled.");
+      if (mode === "individual") {
+        tableSummaries.push({
+          table,
+          defaulted: 0,
+          individual: columns.length,
+        });
+        return {};
+      }
+      const suggested = suggestPolicyExceptionColumns(columns);
+      const exceptions = await promptForMultipleChoice({
+        message: `${table}: select columns that need individual review`,
         flags,
-        options: [
-          { label: "No", value: "NEVER" },
-          { label: "Yes", value: "ALWAYS" },
-        ],
+        options: columns.map((column) => ({ label: column, value: column })),
+        initialValues: suggested,
       });
-      if (!generated) throw new Error("Policy review was cancelled.");
-      const identity = await promptForSelection({
-        message: `${label}: is this an identity column?`,
-        flags,
-        options: [
-          { label: "No", value: "NO" },
-          { label: "Yes", value: "YES" },
-        ],
+      if (!exceptions) throw new Error("Policy review was cancelled.");
+      const tableDecisions = createSafeTablePreset(columns);
+      for (const column of exceptions) delete tableDecisions[column];
+      tableSummaries.push({
+        table,
+        defaulted: columns.length - exceptions.length,
+        individual: exceptions.length,
       });
-      if (!identity) throw new Error("Policy review was cancelled.");
-      const hasForeignKey = await promptForConfirmation(
-        `${label}: does this column reference another table?`,
-        flags,
-        { cancelValue: null },
-      );
-      if (hasForeignKey === null) {
-        throw new Error("Policy review was cancelled.");
-      }
-      let foreignKey = null;
-      if (hasForeignKey) {
-        const schema = await promptForPath({
-          message: `${label}: referenced schema`,
-          defaultValue: "public",
-          flags,
-          validate: (value) =>
-            /^[a-z][a-z0-9_]{0,62}$/u.test(value)
-              ? undefined
-              : "Use a lowercase PostgreSQL identifier.",
-        });
-        const referencedTable = await promptForPath({
-          message: `${label}: referenced table`,
-          flags,
-          validate: (value) =>
-            /^[a-z][a-z0-9_]{0,62}$/u.test(value)
-              ? undefined
-              : "Use a lowercase PostgreSQL identifier.",
-        });
-        const referencedColumn = await promptForPath({
-          message: `${label}: referenced column`,
-          flags,
-          validate: (value) =>
-            /^[a-z][a-z0-9_]{0,62}$/u.test(value)
-              ? undefined
-              : "Use a lowercase PostgreSQL identifier.",
-        });
-        if (!schema || !referencedTable || !referencedColumn) {
-          throw new Error("Policy review was cancelled.");
-        }
-        foreignKey = {
-          schema,
-          table: referencedTable,
-          column: referencedColumn,
-        };
+      if (useStyledPrompts(flags)) {
+        prompts.log.info(
+          `${table}: ${formatCount(columns.length - exceptions.length, "safe default")}; ${formatCount(exceptions.length, "exception")}.`,
+        );
       }
-      return { action, generated, identity, foreignKey };
+      return tableDecisions;
     },
   });
+  const defaultedColumns = totalColumns - individuallyReviewed;
+  const summaryLines = tableSummaries.map(
+    (summary) =>
+      `${summary.table}: ${formatCount(summary.defaulted, "safe default")}; ${formatCount(summary.individual, "individual review")}`,
+  );
+  if (useStyledPrompts(flags)) {
+    prompts.note(summaryLines.join("\n"), "Review summary");
+  } else {
+    console.log(["", "Review summary", ...summaryLines, ""].join("\n"));
+  }
   const accepted = await promptForConfirmation(
-    `Save ${formatCount(totalColumns, "reviewed column")} and activate this policy?`,
+    `Save ${formatCount(totalColumns, "classified column")} and activate this policy?`,
     flags,
   );
   if (!accepted) return false;
@@ -585,14 +769,11 @@ const reviewPolicyInteractively = async ({ state, flags }) => {
     originalSource: source,
     policy,
   });
+  const result = `${formatCount(totalColumns, "column")} classified (${formatCount(defaultedColumns, "safe default")}; ${formatCount(individuallyReviewed, "individual review")}).`;
   if (useStyledPrompts(flags)) {
-    prompts.log.success(
-      `${formatCount(totalColumns, "column")} reviewed; the policy is ready for baseline creation.`,
-    );
+    prompts.log.success(`${result} The policy is ready for baseline creation.`);
   } else {
-    console.log(
-      `Reviewed policy saved: ${formatCount(totalColumns, "column")} classified.`,
-    );
+    console.log(`Reviewed policy saved: ${result}`);
   }
   return true;
 };
@@ -632,7 +813,7 @@ const runGuidedHome = async ({ flags, planOptions }) => {
     } else if (state.policy === "needs-review") {
       options.push({
         label: "Review the script",
-        hint: "Classify every column interactively",
+        hint: "Apply table presets and review exceptions",
         command: "policy-review",
       });
     } else {
@@ -660,14 +841,27 @@ const runGuidedHome = async ({ flags, planOptions }) => {
     });
   }
   options.push(
+    {
+      label: "Get help",
+      hint: "Create a safe, copy-ready support report",
+      command: "support",
+    },
     { label: "Show all commands", command: "help" },
     { label: "Exit", command: "exit" },
   );
 
   const statusLines = [
     `${marker(state.node.supported)} Node.js ${state.node.version}${state.node.supported ? "" : " (Node.js 24 required)"}`,
-    `${marker(state.detected.hasSupabaseConfig)} Supabase project detected`,
-    `${marker(state.detected.hasMigrations)} Migration history detected`,
+    `${marker(
+      state.target === "supabase"
+        ? state.detected.hasSupabaseConfig
+        : state.detected.hasPostgresqlMigrations,
+    )} ${state.target === "supabase" ? "Supabase" : "PostgreSQL"} project detected`,
+    `${marker(
+      state.target === "supabase"
+        ? state.detected.hasMigrations
+        : state.detected.hasPostgresqlMigrations,
+    )} Migration history detected`,
     `${marker(state.config === "valid")} Rehearsal configuration${state.config === "invalid" ? " needs attention" : ""}`,
     ...(state.config === "valid"
       ? [
@@ -719,6 +913,7 @@ const runGuidedHome = async ({ flags, planOptions }) => {
     message: "What would you like to do?",
     options,
     flags,
+    optionsAlreadyShown: !useStyledPrompts(flags),
   });
   if (selected.command === "exit") {
     return null;
@@ -793,63 +988,129 @@ const runGuidedHome = async ({ flags, planOptions }) => {
         "",
         terminalStyle(flags, "1", "CREATE A SAFE BASELINE"),
         "Rehearsal only reads the local files you name here.",
-        "It does not extract data or contact a hosted Supabase project.",
+        "It does not extract data or contact a hosted database.",
         "",
       ].join("\n"),
     );
-    const recordsDefault = await firstExistingPath([
-      "rehearsal/sanitized-data.ndjson",
-      "rehearsal/synthetic-data.ndjson",
-    ]);
-    const ledgerDefault = await firstExistingPath([
-      "rehearsal/migration-ledger.json",
-    ]);
-    flags.recordsPath = await promptForPath({
+    const discovered = await discoverBaselineInputFiles({ projectRoot });
+    const detectedLines = [
+      discovered.records.length
+        ? `Records: ${discovered.records.join(", ")}`
+        : "Records: none detected",
+      discovered.ledgers.length
+        ? `Migration ledgers: ${discovered.ledgers.join(", ")}`
+        : "Migration ledgers: none detected",
+      ...(state.target === "supabase"
+        ? [
+            discovered.assetManifests.length
+              ? `Storage manifests: ${discovered.assetManifests.join(", ")}`
+              : "Storage manifests: none detected",
+          ]
+        : []),
+      "Only paths and file structure were inspected; row values stay hidden.",
+    ];
+    if (useStyledPrompts(flags)) {
+      prompts.note(detectedLines.join("\n"), "Detected safe local inputs");
+    } else {
+      console.log(
+        ["Detected safe local inputs", ...detectedLines, ""].join("\n"),
+      );
+    }
+    flags.recordsPath = await promptForDiscoveredPath({
       message: "Sanitized NDJSON records",
-      defaultValue: recordsDefault,
+      candidates: discovered.records,
       flags,
     });
-    flags.ledgerPath = await promptForPath({
+    flags.ledgerPath = await promptForDiscoveredPath({
       message: "Migration ledger",
-      defaultValue: ledgerDefault,
+      candidates: discovered.ledgers,
       flags,
     });
-    if (selected.command === "baseline-prepare") {
-      const preparationPlan = await planBaselinePreparation({
+    try {
+      if (selected.command === "baseline-prepare") {
+        const preparationPlan = await planBaselinePreparation({
+          ...planOptions,
+          recordsPath: flags.recordsPath,
+          ledgerPath: flags.ledgerPath,
+        });
+        const preview = {
+          ...summarizeBaselinePreparation(preparationPlan, {
+            mode: "preview",
+          }),
+          nextAction:
+            "Review this schema-only summary. No file is written unless you approve below.",
+        };
+        console.log(`\n${renderBaselinePreparation(preview, flags)}\n`);
+        const accepted = await promptForConfirmation(
+          `Create the REVIEW REQUIRED draft at ${preview.destination}?`,
+          flags,
+        );
+        if (!accepted) {
+          console.log("No changes made.");
+          return "refresh";
+        }
+        flags.preparationPlan = preparationPlan;
+        flags.write = true;
+        return "baseline prepare";
+      }
+      flags.assetsPath =
+        state.target === "supabase"
+          ? await promptForDiscoveredPath({
+              message: "Storage assets",
+              candidates: discovered.assetManifests,
+              optional: true,
+              flags,
+            })
+          : undefined;
+      const inspection = await inspectBaselineInputFiles({
         ...planOptions,
         recordsPath: flags.recordsPath,
         ledgerPath: flags.ledgerPath,
+        assetsPath: flags.assetsPath,
       });
-      const preview = {
-        ...summarizeBaselinePreparation(preparationPlan, {
-          mode: "preview",
-        }),
-        nextAction:
-          "Review this schema-only summary. No file is written unless you approve below.",
-      };
-      console.log(`\n${renderBaselinePreparation(preview, flags)}\n`);
+      console.log(`\n${renderBaselineInputInspection(inspection, flags)}\n`);
       const accepted = await promptForConfirmation(
-        `Create the REVIEW REQUIRED draft at ${preview.destination}?`,
+        "Create and activate this immutable local baseline?",
         flags,
       );
       if (!accepted) {
         console.log("No changes made.");
         return "refresh";
       }
-      flags.preparationPlan = preparationPlan;
-      flags.write = true;
-      return "baseline prepare";
+      return "baseline create";
+    } catch (error) {
+      const message = redactDiagnosticValue(String(error?.message ?? error));
+      if (useStyledPrompts(flags)) {
+        prompts.cancel("These baseline inputs need attention.");
+        prompts.note(message, "How to continue");
+      } else {
+        console.log(`\nBASELINE INPUTS NEED ATTENTION\n${message}\n`);
+      }
+      return "refresh";
     }
-    flags.assetsPath = await promptForPath({
-      message: "Storage asset manifest (optional)",
-      optional: true,
-      flags,
-    });
-    return "baseline create";
   }
   if (selected.command !== "setup-write") return selected.command;
 
-  const setupPlan = await planRehearsalSetup({ projectRoot });
+  const targetChoice = await promptForChoice({
+    message: "Which database should Rehearsal use?",
+    flags,
+    options:
+      state.target === "supabase"
+        ? [
+            { label: "Supabase", command: "supabase" },
+            { label: "PostgreSQL", command: "postgresql" },
+          ]
+        : [
+            { label: "PostgreSQL", command: "postgresql" },
+            { label: "Supabase", command: "supabase" },
+          ],
+  });
+  if (!targetChoice) return "refresh";
+  flags.target = targetChoice.command;
+  const setupPlan = await planRehearsalSetup({
+    projectRoot,
+    target: flags.target,
+  });
   const preview = {
     ...summarizeRehearsalSetup(setupPlan, { mode: "preview" }),
     nextAction:
@@ -1012,6 +1273,14 @@ const runManager = ({ action, flags }) => {
     const inferred = normalizeRehearsalError(
       new Error(completeOutput || `Rehearsal ${action} failed.`),
     );
+    const category =
+      action === "migrate" ||
+      (action === "run" &&
+        /migrateRuntime|candidate migration|migration up/iu.test(
+          completeOutput,
+        ))
+        ? "migration_candidate_failure"
+        : inferred.category;
     const conciseOutput = completeOutput
       .replaceAll(String.fromCodePoint(27), "")
       .split("\n")
@@ -1021,7 +1290,7 @@ const runManager = ({ action, flags }) => {
       .join("\n")
       .slice(-2_000);
     throw new RehearsalError({
-      category: inferred.category,
+      category,
       code: `MANAGER_${action.toUpperCase()}_FAILED`,
       message: `The local Rehearsal ${action} operation did not complete.`,
       expected: "the isolated runtime operation to finish and verify",
@@ -1179,7 +1448,12 @@ const renderInit = (result) =>
   ].join("\n");
 
 const runSetup = async ({ flags, planOptions }) => {
-  const plan = flags.setupPlan ?? (await planRehearsalSetup({ projectRoot }));
+  const plan =
+    flags.setupPlan ??
+    (await planRehearsalSetup({
+      projectRoot,
+      target: flags.target ?? "supabase",
+    }));
   if (flags.write) await applyRehearsalSetup(plan);
   const result = summarizeRehearsalSetup(plan, {
     mode: flags.write ? "written" : "preview",
@@ -1251,9 +1525,12 @@ const renderSetup = (result) => {
   return [
     `REHEARSAL SETUP — ${result.mode.toUpperCase()}`,
     `Project: ${result.project}`,
+    `Database: ${result.target === "postgresql" ? "PostgreSQL" : "Supabase"}`,
     `Runtime ID: ${result.projectId}`,
     `Application: ${result.applicationUrl}`,
-    `Ports: API ${result.ports.api}, database ${result.ports.database}, Studio ${result.ports.studio}`,
+    result.target === "postgresql"
+      ? `Port: database ${result.ports.database}`
+      : `Ports: API ${result.ports.api}, database ${result.ports.database}, Studio ${result.ports.studio}`,
     "",
     "Files",
     ...result.files.map(
@@ -1314,15 +1591,66 @@ const renderBaselinePreparation = (result, flags = {}) =>
     result.nextAction,
   ].join("\n");
 
+const renderBaselineInputInspection = (result, flags = {}) =>
+  [
+    "BASELINE INPUTS — READY",
+    `Records: ${formatCount(result.rowCount, "row")} across ${formatCount(result.tables.length, "table")} from ${result.recordsPath}`,
+    `Migrations: ${formatCount(result.migrationCount, "migration")} through ${result.migrationCutoff} from ${result.ledgerPath}`,
+    result.assetsPath
+      ? `Storage: ${formatCount(result.assetCount, "asset")} from ${result.assetsPath}`
+      : "Storage: no asset manifest selected",
+    "",
+    "Detected tables (values are never printed)",
+    ...result.tables.map(
+      (table) =>
+        `  ${terminalStyle(flags, "36", "→")} ${table.name}: ${formatCount(table.rowCount, "row")}`,
+    ),
+    "",
+    "All inputs are project-local regular files and passed structural validation.",
+  ].join("\n");
+
+const renderSupportReport = (report) => {
+  const toolLine = (label, tool) =>
+    `${label}: ${tool.status === "available" ? tool.version : tool.status.replaceAll("_", " ")}`;
+  return [
+    "REHEARSAL SUPPORT REPORT",
+    "",
+    `Rehearsal: ${report.rehearsalVersion}`,
+    `System: ${report.system.platform} ${report.system.architecture} (${report.system.release})`,
+    `Node.js: ${report.system.node}`,
+    toolLine("npm", report.tools.npm),
+    toolLine("Supabase CLI", report.tools.supabase),
+    toolLine("Docker client", report.tools.dockerClient),
+    toolLine("Docker server", report.tools.dockerServer),
+    "",
+    `Readiness: ${report.readiness.state}`,
+    ...report.readiness.checks.map((check) =>
+      check.status === "pass"
+        ? `  ✓ ${check.label}`
+        : `  ✗ ${check.label}${check.remediation ? ` — ${check.remediation}` : ""}`,
+    ),
+    ...(report.readiness.quarantinedHostedVariableCount
+      ? [
+          `  ! ${formatCount(report.readiness.quarantinedHostedVariableCount, "ambient hosted variable")} detected and quarantined`,
+        ]
+      : []),
+    "",
+    "Privacy: no row values, credentials, project paths, migration SQL, or baseline identifiers are included.",
+    "Review this report before sharing it.",
+    `Report a reproducible issue: ${report.supportUrl}`,
+  ].join("\n");
+};
+
 const usage = () => `Usage: rehearsal <command> [options]
 
 Commands:
   guide                       Open the interactive, state-aware home screen
-  setup [--write]             Preview or create safe first-run scaffolding
+  setup [--target=] [--write] Preview or create safe first-run scaffolding
   init [--write]              Preview or explicitly write safe starter config
   baseline prepare --records= --ledger= [--write] Create a fail-closed policy draft
   baseline create --records= --ledger= [--assets=] Create a baseline from safe local inputs
   doctor                     Check whether Rehearsal is safe and ready
+  support                    Print a safe, copy-ready support report
   explain                    Show the immutable execution plan
   run --dry-run              Alias the exact explain plan without mutations
   run --confirm-candidates=  Execute reset, migration, and verification locally
@@ -1337,7 +1665,7 @@ Commands:
   discard                    Remove only this project's disposable runtime
   verify                     Verify the current local Rehearsal runtime
 
-Options: --json --verbose --debug --plain --config=<path>`;
+Options: --json --verbose --debug --plain --config=<path> --target=supabase|postgresql`;
 
 const executeCommand = async ({ command, flags, planOptions, guided }) => {
   if (command === "help" || flags.help) {
@@ -1365,6 +1693,12 @@ const executeCommand = async ({ command, flags, planOptions, guided }) => {
     return;
   }
   if (command === "baseline create") {
+    await inspectBaselineInputFiles({
+      ...planOptions,
+      recordsPath: flags.recordsPath,
+      ledgerPath: flags.ledgerPath,
+      assetsPath: flags.assetsPath,
+    });
     const data = await createSyntheticBaselineFromFiles({
       ...planOptions,
       recordsPath: flags.recordsPath,
@@ -1398,6 +1732,11 @@ const executeCommand = async ({ command, flags, planOptions, guided }) => {
     if (data.state !== "READY" && !guided) process.exitCode = 1;
     return;
   }
+  if (command === "support") {
+    const data = await collectRehearsalSupportReport(planOptions);
+    emit({ command, data, flags, render: renderSupportReport });
+    return;
+  }
   if (command === "explain" || (command === "run" && flags.dryRun)) {
     const data = await buildRehearsalPlan(planOptions);
     emit({ command, data, flags, render: renderPlan });
@@ -1532,10 +1871,39 @@ const resetGuidedFlags = (flags) => {
   flags.recordsPath = undefined;
   flags.ledgerPath = undefined;
   flags.assetsPath = undefined;
+  flags.target = undefined;
   flags.setupPlan = undefined;
   flags.preparationPlan = undefined;
 };
 
+const installGuidedExitShortcut = (flags) => {
+  let exiting = false;
+  const exit = () => {
+    if (exiting) return;
+    exiting = true;
+    if (process.stdin.isTTY && process.stdin.isRaw) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdout.write("\u001B[?25h");
+    if (useStyledPrompts(flags)) {
+      prompts.outro("Rehearsal exited.");
+    } else {
+      console.log("\nRehearsal exited.");
+    }
+    process.exit(0);
+  };
+  const onInput = (chunk) => {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    if (bytes.includes(0x1a)) exit();
+  };
+  process.stdin.prependListener("data", onInput);
+  process.prependListener("SIGTSTP", exit);
+  return () => {
+    process.stdin.removeListener("data", onInput);
+    process.removeListener("SIGTSTP", exit);
+  };
+};
+
 const main = async () => {
   const { flags, positionals } = parseArguments(process.argv.slice(2));
   const command = positionals.join(" ") || "help";
@@ -1560,20 +1928,25 @@ const main = async () => {
     );
   }
   flags.guided = true;
+  const removeGuidedExitShortcut = installGuidedExitShortcut(flags);
   if (useStyledPrompts(flags)) {
     prompts.intro("REHEARSAL · Safe local migration testing");
   }
-  while (true) {
-    resetGuidedFlags(flags);
-    const selected = await runGuidedHome({ flags, planOptions });
-    if (!selected) break;
-    if (selected === "refresh") continue;
-    await executeCommand({
-      command: selected,
-      flags,
-      planOptions,
-      guided: true,
-    });
+  try {
+    while (true) {
+      resetGuidedFlags(flags);
+      const selected = await runGuidedHome({ flags, planOptions });
+      if (!selected) break;
+      if (selected === "refresh") continue;
+      await executeCommand({
+        command: selected,
+        flags,
+        planOptions,
+        guided: true,
+      });
+    }
+  } finally {
+    removeGuidedExitShortcut();
   }
   if (useStyledPrompts(flags)) {
     prompts.outro("See you at the next rehearsal.");