@rehearsal-db/core 0.1.0-beta.3 → 0.1.0-beta.5

package/scripts/operations/rehearsal/rehearsal_cli.mjs

@@ -11,6 +11,7 @@ import { join, relative } from "node:path";
 import { performance } from "node:perf_hooks";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
+import * as prompts from "@clack/prompts";
 import {
   RehearsalError,
   createRehearsalResult,
@@ -35,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,
@@ -45,6 +48,14 @@ import {
   summarizeRehearsalSetup,
 } from "../../lib/rehearsal/setup.mjs";
 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();
@@ -54,6 +65,7 @@ const managerPath = join(
   packageRoot,
   "scripts/operations/database/manage_rehearsal_database.mjs",
 );
+let lastGuidedDetails;
 
 const parseArguments = (arguments_) => {
   const flags = {
@@ -255,12 +267,28 @@ const terminalStyle = (flags, code, value) =>
 const isHumanTerminal = (flags) =>
   !flags.json && process.stdin.isTTY && process.stdout.isTTY;
 
+const useStyledPrompts = (flags) => isHumanTerminal(flags) && useColor(flags);
+
 const formatDuration = (durationMs) =>
   durationMs < 1_000
     ? `${Math.round(durationMs)}ms`
     : `${(durationMs / 1_000).toFixed(1)}s`;
 
-const promptForChoice = async ({ message, options }) => {
+const promptForChoice = async ({ message, options, flags = {} }) => {
+  if (useStyledPrompts(flags)) {
+    const selected = await prompts.select({
+      message,
+      maxItems: options.length,
+      options: options.map((option) => ({
+        value: option,
+        label: option.label,
+        hint: option.hint,
+      })),
+    });
+    return prompts.isCancel(selected)
+      ? options.find((option) => option.command === "exit")
+      : selected;
+  }
   const prompt = createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -283,7 +311,15 @@ const promptForChoice = async ({ message, options }) => {
   }
 };
 
-const promptForConfirmation = async (message) => {
+const promptForConfirmation = async (
+  message,
+  flags = {},
+  { cancelValue = false } = {},
+) => {
+  if (useStyledPrompts(flags)) {
+    const accepted = await prompts.confirm({ message, initialValue: false });
+    return prompts.isCancel(accepted) ? cancelValue : accepted;
+  }
   const prompt = createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -298,7 +334,27 @@ const promptForConfirmation = async (message) => {
   }
 };
 
-const promptForPath = async ({ message, defaultValue, optional = false }) => {
+const promptForPath = async ({
+  message,
+  defaultValue,
+  optional = false,
+  flags = {},
+  validate,
+}) => {
+  if (useStyledPrompts(flags)) {
+    const answer = await prompts.text({
+      message,
+      placeholder: defaultValue ?? (optional ? "Leave blank for none" : ""),
+      defaultValue,
+      validate: (value) => {
+        const resolved = String(value || defaultValue || "").trim();
+        if (!optional && !resolved) return "Enter a value.";
+        return resolved && validate ? validate(resolved) : undefined;
+      },
+    });
+    if (prompts.isCancel(answer)) return undefined;
+    return String(answer || defaultValue || "").trim() || undefined;
+  }
   const prompt = createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -312,6 +368,11 @@ const promptForPath = async ({ message, defaultValue, optional = false }) => {
           : " (required)";
       const answer = (await prompt.question(`${message}${suffix}: `)).trim();
       const value = answer || defaultValue || "";
+      const invalid = value && validate ? validate(value) : undefined;
+      if (invalid) {
+        console.log(invalid);
+        continue;
+      }
       if (value || optional) return value || undefined;
       console.log("Enter a project-relative path.");
     }
@@ -320,11 +381,107 @@ const promptForPath = async ({ message, defaultValue, optional = false }) => {
   }
 };
 
-const firstExistingPath = async (candidates) => {
-  for (const candidate of candidates) {
-    if (await pathExists(join(projectRoot, candidate))) return candidate;
+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 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) => {
@@ -391,6 +548,7 @@ const inspectGuidedProject = async (planOptions) => {
     baseline: Boolean(migrationSummary),
     policy,
     policyPath: relative(projectRoot, loaded.paths.sanitizationPolicy),
+    policyAbsolutePath: loaded.paths.sanitizationPolicy,
     migrationSummary,
     runtime: await pathExists(
       join(loaded.paths.runtimeWorkdir, "baseline.json"),
@@ -398,6 +556,205 @@ const inspectGuidedProject = async (planOptions) => {
   };
 };
 
+const reviewPolicyInteractively = async ({ state, flags }) => {
+  const { source, draft } = await readReviewablePolicyDraft(
+    state.policyAbsolutePath,
+  );
+  const totalColumns = draft.tables.reduce(
+    (total, table) => total + (table.columns?.length ?? 0),
+    0,
+  );
+  const tableSummaries = [];
+  let individuallyReviewed = 0;
+  if (useStyledPrompts(flags)) {
+    prompts.note(
+      [
+        `${formatCount(totalColumns, "column")} across ${formatCount(draft.tables.length, "table")} require explicit review.`,
+        "No row values are displayed or changed by this step.",
+        "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,
+    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: "Use safe defaults, then review exceptions",
+            hint: "Best for larger tables",
+            value: "preset",
+          },
+          {
+            label: "Review every column individually",
+            value: "individual",
+          },
+        ],
+      });
+      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: columns.map((column) => ({ label: column, value: column })),
+        initialValues: suggested,
+      });
+      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 (useStyledPrompts(flags)) {
+        prompts.log.info(
+          `${table}: ${formatCount(columns.length - exceptions.length, "safe default")}; ${formatCount(exceptions.length, "exception")}.`,
+        );
+      }
+      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, "classified column")} and activate this policy?`,
+    flags,
+  );
+  if (!accepted) return false;
+  await applyReviewedPolicy({
+    path: state.policyAbsolutePath,
+    originalSource: source,
+    policy,
+  });
+  const result = `${formatCount(totalColumns, "column")} classified (${formatCount(defaultedColumns, "safe default")}; ${formatCount(individuallyReviewed, "individual review")}).`;
+  if (useStyledPrompts(flags)) {
+    prompts.log.success(`${result} The policy is ready for baseline creation.`);
+  } else {
+    console.log(`Reviewed policy saved: ${result}`);
+  }
+  return true;
+};
+
 const runGuidedHome = async ({ flags, planOptions }) => {
   const state = await inspectGuidedProject(planOptions);
   const marker = (complete) =>
@@ -407,89 +764,126 @@ const runGuidedHome = async ({ flags, planOptions }) => {
   if (!state.node.supported) {
     options.push({
       label: "Show Node.js 24 setup instructions",
+      hint: "Required before Rehearsal can change this project",
       command: "node-help",
     });
   } else if (state.config === "missing") {
     options.push({
-      label: "Set up Rehearsal",
+      label: "Set the stage",
+      hint: "Create safe local configuration",
       command: "setup-write",
     });
-  } else {
-    options.push({ label: "Check readiness", command: "doctor" });
-  }
-  if (state.node.supported && state.baseline) {
+  } else if (state.baseline) {
     options.push(
-      { label: "Review the migration plan", command: "explain" },
       { label: "Run a rehearsal", command: "run" },
+      { label: "Review the migration plan", command: "explain" },
       { label: "Show candidate migrations", command: "candidates" },
+      { label: "Check readiness", command: "doctor" },
     );
   } else if (state.node.supported && state.config === "valid") {
     if (state.policy === "missing") {
       options.push({
-        label: "Prepare a reviewable baseline policy draft",
+        label: "Prepare the script",
+        hint: "Create a reviewable policy draft",
         command: "baseline-prepare",
       });
     } else if (state.policy === "needs-review") {
       options.push({
-        label: "Review the baseline policy draft",
+        label: "Review the script",
+        hint: "Apply table presets and review exceptions",
         command: "policy-review",
       });
     } else {
       options.push({
-        label: "Create a baseline from safe local files",
+        label: "Create the baseline",
+        hint: "Activate reviewed local inputs",
         command: "baseline-guide",
       });
     }
+    options.push({ label: "Check readiness", command: "doctor" });
+  } else {
+    options.push({ label: "Check readiness", command: "doctor" });
   }
   if (state.node.supported && state.runtime) {
-    options.push(
-      { label: "Show local runtime status", command: "status" },
-      { label: "Verify the local runtime", command: "verify" },
-      { label: "Reset to the baseline", command: "reset" },
-      { label: "Stop the local runtime", command: "stop" },
-      { label: "Discard the local runtime", command: "discard" },
-    );
+    options.push({
+      label: "Manage the local runtime",
+      hint: "Status, verification, and cleanup",
+      command: "manage-runtime",
+    });
+  }
+  if (lastGuidedDetails) {
+    options.push({
+      label: "Show details from the last action",
+      command: "last-details",
+    });
   }
   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" },
   );
 
-  console.log(
-    [
-      "",
-      terminalStyle(flags, "1;36", "REHEARSAL"),
-      "Safe local migration testing",
-      "",
-      terminalStyle(flags, "1", state.detected.projectName),
-      `${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.config === "valid")} Rehearsal configuration${state.config === "invalid" ? " needs attention" : ""}`,
-      ...(state.config === "valid"
-        ? [
-            `${marker(state.policy === "reviewed")} ${state.policy === "needs-review" ? "Baseline policy needs review" : state.policy === "reviewed" ? "Baseline policy reviewed" : "Baseline policy needed"}`,
-          ]
-        : []),
-      `${marker(state.baseline)} Verified baseline`,
-      ...(state.runtime ? [`${marker(true)} Disposable runtime created`] : []),
-      ...(state.configError
-        ? ["", terminalStyle(flags, "33", `! ${state.configError}`)]
-        : []),
-      "",
-      "What would you like to do?",
-      "",
-      ...options.map(
-        (option, index) =>
-          `  ${index === 0 ? terminalStyle(flags, "36", "›") : " "} ${index + 1}. ${option.label}`,
-      ),
-      "",
-    ].join("\n"),
-  );
+  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.config === "valid")} Rehearsal configuration${state.config === "invalid" ? " needs attention" : ""}`,
+    ...(state.config === "valid"
+      ? [
+          `${marker(state.policy === "reviewed")} ${state.policy === "needs-review" ? "Baseline policy needs review" : state.policy === "reviewed" ? "Baseline policy reviewed" : "Baseline policy needed"}`,
+        ]
+      : []),
+    `${marker(state.baseline)} Verified baseline`,
+    ...(state.runtime ? [`${marker(true)} Disposable runtime created`] : []),
+    ...(state.configError
+      ? ["", terminalStyle(flags, "33", `! ${state.configError}`)]
+      : []),
+  ];
+  const stage =
+    state.config !== "valid"
+      ? 1
+      : state.policy !== "reviewed"
+        ? 2
+        : !state.baseline
+          ? 3
+          : 4;
+  if (useStyledPrompts(flags)) {
+    prompts.note(
+      statusLines.join("\n"),
+      `${state.detected.projectName} · Stage ${stage} of 4`,
+    );
+  } else {
+    console.log(
+      [
+        "",
+        terminalStyle(flags, "1;36", "REHEARSAL"),
+        "Safe local migration testing",
+        "",
+        terminalStyle(flags, "1", state.detected.projectName),
+        `Stage ${stage} of 4`,
+        ...statusLines,
+        "",
+        "What would you like to do?",
+        "",
+        ...options.map(
+          (option, index) =>
+            `  ${index === 0 ? terminalStyle(flags, "36", "›") : " "} ${index + 1}. ${option.label}`,
+        ),
+        "",
+      ].join("\n"),
+    );
+  }
 
-  const selected = await promptForChoice({ message: "Choose", options });
+  const selected = await promptForChoice({
+    message: "What would you like to do?",
+    options,
+    flags,
+  });
   if (selected.command === "exit") {
-    console.log("No changes made.");
     return null;
   }
   if (selected.command === "node-help") {
@@ -506,20 +900,55 @@ const runGuidedHome = async ({ flags, planOptions }) => {
         "Then reinstall Rehearsal in your scratch project and run npx rehearsal again.",
       ].join("\n"),
     );
-    return null;
+    return "refresh";
   }
   if (selected.command === "policy-review") {
-    console.log(
-      [
-        "",
-        terminalStyle(flags, "1", "REVIEW THE BASELINE POLICY"),
-        `Open ${state.policyPath} and complete every REVIEW REQUIRED decision.`,
-        "For each column, classify its sanitization action, generated status, identity behavior, and foreign key.",
-        'Remove "draft": true only after every decision has been reviewed.',
-        "Then run rehearsal again to continue.",
-      ].join("\n"),
-    );
-    return null;
+    try {
+      await reviewPolicyInteractively({ state, flags });
+    } catch (error) {
+      if (String(error?.message ?? error) !== "Policy review was cancelled.") {
+        throw error;
+      }
+      if (useStyledPrompts(flags)) {
+        prompts.cancel("Policy review cancelled; the draft was not changed.");
+      } else {
+        console.log("Policy review cancelled; the draft was not changed.");
+      }
+    }
+    return "refresh";
+  }
+  if (selected.command === "last-details") {
+    if (useStyledPrompts(flags)) {
+      prompts.note(lastGuidedDetails, "Technical details");
+    } else {
+      console.log(`\nTECHNICAL DETAILS\n${lastGuidedDetails}`);
+    }
+    return "refresh";
+  }
+  if (selected.command === "manage-runtime") {
+    const runtimeAction = await promptForChoice({
+      message: "Manage the disposable local runtime",
+      flags,
+      options: [
+        { label: "Show status", command: "status" },
+        { label: "Verify runtime", command: "verify" },
+        { label: "Reset to the immutable baseline", command: "reset" },
+        { label: "Stop runtime", command: "stop" },
+        { label: "Discard runtime", command: "discard" },
+        { label: "Back", command: "exit" },
+      ],
+    });
+    if (!runtimeAction || runtimeAction.command === "exit") return "refresh";
+    if (["reset", "discard"].includes(runtimeAction.command)) {
+      const accepted = await promptForConfirmation(
+        runtimeAction.command === "reset"
+          ? "Reset the disposable runtime and remove its current changes?"
+          : "Discard the disposable runtime? The immutable baseline will remain.",
+        flags,
+      );
+      if (!accepted) return "refresh";
+    }
+    return runtimeAction.command;
   }
   if (["baseline-guide", "baseline-prepare"].includes(selected.command)) {
     console.log(
@@ -531,51 +960,95 @@ const runGuidedHome = async ({ flags, planOptions }) => {
         "",
       ].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",
+      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 = await promptForDiscoveredPath({
+        message: "Storage assets",
+        candidates: discovered.assetManifests,
+        optional: true,
+        flags,
+      });
+      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 null;
+        return "refresh";
+      }
+      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`);
       }
-      flags.preparationPlan = preparationPlan;
-      flags.write = true;
-      return "baseline prepare";
+      return "refresh";
     }
-    flags.assetsPath = await promptForPath({
-      message: "Storage asset manifest (optional)",
-      optional: true,
-    });
-    return "baseline create";
   }
   if (selected.command !== "setup-write") return selected.command;
 
@@ -588,10 +1061,11 @@ const runGuidedHome = async ({ flags, planOptions }) => {
   console.log(`\n${renderSetup(preview)}\n`);
   const accepted = await promptForConfirmation(
     "Create these project-local files?",
+    flags,
   );
   if (!accepted) {
     console.log("No changes made.");
-    return null;
+    return "refresh";
   }
   flags.setupPlan = setupPlan;
   flags.write = true;
@@ -652,6 +1126,7 @@ const prepareCandidateConfirmation = async ({
   );
   const accepted = await promptForConfirmation(
     `Apply exactly ${summary.candidateCount === 1 ? "this migration" : "these migrations"}?`,
+    flags,
   );
   if (!accepted) {
     console.log("No changes made.");
@@ -709,7 +1184,10 @@ const runManager = ({ action, flags }) => {
     discard: "Removing the disposable local runtime",
     verify: "Verifying the current local runtime",
   }[action];
-  if (isHumanTerminal(flags)) {
+  const spinner = useStyledPrompts(flags) ? prompts.spinner() : null;
+  if (spinner) {
+    spinner.start(`${actionDescription}. This can take a moment.`);
+  } else if (isHumanTerminal(flags)) {
     console.log(
       `\n${terminalStyle(flags, "1;36", action === "run" ? "REHEARSING" : "REHEARSAL")}\n${terminalStyle(flags, "36", "→")} ${actionDescription}. This can take a moment.`,
     );
@@ -721,8 +1199,12 @@ const runManager = ({ action, flags }) => {
     stdio: ["inherit", "pipe", "pipe"],
     maxBuffer: 16 * 1024 * 1024,
   });
-  if (result.error) throw result.error;
+  if (result.error) {
+    if (spinner) spinner.stop(`${actionDescription} did not complete.`);
+    throw result.error;
+  }
   if (result.status !== 0) {
+    if (spinner) spinner.stop(`${actionDescription} did not complete.`);
     const completeOutput = [
       String(result.stdout ?? ""),
       String(result.stderr ?? ""),
@@ -757,7 +1239,11 @@ const runManager = ({ action, flags }) => {
     });
   }
   const durationMs = performance.now() - runtimeStartedMs;
-  if (isHumanTerminal(flags)) {
+  if (spinner) {
+    spinner.stop(
+      `${actionDescription} completed in ${formatDuration(durationMs)}.`,
+    );
+  } else if (isHumanTerminal(flags)) {
     console.log(
       `${terminalStyle(flags, "32", "✓")} Local runtime step completed in ${formatDuration(durationMs)}.`,
     );
@@ -913,7 +1399,9 @@ const runSetup = async ({ flags, planOptions }) => {
       readiness.state === "READY"
         ? "Next: run rehearsal explain to review the migration plan."
         : needsBaselinePolicy
-          ? "Next: run rehearsal again and choose Prepare a reviewable baseline policy draft."
+          ? flags.guided
+            ? "Next: choose Prepare the script to create a reviewable policy draft."
+            : "Next: run rehearsal again and choose Prepare a reviewable baseline policy draft."
           : "Next: complete the remaining readiness items shown above.",
   };
 };
@@ -998,9 +1486,16 @@ const runBaselinePreparation = async ({ flags, planOptions }) => {
       ledgerPath: flags.ledgerPath,
     }));
   if (flags.write) await applyBaselinePreparation(plan);
-  return summarizeBaselinePreparation(plan, {
+  const result = summarizeBaselinePreparation(plan, {
     mode: flags.write ? "written" : "preview",
   });
+  return flags.guided && flags.write
+    ? {
+        ...result,
+        nextAction:
+          "Next: choose Review the script to classify every column interactively.",
+      }
+    : result;
 };
 
 const renderBaselinePreparation = (result, flags = {}) =>
@@ -1022,6 +1517,56 @@ 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:
@@ -1031,6 +1576,7 @@ Commands:
   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
@@ -1047,29 +1593,7 @@ Commands:
 
 Options: --json --verbose --debug --plain --config=<path>`;
 
-const main = async () => {
-  const { flags, positionals } = parseArguments(process.argv.slice(2));
-  let command = positionals.join(" ") || "help";
-  const planOptions = {
-    projectRoot,
-    configPath: flags.configPath,
-  };
-  const wantsAutomaticGuide =
-    positionals.length === 0 &&
-    !flags.help &&
-    !flags.json &&
-    process.stdin.isTTY &&
-    process.stdout.isTTY;
-  if (command === "guide" || wantsAutomaticGuide) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-      throw new Error(
-        "The guided home screen requires an interactive terminal. Run rehearsal --help to list scriptable commands.",
-      );
-    }
-    const selected = await runGuidedHome({ flags, planOptions });
-    if (!selected) return;
-    command = selected;
-  }
+const executeCommand = async ({ command, flags, planOptions, guided }) => {
   if (command === "help" || flags.help) {
     console.log(usage());
     return;
@@ -1095,6 +1619,12 @@ const main = async () => {
     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,
@@ -1109,7 +1639,9 @@ const main = async () => {
         [
           `Activated synthetic baseline ${baseline.generationId}: ${formatCount(baseline.rowCount, "row")} across ${formatCount(baseline.tableCount, "table")}; ${formatCount(baseline.migrationCount, "migration")} through ${baseline.migrationCutoff}.`,
           "",
-          "Next: run rehearsal doctor to check readiness.",
+          flags.guided
+            ? "Next: choose Run a rehearsal when you are ready."
+            : "Next: run rehearsal doctor to check readiness.",
         ].join("\n"),
     });
     return;
@@ -1123,7 +1655,12 @@ const main = async () => {
       render: renderDoctor,
       status: data.state === "READY" ? "success" : "not_ready",
     });
-    if (data.state !== "READY") process.exitCode = 1;
+    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)) {
@@ -1171,19 +1708,34 @@ const main = async () => {
     const runtime = runManager({ action: command, flags });
     let applicationProof;
     if (command === "run") {
-      if (isHumanTerminal(flags)) {
+      const proofSpinner = useStyledPrompts(flags) ? prompts.spinner() : null;
+      if (proofSpinner) {
+        proofSpinner.start("Running the project-owned application proof.");
+      } else if (isHumanTerminal(flags)) {
         console.log(
           `${terminalStyle(flags, "36", "→")} Running the project-owned application proof.`,
         );
       }
-      applicationProof = await runApplicationProof(planOptions);
-      if (isHumanTerminal(flags)) {
+      try {
+        applicationProof = await runApplicationProof(planOptions);
+      } catch (error) {
+        if (proofSpinner) proofSpinner.stop("Application proof failed.");
+        throw error;
+      }
+      if (proofSpinner) {
+        proofSpinner.stop("Application proof passed.");
+      } else if (isHumanTerminal(flags)) {
         console.log(
           `${terminalStyle(flags, "32", "✓")} Application proof passed.`,
         );
       }
     }
     const data = command === "run" ? { runtime, applicationProof } : runtime;
+    if (guided) {
+      lastGuidedDetails = [runtime.output, applicationProof?.output]
+        .filter(Boolean)
+        .join("\n");
+    }
     emit({
       command,
       data,
@@ -1203,6 +1755,23 @@ const main = async () => {
           verify:
             "Next: continue testing, reset to the baseline, or stop the runtime.",
         }[runtimeResult.action];
+        if (guided) {
+          const title =
+            runtimeResult.action === "run"
+              ? "REHEARSAL PASSED"
+              : "ACTION COMPLETE";
+          return [
+            title,
+            `✓ ${runtimeResult.action} completed in ${formatDuration(runtimeResult.durationMs)}`,
+            value.applicationProof
+              ? `✓ Application proof passed: ${value.applicationProof.command}`
+              : null,
+            "",
+            "Technical output is available from Show details in the guide.",
+          ]
+            .filter(Boolean)
+            .join("\n");
+        }
         return [
           runtimeResult.output ||
             `Rehearsal ${runtimeResult.action} completed.`,
@@ -1221,6 +1790,63 @@ const main = async () => {
   throw new Error(`Unknown Rehearsal command: ${command}.\n\n${usage()}`);
 };
 
+const resetGuidedFlags = (flags) => {
+  flags.dryRun = false;
+  flags.write = false;
+  flags.confirmation = undefined;
+  flags.recordsPath = undefined;
+  flags.ledgerPath = undefined;
+  flags.assetsPath = undefined;
+  flags.setupPlan = undefined;
+  flags.preparationPlan = undefined;
+};
+
+const main = async () => {
+  const { flags, positionals } = parseArguments(process.argv.slice(2));
+  const command = positionals.join(" ") || "help";
+  const planOptions = {
+    projectRoot,
+    configPath: flags.configPath,
+  };
+  const wantsAutomaticGuide =
+    positionals.length === 0 &&
+    !flags.help &&
+    !flags.json &&
+    process.stdin.isTTY &&
+    process.stdout.isTTY;
+  const guided = command === "guide" || wantsAutomaticGuide;
+  if (!guided) {
+    await executeCommand({ command, flags, planOptions, guided: false });
+    return;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error(
+      "The guided home screen requires an interactive terminal. Run rehearsal --help to list scriptable commands.",
+    );
+  }
+  flags.guided = true;
+  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,
+    });
+  }
+  if (useStyledPrompts(flags)) {
+    prompts.outro("See you at the next rehearsal.");
+  } else {
+    console.log("See you at the next rehearsal.");
+  }
+};
+
 try {
   await main();
 } catch (error) {