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

package/CHANGELOG.md

@@ -5,6 +5,29 @@ a Changelog, and versions will follow Semantic Versioning after the package exis
 
 ## Unreleased
 
+## [0.1.0-beta.5] - 2026-10-01
+
+### Added
+
+- Scalable policy review with explicit table-level safe defaults, suggested structural
+  exceptions, per-table summaries, and real-PTY coverage of the bulk-review journey.
+- Bounded project-local discovery for baseline records, migration ledgers, and optional
+  Storage manifests, plus a value-free structural preflight before activation.
+- A guided `Get help` action and scriptable `rehearsal support` report with tool
+  versions, readiness statuses, privacy guarantees, and a direct bug-report link.
+
+### Changed
+
+- Guided policy review can classify ordinary columns in bulk as synthetic replacements
+  while keeping likely identifiers, relationships, and timestamps selected for
+  individual review. The saved policy still records every required column decision.
+- The baseline guide offers detected inputs instead of requiring memorized paths,
+  validates referenced Storage files up front, previews counts without row values, and
+  returns to the guide with an actionable message when validation fails.
+- Beta support no longer requires users to assemble environment details by hand; the
+  generated report omits project paths, row values, credentials, migration SQL, and
+  baseline identifiers and remains available before setup is complete.
+
 ## [0.1.0-beta.4] - 2026-10-01
 
 ### Added
@@ -118,7 +141,8 @@ a Changelog, and versions will follow Semantic Versioning after the package exis
   publication uses short-lived trusted OIDC, and every release tag must already exist on
   protected `main`.
 
-[Unreleased]: https://github.com/Ddupasquier/rehearsal-db/compare/v0.1.0-beta.4...HEAD
+[Unreleased]: https://github.com/Ddupasquier/rehearsal-db/compare/v0.1.0-beta.5...HEAD
+[0.1.0-beta.5]: https://github.com/Ddupasquier/rehearsal-db/compare/v0.1.0-beta.4...v0.1.0-beta.5
 [0.1.0-beta.4]: https://github.com/Ddupasquier/rehearsal-db/compare/v0.1.0-beta.3...v0.1.0-beta.4
 [0.1.0-beta.3]: https://github.com/Ddupasquier/rehearsal-db/compare/v0.1.0-beta.2...v0.1.0-beta.3
 [0.1.0-beta.2]: https://github.com/Ddupasquier/rehearsal-db/compare/v0.1.0-beta.1...v0.1.0-beta.2

package/README.md

@@ -93,6 +93,7 @@ npx rehearsal baseline prepare --records=<safe.ndjson> --ledger=<ledger.json>
 npx rehearsal baseline prepare --records=<safe.ndjson> --ledger=<ledger.json> --write
 npx rehearsal baseline create --records=<safe.ndjson> --ledger=<ledger.json>
 npx rehearsal doctor
+npx rehearsal support
 npx rehearsal explain
 npx rehearsal run --dry-run
 npx rehearsal candidates
@@ -110,8 +111,16 @@ npx rehearsal discard
 Running `npx rehearsal` in a terminal opens a state-aware guide that shows completed
 setup steps and recommends available actions. The guide stays open after each action,
 re-inspects the project, and advances to the next useful step. It includes an interactive
-column-by-column policy reviewer, concise completion receipts, and optional technical
-details. The explicit commands remain the stable interface for automation and CI.
+policy reviewer with table-level safe defaults and exception-only column review, concise
+completion receipts, optional technical details, and bounded discovery of likely local
+baseline inputs. Before activation it validates records, migration evidence, and optional
+Storage files, then shows a value-free count summary for confirmation. The explicit
+commands remain the stable interface for automation and CI.
+
+Choose **Get help** at any stage, or run `npx rehearsal support`, to create a copy-ready
+environment and readiness report for a GitHub issue. It works before setup and omits row
+values, credentials, project paths, migration SQL, and baseline identifiers. Review every
+report before sharing it.
 
 `setup` previews a conservative first-run scaffold: the Rehearsal configuration, a
 dedicated local-only Supabase configuration on an available port block, and protective

package/SUPPORT.md

@@ -6,6 +6,11 @@ Docker engine, the failing command, safe diagnostics, and the smallest reproduct
 The first beta does not yet maintain a separate public discussion or feature-request
 channel.
 
+Run `npx rehearsal support` or choose **Get help** in the guide to collect the environment
+and readiness portion without assembling it by hand. The report intentionally excludes
+project paths, row values, credentials, migration SQL, and baseline identifiers. Review
+the report before pasting it into an issue.
+
 Do not include credentials, connection strings, source rows, baseline artifacts, private
 URLs, or proprietary migrations. Report security problems through private vulnerability
 reporting as described in [SECURITY.md](SECURITY.md).

package/docs/commands.md

@@ -15,6 +15,7 @@ values or credentials.
 | `rehearsal baseline prepare --records= --ledger= --write`    | Policy only         | Write the draft without exposing row values.              |
 | `rehearsal baseline create --records=<path> --ledger=<path>` | Artifact only       | Activate a baseline from explicit safe local inputs.      |
 | `rehearsal doctor`                                           | No                  | Check dependencies, inputs, and safety barriers.          |
+| `rehearsal support`                                          | No                  | Print a privacy-safe, copy-ready support report.          |
 | `rehearsal explain`                                          | No                  | Print the immutable execution plan.                       |
 | `rehearsal run --dry-run`                                    | No                  | Alias the same plan used by `explain`.                    |
 | `rehearsal candidates`                                       | No                  | Print pending migrations and their exact digest.          |
@@ -37,14 +38,18 @@ the digest and invalidates either form of confirmation.
 `baseline create` never extracts data. The NDJSON and migration-ledger files must already
 exist inside the project and be safe to retain. Add `--assets=<manifest.json>` to include
 bounded local Storage bytes; every manifest `file` must also remain inside the project.
-The guided home screen can ask for these paths so they do not need to be supplied as
-flags.
+The guided home screen scans a bounded set of small project-local JSON and NDJSON files,
+skips generated and private runtime directories, and offers structurally matching paths
+so they do not need to be memorized. It never displays row values. Before activation it
+validates the selected files and referenced assets, shows row, table, migration, and asset
+counts, and asks for confirmation. Invalid input returns to the guide without writing.
 
 The guide is a persistent session: after setup, policy review, baseline creation, or a
 runtime action it re-reads project state and offers the next relevant action. Generated
 policy drafts can be completed interactively without editing JSON. Each column still
-requires explicit action, generated, identity, and foreign-key decisions; the guide does
-not silently infer them.
+receives explicit action, generated, identity, and foreign-key decisions. A human may
+apply the displayed safe preset to a table, then review only selected exceptions; the
+guide never silently applies a preset.
 
 `baseline prepare` reads only table and column names from the NDJSON records; row values
 are never included in its result. Its generated policy deliberately marks every column
@@ -64,3 +69,9 @@ configuration with hosted access and optional networked services disabled. It do
 overwrite an existing Rehearsal config, dedicated Supabase config, or concurrently
 changed `.gitignore`. After writing, it includes a Doctor readiness summary. `init`
 remains available for config-only/manual onboarding.
+
+`support` reports the Rehearsal, Node.js, npm, Supabase CLI, Docker client, and Docker
+server versions plus readiness check statuses. It can run before configuration exists.
+The report deliberately excludes project names and paths, row values, credentials,
+migration SQL, baseline identifiers, and raw command output. It reports only the count
+of quarantined hosted variables, never their names. Always review it before sharing.

package/docs/getting-started.md

@@ -105,10 +105,18 @@ npx rehearsal baseline prepare \
   --write
 ```
 
-After creating the draft, choose **Review the script** in the guide. Rehearsal walks each
-column through sanitization action, generated status, identity status, and optional
-foreign-key metadata. Every answer is explicit, the complete policy is validated before
-writing, and the original draft is replaced only if it did not change during review.
+Running `npx rehearsal` instead discovers structurally matching project-local inputs and
+offers them in the guide. Discovery is bounded, ignores generated/runtime directories,
+and returns paths only. Before a policy draft or immutable baseline is written, Rehearsal
+validates the selected files and presents a value-free shape and count summary.
+
+After creating the draft, choose **Review the script** in the guide. For each table,
+choose between reviewing every column or applying the displayed safe defaults and
+reviewing only exceptions. Rehearsal suggests identifiers, relationship columns, and
+timestamps as exceptions. Every saved column still records sanitization action,
+generated status, identity status, and optional foreign-key metadata. The complete
+policy is validated before writing, and the original draft is replaced only if it did
+not change during review.
 
 For noninteractive workflows, review every `REVIEW REQUIRED` field directly and remove
 `"draft": true` only after that review. Rehearsal refuses to activate a draft.

package/docs/sanitization.md

@@ -19,11 +19,14 @@ whether it is an identity column, and its foreign-key target or explicit absence
 draft uses `REVIEW REQUIRED` placeholders and cannot be activated until they are
 replaced and the `draft` marker is removed.
 
-In an interactive terminal, the guided **Review the script** action completes these
-decisions one column at a time. Replacement-oriented actions are shown first, retaining
-a value is explicitly labeled as sensitive, and no choice is silently inferred. The
-reviewer validates the completed policy and refuses to overwrite a draft changed during
-the session.
+In an interactive terminal, the guided **Review the script** action works table by table.
+For larger tables, a human can explicitly apply safe defaults (`REPLACE`, `NEVER`
+generated, `NO` identity, and no foreign key), then review only exceptions. Likely
+structural columns such as `id`, `*_id`, and timestamps start selected as exceptions.
+Users can instead review every column individually. Retaining a value is explicitly
+labeled as sensitive, every saved field remains classified, and no preset is silently
+applied. The reviewer validates the completed policy and refuses to overwrite a draft
+changed during the session.
 
 The package exports `validateSanitizationCoverage` and
 `applySanitizationAction` as generic primitives:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rehearsal-db/core",
-  "version": "0.1.0-beta.4",
+  "version": "0.1.0-beta.5",
   "private": false,
   "description": "Safely rehearse Supabase migrations against sanitized, production-shaped PostgreSQL data.",
   "repository": {
@@ -75,6 +75,6 @@
   "devDependencies": {
     "@lydell/node-pty": "^1.2.0-beta.15",
     "prettier": "^3.9.6",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.2"
   }
 }

package/scripts/lib/rehearsal/baseline_preparation.mjs

@@ -4,13 +4,14 @@
  */
 
 import { createReadStream } from "node:fs";
-import { access, mkdir, open, readFile } from "node:fs/promises";
+import { access, lstat, mkdir, open, readFile } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { loadRehearsalConfig } from "./configuration.mjs";
 import { buildMigrationLedgerInventory } from "./migration_history.mjs";
 
 const identifierPattern = /^[a-z][a-z0-9_]{0,62}$/u;
+const storageBucketPattern = /^[a-z0-9][a-z0-9.-]{0,99}$/u;
 
 const resolveProjectInput = (projectRoot, value, label) => {
   if (typeof value !== "string" || value.trim() === "") {
@@ -37,6 +38,19 @@ const pathExists = (path) =>
       throw error;
     });
 
+const assertRegularInput = async (path, label) => {
+  let stats;
+  try {
+    stats = await lstat(path);
+  } catch (error) {
+    if (error?.code === "ENOENT") throw new Error(`${label} does not exist.`);
+    throw error;
+  }
+  if (stats.isSymbolicLink() || !stats.isFile()) {
+    throw new Error(`${label} must be a regular project-local file.`);
+  }
+};
+
 const inspectSyntheticRecords = async (path) => {
   const tables = new Map();
   let rowCount = 0;
@@ -97,6 +111,120 @@ const inspectSyntheticRecords = async (path) => {
   };
 };
 
+const inspectAssetManifest = async (path, projectRoot) => {
+  let manifest;
+  try {
+    manifest = JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    throw new Error("Storage asset manifest contains invalid JSON.", {
+      cause: error,
+    });
+  }
+  if (!Array.isArray(manifest)) {
+    throw new Error("Storage asset manifest must be a JSON array.");
+  }
+  const destinations = new Set();
+  for (const [index, asset] of manifest.entries()) {
+    if (
+      !asset ||
+      typeof asset !== "object" ||
+      Array.isArray(asset) ||
+      !storageBucketPattern.test(asset.bucket ?? "") ||
+      typeof asset.objectPath !== "string" ||
+      !asset.objectPath ||
+      asset.objectPath
+        .split("/")
+        .some((segment) => !segment || segment === "." || segment === "..") ||
+      typeof asset.file !== "string" ||
+      !asset.file.trim() ||
+      (asset.contentType !== undefined && typeof asset.contentType !== "string")
+    ) {
+      throw new Error(
+        `Storage asset manifest entry ${index + 1} has an invalid shape.`,
+      );
+    }
+    const destination = `${asset.bucket}/${asset.objectPath}`;
+    if (destinations.has(destination)) {
+      throw new Error(`Duplicate Storage asset destination: ${destination}.`);
+    }
+    destinations.add(destination);
+    const assetFile = resolveProjectInput(
+      projectRoot,
+      asset.file,
+      `Storage asset file in entry ${index + 1}`,
+    );
+    await assertRegularInput(
+      assetFile,
+      `Storage asset file in entry ${index + 1}`,
+    );
+  }
+  return { assetCount: manifest.length };
+};
+
+export const inspectBaselineInputFiles = async ({
+  projectRoot = process.cwd(),
+  configPath,
+  recordsPath,
+  ledgerPath,
+  assetsPath,
+}) => {
+  const loaded = await loadRehearsalConfig({ projectRoot, configPath });
+  const records = resolveProjectInput(
+    loaded.projectRoot,
+    recordsPath,
+    "Synthetic records path",
+  );
+  const ledger = resolveProjectInput(
+    loaded.projectRoot,
+    ledgerPath,
+    "Migration ledger path",
+  );
+  const assets = assetsPath
+    ? resolveProjectInput(
+        loaded.projectRoot,
+        assetsPath,
+        "Storage asset manifest path",
+      )
+    : undefined;
+  await Promise.all([
+    assertRegularInput(records, "Synthetic records path"),
+    assertRegularInput(ledger, "Migration ledger path"),
+    ...(assets
+      ? [assertRegularInput(assets, "Storage asset manifest path")]
+      : []),
+  ]);
+  let ledgerRows;
+  try {
+    ledgerRows = JSON.parse(await readFile(ledger, "utf8"));
+  } catch (error) {
+    throw new Error("Migration ledger contains invalid JSON.", {
+      cause: error,
+    });
+  }
+  const [inspection, assetInspection] = await Promise.all([
+    inspectSyntheticRecords(records),
+    assets
+      ? inspectAssetManifest(assets, loaded.projectRoot)
+      : Promise.resolve({ assetCount: 0 }),
+  ]);
+  const migrationHistory = buildMigrationLedgerInventory(
+    ledgerRows,
+    "Synthetic migration ledger",
+  );
+  return {
+    projectRoot: loaded.projectRoot,
+    recordsPath: relative(loaded.projectRoot, records),
+    ledgerPath: relative(loaded.projectRoot, ledger),
+    assetsPath: assets ? relative(loaded.projectRoot, assets) : undefined,
+    migrationHistory,
+    migrationCutoff: migrationHistory.at(-1).version,
+    migrationCount: migrationHistory.length,
+    rowCount: inspection.rowCount,
+    tables: inspection.tables,
+    assetCount: assetInspection.assetCount,
+  };
+};
+
 const renderPolicyDraft = ({ migrationCutoff, tables }) =>
   `${JSON.stringify(
     {
@@ -127,43 +255,30 @@ export const planBaselinePreparation = async ({
   ledgerPath,
 }) => {
   const loaded = await loadRehearsalConfig({ projectRoot, configPath });
-  const records = resolveProjectInput(
-    loaded.projectRoot,
+  const inspection = await inspectBaselineInputFiles({
+    projectRoot: loaded.projectRoot,
+    configPath,
     recordsPath,
-    "Synthetic records path",
-  );
-  const ledger = resolveProjectInput(
-    loaded.projectRoot,
     ledgerPath,
-    "Migration ledger path",
-  );
-  const [inspection, ledgerRows] = await Promise.all([
-    inspectSyntheticRecords(records),
-    readFile(ledger, "utf8").then(JSON.parse),
-  ]);
-  const migrationHistory = buildMigrationLedgerInventory(
-    ledgerRows,
-    "Synthetic migration ledger",
-  );
+  });
   const destination = loaded.paths.sanitizationPolicy;
   if (await pathExists(destination)) {
     throw new Error(
       `Rehearsal baseline preparation will not overwrite ${relative(loaded.projectRoot, destination)}.`,
     );
   }
-  const migrationCutoff = migrationHistory.at(-1).version;
   return {
     projectRoot: loaded.projectRoot,
     destination,
     destinationRelative: relative(loaded.projectRoot, destination),
-    recordsPath: relative(loaded.projectRoot, records),
-    ledgerPath: relative(loaded.projectRoot, ledger),
-    migrationCutoff,
-    migrationCount: migrationHistory.length,
+    recordsPath: inspection.recordsPath,
+    ledgerPath: inspection.ledgerPath,
+    migrationCutoff: inspection.migrationCutoff,
+    migrationCount: inspection.migrationCount,
     rowCount: inspection.rowCount,
     tables: inspection.tables,
     content: renderPolicyDraft({
-      migrationCutoff,
+      migrationCutoff: inspection.migrationCutoff,
       tables: inspection.tables,
     }),
   };

package/scripts/lib/rehearsal/diagnostics.mjs

@@ -7,7 +7,7 @@
 import { createHash } from "node:crypto";
 
 export const REHEARSAL_RESULT_VERSION = 1;
-export const REHEARSAL_VERSION = "0.1.0-beta.4";
+export const REHEARSAL_VERSION = "0.1.0-beta.5";
 
 export const REHEARSAL_EXIT_CODES = Object.freeze({
   success: 0,

package/scripts/lib/rehearsal/input_discovery.mjs

@@ -0,0 +1,155 @@
+/**
+ * Discover likely project-owned baseline inputs without exposing their values.
+ * Discovery is bounded, ignores generated/private directories, and only sniffs
+ * small JSON or NDJSON files before returning project-relative paths.
+ */
+
+import { open, readFile, readdir, stat } from "node:fs/promises";
+import { extname, join, relative, sep } from "node:path";
+
+const ignoredDirectories = new Set([
+  ".git",
+  ".next",
+  ".rehearsal",
+  ".turbo",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+]);
+const maximumDepth = 4;
+const maximumFiles = 2_000;
+const maximumJsonBytes = 2 * 1024 * 1024;
+const maximumNdjsonProbeBytes = 64 * 1024;
+
+const projectRelativePath = (projectRoot, path) =>
+  relative(projectRoot, path).split(sep).join("/");
+
+const preference = {
+  records: [
+    "rehearsal/sanitized-data.ndjson",
+    "rehearsal/synthetic-data.ndjson",
+  ],
+  ledgers: ["rehearsal/migration-ledger.json"],
+  assetManifests: ["rehearsal/assets.json"],
+};
+
+const sortCandidates = (kind, candidates) => {
+  const preferred = new Map(
+    preference[kind].map((path, index) => [path, index]),
+  );
+  return candidates.sort((left, right) => {
+    const leftRank = preferred.get(left) ?? Number.POSITIVE_INFINITY;
+    const rightRank = preferred.get(right) ?? Number.POSITIVE_INFINITY;
+    return leftRank - rightRank || left.localeCompare(right);
+  });
+};
+
+const readFirstRecord = async (path) => {
+  const handle = await open(path, "r");
+  try {
+    const buffer = Buffer.alloc(maximumNdjsonProbeBytes);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const probe = buffer.subarray(0, bytesRead).toString("utf8");
+    const lines = probe.split(/\r?\n/u);
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      return JSON.parse(line);
+    }
+  } finally {
+    await handle.close();
+  }
+  return undefined;
+};
+
+const isRecord = (value) =>
+  Boolean(
+    value &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    typeof value.table === "string" &&
+    value.row &&
+    typeof value.row === "object" &&
+    !Array.isArray(value.row),
+  );
+
+const isMigrationLedger = (value) =>
+  Array.isArray(value) &&
+  value.length > 0 &&
+  value.every(
+    (entry) =>
+      entry &&
+      typeof entry === "object" &&
+      typeof entry.version === "string" &&
+      typeof entry.name === "string" &&
+      Array.isArray(entry.statements),
+  );
+
+const isAssetManifest = (value) =>
+  Array.isArray(value) &&
+  value.length > 0 &&
+  value.every(
+    (entry) =>
+      entry &&
+      typeof entry === "object" &&
+      typeof entry.bucket === "string" &&
+      typeof entry.objectPath === "string" &&
+      typeof entry.file === "string",
+  );
+
+const collectCandidateFiles = async (projectRoot) => {
+  const files = [];
+  const visit = async (directory, depth) => {
+    if (depth > maximumDepth || files.length >= maximumFiles) return;
+    const entries = await readdir(directory, { withFileTypes: true }).catch(
+      () => [],
+    );
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      if (files.length >= maximumFiles) return;
+      if (entry.isSymbolicLink()) continue;
+      const path = join(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoredDirectories.has(entry.name)) await visit(path, depth + 1);
+        continue;
+      }
+      if (!entry.isFile() || ![".json", ".ndjson"].includes(extname(path))) {
+        continue;
+      }
+      files.push(path);
+    }
+  };
+  await visit(projectRoot, 0);
+  return files;
+};
+
+export const discoverBaselineInputFiles = async ({
+  projectRoot = process.cwd(),
+} = {}) => {
+  const result = { records: [], ledgers: [], assetManifests: [] };
+  for (const path of await collectCandidateFiles(projectRoot)) {
+    const pathStats = await stat(path).catch(() => undefined);
+    if (!pathStats?.isFile()) continue;
+    const relativePath = projectRelativePath(projectRoot, path);
+    try {
+      if (extname(path) === ".ndjson") {
+        if (isRecord(await readFirstRecord(path))) {
+          result.records.push(relativePath);
+        }
+        continue;
+      }
+      if (pathStats.size > maximumJsonBytes) continue;
+      const value = JSON.parse(await readFile(path, "utf8"));
+      if (isMigrationLedger(value)) result.ledgers.push(relativePath);
+      else if (isAssetManifest(value)) result.assetManifests.push(relativePath);
+    } catch {
+      // Invalid or unreadable files are not candidates; explicit validation will
+      // provide actionable errors if the user enters one manually.
+    }
+  }
+  return {
+    records: sortCandidates("records", result.records),
+    ledgers: sortCandidates("ledgers", result.ledgers),
+    assetManifests: sortCandidates("assetManifests", result.assetManifests),
+  };
+};

package/scripts/lib/rehearsal/policy_review.mjs

@@ -7,6 +7,31 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { validateRuntimeSanitizationPolicy } from "./sanitization_policy.mjs";
 
+export const SAFE_COLUMN_PRESET = Object.freeze({
+  action: "REPLACE WITH SYNTHETIC",
+  generated: "NEVER",
+  identity: "NO",
+  foreignKey: null,
+});
+
+export const createSafeTablePreset = (columns) =>
+  Object.fromEntries(
+    columns.map((column) => [
+      typeof column === "string" ? column : column.name,
+      { ...SAFE_COLUMN_PRESET },
+    ]),
+  );
+
+export const suggestPolicyExceptionColumns = (columns) =>
+  columns
+    .map((column) => (typeof column === "string" ? column : column.name))
+    .filter(
+      (column) =>
+        column === "id" ||
+        column.endsWith("_id") ||
+        ["created_at", "updated_at", "deleted_at"].includes(column),
+    );
+
 export const readReviewablePolicyDraft = async (path) => {
   const source = await readFile(path, "utf8");
   const draft = JSON.parse(source);
@@ -18,18 +43,33 @@ export const readReviewablePolicyDraft = async (path) => {
   return { source, draft };
 };
 
-export const completePolicyDraft = async ({ draft, reviewColumn }) => {
+export const completePolicyDraft = async ({
+  draft,
+  reviewColumn,
+  reviewTable,
+}) => {
   if (draft?.draft !== true || !Array.isArray(draft.tables)) {
     throw new Error("A generated REVIEW REQUIRED policy draft is required.");
   }
   const tables = [];
   for (const table of draft.tables) {
+    const columnNames = (table.columns ?? []).map((column) => column.name);
+    const tableDecisions = reviewTable
+      ? await reviewTable({ table: table.name, columns: columnNames })
+      : {};
     const columns = [];
     for (const column of table.columns ?? []) {
-      const reviewed = await reviewColumn({
-        table: table.name,
-        column: column.name,
-      });
+      const reviewed =
+        tableDecisions?.[column.name] ??
+        (await reviewColumn?.({
+          table: table.name,
+          column: column.name,
+        }));
+      if (!reviewed) {
+        throw new Error(
+          `Policy review did not classify ${table.name}.${column.name}.`,
+        );
+      }
       columns.push({ name: column.name, ...reviewed });
     }
     tables.push({ ...table, columns });