From b005aca090fb2b5824d8bcb4659badb17940f005 Mon Sep 17 00:00:00 2001
From: seonghobae <8172694+seonghobae@users.noreply.github.com>
Date: Sat, 11 Jul 2026 14:00:48 +0000
Subject: [PATCH 1/4] =?UTF-8?q?=F0=9F=8E=A8=20Palette:=20[UX=20improvement?=
 =?UTF-8?q?]=20Enhance=20accessibility=20for=20table-based=20modal=20forms?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .jules/palette.md                                   | 4 ++++
 frontend/src/components/modals/CardinalityModal.tsx | 1 +
 frontend/src/components/modals/GroupModal.tsx       | 1 +
 3 files changed, 6 insertions(+)

diff --git a/.jules/palette.md b/.jules/palette.md
index 4fa55f04..ff8d88f8 100644
--- a/.jules/palette.md
+++ b/.jules/palette.md
@@ -46,3 +46,7 @@
 ## 2026-07-05 - Accessible Disabled Buttons
 **Learning:** Adding `aria-describedby` to disabled buttons and explicitly linking them to visible helper text elements allows screen readers to announce the reason for being disabled, significantly improving accessibility for interactive elements that depend on prior state (like selecting a project).
 **Action:** Always pair disabled interactive elements with visible helper text and use `aria-describedby` to semantically link them, ensuring the context is available to assistive technologies.
+
+## 2024-05-18 - Table row input accessibility
+**Learning:** In table-based forms where inputs or `<select>` elements correspond to a specific row property (e.g., Distinct Count, Group Assignment), the visual context or `<label>` often only provides the row identity. Screen reader users can lose context when focusing directly on these inputs.
+**Action:** Always provide an explicit `aria-label` directly on the input/select to give screen readers full context (e.g., `${column.column_name} distinct count`, `${node.data.title} 그룹 배정`), even if it is linked to a label via `id` or placed next to it visually.
diff --git a/frontend/src/components/modals/CardinalityModal.tsx b/frontend/src/components/modals/CardinalityModal.tsx
index 8d360537..f514e994 100644
--- a/frontend/src/components/modals/CardinalityModal.tsx
+++ b/frontend/src/components/modals/CardinalityModal.tsx
@@ -162,6 +162,7 @@ export function CardinalityModal({
                     <td>
                       <input
                         id={inputId}
+                        aria-label={`${column.column_name} distinct count`}
                         inputMode="numeric"
                         min="1"
                         type="number"
diff --git a/frontend/src/components/modals/GroupModal.tsx b/frontend/src/components/modals/GroupModal.tsx
index 66199beb..20392333 100644
--- a/frontend/src/components/modals/GroupModal.tsx
+++ b/frontend/src/components/modals/GroupModal.tsx
@@ -131,6 +131,7 @@ export function GroupModal({
                   {node.data.title}
                 </span>
                 <select
+                  aria-label={`${node.data.title} 그룹 배정`}
                   value={node.data.businessGroup?.id ?? ""}
                   onChange={(event) =>
                     onAssignBusinessGroup(node.id, event.target.value)

From 99f8fb75dcda4ae2fd8091b5c8f9e8474bb1bb08 Mon Sep 17 00:00:00 2001
From: seonghobae <8172694+seonghobae@users.noreply.github.com>
Date: Sun, 12 Jul 2026 12:20:58 +0000
Subject: [PATCH 2/4] =?UTF-8?q?=F0=9F=8E=A8=20Palette:=20[UX=20improvement?=
 =?UTF-8?q?]=20Enhance=20accessibility=20for=20table-based=20modal=20forms?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .github/workflows/codeql.yml                  |  40 +++
 .github/workflows/dependency-review.yml       |  16 +
 .github/workflows/scorecard.yml               |  42 +++
 .jules/bolt.md                                |   3 -
 AGENTS.md                                     | 101 ------
 CHANGELOG.md                                  |   1 -
 CLAUDE.md                                     | 120 -------
 backend/app/api/dbml.py                       |  36 --
 backend/app/api/snapshots.py                  | 189 ----------
 backend/app/db_introspect.py                  |   9 +-
 backend/app/integrations/__init__.py          |   0
 backend/app/integrations/clearfolio.py        | 202 -----------
 backend/app/main.py                           |   2 -
 backend/app/mysql_introspect/__init__.py      |   3 -
 backend/app/mysql_introspect/introspect.py    | 331 ------------------
 backend/app/schemas.py                        |  65 ----
 backend/app/settings.py                       |   9 -
 backend/app/spec/audit_columns.py             |  88 -----
 backend/app/spec/constraint_inventory.py      |  94 -----
 backend/app/spec/dbml_import.py               | 323 -----------------
 backend/app/spec/fk_cycles.py                 | 129 -------
 backend/app/spec/index_redundancy.py          | 100 ------
 backend/app/spec/orm_codegen.py               | 307 ----------------
 backend/app/spec/schema_stats.py              |  89 -----
 backend/app/spec/sensitive_columns.py         |  90 -----
 backend/tests/test_audit_columns.py           |  56 ---
 backend/tests/test_clearfolio.py              | 145 --------
 backend/tests/test_constraint_inventory.py    |  60 ----
 backend/tests/test_db_introspect.py           |  55 +--
 backend/tests/test_dbml_import.py             | 112 ------
 backend/tests/test_fk_cycles.py               |  50 ---
 backend/tests/test_index_redundancy.py        |  66 ----
 backend/tests/test_mysql_introspect.py        | 100 ------
 backend/tests/test_orm_codegen.py             | 141 --------
 backend/tests/test_schema_stats.py            |  56 ---
 backend/tests/test_sensitive_columns.py       |  58 ---
 docs/ci-drift-check.md                        |  57 ---
 docs/clearfolio-integration.md                |  51 ---
 docs/llm-orchestrator-integration.md          |  53 ---
 frontend/src/App.tsx                          |  42 +--
 .../components/modals/ExportModal.test.tsx    |  18 +-
 .../src/components/modals/ExportModal.tsx     |  22 --
 frontend/src/erd/TableNode.tsx                |  10 +-
 frontend/src/erd/__tests__/TableNode.test.tsx |   2 +-
 .../__tests__/exportDataDictionary.test.ts    | 187 ----------
 frontend/src/erd/__tests__/search.test.ts     |  77 ----
 frontend/src/erd/export.ts                    |  29 +-
 frontend/src/erd/exportDataDictionary.ts      | 162 ---------
 frontend/src/erd/search.ts                    |  44 ---
 scripts/ci/check_schema_drift.sh              |  85 -----
 50 files changed, 133 insertions(+), 3994 deletions(-)
 create mode 100644 .github/workflows/codeql.yml
 create mode 100644 .github/workflows/dependency-review.yml
 create mode 100644 .github/workflows/scorecard.yml
 delete mode 100644 AGENTS.md
 delete mode 100644 CLAUDE.md
 delete mode 100644 backend/app/api/dbml.py
 delete mode 100644 backend/app/integrations/__init__.py
 delete mode 100644 backend/app/integrations/clearfolio.py
 delete mode 100644 backend/app/mysql_introspect/__init__.py
 delete mode 100644 backend/app/mysql_introspect/introspect.py
 delete mode 100644 backend/app/spec/audit_columns.py
 delete mode 100644 backend/app/spec/constraint_inventory.py
 delete mode 100644 backend/app/spec/dbml_import.py
 delete mode 100644 backend/app/spec/fk_cycles.py
 delete mode 100644 backend/app/spec/index_redundancy.py
 delete mode 100644 backend/app/spec/orm_codegen.py
 delete mode 100644 backend/app/spec/schema_stats.py
 delete mode 100644 backend/app/spec/sensitive_columns.py
 delete mode 100644 backend/tests/test_audit_columns.py
 delete mode 100644 backend/tests/test_clearfolio.py
 delete mode 100644 backend/tests/test_constraint_inventory.py
 delete mode 100644 backend/tests/test_dbml_import.py
 delete mode 100644 backend/tests/test_fk_cycles.py
 delete mode 100644 backend/tests/test_index_redundancy.py
 delete mode 100644 backend/tests/test_mysql_introspect.py
 delete mode 100644 backend/tests/test_orm_codegen.py
 delete mode 100644 backend/tests/test_schema_stats.py
 delete mode 100644 backend/tests/test_sensitive_columns.py
 delete mode 100644 docs/ci-drift-check.md
 delete mode 100644 docs/clearfolio-integration.md
 delete mode 100644 docs/llm-orchestrator-integration.md
 delete mode 100644 frontend/src/erd/__tests__/exportDataDictionary.test.ts
 delete mode 100644 frontend/src/erd/__tests__/search.test.ts
 delete mode 100644 frontend/src/erd/exportDataDictionary.ts
 delete mode 100644 frontend/src/erd/search.ts
 delete mode 100755 scripts/ci/check_schema_drift.sh

diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 00000000..136cb2f1
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,40 @@
+name: codeql-ci-sast
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+  schedule:
+    - cron: "17 2 * * 2"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ["javascript-typescript", "python"]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+        with:
+          languages: ${{ matrix.language }}
+
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
diff --git a/.github/workflows/dependency-review.yml b/.github/workflows/dependency-review.yml
new file mode 100644
index 00000000..7952e40b
--- /dev/null
+++ b/.github/workflows/dependency-review.yml
@@ -0,0 +1,16 @@
+name: dependency-review
+
+on:
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  dependency-review:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      - name: Dependency Review
+        uses: actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5.0.0
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
new file mode 100644
index 00000000..75c2c990
--- /dev/null
+++ b/.github/workflows/scorecard.yml
@@ -0,0 +1,42 @@
+---
+name: scorecard
+
+"on":
+  branch_protection_rule:
+  schedule:
+    - cron: "30 1 * * 6"
+  push:
+    branches: ["main"]
+
+permissions:
+  contents: read
+
+jobs:
+  analysis:
+    permissions:
+      contents: read
+      # Private repos may need extra job-level reads to avoid GraphQL
+      # "Resource not accessible by integration" (e.g., ListCommits).
+      issues: read
+      pull-requests: read
+      checks: read
+      security-events: write
+      id-token: write
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Run Scorecard
+        uses: ossf/scorecard-action@62b2cac7ed8198b15735ed49ab1e5cf35480ba46  # v2.4.0
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          publish_results: true
+
+      - name: Upload SARIF
+        uses: github/codeql-action/upload-sarif@8aad20d150bbac5944a9f9d289da16a4b0d87c1e  # v4.36.2
+        with:
+          sarif_file: results.sarif
diff --git a/.jules/bolt.md b/.jules/bolt.md
index 463dc25b..a016530d 100644
--- a/.jules/bolt.md
+++ b/.jules/bolt.md
@@ -60,9 +60,6 @@ Optimized metric route processing to O(N) by creating a mapping of routes direct
 ## 2026-06-25 - Avoid Map allocations in frontend ERD loops and mutate asyncpg records in-place
 **Learning:** The frontend `snapshotToGraph` iterates over thousands of columns to generate the graph, so repeated lookups and redundant collection assignments increase GC pressure. Backend snapshot column dictionaries are freshly instantiated for the payload, so `add_column_examples` can safely fill missing fields in place.
 **Action:** Reuse existing collections while aggregating relational data, create `Map`/`Set` entries only on first use, and check for missing example fields before calling expensive inference helpers.
-## 2024-07-07 - Avoid new Map(array.map(...)) for Large Datasets
-**Learning:** Using `new Map(array.map(item => [key, val]))` creates a completely unnecessary intermediate O(N) array of tuple arrays. This forces the garbage collector to immediately clean up the mapped array and the individual tuples once the Map is constructed, leading to memory spikes and GC pauses in large ERD diagrams during export.
-**Action:** Replace `new Map(array.map(...))` with `const map = new Map();` and an iterative `for (const item of array) { map.set(key, item); }` loop to reduce intermediate garbage allocations to zero.
 
 ## 2024-05-18 - [Optimize Node Resolution in autoInfer.ts]
 **Learning:** Found an O(N^2) loop where `nodes.find` scanning via string splitting was running inside an `O(N)` loop to match foreign key relationships. Additionally, noticed two nested O(C) loops checking the same column array. Replaced the top-level loop with an O(1) `Map` lookup and the inner loop with a single O(C) scan using a standard `for...of` loop with early exits.
diff --git a/AGENTS.md b/AGENTS.md
deleted file mode 100644
index ec76a127..00000000
--- a/AGENTS.md
+++ /dev/null
@@ -1,101 +0,0 @@
-# AGENTS.md
-
-Cross-agent conventions for this repo (`pg-erd-cloud`), readable by any coding
-agent (Claude, Codex, Cursor, opencode, …). This is a Python backend
-(`backend/`, FastAPI + SQLAlchemy/Alembic) plus a TypeScript/Vite frontend
-(`frontend/`), shipped via Docker Compose (`compose.yaml`, `compose.prod.yaml`)
-behind Traefik (`deploy/traefik/`).
-
-<!-- BEGIN cwl-agent-guidance -->
-## Agent guidance (CWL governance)
-
-### Security & review gate
-
-- Every PR runs a central, required **Security Scan** gate: `osv-scan` +
-  `dependency-review` (diff-scoped, moderate/Medium and above) and `trivy-fs`
-  (repo-wide, CRITICAL/HIGH/MEDIUM). It runs against **every PR base, including
-  stacked PRs**.
-- A failing **`trivy-fs`, `osv-scan`, or `dependency-review` is a REAL
-  finding, not a flake.** Read the job log and the run's SARIF/artifacts so the
-  specific package, advisory, CVE/GHSA/OSV id, severity, and affected file are
-  visible, then **remediate Medium and above** — do not weaken or disable the
-  gate:
-  - Vulnerable dependency: bump it. Python lives in `backend/requirements.lock`
-    / `backend/requirements-dev.lock` (hash-locked) and `backend/pyproject.toml`;
-    frontend in `frontend/package.json` + `frontend/package-lock.json` /
-    `frontend/pnpm-lock.yaml`.
-  - Container/config misconfig: fix the offending `backend/Dockerfile`,
-    `frontend/Dockerfile`, `frontend/Dockerfile.prod`, the `compose*.yaml`
-    files, or `deploy/traefik/dynamic.yaml`.
-  - Genuine false positive only: add a narrow, **documented** `.trivyignore`
-    (or `.trivyignore.yaml`) entry — scoped and with a reason.
-- Reproducing locally: a stale local DB misses findings. Run
-  `trivy --download-db-only` first, and scan the **merge ref** (PR merged into
-  base), not just the PR head.
-- The org `code_scanning` ruleset is intentionally **CodeQL-only** (multiple
-  code-scanning tools can't converge on one PR ref). Gating is by the Security
-  Scan **job result**, not the `code_scanning` rule — do **not** add tools to
-  that rule.
-
-### Code exploration
-
-- Always initialize CodeGraph in the active worktree (`codegraph init`) before
-  substantial review or remediation, and run `codegraph sync` after edits. Use
-  it to inspect callers, callees, and impact radius before relying on local
-  intuition.
-- Also use `rg`/structured search for text, generated files, sparse checkouts,
-  and languages CodeGraph cannot parse. A missing or partial CodeGraph result is
-  not proof that a behavior or dependency path is absent; record the limitation
-  in the PR/check evidence when it matters.
-
-### Config & secrets (KV, not env)
-
-- Org rule: at runtime, do **not** read config/secrets via `os.getenv()` /
-  raw environment variables. Read them from a KV / credential registry. Org
-  Actions secrets (e.g. `OPENAI_API_KEY`) flow **into** the KV via a
-  bootstrap/CI step; runtime reads from the KV — env is only transport into the
-  KV, never the runtime source.
-- Reference implementation: `xtrmLLMBatchPython`'s pgcrypto-encrypted Postgres
-  credential registry (`get_credential(name)`). Reuse that pattern (a DB-backed
-  KV is fine) unless a dedicated KV is adopted.
-- **Known deviation to migrate (this repo):** `backend/app/settings.py`
-  (`Settings(BaseSettings)`) currently loads runtime secrets/config directly
-  from the environment / `.env` — `app_secret` (DSN encryption key),
-  `database_url`, `llm_api_key`, and the OIDC/Valkey credentials. The
-  Docker/Podman `*_FILE` pattern for `app_secret` is a step in the right
-  direction, but env is still the runtime source. Migrate these reads to a
-  KV / credential registry (`get_credential(name)`); keep env only as the
-  bootstrap path that seeds the KV.
-
-### This repo's role in the ecosystem
-
-- **This repo (`pg-erd-cloud`):** ERD tool for developers and data architects
-  (project-management context).
-- The org is an ecosystem built around **naruon** — the hub: an email/PIM that
-  DOM-decomposes emails and files into a persisted knowledge graph. Each
-  component below is a **standalone program that must ALSO work as a git
-  submodule**, grown separately and together:
-  - **waf-ids-ai-soc** — WAF / IDS / AI SOC / load balancer / API management.
-  - **clearfolio** — document viewer.
-  - **pg-erd-cloud** — ERD tool (this repo).
-  - **contextual-orchestrator** — LLM cost/perf/upstream-LB gateway (beyond
-    LiteLLM).
-  - **codec-carver** — STT / omni-modal speech-video codec.
-  - **fast-mlsirm** — LLM-as-a-Judge calibration + evaluation-item quality
-    (uses aFIPC FIPC + kaefa item-fit).
-  - **feelanet-adfs** — passwordless SSO (OIDC / SCIM / ADFS / LDAP / FIDO2 /
-    OAuth2.1; eliminate passwords).
-  - **newsdom-api** — PDF→DOM sidecar.
-  - **semantic-data-portal** — upper ontology / catalog / governance plane with
-    its own graph engine.
-
-### Research grounding (attach paper PDFs)
-
-- Org rule: substantive feature/process PRs should find the relevant academic
-  papers and **commit their PDFs into the PR** (e.g. a `docs/papers/` or
-  `references/` dir) with full citations. Respect copyright: attach the PDF
-  only when redistribution is permissible; otherwise cite + link + summarize.
-- For this repo (ERD / schema design), ground substantive work in the relevant
-  literature — e.g. data modeling, ER theory, schema normalization, or
-  graph/layout algorithms for diagram rendering.
-<!-- END cwl-agent-guidance -->
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 519bee6c..9a632832 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,4 +6,3 @@
 - [FE] 📋 **테이블 복제 기능 추가**: 편집 모달 내에서 기존 테이블의 구조(컬럼 정보 포함)를 그대로 복사하여 새 테이블 노드로 생성하는 '복제' 버튼을 추가했습니다.
 - [FE] `autoInfer.ts`에 대한 단위 테스트 및 UI 컴포넌트 단위 테스트를 추가하여 100% 테스트 커버리지를 유지합니다.
 - [FE] ⬇️ **DBML Export**: ERD 다이어그램을 DBML (Database Markup Language) 형식으로 내보낼 수 있는 기능을 추가했습니다. 상단의 DBML 버튼을 클릭하여 다운로드할 수 있습니다.
-- [FE] 📚 **Data Dictionary Export**: ERD 테이블/컬럼 메타데이터를 CSV 및 Markdown으로 내보내며, CSV formula injection과 Markdown 렌더링 escape를 적용했습니다.
diff --git a/CLAUDE.md b/CLAUDE.md
deleted file mode 100644
index e13a3f78..00000000
--- a/CLAUDE.md
+++ /dev/null
@@ -1,120 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## What this is
-
-pg-erd-cloud is a PostgreSQL-focused cloud ERD (entity-relationship diagram) collaboration/sharing service — currently a runnable MVP skeleton. It reverse-engineers a target PostgreSQL database (optionally Snowflake) into JSON schema snapshots, renders them as an interactive ERD (React Flow), and forward-engineers snapshots into DDL exports (PostgreSQL or Snowflake dialect), schema diffs/migration SQL, DBML/Mermaid exports, and "DB reversing spec" documents (markdown draft, LLM prompt, or live LLM draft via an OpenAI-compatible provider configured with `LLM_API_BASE_URL`/`LLM_API_KEY`/`LLM_MODEL`). Project owners can create share links for unauthenticated read/export access.
-
-Repository docs are mixed-language: README.md and CHANGELOG.md are Korean; CONTRIBUTING.md, SECURITY.md, and most of docs/ are English.
-
-## Common commands
-
-### Full stack (Docker, dev)
-
-```bash
-cp .env.example .env   # set POSTGRES_PASSWORD and APP_SECRET
-docker compose up -d --build
-```
-
-Frontend: http://localhost:5173 · Backend: http://localhost:8000 (health: `/healthz`). Source directories are bind-mounted; backend runs with `--reload` and frontend runs the Vite dev server, so edits hot-reload.
-
-### Backend (backend/, Python ≥3.10, CI uses 3.10)
-
-```bash
-cd backend
-python -m venv .venv && source .venv/bin/activate
-pip install -U pip
-pip install -e .                 # add ".[snowflake]" for Snowflake reverse engineering
-alembic upgrade head             # apply migrations (backend/alembic/versions)
-hypercorn --config python:app.hypercorn_config app.main:app \
-  --bind 0.0.0.0:8000 --reload --access-logfile - --error-logfile -
-```
-
-Checks (mirror CI):
-
-```bash
-cd backend
-PYTHONPATH=. mypy app
-PYTHONPATH=. pytest -q
-PYTHONPATH=. pytest -q tests/test_snapshot_job.py                # single file
-PYTHONPATH=. pytest -q tests/test_snapshot_job.py::test_name     # single test
-```
-
-CI installs backend deps with `pip install --require-hashes -r requirements-dev.lock`. The lockfiles are generated with uv (see header comments in `backend/requirements*.lock`); when changing dependencies in `backend/pyproject.toml`, regenerate both lockfiles, e.g.:
-
-```bash
-uv pip compile backend/pyproject.toml --python-version 3.10 --generate-hashes -o backend/requirements.lock
-uv pip compile backend/pyproject.toml --python-version 3.10 --generate-hashes --extra dev -o backend/requirements-dev.lock
-```
-
-### Frontend (frontend/, Node 26 — see .nvmrc / engines)
-
-```bash
-cd frontend
-npm ci
-npm run dev                                              # Vite dev server on 5173
-npm run typecheck                                        # tsc --noEmit
-npm run test                                             # vitest run
-npm run test -- src/erd/__tests__/cardinality.test.ts    # single test file
-npm run build                                            # tsc -b && vite build
-```
-
-CI uses npm with `package-lock.json` (a `pnpm-lock.yaml` also exists, but CI caches npm).
-
-### Production-style (Docker + Traefik)
-
-```bash
-cp .env.example .env
-mkdir -p secrets
-# write a long random value to secrets/app_secret (never commit; .gitignore covers **/secrets/**)
-chmod 600 secrets/app_secret
-docker compose -f compose.prod.yaml up -d --build
-```
-
-App entrypoint: http://localhost:8080 (`TRAEFIK_HTTP_PORT`).
-
-## Architecture
-
-Three deployable pieces in one repo:
-
-- **backend/** — Python FastAPI app (async SQLAlchemy 2 + asyncpg on PostgreSQL 16), served by Hypercorn. The app's own PostgreSQL stores metadata: users, project spaces/members, encrypted DB connections, schema snapshots, job queue, diagram views, annotations, share links, API keys (`app/models.py`).
-- **frontend/** — React 19 + TypeScript + Vite SPA. The ERD canvas is built on `@xyflow/react` (React Flow). Core ERD logic lives in `src/erd/` (snapshot→graph conversion, cardinality, FK auto-inference, DBML/Mermaid/SQL export); modal dialogs in `src/components/modals/`. Tests use Vitest + Testing Library (plus fast-check fuzz tests).
-- **deploy/traefik/** — Traefik dynamic config used by `compose.prod.yaml`.
-
-### Backend layout (backend/app/)
-
-- `api/` — FastAPI routers (projects, connections, snapshots, share, diagram_views, annotations, api_keys, auth_routes, me), all mounted in `main.py` under `/api`.
-- `jobs/` — Postgres-backed job queue (`JobQueue` table). Reverse engineering never blocks the request path: the API enqueues a `snapshot` job, and an in-process worker task (started in the FastAPI lifespan in `main.py`) claims and executes it. Optional Valkey/Redis (`valkey_queue.py`) is only a wake-up signal; Postgres remains the source of truth.
-- `pg_introspect/` — pg_catalog-based introspection of the *target* PostgreSQL: schemas/tables/columns, PK/FK/UNIQUE/CHECK, indexes. Index access methods are discovered dynamically from `pg_am`/`pg_class.relam` and index DDL is preserved losslessly via `pg_get_indexdef()` — do not hardcode an index-type list (project principle, see README). Also synthesizes safe `example_value` column hints from name/type metadata only (never samples real table data).
-- `snowflake_introspect/` — optional Snowflake reverse engineering (INFORMATION_SCHEMA; requires the `snowflake` extra).
-- `ddl/` — forward engineering: snapshot → DDL export with dialect mapping, migration SQL, migration-safety checks.
-- `diff/` — snapshot-to-snapshot schema diff.
-- `spec/` — reversing-spec generation, naming lint, data dictionary, relationship inference, LLM integration.
-- Cross-cutting: `auth.py` (OIDC/Casdoor JWT verification when `OIDC_ISSUER` is set, plus API keys and token revocation), `csrf.py`, `rate_limit.py` (in-memory fixed-window; global `/api/*` limit plus a stricter separate limit for public `/api/share/*`), `security_headers.py`, `observability.py` (JSON request logs + Prometheus metrics — see docs/observability.md), `sanitize.py`/`dsn_redaction.py`, `settings.py` (pydantic-settings; env vars are documented in `.env.example`).
-
-### Data flow
-
-1. A user registers a target-DB connection; the DSN is encrypted with `APP_SECRET` before being stored in the app DB.
-2. Requesting a snapshot enqueues a job; the background worker connects to the target DB, introspects it, and stores a JSON snapshot (`SchemaSnapshot` + `SchemaSnapshotData`).
-3. The frontend fetches snapshots via `/api/*` and renders the ERD; all exports (DDL, diff/migration SQL, reversing spec, DBML/Mermaid) are derived from the stored snapshot, not from live DB access.
-4. Share links expose read-only snapshot/export routes under `/api/share/{share_uuid}/...` with a tighter rate limit, and sensitive fields (schema comments, example values) are redacted from publicly shared payloads.
-
-### Dev vs prod compose
-
-- `compose.yaml` (dev): postgres + backend + frontend. Bind mounts and hot reload; backend on 127.0.0.1:8000, frontend on 127.0.0.1:5173; `APP_SECRET` comes from `.env`; CORS allows http://localhost:5173.
-- `compose.prod.yaml`: adds a Traefik edge router on :8080 that routes `/api/*` and `/healthz` to the backend and everything else to a static frontend (`frontend/Dockerfile.prod` builds `dist/` served by `serve-static.mjs`). No bind mounts or reload; `APP_SECRET` is injected as a Docker secret file (`APP_SECRET_FILE=/run/secrets/app_secret`); only Traefik is published. Traefik also applies security-headers middleware (`deploy/traefik/dynamic.yaml`).
-- Both compose files run `alembic upgrade head` before starting the backend, so migrations must always be committed alongside model changes.
-
-## Conventions and gotchas
-
-- `APP_SECRET` is the encryption key for stored DSNs — changing it breaks decryption of existing data. Prefer `APP_SECRET_FILE` injection in production.
-- Never commit `.env`, `secrets/`, credentials, or DSNs. Treat DSNs and generated schema metadata as sensitive (SECURITY.md, docs/api-security-checklist.md).
-- Backend code is strictly typed: mypy runs with `disallow_untyped_defs` (see `[tool.mypy]` in backend/pyproject.toml). Public defs need docstrings — interrogate is configured with `fail-under = 100` in setup.cfg and `tests/test_docstrings.py` enforces it for checked modules.
-- Long-running work (introspection of target DBs) goes through the job queue, never synchronously in a request handler.
-- Middleware registration order in `app/main.py` is deliberate (security headers registered last so they wrap everything, including 429s and CORS preflight) — read the comments there before reordering.
-- Do not use nested `${VAR:-${OTHER:-default}}` expressions in compose files; podman-compose mishandles them (noted inline in compose.yaml).
-- Supply-chain pinning is enforced (OpenSSF Scorecard): Docker images are pinned by digest, GitHub Actions by commit SHA, and pip installs by `--require-hashes`. Preserve pinning when adding or updating any of these.
-- CI (`.github/workflows/ci.yml`) runs backend mypy + pytest (Python 3.10, hash-locked deps) and frontend typecheck + vitest + production build (Node 26). CodeQL, Scorecard, and dependency-review workflows also run.
-- User-visible frontend changes are recorded in CHANGELOG.md (Korean) and frontend/CHANGELOG.md.
-- Add or update tests when changing behavior; prefer small, focused PRs (CONTRIBUTING.md).
diff --git a/backend/app/api/dbml.py b/backend/app/api/dbml.py
deleted file mode 100644
index c35db752..00000000
--- a/backend/app/api/dbml.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-from fastapi import APIRouter, Depends
-
-from app.auth import CurrentUser, get_current_user
-from app.ddl.export import snapshot_json_to_sql
-from app.schemas import DbmlConvertIn, DbmlConvertOut
-from app.spec.dbml_import import parse_dbml
-
-router = APIRouter(prefix="/api/dbml", tags=["dbml"])
-
-
-@router.post("/convert", response_model=DbmlConvertOut)
-async def convert_dbml(
-    body: DbmlConvertIn,
-    user: CurrentUser = Depends(get_current_user),
-) -> DbmlConvertOut:
-    """Design-first entry point: DBML text → snapshot JSON (+ optional DDL).
-
-    The returned snapshot has the same shape introspection produces, so the
-    whole downstream pipeline (ERD, DDL export, diff, migration, analyzers)
-    works on a design that never touched a database. Pure computation — no
-    project resources involved, so authentication alone suffices.
-    """
-    snapshot = parse_dbml(body.dbml)
-    ddl = (
-        snapshot_json_to_sql(snapshot, target_dialect=body.dialect)
-        if body.include_ddl
-        else None
-    )
-    return DbmlConvertOut(
-        snapshot_json=snapshot,
-        ddl=ddl,
-        tables=len(snapshot["relations"]),
-        foreign_keys=len(snapshot["fk_edges"]),
-    )
diff --git a/backend/app/api/snapshots.py b/backend/app/api/snapshots.py
index f221aaaa..3099d52d 100644
--- a/backend/app/api/snapshots.py
+++ b/backend/app/api/snapshots.py
@@ -19,15 +19,9 @@
 )
 from app.permissions import require_project_member
 from app.schemas import (
-    AuditColumnsOut,
-    ConstraintInventoryOut,
-    FkCyclesOut,
-    IndexRedundancyOut,
     InferredRelationshipOut,
     MigrationSafetyOut,
     NamingLintOut,
-    SchemaStatsOut,
-    SensitiveColumnsOut,
     SnapshotCreateIn,
     SnapshotDetailOut,
     SnapshotDiffOut,
@@ -38,20 +32,9 @@
 from app.ddl.migration import snapshot_diff_to_migration_sql
 from app.ddl.migration_safety import analyze_migration_safety
 from app.diff.schema_diff import diff_snapshots
-from app.spec.audit_columns import check_audit_columns
-from app.spec.constraint_inventory import build_constraint_inventory
-from app.spec.fk_cycles import detect_fk_cycles
-from app.spec.index_redundancy import detect_index_redundancy
 from app.spec.data_dictionary import snapshot_to_data_dictionary_md
 from app.spec.naming_lint import lint_naming
-from app.spec.orm_codegen import (
-    generate_prisma_schema,
-    generate_sqlalchemy_models,
-    generate_typeorm_entities,
-)
 from app.spec.relationship_inference import infer_relationships
-from app.spec.schema_stats import compute_schema_stats
-from app.spec.sensitive_columns import detect_sensitive_columns
 from app.spec.wide_tables import detect_wide_tables
 from app.jobs.valkey_queue import enqueue_job_signal
 from app.spec.llm import (
@@ -377,178 +360,6 @@ async def wide_tables(
     )
 
 
-@router.get("/{schema_snapshot_uuid}/orm-models", response_class=PlainTextResponse)
-async def export_orm_models(
-    schema_snapshot_uuid: uuid.UUID,
-    flavor: str = Query("sqlalchemy", pattern="^(sqlalchemy|prisma|typeorm)$"),
-    user: CurrentUser = Depends(get_current_user),
-    session: AsyncSession = Depends(get_read_session),
-) -> str:
-    """Generate ORM model code from a snapshot (SQLAlchemy 2.0 or Prisma).
-
-    Forward engineering to application code: hand developers ready-to-edit
-    models instead of retyped tables. IDOR-safe (uniform not-found marker).
-    """
-    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
-    if snap is None:
-        return "-- snapshot not found\n"
-    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
-    if data is None:
-        return "-- snapshot data not found\n"
-    if flavor == "prisma":
-        return generate_prisma_schema(data.snapshot_json)
-    if flavor == "typeorm":
-        return generate_typeorm_entities(data.snapshot_json)
-    return generate_sqlalchemy_models(data.snapshot_json)
-
-
-@router.get("/{schema_snapshot_uuid}/stats", response_model=SchemaStatsOut)
-async def schema_stats(
-    schema_snapshot_uuid: uuid.UUID,
-    user: CurrentUser = Depends(get_current_user),
-    session: AsyncSession = Depends(get_read_session),
-) -> SchemaStatsOut:
-    """Overview statistics for a snapshot (object counts, column & type
-    distribution, widest tables, PK/FK/index coverage).
-
-    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
-    """
-    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
-    if snap is None:
-        return SchemaStatsOut(
-            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", stats=None
-        )
-    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
-    stats = compute_schema_stats(data.snapshot_json if data else None)
-    return SchemaStatsOut(
-        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", stats=stats
-    )
-
-
-@router.get("/{schema_snapshot_uuid}/fk-cycles", response_model=FkCyclesOut)
-async def fk_cycles(
-    schema_snapshot_uuid: uuid.UUID,
-    user: CurrentUser = Depends(get_current_user),
-    session: AsyncSession = Depends(get_read_session),
-) -> FkCyclesOut:
-    """Report circular foreign-key dependencies (migration-ordering hazards).
-
-    Multi-table cycles are warnings; self-references are informational.
-    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
-    """
-    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
-    if snap is None:
-        return FkCyclesOut(
-            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None
-        )
-    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
-    report = detect_fk_cycles(data.snapshot_json if data else None)
-    return FkCyclesOut(
-        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report
-    )
-
-
-@router.get(
-    "/{schema_snapshot_uuid}/sensitive-columns", response_model=SensitiveColumnsOut
-)
-async def sensitive_columns(
-    schema_snapshot_uuid: uuid.UUID,
-    user: CurrentUser = Depends(get_current_user),
-    session: AsyncSession = Depends(get_read_session),
-) -> SensitiveColumnsOut:
-    """Compliance-scoping inventory: which columns likely hold PII / card /
-    credential data, mapped to the relevant framework (PCI DSS, GDPR/PIPA).
-
-    Detection only -- it does not encrypt, mask, or tokenize anything.
-    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
-    """
-    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
-    if snap is None:
-        return SensitiveColumnsOut(
-            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None
-        )
-    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
-    report = detect_sensitive_columns(data.snapshot_json if data else None)
-    return SensitiveColumnsOut(
-        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report
-    )
-
-
-@router.get("/{schema_snapshot_uuid}/audit-columns", response_model=AuditColumnsOut)
-async def audit_columns(
-    schema_snapshot_uuid: uuid.UUID,
-    user: CurrentUser = Depends(get_current_user),
-    session: AsyncSession = Depends(get_read_session),
-) -> AuditColumnsOut:
-    """Flag tables missing created_at/updated_at when the schema's own
-    majority follows that convention (no external style imposed).
-
-    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
-    """
-    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
-    if snap is None:
-        return AuditColumnsOut(
-            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None
-        )
-    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
-    report = check_audit_columns(data.snapshot_json if data else None)
-    return AuditColumnsOut(
-        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report
-    )
-
-
-@router.get(
-    "/{schema_snapshot_uuid}/constraint-inventory",
-    response_model=ConstraintInventoryOut,
-)
-async def constraint_inventory(
-    schema_snapshot_uuid: uuid.UUID,
-    user: CurrentUser = Depends(get_current_user),
-    session: AsyncSession = Depends(get_read_session),
-) -> ConstraintInventoryOut:
-    """Inventory CHECK-constraint business rules and FK delete-action risks
-    (ON DELETE CASCADE = warning, SET NULL = info).
-
-    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
-    """
-    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
-    if snap is None:
-        return ConstraintInventoryOut(
-            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None
-        )
-    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
-    report = build_constraint_inventory(data.snapshot_json if data else None)
-    return ConstraintInventoryOut(
-        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report
-    )
-
-
-@router.get(
-    "/{schema_snapshot_uuid}/index-redundancy", response_model=IndexRedundancyOut
-)
-async def index_redundancy(
-    schema_snapshot_uuid: uuid.UUID,
-    user: CurrentUser = Depends(get_current_user),
-    session: AsyncSession = Depends(get_read_session),
-) -> IndexRedundancyOut:
-    """Report duplicate and prefix-shadowed indexes (safe drop candidates).
-
-    Unique indexes are never suggested for dropping (they enforce constraints);
-    expression/partial indexes are skipped rather than guessed.
-    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
-    """
-    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
-    if snap is None:
-        return IndexRedundancyOut(
-            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None
-        )
-    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
-    report = detect_index_redundancy(data.snapshot_json if data else None)
-    return IndexRedundancyOut(
-        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report
-    )
-
-
 @router.get(
     "/{schema_snapshot_uuid}/data-dictionary.md", response_class=PlainTextResponse
 )
diff --git a/backend/app/db_introspect.py b/backend/app/db_introspect.py
index daef76d8..17d06c93 100644
--- a/backend/app/db_introspect.py
+++ b/backend/app/db_introspect.py
@@ -4,7 +4,6 @@
 from urllib.parse import urlparse
 
 from app.dsn_redaction import redact_dsn_error_message
-from app.mysql_introspect import introspect_mysql, probe_mysql
 from app.pg_introspect.forward_ddl import validate_forward_ddl
 from app.pg_introspect.introspect import (
     apply_postgres_ddl,
@@ -14,7 +13,7 @@
 from app.snowflake_introspect import introspect_snowflake
 from app.snowflake_introspect.introspect import probe_snowflake
 
-DatabaseDialect = Literal["postgresql", "snowflake", "mysql"]
+DatabaseDialect = Literal["postgresql", "snowflake"]
 
 
 def detect_dsn_dialect(dsn: str) -> DatabaseDialect:
@@ -25,8 +24,6 @@ def detect_dsn_dialect(dsn: str) -> DatabaseDialect:
         return "postgresql"
     if scheme == "snowflake":
         return "snowflake"
-    if scheme in ("mysql", "mariadb"):
-        return "mysql"
     raise ValueError(f"unsupported database DSN scheme: {scheme or '<empty>'}")
 
 
@@ -37,8 +34,6 @@ async def introspect_database(dsn: str, schema_filter: str | None) -> dict:
         dialect = detect_dsn_dialect(dsn)
         if dialect == "snowflake":
             return await introspect_snowflake(dsn, schema_filter)
-        if dialect == "mysql":
-            return await introspect_mysql(dsn, schema_filter)
         return await introspect_postgres(dsn, schema_filter)
     except Exception as exc:
         message = str(exc) or type(exc).__name__
@@ -76,8 +71,6 @@ async def probe_database(dsn: str) -> str:
         dialect = detect_dsn_dialect(dsn)
         if dialect == "snowflake":
             return await probe_snowflake(dsn)
-        if dialect == "mysql":
-            return await probe_mysql(dsn)
         return await probe_postgres(dsn)
     except Exception as exc:
         message = str(exc) or type(exc).__name__
diff --git a/backend/app/integrations/__init__.py b/backend/app/integrations/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/backend/app/integrations/clearfolio.py b/backend/app/integrations/clearfolio.py
deleted file mode 100644
index 488f23ab..00000000
--- a/backend/app/integrations/clearfolio.py
+++ /dev/null
@@ -1,202 +0,0 @@
-"""Buyer-gateway connector for Clearfolio (reference-document viewer platform).
-
-pg-erd-cloud acts as the *buyer gateway*: it authenticates its own user
-(OIDC / API key), maps that principal to Clearfolio tenant claims, signs those
-claims with the shared HMAC secret, and proxies to the Clearfolio connector API
-(submit → status → viewer bootstrap → artifact link).
-
-Signing contract (from Clearfolio's buyer-deployment playbook — must match its
-verifier exactly):
-
-    payload    = "\\n".join([tenantId, subjectId, canonicalPermissions, issuedAt])
-    signature  = base64url( HMAC_SHA256(secret, payload) )   # no padding
-
-Sent as the header set ``X-Clearfolio-{Tenant-Id,Subject-Id,Permissions,
-Claims-Issued-At,Claims-Signature}``. The gateway host is SSRF-validated (it is
-admin-configured, not per-request user input, but validated for defense in
-depth).
-"""
-
-from __future__ import annotations
-
-import base64
-import datetime as dt
-import hashlib
-import hmac
-from dataclasses import dataclass
-from typing import Any
-from urllib.parse import quote, urlparse
-
-import httpx
-
-from app.pg_introspect.dsn_guard import _validated_ip_hosts
-from app.settings import settings
-
-def _sanitize(value: str) -> str:
-    """Match Clearfolio's claim sanitizer: drop NUL, strip surrounding space."""
-    return value.replace("\x00", "").strip()
-
-
-def canonicalize_permissions(raw: str) -> str:
-    """Reduce a permission string to Clearfolio's canonical form.
-
-    Clearfolio verifies the signature against ``canonicalPermissions`` — the
-    header split on ``,``, each entry sanitized, empties dropped, de-duplicated
-    preserving order, re-joined with ``,``. The gateway must sign (and send)
-    this exact form or every request 401s, so we canonicalize identically.
-    """
-    seen: dict[str, None] = {}
-    for part in raw.split(","):
-        cleaned = _sanitize(part)
-        if cleaned:
-            seen.setdefault(cleaned, None)
-    return ",".join(seen)
-
-
-def _path_segment(value: str) -> str:
-    return quote(value, safe="")
-
-
-_H_TENANT = "X-Clearfolio-Tenant-Id"
-_H_SUBJECT = "X-Clearfolio-Subject-Id"
-_H_PERMS = "X-Clearfolio-Permissions"
-_H_ISSUED = "X-Clearfolio-Claims-Issued-At"
-_H_SIG = "X-Clearfolio-Claims-Signature"
-
-
-class ClearfolioNotConfigured(RuntimeError):
-    """Raised when the Clearfolio connector is called without configuration."""
-
-
-class ClearfolioError(RuntimeError):
-    """A Clearfolio API call failed (status text is safe to surface)."""
-
-
-@dataclass(frozen=True)
-class ClearfolioConfig:
-    gateway_url: str
-    hmac_secret: str
-    tenant_id: str
-    permissions: str
-    timeout_seconds: float
-
-    @classmethod
-    def from_settings(cls) -> "ClearfolioConfig":
-        if not settings.clearfolio_gateway_url or not settings.clearfolio_tenant_claims_hmac_secret:
-            raise ClearfolioNotConfigured(
-                "CLEARFOLIO_GATEWAY_URL and CLEARFOLIO_TENANT_CLAIMS_HMAC_SECRET must be set"
-            )
-        return cls(
-            gateway_url=settings.clearfolio_gateway_url.rstrip("/"),
-            hmac_secret=settings.clearfolio_tenant_claims_hmac_secret,
-            tenant_id=settings.clearfolio_tenant_id,
-            permissions=settings.clearfolio_permissions,
-            timeout_seconds=settings.clearfolio_timeout_seconds,
-        )
-
-
-def sign_tenant_claims(
-    secret: str,
-    tenant_id: str,
-    subject_id: str,
-    canonical_permissions: str,
-    issued_at: int,
-) -> str:
-    """Base64URL (unpadded) HMAC-SHA256 of the newline-joined claim payload."""
-    payload = "\n".join([tenant_id, subject_id, canonical_permissions, str(issued_at)])
-    digest = hmac.new(secret.encode("utf-8"), payload.encode("utf-8"), hashlib.sha256).digest()
-    return base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
-
-
-def build_tenant_headers(
-    config: ClearfolioConfig, subject_id: str, issued_at: int | None = None
-) -> dict[str, str]:
-    """Build the full signed Clearfolio tenant header set for a subject."""
-    if issued_at is None:
-        issued_at = int(dt.datetime.now(dt.timezone.utc).timestamp())
-    # Sign and send the exact canonical values Clearfolio re-derives on verify,
-    # otherwise a config with spaces/duplicates would 401.
-    tenant_id = _sanitize(config.tenant_id)
-    subject = _sanitize(subject_id)
-    permissions = canonicalize_permissions(config.permissions)
-    signature = sign_tenant_claims(
-        config.hmac_secret, tenant_id, subject, permissions, issued_at
-    )
-    return {
-        _H_TENANT: tenant_id,
-        _H_SUBJECT: subject,
-        _H_PERMS: permissions,
-        _H_ISSUED: str(issued_at),
-        _H_SIG: signature,
-    }
-
-
-async def _validate_gateway(config: ClearfolioConfig) -> None:
-    """SSRF defense-in-depth: reject an internal/loopback gateway host."""
-    parsed = urlparse(config.gateway_url)
-    if not parsed.hostname:
-        raise ClearfolioError("invalid CLEARFOLIO_GATEWAY_URL")
-    await _validated_ip_hosts(parsed.hostname, is_hostaddr=False, port=parsed.port or 443)
-
-
-async def _request(
-    config: ClearfolioConfig,
-    method: str,
-    path: str,
-    subject_id: str,
-    *,
-    files: dict[str, Any] | None = None,
-    extra_headers: dict[str, str] | None = None,
-) -> dict[str, Any]:
-    await _validate_gateway(config)
-    headers = build_tenant_headers(config, subject_id)
-    if extra_headers:
-        headers.update(extra_headers)
-    async with httpx.AsyncClient(timeout=config.timeout_seconds) as client:
-        resp = await client.request(
-            method, f"{config.gateway_url}{path}", headers=headers, files=files
-        )
-    if resp.status_code >= 400:
-        raise ClearfolioError(f"clearfolio {method} {path} -> {resp.status_code}")
-    return resp.json() if resp.content else {}
-
-
-async def submit_conversion_job(
-    subject_id: str, file_bytes: bytes, filename: str
-) -> dict[str, Any]:
-    """POST /api/v1/convert/jobs — submit a document for preview conversion."""
-    config = ClearfolioConfig.from_settings()
-    return await _request(
-        config,
-        "POST",
-        "/api/v1/convert/jobs",
-        subject_id,
-        files={"file": (filename, file_bytes)},
-    )
-
-
-async def get_job_status(subject_id: str, job_id: str) -> dict[str, Any]:
-    """GET /api/v1/convert/jobs/{jobId} — read conversion lifecycle status."""
-    config = ClearfolioConfig.from_settings()
-    return await _request(
-        config, "GET", f"/api/v1/convert/jobs/{_path_segment(job_id)}", subject_id
-    )
-
-
-async def get_viewer_bootstrap(subject_id: str, doc_id: str) -> dict[str, Any]:
-    """GET /api/v1/viewer/{docId} — viewer bootstrap (signed previewResourcePath)."""
-    config = ClearfolioConfig.from_settings()
-    return await _request(
-        config, "GET", f"/api/v1/viewer/{_path_segment(doc_id)}", subject_id
-    )
-
-
-async def create_artifact_link(subject_id: str, doc_id: str) -> dict[str, Any]:
-    """POST /api/v1/viewer/{docId}/artifact-links — short-lived signed artifact URL."""
-    config = ClearfolioConfig.from_settings()
-    return await _request(
-        config,
-        "POST",
-        f"/api/v1/viewer/{_path_segment(doc_id)}/artifact-links",
-        subject_id,
-    )
diff --git a/backend/app/main.py b/backend/app/main.py
index ae5788af..a0f0780c 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -11,7 +11,6 @@
 from app.api.annotations import router as annotations_router
 from app.api.api_keys import router as api_keys_router
 from app.api.connections import router as connections_router
-from app.api.dbml import router as dbml_router
 from app.api.auth_routes import router as auth_router
 from app.api.diagram_views import router as diagram_views_router
 from app.api.me import router as me_router
@@ -168,7 +167,6 @@ async def csrf_token() -> dict[str, str]:
 
 app.include_router(projects_router)
 app.include_router(connections_router)
-app.include_router(dbml_router)
 app.include_router(snapshots_router)
 app.include_router(diagram_views_router)
 app.include_router(annotations_router)
diff --git a/backend/app/mysql_introspect/__init__.py b/backend/app/mysql_introspect/__init__.py
deleted file mode 100644
index dad84964..00000000
--- a/backend/app/mysql_introspect/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from app.mysql_introspect.introspect import introspect_mysql, probe_mysql
-
-__all__ = ["introspect_mysql", "probe_mysql"]
diff --git a/backend/app/mysql_introspect/introspect.py b/backend/app/mysql_introspect/introspect.py
deleted file mode 100644
index 5786904e..00000000
--- a/backend/app/mysql_introspect/introspect.py
+++ /dev/null
@@ -1,331 +0,0 @@
-"""MySQL / MariaDB introspection producing the common snapshot JSON.
-
-Mirrors the Snowflake introspector's structure: SSRF-guarded DSN parsing with
-pinned IPs (reuses the same `_validated_ip_hosts` guard as PostgreSQL), a
-lazily imported synchronous driver (PyMySQL) run in a worker thread, and
-``information_schema`` queries mapped into the shape every downstream feature
-consumes (relations / columns / constraints / indexes / pk_columns / fk_edges).
-"""
-
-from __future__ import annotations
-
-import asyncio
-import datetime as dt
-import importlib
-from dataclasses import dataclass
-from typing import Any
-from urllib.parse import unquote, urlparse
-
-from app.pg_introspect.column_examples import add_column_examples
-from app.pg_introspect.dsn_guard import _validated_ip_hosts
-from app.sanitize import sanitize_for_storage
-
-_SYSTEM_SCHEMAS = ("mysql", "information_schema", "performance_schema", "sys")
-_DEFAULT_PORT = 3306
-
-
-@dataclass(frozen=True)
-class MysqlDsnConfig:
-    """Validated MySQL connection parameters with a pinned IP host."""
-
-    host: str  # pinned, validated IP
-    server_hostname: str  # original hostname (for TLS/SNI if needed)
-    port: int
-    user: str
-    password: str
-    database: str | None
-
-
-async def _parse_mysql_dsn(dsn: str) -> MysqlDsnConfig:
-    """Parse and SSRF-validate a mysql:// DSN; pin the resolved IP."""
-    parsed = urlparse(dsn)
-    scheme = parsed.scheme.lower().split("+", 1)[0]
-    if scheme not in ("mysql", "mariadb"):
-        raise ValueError("unsupported MySQL DSN scheme")
-    if not parsed.hostname:
-        raise ValueError("MySQL DSN must include a host")
-    if not parsed.username:
-        raise ValueError("MySQL DSN must include a user")
-    port = parsed.port or _DEFAULT_PORT
-    hosts = await _validated_ip_hosts(parsed.hostname, is_hostaddr=False, port=port)
-    database = parsed.path.lstrip("/") or None
-    return MysqlDsnConfig(
-        host=hosts[0],
-        server_hostname=parsed.hostname,
-        port=port,
-        user=unquote(parsed.username),
-        password=unquote(parsed.password or ""),
-        database=database,
-    )
-
-
-def _connect(config: MysqlDsnConfig) -> Any:
-    try:
-        pymysql = importlib.import_module("pymysql")
-    except ImportError as exc:  # pragma: no cover - environment dependent
-        raise RuntimeError(
-            "MySQL support requires the PyMySQL package"
-        ) from exc
-    return pymysql.connect(
-        host=config.host,  # pinned IP (SSRF)
-        port=config.port,
-        user=config.user,
-        password=config.password,
-        database=config.database,
-        connect_timeout=10,
-        read_timeout=30,
-        write_timeout=30,
-    )
-
-
-def _fetch_dicts(cursor: Any, sql: str, params: tuple[object, ...] = ()) -> list[dict]:
-    cursor.execute(sql, params or None)
-    names = [d[0] for d in cursor.description or []]
-    return [dict(zip(names, row)) for row in cursor.fetchall()]
-
-
-def _schema_filter_clause(schema_filter: str | None) -> tuple[str, tuple[object, ...]]:
-    if schema_filter:
-        return "TABLE_SCHEMA = %s", (schema_filter,)
-    placeholders = ", ".join(["%s"] * len(_SYSTEM_SCHEMAS))
-    return f"TABLE_SCHEMA NOT IN ({placeholders})", _SYSTEM_SCHEMAS
-
-
-def rows_to_snapshot(
-    version: str,
-    schema_filter: str | None,
-    tables: list[dict],
-    columns: list[dict],
-    key_usage: list[dict],
-    indexes: list[dict],
-) -> dict[str, Any]:
-    """Pure transformation: information_schema rows → common snapshot JSON."""
-    oid_by_table: dict[tuple[str, str], int] = {}
-    relations: list[dict[str, Any]] = []
-    for i, row in enumerate(tables, start=1):
-        key = (str(row["TABLE_SCHEMA"]), str(row["TABLE_NAME"]))
-        oid_by_table[key] = i
-        relations.append(
-            {
-                "relation_oid": i,
-                "relation_kind": "v" if str(row.get("TABLE_TYPE", "")).upper() == "VIEW" else "r",
-                "schema_name": key[0],
-                "relation_name": key[1],
-                "relation_comment": str(row.get("TABLE_COMMENT") or "") or None,
-            }
-        )
-
-    out_columns: list[dict[str, Any]] = []
-    for row in columns:
-        oid = oid_by_table.get((str(row["TABLE_SCHEMA"]), str(row["TABLE_NAME"])))
-        if oid is None:
-            continue
-        out_columns.append(
-            {
-                "relation_oid": oid,
-                "column_name": str(row["COLUMN_NAME"]),
-                "column_position": int(row["ORDINAL_POSITION"]),
-                "data_type": str(row.get("COLUMN_TYPE") or row.get("DATA_TYPE") or ""),
-                "is_not_null": str(row.get("IS_NULLABLE", "YES")).upper() == "NO",
-                "has_default": row.get("COLUMN_DEFAULT") is not None,
-                "default_expr": (
-                    str(row["COLUMN_DEFAULT"]) if row.get("COLUMN_DEFAULT") is not None else None
-                ),
-                "column_comment": str(row.get("COLUMN_COMMENT") or "") or None,
-            }
-        )
-    pos_by_oid_col = {
-        (c["relation_oid"], c["column_name"]): c["column_position"] for c in out_columns
-    }
-
-    pk_columns: list[dict[str, Any]] = []
-    fk_edges: list[dict[str, Any]] = []
-    constraints: list[dict[str, Any]] = []
-    pk_cols_by_oid: dict[int, list[str]] = {}
-    for row in key_usage:
-        oid = oid_by_table.get((str(row["TABLE_SCHEMA"]), str(row["TABLE_NAME"])))
-        if oid is None:
-            continue
-        col = str(row["COLUMN_NAME"])
-        if str(row.get("CONSTRAINT_NAME")) == "PRIMARY":
-            pk_columns.append(
-                {
-                    "relation_oid": oid,
-                    "column_name": col,
-                    "column_ordinal": int(row.get("ORDINAL_POSITION") or 1),
-                }
-            )
-            pk_cols_by_oid.setdefault(oid, []).append(col)
-        elif row.get("REFERENCED_TABLE_NAME"):
-            parent = oid_by_table.get(
-                (
-                    str(row.get("REFERENCED_TABLE_SCHEMA") or row["TABLE_SCHEMA"]),
-                    str(row["REFERENCED_TABLE_NAME"]),
-                )
-            )
-            if parent is None:
-                continue
-            edge_id = len(fk_edges) + 1
-            fk_edges.append(
-                {
-                    "fk_constraint_oid": 100000 + edge_id,
-                    "fk_constraint_name": str(row.get("CONSTRAINT_NAME") or f"fk_{edge_id}"),
-                    "child_relation_oid": oid,
-                    "parent_relation_oid": parent,
-                    "child_column_name": col,
-                    "parent_column_name": str(row["REFERENCED_COLUMN_NAME"]),
-                    "column_ordinal": int(row.get("ORDINAL_POSITION") or 1),
-                }
-            )
-
-    rel_by_oid = {r["relation_oid"]: r for r in relations}
-    for oid, cols in pk_cols_by_oid.items():
-        rel = rel_by_oid[oid]
-        quoted = ", ".join(f'"{c}"' for c in cols)
-        constraints.append(
-            {
-                "constraint_oid": 200000 + oid,
-                "constraint_name": f"pk_{rel['relation_name']}",
-                "constraint_type": "p",
-                "schema_name": rel["schema_name"],
-                "relation_oid": oid,
-                "relation_name": rel["relation_name"],
-                "constrained_attnums": [pos_by_oid_col.get((oid, c), i + 1) for i, c in enumerate(cols)],
-                "constraint_def": f"PRIMARY KEY ({quoted})",
-            }
-        )
-    for edge in fk_edges:
-        child_rel = rel_by_oid[edge["child_relation_oid"]]
-        parent_rel = rel_by_oid[edge["parent_relation_oid"]]
-        constraints.append(
-            {
-                "constraint_oid": 300000 + edge["fk_constraint_oid"],
-                "constraint_name": edge["fk_constraint_name"],
-                "constraint_type": "f",
-                "schema_name": child_rel["schema_name"],
-                "relation_oid": edge["child_relation_oid"],
-                "relation_name": child_rel["relation_name"],
-                "constrained_attnums": [
-                    pos_by_oid_col.get((edge["child_relation_oid"], edge["child_column_name"]), 1)
-                ],
-                "constraint_def": (
-                    f'FOREIGN KEY ("{edge["child_column_name"]}") REFERENCES '
-                    f'"{parent_rel["schema_name"]}"."{parent_rel["relation_name"]}" '
-                    f'("{edge["parent_column_name"]}")'
-                ),
-            }
-        )
-
-    # group STATISTICS rows into per-index column lists
-    grouped: dict[tuple[str, str, str], list[tuple[int, str, bool]]] = {}
-    for row in indexes:
-        ix_key = (str(row["TABLE_SCHEMA"]), str(row["TABLE_NAME"]), str(row["INDEX_NAME"]))
-        grouped.setdefault(ix_key, []).append(
-            (
-                int(row.get("SEQ_IN_INDEX") or 1),
-                str(row["COLUMN_NAME"]),
-                not bool(int(row.get("NON_UNIQUE") or 0)),
-            )
-        )
-    out_indexes: list[dict[str, Any]] = []
-    for (schema, table, name), ix_cols in sorted(grouped.items()):
-        ix_oid = oid_by_table.get((schema, table))
-        if ix_oid is None:
-            continue
-        ordered = [c for _, c, _ in sorted(ix_cols)]
-        unique = ix_cols[0][2]
-        cols_sql = ", ".join(ordered)
-        out_indexes.append(
-            {
-                "relation_oid": ix_oid,
-                "index_name": name,
-                "is_unique": unique,
-                "is_primary": name == "PRIMARY",
-                "index_def": (
-                    f"CREATE {'UNIQUE ' if unique else ''}INDEX {name} "
-                    f"ON {schema}.{table} ({cols_sql})"
-                ),
-            }
-        )
-
-    snapshot = {
-        "captured_at": dt.datetime.now(dt.timezone.utc).isoformat(),
-        "server_version": version,
-        "source_dialect": "mysql",
-        "schema_filter": schema_filter,
-        "schemas": sorted({r["schema_name"] for r in relations}),
-        "relations": relations,
-        "columns": add_column_examples(out_columns),
-        "constraints": constraints,
-        "indexes": out_indexes,
-        "pk_columns": pk_columns,
-        "fk_edges": fk_edges,
-        "citus_distributed_tables": [],
-    }
-    return sanitize_for_storage(snapshot)  # type: ignore[return-value]
-
-
-def _introspect_sync(config: MysqlDsnConfig, schema_filter: str | None) -> dict[str, Any]:
-    conn = _connect(config)
-    try:
-        cursor = conn.cursor()
-        version_rows = _fetch_dicts(cursor, "SELECT VERSION() AS v")
-        version = str(version_rows[0]["v"]) if version_rows else "unknown"
-        where, params = _schema_filter_clause(schema_filter)
-        tables = _fetch_dicts(
-            cursor,
-            "SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE, TABLE_COMMENT "
-            f"FROM information_schema.TABLES WHERE {where} "
-            "ORDER BY TABLE_SCHEMA, TABLE_NAME",
-            params,
-        )
-        columns = _fetch_dicts(
-            cursor,
-            "SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, ORDINAL_POSITION, "
-            "COLUMN_TYPE, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT, COLUMN_COMMENT "
-            f"FROM information_schema.COLUMNS WHERE {where} "
-            "ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION",
-            params,
-        )
-        key_usage = _fetch_dicts(
-            cursor,
-            "SELECT CONSTRAINT_NAME, TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, "
-            "ORDINAL_POSITION, REFERENCED_TABLE_SCHEMA, REFERENCED_TABLE_NAME, "
-            "REFERENCED_COLUMN_NAME "
-            f"FROM information_schema.KEY_COLUMN_USAGE WHERE {where} "
-            "ORDER BY TABLE_SCHEMA, TABLE_NAME, CONSTRAINT_NAME, ORDINAL_POSITION",
-            params,
-        )
-        indexes = _fetch_dicts(
-            cursor,
-            "SELECT TABLE_SCHEMA, TABLE_NAME, INDEX_NAME, NON_UNIQUE, "
-            "SEQ_IN_INDEX, COLUMN_NAME "
-            f"FROM information_schema.STATISTICS WHERE {where} "
-            "ORDER BY TABLE_SCHEMA, TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX",
-            params,
-        )
-        return rows_to_snapshot(version, schema_filter, tables, columns, key_usage, indexes)
-    finally:
-        conn.close()
-
-
-async def introspect_mysql(dsn: str, schema_filter: str | None) -> dict[str, Any]:
-    """Introspect a MySQL/MariaDB database and return a snapshot JSON."""
-    config = await _parse_mysql_dsn(dsn)
-    return await asyncio.to_thread(_introspect_sync, config, schema_filter)
-
-
-def _probe_sync(config: MysqlDsnConfig) -> str:
-    conn = _connect(config)
-    try:
-        cursor = conn.cursor()
-        rows = _fetch_dicts(cursor, "SELECT VERSION() AS v")
-        return str(rows[0]["v"]) if rows else "unknown"
-    finally:
-        conn.close()
-
-
-async def probe_mysql(dsn: str) -> str:
-    """SSRF-guarded connectivity check: connect and return the server version."""
-    config = await _parse_mysql_dsn(dsn)
-    return await asyncio.to_thread(_probe_sync, config)
diff --git a/backend/app/schemas.py b/backend/app/schemas.py
index d7c6de77..e5751477 100644
--- a/backend/app/schemas.py
+++ b/backend/app/schemas.py
@@ -139,54 +139,6 @@ class WideTablesOut(BaseModel):
     report: dict | None
 
 
-class SchemaStatsOut(BaseModel):
-    """Overview statistics for a schema snapshot."""
-
-    schema_snapshot_uuid: uuid.UUID
-    status: str
-    stats: dict | None
-
-
-class FkCyclesOut(BaseModel):
-    """Circular foreign-key dependency findings for a snapshot."""
-
-    schema_snapshot_uuid: uuid.UUID
-    status: str
-    report: dict | None
-
-
-class SensitiveColumnsOut(BaseModel):
-    """Compliance-scoping inventory of likely-sensitive columns."""
-
-    schema_snapshot_uuid: uuid.UUID
-    status: str
-    report: dict | None
-
-
-class AuditColumnsOut(BaseModel):
-    """Audit-column (created_at/updated_at) convention findings."""
-
-    schema_snapshot_uuid: uuid.UUID
-    status: str
-    report: dict | None
-
-
-class ConstraintInventoryOut(BaseModel):
-    """CHECK-rule inventory and FK delete-action risks for a snapshot."""
-
-    schema_snapshot_uuid: uuid.UUID
-    status: str
-    report: dict | None
-
-
-class IndexRedundancyOut(BaseModel):
-    """Duplicate / prefix-redundant index findings for a snapshot."""
-
-    schema_snapshot_uuid: uuid.UUID
-    status: str
-    report: dict | None
-
-
 class DiagramViewCreateIn(BaseModel):
     """Request body for saving an ERD canvas view."""
 
@@ -282,23 +234,6 @@ class NamingLintOut(BaseModel):
     report: dict | None
 
 
-class DbmlConvertIn(BaseModel):
-    """Request body for converting DBML text into a snapshot."""
-
-    dbml: str = Field(min_length=1, max_length=524_288)
-    include_ddl: bool = True
-    dialect: Literal["postgresql", "snowflake"] = "postgresql"
-
-
-class DbmlConvertOut(BaseModel):
-    """DBML conversion result: snapshot JSON plus optional DDL."""
-
-    snapshot_json: dict
-    ddl: str | None = None
-    tables: int
-    foreign_keys: int
-
-
 class ApiKeyCreateIn(BaseModel):
     """Request body for creating an API key."""
 
diff --git a/backend/app/settings.py b/backend/app/settings.py
index 93903ec6..0d1a7b91 100644
--- a/backend/app/settings.py
+++ b/backend/app/settings.py
@@ -123,15 +123,6 @@ def _load_app_secret_from_file(cls, data: object) -> object:
     llm_model: str | None = None
     llm_timeout_seconds: float = Field(30.0, gt=0.0, le=120.0)
 
-    # Clearfolio reference-document viewer connector (buyer gateway).
-    clearfolio_gateway_url: str | None = None
-    clearfolio_tenant_claims_hmac_secret: str | None = None
-    clearfolio_tenant_id: str = "pg-erd-cloud"
-    clearfolio_permissions: str = (
-        "job:create,job:read,job:retry,viewer:read,artifact-link:create,analytics:read"
-    )
-    clearfolio_timeout_seconds: float = Field(30.0, gt=0.0, le=120.0)
-
     # Allowed JWT signing algorithms for OIDC verification.
     # Comma-separated string (env: OIDC_ALGORITHMS). Default is RS256.
     # NOTE: Do not trust the token header's alg; only accept algorithms from
diff --git a/backend/app/spec/audit_columns.py b/backend/app/spec/audit_columns.py
deleted file mode 100644
index 9340a5b3..00000000
--- a/backend/app/spec/audit_columns.py
+++ /dev/null
@@ -1,88 +0,0 @@
-"""Check audit-column conventions (created_at / updated_at) across tables.
-
-When most of a schema tracks row lifecycle with ``created_at``/``updated_at``
-(or ``*_time``/``*_date`` variants), tables missing them are usually an
-oversight — and the gap surfaces later as "when did this row change?" with no
-answer. Like the naming lint, no convention is imposed: a table is only flagged
-when the schema's *own* majority follows the convention.
-
-Pure and dialect-agnostic.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import Any
-
-INFO = "info"
-
-_CREATED = re.compile(r"^(created?_(at|on|time|date|dt)|create_(time|date|dt)|creation_date|reg(istered)?_(at|dt|date)|insert(ed)?_(at|dt))$")
-_UPDATED = re.compile(r"^(updated?_(at|on|time|date|dt)|update_(time|date|dt)|modified?_(at|on|time|date|dt)|last_modified(_at)?|mod_dt)$")
-
-# Only flag when at least this share of tables already follows the convention.
-_ADOPTION_THRESHOLD = 0.5
-_MIN_TABLES = 4
-
-
-def check_audit_columns(snapshot: dict[str, Any] | None) -> dict[str, Any]:
-    """Flag tables missing the audit columns their schema-mates have."""
-    snapshot = snapshot or {}
-    relations = snapshot.get("relations") or []
-    columns = snapshot.get("columns") or []
-
-    tables = {
-        r.get("relation_oid"): r
-        for r in relations
-        if (r.get("relation_kind") or "r") in ("r", "p")
-    }
-    has_created: set[Any] = set()
-    has_updated: set[Any] = set()
-    for c in columns:
-        oid = c.get("relation_oid")
-        if oid not in tables:
-            continue
-        name = str(c.get("column_name") or "").lower()
-        if _CREATED.match(name):
-            has_created.add(oid)
-        elif _UPDATED.match(name):
-            has_updated.add(oid)
-
-    total = len(tables)
-    created_share = len(has_created) / total if total else 0.0
-    updated_share = len(has_updated) / total if total else 0.0
-
-    items: list[dict[str, Any]] = []
-    if total >= _MIN_TABLES:
-        for oid, rel in tables.items():
-            qname = f"{rel.get('schema_name')}.{rel.get('relation_name')}"
-            missing = []
-            if created_share >= _ADOPTION_THRESHOLD and oid not in has_created:
-                missing.append("created_at")
-            if updated_share >= _ADOPTION_THRESHOLD and oid not in has_updated:
-                missing.append("updated_at")
-            if missing:
-                items.append(
-                    {
-                        "category": "missing_audit_columns",
-                        "severity": INFO,
-                        "table": qname,
-                        "missing": missing,
-                        "detail": (
-                            f"Missing {' & '.join(missing)} while most tables in this "
-                            "schema track them — row lifecycle will be unanswerable."
-                        ),
-                    }
-                )
-
-    items.sort(key=lambda i: i["table"])
-    summary = {
-        "tables": total,
-        "with_created": len(has_created),
-        "with_updated": len(has_updated),
-        "created_adoption": round(created_share, 2),
-        "updated_adoption": round(updated_share, 2),
-        "convention_active": total >= _MIN_TABLES
-        and (created_share >= _ADOPTION_THRESHOLD or updated_share >= _ADOPTION_THRESHOLD),
-        "total": len(items),
-    }
-    return {"items": items, "summary": summary}
diff --git a/backend/app/spec/constraint_inventory.py b/backend/app/spec/constraint_inventory.py
deleted file mode 100644
index 0c47f502..00000000
--- a/backend/app/spec/constraint_inventory.py
+++ /dev/null
@@ -1,94 +0,0 @@
-"""Inventory business rules living in constraints, and flag CASCADE risk.
-
-Reverse engineering isn't just tables and columns -- the *business rules* often
-hide in CHECK constraints, and the operational hazards hide in FK referential
-actions. This inventories both:
-
-* **check_rules** -- every CHECK constraint with its expression: the closest
-  thing a legacy database has to documented invariants.
-* **cascade_deletes** (warning) -- ``ON DELETE CASCADE`` foreign keys: deleting
-  a parent silently deletes children; every operator should know these paths.
-* **set_null_deletes** (info) -- ``ON DELETE SET NULL``: orphaned-but-kept rows.
-
-Pure and dialect-agnostic (PostgreSQL action codes 'c'/'n' plus spelled-out
-variants are both handled).
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-WARNING = "warning"
-INFO = "info"
-
-_CASCADE = {"c", "cascade"}
-_SET_NULL = {"n", "set null", "set_null"}
-
-
-def build_constraint_inventory(snapshot: dict[str, Any] | None) -> dict[str, Any]:
-    """Return CHECK-rule inventory and FK delete-action risk findings."""
-    snapshot = snapshot or {}
-    constraints = snapshot.get("constraints") or []
-
-    check_rules: list[dict[str, Any]] = []
-    cascade_items: list[dict[str, Any]] = []
-
-    for con in constraints:
-        ctype = str(con.get("constraint_type") or "").lower()
-        table = f"{con.get('schema_name')}.{con.get('relation_name')}"
-        name = str(con.get("constraint_name") or "")
-
-        if ctype == "c":
-            expr = con.get("check_expr") or con.get("constraint_def")
-            check_rules.append(
-                {
-                    "table": table,
-                    "constraint": name,
-                    "expression": str(expr or ""),
-                }
-            )
-        elif ctype == "f":
-            on_delete = str(con.get("fk_on_delete") or "").lower()
-            target = (
-                f"{con.get('foreign_schema_name')}.{con.get('foreign_relation_name')}"
-            )
-            if on_delete in _CASCADE:
-                cascade_items.append(
-                    {
-                        "category": "cascade_delete",
-                        "severity": WARNING,
-                        "table": table,
-                        "constraint": name,
-                        "references": target,
-                        "detail": (
-                            f"Deleting a row in {target} silently deletes rows in "
-                            f"{table} (ON DELETE CASCADE via '{name}')."
-                        ),
-                    }
-                )
-            elif on_delete in _SET_NULL:
-                cascade_items.append(
-                    {
-                        "category": "set_null_delete",
-                        "severity": INFO,
-                        "table": table,
-                        "constraint": name,
-                        "references": target,
-                        "detail": (
-                            f"Deleting a row in {target} nulls the reference in "
-                            f"{table} (ON DELETE SET NULL via '{name}') — rows are kept but orphaned."
-                        ),
-                    }
-                )
-
-    check_rules.sort(key=lambda r: (r["table"], r["constraint"]))
-    cascade_items.sort(
-        key=lambda i: (0 if i["severity"] == WARNING else 1, i["table"], i["constraint"])
-    )
-
-    summary = {
-        "check_rules": len(check_rules),
-        "cascade_deletes": sum(1 for i in cascade_items if i["category"] == "cascade_delete"),
-        "set_null_deletes": sum(1 for i in cascade_items if i["category"] == "set_null_delete"),
-    }
-    return {"check_rules": check_rules, "delete_actions": cascade_items, "summary": summary}
diff --git a/backend/app/spec/dbml_import.py b/backend/app/spec/dbml_import.py
deleted file mode 100644
index b93454a9..00000000
--- a/backend/app/spec/dbml_import.py
+++ /dev/null
@@ -1,323 +0,0 @@
-"""Parse DBML (database markup language) into the common snapshot JSON.
-
-Design-first workflow: write DBML (the dbdiagram.io/dbdocs dialect), convert it
-to the same snapshot shape introspection produces, and every downstream feature
-works on it unchanged — DDL export, migration generation, analyzers, the ERD.
-
-Supported subset (the parts real DBML files actually use):
-
-* ``Table [schema.]name { ... }`` with columns ``name type [settings]``
-* column settings: ``pk``/``primary key``, ``not null``, ``unique``, ``default:``,
-  ``note:``, inline ``ref: > other.col`` (also ``<`` and ``-``)
-* standalone ``Ref: a.col > b.col`` / ``Ref name { a.col > b.col }``
-* quoted identifiers ``"My Table"``; comments ``//``; multi-word types
-
-Ignored (parsed over, not errors): ``Project``/``Enum``/``TableGroup``/``Note``
-blocks, ``indexes`` blocks, header colors. ponytail: line-oriented parser, not a
-grammar — good for the 95% of DBML in the wild; a hostile file degrades to
-skipped lines, never an exception.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import Any
-
-_COLUMN_RE = re.compile(
-    r"^(?:\"(?P<qname>[^\"]+)\"|(?P<name>\w+))\s+"
-    r"(?P<type>[\w]+(?:\([^)]*\))?(?:\[\])?)"
-    r"(?:\s*\[(?P<settings>.*)\])?\s*$"
-)
-# a dotted path whose segments may be quoted (quotes can contain spaces)
-_PATH = r'(?:"[^"]+"|\w+)(?:\.(?:"[^"]+"|\w+))*'
-_REF_RE = re.compile(
-    r"ref\s*(?:\w+\s*)?:?\s*"
-    rf"(?P<from>{_PATH})\s*(?P<op>[<>-])\s*(?P<to>{_PATH})",
-    re.IGNORECASE,
-)
-_INLINE_REF_RE = re.compile(rf"ref:\s*(?P<op>[<>-])\s*(?P<to>{_PATH})", re.IGNORECASE)
-_PATH_SEGMENT_RE = re.compile(r'"[^"]+"|[^.]+')
-
-
-def _consume_table_name(line: str, start: int) -> tuple[str, int] | None:
-    """Return the table identifier and the offset after it, using only linear scans."""
-    if start >= len(line):
-        return None
-    if line[start] == '"':
-        end = line.find('"', start + 1)
-        if end <= start + 1:
-            return None
-        return line[start + 1 : end], end + 1
-
-    pos = start
-    while pos < len(line) and (line[pos].isalnum() or line[pos] in "_."):
-        pos += 1
-    if pos == start:
-        return None
-
-    raw = line[start:pos]
-    parts = raw.split(".")
-    if any(part == "" for part in parts):
-        return None
-    return raw, pos
-
-
-def _table_header_tail_ok(tail: str) -> bool:
-    """Validate what may follow a ``Table <name>`` header on the same line.
-
-    Grammar (whitespace-insensitive): an optional ``as <alias>`` rename followed
-    by an optional opening ``{`` (dbdiagram also allows the brace on the next
-    line). Implemented with plain string scanning rather than a regex so there
-    is no backtracking.
-    """
-    rest = tail.strip()
-    if not rest:
-        return True
-    if rest[:2].lower() == "as" and (len(rest) == 2 or rest[2].isspace()):
-        rest = rest[2:].lstrip()
-        alias_len = 0
-        while alias_len < len(rest) and (
-            rest[alias_len].isalnum() or rest[alias_len] == "_"
-        ):
-            alias_len += 1
-        if alias_len == 0:
-            return False
-        rest = rest[alias_len:].lstrip()
-    return rest in ("", "{")
-
-
-def _parse_table_header(line: str) -> tuple[str, str] | None:
-    """Parse ``Table [schema.]name`` headers without regex backtracking."""
-    if len(line) < 6 or line[:5].lower() != "table" or not line[5].isspace():
-        return None
-    pos = 5
-    while pos < len(line) and line[pos].isspace():
-        pos += 1
-    consumed = _consume_table_name(line, pos)
-    if consumed is None:
-        return None
-    raw_name, pos = consumed
-    if not _table_header_tail_ok(line[pos:]):
-        return None
-    return _split_table_name(raw_name)
-
-
-def _split_table_name(raw: str) -> tuple[str, str]:
-    raw = raw.strip().strip('"')
-    if "." in raw:
-        schema, _, name = raw.partition(".")
-        return schema.strip('"'), name.strip('"')
-    return "public", raw
-
-
-def _split_col_ref(raw: str) -> tuple[str, str, str]:
-    """'schema.table.col' | 'table.col' -> (schema, table, col).
-
-    Splits on dots *outside* quotes so '"Order Items".account_id' works.
-    """
-    parts = [p.strip('"') for p in _PATH_SEGMENT_RE.findall(raw.strip())]
-    if len(parts) >= 3:
-        return parts[0], parts[1], parts[2]
-    if len(parts) == 2:
-        return "public", parts[0], parts[1]
-    return "public", "", parts[0]
-
-
-def parse_dbml(text: str) -> dict[str, Any]:
-    """Parse DBML text into snapshot JSON (relations/columns/pk_columns/fk_edges)."""
-    relations: list[dict[str, Any]] = []
-    columns: list[dict[str, Any]] = []
-    pk_columns: list[dict[str, Any]] = []
-    fk_specs: list[tuple[str, str, str, str, str, str]] = []  # child s/t/c, parent s/t/c
-
-    oid_by_table: dict[tuple[str, str], int] = {}
-    next_oid = 1
-    current: tuple[str, str] | None = None
-    in_ignored_block = 0
-    in_indexes = False
-
-    for raw_line in text.splitlines():
-        # ReDoS guard: no legitimate DBML line approaches this length; capping
-        # input size per regex call bounds worst-case backtracking to O(1).
-        if len(raw_line) > 4096:
-            continue
-        line = raw_line.split("//", 1)[0].strip()
-        if not line:
-            continue
-
-        # ignored blocks (Project / Enum / TableGroup / Note) — track braces
-        if in_ignored_block:
-            in_ignored_block += line.count("{") - line.count("}")
-            continue
-        if re.match(r"^(project|enum|tablegroup|note)\b", line, re.IGNORECASE):
-            in_ignored_block = line.count("{") - line.count("}")
-            if in_ignored_block <= 0 and "{" not in line:
-                in_ignored_block = 1  # block opens on a following line
-            continue
-
-        table_name = _parse_table_header(line)
-        if table_name is not None:
-            schema, name = table_name
-            current = (schema, name)
-            if current not in oid_by_table:
-                oid_by_table[current] = next_oid
-                relations.append(
-                    {
-                        "relation_oid": next_oid,
-                        "relation_kind": "r",
-                        "schema_name": schema,
-                        "relation_name": name,
-                        "relation_comment": None,
-                    }
-                )
-                next_oid += 1
-            continue
-
-        if line.startswith("}"):
-            current = None
-            in_indexes = False
-            continue
-
-        # standalone Ref (works inside or outside a table body)
-        if re.match(r"^ref\b", line, re.IGNORECASE):
-            rm = _REF_RE.search(line)
-            if rm:
-                fs, ft, fc = _split_col_ref(rm.group("from"))
-                ts, tt, tc = _split_col_ref(rm.group("to"))
-                if rm.group("op") == "<":  # a < b means b references a
-                    fs, ft, fc, ts, tt, tc = ts, tt, tc, fs, ft, fc
-                if ft and tt:
-                    fk_specs.append((fs, ft, fc, ts, tt, tc))
-            continue
-
-        if current is None:
-            continue
-        if re.match(r"^indexes\s*\{", line, re.IGNORECASE):
-            in_indexes = True
-            continue
-        if in_indexes:
-            if "}" in line:
-                in_indexes = False
-            continue
-
-        cm = _COLUMN_RE.match(line)
-        if not cm:
-            continue
-        col_name = (cm.group("qname") or cm.group("name")).strip('"')
-        settings = (cm.group("settings") or "").lower()
-        oid = oid_by_table[current]
-        is_pk = bool(re.search(r"\bpk\b|primary\s+key", settings))
-        columns.append(
-            {
-                "relation_oid": oid,
-                "column_name": col_name,
-                "column_position": sum(1 for c in columns if c["relation_oid"] == oid) + 1,
-                "data_type": cm.group("type"),
-                "is_not_null": is_pk or "not null" in settings,
-                "has_default": "default:" in settings,
-                "default_expr": None,
-                "column_comment": None,
-            }
-        )
-        if is_pk:
-            pk_columns.append(
-                {"relation_oid": oid, "column_name": col_name, "column_ordinal": len(pk_columns) + 1}
-            )
-        im = _INLINE_REF_RE.search(cm.group("settings") or "")
-        if im:
-            ts, tt, tc = _split_col_ref(im.group("to"))
-            if im.group("op") == "<":
-                # inverse inline ref: the other table references this column
-                fk_specs.append((ts, tt, tc, current[0], current[1], col_name))
-            else:
-                fk_specs.append((current[0], current[1], col_name, ts, tt, tc))
-
-    fk_edges: list[dict[str, Any]] = []
-    for i, (cs, ct, cc, ps, pt, pc) in enumerate(fk_specs, start=1):
-        child = oid_by_table.get((cs, ct))
-        parent = oid_by_table.get((ps, pt))
-        if child is None or parent is None:
-            continue  # ref to a table not defined in this document
-        fk_edges.append(
-            {
-                "fk_constraint_oid": 100000 + i,
-                "fk_constraint_name": f"fk_{ct}_{cc}",
-                "child_relation_oid": child,
-                "parent_relation_oid": parent,
-                "child_column_name": cc,
-                "parent_column_name": pc,
-                "column_ordinal": 1,
-            }
-        )
-
-    constraints = _build_constraints(relations, columns, pk_columns, fk_edges)
-
-    return {
-        "source": "dbml",
-        "schemas": sorted({r["schema_name"] for r in relations}),
-        "relations": relations,
-        "columns": columns,
-        "constraints": constraints,
-        "indexes": [],
-        "pk_columns": pk_columns,
-        "fk_edges": fk_edges,
-        "citus_distributed_tables": [],
-    }
-
-
-def _build_constraints(
-    relations: list[dict[str, Any]],
-    columns: list[dict[str, Any]],
-    pk_columns: list[dict[str, Any]],
-    fk_edges: list[dict[str, Any]],
-) -> list[dict[str, Any]]:
-    """Derive the ``constraints`` array (what DDL export renders) from parsed parts."""
-    rel_by_oid = {r["relation_oid"]: r for r in relations}
-    pos_by_oid_col: dict[tuple[int, str], int] = {
-        (c["relation_oid"], c["column_name"]): c["column_position"] for c in columns
-    }
-    constraints: list[dict[str, Any]] = []
-
-    pk_cols_by_oid: dict[int, list[str]] = {}
-    for pk in pk_columns:
-        pk_cols_by_oid.setdefault(pk["relation_oid"], []).append(pk["column_name"])
-    for oid, cols in pk_cols_by_oid.items():
-        rel = rel_by_oid[oid]
-        quoted = ", ".join(f'"{c}"' for c in cols)
-        constraints.append(
-            {
-                "constraint_oid": 200000 + oid,
-                "constraint_name": f"pk_{rel['relation_name']}",
-                "constraint_type": "p",
-                "schema_name": rel["schema_name"],
-                "relation_oid": oid,
-                "relation_name": rel["relation_name"],
-                "constrained_attnums": [pos_by_oid_col[(oid, c)] for c in cols],
-                "constraint_def": f"PRIMARY KEY ({quoted})",
-            }
-        )
-
-    for edge in fk_edges:
-        child = rel_by_oid[edge["child_relation_oid"]]
-        parent = rel_by_oid[edge["parent_relation_oid"]]
-        constraints.append(
-            {
-                "constraint_oid": 300000 + edge["fk_constraint_oid"],
-                "constraint_name": edge["fk_constraint_name"],
-                "constraint_type": "f",
-                "schema_name": child["schema_name"],
-                "relation_oid": edge["child_relation_oid"],
-                "relation_name": child["relation_name"],
-                "constrained_attnums": [
-                    pos_by_oid_col.get(
-                        (edge["child_relation_oid"], edge["child_column_name"]), 1
-                    )
-                ],
-                "constraint_def": (
-                    f'FOREIGN KEY ("{edge["child_column_name"]}") REFERENCES '
-                    f'"{parent["schema_name"]}"."{parent["relation_name"]}" '
-                    f'("{edge["parent_column_name"]}")'
-                ),
-            }
-        )
-    return constraints
diff --git a/backend/app/spec/fk_cycles.py b/backend/app/spec/fk_cycles.py
deleted file mode 100644
index 03788598..00000000
--- a/backend/app/spec/fk_cycles.py
+++ /dev/null
@@ -1,129 +0,0 @@
-"""Detect circular foreign-key dependencies in a snapshot.
-
-A cycle in the FK graph (A → B → … → A) means there's no order in which the
-tables can be created, dropped, or bulk-loaded without deferring constraints --
-a real migration hazard. Self-references (``employee.manager_id → employee``)
-are a normal, benign special case and are reported separately.
-
-Pure and dialect-agnostic. Uses an iterative Tarjan SCC so a deep FK chain can't
-blow the recursion limit.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-WARNING = "warning"
-INFO = "info"
-
-
-def _sccs(nodes: list[str], adj: dict[str, set[str]]) -> list[list[str]]:
-    """Tarjan's strongly-connected components (iterative)."""
-    index: dict[str, int] = {}
-    low: dict[str, int] = {}
-    on_stack: set[str] = set()
-    stack: list[str] = []
-    result: list[list[str]] = []
-    counter = 0
-
-    for root in nodes:
-        if root in index:
-            continue
-        index[root] = low[root] = counter
-        counter += 1
-        stack.append(root)
-        on_stack.add(root)
-        work = [(root, iter(sorted(adj.get(root, set()))))]
-        while work:
-            v, it = work[-1]
-            pushed = False
-            for w in it:
-                if w not in index:
-                    index[w] = low[w] = counter
-                    counter += 1
-                    stack.append(w)
-                    on_stack.add(w)
-                    work.append((w, iter(sorted(adj.get(w, set())))))
-                    pushed = True
-                    break
-                if w in on_stack:
-                    low[v] = min(low[v], index[w])
-            if pushed:
-                continue
-            if low[v] == index[v]:
-                comp = []
-                while True:
-                    w = stack.pop()
-                    on_stack.discard(w)
-                    comp.append(w)
-                    if w == v:
-                        break
-                result.append(comp)
-            work.pop()
-            if work:
-                low[work[-1][0]] = min(low[work[-1][0]], low[v])
-    return result
-
-
-def detect_fk_cycles(snapshot: dict[str, Any] | None) -> dict[str, Any]:
-    """Return circular-FK findings (multi-table cycles + self-references)."""
-    snapshot = snapshot or {}
-    relations = snapshot.get("relations") or []
-    fk_edges = snapshot.get("fk_edges") or []
-
-    def _qname(oid: Any) -> str | None:
-        rel = rel_by_oid.get(oid)
-        if rel is None:
-            return None
-        return f"{rel.get('schema_name')}.{rel.get('relation_name')}"
-
-    rel_by_oid = {r.get("relation_oid"): r for r in relations}
-
-    adj: dict[str, set[str]] = {}
-    nodes: set[str] = set()
-    self_refs: set[str] = set()
-    for edge in fk_edges:
-        child = _qname(edge.get("child_relation_oid"))
-        parent = _qname(edge.get("parent_relation_oid"))
-        if child is None or parent is None:
-            continue
-        nodes.add(child)
-        nodes.add(parent)
-        if child == parent:
-            self_refs.add(child)
-        else:
-            adj.setdefault(child, set()).add(parent)
-
-    items: list[dict[str, Any]] = []
-    for comp in _sccs(sorted(nodes), adj):
-        if len(comp) >= 2:
-            tables = sorted(comp)
-            items.append(
-                {
-                    "category": "circular_dependency",
-                    "severity": WARNING,
-                    "tables": tables,
-                    "detail": (
-                        "Circular foreign-key dependency: "
-                        + " → ".join(tables)
-                        + " — no create/drop/load order works without deferring constraints."
-                    ),
-                }
-            )
-    for table in sorted(self_refs):
-        items.append(
-            {
-                "category": "self_reference",
-                "severity": INFO,
-                "tables": [table],
-                "detail": f"{table} references itself (hierarchical/tree) — usually fine; load roots first.",
-            }
-        )
-
-    items.sort(key=lambda i: (0 if i["severity"] == WARNING else 1, i["tables"]))
-    summary = {
-        "circular_dependencies": sum(1 for i in items if i["category"] == "circular_dependency"),
-        "self_references": len(self_refs),
-        "total": len(items),
-    }
-    return {"items": items, "summary": summary}
diff --git a/backend/app/spec/index_redundancy.py b/backend/app/spec/index_redundancy.py
deleted file mode 100644
index 14d944ea..00000000
--- a/backend/app/spec/index_redundancy.py
+++ /dev/null
@@ -1,100 +0,0 @@
-"""Detect redundant (prefix-shadowed) and duplicate indexes.
-
-Every index costs write amplification and storage on each INSERT/UPDATE. An
-index on ``(a)`` is *redundant* when another index on the same table starts
-with ``(a, ...)`` -- the wider index already serves those scans. Two indexes
-over the identical column list are *duplicates*. Both are safe wins to drop.
-
-Pure and dialect-agnostic. Column lists come from a best-effort parse of
-``index_def``; expression/partial indexes that don't parse are skipped rather
-than guessed (ponytail: false negatives over false positives -- dropping an
-index is cheap to re-do, a wrong "drop this" suggestion is not).
-"""
-
-from __future__ import annotations
-
-import re
-from typing import Any
-
-WARNING = "warning"
-INFO = "info"
-
-
-def _index_columns(index_def: object) -> list[str]:
-    """Best-effort ordered column list from an index definition."""
-    text = str(index_def or "")
-    if " where " in text.lower():
-        return []  # partial index: not comparable
-    match = re.search(r"\(([^()]*)\)", text)
-    if not match:
-        return []
-    cols: list[str] = []
-    for part in match.group(1).split(","):
-        token = part.strip().strip('"').split()
-        if not token or "(" in part:
-            return []  # expression index: not comparable
-        cols.append(token[0].strip('"').lower())
-    return cols
-
-
-def detect_index_redundancy(snapshot: dict[str, Any] | None) -> dict[str, Any]:
-    """Return duplicate and prefix-shadowed indexes, per table."""
-    snapshot = snapshot or {}
-    relations = snapshot.get("relations") or []
-    indexes = snapshot.get("indexes") or []
-    rel_by_oid = {r.get("relation_oid"): r for r in relations}
-
-    by_table: dict[Any, list[tuple[str, tuple[str, ...], bool]]] = {}
-    for idx in indexes:
-        oid = idx.get("relation_oid") or idx.get("table_oid")
-        cols = tuple(_index_columns(idx.get("index_def")))
-        if not cols:
-            continue
-        name = str(idx.get("index_name") or "")
-        unique = bool(idx.get("is_unique") or idx.get("is_primary"))
-        by_table.setdefault(oid, []).append((name, cols, unique))
-
-    items: list[dict[str, Any]] = []
-    for oid, idx_list in by_table.items():
-        rel = rel_by_oid.get(oid) or {}
-        table = f"{rel.get('schema_name')}.{rel.get('relation_name')}"
-        for i, (name_a, cols_a, unique_a) in enumerate(idx_list):
-            for name_b, cols_b, unique_b in idx_list[i + 1:]:
-                if cols_a == cols_b:
-                    # exact duplicate: suggest dropping the non-unique one
-                    drop = name_b if unique_a and not unique_b else name_a if unique_b and not unique_a else name_b
-                    items.append(
-                        {
-                            "category": "duplicate_index", "severity": WARNING,
-                            "table": table, "index": drop,
-                            "kept": name_a if drop == name_b else name_b,
-                            "columns": list(cols_a),
-                            "detail": f"'{drop}' duplicates '{name_a if drop == name_b else name_b}' on ({', '.join(cols_a)}) — drop it.",
-                        }
-                    )
-                    continue
-                for shorter, longer, s_name, l_name, s_unique in (
-                    (cols_a, cols_b, name_a, name_b, unique_a),
-                    (cols_b, cols_a, name_b, name_a, unique_b),
-                ):
-                    if longer[: len(shorter)] == shorter:
-                        if s_unique:
-                            break  # unique index enforces a constraint; never suggest dropping
-                        items.append(
-                            {
-                                "category": "prefix_redundant_index", "severity": INFO,
-                                "table": table, "index": s_name,
-                                "kept": l_name,
-                                "columns": list(shorter),
-                                "detail": f"'{s_name}' on ({', '.join(shorter)}) is a prefix of '{l_name}' on ({', '.join(longer)}) — likely droppable.",
-                            }
-                        )
-                        break
-
-    items.sort(key=lambda i: (0 if i["severity"] == WARNING else 1, i["table"], i["index"]))
-    summary = {
-        "duplicates": sum(1 for i in items if i["category"] == "duplicate_index"),
-        "prefix_redundant": sum(1 for i in items if i["category"] == "prefix_redundant_index"),
-        "total": len(items),
-    }
-    return {"items": items, "summary": summary}
diff --git a/backend/app/spec/orm_codegen.py b/backend/app/spec/orm_codegen.py
deleted file mode 100644
index a6ddc915..00000000
--- a/backend/app/spec/orm_codegen.py
+++ /dev/null
@@ -1,307 +0,0 @@
-"""Generate ORM model code (SQLAlchemy 2.0 / Prisma) from a snapshot.
-
-Forward engineering all the way to application code: reverse-engineer a legacy
-database, then hand developers ready-to-edit ORM models instead of making them
-retype every table. Most diagram tools stop at DDL — this is a differentiator
-(see docs/erd-tool-feature-research.md).
-
-Pure and dialect-agnostic. Type mapping is best-effort: unmapped SQL types fall
-back to ``str``/``String`` with the original type kept in a comment, so the
-output always imports/parses.
-"""
-
-from __future__ import annotations
-
-import json
-import keyword
-import re
-from typing import Any
-
-_PY_TYPES: list[tuple[re.Pattern[str], str]] = [
-    (re.compile(r"^(big)?serial|^(small|big)?int|^integer"), "int"),
-    (re.compile(r"^bool"), "bool"),
-    (re.compile(r"^(timestamp|datetime)"), "dt.datetime"),
-    (re.compile(r"^date$"), "dt.date"),
-    (re.compile(r"^time($|\()"), "dt.time"),
-    (re.compile(r"^(numeric|decimal)"), "Decimal"),
-    (re.compile(r"^(real|float|double)"), "float"),
-    (re.compile(r"^uuid"), "uuid.UUID"),
-    (re.compile(r"^(json|jsonb)"), "dict"),
-    (re.compile(r"^bytea|^(var)?binary|^blob"), "bytes"),
-    (re.compile(r"^(text|(var)?char|character|enum)"), "str"),
-]
-
-_PRISMA_TYPES: list[tuple[re.Pattern[str], str]] = [
-    (re.compile(r"^bigserial|^bigint"), "BigInt"),
-    (re.compile(r"^serial|^(small)?int|^integer"), "Int"),
-    (re.compile(r"^bool"), "Boolean"),
-    (re.compile(r"^(timestamp|datetime|date$|time($|\())"), "DateTime"),
-    (re.compile(r"^(numeric|decimal)"), "Decimal"),
-    (re.compile(r"^(real|float|double)"), "Float"),
-    (re.compile(r"^(json|jsonb)"), "Json"),
-    (re.compile(r"^bytea|^(var)?binary|^blob"), "Bytes"),
-]
-
-
-def _map_type(data_type: str, table: list[tuple[re.Pattern[str], str]], default: str) -> str:
-    lowered = data_type.strip().lower()
-    for pattern, mapped in table:
-        if pattern.search(lowered):
-            return mapped
-    return default
-
-
-def _snake_name(value: object, fallback: str) -> str:
-    name = re.sub(r"(?<=[a-z0-9])(?=[A-Z])", "_", str(value or ""))
-    name = re.sub(r"[^0-9a-zA-Z]+", "_", name).strip("_").lower()
-    name = name or fallback
-    if name[0].isdigit():
-        name = f"{fallback}_{name}"
-    if keyword.iskeyword(name):
-        name = f"{name}_"
-    return name
-
-
-def _class_name(table_name: str) -> str:
-    parts = re.split(r"[^0-9a-zA-Z]+", table_name)
-    name = "".join(p[:1].upper() + p[1:] for p in parts if p)
-    if not name or name[0].isdigit():
-        name = f"Table{name}"
-    return f"{name}Model" if keyword.iskeyword(name) else name
-
-
-def _column_names(cols: list[dict[str, Any]]) -> dict[str, str]:
-    return {str(col.get("column_name")): _snake_name(col.get("column_name"), "column") for col in cols}
-
-
-def _index(snapshot: dict[str, Any] | None) -> dict[str, Any]:
-    snapshot = snapshot or {}
-    relations = [
-        r for r in snapshot.get("relations") or []
-        if (r.get("relation_kind") or "r") in ("r", "p")
-    ]
-    cols_by_oid: dict[Any, list[dict[str, Any]]] = {}
-    for c in snapshot.get("columns") or []:
-        cols_by_oid.setdefault(c.get("relation_oid"), []).append(c)
-    for cols in cols_by_oid.values():
-        cols.sort(key=lambda c: c.get("column_position") or 0)
-    pk_by_oid: dict[Any, set[str]] = {}
-    for pk in snapshot.get("pk_columns") or []:
-        pk_by_oid.setdefault(pk.get("relation_oid"), set()).add(str(pk.get("column_name")))
-    fk_by_child: dict[tuple[Any, str], dict[str, Any]] = {}
-    for e in snapshot.get("fk_edges") or []:
-        fk_by_child[(e.get("child_relation_oid"), str(e.get("child_column_name")))] = e
-    rel_by_oid = {r.get("relation_oid"): r for r in relations}
-    return {
-        "relations": relations,
-        "cols_by_oid": cols_by_oid,
-        "pk_by_oid": pk_by_oid,
-        "fk_by_child": fk_by_child,
-        "rel_by_oid": rel_by_oid,
-    }
-
-
-def generate_sqlalchemy_models(snapshot: dict[str, Any] | None) -> str:
-    """Render SQLAlchemy 2.0 (Mapped/mapped_column) models."""
-    ix = _index(snapshot)
-    lines = [
-        "# Generated by pg-erd-cloud — SQLAlchemy 2.0 models (edit freely)",
-        "from __future__ import annotations",
-        "",
-        "import datetime as dt",
-        "import uuid",
-        "from decimal import Decimal",
-        "",
-        "from sqlalchemy import ForeignKey",
-        "from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column",
-        "",
-        "",
-        "class Base(DeclarativeBase):",
-        "    pass",
-    ]
-    for rel in ix["relations"]:
-        oid = rel.get("relation_oid")
-        table = str(rel.get("relation_name"))
-        schema = str(rel.get("schema_name"))
-        lines += ["", "", f"class {_class_name(table)}(Base):"]
-        if rel.get("relation_comment"):
-            lines.append(f"    {str(rel['relation_comment'])!r}")
-            lines.append("")
-        lines.append(f"    __tablename__ = {table!r}")
-        if schema and schema != "public":
-            lines.append(f"    __table_args__ = {{'schema': {schema!r}}}")
-        cols = ix["cols_by_oid"].get(oid, [])
-        col_names = _column_names(cols)
-        if not cols:
-            lines.append("    pass")
-            continue
-        for col in cols:
-            name = str(col.get("column_name"))
-            attr = col_names[name]
-            raw_type = str(col.get("data_type") or "")
-            py_type = _map_type(raw_type, _PY_TYPES, "str")
-            not_null = bool(col.get("is_not_null"))
-            annotated = py_type if not_null else f"{py_type} | None"
-            args = [repr(name)] if attr != name else []
-            fk = ix["fk_by_child"].get((oid, name))
-            if fk is not None:
-                parent = ix["rel_by_oid"].get(fk.get("parent_relation_oid"))
-                if parent is not None:
-                    target = f'{parent.get("schema_name")}.{parent.get("relation_name")}.{fk.get("parent_column_name")}'
-                    if parent.get("schema_name") == "public":
-                        target = f'{parent.get("relation_name")}.{fk.get("parent_column_name")}'
-                    args.append(f"ForeignKey({target!r})")
-            if name in ix["pk_by_oid"].get(oid, set()):
-                args.append("primary_key=True")
-            comment = "" if _map_type(raw_type, _PY_TYPES, "?") != "?" else f"  # type: {raw_type}"
-            call = f"mapped_column({', '.join(args)})" if args else "mapped_column()"
-            lines.append(f"    {attr}: Mapped[{annotated}] = {call}{comment}")
-    return "\n".join(lines) + "\n"
-
-
-def generate_prisma_schema(snapshot: dict[str, Any] | None) -> str:
-    """Render a Prisma schema (models with @id/@map; relations as field pairs)."""
-    ix = _index(snapshot)
-    lines = [
-        "// Generated by pg-erd-cloud — Prisma schema (edit freely)",
-        'datasource db {',
-        '  provider = "postgresql"',
-        '  url      = env("DATABASE_URL")',
-        '}',
-    ]
-    # child fk list per parent for reverse relation fields
-    children_of: dict[Any, list[dict[str, Any]]] = {}
-    for (child_oid, _), e in ix["fk_by_child"].items():
-        children_of.setdefault(e.get("parent_relation_oid"), []).append(e)
-
-    for rel in ix["relations"]:
-        oid = rel.get("relation_oid")
-        table = str(rel.get("relation_name"))
-        model = _class_name(table)
-        lines += ["", f"model {model} {{"]
-        cols = ix["cols_by_oid"].get(oid, [])
-        col_names = _column_names(cols)
-        pk_cols = ix["pk_by_oid"].get(oid, set())
-        for col in cols:
-            name = str(col.get("column_name"))
-            field_name = col_names[name]
-            raw_type = str(col.get("data_type") or "")
-            p_type = _map_type(raw_type, _PRISMA_TYPES, "String")
-            optional = "" if col.get("is_not_null") else "?"
-            attrs = []
-            if name in pk_cols and len(pk_cols) == 1:
-                attrs.append("@id")
-            if field_name != name:
-                attrs.append(f"@map({json.dumps(name)})")
-            comment = "" if _map_type(raw_type, _PRISMA_TYPES, "?") != "?" and p_type != "String" or raw_type.lower().startswith(("text", "varchar", "char")) else f" // {raw_type}"
-            lines.append(f"  {field_name} {p_type}{optional}{' ' + ' '.join(attrs) if attrs else ''}{comment}")
-        # relation fields
-        for (child_oid, child_col), e in ix["fk_by_child"].items():
-            if child_oid != oid:
-                continue
-            parent = ix["rel_by_oid"].get(e.get("parent_relation_oid"))
-            if parent is None:
-                continue
-            pmodel = _class_name(str(parent.get("relation_name")))
-            child_field = col_names.get(child_col, _snake_name(child_col, "column"))
-            parent_cols = ix["cols_by_oid"].get(e.get("parent_relation_oid"), [])
-            parent_field = _column_names(parent_cols).get(str(e.get("parent_column_name")), _snake_name(e.get("parent_column_name"), "column"))
-            field = re.sub(r"_id$", "", child_field) or _snake_name(pmodel, "relation")
-            lines.append(
-                f"  {field} {pmodel} @relation(fields: [{child_field}], references: [{parent_field}])"
-            )
-        for e in children_of.get(oid, []):
-            child = ix["rel_by_oid"].get(e.get("child_relation_oid"))
-            if child is None:
-                continue
-            cmodel = _class_name(str(child.get("relation_name")))
-            lines.append(f"  {cmodel[0].lower() + cmodel[1:]}s {cmodel}[]")
-        if len(pk_cols) > 1:
-            ordered = [col_names[str(c.get("column_name"))] for c in cols if str(c.get("column_name")) in pk_cols]
-            lines.append(f"  @@id([{', '.join(ordered)}])")
-        lines.append(f"  @@map({json.dumps(table)})")
-        lines.append("}")
-    return "\n".join(lines) + "\n"
-
-
-_TS_TYPES: list[tuple[re.Pattern[str], str]] = [
-    (re.compile(r"^(big)?serial|^(small|big)?int|^integer|^(real|float|double|numeric|decimal)"), "number"),
-    (re.compile(r"^bool"), "boolean"),
-    (re.compile(r"^(timestamp|datetime|date$|time($|\())"), "Date"),
-    (re.compile(r"^(json|jsonb)"), "object"),
-    (re.compile(r"^bytea|^(var)?binary|^blob"), "Buffer"),
-]
-
-
-def generate_typeorm_entities(snapshot: dict[str, Any] | None) -> str:
-    """Render TypeORM entity classes (TypeScript decorators)."""
-    ix = _index(snapshot)
-    lines = [
-        "// Generated by pg-erd-cloud — TypeORM entities (edit freely)",
-        "import {",
-        "  Column,",
-        "  Entity,",
-        "  JoinColumn,",
-        "  ManyToOne,",
-        "  OneToMany,",
-        "  PrimaryColumn,",
-        "} from 'typeorm';",
-    ]
-    # reverse-relation index: parent oid -> child fk edges
-    children_of: dict[Any, list[dict[str, Any]]] = {}
-    for (child_oid, _), e in ix["fk_by_child"].items():
-        children_of.setdefault(e.get("parent_relation_oid"), []).append(e)
-
-    for rel in ix["relations"]:
-        oid = rel.get("relation_oid")
-        table = str(rel.get("relation_name"))
-        schema = str(rel.get("schema_name"))
-        cls = _class_name(table)
-        entity_args = json.dumps(table) if schema == "public" else f"{{ name: {json.dumps(table)}, schema: {json.dumps(schema)} }}"
-        lines += ["", f"@Entity({entity_args})", f"export class {cls} {{"]
-        cols = ix["cols_by_oid"].get(oid, [])
-        col_names = _column_names(cols)
-        for col in cols:
-            name = str(col.get("column_name"))
-            field_name = col_names[name]
-            raw_type = str(col.get("data_type") or "")
-            ts_type = _map_type(raw_type, _TS_TYPES, "string")
-            nullable = not col.get("is_not_null")
-            is_pk = name in ix["pk_by_oid"].get(oid, set())
-            options = []
-            if field_name != name:
-                options.append(f"name: {json.dumps(name)}")
-            if nullable and not is_pk:
-                options.append("nullable: true")
-            decorator = "@PrimaryColumn" if is_pk else "@Column"
-            decorator = f"{decorator}({{{', '.join(options)}}})" if options else f"{decorator}()"
-            comment = "" if _map_type(raw_type, _TS_TYPES, "?") != "?" and ts_type != "string" or raw_type.lower().startswith(("text", "varchar", "char")) else f" // {raw_type}"
-            lines.append(f"  {decorator}")
-            lines.append(f"  {field_name}{'?' if nullable else '!'}: {ts_type}{' | null' if nullable else ''};{comment}")
-            lines.append("")
-        for (child_oid, child_col), e in ix["fk_by_child"].items():
-            if child_oid != oid:
-                continue
-            parent = ix["rel_by_oid"].get(e.get("parent_relation_oid"))
-            if parent is None:
-                continue
-            pcls = _class_name(str(parent.get("relation_name")))
-            child_field = col_names.get(child_col, _snake_name(child_col, "column"))
-            field = re.sub(r"_id$", "", child_field) or _snake_name(pcls, "relation")
-            lines.append(f"  @ManyToOne(() => {pcls})")
-            lines.append(f"  @JoinColumn({{ name: {json.dumps(child_col)} }})")
-            lines.append(f"  {field}?: {pcls};")
-            lines.append("")
-        for e in children_of.get(oid, []):
-            child = ix["rel_by_oid"].get(e.get("child_relation_oid"))
-            if child is None:
-                continue
-            ccls = _class_name(str(child.get("relation_name")))
-            field = ccls[0].lower() + ccls[1:] + "s"
-            lines.append(f"  @OneToMany(() => {ccls}, (child) => child)")
-            lines.append(f"  {field}?: {ccls}[];")
-            lines.append("")
-        while lines and lines[-1] == "":
-            lines.pop()
-        lines.append("}")
-    return "\n".join(lines) + "\n"
diff --git a/backend/app/spec/schema_stats.py b/backend/app/spec/schema_stats.py
deleted file mode 100644
index 76f4b9fd..00000000
--- a/backend/app/spec/schema_stats.py
+++ /dev/null
@@ -1,89 +0,0 @@
-"""Compute overview statistics for a schema snapshot.
-
-A single call that answers "how big and how shaped is this schema?": object
-counts, column distribution, the widest tables, PK/FK/index coverage, and the
-most common data types. Useful for a dashboard header or an API consumer sizing
-a migration effort.
-
-Pure and dialect-agnostic.
-"""
-
-from __future__ import annotations
-
-from collections import Counter
-from typing import Any
-
-_KIND_LABELS = {
-    "r": "table",
-    "p": "table",  # partitioned table
-    "v": "view",
-    "m": "materialized_view",
-    "f": "foreign_table",
-    "t": "toast",
-}
-
-
-def compute_schema_stats(snapshot: dict[str, Any] | None) -> dict[str, Any]:
-    """Return counts and distributions describing the snapshot."""
-    snapshot = snapshot or {}
-    relations = snapshot.get("relations") or []
-    columns = snapshot.get("columns") or []
-    pk_columns = snapshot.get("pk_columns") or []
-    fk_edges = snapshot.get("fk_edges") or []
-    indexes = snapshot.get("indexes") or []
-
-    rel_by_oid = {r.get("relation_oid"): r for r in relations}
-
-    kinds: Counter[str] = Counter()
-    for r in relations:
-        kinds[_KIND_LABELS.get(r.get("relation_kind") or "r", "other")] += 1
-
-    cols_per_oid: Counter[Any] = Counter()
-    nullable = 0
-    type_counts: Counter[str] = Counter()
-    for c in columns:
-        cols_per_oid[c.get("relation_oid")] += 1
-        if not c.get("is_not_null"):
-            nullable += 1
-        dtype = str(c.get("data_type") or "").strip().lower()
-        if dtype:
-            type_counts[dtype] += 1
-
-    table_oids = [
-        r.get("relation_oid")
-        for r in relations
-        if (r.get("relation_kind") or "r") in ("r", "p")
-    ]
-    pk_oids = {pk.get("relation_oid") for pk in pk_columns}
-    without_pk = sum(1 for oid in table_oids if oid not in pk_oids)
-
-    total_columns = len(columns)
-    table_total = len(table_oids)
-
-    def _qname(oid: Any) -> str:
-        rel = rel_by_oid.get(oid) or {}
-        return f"{rel.get('schema_name')}.{rel.get('relation_name')}"
-
-    widest = [
-        {"table": _qname(oid), "columns": n}
-        for oid, n in cols_per_oid.most_common(5)
-    ]
-
-    return {
-        "relations": {**dict(kinds), "total": len(relations)},
-        "columns": {
-            "total": total_columns,
-            "nullable": nullable,
-            "not_null": total_columns - nullable,
-            "avg_per_table": round(total_columns / table_total, 1) if table_total else 0.0,
-            "max_per_table": max(cols_per_oid.values(), default=0),
-        },
-        "constraints": {
-            "primary_keys": len(pk_oids),
-            "foreign_keys": len(fk_edges),
-            "indexes": len(indexes),
-        },
-        "tables_without_primary_key": without_pk,
-        "widest_tables": widest,
-        "data_types": dict(type_counts.most_common(10)),
-    }
diff --git a/backend/app/spec/sensitive_columns.py b/backend/app/spec/sensitive_columns.py
deleted file mode 100644
index bf2345bf..00000000
--- a/backend/app/spec/sensitive_columns.py
+++ /dev/null
@@ -1,90 +0,0 @@
-"""Flag columns that likely hold sensitive / personal data (PII).
-
-This is a compliance **scoping** aid, NOT enforcement. It answers "which columns
-put me in regulatory scope?" by mapping likely-sensitive columns to the relevant
-framework (PCI DSS for card data, GDPR/PIPA for personal & special-category
-data, secrets-management for credentials). It does NOT encrypt, mask, tokenize,
-or apply access controls -- that remediation is the database owner's job.
-
-Pure and dialect-agnostic; name-heuristic only (no data is read). ponytail:
-name matching flags likely locations -- a review starting point, not proof; it
-won't catch sensitive data hidden behind an opaque column name, nor confirm a
-matched column actually holds regulated data.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import Any
-
-HIGH = "high"
-MEDIUM = "medium"
-LOW = "low"
-
-_SEVERITY_RANK = {HIGH: 0, MEDIUM: 1, LOW: 2}
-
-# (category, severity, framework, compiled pattern). Order matters: first match
-# wins, so the most specific / most sensitive categories come first. `framework`
-# names the regulation that brings the column into scope.
-_RULES: list[tuple[str, str, str, re.Pattern[str]]] = [
-    ("credential", HIGH, "Secrets (must never be stored in plaintext)", re.compile(r"pass(word|wd)?|passwd|secret|api[_-]?key|token|private[_-]?key|salt|otp")),
-    ("national_id", HIGH, "GDPR Art.9 / PIPA unique-identifier & special category", re.compile(r"ssn|social[_-]?security|resident[_-]?reg|jumin|national[_-]?id|passport|tax[_-]?id|driver[_-]?licen"),),
-    ("payment", HIGH, "PCI DSS (cardholder data environment)", re.compile(r"card[_-]?(no|num|number)|credit[_-]?card|ccnum|cvv|cvc|iban|account[_-]?(no|number)|routing")),
-    ("special_category", HIGH, "GDPR Art.9 / PIPA sensitive data", re.compile(r"(^|_)health|medical|diagnos|disease|biometric|fingerprint|(^|_)race($|_)|ethnic|religion|political|sexual|genetic")),
-    ("contact", MEDIUM, "GDPR / PIPA personal data", re.compile(r"e[_-]?mail|(^|_)email|phone|mobile|(^|_)tel($|_)|fax")),
-    ("location", MEDIUM, "GDPR / PIPA personal data", re.compile(r"address|(^|_)addr($|_)|zip[_-]?code|postal|(^|_)city($|_)|latitude|longitude|(^|_)geo")),
-    ("personal", MEDIUM, "GDPR / PIPA personal data", re.compile(r"birth|(^|_)dob($|_)|gender|nationality|marital")),
-    ("name", LOW, "GDPR / PIPA personal data", re.compile(r"(first|last|full|middle|given|family)[_-]?name|(^|_)fname|(^|_)lname|username|nickname")),
-]
-
-
-def detect_sensitive_columns(snapshot: dict[str, Any] | None) -> dict[str, Any]:
-    """Return a classified inventory of likely-sensitive columns."""
-    snapshot = snapshot or {}
-    relations = snapshot.get("relations") or []
-    columns = snapshot.get("columns") or []
-
-    rel_by_oid = {r.get("relation_oid"): r for r in relations}
-    items: list[dict[str, Any]] = []
-
-    for col in columns:
-        name = str(col.get("column_name") or "")
-        if not name:
-            continue
-        lname = name.lower()
-        for category, severity, framework, pattern in _RULES:
-            if pattern.search(lname):
-                rel = rel_by_oid.get(col.get("relation_oid")) or {}
-                items.append(
-                    {
-                        "schema": rel.get("schema_name"),
-                        "table": rel.get("relation_name"),
-                        "column": name,
-                        "category": category,
-                        "severity": severity,
-                        "framework": framework,
-                    }
-                )
-                break  # first (most sensitive) match wins
-
-    items.sort(
-        key=lambda i: (
-            _SEVERITY_RANK.get(i["severity"], 9),
-            str(i["schema"]),
-            str(i["table"]),
-            str(i["column"]),
-        )
-    )
-
-    by_framework: dict[str, int] = {}
-    for i in items:
-        by_framework[i["framework"]] = by_framework.get(i["framework"], 0) + 1
-
-    summary = {
-        "high": sum(1 for i in items if i["severity"] == HIGH),
-        "medium": sum(1 for i in items if i["severity"] == MEDIUM),
-        "low": sum(1 for i in items if i["severity"] == LOW),
-        "total": len(items),
-        "by_framework": by_framework,
-    }
-    return {"items": items, "summary": summary}
diff --git a/backend/tests/test_audit_columns.py b/backend/tests/test_audit_columns.py
deleted file mode 100644
index 0ab8b436..00000000
--- a/backend/tests/test_audit_columns.py
+++ /dev/null
@@ -1,56 +0,0 @@
-from __future__ import annotations
-
-from app.spec.audit_columns import check_audit_columns
-
-
-def _snap(tables):
-    """tables: {name: [column, ...]}"""
-    relations, columns = [], []
-    for oid, (t, cols) in enumerate(tables.items(), start=1):
-        relations.append({"relation_oid": oid, "relation_kind": "r", "schema_name": "public", "relation_name": t})
-        for c in cols:
-            columns.append({"relation_oid": oid, "column_name": c})
-    return {"relations": relations, "columns": columns}
-
-
-def test_flags_outlier_when_majority_has_audit_columns():
-    snap = _snap({
-        "a": ["id", "created_at", "updated_at"],
-        "b": ["id", "created_at", "updated_at"],
-        "c": ["id", "created_at", "updated_at"],
-        "d": ["id"],  # outlier
-    })
-    report = check_audit_columns(snap)
-    assert report["summary"]["convention_active"] is True
-    assert len(report["items"]) == 1
-    item = report["items"][0]
-    assert item["table"] == "public.d"
-    assert set(item["missing"]) == {"created_at", "updated_at"}
-
-
-def test_no_flags_when_schema_has_no_convention():
-    snap = _snap({
-        "a": ["id"], "b": ["id"], "c": ["id"], "d": ["id", "created_at"],
-    })
-    report = check_audit_columns(snap)  # 25% adoption < 50%
-    assert report["items"] == []
-    assert report["summary"]["convention_active"] is False
-
-
-def test_variant_names_count_as_audit_columns():
-    snap = _snap({
-        "a": ["id", "create_time", "modified_at"],
-        "b": ["id", "reg_dt", "last_modified"],
-        "c": ["id", "inserted_at", "update_dt"],
-        "d": ["id", "created_on", "updated_on"],
-    })
-    report = check_audit_columns(snap)
-    assert report["items"] == []  # all four satisfy both via variants
-    assert report["summary"]["with_created"] == 4
-    assert report["summary"]["with_updated"] == 4
-
-
-def test_small_schemas_are_not_judged_and_empty():
-    snap = _snap({"a": ["id", "created_at"], "b": ["id"]})  # only 2 tables
-    assert check_audit_columns(snap)["items"] == []
-    assert check_audit_columns({})["summary"]["tables"] == 0
diff --git a/backend/tests/test_clearfolio.py b/backend/tests/test_clearfolio.py
deleted file mode 100644
index 35272ca4..00000000
--- a/backend/tests/test_clearfolio.py
+++ /dev/null
@@ -1,145 +0,0 @@
-from __future__ import annotations
-
-from unittest.mock import patch
-
-import httpx
-import pytest
-
-from app.integrations import clearfolio as cf
-
-
-SECRET = "gateway-shared-secret"
-PERMS = "job:create,job:read,job:retry,viewer:read,artifact-link:create,analytics:read"
-
-
-def test_sign_tenant_claims_matches_golden_vector():
-    # Golden value computed from the documented recipe:
-    #   base64url(HMAC_SHA256(secret, tenant\nsubject\nperms\nissuedAt)), no padding
-    sig = cf.sign_tenant_claims(SECRET, "pg-erd-cloud", "dev:alice", PERMS, 1782995100)
-    assert sig == "TVdcjfzpR30SJmpCMrliK4gjuj6UY7zi2zGXBHzRlvc"
-    assert "=" not in sig  # unpadded
-    assert "+" not in sig and "/" not in sig  # base64URL alphabet
-
-
-def test_signature_binds_every_claim():
-    base = cf.sign_tenant_claims(SECRET, "t", "s", "p", 100)
-    assert base != cf.sign_tenant_claims(SECRET, "t2", "s", "p", 100)
-    assert base != cf.sign_tenant_claims(SECRET, "t", "s2", "p", 100)
-    assert base != cf.sign_tenant_claims(SECRET, "t", "s", "p2", 100)
-    assert base != cf.sign_tenant_claims(SECRET, "t", "s", "p", 101)
-    assert base != cf.sign_tenant_claims("other", "t", "s", "p", 100)
-
-
-def test_build_headers_sends_full_signed_set_and_self_verifies():
-    cfg = cf.ClearfolioConfig(
-        gateway_url="https://cf.example.com", hmac_secret=SECRET,
-        tenant_id="pg-erd-cloud", permissions=PERMS, timeout_seconds=10.0,
-    )
-    headers = cf.build_tenant_headers(cfg, "dev:alice", issued_at=1782995100)
-    assert headers["X-Clearfolio-Tenant-Id"] == "pg-erd-cloud"
-    assert headers["X-Clearfolio-Subject-Id"] == "dev:alice"
-    assert headers["X-Clearfolio-Permissions"] == PERMS
-    assert headers["X-Clearfolio-Claims-Issued-At"] == "1782995100"
-    # the signature header must equal an independent re-sign of the sent claims
-    assert headers["X-Clearfolio-Claims-Signature"] == cf.sign_tenant_claims(
-        SECRET,
-        headers["X-Clearfolio-Tenant-Id"],
-        headers["X-Clearfolio-Subject-Id"],
-        headers["X-Clearfolio-Permissions"],
-        int(headers["X-Clearfolio-Claims-Issued-At"]),
-    )
-
-
-@pytest.mark.asyncio
-async def test_not_configured_raises():
-    with patch.object(cf.settings, "clearfolio_gateway_url", None):
-        with pytest.raises(cf.ClearfolioNotConfigured):
-            await cf.submit_conversion_job("dev:alice", b"pdf", "spec.pdf")
-
-
-@pytest.mark.asyncio
-async def test_submit_signs_and_posts_multipart(monkeypatch):
-    monkeypatch.setattr(cf.settings, "clearfolio_gateway_url", "https://cf.example.com")
-    monkeypatch.setattr(cf.settings, "clearfolio_tenant_claims_hmac_secret", SECRET)
-    monkeypatch.setattr(cf.settings, "clearfolio_tenant_id", "pg-erd-cloud")
-    captured = {}
-
-    async def fake_validate(config):
-        return None
-
-    async def fake_request(self, method, url, headers=None, files=None):
-        captured.update(method=method, url=url, headers=headers, files=files)
-        return httpx.Response(202, json={"jobId": "j-1", "statusUrl": "/x"})
-
-    monkeypatch.setattr(cf, "_validate_gateway", fake_validate)
-    monkeypatch.setattr(httpx.AsyncClient, "request", fake_request)
-
-    out = await cf.submit_conversion_job("dev:alice", b"%PDF-1.7", "spec.pdf")
-    assert out["jobId"] == "j-1"
-    assert captured["method"] == "POST"
-    assert captured["url"] == "https://cf.example.com/api/v1/convert/jobs"
-    assert captured["headers"]["X-Clearfolio-Claims-Signature"]  # signed
-    assert captured["files"]["file"][0] == "spec.pdf"
-
-
-@pytest.mark.asyncio
-async def test_http_error_becomes_clearfolio_error(monkeypatch):
-    monkeypatch.setattr(cf.settings, "clearfolio_gateway_url", "https://cf.example.com")
-    monkeypatch.setattr(cf.settings, "clearfolio_tenant_claims_hmac_secret", SECRET)
-
-    async def fake_validate(config):
-        return None
-
-    async def fake_request(self, method, url, headers=None, files=None):
-        return httpx.Response(403, json={"error": "forbidden"})
-
-    monkeypatch.setattr(cf, "_validate_gateway", fake_validate)
-    monkeypatch.setattr(httpx.AsyncClient, "request", fake_request)
-    with pytest.raises(cf.ClearfolioError):
-        await cf.get_viewer_bootstrap("dev:alice", "doc-1")
-
-
-@pytest.mark.asyncio
-async def test_ids_are_url_encoded_as_path_segments(monkeypatch):
-    monkeypatch.setattr(cf.settings, "clearfolio_gateway_url", "https://cf.example.com")
-    monkeypatch.setattr(cf.settings, "clearfolio_tenant_claims_hmac_secret", SECRET)
-    captured = []
-
-    async def fake_validate(config):
-        return None
-
-    async def fake_request(self, method, url, headers=None, files=None):
-        captured.append((method, url))
-        return httpx.Response(200, json={"ok": True})
-
-    monkeypatch.setattr(cf, "_validate_gateway", fake_validate)
-    monkeypatch.setattr(httpx.AsyncClient, "request", fake_request)
-
-    await cf.get_job_status("dev:alice", "../job 1?x=y")
-    await cf.get_viewer_bootstrap("dev:alice", "folder/doc 1")
-    await cf.create_artifact_link("dev:alice", "folder/doc 1")
-
-    assert captured == [
-        ("GET", "https://cf.example.com/api/v1/convert/jobs/..%2Fjob%201%3Fx%3Dy"),
-        ("GET", "https://cf.example.com/api/v1/viewer/folder%2Fdoc%201"),
-        ("POST", "https://cf.example.com/api/v1/viewer/folder%2Fdoc%201/artifact-links"),
-    ]
-
-
-def test_permissions_canonicalized_to_match_clearfolio():
-    # messy config: spaces, a duplicate, a trailing empty entry
-    messy = " viewer:read , job:create,viewer:read, job:read ,"
-    assert cf.canonicalize_permissions(messy) == "viewer:read,job:create,job:read"
-    cfg = cf.ClearfolioConfig(
-        gateway_url="https://cf.example.com", hmac_secret=SECRET,
-        tenant_id=" pg-erd-cloud ", permissions=messy, timeout_seconds=10.0,
-    )
-    h = cf.build_tenant_headers(cfg, " dev:alice ", issued_at=100)
-    # sent header equals canonical form (no spaces/dupes), tenant/subject stripped
-    assert h["X-Clearfolio-Permissions"] == "viewer:read,job:create,job:read"
-    assert h["X-Clearfolio-Tenant-Id"] == "pg-erd-cloud"
-    assert h["X-Clearfolio-Subject-Id"] == "dev:alice"
-    # signature is over the canonical values, so Clearfolio's re-derivation matches
-    assert h["X-Clearfolio-Claims-Signature"] == cf.sign_tenant_claims(
-        SECRET, "pg-erd-cloud", "dev:alice", "viewer:read,job:create,job:read", 100
-    )
diff --git a/backend/tests/test_constraint_inventory.py b/backend/tests/test_constraint_inventory.py
deleted file mode 100644
index 27c2ec76..00000000
--- a/backend/tests/test_constraint_inventory.py
+++ /dev/null
@@ -1,60 +0,0 @@
-from __future__ import annotations
-
-from app.spec.constraint_inventory import build_constraint_inventory
-
-
-def _con(ctype, name, table="orders", ftable=None, on_delete=None, check_expr=None):
-    return {
-        "constraint_type": ctype,
-        "constraint_name": name,
-        "schema_name": "public",
-        "relation_name": table,
-        "foreign_schema_name": "public" if ftable else None,
-        "foreign_relation_name": ftable,
-        "fk_on_delete": on_delete,
-        "check_expr": check_expr,
-        "constraint_def": f"DEF {name}",
-    }
-
-
-def test_inventories_check_constraints_with_expressions():
-    snap = {"constraints": [
-        _con("c", "chk_qty_positive", check_expr="(quantity > 0)"),
-        _con("c", "chk_status", table="member", check_expr="(status IN ('active','banned'))"),
-        _con("p", "pk_orders"),
-    ]}
-    inv = build_constraint_inventory(snap)
-    assert inv["summary"]["check_rules"] == 2
-    assert inv["check_rules"][0]["table"] == "public.member"  # sorted by table
-    assert inv["check_rules"][1]["expression"] == "(quantity > 0)"
-
-
-def test_flags_cascade_delete_as_warning():
-    snap = {"constraints": [
-        _con("f", "fk_item_order", table="order_item", ftable="orders", on_delete="c"),
-    ]}
-    inv = build_constraint_inventory(snap)
-    assert inv["summary"]["cascade_deletes"] == 1
-    item = inv["delete_actions"][0]
-    assert item["severity"] == "warning"
-    assert "public.orders" in item["detail"] and "public.order_item" in item["detail"]
-
-
-def test_set_null_is_info_and_spelled_out_codes_work():
-    snap = {"constraints": [
-        _con("f", "fk_a", table="a", ftable="b", on_delete="set null"),
-        _con("f", "fk_c", table="c", ftable="d", on_delete="CASCADE"),
-        _con("f", "fk_plain", table="e", ftable="f", on_delete="a"),  # no action
-    ]}
-    inv = build_constraint_inventory(snap)
-    assert inv["summary"]["set_null_deletes"] == 1
-    assert inv["summary"]["cascade_deletes"] == 1
-    # warnings sort before infos
-    assert [i["severity"] for i in inv["delete_actions"]] == ["warning", "info"]
-
-
-def test_check_without_expr_falls_back_to_def_and_empty():
-    snap = {"constraints": [_con("c", "chk_x", check_expr=None)]}
-    inv = build_constraint_inventory(snap)
-    assert inv["check_rules"][0]["expression"] == "DEF chk_x"
-    assert build_constraint_inventory({})["summary"]["check_rules"] == 0
diff --git a/backend/tests/test_db_introspect.py b/backend/tests/test_db_introspect.py
index a7ee93f5..0e8851cc 100644
--- a/backend/tests/test_db_introspect.py
+++ b/backend/tests/test_db_introspect.py
@@ -17,10 +17,6 @@
         ("SNOWFLAKE://u:p@acct/DB", "snowflake"),
         ("snowflake+snowflake-connector-python://u:p@acct/DB", "snowflake"),
         ("snowflake+async://u:p@acct/DB", "snowflake"),
-        ("mysql://u:p@db/app", "mysql"),
-        ("mysql+pymysql://u:p@db/app", "mysql"),
-        ("mariadb://u:p@db/app", "mysql"),
-        ("MARIADB://u:p@db/app", "mysql"),
     ],
 )
 def test_detect_dsn_dialect_valid(
@@ -32,7 +28,7 @@ def test_detect_dsn_dialect_valid(
 @pytest.mark.parametrize(
     "dsn,expected_error",
     [
-        ("oracle://u:p@db/app", "unsupported database DSN scheme: oracle"),
+        ("mysql://u:p@db/app", "unsupported database DSN scheme: mysql"),
         (
             "snowflake_invalid://u:p@acct/DB",
             "unsupported database DSN scheme: <empty>",
@@ -65,13 +61,8 @@ async def fake_snowflake(dsn: str, schema_filter: str | None) -> dict:
         calls.append(("snowflake", dsn, schema_filter))
         return {"source_dialect": "snowflake"}
 
-    async def fake_mysql(dsn: str, schema_filter: str | None) -> dict:
-        calls.append(("mysql", dsn, schema_filter))
-        return {"source_dialect": "mysql"}
-
     monkeypatch.setattr(db_introspect, "introspect_postgres", fake_postgres)
     monkeypatch.setattr(db_introspect, "introspect_snowflake", fake_snowflake)
-    monkeypatch.setattr(db_introspect, "introspect_mysql", fake_mysql)
 
     assert await db_introspect.introspect_database(
         "postgresql://u:p@db/app", "public"
@@ -79,53 +70,9 @@ async def fake_mysql(dsn: str, schema_filter: str | None) -> dict:
     assert await db_introspect.introspect_database(
         "snowflake://u:p@acct/APP/PUBLIC", None
     ) == {"source_dialect": "snowflake"}
-    assert await db_introspect.introspect_database(
-        "mariadb://u:p@db/app", "shop"
-    ) == {"source_dialect": "mysql"}
     assert calls == [
         ("postgresql", "postgresql://u:p@db/app", "public"),
         ("snowflake", "snowflake://u:p@acct/APP/PUBLIC", None),
-        ("mysql", "mariadb://u:p@db/app", "shop"),
-    ]
-
-
-@pytest.mark.asyncio
-async def test_probe_database_dispatches_by_dialect(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    calls: list[tuple[str, str]] = []
-
-    async def fake_postgres(dsn: str) -> str:
-        calls.append(("postgresql", dsn))
-        return "postgresql 17"
-
-    async def fake_snowflake(dsn: str) -> str:
-        calls.append(("snowflake", dsn))
-        return "snowflake 9"
-
-    async def fake_mysql(dsn: str) -> str:
-        calls.append(("mysql", dsn))
-        return "mysql 8"
-
-    monkeypatch.setattr(db_introspect, "probe_postgres", fake_postgres)
-    monkeypatch.setattr(db_introspect, "probe_snowflake", fake_snowflake)
-    monkeypatch.setattr(db_introspect, "probe_mysql", fake_mysql)
-
-    assert (
-        await db_introspect.probe_database("postgres://u:p@db/app")
-        == "postgresql 17"
-    )
-    assert (
-        await db_introspect.probe_database("snowflake://u:p@acct/APP")
-        == "snowflake 9"
-    )
-    assert (
-        await db_introspect.probe_database("mysql+pymysql://u:p@db/app") == "mysql 8"
-    )
-    assert calls == [
-        ("postgresql", "postgres://u:p@db/app"),
-        ("snowflake", "snowflake://u:p@acct/APP"),
-        ("mysql", "mysql+pymysql://u:p@db/app"),
     ]
 
 
diff --git a/backend/tests/test_dbml_import.py b/backend/tests/test_dbml_import.py
deleted file mode 100644
index 2c034bef..00000000
--- a/backend/tests/test_dbml_import.py
+++ /dev/null
@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-from app.ddl.export import snapshot_json_to_sql
-from app.spec.dbml_import import parse_dbml
-
-BASIC = """
-// a typical dbdiagram.io document
-Table users {
-  id integer [pk, not null]
-  username varchar(255) [not null, unique]
-  created_at timestamp
-}
-
-Table posts {
-  id integer [pk]
-  user_id integer [not null, ref: > users.id]
-  title varchar
-}
-
-Ref: posts.user_id > users.id
-"""
-
-
-def test_parses_tables_columns_pks():
-    snap = parse_dbml(BASIC)
-    names = {(r["schema_name"], r["relation_name"]) for r in snap["relations"]}
-    assert names == {("public", "users"), ("public", "posts")}
-    cols = {c["column_name"] for c in snap["columns"] if c["relation_oid"] == 1}
-    assert cols == {"id", "username", "created_at"}
-    # pk implies not null; plain column stays nullable
-    by_name = {c["column_name"]: c for c in snap["columns"]}
-    assert by_name["id"]["is_not_null"] is True
-    assert by_name["created_at"]["is_not_null"] is False
-    assert {p["column_name"] for p in snap["pk_columns"]} == {"id"}
-
-
-def test_parses_refs_inline_and_standalone_deduped_semantics():
-    snap = parse_dbml(BASIC)
-    # inline ref + standalone ref both point posts.user_id -> users.id
-    assert all(
-        e["child_column_name"] == "user_id" and e["parent_column_name"] == "id"
-        for e in snap["fk_edges"]
-    )
-    assert len(snap["fk_edges"]) == 2  # parser is literal; dedup is the caller's choice
-
-
-def test_reverse_arrow_and_schema_qualified_and_quoted():
-    text = '''
-Table auth.accounts {
-  account_id bigint [pk]
-}
-Table "Order Items" {
-  id bigint [pk]
-  account_id bigint
-}
-Ref: auth.accounts.account_id < "Order Items".account_id
-'''
-    snap = parse_dbml(text)
-    assert ("auth", "accounts") in {(r["schema_name"], r["relation_name"]) for r in snap["relations"]}
-    edge = snap["fk_edges"][0]
-    # '<' means the right side references the left
-    child = next(r for r in snap["relations"] if r["relation_oid"] == edge["child_relation_oid"])
-    assert child["relation_name"] == "Order Items"
-
-
-def test_ignores_project_enum_notes_and_unknown_refs():
-    text = """
-Project demo {
-  database_type: 'PostgreSQL'
-}
-Enum status {
-  active
-  banned
-}
-Table t {
-  id int [pk]
-  s status
-}
-Ref: t.ghost_col > missing_table.id
-"""
-    snap = parse_dbml(text)
-    assert len(snap["relations"]) == 1
-    assert snap["fk_edges"] == []  # ref to undefined table skipped, no crash
-
-
-def test_dbml_snapshot_feeds_existing_ddl_export():
-    ddl = snapshot_json_to_sql(parse_dbml(BASIC), target_dialect="postgresql")
-    assert 'CREATE TABLE IF NOT EXISTS "public"."users"' in ddl
-    assert 'CREATE TABLE IF NOT EXISTS "public"."posts"' in ddl
-    assert "PRIMARY KEY" in ddl
-
-
-def test_pathological_long_line_is_skipped_fast():
-    import time
-
-    hostile = 'Table t {\n  id int [pk]\n}\nRef: ' + '"a' * 100_000 + "\n"
-    start = time.monotonic()
-    snap = parse_dbml(hostile)
-    assert time.monotonic() - start < 1.0  # no catastrophic backtracking
-    assert len(snap["relations"]) == 1
-
-
-def test_pathological_table_header_dots_are_rejected_fast():
-    import time
-
-    hostile = "Table ." + "." * 4000 + "\nTable users {\n  id int [pk]\n}\n"
-    start = time.monotonic()
-    snap = parse_dbml(hostile)
-    assert time.monotonic() - start < 1.0
-    assert {(r["schema_name"], r["relation_name"]) for r in snap["relations"]} == {
-        ("public", "users")
-    }
diff --git a/backend/tests/test_fk_cycles.py b/backend/tests/test_fk_cycles.py
deleted file mode 100644
index 5298bff0..00000000
--- a/backend/tests/test_fk_cycles.py
+++ /dev/null
@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-from app.spec.fk_cycles import detect_fk_cycles
-
-
-def _snap(edges, names=None):
-    names = names or sorted({e[0] for e in edges} | {e[1] for e in edges})
-    oid = {n: i + 1 for i, n in enumerate(names)}
-    return {
-        "relations": [{"relation_oid": oid[n], "schema_name": "public", "relation_name": n} for n in names],
-        "fk_edges": [
-            {"child_relation_oid": oid[c], "parent_relation_oid": oid[p], "child_column_name": "x", "parent_column_name": "y"}
-            for c, p in edges
-        ],
-    }
-
-
-def test_detects_multi_table_cycle():
-    # a -> b -> c -> a
-    report = detect_fk_cycles(_snap([("a", "b"), ("b", "c"), ("c", "a")]))
-    assert report["summary"]["circular_dependencies"] == 1
-    cyc = next(i for i in report["items"] if i["category"] == "circular_dependency")
-    assert set(cyc["tables"]) == {"public.a", "public.b", "public.c"}
-    assert cyc["severity"] == "warning"
-
-
-def test_two_node_cycle():
-    report = detect_fk_cycles(_snap([("a", "b"), ("b", "a")]))
-    assert report["summary"]["circular_dependencies"] == 1
-
-
-def test_self_reference_is_info_not_a_cycle():
-    report = detect_fk_cycles(_snap([("employee", "employee")], names=["employee"]))
-    assert report["summary"]["circular_dependencies"] == 0
-    assert report["summary"]["self_references"] == 1
-    assert report["items"][0]["severity"] == "info"
-
-
-def test_acyclic_graph_has_no_findings():
-    report = detect_fk_cycles(_snap([("orders", "member"), ("order_item", "orders")]))
-    assert report["items"] == []
-
-
-def test_two_independent_cycles_and_deep_chain_no_recursion_error():
-    edges = [("a", "b"), ("b", "a"), ("c", "d"), ("d", "c")]
-    # long acyclic chain to exercise the iterative SCC
-    chain = [f"n{i}" for i in range(1500)]
-    edges += [(chain[i], chain[i + 1]) for i in range(len(chain) - 1)]
-    report = detect_fk_cycles(_snap(edges))
-    assert report["summary"]["circular_dependencies"] == 2
diff --git a/backend/tests/test_index_redundancy.py b/backend/tests/test_index_redundancy.py
deleted file mode 100644
index 703e0403..00000000
--- a/backend/tests/test_index_redundancy.py
+++ /dev/null
@@ -1,66 +0,0 @@
-from __future__ import annotations
-
-from app.spec.index_redundancy import detect_index_redundancy
-
-
-def _snap(index_defs, unique=None):
-    """index_defs: {index_name: 'col1, col2'} on one table 'orders'."""
-    unique = unique or set()
-    return {
-        "relations": [{"relation_oid": 1, "schema_name": "public", "relation_name": "orders"}],
-        "indexes": [
-            {
-                "relation_oid": 1,
-                "index_name": name,
-                "is_unique": name in unique,
-                "index_def": f"CREATE INDEX {name} ON public.orders USING btree ({cols})",
-            }
-            for name, cols in index_defs.items()
-        ],
-    }
-
-
-def _cats(report):
-    return {(i["category"], i["index"]) for i in report["items"]}
-
-
-def test_detects_exact_duplicate():
-    report = detect_index_redundancy(_snap({"ix_a": "member_id", "ix_b": "member_id"}))
-    assert report["summary"]["duplicates"] == 1
-    dup = report["items"][0]
-    assert dup["severity"] == "warning" and dup["columns"] == ["member_id"]
-
-
-def test_duplicate_keeps_the_unique_one():
-    report = detect_index_redundancy(
-        _snap({"uq_a": "email", "ix_b": "email"}, unique={"uq_a"})
-    )
-    dup = report["items"][0]
-    assert dup["index"] == "ix_b" and dup["kept"] == "uq_a"
-
-
-def test_detects_prefix_redundancy_but_not_unique_prefix():
-    # ix_short(member_id) is a prefix of ix_long(member_id, created_at)
-    report = detect_index_redundancy(
-        _snap({"ix_short": "member_id", "ix_long": "member_id, created_at"})
-    )
-    assert ("prefix_redundant_index", "ix_short") in _cats(report)
-
-    # but a UNIQUE index is a constraint — never suggested for dropping
-    report2 = detect_index_redundancy(
-        _snap({"uq_short": "member_id", "ix_long": "member_id, created_at"}, unique={"uq_short"})
-    )
-    assert report2["items"] == []
-
-
-def test_different_columns_and_unparseable_defs_are_skipped():
-    report = detect_index_redundancy(_snap({"ix_a": "member_id", "ix_b": "created_at"}))
-    assert report["items"] == []
-    # expression + partial indexes are skipped, not guessed
-    snap = _snap({"ix_a": "member_id"})
-    snap["indexes"].append({"relation_oid": 1, "index_name": "ix_expr",
-                            "index_def": "CREATE INDEX ix_expr ON public.orders (lower(email))"})
-    snap["indexes"].append({"relation_oid": 1, "index_name": "ix_part",
-                            "index_def": "CREATE INDEX ix_part ON public.orders (member_id) WHERE deleted_at IS NULL"})
-    assert detect_index_redundancy(snap)["items"] == []
-    assert detect_index_redundancy({})["summary"]["total"] == 0
diff --git a/backend/tests/test_mysql_introspect.py b/backend/tests/test_mysql_introspect.py
deleted file mode 100644
index 24424b91..00000000
--- a/backend/tests/test_mysql_introspect.py
+++ /dev/null
@@ -1,100 +0,0 @@
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from app.db_introspect import detect_dsn_dialect
-from app.ddl.export import snapshot_json_to_sql
-from app.mysql_introspect.introspect import _parse_mysql_dsn, rows_to_snapshot
-
-TABLES = [
-    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "member", "TABLE_TYPE": "BASE TABLE", "TABLE_COMMENT": "회원"},
-    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "TABLE_TYPE": "BASE TABLE", "TABLE_COMMENT": ""},
-    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "v_sales", "TABLE_TYPE": "VIEW", "TABLE_COMMENT": ""},
-]
-COLUMNS = [
-    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "member", "COLUMN_NAME": "member_id", "ORDINAL_POSITION": 1,
-     "COLUMN_TYPE": "bigint", "DATA_TYPE": "bigint", "IS_NULLABLE": "NO", "COLUMN_DEFAULT": None, "COLUMN_COMMENT": ""},
-    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "member", "COLUMN_NAME": "email", "ORDINAL_POSITION": 2,
-     "COLUMN_TYPE": "varchar(255)", "DATA_TYPE": "varchar", "IS_NULLABLE": "YES", "COLUMN_DEFAULT": None, "COLUMN_COMMENT": ""},
-    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "COLUMN_NAME": "order_id", "ORDINAL_POSITION": 1,
-     "COLUMN_TYPE": "bigint", "DATA_TYPE": "bigint", "IS_NULLABLE": "NO", "COLUMN_DEFAULT": None, "COLUMN_COMMENT": ""},
-    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "COLUMN_NAME": "member_id", "ORDINAL_POSITION": 2,
-     "COLUMN_TYPE": "bigint", "DATA_TYPE": "bigint", "IS_NULLABLE": "NO", "COLUMN_DEFAULT": None, "COLUMN_COMMENT": ""},
-]
-KEY_USAGE = [
-    {"CONSTRAINT_NAME": "PRIMARY", "TABLE_SCHEMA": "shop", "TABLE_NAME": "member", "COLUMN_NAME": "member_id",
-     "ORDINAL_POSITION": 1, "REFERENCED_TABLE_SCHEMA": None, "REFERENCED_TABLE_NAME": None, "REFERENCED_COLUMN_NAME": None},
-    {"CONSTRAINT_NAME": "PRIMARY", "TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "COLUMN_NAME": "order_id",
-     "ORDINAL_POSITION": 1, "REFERENCED_TABLE_SCHEMA": None, "REFERENCED_TABLE_NAME": None, "REFERENCED_COLUMN_NAME": None},
-    {"CONSTRAINT_NAME": "fk_orders_member", "TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "COLUMN_NAME": "member_id",
-     "ORDINAL_POSITION": 1, "REFERENCED_TABLE_SCHEMA": "shop", "REFERENCED_TABLE_NAME": "member", "REFERENCED_COLUMN_NAME": "member_id"},
-]
-INDEXES = [
-    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "INDEX_NAME": "ix_orders_member",
-     "NON_UNIQUE": 1, "SEQ_IN_INDEX": 1, "COLUMN_NAME": "member_id"},
-    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "member", "INDEX_NAME": "PRIMARY",
-     "NON_UNIQUE": 0, "SEQ_IN_INDEX": 1, "COLUMN_NAME": "member_id"},
-]
-
-
-def _snap():
-    return rows_to_snapshot("8.4.0", None, TABLES, COLUMNS, KEY_USAGE, INDEXES)
-
-
-def test_maps_tables_views_columns():
-    snap = _snap()
-    kinds = {r["relation_name"]: r["relation_kind"] for r in snap["relations"]}
-    assert kinds == {"member": "r", "orders": "r", "v_sales": "v"}
-    email = next(c for c in snap["columns"] if c["column_name"] == "email")
-    assert email["data_type"] == "varchar(255)" and email["is_not_null"] is False
-    assert snap["server_version"] == "8.4.0" and snap["source_dialect"] == "mysql"
-
-
-def test_maps_pks_and_fks_by_name():
-    snap = _snap()
-    assert {p["column_name"] for p in snap["pk_columns"]} == {"member_id", "order_id"}
-    edge = snap["fk_edges"][0]
-    rel = {r["relation_oid"]: r["relation_name"] for r in snap["relations"]}
-    assert rel[edge["child_relation_oid"]] == "orders"
-    assert rel[edge["parent_relation_oid"]] == "member"
-    # constraints derived so DDL export renders PK/FK
-    assert any(c["constraint_type"] == "p" for c in snap["constraints"])
-    assert any(c["constraint_type"] == "f" for c in snap["constraints"])
-
-
-def test_index_rows_grouped_into_defs():
-    snap = _snap()
-    ix = next(i for i in snap["indexes"] if i["index_name"] == "ix_orders_member")
-    assert "ON shop.orders (member_id)" in ix["index_def"]
-    assert ix["is_unique"] is False
-    primary = next(i for i in snap["indexes"] if i["index_name"] == "PRIMARY")
-    assert primary["is_primary"] is True
-
-
-def test_snapshot_feeds_ddl_export_and_dialect_detection():
-    ddl = snapshot_json_to_sql(_snap(), target_dialect="postgresql")
-    assert 'CREATE TABLE IF NOT EXISTS "shop"."member"' in ddl
-    assert "PRIMARY KEY" in ddl
-    assert detect_dsn_dialect("mysql://u:p@db.example.com/shop") == "mysql"
-    assert detect_dsn_dialect("mariadb://u:p@db.example.com/shop") == "mysql"
-
-
-@pytest.mark.asyncio
-async def test_dsn_parse_pins_validated_ip_and_rejects_bad():
-    with patch(
-        "app.mysql_introspect.introspect._validated_ip_hosts",
-        new_callable=AsyncMock,
-        return_value=["93.184.216.34"],
-    ) as guard:
-        cfg = await _parse_mysql_dsn("mysql://user:s3cret@db.example.com:3307/shop")
-    guard.assert_awaited_once_with("db.example.com", is_hostaddr=False, port=3307)
-    assert cfg.host == "93.184.216.34"  # pinned IP, not the hostname
-    assert cfg.server_hostname == "db.example.com"
-    assert cfg.port == 3307 and cfg.user == "user" and cfg.database == "shop"
-
-    with pytest.raises(ValueError):
-        await _parse_mysql_dsn("mysql:///nohost")
-    with pytest.raises(ValueError):
-        await _parse_mysql_dsn("postgres://u@h/db")
diff --git a/backend/tests/test_orm_codegen.py b/backend/tests/test_orm_codegen.py
deleted file mode 100644
index 51a50fad..00000000
--- a/backend/tests/test_orm_codegen.py
+++ /dev/null
@@ -1,141 +0,0 @@
-from __future__ import annotations
-
-import ast
-
-from app.spec.orm_codegen import generate_prisma_schema, generate_sqlalchemy_models
-
-SNAP = {
-    "relations": [
-        {"relation_oid": 1, "relation_kind": "r", "schema_name": "public", "relation_name": "member", "relation_comment": "회원"},
-        {"relation_oid": 2, "relation_kind": "r", "schema_name": "public", "relation_name": "orders", "relation_comment": None},
-        {"relation_oid": 3, "relation_kind": "v", "schema_name": "public", "relation_name": "v_report"},
-    ],
-    "columns": [
-        {"relation_oid": 1, "column_name": "member_id", "column_position": 1, "data_type": "bigint", "is_not_null": True},
-        {"relation_oid": 1, "column_name": "email", "column_position": 2, "data_type": "varchar(255)", "is_not_null": True},
-        {"relation_oid": 1, "column_name": "joined_at", "column_position": 3, "data_type": "timestamp with time zone", "is_not_null": False},
-        {"relation_oid": 2, "column_name": "order_id", "column_position": 1, "data_type": "bigint", "is_not_null": True},
-        {"relation_oid": 2, "column_name": "member_id", "column_position": 2, "data_type": "bigint", "is_not_null": True},
-        {"relation_oid": 2, "column_name": "total", "column_position": 3, "data_type": "numeric(10,2)", "is_not_null": False},
-    ],
-    "pk_columns": [
-        {"relation_oid": 1, "column_name": "member_id"},
-        {"relation_oid": 2, "column_name": "order_id"},
-    ],
-    "fk_edges": [
-        {"fk_constraint_oid": 10, "fk_constraint_name": "fk_orders_member",
-         "child_relation_oid": 2, "parent_relation_oid": 1,
-         "child_column_name": "member_id", "parent_column_name": "member_id", "column_ordinal": 1},
-    ],
-}
-
-
-def test_sqlalchemy_output_is_valid_python_with_expected_shapes():
-    code = generate_sqlalchemy_models(SNAP)
-    ast.parse(code)  # must always be syntactically valid Python
-    assert "class Member(Base):" in code
-    assert "class Orders(Base):" in code
-    assert "class VReport" not in code  # views excluded
-    assert "member_id: Mapped[int] = mapped_column(primary_key=True)" in code
-    assert "joined_at: Mapped[dt.datetime | None] = mapped_column()" in code
-    assert "ForeignKey('member.member_id')" in code
-    assert "total: Mapped[Decimal | None]" in code
-
-
-def test_sqlalchemy_unknown_type_falls_back_with_comment():
-    snap = {
-        "relations": [{"relation_oid": 1, "relation_kind": "r", "schema_name": "public", "relation_name": "t"}],
-        "columns": [{"relation_oid": 1, "column_name": "shape", "column_position": 1, "data_type": "polygon", "is_not_null": False}],
-        "pk_columns": [], "fk_edges": [],
-    }
-    code = generate_sqlalchemy_models(snap)
-    ast.parse(code)
-    assert "shape: Mapped[str | None] = mapped_column()  # type: polygon" in code
-
-
-def test_prisma_models_relations_and_map():
-    schema = generate_prisma_schema(SNAP)
-    assert "model Member {" in schema and "model Orders {" in schema
-    assert "member_id BigInt @id" in schema
-    assert "member Member @relation(fields: [member_id], references: [member_id])" in schema
-    assert "orderss Orders[]" in schema or "orders Orders[]" in schema  # reverse side exists
-    assert '@@map("orders")' in schema
-    assert "total Decimal?" in schema
-
-
-def test_composite_pk_and_empty_snapshot():
-    snap = {
-        "relations": [{"relation_oid": 1, "relation_kind": "r", "schema_name": "public", "relation_name": "m2m"}],
-        "columns": [
-            {"relation_oid": 1, "column_name": "a_id", "column_position": 1, "data_type": "bigint", "is_not_null": True},
-            {"relation_oid": 1, "column_name": "b_id", "column_position": 2, "data_type": "bigint", "is_not_null": True},
-        ],
-        "pk_columns": [
-            {"relation_oid": 1, "column_name": "a_id"},
-            {"relation_oid": 1, "column_name": "b_id"},
-        ],
-        "fk_edges": [],
-    }
-    schema = generate_prisma_schema(snap)
-    assert "@@id([a_id, b_id])" in schema
-    assert "@id\n" not in schema.replace("@@id", "")  # no single-column @id emitted
-    ast.parse(generate_sqlalchemy_models({}))  # empty snapshot still valid
-
-
-def test_typeorm_entities_decorators_and_relations():
-    from app.spec.orm_codegen import generate_typeorm_entities
-
-    code = generate_typeorm_entities(SNAP)
-    assert '@Entity("member")' in code
-    assert "export class Member {" in code
-    assert "@PrimaryColumn()" in code
-    assert "member_id!: number;" in code
-    assert "joined_at?: Date | null;" in code
-    assert "@ManyToOne(() => Member)" in code
-    assert '@JoinColumn({ name: "member_id" })' in code
-    assert "@OneToMany(() => Orders" in code
-    # balanced braces => structurally sound TS
-    assert code.count("{") == code.count("}")
-
-
-def test_non_snake_db_names_are_mapped_to_safe_identifiers():
-    from app.spec.orm_codegen import generate_typeorm_entities
-
-    snap = {
-        "relations": [
-            {
-                "relation_oid": 1,
-                "relation_kind": "r",
-                "schema_name": "public",
-                "relation_name": "Order Items",
-                "relation_comment": 'quote " is fine',
-            }
-        ],
-        "columns": [
-            {"relation_oid": 1, "column_name": "Order ID", "column_position": 1, "data_type": "bigint", "is_not_null": True},
-            {"relation_oid": 1, "column_name": "class", "column_position": 2, "data_type": "text", "is_not_null": False},
-            {"relation_oid": 1, "column_name": "2FA Enabled", "column_position": 3, "data_type": "boolean", "is_not_null": True},
-        ],
-        "pk_columns": [{"relation_oid": 1, "column_name": "Order ID"}],
-        "fk_edges": [],
-    }
-
-    py_code = generate_sqlalchemy_models(snap)
-    ast.parse(py_code)
-    assert "class OrderItems(Base):" in py_code
-    assert "order_id: Mapped[int] = mapped_column('Order ID', primary_key=True)" in py_code
-    assert "class_: Mapped[str | None] = mapped_column('class')" in py_code
-    assert "column_2_fa_enabled: Mapped[bool] = mapped_column('2FA Enabled')" in py_code
-
-    prisma = generate_prisma_schema(snap)
-    assert "model OrderItems {" in prisma
-    assert 'order_id BigInt @id @map("Order ID")' in prisma
-    assert 'class_ String? @map("class")' in prisma
-    assert 'column_2_fa_enabled Boolean @map("2FA Enabled")' in prisma
-
-    ts_code = generate_typeorm_entities(snap)
-    assert '@Entity("Order Items")' in ts_code
-    assert '@PrimaryColumn({name: "Order ID"})' in ts_code
-    assert 'order_id!: number;' in ts_code
-    assert '@Column({name: "class", nullable: true})' in ts_code
-    assert 'class_?: string | null;' in ts_code
diff --git a/backend/tests/test_schema_stats.py b/backend/tests/test_schema_stats.py
deleted file mode 100644
index 37023eb2..00000000
--- a/backend/tests/test_schema_stats.py
+++ /dev/null
@@ -1,56 +0,0 @@
-from __future__ import annotations
-
-from app.spec.schema_stats import compute_schema_stats
-
-
-def _snap():
-    return {
-        "relations": [
-            {"relation_oid": 1, "relation_kind": "r", "schema_name": "public", "relation_name": "member"},
-            {"relation_oid": 2, "relation_kind": "r", "schema_name": "public", "relation_name": "orders"},
-            {"relation_oid": 3, "relation_kind": "v", "schema_name": "public", "relation_name": "v_report"},
-        ],
-        "columns": [
-            {"relation_oid": 1, "column_name": "member_id", "data_type": "bigint", "is_not_null": True},
-            {"relation_oid": 1, "column_name": "email", "data_type": "text", "is_not_null": True},
-            {"relation_oid": 1, "column_name": "nickname", "data_type": "text", "is_not_null": False},
-            {"relation_oid": 2, "column_name": "order_id", "data_type": "bigint", "is_not_null": True},
-        ],
-        "pk_columns": [{"relation_oid": 1, "column_name": "member_id"}],
-        "fk_edges": [{"child_relation_oid": 2, "parent_relation_oid": 1, "child_column_name": "member_id", "parent_column_name": "member_id"}],
-        "indexes": [{"relation_oid": 1, "index_name": "pk_member"}],
-    }
-
-
-def test_counts_relations_by_kind():
-    s = compute_schema_stats(_snap())
-    assert s["relations"]["table"] == 2
-    assert s["relations"]["view"] == 1
-    assert s["relations"]["total"] == 3
-
-
-def test_column_stats_and_widest_table():
-    s = compute_schema_stats(_snap())
-    assert s["columns"]["total"] == 4
-    assert s["columns"]["nullable"] == 1
-    assert s["columns"]["not_null"] == 3
-    assert s["columns"]["avg_per_table"] == 2.0  # 4 columns / 2 tables
-    assert s["columns"]["max_per_table"] == 3    # member has 3
-    assert s["widest_tables"][0] == {"table": "public.member", "columns": 3}
-
-
-def test_constraint_and_pk_coverage():
-    s = compute_schema_stats(_snap())
-    assert s["constraints"]["primary_keys"] == 1
-    assert s["constraints"]["foreign_keys"] == 1
-    assert s["constraints"]["indexes"] == 1
-    assert s["tables_without_primary_key"] == 1  # orders has no PK
-
-
-def test_data_type_distribution_and_empty():
-    s = compute_schema_stats(_snap())
-    assert s["data_types"]["bigint"] == 2
-    assert s["data_types"]["text"] == 2
-    empty = compute_schema_stats({})
-    assert empty["relations"]["total"] == 0
-    assert empty["columns"]["avg_per_table"] == 0.0
diff --git a/backend/tests/test_sensitive_columns.py b/backend/tests/test_sensitive_columns.py
deleted file mode 100644
index d30af25d..00000000
--- a/backend/tests/test_sensitive_columns.py
+++ /dev/null
@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-from app.spec.sensitive_columns import detect_sensitive_columns
-
-
-def _snap(columns):
-    return {
-        "relations": [{"relation_oid": 1, "schema_name": "public", "relation_name": "member"}],
-        "columns": [{"relation_oid": 1, "column_name": c} for c in columns],
-    }
-
-
-def _by_col(report):
-    return {i["column"]: (i["category"], i["severity"]) for i in report["items"]}
-
-
-def test_classifies_common_sensitive_columns():
-    report = detect_sensitive_columns(
-        _snap(["password_hash", "ssn", "credit_card_no", "email", "home_address", "date_of_birth", "first_name"])
-    )
-    byc = _by_col(report)
-    assert byc["password_hash"] == ("credential", "high")
-    assert byc["ssn"] == ("national_id", "high")
-    assert byc["credit_card_no"] == ("payment", "high")
-    assert byc["email"] == ("contact", "medium")
-    assert byc["home_address"] == ("location", "medium")
-    assert byc["date_of_birth"] == ("personal", "medium")
-    assert byc["first_name"] == ("name", "low")
-
-
-def test_ignores_plain_columns_and_sorts_high_first():
-    report = detect_sensitive_columns(_snap(["id", "created_at", "quantity", "email", "api_key"]))
-    cols = _by_col(report)
-    assert "id" not in cols and "quantity" not in cols
-    severities = [i["severity"] for i in report["items"]]
-    assert severities == sorted(severities, key={"high": 0, "medium": 1, "low": 2}.get)
-    assert report["summary"]["high"] == 1  # api_key
-
-
-def test_maps_findings_to_compliance_frameworks():
-    report = detect_sensitive_columns(_snap(["card_number", "email", "medical_history"]))
-    fw = {i["column"]: i["framework"] for i in report["items"]}
-    assert "PCI DSS" in fw["card_number"]
-    assert "GDPR" in fw["email"]
-    assert "sensitive" in fw["medical_history"].lower()  # special category
-    # per-framework breakdown lets a user answer "what is in PCI DSS scope?"
-    assert report["summary"]["by_framework"]["PCI DSS (cardholder data environment)"] == 1
-
-
-def test_first_most_sensitive_match_wins():
-    # a column matching multiple rules is classified by the most sensitive one
-    report = detect_sensitive_columns(_snap(["account_password"]))
-    assert _by_col(report)["account_password"][0] == "credential"
-
-
-def test_empty_snapshot():
-    assert detect_sensitive_columns({})["items"] == []
-    assert detect_sensitive_columns(None)["summary"]["total"] == 0
diff --git a/docs/ci-drift-check.md b/docs/ci-drift-check.md
deleted file mode 100644
index 07edf673..00000000
--- a/docs/ci-drift-check.md
+++ /dev/null
@@ -1,57 +0,0 @@
-# CI schema-drift gate
-
-Gate deploys on "the database schema matches the approved baseline". This is
-the highest-leverage automation the snapshot/diff APIs enable: schema changes
-stop sneaking into production unreviewed.
-
-## How it works
-
-1. **Baseline**: after a reviewed migration lands, take a snapshot and record
-   its UUID as the approved baseline (e.g. in your pipeline variables).
-2. **Check**: on every deploy, take a fresh snapshot of the target database and
-   diff it against the baseline:
-   `GET /api/snapshots/{target}/diff?against={baseline}`.
-3. **Gate**: `diff.summary.has_changes == false` → deploy proceeds. Otherwise
-   the pipeline fails and prints both the structured summary and the exact
-   migration SQL that would reconcile the drift
-   (`GET /api/snapshots/{target}/migration.sql?against={baseline}`).
-
-The diff is name-keyed (never `relation_oid`), so re-introspecting the same
-database yields a stable, empty diff — no false drift between runs.
-
-## Ready-made script
-
-[`scripts/ci/check_schema_drift.sh`](../scripts/ci/check_schema_drift.sh):
-
-```bash
-PG_ERD_BASE_URL=https://erd.example.com \
-PG_ERD_COOKIE="session=..." \
-./scripts/ci/check_schema_drift.sh "$BASELINE_SNAPSHOT_UUID" "$TARGET_SNAPSHOT_UUID"
-```
-
-Exit codes: `0` no drift · `1` drift detected (summary + migration SQL on
-stderr) · `2` snapshot missing/unauthorized.
-
-### GitHub Actions example
-
-```yaml
-- name: Schema drift gate
-  env:
-    PG_ERD_BASE_URL: ${{ vars.PG_ERD_BASE_URL }}
-    PG_ERD_COOKIE: ${{ secrets.PG_ERD_SESSION_COOKIE }}
-  run: |
-    ./scripts/ci/check_schema_drift.sh \
-      "${{ vars.SCHEMA_BASELINE_UUID }}" \
-      "${{ steps.snapshot.outputs.snapshot_uuid }}"
-```
-
-## Reviewing drift before promoting a baseline
-
-When drift is intentional (a planned migration), review it with:
-
-- `GET /diff?against=` — structured change list
-- `GET /migration-safety?against=` — each change classified
-  safe / warning / destructive
-- `GET /migration.sql?against=` — the reconciling SQL
-
-then promote the new snapshot UUID as the baseline.
diff --git a/docs/clearfolio-integration.md b/docs/clearfolio-integration.md
deleted file mode 100644
index ffb77c11..00000000
--- a/docs/clearfolio-integration.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# Clearfolio reference-document viewer — integration
-
-[Clearfolio](https://github.com/ContextualWisdomLab/clearfolio) is a document-viewer
-platform (Java backend + JS preview). pg-erd-cloud links it so a project can attach
-external reference documents (requirements, design specs, contracts — PDF/DOCX/PPT)
-and view them next to the ERD.
-
-## Architecture: pg-erd-cloud is the *buyer gateway*
-
-pg-erd-cloud authenticates its own user (OIDC / API key), maps the principal to
-Clearfolio tenant claims, **HMAC-signs** them, and proxies to Clearfolio's
-connector API. Clearfolio verifies the signature, enforces permissions, and
-isolates tenants.
-
-### Signing contract (must match Clearfolio's verifier)
-
-```
-payload   = "\n".join([tenantId, subjectId, canonicalPermissions, issuedAt])
-signature = base64url( HMAC_SHA256(secret, payload) )        # no padding
-```
-
-Sent as `X-Clearfolio-{Tenant-Id, Subject-Id, Permissions, Claims-Issued-At,
-Claims-Signature}`. Implemented in `app/integrations/clearfolio.py`
-(`sign_tenant_claims`, `build_tenant_headers`) and covered by a golden-vector test.
-
-### Connector calls (proxied, SSRF-validated gateway host)
-
-| Step | Clearfolio endpoint |
-| --- | --- |
-| Submit document | `POST /api/v1/convert/jobs` (multipart) |
-| Poll status | `GET /api/v1/convert/jobs/{jobId}` |
-| Viewer bootstrap | `GET /api/v1/viewer/{docId}` (signed previewResourcePath) |
-| Artifact link | `POST /api/v1/viewer/{docId}/artifact-links` |
-
-## Configuration
-
-```bash
-CLEARFOLIO_GATEWAY_URL=https://clearfolio.example.com
-CLEARFOLIO_TENANT_CLAIMS_HMAC_SECRET=<shared gateway secret>
-CLEARFOLIO_TENANT_ID=pg-erd-cloud            # default
-CLEARFOLIO_PERMISSIONS=job:create,job:read,job:retry,viewer:read,artifact-link:create,analytics:read
-```
-
-Unset → the connector raises `ClearfolioNotConfigured` (feature is opt-in; no live
-Clearfolio instance required for the rest of pg-erd-cloud).
-
-## Status / next
-
-- ✅ Connector core (signing + gateway client + config) — this PR, contract-mocked tests.
-- ⬜ Project-scoped endpoints + `reference_document` persistence (IDOR per project) — follow-up (needs the alembic chain).
-- ⬜ Frontend: attach/upload panel + embedded Clearfolio viewer bootstrap.
diff --git a/docs/llm-orchestrator-integration.md b/docs/llm-orchestrator-integration.md
deleted file mode 100644
index 8e8ddb14..00000000
--- a/docs/llm-orchestrator-integration.md
+++ /dev/null
@@ -1,53 +0,0 @@
-# LLM via Contextual Orchestrator
-
-pg-erd-cloud's LLM features (`reversing-spec.md?mode=llm-draft`,
-`index-design.md?mode=llm-draft`) call an **OpenAI-compatible** chat-completions
-endpoint (`app/spec/llm.py`: `POST {base}/chat/completions`, `Authorization:
-Bearer`, `{model, messages}`). [contextual-orchestrator](https://github.com/ContextualWisdomLab/contextual-orchestrator)
-exposes exactly that interface (`/v1/chat/completions`) while routing,
-delegating, verifying, and synthesizing across a pool of model agents.
-
-So the integration is **configuration only — no code change**.
-
-## Point pg-erd-cloud at the orchestrator
-
-```bash
-LLM_API_BASE_URL=https://<orchestrator-host>/v1
-LLM_API_KEY=<orchestrator inference bearer token>   # NOT the OpenAI key
-LLM_MODEL=contextual-orchestrator
-```
-
-pg-erd-cloud calls `${LLM_API_BASE_URL}/chat/completions` → the orchestrator's
-`/v1/chat/completions`. The orchestrator authenticates the Bearer token,
-orchestrates, and returns an OpenAI-shaped response.
-
-## Secret isolation (why this is better than calling OpenAI directly)
-
-The real **OpenAI API key lives only in the orchestrator's agent pool**, backed
-by the org Secret — pg-erd-cloud never holds it. pg-erd holds only the
-orchestrator's inference token.
-
-Orchestrator agent config (on the orchestrator side, env-backed key):
-
-```json
-{
-  "agents": [
-    {
-      "id": "coding_agent",
-      "endpoint": "https://api.openai.com/v1",
-      "api_key_env": "OPENAI_API_KEY",
-      "model": "gpt-4o"
-    }
-  ]
-}
-```
-
-Run: `python -m contextual_orchestrator --serve --agents agents.json \
---inference-token "$CONTEXTUAL_ORCHESTRATOR_TOKEN" --port 8000` with
-`OPENAI_API_KEY` supplied from the org Secret at deploy time.
-
-## Fallback
-
-Unset `LLM_API_*` → the LLM-draft endpoints raise `LlmConfigurationError`
-(503); the non-LLM `mode=markdown|llm-prompt` paths are unaffected. The
-integration is fully opt-in.
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 01e62762..edaeeea0 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -54,15 +54,12 @@ import {
   downloadText,
   exportDDL,
   exportDiagramSvg,
-  exportDictionaryCsv,
-  exportDictionaryMarkdown,
   exportPlantUml,
 } from "./erd/export";
 import { exportMermaid } from "./erd/mermaid";
 import { inferRelationships } from "./erd/autoInfer";
 import { exportDbml } from "./erd/dbml";
 import { GRID_COLUMNS, GRID_X_GAP, GRID_Y_GAP } from "./erd/layoutConstants";
-import { findSearchMatchedNodeIds } from "./erd/search";
 import type { Connection, Project, Snapshot, SnapshotDetail } from "./types";
 
 const TERMINAL_SNAPSHOT_STATUSES = new Set([
@@ -195,7 +192,25 @@ export default function App() {
   const nodeTypes = useMemo<NodeTypes>(() => ({ tableNode: TableNode }), []);
   const normalizedNodeSearch = nodeSearch.trim().toLocaleLowerCase();
   const searchMatchedNodeIds = useMemo(() => {
-    return findSearchMatchedNodeIds(nodes, normalizedNodeSearch);
+    if (!normalizedNodeSearch) return new Set<string>();
+    const matches = new Set<string>();
+    for (const node of nodes) {
+      const haystack = [
+        node.data.title,
+        node.data.comment ?? "",
+        ...node.data.columns.flatMap((column) => [
+          column.column_name,
+          column.data_type,
+          column.column_comment ?? "",
+        ]),
+      ]
+        .join(" ")
+        .toLocaleLowerCase();
+      if (haystack.includes(normalizedNodeSearch)) {
+        matches.add(node.id);
+      }
+    }
+    return matches;
   }, [nodes, normalizedNodeSearch]);
   const visibleNodes = useMemo(() => {
     if (!normalizedNodeSearch) return nodes;
@@ -622,22 +637,6 @@ export default function App() {
     downloadText("pg-erd-diagram.mermaid", exportMermaid(nodes, edges), "text/plain");
   }
 
-  function onExportDictionaryCsv() {
-    downloadText(
-      "data_dictionary.csv",
-      exportDictionaryCsv(nodes, edges),
-      "text/csv;charset=utf-8",
-    );
-  }
-
-  function onExportDictionaryMarkdown() {
-    downloadText(
-      "data_dictionary.md",
-      exportDictionaryMarkdown(nodes, edges),
-      "text/markdown;charset=utf-8",
-    );
-  }
-
   function onDownloadDbml() {
     downloadText("pg-erd-diagram.dbml", exportDbml(nodes, edges), "text/plain");
   }
@@ -1598,7 +1597,6 @@ export default function App() {
             isOpen={isExportModalOpen}
             isCopied={isCopied}
             hasDdlExport={nodes.length > 0}
-            hasDictionaryExport={nodes.length > 0}
             hasDiagramExport={nodes.length > 0}
             shareLinkUrl={shareLinkUrl}
             isCreatingShareLink={isCreatingShareLink}
@@ -1610,8 +1608,6 @@ export default function App() {
             onDownloadSvg={onDownloadSvg}
             onDownloadUml={onDownloadUml}
             onDownloadMermaid={onDownloadMermaid}
-            onExportDictionaryCsv={onExportDictionaryCsv}
-            onExportDictionaryMarkdown={onExportDictionaryMarkdown}
             onCreateShareLink={onCreateShareLink}
             onCopyShareLink={onCopyShareLink}
           />
diff --git a/frontend/src/components/modals/ExportModal.test.tsx b/frontend/src/components/modals/ExportModal.test.tsx
index 5e101d71..36fbd1f7 100644
--- a/frontend/src/components/modals/ExportModal.test.tsx
+++ b/frontend/src/components/modals/ExportModal.test.tsx
@@ -8,7 +8,6 @@ const baseProps = {
   isOpen: true,
   isCopied: false,
   hasDdlExport: true,
-  hasDictionaryExport: true,
   hasDiagramExport: true,
   shareLinkUrl: '',
   isCreatingShareLink: false,
@@ -20,8 +19,6 @@ const baseProps = {
   onDownloadSvg: vi.fn(),
   onDownloadUml: vi.fn(),
   onDownloadMermaid: vi.fn(),
-  onExportDictionaryCsv: vi.fn(),
-  onExportDictionaryMarkdown: vi.fn(),
   onCreateShareLink: vi.fn(),
   onCopyShareLink: vi.fn(),
 };
@@ -49,8 +46,6 @@ describe('ExportModal', () => {
     expect(screen.getByText('SVG 이미지')).toBeInTheDocument();
     expect(screen.getByText('PlantUML')).toBeInTheDocument();
     expect(screen.getByText('Mermaid')).toBeInTheDocument();
-    expect(screen.getByText('Data Dictionary CSV')).toBeInTheDocument();
-    expect(screen.getByText('Data Dictionary MD')).toBeInTheDocument();
   });
 
   it('copies an already generated share link', () => {
@@ -76,8 +71,6 @@ describe('ExportModal', () => {
     const onDownloadSvg = vi.fn();
     const onDownloadUml = vi.fn();
     const onDownloadMermaid = vi.fn();
-    const onExportDictionaryCsv = vi.fn();
-    const onExportDictionaryMarkdown = vi.fn();
 
     render(
       <ExportModal
@@ -86,8 +79,6 @@ describe('ExportModal', () => {
         onDownloadSvg={onDownloadSvg}
         onDownloadUml={onDownloadUml}
         onDownloadMermaid={onDownloadMermaid}
-        onExportDictionaryCsv={onExportDictionaryCsv}
-        onExportDictionaryMarkdown={onExportDictionaryMarkdown}
       />,
     );
 
@@ -95,15 +86,11 @@ describe('ExportModal', () => {
     fireEvent.click(screen.getByRole('button', { name: 'SVG 이미지 내보내기' }));
     fireEvent.click(screen.getByRole('button', { name: 'PlantUML 내보내기' }));
     fireEvent.click(screen.getByRole('button', { name: 'Mermaid 내보내기' }));
-    fireEvent.click(screen.getByRole('button', { name: '데이터 사전 CSV 내보내기' }));
-    fireEvent.click(screen.getByRole('button', { name: '데이터 사전 Markdown 내보내기' }));
 
     expect(onCopyExportDdl).toHaveBeenCalledOnce();
     expect(onDownloadSvg).toHaveBeenCalledOnce();
     expect(onDownloadUml).toHaveBeenCalledOnce();
     expect(onDownloadMermaid).toHaveBeenCalledOnce();
-    expect(onExportDictionaryCsv).toHaveBeenCalledOnce();
-    expect(onExportDictionaryMarkdown).toHaveBeenCalledOnce();
   });
 
   it('shows share link copy or creation errors', () => {
@@ -122,18 +109,15 @@ describe('ExportModal', () => {
       <ExportModal
         {...baseProps}
         hasDdlExport={false}
-        hasDictionaryExport={false}
         hasDiagramExport={false}
       />,
     );
 
-    expect(screen.getAllByText('먼저 테이블을 추가하세요')).toHaveLength(6);
+    expect(screen.getAllByText('먼저 테이블을 추가하세요')).toHaveLength(4);
     expect(screen.getByRole('button', { name: 'SQL DDL 복사' })).toBeDisabled();
     expect(screen.getByRole('button', { name: 'SVG 이미지 내보내기' })).toBeDisabled();
     expect(screen.getByRole('button', { name: 'PlantUML 내보내기' })).toBeDisabled();
     expect(screen.getByRole('button', { name: 'Mermaid 내보내기' })).toBeDisabled();
-    expect(screen.getByRole('button', { name: '데이터 사전 CSV 내보내기' })).toBeDisabled();
-    expect(screen.getByRole('button', { name: '데이터 사전 Markdown 내보내기' })).toBeDisabled();
   });
 
   it('exposes access-control guidance for disabled button', () => {
diff --git a/frontend/src/components/modals/ExportModal.tsx b/frontend/src/components/modals/ExportModal.tsx
index 9feebd03..1d4370a0 100644
--- a/frontend/src/components/modals/ExportModal.tsx
+++ b/frontend/src/components/modals/ExportModal.tsx
@@ -5,7 +5,6 @@ interface ExportModalProps {
   isOpen: boolean;
   isCopied: boolean;
   hasDdlExport: boolean;
-  hasDictionaryExport: boolean;
   hasDiagramExport: boolean;
   shareLinkUrl: string;
   isCreatingShareLink: boolean;
@@ -17,8 +16,6 @@ interface ExportModalProps {
   onDownloadSvg: () => void;
   onDownloadUml: () => void;
   onDownloadMermaid: () => void;
-  onExportDictionaryCsv: () => void;
-  onExportDictionaryMarkdown: () => void;
   onCreateShareLink: () => void;
   onCopyShareLink: () => void;
 }
@@ -36,7 +33,6 @@ export function ExportModal({
   isOpen,
   isCopied,
   hasDdlExport,
-  hasDictionaryExport,
   hasDiagramExport,
   shareLinkUrl,
   isCreatingShareLink,
@@ -48,8 +44,6 @@ export function ExportModal({
   onDownloadSvg,
   onDownloadUml,
   onDownloadMermaid,
-  onExportDictionaryCsv,
-  onExportDictionaryMarkdown,
   onCreateShareLink,
   onCopyShareLink,
 }: ExportModalProps) {
@@ -99,22 +93,6 @@ export function ExportModal({
       onExport: onDownloadMermaid,
       ariaLabel: 'Mermaid 내보내기',
     },
-    {
-      label: 'Data Dictionary CSV',
-      description: hasDictionaryExport ? '테이블/컬럼 목록' : '먼저 테이블을 추가하세요',
-      buttonLabel: '내보내기',
-      disabled: !hasDictionaryExport,
-      onExport: onExportDictionaryCsv,
-      ariaLabel: '데이터 사전 CSV 내보내기',
-    },
-    {
-      label: 'Data Dictionary MD',
-      description: hasDictionaryExport ? '마크다운 문서' : '먼저 테이블을 추가하세요',
-      buttonLabel: '내보내기',
-      disabled: !hasDictionaryExport,
-      onExport: onExportDictionaryMarkdown,
-      ariaLabel: '데이터 사전 Markdown 내보내기',
-    },
   ];
 
   return (
diff --git a/frontend/src/erd/TableNode.tsx b/frontend/src/erd/TableNode.tsx
index bf7c4709..8e364a4b 100644
--- a/frontend/src/erd/TableNode.tsx
+++ b/frontend/src/erd/TableNode.tsx
@@ -157,13 +157,9 @@ function TableNode(props: NodeProps<TableNodeNode>) {
                 </abbr>
               ) : null}
               {c.is_not_null ? (
-                <abbr
-                  className="tableNode__badge"
-                  title="Not Null"
-                  aria-label="필수 입력 (Not Null)"
-                >
-                  NN
-                </abbr>
+                <span className="tableNode__badge" title="Not Null" aria-label="필수 입력 (Not Null)">
+                  NOT NULL
+                </span>
               ) : null}
               <Handle
                 type="source"
diff --git a/frontend/src/erd/__tests__/TableNode.test.tsx b/frontend/src/erd/__tests__/TableNode.test.tsx
index 412e9533..ae2154c0 100644
--- a/frontend/src/erd/__tests__/TableNode.test.tsx
+++ b/frontend/src/erd/__tests__/TableNode.test.tsx
@@ -82,7 +82,7 @@ describe('TableNode', () => {
 
     const [notNullBadge] = screen.getAllByLabelText('필수 입력 (Not Null)');
     expect(notNullBadge).toHaveAttribute('title', 'Not Null');
-    expect(notNullBadge).toHaveTextContent('NN');
+    expect(notNullBadge).toHaveTextContent('NOT NULL');
   });
 
   it('uses a fallback accessible name for blank table titles', () => {
diff --git a/frontend/src/erd/__tests__/exportDataDictionary.test.ts b/frontend/src/erd/__tests__/exportDataDictionary.test.ts
deleted file mode 100644
index 85fa2737..00000000
--- a/frontend/src/erd/__tests__/exportDataDictionary.test.ts
+++ /dev/null
@@ -1,187 +0,0 @@
-import type { Edge, Node } from '@xyflow/react';
-import { describe, expect, it } from 'vitest';
-
-import type { TableNodeData } from '../convert';
-import { exportDictionaryCsv, exportDictionaryMarkdown } from '../exportDataDictionary';
-
-describe('exportDataDictionary', () => {
-  const nodes: Node<TableNodeData>[] = [
-    {
-      id: 'users',
-      type: 'tableNode',
-      position: { x: 0, y: 0 },
-      data: {
-        title: 'public.users',
-        comment: 'User accounts',
-        badges: { pk: true, fk: false },
-        columns: [
-          {
-            column_name: 'id',
-            data_type: 'integer',
-            is_pk: true,
-            is_not_null: true,
-            column_comment: 'Primary Key',
-            example_value: 1,
-          },
-          {
-            column_name: 'account_id',
-            data_type: 'integer',
-            is_pk: false,
-            is_not_null: true,
-            column_comment: null,
-            example_value: 42,
-          },
-          {
-            column_name: 'email',
-            data_type: 'varchar',
-            is_pk: false,
-            is_not_null: true,
-            column_comment: null,
-            example_value: 'test@example.com',
-          },
-        ],
-      },
-    },
-    {
-      id: 'accounts',
-      type: 'tableNode',
-      position: { x: 0, y: 0 },
-      data: {
-        title: 'public.accounts',
-        comment: null,
-        badges: { pk: true, fk: false },
-        columns: [
-          {
-            column_name: 'id',
-            data_type: 'integer',
-            is_pk: true,
-            is_not_null: true,
-            column_comment: null,
-            example_value: 1,
-          },
-        ],
-      },
-    },
-    {
-      id: 'empty_table',
-      type: 'tableNode',
-      position: { x: 0, y: 0 },
-      data: {
-        title: 'empty_table',
-        comment: null,
-        badges: { pk: false, fk: false },
-        columns: [],
-      },
-    },
-  ];
-
-  const edges: Edge[] = [
-    {
-      id: 'fk_users_accounts',
-      source: 'users',
-      target: 'accounts',
-      data: { sourceColumns: ['account_id'], targetColumns: ['id'] },
-    },
-  ];
-
-  it('exports table and column metadata to CSV', () => {
-    const csv = exportDictionaryCsv(nodes, edges);
-
-    expect(csv).toContain('"Table Name","Table Comment","Column Name","Data Type","PK","FK","Not Null","Column Comment","Example Value"');
-    expect(csv).toContain('"public.users","User accounts","id","integer","Y","N","Y","Primary Key","1"');
-    expect(csv).toContain('"public.users","User accounts","account_id","integer","N","Y","Y","","42"');
-    expect(csv).toContain('"public.users","User accounts","email","varchar","N","N","Y","","test@example.com"');
-    expect(csv).toContain('"empty_table","","","","","","","",""');
-  });
-
-  it('handles empty CSV exports', () => {
-    expect(exportDictionaryCsv([], edges)).toBe(
-      '"Table Name","Table Comment","Column Name","Data Type","PK","FK","Not Null","Column Comment","Example Value"',
-    );
-  });
-
-  it('neutralizes CSV formula injection and normalizes control characters', () => {
-    const csv = exportDictionaryCsv(
-      [
-        {
-          id: 'attack',
-          type: 'tableNode',
-          position: { x: 0, y: 0 },
-          data: {
-            title: '=HYPERLINK("https://example.invalid")',
-            comment: '@note\r\nsecond line',
-            badges: { pk: false, fk: false },
-            columns: [
-              {
-                column_name: '+cmd',
-                data_type: '-integer',
-                is_pk: false,
-                is_not_null: false,
-                column_comment: '@comment',
-                example_value: '\t=2+2',
-              },
-            ],
-          },
-        },
-      ],
-      [],
-    );
-
-    expect(csv).toContain('"\'=HYPERLINK(""https://example.invalid"")"');
-    expect(csv).toContain('"\'@note second line"');
-    expect(csv).toContain('"\'+cmd"');
-    expect(csv).toContain('"\'-integer"');
-    expect(csv).toContain('"\'@comment"');
-    expect(csv).toContain('"\' =2+2"');
-  });
-
-  it('exports table and column metadata to Markdown', () => {
-    const markdown = exportDictionaryMarkdown(nodes, edges);
-
-    expect(markdown).toContain('# Data Dictionary');
-    expect(markdown).toContain('## Table: public.users (User accounts)');
-    expect(markdown).toContain('| id | integer | Y | N | Y | Primary Key | 1 |');
-    expect(markdown).toContain('| account_id | integer | N | Y | Y |  | 42 |');
-    expect(markdown).toContain('## Table: empty_table');
-    expect(markdown).toContain('No columns.');
-  });
-
-  it('escapes Markdown table breakers and HTML-like content', () => {
-    const markdown = exportDictionaryMarkdown(
-      [
-        {
-          id: 'danger',
-          type: 'tableNode',
-          position: { x: 0, y: 0 },
-          data: {
-            title: 'orders|<script>\nnext',
-            comment: '<b>note</b>',
-            badges: { pk: false, fk: false },
-            columns: [
-              {
-                column_name: 'name|x',
-                data_type: 'text',
-                is_pk: false,
-                is_not_null: false,
-                column_comment: 'see [docs](javascript:alert(1))',
-                example_value: '<img src=x onerror=alert(1)>',
-              },
-            ],
-          },
-        },
-      ],
-      [],
-    );
-
-    expect(markdown).toContain('## Table: orders\\|&lt;script&gt; next (&lt;b&gt;note&lt;/b&gt;)');
-    expect(markdown).toContain('name\\|x');
-    expect(markdown).toContain('see \\[docs\\]\\(javascript:alert\\(1\\)\\)');
-    expect(markdown).toContain('&lt;img src=x onerror=alert\\(1\\)&gt;');
-    expect(markdown).not.toContain('<script>');
-    expect(markdown).not.toContain('<img');
-  });
-
-  it('handles empty Markdown exports', () => {
-    expect(exportDictionaryMarkdown([], edges)).toBe('# Data Dictionary\n\nNo tables found.');
-  });
-});
diff --git a/frontend/src/erd/__tests__/search.test.ts b/frontend/src/erd/__tests__/search.test.ts
deleted file mode 100644
index de341603..00000000
--- a/frontend/src/erd/__tests__/search.test.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import type { Node } from "@xyflow/react";
-import { describe, expect, it } from "vitest";
-
-import type { TableNodeData } from "../convert";
-import { findSearchMatchedNodeIds, tableNodeMatchesSearch } from "../search";
-
-function tableNode(
-  id: string,
-  data: Pick<TableNodeData, "title" | "columns"> &
-    Partial<Pick<TableNodeData, "comment">>,
-): Node<TableNodeData> {
-  return {
-    id,
-    type: "tableNode",
-    position: { x: 0, y: 0 },
-    data: {
-      badges: { pk: false, fk: false },
-      comment: null,
-      ...data,
-    },
-  };
-}
-
-describe("ERD node search", () => {
-  const users = tableNode("users", {
-    title: "public.users",
-    comment: "Customer profile records",
-    columns: [
-      {
-        column_name: "id",
-        data_type: "uuid",
-        is_not_null: true,
-        is_pk: true,
-      },
-      {
-        column_name: "email_address",
-        data_type: "text",
-        is_not_null: true,
-        is_pk: false,
-        column_comment: "Login email",
-      },
-    ],
-  });
-
-  const audit = tableNode("audit", {
-    title: "ops.audit_log",
-    columns: [
-      {
-        column_name: "payload",
-        data_type: "jsonb",
-        is_not_null: false,
-        is_pk: false,
-      },
-    ],
-  });
-
-  it("returns no matches for an empty search", () => {
-    expect([...findSearchMatchedNodeIds([users, audit], "   ")]).toEqual([]);
-  });
-
-  it("matches table and column fields without building a joined haystack", () => {
-    expect([...findSearchMatchedNodeIds([users, audit], "PUBLIC uuid")]).toEqual([
-      "users",
-    ]);
-    expect([...findSearchMatchedNodeIds([users, audit], "customer email")]).toEqual([
-      "users",
-    ]);
-    expect([...findSearchMatchedNodeIds([users, audit], "audit jsonb")]).toEqual([
-      "audit",
-    ]);
-  });
-
-  it("requires every search term to appear somewhere on the same node", () => {
-    expect(tableNodeMatchesSearch(users, "users jsonb")).toBe(false);
-    expect(tableNodeMatchesSearch(audit, "audit missing")).toBe(false);
-  });
-});
diff --git a/frontend/src/erd/export.ts b/frontend/src/erd/export.ts
index edd481d6..b172947e 100644
--- a/frontend/src/erd/export.ts
+++ b/frontend/src/erd/export.ts
@@ -4,8 +4,6 @@ import type { IndexRecommendation } from './cardinality';
 import type { ForeignKeyEdgeData, TableNodeData } from './convert';
 import { sourceColumnHandleId, targetColumnHandleId } from './handleUtils';
 
-export * from './exportDataDictionary';
-
 type SnapshotJson = {
   relations?: Array<{ relation_oid: number; schema_name: string; relation_name: string; relation_kind: string; relation_comment?: string | null }>
   columns?: Array<{ relation_oid: number; column_name: string; data_type: string; is_not_null: boolean; example_value?: string | number | boolean | null }>
@@ -94,11 +92,7 @@ export function exportDDL(nodes: Node<TableNodeData>[], edges: Edge[]): string {
   let ddl = '-- Generated DDL\n\n';
 
   // Bolt: Use map for O(1) node lookup instead of O(N) array find
-  // Avoid Map(array.map) to prevent O(N) intermediate tuple array allocation overhead
-  const nodesById = new Map<string, Node<TableNodeData>>();
-  for (const n of nodes) {
-    nodesById.set(n.id, n);
-  }
+  const nodesById = new Map(nodes.map(n => [n.id, n]));
 
   // Export tables
   for (const node of nodes) {
@@ -287,24 +281,19 @@ export function exportDiagramSvg(
   snapshot?: SnapshotJson | null,
 ): string {
   // Bolt: Use map for O(1) node lookup instead of O(N) array find
-  // Avoid Map(array.map) to prevent O(N) intermediate tuple array allocation overhead
-  const nodesById = new Map<string, Node<TableNodeData>>();
-  for (const n of nodes) {
-    nodesById.set(n.id, n);
-  }
+  const nodesById = new Map(nodes.map(n => [n.id, n]));
   const width = 280;
   const headerHeight = 34;
   const rowHeight = 22;
   const padding = 40;
   const indexes = indexesByRelation(snapshot);
-
-  // Avoid Map(array.map) to prevent O(N) intermediate tuple array allocation overhead
-  const heights = new Map<string, number>();
-  for (const node of nodes) {
-    // ponytail: cap rendered index rows; add full index export when the canvas carries index nodes.
-    const indexRows = Math.min((indexes.get(node.id)?.length || 0) + (node.data.indexes?.length || 0), 8);
-    heights.set(node.id, headerHeight + rowHeight * ((node.data.columns?.length || 0) + indexRows + (indexRows ? 1 : 0)));
-  }
+  const heights = new Map(
+    nodes.map((node) => {
+      // ponytail: cap rendered index rows; add full index export when the canvas carries index nodes.
+      const indexRows = Math.min((indexes.get(node.id)?.length || 0) + (node.data.indexes?.length || 0), 8);
+      return [node.id, headerHeight + rowHeight * ((node.data.columns?.length || 0) + indexRows + (indexRows ? 1 : 0))];
+    }),
+  );
   let minX = 0;
   let minY = 0;
   let maxX = width;
diff --git a/frontend/src/erd/exportDataDictionary.ts b/frontend/src/erd/exportDataDictionary.ts
deleted file mode 100644
index fe821640..00000000
--- a/frontend/src/erd/exportDataDictionary.ts
+++ /dev/null
@@ -1,162 +0,0 @@
-import type { Edge, Node } from '@xyflow/react';
-
-import type { ForeignKeyEdgeData, TableNodeData } from './convert';
-import { sourceColumnHandleId } from './handleUtils';
-
-const CONTROL_TEXT_RE = /[\u0000-\u001f\u007f]+/g;
-const CSV_FORMULA_RE = /^[=+\-@]/;
-const MARKDOWN_ESCAPE_RE = /[\\|`\[\]()]/g;
-const MARKDOWN_HTML_RE = /[&<>]/g;
-const MARKDOWN_HTML_ESCAPES: Record<string, string> = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-};
-
-function cellText(value: unknown): string {
-  return String(value ?? '').replace(CONTROL_TEXT_RE, ' ');
-}
-
-function csvCell(value: unknown): string {
-  const text = cellText(value);
-  const neutralized = CSV_FORMULA_RE.test(text.trimStart()) ? `'${text}` : text;
-  return `"${neutralized.replace(/"/g, '""')}"`;
-}
-
-function markdownText(value: unknown): string {
-  return cellText(value)
-    .replace(MARKDOWN_HTML_RE, (char) => MARKDOWN_HTML_ESCAPES[char] ?? char)
-    .replace(MARKDOWN_ESCAPE_RE, (char) => `\\${char}`);
-}
-
-function sourceColumnsForEdge(edge: Edge): Set<string> {
-  const columns = new Set<string>();
-  const data = edge.data as ForeignKeyEdgeData | undefined;
-  for (const column of data?.sourceColumns || []) {
-    if (column) columns.add(column);
-  }
-  return columns;
-}
-
-function foreignKeyColumnsByNode(edges: Edge[]): Map<string, Set<string>> {
-  const map = new Map<string, Set<string>>();
-
-  for (const edge of edges) {
-    let columns = map.get(edge.source);
-    if (!columns) {
-      columns = new Set<string>();
-      map.set(edge.source, columns);
-    }
-
-    for (const column of sourceColumnsForEdge(edge)) {
-      columns.add(column);
-    }
-  }
-
-  return map;
-}
-
-function isForeignKeyColumn(
-  edgeColumnsByNode: Map<string, Set<string>>,
-  node: Node<TableNodeData>,
-  columnName: string,
-  edges: Edge[],
-): boolean {
-  if (edgeColumnsByNode.get(node.id)?.has(columnName)) {
-    return true;
-  }
-
-  const handleId = sourceColumnHandleId(columnName);
-  return edges.some((edge) => edge.source === node.id && edge.sourceHandle === handleId);
-}
-
-function exampleValue(value: TableNodeData['columns'][number]['example_value']): string {
-  return value === null || value === undefined ? '' : String(value);
-}
-
-export function exportDictionaryCsv(
-  nodes: Node<TableNodeData>[],
-  edges: Edge[],
-): string {
-  const header = [
-    'Table Name',
-    'Table Comment',
-    'Column Name',
-    'Data Type',
-    'PK',
-    'FK',
-    'Not Null',
-    'Column Comment',
-    'Example Value',
-  ];
-  const rows: unknown[][] = [header];
-  const fkColumnsByNode = foreignKeyColumnsByNode(edges);
-
-  for (const node of nodes) {
-    const tableName = node.data.title || node.id;
-    const tableComment = node.data.comment || '';
-    const columns = node.data.columns || [];
-
-    if (columns.length === 0) {
-      rows.push([tableName, tableComment, '', '', '', '', '', '', '']);
-      continue;
-    }
-
-    for (const column of columns) {
-      rows.push([
-        tableName,
-        tableComment,
-        column.column_name,
-        column.data_type,
-        column.is_pk ? 'Y' : 'N',
-        isForeignKeyColumn(fkColumnsByNode, node, column.column_name, edges) ? 'Y' : 'N',
-        column.is_not_null ? 'Y' : 'N',
-        column.column_comment || '',
-        exampleValue(column.example_value),
-      ]);
-    }
-  }
-
-  return rows.map((row) => row.map(csvCell).join(',')).join('\n');
-}
-
-export function exportDictionaryMarkdown(
-  nodes: Node<TableNodeData>[],
-  edges: Edge[],
-): string {
-  const lines: string[] = ['# Data Dictionary', ''];
-  const fkColumnsByNode = foreignKeyColumnsByNode(edges);
-
-  if (nodes.length === 0) {
-    lines.push('No tables found.');
-    return lines.join('\n');
-  }
-
-  for (const node of nodes) {
-    const tableName = markdownText(node.data.title || node.id);
-    const tableComment = node.data.comment ? ` (${markdownText(node.data.comment)})` : '';
-    const columns = node.data.columns || [];
-    lines.push(`## Table: ${tableName}${tableComment}`);
-
-    if (columns.length === 0) {
-      lines.push('No columns.', '');
-      continue;
-    }
-
-    lines.push('| Column Name | Data Type | PK | FK | Not Null | Comment | Example |');
-    lines.push('|---|---|---|---|---|---|---|');
-
-    for (const column of columns) {
-      const pk = column.is_pk ? 'Y' : 'N';
-      const fk = isForeignKeyColumn(fkColumnsByNode, node, column.column_name, edges) ? 'Y' : 'N';
-      const notNull = column.is_not_null ? 'Y' : 'N';
-      const comment = column.column_comment || '';
-      lines.push(
-        `| ${markdownText(column.column_name)} | ${markdownText(column.data_type)} | ${pk} | ${fk} | ${notNull} | ${markdownText(comment)} | ${markdownText(exampleValue(column.example_value))} |`,
-      );
-    }
-    lines.push('');
-  }
-
-  return lines.join('\n').trim();
-}
diff --git a/frontend/src/erd/search.ts b/frontend/src/erd/search.ts
deleted file mode 100644
index 7e169562..00000000
--- a/frontend/src/erd/search.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import type { Node } from "@xyflow/react";
-
-import type { TableNodeData } from "./convert";
-
-function fieldIncludes(value: string | null | undefined, term: string): boolean {
-  return Boolean(value && value.toLocaleLowerCase().includes(term));
-}
-
-function nodeIncludesTerm(node: Node<TableNodeData>, term: string): boolean {
-  if (fieldIncludes(node.data.title, term)) return true;
-  if (fieldIncludes(node.data.comment, term)) return true;
-
-  for (const column of node.data.columns) {
-    if (fieldIncludes(column.column_name, term)) return true;
-    if (fieldIncludes(column.data_type, term)) return true;
-    if (fieldIncludes(column.column_comment, term)) return true;
-  }
-
-  return false;
-}
-
-export function tableNodeMatchesSearch(
-  node: Node<TableNodeData>,
-  search: string,
-): boolean {
-  const terms = Array.from(
-    new Set(search.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean)),
-  );
-  if (terms.length === 0) return false;
-  return terms.every((term) => nodeIncludesTerm(node, term));
-}
-
-export function findSearchMatchedNodeIds(
-  nodes: Array<Node<TableNodeData>>,
-  search: string,
-): Set<string> {
-  const matches = new Set<string>();
-  for (const node of nodes) {
-    if (tableNodeMatchesSearch(node, search)) {
-      matches.add(node.id);
-    }
-  }
-  return matches;
-}
diff --git a/scripts/ci/check_schema_drift.sh b/scripts/ci/check_schema_drift.sh
deleted file mode 100755
index 89feb4da..00000000
--- a/scripts/ci/check_schema_drift.sh
+++ /dev/null
@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# Gate a deploy on "no unexpected schema drift".
-#
-# Compares the latest schema snapshot (target) against an approved baseline
-# snapshot (base) via the diff API and fails the pipeline when the schema
-# changed. Pair with GET .../migration.sql to print the SQL that would
-# reconcile the drift.
-#
-# Usage:
-#   PG_ERD_BASE_URL=https://erd.example.com \
-#   PG_ERD_COOKIE="session=..." \
-#   ./check_schema_drift.sh <baseline_snapshot_uuid> <target_snapshot_uuid>
-#
-# Exit codes:
-#   0  no drift (schemas identical)
-#   1  drift detected (diff summary printed, migration SQL printed)
-#   2  usage / API error (snapshot missing or unauthorized)
-set -euo pipefail
-
-usage() {
-  echo "usage: check_schema_drift.sh <baseline_uuid> <target_uuid>" >&2
-  echo "required env: PG_ERD_BASE_URL and PG_ERD_COOKIE" >&2
-}
-
-if [ "$#" -ne 2 ]; then
-  echo "drift-check: expected exactly 2 snapshot UUID arguments; got $#." >&2
-  usage
-  exit 2
-fi
-
-if [ -z "${PG_ERD_BASE_URL:-}" ]; then
-  echo "drift-check: PG_ERD_BASE_URL is not set." >&2
-  usage
-  exit 2
-fi
-
-if [ -z "${PG_ERD_COOKIE:-}" ]; then
-  echo "drift-check: PG_ERD_COOKIE is not set." >&2
-  usage
-  exit 2
-fi
-
-BASE_UUID="$1"
-TARGET_UUID="$2"
-
-api() {
-  local path="$1"
-  if ! curl --fail --silent --show-error \
-    --cookie "${PG_ERD_COOKIE}" \
-    "${PG_ERD_BASE_URL}${path}"
-  then
-    echo "drift-check: API request failed for ${path}." >&2
-    return 1
-  fi
-}
-
-if ! DIFF_JSON="$(api "/api/snapshots/${TARGET_UUID}/diff?against=${BASE_UUID}")"; then
-  echo "drift-check: unable to fetch schema diff for target=${TARGET_UUID} against baseline=${BASE_UUID}." >&2
-  exit 2
-fi
-
-if ! STATUS="$(printf '%s' "${DIFF_JSON}" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("status",""))')"; then
-  echo "drift-check: diff API response was not valid JSON." >&2
-  exit 2
-fi
-if [ "${STATUS}" != "ok" ]; then
-  echo "drift-check: snapshot not found or unauthorized (status=${STATUS})" >&2
-  exit 2
-fi
-
-if ! HAS_CHANGES="$(printf '%s' "${DIFF_JSON}" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(str(d["diff"]["summary"]["has_changes"]).lower())')"; then
-  echo "drift-check: diff API response is missing diff.summary.has_changes." >&2
-  exit 2
-fi
-
-if [ "${HAS_CHANGES}" = "false" ]; then
-  echo "drift-check: OK - schema matches the approved baseline."
-  exit 0
-fi
-
-echo "drift-check: DRIFT DETECTED - schema differs from the approved baseline." >&2
-printf '%s' "${DIFF_JSON}" | python3 -c 'import json,sys; print(json.dumps(json.load(sys.stdin)["diff"]["summary"], indent=2))' >&2
-echo "--- migration SQL that would reconcile the drift ---" >&2
-api "/api/snapshots/${TARGET_UUID}/migration.sql?against=${BASE_UUID}" >&2 || true
-exit 1

From 91a03366d3afb791c2217efdb9e2b6e946448087 Mon Sep 17 00:00:00 2001
From: seonghobae <8172694+seonghobae@users.noreply.github.com>
Date: Sun, 12 Jul 2026 15:32:21 +0000
Subject: [PATCH 3/4] =?UTF-8?q?=F0=9F=8E=A8=20Palette:=20[UX=20improvement?=
 =?UTF-8?q?]=20Enhance=20accessibility=20for=20table-based=20modal=20forms?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit


From 2d3d9c467dde9e5b14b2f5b941b53482a66b106a Mon Sep 17 00:00:00 2001
From: seonghobae <8172694+seonghobae@users.noreply.github.com>
Date: Sun, 12 Jul 2026 16:40:22 +0000
Subject: [PATCH 4/4] =?UTF-8?q?=F0=9F=8E=A8=20Palette:=20[UX=20improvement?=
 =?UTF-8?q?]=20Enhance=20accessibility=20for=20table-based=20modal=20forms?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .github/workflows/codeql.yml                  |  40 ---
 .github/workflows/dependency-review.yml       |  16 -
 .github/workflows/scorecard.yml               |  42 ---
 .jules/bolt.md                                |   3 +
 AGENTS.md                                     | 101 ++++++
 CHANGELOG.md                                  |   1 +
 CLAUDE.md                                     | 120 +++++++
 backend/app/api/dbml.py                       |  36 ++
 backend/app/api/snapshots.py                  | 189 ++++++++++
 backend/app/db_introspect.py                  |   9 +-
 backend/app/integrations/__init__.py          |   0
 backend/app/integrations/clearfolio.py        | 202 +++++++++++
 backend/app/main.py                           |   2 +
 backend/app/mysql_introspect/__init__.py      |   3 +
 backend/app/mysql_introspect/introspect.py    | 331 ++++++++++++++++++
 backend/app/schemas.py                        |  65 ++++
 backend/app/settings.py                       |   9 +
 backend/app/spec/audit_columns.py             |  88 +++++
 backend/app/spec/constraint_inventory.py      |  94 +++++
 backend/app/spec/dbml_import.py               | 323 +++++++++++++++++
 backend/app/spec/fk_cycles.py                 | 129 +++++++
 backend/app/spec/index_redundancy.py          | 100 ++++++
 backend/app/spec/orm_codegen.py               | 307 ++++++++++++++++
 backend/app/spec/schema_stats.py              |  89 +++++
 backend/app/spec/sensitive_columns.py         |  90 +++++
 backend/tests/test_audit_columns.py           |  56 +++
 backend/tests/test_clearfolio.py              | 145 ++++++++
 backend/tests/test_constraint_inventory.py    |  60 ++++
 backend/tests/test_db_introspect.py           |  55 ++-
 backend/tests/test_dbml_import.py             | 112 ++++++
 backend/tests/test_fk_cycles.py               |  50 +++
 backend/tests/test_index_redundancy.py        |  66 ++++
 backend/tests/test_mysql_introspect.py        | 100 ++++++
 backend/tests/test_orm_codegen.py             | 141 ++++++++
 backend/tests/test_schema_stats.py            |  56 +++
 backend/tests/test_sensitive_columns.py       |  58 +++
 docs/ci-drift-check.md                        |  57 +++
 docs/clearfolio-integration.md                |  51 +++
 docs/llm-orchestrator-integration.md          |  53 +++
 frontend/src/App.tsx                          |  42 ++-
 .../components/modals/ExportModal.test.tsx    |  18 +-
 .../src/components/modals/ExportModal.tsx     |  22 ++
 frontend/src/erd/TableNode.tsx                |  10 +-
 frontend/src/erd/__tests__/TableNode.test.tsx |   2 +-
 .../__tests__/exportDataDictionary.test.ts    | 187 ++++++++++
 frontend/src/erd/__tests__/search.test.ts     |  77 ++++
 frontend/src/erd/export.ts                    |  29 +-
 frontend/src/erd/exportDataDictionary.ts      | 162 +++++++++
 frontend/src/erd/search.ts                    |  44 +++
 scripts/ci/check_schema_drift.sh              |  85 +++++
 50 files changed, 3994 insertions(+), 133 deletions(-)
 delete mode 100644 .github/workflows/codeql.yml
 delete mode 100644 .github/workflows/dependency-review.yml
 delete mode 100644 .github/workflows/scorecard.yml
 create mode 100644 AGENTS.md
 create mode 100644 CLAUDE.md
 create mode 100644 backend/app/api/dbml.py
 create mode 100644 backend/app/integrations/__init__.py
 create mode 100644 backend/app/integrations/clearfolio.py
 create mode 100644 backend/app/mysql_introspect/__init__.py
 create mode 100644 backend/app/mysql_introspect/introspect.py
 create mode 100644 backend/app/spec/audit_columns.py
 create mode 100644 backend/app/spec/constraint_inventory.py
 create mode 100644 backend/app/spec/dbml_import.py
 create mode 100644 backend/app/spec/fk_cycles.py
 create mode 100644 backend/app/spec/index_redundancy.py
 create mode 100644 backend/app/spec/orm_codegen.py
 create mode 100644 backend/app/spec/schema_stats.py
 create mode 100644 backend/app/spec/sensitive_columns.py
 create mode 100644 backend/tests/test_audit_columns.py
 create mode 100644 backend/tests/test_clearfolio.py
 create mode 100644 backend/tests/test_constraint_inventory.py
 create mode 100644 backend/tests/test_dbml_import.py
 create mode 100644 backend/tests/test_fk_cycles.py
 create mode 100644 backend/tests/test_index_redundancy.py
 create mode 100644 backend/tests/test_mysql_introspect.py
 create mode 100644 backend/tests/test_orm_codegen.py
 create mode 100644 backend/tests/test_schema_stats.py
 create mode 100644 backend/tests/test_sensitive_columns.py
 create mode 100644 docs/ci-drift-check.md
 create mode 100644 docs/clearfolio-integration.md
 create mode 100644 docs/llm-orchestrator-integration.md
 create mode 100644 frontend/src/erd/__tests__/exportDataDictionary.test.ts
 create mode 100644 frontend/src/erd/__tests__/search.test.ts
 create mode 100644 frontend/src/erd/exportDataDictionary.ts
 create mode 100644 frontend/src/erd/search.ts
 create mode 100755 scripts/ci/check_schema_drift.sh

diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
deleted file mode 100644
index 136cb2f1..00000000
--- a/.github/workflows/codeql.yml
+++ /dev/null
@@ -1,40 +0,0 @@
-name: codeql-ci-sast
-
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-  schedule:
-    - cron: "17 2 * * 2"
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-    strategy:
-      fail-fast: false
-      matrix:
-        language: ["javascript-typescript", "python"]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
-        with:
-          languages: ${{ matrix.language }}
-
-      - name: Autobuild
-        uses: github/codeql-action/autobuild@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
-
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
diff --git a/.github/workflows/dependency-review.yml b/.github/workflows/dependency-review.yml
deleted file mode 100644
index 7952e40b..00000000
--- a/.github/workflows/dependency-review.yml
+++ /dev/null
@@ -1,16 +0,0 @@
-name: dependency-review
-
-on:
-  pull_request:
-
-permissions:
-  contents: read
-
-jobs:
-  dependency-review:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
-      - name: Dependency Review
-        uses: actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5.0.0
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
deleted file mode 100644
index 75c2c990..00000000
--- a/.github/workflows/scorecard.yml
+++ /dev/null
@@ -1,42 +0,0 @@
----
-name: scorecard
-
-"on":
-  branch_protection_rule:
-  schedule:
-    - cron: "30 1 * * 6"
-  push:
-    branches: ["main"]
-
-permissions:
-  contents: read
-
-jobs:
-  analysis:
-    permissions:
-      contents: read
-      # Private repos may need extra job-level reads to avoid GraphQL
-      # "Resource not accessible by integration" (e.g., ListCommits).
-      issues: read
-      pull-requests: read
-      checks: read
-      security-events: write
-      id-token: write
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
-        with:
-          persist-credentials: false
-
-      - name: Run Scorecard
-        uses: ossf/scorecard-action@62b2cac7ed8198b15735ed49ab1e5cf35480ba46  # v2.4.0
-        with:
-          results_file: results.sarif
-          results_format: sarif
-          publish_results: true
-
-      - name: Upload SARIF
-        uses: github/codeql-action/upload-sarif@8aad20d150bbac5944a9f9d289da16a4b0d87c1e  # v4.36.2
-        with:
-          sarif_file: results.sarif
diff --git a/.jules/bolt.md b/.jules/bolt.md
index a016530d..463dc25b 100644
--- a/.jules/bolt.md
+++ b/.jules/bolt.md
@@ -60,6 +60,9 @@ Optimized metric route processing to O(N) by creating a mapping of routes direct
 ## 2026-06-25 - Avoid Map allocations in frontend ERD loops and mutate asyncpg records in-place
 **Learning:** The frontend `snapshotToGraph` iterates over thousands of columns to generate the graph, so repeated lookups and redundant collection assignments increase GC pressure. Backend snapshot column dictionaries are freshly instantiated for the payload, so `add_column_examples` can safely fill missing fields in place.
 **Action:** Reuse existing collections while aggregating relational data, create `Map`/`Set` entries only on first use, and check for missing example fields before calling expensive inference helpers.
+## 2024-07-07 - Avoid new Map(array.map(...)) for Large Datasets
+**Learning:** Using `new Map(array.map(item => [key, val]))` creates a completely unnecessary intermediate O(N) array of tuple arrays. This forces the garbage collector to immediately clean up the mapped array and the individual tuples once the Map is constructed, leading to memory spikes and GC pauses in large ERD diagrams during export.
+**Action:** Replace `new Map(array.map(...))` with `const map = new Map();` and an iterative `for (const item of array) { map.set(key, item); }` loop to reduce intermediate garbage allocations to zero.
 
 ## 2024-05-18 - [Optimize Node Resolution in autoInfer.ts]
 **Learning:** Found an O(N^2) loop where `nodes.find` scanning via string splitting was running inside an `O(N)` loop to match foreign key relationships. Additionally, noticed two nested O(C) loops checking the same column array. Replaced the top-level loop with an O(1) `Map` lookup and the inner loop with a single O(C) scan using a standard `for...of` loop with early exits.
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..ec76a127
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,101 @@
+# AGENTS.md
+
+Cross-agent conventions for this repo (`pg-erd-cloud`), readable by any coding
+agent (Claude, Codex, Cursor, opencode, …). This is a Python backend
+(`backend/`, FastAPI + SQLAlchemy/Alembic) plus a TypeScript/Vite frontend
+(`frontend/`), shipped via Docker Compose (`compose.yaml`, `compose.prod.yaml`)
+behind Traefik (`deploy/traefik/`).
+
+<!-- BEGIN cwl-agent-guidance -->
+## Agent guidance (CWL governance)
+
+### Security & review gate
+
+- Every PR runs a central, required **Security Scan** gate: `osv-scan` +
+  `dependency-review` (diff-scoped, moderate/Medium and above) and `trivy-fs`
+  (repo-wide, CRITICAL/HIGH/MEDIUM). It runs against **every PR base, including
+  stacked PRs**.
+- A failing **`trivy-fs`, `osv-scan`, or `dependency-review` is a REAL
+  finding, not a flake.** Read the job log and the run's SARIF/artifacts so the
+  specific package, advisory, CVE/GHSA/OSV id, severity, and affected file are
+  visible, then **remediate Medium and above** — do not weaken or disable the
+  gate:
+  - Vulnerable dependency: bump it. Python lives in `backend/requirements.lock`
+    / `backend/requirements-dev.lock` (hash-locked) and `backend/pyproject.toml`;
+    frontend in `frontend/package.json` + `frontend/package-lock.json` /
+    `frontend/pnpm-lock.yaml`.
+  - Container/config misconfig: fix the offending `backend/Dockerfile`,
+    `frontend/Dockerfile`, `frontend/Dockerfile.prod`, the `compose*.yaml`
+    files, or `deploy/traefik/dynamic.yaml`.
+  - Genuine false positive only: add a narrow, **documented** `.trivyignore`
+    (or `.trivyignore.yaml`) entry — scoped and with a reason.
+- Reproducing locally: a stale local DB misses findings. Run
+  `trivy --download-db-only` first, and scan the **merge ref** (PR merged into
+  base), not just the PR head.
+- The org `code_scanning` ruleset is intentionally **CodeQL-only** (multiple
+  code-scanning tools can't converge on one PR ref). Gating is by the Security
+  Scan **job result**, not the `code_scanning` rule — do **not** add tools to
+  that rule.
+
+### Code exploration
+
+- Always initialize CodeGraph in the active worktree (`codegraph init`) before
+  substantial review or remediation, and run `codegraph sync` after edits. Use
+  it to inspect callers, callees, and impact radius before relying on local
+  intuition.
+- Also use `rg`/structured search for text, generated files, sparse checkouts,
+  and languages CodeGraph cannot parse. A missing or partial CodeGraph result is
+  not proof that a behavior or dependency path is absent; record the limitation
+  in the PR/check evidence when it matters.
+
+### Config & secrets (KV, not env)
+
+- Org rule: at runtime, do **not** read config/secrets via `os.getenv()` /
+  raw environment variables. Read them from a KV / credential registry. Org
+  Actions secrets (e.g. `OPENAI_API_KEY`) flow **into** the KV via a
+  bootstrap/CI step; runtime reads from the KV — env is only transport into the
+  KV, never the runtime source.
+- Reference implementation: `xtrmLLMBatchPython`'s pgcrypto-encrypted Postgres
+  credential registry (`get_credential(name)`). Reuse that pattern (a DB-backed
+  KV is fine) unless a dedicated KV is adopted.
+- **Known deviation to migrate (this repo):** `backend/app/settings.py`
+  (`Settings(BaseSettings)`) currently loads runtime secrets/config directly
+  from the environment / `.env` — `app_secret` (DSN encryption key),
+  `database_url`, `llm_api_key`, and the OIDC/Valkey credentials. The
+  Docker/Podman `*_FILE` pattern for `app_secret` is a step in the right
+  direction, but env is still the runtime source. Migrate these reads to a
+  KV / credential registry (`get_credential(name)`); keep env only as the
+  bootstrap path that seeds the KV.
+
+### This repo's role in the ecosystem
+
+- **This repo (`pg-erd-cloud`):** ERD tool for developers and data architects
+  (project-management context).
+- The org is an ecosystem built around **naruon** — the hub: an email/PIM that
+  DOM-decomposes emails and files into a persisted knowledge graph. Each
+  component below is a **standalone program that must ALSO work as a git
+  submodule**, grown separately and together:
+  - **waf-ids-ai-soc** — WAF / IDS / AI SOC / load balancer / API management.
+  - **clearfolio** — document viewer.
+  - **pg-erd-cloud** — ERD tool (this repo).
+  - **contextual-orchestrator** — LLM cost/perf/upstream-LB gateway (beyond
+    LiteLLM).
+  - **codec-carver** — STT / omni-modal speech-video codec.
+  - **fast-mlsirm** — LLM-as-a-Judge calibration + evaluation-item quality
+    (uses aFIPC FIPC + kaefa item-fit).
+  - **feelanet-adfs** — passwordless SSO (OIDC / SCIM / ADFS / LDAP / FIDO2 /
+    OAuth2.1; eliminate passwords).
+  - **newsdom-api** — PDF→DOM sidecar.
+  - **semantic-data-portal** — upper ontology / catalog / governance plane with
+    its own graph engine.
+
+### Research grounding (attach paper PDFs)
+
+- Org rule: substantive feature/process PRs should find the relevant academic
+  papers and **commit their PDFs into the PR** (e.g. a `docs/papers/` or
+  `references/` dir) with full citations. Respect copyright: attach the PDF
+  only when redistribution is permissible; otherwise cite + link + summarize.
+- For this repo (ERD / schema design), ground substantive work in the relevant
+  literature — e.g. data modeling, ER theory, schema normalization, or
+  graph/layout algorithms for diagram rendering.
+<!-- END cwl-agent-guidance -->
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9a632832..519bee6c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,3 +6,4 @@
 - [FE] 📋 **테이블 복제 기능 추가**: 편집 모달 내에서 기존 테이블의 구조(컬럼 정보 포함)를 그대로 복사하여 새 테이블 노드로 생성하는 '복제' 버튼을 추가했습니다.
 - [FE] `autoInfer.ts`에 대한 단위 테스트 및 UI 컴포넌트 단위 테스트를 추가하여 100% 테스트 커버리지를 유지합니다.
 - [FE] ⬇️ **DBML Export**: ERD 다이어그램을 DBML (Database Markup Language) 형식으로 내보낼 수 있는 기능을 추가했습니다. 상단의 DBML 버튼을 클릭하여 다운로드할 수 있습니다.
+- [FE] 📚 **Data Dictionary Export**: ERD 테이블/컬럼 메타데이터를 CSV 및 Markdown으로 내보내며, CSV formula injection과 Markdown 렌더링 escape를 적용했습니다.
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..e13a3f78
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,120 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+pg-erd-cloud is a PostgreSQL-focused cloud ERD (entity-relationship diagram) collaboration/sharing service — currently a runnable MVP skeleton. It reverse-engineers a target PostgreSQL database (optionally Snowflake) into JSON schema snapshots, renders them as an interactive ERD (React Flow), and forward-engineers snapshots into DDL exports (PostgreSQL or Snowflake dialect), schema diffs/migration SQL, DBML/Mermaid exports, and "DB reversing spec" documents (markdown draft, LLM prompt, or live LLM draft via an OpenAI-compatible provider configured with `LLM_API_BASE_URL`/`LLM_API_KEY`/`LLM_MODEL`). Project owners can create share links for unauthenticated read/export access.
+
+Repository docs are mixed-language: README.md and CHANGELOG.md are Korean; CONTRIBUTING.md, SECURITY.md, and most of docs/ are English.
+
+## Common commands
+
+### Full stack (Docker, dev)
+
+```bash
+cp .env.example .env   # set POSTGRES_PASSWORD and APP_SECRET
+docker compose up -d --build
+```
+
+Frontend: http://localhost:5173 · Backend: http://localhost:8000 (health: `/healthz`). Source directories are bind-mounted; backend runs with `--reload` and frontend runs the Vite dev server, so edits hot-reload.
+
+### Backend (backend/, Python ≥3.10, CI uses 3.10)
+
+```bash
+cd backend
+python -m venv .venv && source .venv/bin/activate
+pip install -U pip
+pip install -e .                 # add ".[snowflake]" for Snowflake reverse engineering
+alembic upgrade head             # apply migrations (backend/alembic/versions)
+hypercorn --config python:app.hypercorn_config app.main:app \
+  --bind 0.0.0.0:8000 --reload --access-logfile - --error-logfile -
+```
+
+Checks (mirror CI):
+
+```bash
+cd backend
+PYTHONPATH=. mypy app
+PYTHONPATH=. pytest -q
+PYTHONPATH=. pytest -q tests/test_snapshot_job.py                # single file
+PYTHONPATH=. pytest -q tests/test_snapshot_job.py::test_name     # single test
+```
+
+CI installs backend deps with `pip install --require-hashes -r requirements-dev.lock`. The lockfiles are generated with uv (see header comments in `backend/requirements*.lock`); when changing dependencies in `backend/pyproject.toml`, regenerate both lockfiles, e.g.:
+
+```bash
+uv pip compile backend/pyproject.toml --python-version 3.10 --generate-hashes -o backend/requirements.lock
+uv pip compile backend/pyproject.toml --python-version 3.10 --generate-hashes --extra dev -o backend/requirements-dev.lock
+```
+
+### Frontend (frontend/, Node 26 — see .nvmrc / engines)
+
+```bash
+cd frontend
+npm ci
+npm run dev                                              # Vite dev server on 5173
+npm run typecheck                                        # tsc --noEmit
+npm run test                                             # vitest run
+npm run test -- src/erd/__tests__/cardinality.test.ts    # single test file
+npm run build                                            # tsc -b && vite build
+```
+
+CI uses npm with `package-lock.json` (a `pnpm-lock.yaml` also exists, but CI caches npm).
+
+### Production-style (Docker + Traefik)
+
+```bash
+cp .env.example .env
+mkdir -p secrets
+# write a long random value to secrets/app_secret (never commit; .gitignore covers **/secrets/**)
+chmod 600 secrets/app_secret
+docker compose -f compose.prod.yaml up -d --build
+```
+
+App entrypoint: http://localhost:8080 (`TRAEFIK_HTTP_PORT`).
+
+## Architecture
+
+Three deployable pieces in one repo:
+
+- **backend/** — Python FastAPI app (async SQLAlchemy 2 + asyncpg on PostgreSQL 16), served by Hypercorn. The app's own PostgreSQL stores metadata: users, project spaces/members, encrypted DB connections, schema snapshots, job queue, diagram views, annotations, share links, API keys (`app/models.py`).
+- **frontend/** — React 19 + TypeScript + Vite SPA. The ERD canvas is built on `@xyflow/react` (React Flow). Core ERD logic lives in `src/erd/` (snapshot→graph conversion, cardinality, FK auto-inference, DBML/Mermaid/SQL export); modal dialogs in `src/components/modals/`. Tests use Vitest + Testing Library (plus fast-check fuzz tests).
+- **deploy/traefik/** — Traefik dynamic config used by `compose.prod.yaml`.
+
+### Backend layout (backend/app/)
+
+- `api/` — FastAPI routers (projects, connections, snapshots, share, diagram_views, annotations, api_keys, auth_routes, me), all mounted in `main.py` under `/api`.
+- `jobs/` — Postgres-backed job queue (`JobQueue` table). Reverse engineering never blocks the request path: the API enqueues a `snapshot` job, and an in-process worker task (started in the FastAPI lifespan in `main.py`) claims and executes it. Optional Valkey/Redis (`valkey_queue.py`) is only a wake-up signal; Postgres remains the source of truth.
+- `pg_introspect/` — pg_catalog-based introspection of the *target* PostgreSQL: schemas/tables/columns, PK/FK/UNIQUE/CHECK, indexes. Index access methods are discovered dynamically from `pg_am`/`pg_class.relam` and index DDL is preserved losslessly via `pg_get_indexdef()` — do not hardcode an index-type list (project principle, see README). Also synthesizes safe `example_value` column hints from name/type metadata only (never samples real table data).
+- `snowflake_introspect/` — optional Snowflake reverse engineering (INFORMATION_SCHEMA; requires the `snowflake` extra).
+- `ddl/` — forward engineering: snapshot → DDL export with dialect mapping, migration SQL, migration-safety checks.
+- `diff/` — snapshot-to-snapshot schema diff.
+- `spec/` — reversing-spec generation, naming lint, data dictionary, relationship inference, LLM integration.
+- Cross-cutting: `auth.py` (OIDC/Casdoor JWT verification when `OIDC_ISSUER` is set, plus API keys and token revocation), `csrf.py`, `rate_limit.py` (in-memory fixed-window; global `/api/*` limit plus a stricter separate limit for public `/api/share/*`), `security_headers.py`, `observability.py` (JSON request logs + Prometheus metrics — see docs/observability.md), `sanitize.py`/`dsn_redaction.py`, `settings.py` (pydantic-settings; env vars are documented in `.env.example`).
+
+### Data flow
+
+1. A user registers a target-DB connection; the DSN is encrypted with `APP_SECRET` before being stored in the app DB.
+2. Requesting a snapshot enqueues a job; the background worker connects to the target DB, introspects it, and stores a JSON snapshot (`SchemaSnapshot` + `SchemaSnapshotData`).
+3. The frontend fetches snapshots via `/api/*` and renders the ERD; all exports (DDL, diff/migration SQL, reversing spec, DBML/Mermaid) are derived from the stored snapshot, not from live DB access.
+4. Share links expose read-only snapshot/export routes under `/api/share/{share_uuid}/...` with a tighter rate limit, and sensitive fields (schema comments, example values) are redacted from publicly shared payloads.
+
+### Dev vs prod compose
+
+- `compose.yaml` (dev): postgres + backend + frontend. Bind mounts and hot reload; backend on 127.0.0.1:8000, frontend on 127.0.0.1:5173; `APP_SECRET` comes from `.env`; CORS allows http://localhost:5173.
+- `compose.prod.yaml`: adds a Traefik edge router on :8080 that routes `/api/*` and `/healthz` to the backend and everything else to a static frontend (`frontend/Dockerfile.prod` builds `dist/` served by `serve-static.mjs`). No bind mounts or reload; `APP_SECRET` is injected as a Docker secret file (`APP_SECRET_FILE=/run/secrets/app_secret`); only Traefik is published. Traefik also applies security-headers middleware (`deploy/traefik/dynamic.yaml`).
+- Both compose files run `alembic upgrade head` before starting the backend, so migrations must always be committed alongside model changes.
+
+## Conventions and gotchas
+
+- `APP_SECRET` is the encryption key for stored DSNs — changing it breaks decryption of existing data. Prefer `APP_SECRET_FILE` injection in production.
+- Never commit `.env`, `secrets/`, credentials, or DSNs. Treat DSNs and generated schema metadata as sensitive (SECURITY.md, docs/api-security-checklist.md).
+- Backend code is strictly typed: mypy runs with `disallow_untyped_defs` (see `[tool.mypy]` in backend/pyproject.toml). Public defs need docstrings — interrogate is configured with `fail-under = 100` in setup.cfg and `tests/test_docstrings.py` enforces it for checked modules.
+- Long-running work (introspection of target DBs) goes through the job queue, never synchronously in a request handler.
+- Middleware registration order in `app/main.py` is deliberate (security headers registered last so they wrap everything, including 429s and CORS preflight) — read the comments there before reordering.
+- Do not use nested `${VAR:-${OTHER:-default}}` expressions in compose files; podman-compose mishandles them (noted inline in compose.yaml).
+- Supply-chain pinning is enforced (OpenSSF Scorecard): Docker images are pinned by digest, GitHub Actions by commit SHA, and pip installs by `--require-hashes`. Preserve pinning when adding or updating any of these.
+- CI (`.github/workflows/ci.yml`) runs backend mypy + pytest (Python 3.10, hash-locked deps) and frontend typecheck + vitest + production build (Node 26). CodeQL, Scorecard, and dependency-review workflows also run.
+- User-visible frontend changes are recorded in CHANGELOG.md (Korean) and frontend/CHANGELOG.md.
+- Add or update tests when changing behavior; prefer small, focused PRs (CONTRIBUTING.md).
diff --git a/backend/app/api/dbml.py b/backend/app/api/dbml.py
new file mode 100644
index 00000000..c35db752
--- /dev/null
+++ b/backend/app/api/dbml.py
@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+
+from app.auth import CurrentUser, get_current_user
+from app.ddl.export import snapshot_json_to_sql
+from app.schemas import DbmlConvertIn, DbmlConvertOut
+from app.spec.dbml_import import parse_dbml
+
+router = APIRouter(prefix="/api/dbml", tags=["dbml"])
+
+
+@router.post("/convert", response_model=DbmlConvertOut)
+async def convert_dbml(
+    body: DbmlConvertIn,
+    user: CurrentUser = Depends(get_current_user),
+) -> DbmlConvertOut:
+    """Design-first entry point: DBML text → snapshot JSON (+ optional DDL).
+
+    The returned snapshot has the same shape introspection produces, so the
+    whole downstream pipeline (ERD, DDL export, diff, migration, analyzers)
+    works on a design that never touched a database. Pure computation — no
+    project resources involved, so authentication alone suffices.
+    """
+    snapshot = parse_dbml(body.dbml)
+    ddl = (
+        snapshot_json_to_sql(snapshot, target_dialect=body.dialect)
+        if body.include_ddl
+        else None
+    )
+    return DbmlConvertOut(
+        snapshot_json=snapshot,
+        ddl=ddl,
+        tables=len(snapshot["relations"]),
+        foreign_keys=len(snapshot["fk_edges"]),
+    )
diff --git a/backend/app/api/snapshots.py b/backend/app/api/snapshots.py
index 3099d52d..f221aaaa 100644
--- a/backend/app/api/snapshots.py
+++ b/backend/app/api/snapshots.py
@@ -19,9 +19,15 @@
 )
 from app.permissions import require_project_member
 from app.schemas import (
+    AuditColumnsOut,
+    ConstraintInventoryOut,
+    FkCyclesOut,
+    IndexRedundancyOut,
     InferredRelationshipOut,
     MigrationSafetyOut,
     NamingLintOut,
+    SchemaStatsOut,
+    SensitiveColumnsOut,
     SnapshotCreateIn,
     SnapshotDetailOut,
     SnapshotDiffOut,
@@ -32,9 +38,20 @@
 from app.ddl.migration import snapshot_diff_to_migration_sql
 from app.ddl.migration_safety import analyze_migration_safety
 from app.diff.schema_diff import diff_snapshots
+from app.spec.audit_columns import check_audit_columns
+from app.spec.constraint_inventory import build_constraint_inventory
+from app.spec.fk_cycles import detect_fk_cycles
+from app.spec.index_redundancy import detect_index_redundancy
 from app.spec.data_dictionary import snapshot_to_data_dictionary_md
 from app.spec.naming_lint import lint_naming
+from app.spec.orm_codegen import (
+    generate_prisma_schema,
+    generate_sqlalchemy_models,
+    generate_typeorm_entities,
+)
 from app.spec.relationship_inference import infer_relationships
+from app.spec.schema_stats import compute_schema_stats
+from app.spec.sensitive_columns import detect_sensitive_columns
 from app.spec.wide_tables import detect_wide_tables
 from app.jobs.valkey_queue import enqueue_job_signal
 from app.spec.llm import (
@@ -360,6 +377,178 @@ async def wide_tables(
     )
 
 
+@router.get("/{schema_snapshot_uuid}/orm-models", response_class=PlainTextResponse)
+async def export_orm_models(
+    schema_snapshot_uuid: uuid.UUID,
+    flavor: str = Query("sqlalchemy", pattern="^(sqlalchemy|prisma|typeorm)$"),
+    user: CurrentUser = Depends(get_current_user),
+    session: AsyncSession = Depends(get_read_session),
+) -> str:
+    """Generate ORM model code from a snapshot (SQLAlchemy 2.0 or Prisma).
+
+    Forward engineering to application code: hand developers ready-to-edit
+    models instead of retyped tables. IDOR-safe (uniform not-found marker).
+    """
+    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
+    if snap is None:
+        return "-- snapshot not found\n"
+    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
+    if data is None:
+        return "-- snapshot data not found\n"
+    if flavor == "prisma":
+        return generate_prisma_schema(data.snapshot_json)
+    if flavor == "typeorm":
+        return generate_typeorm_entities(data.snapshot_json)
+    return generate_sqlalchemy_models(data.snapshot_json)
+
+
+@router.get("/{schema_snapshot_uuid}/stats", response_model=SchemaStatsOut)
+async def schema_stats(
+    schema_snapshot_uuid: uuid.UUID,
+    user: CurrentUser = Depends(get_current_user),
+    session: AsyncSession = Depends(get_read_session),
+) -> SchemaStatsOut:
+    """Overview statistics for a snapshot (object counts, column & type
+    distribution, widest tables, PK/FK/index coverage).
+
+    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
+    """
+    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
+    if snap is None:
+        return SchemaStatsOut(
+            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", stats=None
+        )
+    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
+    stats = compute_schema_stats(data.snapshot_json if data else None)
+    return SchemaStatsOut(
+        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", stats=stats
+    )
+
+
+@router.get("/{schema_snapshot_uuid}/fk-cycles", response_model=FkCyclesOut)
+async def fk_cycles(
+    schema_snapshot_uuid: uuid.UUID,
+    user: CurrentUser = Depends(get_current_user),
+    session: AsyncSession = Depends(get_read_session),
+) -> FkCyclesOut:
+    """Report circular foreign-key dependencies (migration-ordering hazards).
+
+    Multi-table cycles are warnings; self-references are informational.
+    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
+    """
+    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
+    if snap is None:
+        return FkCyclesOut(
+            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None
+        )
+    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
+    report = detect_fk_cycles(data.snapshot_json if data else None)
+    return FkCyclesOut(
+        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report
+    )
+
+
+@router.get(
+    "/{schema_snapshot_uuid}/sensitive-columns", response_model=SensitiveColumnsOut
+)
+async def sensitive_columns(
+    schema_snapshot_uuid: uuid.UUID,
+    user: CurrentUser = Depends(get_current_user),
+    session: AsyncSession = Depends(get_read_session),
+) -> SensitiveColumnsOut:
+    """Compliance-scoping inventory: which columns likely hold PII / card /
+    credential data, mapped to the relevant framework (PCI DSS, GDPR/PIPA).
+
+    Detection only -- it does not encrypt, mask, or tokenize anything.
+    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
+    """
+    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
+    if snap is None:
+        return SensitiveColumnsOut(
+            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None
+        )
+    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
+    report = detect_sensitive_columns(data.snapshot_json if data else None)
+    return SensitiveColumnsOut(
+        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report
+    )
+
+
+@router.get("/{schema_snapshot_uuid}/audit-columns", response_model=AuditColumnsOut)
+async def audit_columns(
+    schema_snapshot_uuid: uuid.UUID,
+    user: CurrentUser = Depends(get_current_user),
+    session: AsyncSession = Depends(get_read_session),
+) -> AuditColumnsOut:
+    """Flag tables missing created_at/updated_at when the schema's own
+    majority follows that convention (no external style imposed).
+
+    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
+    """
+    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
+    if snap is None:
+        return AuditColumnsOut(
+            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None
+        )
+    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
+    report = check_audit_columns(data.snapshot_json if data else None)
+    return AuditColumnsOut(
+        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report
+    )
+
+
+@router.get(
+    "/{schema_snapshot_uuid}/constraint-inventory",
+    response_model=ConstraintInventoryOut,
+)
+async def constraint_inventory(
+    schema_snapshot_uuid: uuid.UUID,
+    user: CurrentUser = Depends(get_current_user),
+    session: AsyncSession = Depends(get_read_session),
+) -> ConstraintInventoryOut:
+    """Inventory CHECK-constraint business rules and FK delete-action risks
+    (ON DELETE CASCADE = warning, SET NULL = info).
+
+    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
+    """
+    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
+    if snap is None:
+        return ConstraintInventoryOut(
+            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None
+        )
+    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
+    report = build_constraint_inventory(data.snapshot_json if data else None)
+    return ConstraintInventoryOut(
+        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report
+    )
+
+
+@router.get(
+    "/{schema_snapshot_uuid}/index-redundancy", response_model=IndexRedundancyOut
+)
+async def index_redundancy(
+    schema_snapshot_uuid: uuid.UUID,
+    user: CurrentUser = Depends(get_current_user),
+    session: AsyncSession = Depends(get_read_session),
+) -> IndexRedundancyOut:
+    """Report duplicate and prefix-shadowed indexes (safe drop candidates).
+
+    Unique indexes are never suggested for dropping (they enforce constraints);
+    expression/partial indexes are skipped rather than guessed.
+    IDOR-safe (uniform not-found for missing/unauthorized snapshots).
+    """
+    snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user)
+    if snap is None:
+        return IndexRedundancyOut(
+            schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None
+        )
+    data = await session.get(SchemaSnapshotData, schema_snapshot_uuid)
+    report = detect_index_redundancy(data.snapshot_json if data else None)
+    return IndexRedundancyOut(
+        schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report
+    )
+
+
 @router.get(
     "/{schema_snapshot_uuid}/data-dictionary.md", response_class=PlainTextResponse
 )
diff --git a/backend/app/db_introspect.py b/backend/app/db_introspect.py
index 17d06c93..daef76d8 100644
--- a/backend/app/db_introspect.py
+++ b/backend/app/db_introspect.py
@@ -4,6 +4,7 @@
 from urllib.parse import urlparse
 
 from app.dsn_redaction import redact_dsn_error_message
+from app.mysql_introspect import introspect_mysql, probe_mysql
 from app.pg_introspect.forward_ddl import validate_forward_ddl
 from app.pg_introspect.introspect import (
     apply_postgres_ddl,
@@ -13,7 +14,7 @@
 from app.snowflake_introspect import introspect_snowflake
 from app.snowflake_introspect.introspect import probe_snowflake
 
-DatabaseDialect = Literal["postgresql", "snowflake"]
+DatabaseDialect = Literal["postgresql", "snowflake", "mysql"]
 
 
 def detect_dsn_dialect(dsn: str) -> DatabaseDialect:
@@ -24,6 +25,8 @@ def detect_dsn_dialect(dsn: str) -> DatabaseDialect:
         return "postgresql"
     if scheme == "snowflake":
         return "snowflake"
+    if scheme in ("mysql", "mariadb"):
+        return "mysql"
     raise ValueError(f"unsupported database DSN scheme: {scheme or '<empty>'}")
 
 
@@ -34,6 +37,8 @@ async def introspect_database(dsn: str, schema_filter: str | None) -> dict:
         dialect = detect_dsn_dialect(dsn)
         if dialect == "snowflake":
             return await introspect_snowflake(dsn, schema_filter)
+        if dialect == "mysql":
+            return await introspect_mysql(dsn, schema_filter)
         return await introspect_postgres(dsn, schema_filter)
     except Exception as exc:
         message = str(exc) or type(exc).__name__
@@ -71,6 +76,8 @@ async def probe_database(dsn: str) -> str:
         dialect = detect_dsn_dialect(dsn)
         if dialect == "snowflake":
             return await probe_snowflake(dsn)
+        if dialect == "mysql":
+            return await probe_mysql(dsn)
         return await probe_postgres(dsn)
     except Exception as exc:
         message = str(exc) or type(exc).__name__
diff --git a/backend/app/integrations/__init__.py b/backend/app/integrations/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/backend/app/integrations/clearfolio.py b/backend/app/integrations/clearfolio.py
new file mode 100644
index 00000000..488f23ab
--- /dev/null
+++ b/backend/app/integrations/clearfolio.py
@@ -0,0 +1,202 @@
+"""Buyer-gateway connector for Clearfolio (reference-document viewer platform).
+
+pg-erd-cloud acts as the *buyer gateway*: it authenticates its own user
+(OIDC / API key), maps that principal to Clearfolio tenant claims, signs those
+claims with the shared HMAC secret, and proxies to the Clearfolio connector API
+(submit → status → viewer bootstrap → artifact link).
+
+Signing contract (from Clearfolio's buyer-deployment playbook — must match its
+verifier exactly):
+
+    payload    = "\\n".join([tenantId, subjectId, canonicalPermissions, issuedAt])
+    signature  = base64url( HMAC_SHA256(secret, payload) )   # no padding
+
+Sent as the header set ``X-Clearfolio-{Tenant-Id,Subject-Id,Permissions,
+Claims-Issued-At,Claims-Signature}``. The gateway host is SSRF-validated (it is
+admin-configured, not per-request user input, but validated for defense in
+depth).
+"""
+
+from __future__ import annotations
+
+import base64
+import datetime as dt
+import hashlib
+import hmac
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import quote, urlparse
+
+import httpx
+
+from app.pg_introspect.dsn_guard import _validated_ip_hosts
+from app.settings import settings
+
+def _sanitize(value: str) -> str:
+    """Match Clearfolio's claim sanitizer: drop NUL, strip surrounding space."""
+    return value.replace("\x00", "").strip()
+
+
+def canonicalize_permissions(raw: str) -> str:
+    """Reduce a permission string to Clearfolio's canonical form.
+
+    Clearfolio verifies the signature against ``canonicalPermissions`` — the
+    header split on ``,``, each entry sanitized, empties dropped, de-duplicated
+    preserving order, re-joined with ``,``. The gateway must sign (and send)
+    this exact form or every request 401s, so we canonicalize identically.
+    """
+    seen: dict[str, None] = {}
+    for part in raw.split(","):
+        cleaned = _sanitize(part)
+        if cleaned:
+            seen.setdefault(cleaned, None)
+    return ",".join(seen)
+
+
+def _path_segment(value: str) -> str:
+    return quote(value, safe="")
+
+
+_H_TENANT = "X-Clearfolio-Tenant-Id"
+_H_SUBJECT = "X-Clearfolio-Subject-Id"
+_H_PERMS = "X-Clearfolio-Permissions"
+_H_ISSUED = "X-Clearfolio-Claims-Issued-At"
+_H_SIG = "X-Clearfolio-Claims-Signature"
+
+
+class ClearfolioNotConfigured(RuntimeError):
+    """Raised when the Clearfolio connector is called without configuration."""
+
+
+class ClearfolioError(RuntimeError):
+    """A Clearfolio API call failed (status text is safe to surface)."""
+
+
+@dataclass(frozen=True)
+class ClearfolioConfig:
+    gateway_url: str
+    hmac_secret: str
+    tenant_id: str
+    permissions: str
+    timeout_seconds: float
+
+    @classmethod
+    def from_settings(cls) -> "ClearfolioConfig":
+        if not settings.clearfolio_gateway_url or not settings.clearfolio_tenant_claims_hmac_secret:
+            raise ClearfolioNotConfigured(
+                "CLEARFOLIO_GATEWAY_URL and CLEARFOLIO_TENANT_CLAIMS_HMAC_SECRET must be set"
+            )
+        return cls(
+            gateway_url=settings.clearfolio_gateway_url.rstrip("/"),
+            hmac_secret=settings.clearfolio_tenant_claims_hmac_secret,
+            tenant_id=settings.clearfolio_tenant_id,
+            permissions=settings.clearfolio_permissions,
+            timeout_seconds=settings.clearfolio_timeout_seconds,
+        )
+
+
+def sign_tenant_claims(
+    secret: str,
+    tenant_id: str,
+    subject_id: str,
+    canonical_permissions: str,
+    issued_at: int,
+) -> str:
+    """Base64URL (unpadded) HMAC-SHA256 of the newline-joined claim payload."""
+    payload = "\n".join([tenant_id, subject_id, canonical_permissions, str(issued_at)])
+    digest = hmac.new(secret.encode("utf-8"), payload.encode("utf-8"), hashlib.sha256).digest()
+    return base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
+
+
+def build_tenant_headers(
+    config: ClearfolioConfig, subject_id: str, issued_at: int | None = None
+) -> dict[str, str]:
+    """Build the full signed Clearfolio tenant header set for a subject."""
+    if issued_at is None:
+        issued_at = int(dt.datetime.now(dt.timezone.utc).timestamp())
+    # Sign and send the exact canonical values Clearfolio re-derives on verify,
+    # otherwise a config with spaces/duplicates would 401.
+    tenant_id = _sanitize(config.tenant_id)
+    subject = _sanitize(subject_id)
+    permissions = canonicalize_permissions(config.permissions)
+    signature = sign_tenant_claims(
+        config.hmac_secret, tenant_id, subject, permissions, issued_at
+    )
+    return {
+        _H_TENANT: tenant_id,
+        _H_SUBJECT: subject,
+        _H_PERMS: permissions,
+        _H_ISSUED: str(issued_at),
+        _H_SIG: signature,
+    }
+
+
+async def _validate_gateway(config: ClearfolioConfig) -> None:
+    """SSRF defense-in-depth: reject an internal/loopback gateway host."""
+    parsed = urlparse(config.gateway_url)
+    if not parsed.hostname:
+        raise ClearfolioError("invalid CLEARFOLIO_GATEWAY_URL")
+    await _validated_ip_hosts(parsed.hostname, is_hostaddr=False, port=parsed.port or 443)
+
+
+async def _request(
+    config: ClearfolioConfig,
+    method: str,
+    path: str,
+    subject_id: str,
+    *,
+    files: dict[str, Any] | None = None,
+    extra_headers: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    await _validate_gateway(config)
+    headers = build_tenant_headers(config, subject_id)
+    if extra_headers:
+        headers.update(extra_headers)
+    async with httpx.AsyncClient(timeout=config.timeout_seconds) as client:
+        resp = await client.request(
+            method, f"{config.gateway_url}{path}", headers=headers, files=files
+        )
+    if resp.status_code >= 400:
+        raise ClearfolioError(f"clearfolio {method} {path} -> {resp.status_code}")
+    return resp.json() if resp.content else {}
+
+
+async def submit_conversion_job(
+    subject_id: str, file_bytes: bytes, filename: str
+) -> dict[str, Any]:
+    """POST /api/v1/convert/jobs — submit a document for preview conversion."""
+    config = ClearfolioConfig.from_settings()
+    return await _request(
+        config,
+        "POST",
+        "/api/v1/convert/jobs",
+        subject_id,
+        files={"file": (filename, file_bytes)},
+    )
+
+
+async def get_job_status(subject_id: str, job_id: str) -> dict[str, Any]:
+    """GET /api/v1/convert/jobs/{jobId} — read conversion lifecycle status."""
+    config = ClearfolioConfig.from_settings()
+    return await _request(
+        config, "GET", f"/api/v1/convert/jobs/{_path_segment(job_id)}", subject_id
+    )
+
+
+async def get_viewer_bootstrap(subject_id: str, doc_id: str) -> dict[str, Any]:
+    """GET /api/v1/viewer/{docId} — viewer bootstrap (signed previewResourcePath)."""
+    config = ClearfolioConfig.from_settings()
+    return await _request(
+        config, "GET", f"/api/v1/viewer/{_path_segment(doc_id)}", subject_id
+    )
+
+
+async def create_artifact_link(subject_id: str, doc_id: str) -> dict[str, Any]:
+    """POST /api/v1/viewer/{docId}/artifact-links — short-lived signed artifact URL."""
+    config = ClearfolioConfig.from_settings()
+    return await _request(
+        config,
+        "POST",
+        f"/api/v1/viewer/{_path_segment(doc_id)}/artifact-links",
+        subject_id,
+    )
diff --git a/backend/app/main.py b/backend/app/main.py
index a0f0780c..ae5788af 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -11,6 +11,7 @@
 from app.api.annotations import router as annotations_router
 from app.api.api_keys import router as api_keys_router
 from app.api.connections import router as connections_router
+from app.api.dbml import router as dbml_router
 from app.api.auth_routes import router as auth_router
 from app.api.diagram_views import router as diagram_views_router
 from app.api.me import router as me_router
@@ -167,6 +168,7 @@ async def csrf_token() -> dict[str, str]:
 
 app.include_router(projects_router)
 app.include_router(connections_router)
+app.include_router(dbml_router)
 app.include_router(snapshots_router)
 app.include_router(diagram_views_router)
 app.include_router(annotations_router)
diff --git a/backend/app/mysql_introspect/__init__.py b/backend/app/mysql_introspect/__init__.py
new file mode 100644
index 00000000..dad84964
--- /dev/null
+++ b/backend/app/mysql_introspect/__init__.py
@@ -0,0 +1,3 @@
+from app.mysql_introspect.introspect import introspect_mysql, probe_mysql
+
+__all__ = ["introspect_mysql", "probe_mysql"]
diff --git a/backend/app/mysql_introspect/introspect.py b/backend/app/mysql_introspect/introspect.py
new file mode 100644
index 00000000..5786904e
--- /dev/null
+++ b/backend/app/mysql_introspect/introspect.py
@@ -0,0 +1,331 @@
+"""MySQL / MariaDB introspection producing the common snapshot JSON.
+
+Mirrors the Snowflake introspector's structure: SSRF-guarded DSN parsing with
+pinned IPs (reuses the same `_validated_ip_hosts` guard as PostgreSQL), a
+lazily imported synchronous driver (PyMySQL) run in a worker thread, and
+``information_schema`` queries mapped into the shape every downstream feature
+consumes (relations / columns / constraints / indexes / pk_columns / fk_edges).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import datetime as dt
+import importlib
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import unquote, urlparse
+
+from app.pg_introspect.column_examples import add_column_examples
+from app.pg_introspect.dsn_guard import _validated_ip_hosts
+from app.sanitize import sanitize_for_storage
+
+_SYSTEM_SCHEMAS = ("mysql", "information_schema", "performance_schema", "sys")
+_DEFAULT_PORT = 3306
+
+
+@dataclass(frozen=True)
+class MysqlDsnConfig:
+    """Validated MySQL connection parameters with a pinned IP host."""
+
+    host: str  # pinned, validated IP
+    server_hostname: str  # original hostname (for TLS/SNI if needed)
+    port: int
+    user: str
+    password: str
+    database: str | None
+
+
+async def _parse_mysql_dsn(dsn: str) -> MysqlDsnConfig:
+    """Parse and SSRF-validate a mysql:// DSN; pin the resolved IP."""
+    parsed = urlparse(dsn)
+    scheme = parsed.scheme.lower().split("+", 1)[0]
+    if scheme not in ("mysql", "mariadb"):
+        raise ValueError("unsupported MySQL DSN scheme")
+    if not parsed.hostname:
+        raise ValueError("MySQL DSN must include a host")
+    if not parsed.username:
+        raise ValueError("MySQL DSN must include a user")
+    port = parsed.port or _DEFAULT_PORT
+    hosts = await _validated_ip_hosts(parsed.hostname, is_hostaddr=False, port=port)
+    database = parsed.path.lstrip("/") or None
+    return MysqlDsnConfig(
+        host=hosts[0],
+        server_hostname=parsed.hostname,
+        port=port,
+        user=unquote(parsed.username),
+        password=unquote(parsed.password or ""),
+        database=database,
+    )
+
+
+def _connect(config: MysqlDsnConfig) -> Any:
+    try:
+        pymysql = importlib.import_module("pymysql")
+    except ImportError as exc:  # pragma: no cover - environment dependent
+        raise RuntimeError(
+            "MySQL support requires the PyMySQL package"
+        ) from exc
+    return pymysql.connect(
+        host=config.host,  # pinned IP (SSRF)
+        port=config.port,
+        user=config.user,
+        password=config.password,
+        database=config.database,
+        connect_timeout=10,
+        read_timeout=30,
+        write_timeout=30,
+    )
+
+
+def _fetch_dicts(cursor: Any, sql: str, params: tuple[object, ...] = ()) -> list[dict]:
+    cursor.execute(sql, params or None)
+    names = [d[0] for d in cursor.description or []]
+    return [dict(zip(names, row)) for row in cursor.fetchall()]
+
+
+def _schema_filter_clause(schema_filter: str | None) -> tuple[str, tuple[object, ...]]:
+    if schema_filter:
+        return "TABLE_SCHEMA = %s", (schema_filter,)
+    placeholders = ", ".join(["%s"] * len(_SYSTEM_SCHEMAS))
+    return f"TABLE_SCHEMA NOT IN ({placeholders})", _SYSTEM_SCHEMAS
+
+
+def rows_to_snapshot(
+    version: str,
+    schema_filter: str | None,
+    tables: list[dict],
+    columns: list[dict],
+    key_usage: list[dict],
+    indexes: list[dict],
+) -> dict[str, Any]:
+    """Pure transformation: information_schema rows → common snapshot JSON."""
+    oid_by_table: dict[tuple[str, str], int] = {}
+    relations: list[dict[str, Any]] = []
+    for i, row in enumerate(tables, start=1):
+        key = (str(row["TABLE_SCHEMA"]), str(row["TABLE_NAME"]))
+        oid_by_table[key] = i
+        relations.append(
+            {
+                "relation_oid": i,
+                "relation_kind": "v" if str(row.get("TABLE_TYPE", "")).upper() == "VIEW" else "r",
+                "schema_name": key[0],
+                "relation_name": key[1],
+                "relation_comment": str(row.get("TABLE_COMMENT") or "") or None,
+            }
+        )
+
+    out_columns: list[dict[str, Any]] = []
+    for row in columns:
+        oid = oid_by_table.get((str(row["TABLE_SCHEMA"]), str(row["TABLE_NAME"])))
+        if oid is None:
+            continue
+        out_columns.append(
+            {
+                "relation_oid": oid,
+                "column_name": str(row["COLUMN_NAME"]),
+                "column_position": int(row["ORDINAL_POSITION"]),
+                "data_type": str(row.get("COLUMN_TYPE") or row.get("DATA_TYPE") or ""),
+                "is_not_null": str(row.get("IS_NULLABLE", "YES")).upper() == "NO",
+                "has_default": row.get("COLUMN_DEFAULT") is not None,
+                "default_expr": (
+                    str(row["COLUMN_DEFAULT"]) if row.get("COLUMN_DEFAULT") is not None else None
+                ),
+                "column_comment": str(row.get("COLUMN_COMMENT") or "") or None,
+            }
+        )
+    pos_by_oid_col = {
+        (c["relation_oid"], c["column_name"]): c["column_position"] for c in out_columns
+    }
+
+    pk_columns: list[dict[str, Any]] = []
+    fk_edges: list[dict[str, Any]] = []
+    constraints: list[dict[str, Any]] = []
+    pk_cols_by_oid: dict[int, list[str]] = {}
+    for row in key_usage:
+        oid = oid_by_table.get((str(row["TABLE_SCHEMA"]), str(row["TABLE_NAME"])))
+        if oid is None:
+            continue
+        col = str(row["COLUMN_NAME"])
+        if str(row.get("CONSTRAINT_NAME")) == "PRIMARY":
+            pk_columns.append(
+                {
+                    "relation_oid": oid,
+                    "column_name": col,
+                    "column_ordinal": int(row.get("ORDINAL_POSITION") or 1),
+                }
+            )
+            pk_cols_by_oid.setdefault(oid, []).append(col)
+        elif row.get("REFERENCED_TABLE_NAME"):
+            parent = oid_by_table.get(
+                (
+                    str(row.get("REFERENCED_TABLE_SCHEMA") or row["TABLE_SCHEMA"]),
+                    str(row["REFERENCED_TABLE_NAME"]),
+                )
+            )
+            if parent is None:
+                continue
+            edge_id = len(fk_edges) + 1
+            fk_edges.append(
+                {
+                    "fk_constraint_oid": 100000 + edge_id,
+                    "fk_constraint_name": str(row.get("CONSTRAINT_NAME") or f"fk_{edge_id}"),
+                    "child_relation_oid": oid,
+                    "parent_relation_oid": parent,
+                    "child_column_name": col,
+                    "parent_column_name": str(row["REFERENCED_COLUMN_NAME"]),
+                    "column_ordinal": int(row.get("ORDINAL_POSITION") or 1),
+                }
+            )
+
+    rel_by_oid = {r["relation_oid"]: r for r in relations}
+    for oid, cols in pk_cols_by_oid.items():
+        rel = rel_by_oid[oid]
+        quoted = ", ".join(f'"{c}"' for c in cols)
+        constraints.append(
+            {
+                "constraint_oid": 200000 + oid,
+                "constraint_name": f"pk_{rel['relation_name']}",
+                "constraint_type": "p",
+                "schema_name": rel["schema_name"],
+                "relation_oid": oid,
+                "relation_name": rel["relation_name"],
+                "constrained_attnums": [pos_by_oid_col.get((oid, c), i + 1) for i, c in enumerate(cols)],
+                "constraint_def": f"PRIMARY KEY ({quoted})",
+            }
+        )
+    for edge in fk_edges:
+        child_rel = rel_by_oid[edge["child_relation_oid"]]
+        parent_rel = rel_by_oid[edge["parent_relation_oid"]]
+        constraints.append(
+            {
+                "constraint_oid": 300000 + edge["fk_constraint_oid"],
+                "constraint_name": edge["fk_constraint_name"],
+                "constraint_type": "f",
+                "schema_name": child_rel["schema_name"],
+                "relation_oid": edge["child_relation_oid"],
+                "relation_name": child_rel["relation_name"],
+                "constrained_attnums": [
+                    pos_by_oid_col.get((edge["child_relation_oid"], edge["child_column_name"]), 1)
+                ],
+                "constraint_def": (
+                    f'FOREIGN KEY ("{edge["child_column_name"]}") REFERENCES '
+                    f'"{parent_rel["schema_name"]}"."{parent_rel["relation_name"]}" '
+                    f'("{edge["parent_column_name"]}")'
+                ),
+            }
+        )
+
+    # group STATISTICS rows into per-index column lists
+    grouped: dict[tuple[str, str, str], list[tuple[int, str, bool]]] = {}
+    for row in indexes:
+        ix_key = (str(row["TABLE_SCHEMA"]), str(row["TABLE_NAME"]), str(row["INDEX_NAME"]))
+        grouped.setdefault(ix_key, []).append(
+            (
+                int(row.get("SEQ_IN_INDEX") or 1),
+                str(row["COLUMN_NAME"]),
+                not bool(int(row.get("NON_UNIQUE") or 0)),
+            )
+        )
+    out_indexes: list[dict[str, Any]] = []
+    for (schema, table, name), ix_cols in sorted(grouped.items()):
+        ix_oid = oid_by_table.get((schema, table))
+        if ix_oid is None:
+            continue
+        ordered = [c for _, c, _ in sorted(ix_cols)]
+        unique = ix_cols[0][2]
+        cols_sql = ", ".join(ordered)
+        out_indexes.append(
+            {
+                "relation_oid": ix_oid,
+                "index_name": name,
+                "is_unique": unique,
+                "is_primary": name == "PRIMARY",
+                "index_def": (
+                    f"CREATE {'UNIQUE ' if unique else ''}INDEX {name} "
+                    f"ON {schema}.{table} ({cols_sql})"
+                ),
+            }
+        )
+
+    snapshot = {
+        "captured_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "server_version": version,
+        "source_dialect": "mysql",
+        "schema_filter": schema_filter,
+        "schemas": sorted({r["schema_name"] for r in relations}),
+        "relations": relations,
+        "columns": add_column_examples(out_columns),
+        "constraints": constraints,
+        "indexes": out_indexes,
+        "pk_columns": pk_columns,
+        "fk_edges": fk_edges,
+        "citus_distributed_tables": [],
+    }
+    return sanitize_for_storage(snapshot)  # type: ignore[return-value]
+
+
+def _introspect_sync(config: MysqlDsnConfig, schema_filter: str | None) -> dict[str, Any]:
+    conn = _connect(config)
+    try:
+        cursor = conn.cursor()
+        version_rows = _fetch_dicts(cursor, "SELECT VERSION() AS v")
+        version = str(version_rows[0]["v"]) if version_rows else "unknown"
+        where, params = _schema_filter_clause(schema_filter)
+        tables = _fetch_dicts(
+            cursor,
+            "SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE, TABLE_COMMENT "
+            f"FROM information_schema.TABLES WHERE {where} "
+            "ORDER BY TABLE_SCHEMA, TABLE_NAME",
+            params,
+        )
+        columns = _fetch_dicts(
+            cursor,
+            "SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, ORDINAL_POSITION, "
+            "COLUMN_TYPE, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT, COLUMN_COMMENT "
+            f"FROM information_schema.COLUMNS WHERE {where} "
+            "ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION",
+            params,
+        )
+        key_usage = _fetch_dicts(
+            cursor,
+            "SELECT CONSTRAINT_NAME, TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, "
+            "ORDINAL_POSITION, REFERENCED_TABLE_SCHEMA, REFERENCED_TABLE_NAME, "
+            "REFERENCED_COLUMN_NAME "
+            f"FROM information_schema.KEY_COLUMN_USAGE WHERE {where} "
+            "ORDER BY TABLE_SCHEMA, TABLE_NAME, CONSTRAINT_NAME, ORDINAL_POSITION",
+            params,
+        )
+        indexes = _fetch_dicts(
+            cursor,
+            "SELECT TABLE_SCHEMA, TABLE_NAME, INDEX_NAME, NON_UNIQUE, "
+            "SEQ_IN_INDEX, COLUMN_NAME "
+            f"FROM information_schema.STATISTICS WHERE {where} "
+            "ORDER BY TABLE_SCHEMA, TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX",
+            params,
+        )
+        return rows_to_snapshot(version, schema_filter, tables, columns, key_usage, indexes)
+    finally:
+        conn.close()
+
+
+async def introspect_mysql(dsn: str, schema_filter: str | None) -> dict[str, Any]:
+    """Introspect a MySQL/MariaDB database and return a snapshot JSON."""
+    config = await _parse_mysql_dsn(dsn)
+    return await asyncio.to_thread(_introspect_sync, config, schema_filter)
+
+
+def _probe_sync(config: MysqlDsnConfig) -> str:
+    conn = _connect(config)
+    try:
+        cursor = conn.cursor()
+        rows = _fetch_dicts(cursor, "SELECT VERSION() AS v")
+        return str(rows[0]["v"]) if rows else "unknown"
+    finally:
+        conn.close()
+
+
+async def probe_mysql(dsn: str) -> str:
+    """SSRF-guarded connectivity check: connect and return the server version."""
+    config = await _parse_mysql_dsn(dsn)
+    return await asyncio.to_thread(_probe_sync, config)
diff --git a/backend/app/schemas.py b/backend/app/schemas.py
index e5751477..d7c6de77 100644
--- a/backend/app/schemas.py
+++ b/backend/app/schemas.py
@@ -139,6 +139,54 @@ class WideTablesOut(BaseModel):
     report: dict | None
 
 
+class SchemaStatsOut(BaseModel):
+    """Overview statistics for a schema snapshot."""
+
+    schema_snapshot_uuid: uuid.UUID
+    status: str
+    stats: dict | None
+
+
+class FkCyclesOut(BaseModel):
+    """Circular foreign-key dependency findings for a snapshot."""
+
+    schema_snapshot_uuid: uuid.UUID
+    status: str
+    report: dict | None
+
+
+class SensitiveColumnsOut(BaseModel):
+    """Compliance-scoping inventory of likely-sensitive columns."""
+
+    schema_snapshot_uuid: uuid.UUID
+    status: str
+    report: dict | None
+
+
+class AuditColumnsOut(BaseModel):
+    """Audit-column (created_at/updated_at) convention findings."""
+
+    schema_snapshot_uuid: uuid.UUID
+    status: str
+    report: dict | None
+
+
+class ConstraintInventoryOut(BaseModel):
+    """CHECK-rule inventory and FK delete-action risks for a snapshot."""
+
+    schema_snapshot_uuid: uuid.UUID
+    status: str
+    report: dict | None
+
+
+class IndexRedundancyOut(BaseModel):
+    """Duplicate / prefix-redundant index findings for a snapshot."""
+
+    schema_snapshot_uuid: uuid.UUID
+    status: str
+    report: dict | None
+
+
 class DiagramViewCreateIn(BaseModel):
     """Request body for saving an ERD canvas view."""
 
@@ -234,6 +282,23 @@ class NamingLintOut(BaseModel):
     report: dict | None
 
 
+class DbmlConvertIn(BaseModel):
+    """Request body for converting DBML text into a snapshot."""
+
+    dbml: str = Field(min_length=1, max_length=524_288)
+    include_ddl: bool = True
+    dialect: Literal["postgresql", "snowflake"] = "postgresql"
+
+
+class DbmlConvertOut(BaseModel):
+    """DBML conversion result: snapshot JSON plus optional DDL."""
+
+    snapshot_json: dict
+    ddl: str | None = None
+    tables: int
+    foreign_keys: int
+
+
 class ApiKeyCreateIn(BaseModel):
     """Request body for creating an API key."""
 
diff --git a/backend/app/settings.py b/backend/app/settings.py
index 0d1a7b91..93903ec6 100644
--- a/backend/app/settings.py
+++ b/backend/app/settings.py
@@ -123,6 +123,15 @@ def _load_app_secret_from_file(cls, data: object) -> object:
     llm_model: str | None = None
     llm_timeout_seconds: float = Field(30.0, gt=0.0, le=120.0)
 
+    # Clearfolio reference-document viewer connector (buyer gateway).
+    clearfolio_gateway_url: str | None = None
+    clearfolio_tenant_claims_hmac_secret: str | None = None
+    clearfolio_tenant_id: str = "pg-erd-cloud"
+    clearfolio_permissions: str = (
+        "job:create,job:read,job:retry,viewer:read,artifact-link:create,analytics:read"
+    )
+    clearfolio_timeout_seconds: float = Field(30.0, gt=0.0, le=120.0)
+
     # Allowed JWT signing algorithms for OIDC verification.
     # Comma-separated string (env: OIDC_ALGORITHMS). Default is RS256.
     # NOTE: Do not trust the token header's alg; only accept algorithms from
diff --git a/backend/app/spec/audit_columns.py b/backend/app/spec/audit_columns.py
new file mode 100644
index 00000000..9340a5b3
--- /dev/null
+++ b/backend/app/spec/audit_columns.py
@@ -0,0 +1,88 @@
+"""Check audit-column conventions (created_at / updated_at) across tables.
+
+When most of a schema tracks row lifecycle with ``created_at``/``updated_at``
+(or ``*_time``/``*_date`` variants), tables missing them are usually an
+oversight — and the gap surfaces later as "when did this row change?" with no
+answer. Like the naming lint, no convention is imposed: a table is only flagged
+when the schema's *own* majority follows the convention.
+
+Pure and dialect-agnostic.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+INFO = "info"
+
+_CREATED = re.compile(r"^(created?_(at|on|time|date|dt)|create_(time|date|dt)|creation_date|reg(istered)?_(at|dt|date)|insert(ed)?_(at|dt))$")
+_UPDATED = re.compile(r"^(updated?_(at|on|time|date|dt)|update_(time|date|dt)|modified?_(at|on|time|date|dt)|last_modified(_at)?|mod_dt)$")
+
+# Only flag when at least this share of tables already follows the convention.
+_ADOPTION_THRESHOLD = 0.5
+_MIN_TABLES = 4
+
+
+def check_audit_columns(snapshot: dict[str, Any] | None) -> dict[str, Any]:
+    """Flag tables missing the audit columns their schema-mates have."""
+    snapshot = snapshot or {}
+    relations = snapshot.get("relations") or []
+    columns = snapshot.get("columns") or []
+
+    tables = {
+        r.get("relation_oid"): r
+        for r in relations
+        if (r.get("relation_kind") or "r") in ("r", "p")
+    }
+    has_created: set[Any] = set()
+    has_updated: set[Any] = set()
+    for c in columns:
+        oid = c.get("relation_oid")
+        if oid not in tables:
+            continue
+        name = str(c.get("column_name") or "").lower()
+        if _CREATED.match(name):
+            has_created.add(oid)
+        elif _UPDATED.match(name):
+            has_updated.add(oid)
+
+    total = len(tables)
+    created_share = len(has_created) / total if total else 0.0
+    updated_share = len(has_updated) / total if total else 0.0
+
+    items: list[dict[str, Any]] = []
+    if total >= _MIN_TABLES:
+        for oid, rel in tables.items():
+            qname = f"{rel.get('schema_name')}.{rel.get('relation_name')}"
+            missing = []
+            if created_share >= _ADOPTION_THRESHOLD and oid not in has_created:
+                missing.append("created_at")
+            if updated_share >= _ADOPTION_THRESHOLD and oid not in has_updated:
+                missing.append("updated_at")
+            if missing:
+                items.append(
+                    {
+                        "category": "missing_audit_columns",
+                        "severity": INFO,
+                        "table": qname,
+                        "missing": missing,
+                        "detail": (
+                            f"Missing {' & '.join(missing)} while most tables in this "
+                            "schema track them — row lifecycle will be unanswerable."
+                        ),
+                    }
+                )
+
+    items.sort(key=lambda i: i["table"])
+    summary = {
+        "tables": total,
+        "with_created": len(has_created),
+        "with_updated": len(has_updated),
+        "created_adoption": round(created_share, 2),
+        "updated_adoption": round(updated_share, 2),
+        "convention_active": total >= _MIN_TABLES
+        and (created_share >= _ADOPTION_THRESHOLD or updated_share >= _ADOPTION_THRESHOLD),
+        "total": len(items),
+    }
+    return {"items": items, "summary": summary}
diff --git a/backend/app/spec/constraint_inventory.py b/backend/app/spec/constraint_inventory.py
new file mode 100644
index 00000000..0c47f502
--- /dev/null
+++ b/backend/app/spec/constraint_inventory.py
@@ -0,0 +1,94 @@
+"""Inventory business rules living in constraints, and flag CASCADE risk.
+
+Reverse engineering isn't just tables and columns -- the *business rules* often
+hide in CHECK constraints, and the operational hazards hide in FK referential
+actions. This inventories both:
+
+* **check_rules** -- every CHECK constraint with its expression: the closest
+  thing a legacy database has to documented invariants.
+* **cascade_deletes** (warning) -- ``ON DELETE CASCADE`` foreign keys: deleting
+  a parent silently deletes children; every operator should know these paths.
+* **set_null_deletes** (info) -- ``ON DELETE SET NULL``: orphaned-but-kept rows.
+
+Pure and dialect-agnostic (PostgreSQL action codes 'c'/'n' plus spelled-out
+variants are both handled).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+WARNING = "warning"
+INFO = "info"
+
+_CASCADE = {"c", "cascade"}
+_SET_NULL = {"n", "set null", "set_null"}
+
+
+def build_constraint_inventory(snapshot: dict[str, Any] | None) -> dict[str, Any]:
+    """Return CHECK-rule inventory and FK delete-action risk findings."""
+    snapshot = snapshot or {}
+    constraints = snapshot.get("constraints") or []
+
+    check_rules: list[dict[str, Any]] = []
+    cascade_items: list[dict[str, Any]] = []
+
+    for con in constraints:
+        ctype = str(con.get("constraint_type") or "").lower()
+        table = f"{con.get('schema_name')}.{con.get('relation_name')}"
+        name = str(con.get("constraint_name") or "")
+
+        if ctype == "c":
+            expr = con.get("check_expr") or con.get("constraint_def")
+            check_rules.append(
+                {
+                    "table": table,
+                    "constraint": name,
+                    "expression": str(expr or ""),
+                }
+            )
+        elif ctype == "f":
+            on_delete = str(con.get("fk_on_delete") or "").lower()
+            target = (
+                f"{con.get('foreign_schema_name')}.{con.get('foreign_relation_name')}"
+            )
+            if on_delete in _CASCADE:
+                cascade_items.append(
+                    {
+                        "category": "cascade_delete",
+                        "severity": WARNING,
+                        "table": table,
+                        "constraint": name,
+                        "references": target,
+                        "detail": (
+                            f"Deleting a row in {target} silently deletes rows in "
+                            f"{table} (ON DELETE CASCADE via '{name}')."
+                        ),
+                    }
+                )
+            elif on_delete in _SET_NULL:
+                cascade_items.append(
+                    {
+                        "category": "set_null_delete",
+                        "severity": INFO,
+                        "table": table,
+                        "constraint": name,
+                        "references": target,
+                        "detail": (
+                            f"Deleting a row in {target} nulls the reference in "
+                            f"{table} (ON DELETE SET NULL via '{name}') — rows are kept but orphaned."
+                        ),
+                    }
+                )
+
+    check_rules.sort(key=lambda r: (r["table"], r["constraint"]))
+    cascade_items.sort(
+        key=lambda i: (0 if i["severity"] == WARNING else 1, i["table"], i["constraint"])
+    )
+
+    summary = {
+        "check_rules": len(check_rules),
+        "cascade_deletes": sum(1 for i in cascade_items if i["category"] == "cascade_delete"),
+        "set_null_deletes": sum(1 for i in cascade_items if i["category"] == "set_null_delete"),
+    }
+    return {"check_rules": check_rules, "delete_actions": cascade_items, "summary": summary}
diff --git a/backend/app/spec/dbml_import.py b/backend/app/spec/dbml_import.py
new file mode 100644
index 00000000..b93454a9
--- /dev/null
+++ b/backend/app/spec/dbml_import.py
@@ -0,0 +1,323 @@
+"""Parse DBML (database markup language) into the common snapshot JSON.
+
+Design-first workflow: write DBML (the dbdiagram.io/dbdocs dialect), convert it
+to the same snapshot shape introspection produces, and every downstream feature
+works on it unchanged — DDL export, migration generation, analyzers, the ERD.
+
+Supported subset (the parts real DBML files actually use):
+
+* ``Table [schema.]name { ... }`` with columns ``name type [settings]``
+* column settings: ``pk``/``primary key``, ``not null``, ``unique``, ``default:``,
+  ``note:``, inline ``ref: > other.col`` (also ``<`` and ``-``)
+* standalone ``Ref: a.col > b.col`` / ``Ref name { a.col > b.col }``
+* quoted identifiers ``"My Table"``; comments ``//``; multi-word types
+
+Ignored (parsed over, not errors): ``Project``/``Enum``/``TableGroup``/``Note``
+blocks, ``indexes`` blocks, header colors. ponytail: line-oriented parser, not a
+grammar — good for the 95% of DBML in the wild; a hostile file degrades to
+skipped lines, never an exception.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+_COLUMN_RE = re.compile(
+    r"^(?:\"(?P<qname>[^\"]+)\"|(?P<name>\w+))\s+"
+    r"(?P<type>[\w]+(?:\([^)]*\))?(?:\[\])?)"
+    r"(?:\s*\[(?P<settings>.*)\])?\s*$"
+)
+# a dotted path whose segments may be quoted (quotes can contain spaces)
+_PATH = r'(?:"[^"]+"|\w+)(?:\.(?:"[^"]+"|\w+))*'
+_REF_RE = re.compile(
+    r"ref\s*(?:\w+\s*)?:?\s*"
+    rf"(?P<from>{_PATH})\s*(?P<op>[<>-])\s*(?P<to>{_PATH})",
+    re.IGNORECASE,
+)
+_INLINE_REF_RE = re.compile(rf"ref:\s*(?P<op>[<>-])\s*(?P<to>{_PATH})", re.IGNORECASE)
+_PATH_SEGMENT_RE = re.compile(r'"[^"]+"|[^.]+')
+
+
+def _consume_table_name(line: str, start: int) -> tuple[str, int] | None:
+    """Return the table identifier and the offset after it, using only linear scans."""
+    if start >= len(line):
+        return None
+    if line[start] == '"':
+        end = line.find('"', start + 1)
+        if end <= start + 1:
+            return None
+        return line[start + 1 : end], end + 1
+
+    pos = start
+    while pos < len(line) and (line[pos].isalnum() or line[pos] in "_."):
+        pos += 1
+    if pos == start:
+        return None
+
+    raw = line[start:pos]
+    parts = raw.split(".")
+    if any(part == "" for part in parts):
+        return None
+    return raw, pos
+
+
+def _table_header_tail_ok(tail: str) -> bool:
+    """Validate what may follow a ``Table <name>`` header on the same line.
+
+    Grammar (whitespace-insensitive): an optional ``as <alias>`` rename followed
+    by an optional opening ``{`` (dbdiagram also allows the brace on the next
+    line). Implemented with plain string scanning rather than a regex so there
+    is no backtracking.
+    """
+    rest = tail.strip()
+    if not rest:
+        return True
+    if rest[:2].lower() == "as" and (len(rest) == 2 or rest[2].isspace()):
+        rest = rest[2:].lstrip()
+        alias_len = 0
+        while alias_len < len(rest) and (
+            rest[alias_len].isalnum() or rest[alias_len] == "_"
+        ):
+            alias_len += 1
+        if alias_len == 0:
+            return False
+        rest = rest[alias_len:].lstrip()
+    return rest in ("", "{")
+
+
+def _parse_table_header(line: str) -> tuple[str, str] | None:
+    """Parse ``Table [schema.]name`` headers without regex backtracking."""
+    if len(line) < 6 or line[:5].lower() != "table" or not line[5].isspace():
+        return None
+    pos = 5
+    while pos < len(line) and line[pos].isspace():
+        pos += 1
+    consumed = _consume_table_name(line, pos)
+    if consumed is None:
+        return None
+    raw_name, pos = consumed
+    if not _table_header_tail_ok(line[pos:]):
+        return None
+    return _split_table_name(raw_name)
+
+
+def _split_table_name(raw: str) -> tuple[str, str]:
+    raw = raw.strip().strip('"')
+    if "." in raw:
+        schema, _, name = raw.partition(".")
+        return schema.strip('"'), name.strip('"')
+    return "public", raw
+
+
+def _split_col_ref(raw: str) -> tuple[str, str, str]:
+    """'schema.table.col' | 'table.col' -> (schema, table, col).
+
+    Splits on dots *outside* quotes so '"Order Items".account_id' works.
+    """
+    parts = [p.strip('"') for p in _PATH_SEGMENT_RE.findall(raw.strip())]
+    if len(parts) >= 3:
+        return parts[0], parts[1], parts[2]
+    if len(parts) == 2:
+        return "public", parts[0], parts[1]
+    return "public", "", parts[0]
+
+
+def parse_dbml(text: str) -> dict[str, Any]:
+    """Parse DBML text into snapshot JSON (relations/columns/pk_columns/fk_edges)."""
+    relations: list[dict[str, Any]] = []
+    columns: list[dict[str, Any]] = []
+    pk_columns: list[dict[str, Any]] = []
+    fk_specs: list[tuple[str, str, str, str, str, str]] = []  # child s/t/c, parent s/t/c
+
+    oid_by_table: dict[tuple[str, str], int] = {}
+    next_oid = 1
+    current: tuple[str, str] | None = None
+    in_ignored_block = 0
+    in_indexes = False
+
+    for raw_line in text.splitlines():
+        # ReDoS guard: no legitimate DBML line approaches this length; capping
+        # input size per regex call bounds worst-case backtracking to O(1).
+        if len(raw_line) > 4096:
+            continue
+        line = raw_line.split("//", 1)[0].strip()
+        if not line:
+            continue
+
+        # ignored blocks (Project / Enum / TableGroup / Note) — track braces
+        if in_ignored_block:
+            in_ignored_block += line.count("{") - line.count("}")
+            continue
+        if re.match(r"^(project|enum|tablegroup|note)\b", line, re.IGNORECASE):
+            in_ignored_block = line.count("{") - line.count("}")
+            if in_ignored_block <= 0 and "{" not in line:
+                in_ignored_block = 1  # block opens on a following line
+            continue
+
+        table_name = _parse_table_header(line)
+        if table_name is not None:
+            schema, name = table_name
+            current = (schema, name)
+            if current not in oid_by_table:
+                oid_by_table[current] = next_oid
+                relations.append(
+                    {
+                        "relation_oid": next_oid,
+                        "relation_kind": "r",
+                        "schema_name": schema,
+                        "relation_name": name,
+                        "relation_comment": None,
+                    }
+                )
+                next_oid += 1
+            continue
+
+        if line.startswith("}"):
+            current = None
+            in_indexes = False
+            continue
+
+        # standalone Ref (works inside or outside a table body)
+        if re.match(r"^ref\b", line, re.IGNORECASE):
+            rm = _REF_RE.search(line)
+            if rm:
+                fs, ft, fc = _split_col_ref(rm.group("from"))
+                ts, tt, tc = _split_col_ref(rm.group("to"))
+                if rm.group("op") == "<":  # a < b means b references a
+                    fs, ft, fc, ts, tt, tc = ts, tt, tc, fs, ft, fc
+                if ft and tt:
+                    fk_specs.append((fs, ft, fc, ts, tt, tc))
+            continue
+
+        if current is None:
+            continue
+        if re.match(r"^indexes\s*\{", line, re.IGNORECASE):
+            in_indexes = True
+            continue
+        if in_indexes:
+            if "}" in line:
+                in_indexes = False
+            continue
+
+        cm = _COLUMN_RE.match(line)
+        if not cm:
+            continue
+        col_name = (cm.group("qname") or cm.group("name")).strip('"')
+        settings = (cm.group("settings") or "").lower()
+        oid = oid_by_table[current]
+        is_pk = bool(re.search(r"\bpk\b|primary\s+key", settings))
+        columns.append(
+            {
+                "relation_oid": oid,
+                "column_name": col_name,
+                "column_position": sum(1 for c in columns if c["relation_oid"] == oid) + 1,
+                "data_type": cm.group("type"),
+                "is_not_null": is_pk or "not null" in settings,
+                "has_default": "default:" in settings,
+                "default_expr": None,
+                "column_comment": None,
+            }
+        )
+        if is_pk:
+            pk_columns.append(
+                {"relation_oid": oid, "column_name": col_name, "column_ordinal": len(pk_columns) + 1}
+            )
+        im = _INLINE_REF_RE.search(cm.group("settings") or "")
+        if im:
+            ts, tt, tc = _split_col_ref(im.group("to"))
+            if im.group("op") == "<":
+                # inverse inline ref: the other table references this column
+                fk_specs.append((ts, tt, tc, current[0], current[1], col_name))
+            else:
+                fk_specs.append((current[0], current[1], col_name, ts, tt, tc))
+
+    fk_edges: list[dict[str, Any]] = []
+    for i, (cs, ct, cc, ps, pt, pc) in enumerate(fk_specs, start=1):
+        child = oid_by_table.get((cs, ct))
+        parent = oid_by_table.get((ps, pt))
+        if child is None or parent is None:
+            continue  # ref to a table not defined in this document
+        fk_edges.append(
+            {
+                "fk_constraint_oid": 100000 + i,
+                "fk_constraint_name": f"fk_{ct}_{cc}",
+                "child_relation_oid": child,
+                "parent_relation_oid": parent,
+                "child_column_name": cc,
+                "parent_column_name": pc,
+                "column_ordinal": 1,
+            }
+        )
+
+    constraints = _build_constraints(relations, columns, pk_columns, fk_edges)
+
+    return {
+        "source": "dbml",
+        "schemas": sorted({r["schema_name"] for r in relations}),
+        "relations": relations,
+        "columns": columns,
+        "constraints": constraints,
+        "indexes": [],
+        "pk_columns": pk_columns,
+        "fk_edges": fk_edges,
+        "citus_distributed_tables": [],
+    }
+
+
+def _build_constraints(
+    relations: list[dict[str, Any]],
+    columns: list[dict[str, Any]],
+    pk_columns: list[dict[str, Any]],
+    fk_edges: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Derive the ``constraints`` array (what DDL export renders) from parsed parts."""
+    rel_by_oid = {r["relation_oid"]: r for r in relations}
+    pos_by_oid_col: dict[tuple[int, str], int] = {
+        (c["relation_oid"], c["column_name"]): c["column_position"] for c in columns
+    }
+    constraints: list[dict[str, Any]] = []
+
+    pk_cols_by_oid: dict[int, list[str]] = {}
+    for pk in pk_columns:
+        pk_cols_by_oid.setdefault(pk["relation_oid"], []).append(pk["column_name"])
+    for oid, cols in pk_cols_by_oid.items():
+        rel = rel_by_oid[oid]
+        quoted = ", ".join(f'"{c}"' for c in cols)
+        constraints.append(
+            {
+                "constraint_oid": 200000 + oid,
+                "constraint_name": f"pk_{rel['relation_name']}",
+                "constraint_type": "p",
+                "schema_name": rel["schema_name"],
+                "relation_oid": oid,
+                "relation_name": rel["relation_name"],
+                "constrained_attnums": [pos_by_oid_col[(oid, c)] for c in cols],
+                "constraint_def": f"PRIMARY KEY ({quoted})",
+            }
+        )
+
+    for edge in fk_edges:
+        child = rel_by_oid[edge["child_relation_oid"]]
+        parent = rel_by_oid[edge["parent_relation_oid"]]
+        constraints.append(
+            {
+                "constraint_oid": 300000 + edge["fk_constraint_oid"],
+                "constraint_name": edge["fk_constraint_name"],
+                "constraint_type": "f",
+                "schema_name": child["schema_name"],
+                "relation_oid": edge["child_relation_oid"],
+                "relation_name": child["relation_name"],
+                "constrained_attnums": [
+                    pos_by_oid_col.get(
+                        (edge["child_relation_oid"], edge["child_column_name"]), 1
+                    )
+                ],
+                "constraint_def": (
+                    f'FOREIGN KEY ("{edge["child_column_name"]}") REFERENCES '
+                    f'"{parent["schema_name"]}"."{parent["relation_name"]}" '
+                    f'("{edge["parent_column_name"]}")'
+                ),
+            }
+        )
+    return constraints
diff --git a/backend/app/spec/fk_cycles.py b/backend/app/spec/fk_cycles.py
new file mode 100644
index 00000000..03788598
--- /dev/null
+++ b/backend/app/spec/fk_cycles.py
@@ -0,0 +1,129 @@
+"""Detect circular foreign-key dependencies in a snapshot.
+
+A cycle in the FK graph (A → B → … → A) means there's no order in which the
+tables can be created, dropped, or bulk-loaded without deferring constraints --
+a real migration hazard. Self-references (``employee.manager_id → employee``)
+are a normal, benign special case and are reported separately.
+
+Pure and dialect-agnostic. Uses an iterative Tarjan SCC so a deep FK chain can't
+blow the recursion limit.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+WARNING = "warning"
+INFO = "info"
+
+
+def _sccs(nodes: list[str], adj: dict[str, set[str]]) -> list[list[str]]:
+    """Tarjan's strongly-connected components (iterative)."""
+    index: dict[str, int] = {}
+    low: dict[str, int] = {}
+    on_stack: set[str] = set()
+    stack: list[str] = []
+    result: list[list[str]] = []
+    counter = 0
+
+    for root in nodes:
+        if root in index:
+            continue
+        index[root] = low[root] = counter
+        counter += 1
+        stack.append(root)
+        on_stack.add(root)
+        work = [(root, iter(sorted(adj.get(root, set()))))]
+        while work:
+            v, it = work[-1]
+            pushed = False
+            for w in it:
+                if w not in index:
+                    index[w] = low[w] = counter
+                    counter += 1
+                    stack.append(w)
+                    on_stack.add(w)
+                    work.append((w, iter(sorted(adj.get(w, set())))))
+                    pushed = True
+                    break
+                if w in on_stack:
+                    low[v] = min(low[v], index[w])
+            if pushed:
+                continue
+            if low[v] == index[v]:
+                comp = []
+                while True:
+                    w = stack.pop()
+                    on_stack.discard(w)
+                    comp.append(w)
+                    if w == v:
+                        break
+                result.append(comp)
+            work.pop()
+            if work:
+                low[work[-1][0]] = min(low[work[-1][0]], low[v])
+    return result
+
+
+def detect_fk_cycles(snapshot: dict[str, Any] | None) -> dict[str, Any]:
+    """Return circular-FK findings (multi-table cycles + self-references)."""
+    snapshot = snapshot or {}
+    relations = snapshot.get("relations") or []
+    fk_edges = snapshot.get("fk_edges") or []
+
+    def _qname(oid: Any) -> str | None:
+        rel = rel_by_oid.get(oid)
+        if rel is None:
+            return None
+        return f"{rel.get('schema_name')}.{rel.get('relation_name')}"
+
+    rel_by_oid = {r.get("relation_oid"): r for r in relations}
+
+    adj: dict[str, set[str]] = {}
+    nodes: set[str] = set()
+    self_refs: set[str] = set()
+    for edge in fk_edges:
+        child = _qname(edge.get("child_relation_oid"))
+        parent = _qname(edge.get("parent_relation_oid"))
+        if child is None or parent is None:
+            continue
+        nodes.add(child)
+        nodes.add(parent)
+        if child == parent:
+            self_refs.add(child)
+        else:
+            adj.setdefault(child, set()).add(parent)
+
+    items: list[dict[str, Any]] = []
+    for comp in _sccs(sorted(nodes), adj):
+        if len(comp) >= 2:
+            tables = sorted(comp)
+            items.append(
+                {
+                    "category": "circular_dependency",
+                    "severity": WARNING,
+                    "tables": tables,
+                    "detail": (
+                        "Circular foreign-key dependency: "
+                        + " → ".join(tables)
+                        + " — no create/drop/load order works without deferring constraints."
+                    ),
+                }
+            )
+    for table in sorted(self_refs):
+        items.append(
+            {
+                "category": "self_reference",
+                "severity": INFO,
+                "tables": [table],
+                "detail": f"{table} references itself (hierarchical/tree) — usually fine; load roots first.",
+            }
+        )
+
+    items.sort(key=lambda i: (0 if i["severity"] == WARNING else 1, i["tables"]))
+    summary = {
+        "circular_dependencies": sum(1 for i in items if i["category"] == "circular_dependency"),
+        "self_references": len(self_refs),
+        "total": len(items),
+    }
+    return {"items": items, "summary": summary}
diff --git a/backend/app/spec/index_redundancy.py b/backend/app/spec/index_redundancy.py
new file mode 100644
index 00000000..14d944ea
--- /dev/null
+++ b/backend/app/spec/index_redundancy.py
@@ -0,0 +1,100 @@
+"""Detect redundant (prefix-shadowed) and duplicate indexes.
+
+Every index costs write amplification and storage on each INSERT/UPDATE. An
+index on ``(a)`` is *redundant* when another index on the same table starts
+with ``(a, ...)`` -- the wider index already serves those scans. Two indexes
+over the identical column list are *duplicates*. Both are safe wins to drop.
+
+Pure and dialect-agnostic. Column lists come from a best-effort parse of
+``index_def``; expression/partial indexes that don't parse are skipped rather
+than guessed (ponytail: false negatives over false positives -- dropping an
+index is cheap to re-do, a wrong "drop this" suggestion is not).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+WARNING = "warning"
+INFO = "info"
+
+
+def _index_columns(index_def: object) -> list[str]:
+    """Best-effort ordered column list from an index definition."""
+    text = str(index_def or "")
+    if " where " in text.lower():
+        return []  # partial index: not comparable
+    match = re.search(r"\(([^()]*)\)", text)
+    if not match:
+        return []
+    cols: list[str] = []
+    for part in match.group(1).split(","):
+        token = part.strip().strip('"').split()
+        if not token or "(" in part:
+            return []  # expression index: not comparable
+        cols.append(token[0].strip('"').lower())
+    return cols
+
+
+def detect_index_redundancy(snapshot: dict[str, Any] | None) -> dict[str, Any]:
+    """Return duplicate and prefix-shadowed indexes, per table."""
+    snapshot = snapshot or {}
+    relations = snapshot.get("relations") or []
+    indexes = snapshot.get("indexes") or []
+    rel_by_oid = {r.get("relation_oid"): r for r in relations}
+
+    by_table: dict[Any, list[tuple[str, tuple[str, ...], bool]]] = {}
+    for idx in indexes:
+        oid = idx.get("relation_oid") or idx.get("table_oid")
+        cols = tuple(_index_columns(idx.get("index_def")))
+        if not cols:
+            continue
+        name = str(idx.get("index_name") or "")
+        unique = bool(idx.get("is_unique") or idx.get("is_primary"))
+        by_table.setdefault(oid, []).append((name, cols, unique))
+
+    items: list[dict[str, Any]] = []
+    for oid, idx_list in by_table.items():
+        rel = rel_by_oid.get(oid) or {}
+        table = f"{rel.get('schema_name')}.{rel.get('relation_name')}"
+        for i, (name_a, cols_a, unique_a) in enumerate(idx_list):
+            for name_b, cols_b, unique_b in idx_list[i + 1:]:
+                if cols_a == cols_b:
+                    # exact duplicate: suggest dropping the non-unique one
+                    drop = name_b if unique_a and not unique_b else name_a if unique_b and not unique_a else name_b
+                    items.append(
+                        {
+                            "category": "duplicate_index", "severity": WARNING,
+                            "table": table, "index": drop,
+                            "kept": name_a if drop == name_b else name_b,
+                            "columns": list(cols_a),
+                            "detail": f"'{drop}' duplicates '{name_a if drop == name_b else name_b}' on ({', '.join(cols_a)}) — drop it.",
+                        }
+                    )
+                    continue
+                for shorter, longer, s_name, l_name, s_unique in (
+                    (cols_a, cols_b, name_a, name_b, unique_a),
+                    (cols_b, cols_a, name_b, name_a, unique_b),
+                ):
+                    if longer[: len(shorter)] == shorter:
+                        if s_unique:
+                            break  # unique index enforces a constraint; never suggest dropping
+                        items.append(
+                            {
+                                "category": "prefix_redundant_index", "severity": INFO,
+                                "table": table, "index": s_name,
+                                "kept": l_name,
+                                "columns": list(shorter),
+                                "detail": f"'{s_name}' on ({', '.join(shorter)}) is a prefix of '{l_name}' on ({', '.join(longer)}) — likely droppable.",
+                            }
+                        )
+                        break
+
+    items.sort(key=lambda i: (0 if i["severity"] == WARNING else 1, i["table"], i["index"]))
+    summary = {
+        "duplicates": sum(1 for i in items if i["category"] == "duplicate_index"),
+        "prefix_redundant": sum(1 for i in items if i["category"] == "prefix_redundant_index"),
+        "total": len(items),
+    }
+    return {"items": items, "summary": summary}
diff --git a/backend/app/spec/orm_codegen.py b/backend/app/spec/orm_codegen.py
new file mode 100644
index 00000000..a6ddc915
--- /dev/null
+++ b/backend/app/spec/orm_codegen.py
@@ -0,0 +1,307 @@
+"""Generate ORM model code (SQLAlchemy 2.0 / Prisma) from a snapshot.
+
+Forward engineering all the way to application code: reverse-engineer a legacy
+database, then hand developers ready-to-edit ORM models instead of making them
+retype every table. Most diagram tools stop at DDL — this is a differentiator
+(see docs/erd-tool-feature-research.md).
+
+Pure and dialect-agnostic. Type mapping is best-effort: unmapped SQL types fall
+back to ``str``/``String`` with the original type kept in a comment, so the
+output always imports/parses.
+"""
+
+from __future__ import annotations
+
+import json
+import keyword
+import re
+from typing import Any
+
+_PY_TYPES: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r"^(big)?serial|^(small|big)?int|^integer"), "int"),
+    (re.compile(r"^bool"), "bool"),
+    (re.compile(r"^(timestamp|datetime)"), "dt.datetime"),
+    (re.compile(r"^date$"), "dt.date"),
+    (re.compile(r"^time($|\()"), "dt.time"),
+    (re.compile(r"^(numeric|decimal)"), "Decimal"),
+    (re.compile(r"^(real|float|double)"), "float"),
+    (re.compile(r"^uuid"), "uuid.UUID"),
+    (re.compile(r"^(json|jsonb)"), "dict"),
+    (re.compile(r"^bytea|^(var)?binary|^blob"), "bytes"),
+    (re.compile(r"^(text|(var)?char|character|enum)"), "str"),
+]
+
+_PRISMA_TYPES: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r"^bigserial|^bigint"), "BigInt"),
+    (re.compile(r"^serial|^(small)?int|^integer"), "Int"),
+    (re.compile(r"^bool"), "Boolean"),
+    (re.compile(r"^(timestamp|datetime|date$|time($|\())"), "DateTime"),
+    (re.compile(r"^(numeric|decimal)"), "Decimal"),
+    (re.compile(r"^(real|float|double)"), "Float"),
+    (re.compile(r"^(json|jsonb)"), "Json"),
+    (re.compile(r"^bytea|^(var)?binary|^blob"), "Bytes"),
+]
+
+
+def _map_type(data_type: str, table: list[tuple[re.Pattern[str], str]], default: str) -> str:
+    lowered = data_type.strip().lower()
+    for pattern, mapped in table:
+        if pattern.search(lowered):
+            return mapped
+    return default
+
+
+def _snake_name(value: object, fallback: str) -> str:
+    name = re.sub(r"(?<=[a-z0-9])(?=[A-Z])", "_", str(value or ""))
+    name = re.sub(r"[^0-9a-zA-Z]+", "_", name).strip("_").lower()
+    name = name or fallback
+    if name[0].isdigit():
+        name = f"{fallback}_{name}"
+    if keyword.iskeyword(name):
+        name = f"{name}_"
+    return name
+
+
+def _class_name(table_name: str) -> str:
+    parts = re.split(r"[^0-9a-zA-Z]+", table_name)
+    name = "".join(p[:1].upper() + p[1:] for p in parts if p)
+    if not name or name[0].isdigit():
+        name = f"Table{name}"
+    return f"{name}Model" if keyword.iskeyword(name) else name
+
+
+def _column_names(cols: list[dict[str, Any]]) -> dict[str, str]:
+    return {str(col.get("column_name")): _snake_name(col.get("column_name"), "column") for col in cols}
+
+
+def _index(snapshot: dict[str, Any] | None) -> dict[str, Any]:
+    snapshot = snapshot or {}
+    relations = [
+        r for r in snapshot.get("relations") or []
+        if (r.get("relation_kind") or "r") in ("r", "p")
+    ]
+    cols_by_oid: dict[Any, list[dict[str, Any]]] = {}
+    for c in snapshot.get("columns") or []:
+        cols_by_oid.setdefault(c.get("relation_oid"), []).append(c)
+    for cols in cols_by_oid.values():
+        cols.sort(key=lambda c: c.get("column_position") or 0)
+    pk_by_oid: dict[Any, set[str]] = {}
+    for pk in snapshot.get("pk_columns") or []:
+        pk_by_oid.setdefault(pk.get("relation_oid"), set()).add(str(pk.get("column_name")))
+    fk_by_child: dict[tuple[Any, str], dict[str, Any]] = {}
+    for e in snapshot.get("fk_edges") or []:
+        fk_by_child[(e.get("child_relation_oid"), str(e.get("child_column_name")))] = e
+    rel_by_oid = {r.get("relation_oid"): r for r in relations}
+    return {
+        "relations": relations,
+        "cols_by_oid": cols_by_oid,
+        "pk_by_oid": pk_by_oid,
+        "fk_by_child": fk_by_child,
+        "rel_by_oid": rel_by_oid,
+    }
+
+
+def generate_sqlalchemy_models(snapshot: dict[str, Any] | None) -> str:
+    """Render SQLAlchemy 2.0 (Mapped/mapped_column) models."""
+    ix = _index(snapshot)
+    lines = [
+        "# Generated by pg-erd-cloud — SQLAlchemy 2.0 models (edit freely)",
+        "from __future__ import annotations",
+        "",
+        "import datetime as dt",
+        "import uuid",
+        "from decimal import Decimal",
+        "",
+        "from sqlalchemy import ForeignKey",
+        "from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column",
+        "",
+        "",
+        "class Base(DeclarativeBase):",
+        "    pass",
+    ]
+    for rel in ix["relations"]:
+        oid = rel.get("relation_oid")
+        table = str(rel.get("relation_name"))
+        schema = str(rel.get("schema_name"))
+        lines += ["", "", f"class {_class_name(table)}(Base):"]
+        if rel.get("relation_comment"):
+            lines.append(f"    {str(rel['relation_comment'])!r}")
+            lines.append("")
+        lines.append(f"    __tablename__ = {table!r}")
+        if schema and schema != "public":
+            lines.append(f"    __table_args__ = {{'schema': {schema!r}}}")
+        cols = ix["cols_by_oid"].get(oid, [])
+        col_names = _column_names(cols)
+        if not cols:
+            lines.append("    pass")
+            continue
+        for col in cols:
+            name = str(col.get("column_name"))
+            attr = col_names[name]
+            raw_type = str(col.get("data_type") or "")
+            py_type = _map_type(raw_type, _PY_TYPES, "str")
+            not_null = bool(col.get("is_not_null"))
+            annotated = py_type if not_null else f"{py_type} | None"
+            args = [repr(name)] if attr != name else []
+            fk = ix["fk_by_child"].get((oid, name))
+            if fk is not None:
+                parent = ix["rel_by_oid"].get(fk.get("parent_relation_oid"))
+                if parent is not None:
+                    target = f'{parent.get("schema_name")}.{parent.get("relation_name")}.{fk.get("parent_column_name")}'
+                    if parent.get("schema_name") == "public":
+                        target = f'{parent.get("relation_name")}.{fk.get("parent_column_name")}'
+                    args.append(f"ForeignKey({target!r})")
+            if name in ix["pk_by_oid"].get(oid, set()):
+                args.append("primary_key=True")
+            comment = "" if _map_type(raw_type, _PY_TYPES, "?") != "?" else f"  # type: {raw_type}"
+            call = f"mapped_column({', '.join(args)})" if args else "mapped_column()"
+            lines.append(f"    {attr}: Mapped[{annotated}] = {call}{comment}")
+    return "\n".join(lines) + "\n"
+
+
+def generate_prisma_schema(snapshot: dict[str, Any] | None) -> str:
+    """Render a Prisma schema (models with @id/@map; relations as field pairs)."""
+    ix = _index(snapshot)
+    lines = [
+        "// Generated by pg-erd-cloud — Prisma schema (edit freely)",
+        'datasource db {',
+        '  provider = "postgresql"',
+        '  url      = env("DATABASE_URL")',
+        '}',
+    ]
+    # child fk list per parent for reverse relation fields
+    children_of: dict[Any, list[dict[str, Any]]] = {}
+    for (child_oid, _), e in ix["fk_by_child"].items():
+        children_of.setdefault(e.get("parent_relation_oid"), []).append(e)
+
+    for rel in ix["relations"]:
+        oid = rel.get("relation_oid")
+        table = str(rel.get("relation_name"))
+        model = _class_name(table)
+        lines += ["", f"model {model} {{"]
+        cols = ix["cols_by_oid"].get(oid, [])
+        col_names = _column_names(cols)
+        pk_cols = ix["pk_by_oid"].get(oid, set())
+        for col in cols:
+            name = str(col.get("column_name"))
+            field_name = col_names[name]
+            raw_type = str(col.get("data_type") or "")
+            p_type = _map_type(raw_type, _PRISMA_TYPES, "String")
+            optional = "" if col.get("is_not_null") else "?"
+            attrs = []
+            if name in pk_cols and len(pk_cols) == 1:
+                attrs.append("@id")
+            if field_name != name:
+                attrs.append(f"@map({json.dumps(name)})")
+            comment = "" if _map_type(raw_type, _PRISMA_TYPES, "?") != "?" and p_type != "String" or raw_type.lower().startswith(("text", "varchar", "char")) else f" // {raw_type}"
+            lines.append(f"  {field_name} {p_type}{optional}{' ' + ' '.join(attrs) if attrs else ''}{comment}")
+        # relation fields
+        for (child_oid, child_col), e in ix["fk_by_child"].items():
+            if child_oid != oid:
+                continue
+            parent = ix["rel_by_oid"].get(e.get("parent_relation_oid"))
+            if parent is None:
+                continue
+            pmodel = _class_name(str(parent.get("relation_name")))
+            child_field = col_names.get(child_col, _snake_name(child_col, "column"))
+            parent_cols = ix["cols_by_oid"].get(e.get("parent_relation_oid"), [])
+            parent_field = _column_names(parent_cols).get(str(e.get("parent_column_name")), _snake_name(e.get("parent_column_name"), "column"))
+            field = re.sub(r"_id$", "", child_field) or _snake_name(pmodel, "relation")
+            lines.append(
+                f"  {field} {pmodel} @relation(fields: [{child_field}], references: [{parent_field}])"
+            )
+        for e in children_of.get(oid, []):
+            child = ix["rel_by_oid"].get(e.get("child_relation_oid"))
+            if child is None:
+                continue
+            cmodel = _class_name(str(child.get("relation_name")))
+            lines.append(f"  {cmodel[0].lower() + cmodel[1:]}s {cmodel}[]")
+        if len(pk_cols) > 1:
+            ordered = [col_names[str(c.get("column_name"))] for c in cols if str(c.get("column_name")) in pk_cols]
+            lines.append(f"  @@id([{', '.join(ordered)}])")
+        lines.append(f"  @@map({json.dumps(table)})")
+        lines.append("}")
+    return "\n".join(lines) + "\n"
+
+
+_TS_TYPES: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r"^(big)?serial|^(small|big)?int|^integer|^(real|float|double|numeric|decimal)"), "number"),
+    (re.compile(r"^bool"), "boolean"),
+    (re.compile(r"^(timestamp|datetime|date$|time($|\())"), "Date"),
+    (re.compile(r"^(json|jsonb)"), "object"),
+    (re.compile(r"^bytea|^(var)?binary|^blob"), "Buffer"),
+]
+
+
+def generate_typeorm_entities(snapshot: dict[str, Any] | None) -> str:
+    """Render TypeORM entity classes (TypeScript decorators)."""
+    ix = _index(snapshot)
+    lines = [
+        "// Generated by pg-erd-cloud — TypeORM entities (edit freely)",
+        "import {",
+        "  Column,",
+        "  Entity,",
+        "  JoinColumn,",
+        "  ManyToOne,",
+        "  OneToMany,",
+        "  PrimaryColumn,",
+        "} from 'typeorm';",
+    ]
+    # reverse-relation index: parent oid -> child fk edges
+    children_of: dict[Any, list[dict[str, Any]]] = {}
+    for (child_oid, _), e in ix["fk_by_child"].items():
+        children_of.setdefault(e.get("parent_relation_oid"), []).append(e)
+
+    for rel in ix["relations"]:
+        oid = rel.get("relation_oid")
+        table = str(rel.get("relation_name"))
+        schema = str(rel.get("schema_name"))
+        cls = _class_name(table)
+        entity_args = json.dumps(table) if schema == "public" else f"{{ name: {json.dumps(table)}, schema: {json.dumps(schema)} }}"
+        lines += ["", f"@Entity({entity_args})", f"export class {cls} {{"]
+        cols = ix["cols_by_oid"].get(oid, [])
+        col_names = _column_names(cols)
+        for col in cols:
+            name = str(col.get("column_name"))
+            field_name = col_names[name]
+            raw_type = str(col.get("data_type") or "")
+            ts_type = _map_type(raw_type, _TS_TYPES, "string")
+            nullable = not col.get("is_not_null")
+            is_pk = name in ix["pk_by_oid"].get(oid, set())
+            options = []
+            if field_name != name:
+                options.append(f"name: {json.dumps(name)}")
+            if nullable and not is_pk:
+                options.append("nullable: true")
+            decorator = "@PrimaryColumn" if is_pk else "@Column"
+            decorator = f"{decorator}({{{', '.join(options)}}})" if options else f"{decorator}()"
+            comment = "" if _map_type(raw_type, _TS_TYPES, "?") != "?" and ts_type != "string" or raw_type.lower().startswith(("text", "varchar", "char")) else f" // {raw_type}"
+            lines.append(f"  {decorator}")
+            lines.append(f"  {field_name}{'?' if nullable else '!'}: {ts_type}{' | null' if nullable else ''};{comment}")
+            lines.append("")
+        for (child_oid, child_col), e in ix["fk_by_child"].items():
+            if child_oid != oid:
+                continue
+            parent = ix["rel_by_oid"].get(e.get("parent_relation_oid"))
+            if parent is None:
+                continue
+            pcls = _class_name(str(parent.get("relation_name")))
+            child_field = col_names.get(child_col, _snake_name(child_col, "column"))
+            field = re.sub(r"_id$", "", child_field) or _snake_name(pcls, "relation")
+            lines.append(f"  @ManyToOne(() => {pcls})")
+            lines.append(f"  @JoinColumn({{ name: {json.dumps(child_col)} }})")
+            lines.append(f"  {field}?: {pcls};")
+            lines.append("")
+        for e in children_of.get(oid, []):
+            child = ix["rel_by_oid"].get(e.get("child_relation_oid"))
+            if child is None:
+                continue
+            ccls = _class_name(str(child.get("relation_name")))
+            field = ccls[0].lower() + ccls[1:] + "s"
+            lines.append(f"  @OneToMany(() => {ccls}, (child) => child)")
+            lines.append(f"  {field}?: {ccls}[];")
+            lines.append("")
+        while lines and lines[-1] == "":
+            lines.pop()
+        lines.append("}")
+    return "\n".join(lines) + "\n"
diff --git a/backend/app/spec/schema_stats.py b/backend/app/spec/schema_stats.py
new file mode 100644
index 00000000..76f4b9fd
--- /dev/null
+++ b/backend/app/spec/schema_stats.py
@@ -0,0 +1,89 @@
+"""Compute overview statistics for a schema snapshot.
+
+A single call that answers "how big and how shaped is this schema?": object
+counts, column distribution, the widest tables, PK/FK/index coverage, and the
+most common data types. Useful for a dashboard header or an API consumer sizing
+a migration effort.
+
+Pure and dialect-agnostic.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from typing import Any
+
+_KIND_LABELS = {
+    "r": "table",
+    "p": "table",  # partitioned table
+    "v": "view",
+    "m": "materialized_view",
+    "f": "foreign_table",
+    "t": "toast",
+}
+
+
+def compute_schema_stats(snapshot: dict[str, Any] | None) -> dict[str, Any]:
+    """Return counts and distributions describing the snapshot."""
+    snapshot = snapshot or {}
+    relations = snapshot.get("relations") or []
+    columns = snapshot.get("columns") or []
+    pk_columns = snapshot.get("pk_columns") or []
+    fk_edges = snapshot.get("fk_edges") or []
+    indexes = snapshot.get("indexes") or []
+
+    rel_by_oid = {r.get("relation_oid"): r for r in relations}
+
+    kinds: Counter[str] = Counter()
+    for r in relations:
+        kinds[_KIND_LABELS.get(r.get("relation_kind") or "r", "other")] += 1
+
+    cols_per_oid: Counter[Any] = Counter()
+    nullable = 0
+    type_counts: Counter[str] = Counter()
+    for c in columns:
+        cols_per_oid[c.get("relation_oid")] += 1
+        if not c.get("is_not_null"):
+            nullable += 1
+        dtype = str(c.get("data_type") or "").strip().lower()
+        if dtype:
+            type_counts[dtype] += 1
+
+    table_oids = [
+        r.get("relation_oid")
+        for r in relations
+        if (r.get("relation_kind") or "r") in ("r", "p")
+    ]
+    pk_oids = {pk.get("relation_oid") for pk in pk_columns}
+    without_pk = sum(1 for oid in table_oids if oid not in pk_oids)
+
+    total_columns = len(columns)
+    table_total = len(table_oids)
+
+    def _qname(oid: Any) -> str:
+        rel = rel_by_oid.get(oid) or {}
+        return f"{rel.get('schema_name')}.{rel.get('relation_name')}"
+
+    widest = [
+        {"table": _qname(oid), "columns": n}
+        for oid, n in cols_per_oid.most_common(5)
+    ]
+
+    return {
+        "relations": {**dict(kinds), "total": len(relations)},
+        "columns": {
+            "total": total_columns,
+            "nullable": nullable,
+            "not_null": total_columns - nullable,
+            "avg_per_table": round(total_columns / table_total, 1) if table_total else 0.0,
+            "max_per_table": max(cols_per_oid.values(), default=0),
+        },
+        "constraints": {
+            "primary_keys": len(pk_oids),
+            "foreign_keys": len(fk_edges),
+            "indexes": len(indexes),
+        },
+        "tables_without_primary_key": without_pk,
+        "widest_tables": widest,
+        "data_types": dict(type_counts.most_common(10)),
+    }
diff --git a/backend/app/spec/sensitive_columns.py b/backend/app/spec/sensitive_columns.py
new file mode 100644
index 00000000..bf2345bf
--- /dev/null
+++ b/backend/app/spec/sensitive_columns.py
@@ -0,0 +1,90 @@
+"""Flag columns that likely hold sensitive / personal data (PII).
+
+This is a compliance **scoping** aid, NOT enforcement. It answers "which columns
+put me in regulatory scope?" by mapping likely-sensitive columns to the relevant
+framework (PCI DSS for card data, GDPR/PIPA for personal & special-category
+data, secrets-management for credentials). It does NOT encrypt, mask, tokenize,
+or apply access controls -- that remediation is the database owner's job.
+
+Pure and dialect-agnostic; name-heuristic only (no data is read). ponytail:
+name matching flags likely locations -- a review starting point, not proof; it
+won't catch sensitive data hidden behind an opaque column name, nor confirm a
+matched column actually holds regulated data.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+HIGH = "high"
+MEDIUM = "medium"
+LOW = "low"
+
+_SEVERITY_RANK = {HIGH: 0, MEDIUM: 1, LOW: 2}
+
+# (category, severity, framework, compiled pattern). Order matters: first match
+# wins, so the most specific / most sensitive categories come first. `framework`
+# names the regulation that brings the column into scope.
+_RULES: list[tuple[str, str, str, re.Pattern[str]]] = [
+    ("credential", HIGH, "Secrets (must never be stored in plaintext)", re.compile(r"pass(word|wd)?|passwd|secret|api[_-]?key|token|private[_-]?key|salt|otp")),
+    ("national_id", HIGH, "GDPR Art.9 / PIPA unique-identifier & special category", re.compile(r"ssn|social[_-]?security|resident[_-]?reg|jumin|national[_-]?id|passport|tax[_-]?id|driver[_-]?licen"),),
+    ("payment", HIGH, "PCI DSS (cardholder data environment)", re.compile(r"card[_-]?(no|num|number)|credit[_-]?card|ccnum|cvv|cvc|iban|account[_-]?(no|number)|routing")),
+    ("special_category", HIGH, "GDPR Art.9 / PIPA sensitive data", re.compile(r"(^|_)health|medical|diagnos|disease|biometric|fingerprint|(^|_)race($|_)|ethnic|religion|political|sexual|genetic")),
+    ("contact", MEDIUM, "GDPR / PIPA personal data", re.compile(r"e[_-]?mail|(^|_)email|phone|mobile|(^|_)tel($|_)|fax")),
+    ("location", MEDIUM, "GDPR / PIPA personal data", re.compile(r"address|(^|_)addr($|_)|zip[_-]?code|postal|(^|_)city($|_)|latitude|longitude|(^|_)geo")),
+    ("personal", MEDIUM, "GDPR / PIPA personal data", re.compile(r"birth|(^|_)dob($|_)|gender|nationality|marital")),
+    ("name", LOW, "GDPR / PIPA personal data", re.compile(r"(first|last|full|middle|given|family)[_-]?name|(^|_)fname|(^|_)lname|username|nickname")),
+]
+
+
+def detect_sensitive_columns(snapshot: dict[str, Any] | None) -> dict[str, Any]:
+    """Return a classified inventory of likely-sensitive columns."""
+    snapshot = snapshot or {}
+    relations = snapshot.get("relations") or []
+    columns = snapshot.get("columns") or []
+
+    rel_by_oid = {r.get("relation_oid"): r for r in relations}
+    items: list[dict[str, Any]] = []
+
+    for col in columns:
+        name = str(col.get("column_name") or "")
+        if not name:
+            continue
+        lname = name.lower()
+        for category, severity, framework, pattern in _RULES:
+            if pattern.search(lname):
+                rel = rel_by_oid.get(col.get("relation_oid")) or {}
+                items.append(
+                    {
+                        "schema": rel.get("schema_name"),
+                        "table": rel.get("relation_name"),
+                        "column": name,
+                        "category": category,
+                        "severity": severity,
+                        "framework": framework,
+                    }
+                )
+                break  # first (most sensitive) match wins
+
+    items.sort(
+        key=lambda i: (
+            _SEVERITY_RANK.get(i["severity"], 9),
+            str(i["schema"]),
+            str(i["table"]),
+            str(i["column"]),
+        )
+    )
+
+    by_framework: dict[str, int] = {}
+    for i in items:
+        by_framework[i["framework"]] = by_framework.get(i["framework"], 0) + 1
+
+    summary = {
+        "high": sum(1 for i in items if i["severity"] == HIGH),
+        "medium": sum(1 for i in items if i["severity"] == MEDIUM),
+        "low": sum(1 for i in items if i["severity"] == LOW),
+        "total": len(items),
+        "by_framework": by_framework,
+    }
+    return {"items": items, "summary": summary}
diff --git a/backend/tests/test_audit_columns.py b/backend/tests/test_audit_columns.py
new file mode 100644
index 00000000..0ab8b436
--- /dev/null
+++ b/backend/tests/test_audit_columns.py
@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from app.spec.audit_columns import check_audit_columns
+
+
+def _snap(tables):
+    """tables: {name: [column, ...]}"""
+    relations, columns = [], []
+    for oid, (t, cols) in enumerate(tables.items(), start=1):
+        relations.append({"relation_oid": oid, "relation_kind": "r", "schema_name": "public", "relation_name": t})
+        for c in cols:
+            columns.append({"relation_oid": oid, "column_name": c})
+    return {"relations": relations, "columns": columns}
+
+
+def test_flags_outlier_when_majority_has_audit_columns():
+    snap = _snap({
+        "a": ["id", "created_at", "updated_at"],
+        "b": ["id", "created_at", "updated_at"],
+        "c": ["id", "created_at", "updated_at"],
+        "d": ["id"],  # outlier
+    })
+    report = check_audit_columns(snap)
+    assert report["summary"]["convention_active"] is True
+    assert len(report["items"]) == 1
+    item = report["items"][0]
+    assert item["table"] == "public.d"
+    assert set(item["missing"]) == {"created_at", "updated_at"}
+
+
+def test_no_flags_when_schema_has_no_convention():
+    snap = _snap({
+        "a": ["id"], "b": ["id"], "c": ["id"], "d": ["id", "created_at"],
+    })
+    report = check_audit_columns(snap)  # 25% adoption < 50%
+    assert report["items"] == []
+    assert report["summary"]["convention_active"] is False
+
+
+def test_variant_names_count_as_audit_columns():
+    snap = _snap({
+        "a": ["id", "create_time", "modified_at"],
+        "b": ["id", "reg_dt", "last_modified"],
+        "c": ["id", "inserted_at", "update_dt"],
+        "d": ["id", "created_on", "updated_on"],
+    })
+    report = check_audit_columns(snap)
+    assert report["items"] == []  # all four satisfy both via variants
+    assert report["summary"]["with_created"] == 4
+    assert report["summary"]["with_updated"] == 4
+
+
+def test_small_schemas_are_not_judged_and_empty():
+    snap = _snap({"a": ["id", "created_at"], "b": ["id"]})  # only 2 tables
+    assert check_audit_columns(snap)["items"] == []
+    assert check_audit_columns({})["summary"]["tables"] == 0
diff --git a/backend/tests/test_clearfolio.py b/backend/tests/test_clearfolio.py
new file mode 100644
index 00000000..35272ca4
--- /dev/null
+++ b/backend/tests/test_clearfolio.py
@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import httpx
+import pytest
+
+from app.integrations import clearfolio as cf
+
+
+SECRET = "gateway-shared-secret"
+PERMS = "job:create,job:read,job:retry,viewer:read,artifact-link:create,analytics:read"
+
+
+def test_sign_tenant_claims_matches_golden_vector():
+    # Golden value computed from the documented recipe:
+    #   base64url(HMAC_SHA256(secret, tenant\nsubject\nperms\nissuedAt)), no padding
+    sig = cf.sign_tenant_claims(SECRET, "pg-erd-cloud", "dev:alice", PERMS, 1782995100)
+    assert sig == "TVdcjfzpR30SJmpCMrliK4gjuj6UY7zi2zGXBHzRlvc"
+    assert "=" not in sig  # unpadded
+    assert "+" not in sig and "/" not in sig  # base64URL alphabet
+
+
+def test_signature_binds_every_claim():
+    base = cf.sign_tenant_claims(SECRET, "t", "s", "p", 100)
+    assert base != cf.sign_tenant_claims(SECRET, "t2", "s", "p", 100)
+    assert base != cf.sign_tenant_claims(SECRET, "t", "s2", "p", 100)
+    assert base != cf.sign_tenant_claims(SECRET, "t", "s", "p2", 100)
+    assert base != cf.sign_tenant_claims(SECRET, "t", "s", "p", 101)
+    assert base != cf.sign_tenant_claims("other", "t", "s", "p", 100)
+
+
+def test_build_headers_sends_full_signed_set_and_self_verifies():
+    cfg = cf.ClearfolioConfig(
+        gateway_url="https://cf.example.com", hmac_secret=SECRET,
+        tenant_id="pg-erd-cloud", permissions=PERMS, timeout_seconds=10.0,
+    )
+    headers = cf.build_tenant_headers(cfg, "dev:alice", issued_at=1782995100)
+    assert headers["X-Clearfolio-Tenant-Id"] == "pg-erd-cloud"
+    assert headers["X-Clearfolio-Subject-Id"] == "dev:alice"
+    assert headers["X-Clearfolio-Permissions"] == PERMS
+    assert headers["X-Clearfolio-Claims-Issued-At"] == "1782995100"
+    # the signature header must equal an independent re-sign of the sent claims
+    assert headers["X-Clearfolio-Claims-Signature"] == cf.sign_tenant_claims(
+        SECRET,
+        headers["X-Clearfolio-Tenant-Id"],
+        headers["X-Clearfolio-Subject-Id"],
+        headers["X-Clearfolio-Permissions"],
+        int(headers["X-Clearfolio-Claims-Issued-At"]),
+    )
+
+
+@pytest.mark.asyncio
+async def test_not_configured_raises():
+    with patch.object(cf.settings, "clearfolio_gateway_url", None):
+        with pytest.raises(cf.ClearfolioNotConfigured):
+            await cf.submit_conversion_job("dev:alice", b"pdf", "spec.pdf")
+
+
+@pytest.mark.asyncio
+async def test_submit_signs_and_posts_multipart(monkeypatch):
+    monkeypatch.setattr(cf.settings, "clearfolio_gateway_url", "https://cf.example.com")
+    monkeypatch.setattr(cf.settings, "clearfolio_tenant_claims_hmac_secret", SECRET)
+    monkeypatch.setattr(cf.settings, "clearfolio_tenant_id", "pg-erd-cloud")
+    captured = {}
+
+    async def fake_validate(config):
+        return None
+
+    async def fake_request(self, method, url, headers=None, files=None):
+        captured.update(method=method, url=url, headers=headers, files=files)
+        return httpx.Response(202, json={"jobId": "j-1", "statusUrl": "/x"})
+
+    monkeypatch.setattr(cf, "_validate_gateway", fake_validate)
+    monkeypatch.setattr(httpx.AsyncClient, "request", fake_request)
+
+    out = await cf.submit_conversion_job("dev:alice", b"%PDF-1.7", "spec.pdf")
+    assert out["jobId"] == "j-1"
+    assert captured["method"] == "POST"
+    assert captured["url"] == "https://cf.example.com/api/v1/convert/jobs"
+    assert captured["headers"]["X-Clearfolio-Claims-Signature"]  # signed
+    assert captured["files"]["file"][0] == "spec.pdf"
+
+
+@pytest.mark.asyncio
+async def test_http_error_becomes_clearfolio_error(monkeypatch):
+    monkeypatch.setattr(cf.settings, "clearfolio_gateway_url", "https://cf.example.com")
+    monkeypatch.setattr(cf.settings, "clearfolio_tenant_claims_hmac_secret", SECRET)
+
+    async def fake_validate(config):
+        return None
+
+    async def fake_request(self, method, url, headers=None, files=None):
+        return httpx.Response(403, json={"error": "forbidden"})
+
+    monkeypatch.setattr(cf, "_validate_gateway", fake_validate)
+    monkeypatch.setattr(httpx.AsyncClient, "request", fake_request)
+    with pytest.raises(cf.ClearfolioError):
+        await cf.get_viewer_bootstrap("dev:alice", "doc-1")
+
+
+@pytest.mark.asyncio
+async def test_ids_are_url_encoded_as_path_segments(monkeypatch):
+    monkeypatch.setattr(cf.settings, "clearfolio_gateway_url", "https://cf.example.com")
+    monkeypatch.setattr(cf.settings, "clearfolio_tenant_claims_hmac_secret", SECRET)
+    captured = []
+
+    async def fake_validate(config):
+        return None
+
+    async def fake_request(self, method, url, headers=None, files=None):
+        captured.append((method, url))
+        return httpx.Response(200, json={"ok": True})
+
+    monkeypatch.setattr(cf, "_validate_gateway", fake_validate)
+    monkeypatch.setattr(httpx.AsyncClient, "request", fake_request)
+
+    await cf.get_job_status("dev:alice", "../job 1?x=y")
+    await cf.get_viewer_bootstrap("dev:alice", "folder/doc 1")
+    await cf.create_artifact_link("dev:alice", "folder/doc 1")
+
+    assert captured == [
+        ("GET", "https://cf.example.com/api/v1/convert/jobs/..%2Fjob%201%3Fx%3Dy"),
+        ("GET", "https://cf.example.com/api/v1/viewer/folder%2Fdoc%201"),
+        ("POST", "https://cf.example.com/api/v1/viewer/folder%2Fdoc%201/artifact-links"),
+    ]
+
+
+def test_permissions_canonicalized_to_match_clearfolio():
+    # messy config: spaces, a duplicate, a trailing empty entry
+    messy = " viewer:read , job:create,viewer:read, job:read ,"
+    assert cf.canonicalize_permissions(messy) == "viewer:read,job:create,job:read"
+    cfg = cf.ClearfolioConfig(
+        gateway_url="https://cf.example.com", hmac_secret=SECRET,
+        tenant_id=" pg-erd-cloud ", permissions=messy, timeout_seconds=10.0,
+    )
+    h = cf.build_tenant_headers(cfg, " dev:alice ", issued_at=100)
+    # sent header equals canonical form (no spaces/dupes), tenant/subject stripped
+    assert h["X-Clearfolio-Permissions"] == "viewer:read,job:create,job:read"
+    assert h["X-Clearfolio-Tenant-Id"] == "pg-erd-cloud"
+    assert h["X-Clearfolio-Subject-Id"] == "dev:alice"
+    # signature is over the canonical values, so Clearfolio's re-derivation matches
+    assert h["X-Clearfolio-Claims-Signature"] == cf.sign_tenant_claims(
+        SECRET, "pg-erd-cloud", "dev:alice", "viewer:read,job:create,job:read", 100
+    )
diff --git a/backend/tests/test_constraint_inventory.py b/backend/tests/test_constraint_inventory.py
new file mode 100644
index 00000000..27c2ec76
--- /dev/null
+++ b/backend/tests/test_constraint_inventory.py
@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from app.spec.constraint_inventory import build_constraint_inventory
+
+
+def _con(ctype, name, table="orders", ftable=None, on_delete=None, check_expr=None):
+    return {
+        "constraint_type": ctype,
+        "constraint_name": name,
+        "schema_name": "public",
+        "relation_name": table,
+        "foreign_schema_name": "public" if ftable else None,
+        "foreign_relation_name": ftable,
+        "fk_on_delete": on_delete,
+        "check_expr": check_expr,
+        "constraint_def": f"DEF {name}",
+    }
+
+
+def test_inventories_check_constraints_with_expressions():
+    snap = {"constraints": [
+        _con("c", "chk_qty_positive", check_expr="(quantity > 0)"),
+        _con("c", "chk_status", table="member", check_expr="(status IN ('active','banned'))"),
+        _con("p", "pk_orders"),
+    ]}
+    inv = build_constraint_inventory(snap)
+    assert inv["summary"]["check_rules"] == 2
+    assert inv["check_rules"][0]["table"] == "public.member"  # sorted by table
+    assert inv["check_rules"][1]["expression"] == "(quantity > 0)"
+
+
+def test_flags_cascade_delete_as_warning():
+    snap = {"constraints": [
+        _con("f", "fk_item_order", table="order_item", ftable="orders", on_delete="c"),
+    ]}
+    inv = build_constraint_inventory(snap)
+    assert inv["summary"]["cascade_deletes"] == 1
+    item = inv["delete_actions"][0]
+    assert item["severity"] == "warning"
+    assert "public.orders" in item["detail"] and "public.order_item" in item["detail"]
+
+
+def test_set_null_is_info_and_spelled_out_codes_work():
+    snap = {"constraints": [
+        _con("f", "fk_a", table="a", ftable="b", on_delete="set null"),
+        _con("f", "fk_c", table="c", ftable="d", on_delete="CASCADE"),
+        _con("f", "fk_plain", table="e", ftable="f", on_delete="a"),  # no action
+    ]}
+    inv = build_constraint_inventory(snap)
+    assert inv["summary"]["set_null_deletes"] == 1
+    assert inv["summary"]["cascade_deletes"] == 1
+    # warnings sort before infos
+    assert [i["severity"] for i in inv["delete_actions"]] == ["warning", "info"]
+
+
+def test_check_without_expr_falls_back_to_def_and_empty():
+    snap = {"constraints": [_con("c", "chk_x", check_expr=None)]}
+    inv = build_constraint_inventory(snap)
+    assert inv["check_rules"][0]["expression"] == "DEF chk_x"
+    assert build_constraint_inventory({})["summary"]["check_rules"] == 0
diff --git a/backend/tests/test_db_introspect.py b/backend/tests/test_db_introspect.py
index 0e8851cc..a7ee93f5 100644
--- a/backend/tests/test_db_introspect.py
+++ b/backend/tests/test_db_introspect.py
@@ -17,6 +17,10 @@
         ("SNOWFLAKE://u:p@acct/DB", "snowflake"),
         ("snowflake+snowflake-connector-python://u:p@acct/DB", "snowflake"),
         ("snowflake+async://u:p@acct/DB", "snowflake"),
+        ("mysql://u:p@db/app", "mysql"),
+        ("mysql+pymysql://u:p@db/app", "mysql"),
+        ("mariadb://u:p@db/app", "mysql"),
+        ("MARIADB://u:p@db/app", "mysql"),
     ],
 )
 def test_detect_dsn_dialect_valid(
@@ -28,7 +32,7 @@ def test_detect_dsn_dialect_valid(
 @pytest.mark.parametrize(
     "dsn,expected_error",
     [
-        ("mysql://u:p@db/app", "unsupported database DSN scheme: mysql"),
+        ("oracle://u:p@db/app", "unsupported database DSN scheme: oracle"),
         (
             "snowflake_invalid://u:p@acct/DB",
             "unsupported database DSN scheme: <empty>",
@@ -61,8 +65,13 @@ async def fake_snowflake(dsn: str, schema_filter: str | None) -> dict:
         calls.append(("snowflake", dsn, schema_filter))
         return {"source_dialect": "snowflake"}
 
+    async def fake_mysql(dsn: str, schema_filter: str | None) -> dict:
+        calls.append(("mysql", dsn, schema_filter))
+        return {"source_dialect": "mysql"}
+
     monkeypatch.setattr(db_introspect, "introspect_postgres", fake_postgres)
     monkeypatch.setattr(db_introspect, "introspect_snowflake", fake_snowflake)
+    monkeypatch.setattr(db_introspect, "introspect_mysql", fake_mysql)
 
     assert await db_introspect.introspect_database(
         "postgresql://u:p@db/app", "public"
@@ -70,9 +79,53 @@ async def fake_snowflake(dsn: str, schema_filter: str | None) -> dict:
     assert await db_introspect.introspect_database(
         "snowflake://u:p@acct/APP/PUBLIC", None
     ) == {"source_dialect": "snowflake"}
+    assert await db_introspect.introspect_database(
+        "mariadb://u:p@db/app", "shop"
+    ) == {"source_dialect": "mysql"}
     assert calls == [
         ("postgresql", "postgresql://u:p@db/app", "public"),
         ("snowflake", "snowflake://u:p@acct/APP/PUBLIC", None),
+        ("mysql", "mariadb://u:p@db/app", "shop"),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_probe_database_dispatches_by_dialect(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[tuple[str, str]] = []
+
+    async def fake_postgres(dsn: str) -> str:
+        calls.append(("postgresql", dsn))
+        return "postgresql 17"
+
+    async def fake_snowflake(dsn: str) -> str:
+        calls.append(("snowflake", dsn))
+        return "snowflake 9"
+
+    async def fake_mysql(dsn: str) -> str:
+        calls.append(("mysql", dsn))
+        return "mysql 8"
+
+    monkeypatch.setattr(db_introspect, "probe_postgres", fake_postgres)
+    monkeypatch.setattr(db_introspect, "probe_snowflake", fake_snowflake)
+    monkeypatch.setattr(db_introspect, "probe_mysql", fake_mysql)
+
+    assert (
+        await db_introspect.probe_database("postgres://u:p@db/app")
+        == "postgresql 17"
+    )
+    assert (
+        await db_introspect.probe_database("snowflake://u:p@acct/APP")
+        == "snowflake 9"
+    )
+    assert (
+        await db_introspect.probe_database("mysql+pymysql://u:p@db/app") == "mysql 8"
+    )
+    assert calls == [
+        ("postgresql", "postgres://u:p@db/app"),
+        ("snowflake", "snowflake://u:p@acct/APP"),
+        ("mysql", "mysql+pymysql://u:p@db/app"),
     ]
 
 
diff --git a/backend/tests/test_dbml_import.py b/backend/tests/test_dbml_import.py
new file mode 100644
index 00000000..2c034bef
--- /dev/null
+++ b/backend/tests/test_dbml_import.py
@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from app.ddl.export import snapshot_json_to_sql
+from app.spec.dbml_import import parse_dbml
+
+BASIC = """
+// a typical dbdiagram.io document
+Table users {
+  id integer [pk, not null]
+  username varchar(255) [not null, unique]
+  created_at timestamp
+}
+
+Table posts {
+  id integer [pk]
+  user_id integer [not null, ref: > users.id]
+  title varchar
+}
+
+Ref: posts.user_id > users.id
+"""
+
+
+def test_parses_tables_columns_pks():
+    snap = parse_dbml(BASIC)
+    names = {(r["schema_name"], r["relation_name"]) for r in snap["relations"]}
+    assert names == {("public", "users"), ("public", "posts")}
+    cols = {c["column_name"] for c in snap["columns"] if c["relation_oid"] == 1}
+    assert cols == {"id", "username", "created_at"}
+    # pk implies not null; plain column stays nullable
+    by_name = {c["column_name"]: c for c in snap["columns"]}
+    assert by_name["id"]["is_not_null"] is True
+    assert by_name["created_at"]["is_not_null"] is False
+    assert {p["column_name"] for p in snap["pk_columns"]} == {"id"}
+
+
+def test_parses_refs_inline_and_standalone_deduped_semantics():
+    snap = parse_dbml(BASIC)
+    # inline ref + standalone ref both point posts.user_id -> users.id
+    assert all(
+        e["child_column_name"] == "user_id" and e["parent_column_name"] == "id"
+        for e in snap["fk_edges"]
+    )
+    assert len(snap["fk_edges"]) == 2  # parser is literal; dedup is the caller's choice
+
+
+def test_reverse_arrow_and_schema_qualified_and_quoted():
+    text = '''
+Table auth.accounts {
+  account_id bigint [pk]
+}
+Table "Order Items" {
+  id bigint [pk]
+  account_id bigint
+}
+Ref: auth.accounts.account_id < "Order Items".account_id
+'''
+    snap = parse_dbml(text)
+    assert ("auth", "accounts") in {(r["schema_name"], r["relation_name"]) for r in snap["relations"]}
+    edge = snap["fk_edges"][0]
+    # '<' means the right side references the left
+    child = next(r for r in snap["relations"] if r["relation_oid"] == edge["child_relation_oid"])
+    assert child["relation_name"] == "Order Items"
+
+
+def test_ignores_project_enum_notes_and_unknown_refs():
+    text = """
+Project demo {
+  database_type: 'PostgreSQL'
+}
+Enum status {
+  active
+  banned
+}
+Table t {
+  id int [pk]
+  s status
+}
+Ref: t.ghost_col > missing_table.id
+"""
+    snap = parse_dbml(text)
+    assert len(snap["relations"]) == 1
+    assert snap["fk_edges"] == []  # ref to undefined table skipped, no crash
+
+
+def test_dbml_snapshot_feeds_existing_ddl_export():
+    ddl = snapshot_json_to_sql(parse_dbml(BASIC), target_dialect="postgresql")
+    assert 'CREATE TABLE IF NOT EXISTS "public"."users"' in ddl
+    assert 'CREATE TABLE IF NOT EXISTS "public"."posts"' in ddl
+    assert "PRIMARY KEY" in ddl
+
+
+def test_pathological_long_line_is_skipped_fast():
+    import time
+
+    hostile = 'Table t {\n  id int [pk]\n}\nRef: ' + '"a' * 100_000 + "\n"
+    start = time.monotonic()
+    snap = parse_dbml(hostile)
+    assert time.monotonic() - start < 1.0  # no catastrophic backtracking
+    assert len(snap["relations"]) == 1
+
+
+def test_pathological_table_header_dots_are_rejected_fast():
+    import time
+
+    hostile = "Table ." + "." * 4000 + "\nTable users {\n  id int [pk]\n}\n"
+    start = time.monotonic()
+    snap = parse_dbml(hostile)
+    assert time.monotonic() - start < 1.0
+    assert {(r["schema_name"], r["relation_name"]) for r in snap["relations"]} == {
+        ("public", "users")
+    }
diff --git a/backend/tests/test_fk_cycles.py b/backend/tests/test_fk_cycles.py
new file mode 100644
index 00000000..5298bff0
--- /dev/null
+++ b/backend/tests/test_fk_cycles.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from app.spec.fk_cycles import detect_fk_cycles
+
+
+def _snap(edges, names=None):
+    names = names or sorted({e[0] for e in edges} | {e[1] for e in edges})
+    oid = {n: i + 1 for i, n in enumerate(names)}
+    return {
+        "relations": [{"relation_oid": oid[n], "schema_name": "public", "relation_name": n} for n in names],
+        "fk_edges": [
+            {"child_relation_oid": oid[c], "parent_relation_oid": oid[p], "child_column_name": "x", "parent_column_name": "y"}
+            for c, p in edges
+        ],
+    }
+
+
+def test_detects_multi_table_cycle():
+    # a -> b -> c -> a
+    report = detect_fk_cycles(_snap([("a", "b"), ("b", "c"), ("c", "a")]))
+    assert report["summary"]["circular_dependencies"] == 1
+    cyc = next(i for i in report["items"] if i["category"] == "circular_dependency")
+    assert set(cyc["tables"]) == {"public.a", "public.b", "public.c"}
+    assert cyc["severity"] == "warning"
+
+
+def test_two_node_cycle():
+    report = detect_fk_cycles(_snap([("a", "b"), ("b", "a")]))
+    assert report["summary"]["circular_dependencies"] == 1
+
+
+def test_self_reference_is_info_not_a_cycle():
+    report = detect_fk_cycles(_snap([("employee", "employee")], names=["employee"]))
+    assert report["summary"]["circular_dependencies"] == 0
+    assert report["summary"]["self_references"] == 1
+    assert report["items"][0]["severity"] == "info"
+
+
+def test_acyclic_graph_has_no_findings():
+    report = detect_fk_cycles(_snap([("orders", "member"), ("order_item", "orders")]))
+    assert report["items"] == []
+
+
+def test_two_independent_cycles_and_deep_chain_no_recursion_error():
+    edges = [("a", "b"), ("b", "a"), ("c", "d"), ("d", "c")]
+    # long acyclic chain to exercise the iterative SCC
+    chain = [f"n{i}" for i in range(1500)]
+    edges += [(chain[i], chain[i + 1]) for i in range(len(chain) - 1)]
+    report = detect_fk_cycles(_snap(edges))
+    assert report["summary"]["circular_dependencies"] == 2
diff --git a/backend/tests/test_index_redundancy.py b/backend/tests/test_index_redundancy.py
new file mode 100644
index 00000000..703e0403
--- /dev/null
+++ b/backend/tests/test_index_redundancy.py
@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from app.spec.index_redundancy import detect_index_redundancy
+
+
+def _snap(index_defs, unique=None):
+    """index_defs: {index_name: 'col1, col2'} on one table 'orders'."""
+    unique = unique or set()
+    return {
+        "relations": [{"relation_oid": 1, "schema_name": "public", "relation_name": "orders"}],
+        "indexes": [
+            {
+                "relation_oid": 1,
+                "index_name": name,
+                "is_unique": name in unique,
+                "index_def": f"CREATE INDEX {name} ON public.orders USING btree ({cols})",
+            }
+            for name, cols in index_defs.items()
+        ],
+    }
+
+
+def _cats(report):
+    return {(i["category"], i["index"]) for i in report["items"]}
+
+
+def test_detects_exact_duplicate():
+    report = detect_index_redundancy(_snap({"ix_a": "member_id", "ix_b": "member_id"}))
+    assert report["summary"]["duplicates"] == 1
+    dup = report["items"][0]
+    assert dup["severity"] == "warning" and dup["columns"] == ["member_id"]
+
+
+def test_duplicate_keeps_the_unique_one():
+    report = detect_index_redundancy(
+        _snap({"uq_a": "email", "ix_b": "email"}, unique={"uq_a"})
+    )
+    dup = report["items"][0]
+    assert dup["index"] == "ix_b" and dup["kept"] == "uq_a"
+
+
+def test_detects_prefix_redundancy_but_not_unique_prefix():
+    # ix_short(member_id) is a prefix of ix_long(member_id, created_at)
+    report = detect_index_redundancy(
+        _snap({"ix_short": "member_id", "ix_long": "member_id, created_at"})
+    )
+    assert ("prefix_redundant_index", "ix_short") in _cats(report)
+
+    # but a UNIQUE index is a constraint — never suggested for dropping
+    report2 = detect_index_redundancy(
+        _snap({"uq_short": "member_id", "ix_long": "member_id, created_at"}, unique={"uq_short"})
+    )
+    assert report2["items"] == []
+
+
+def test_different_columns_and_unparseable_defs_are_skipped():
+    report = detect_index_redundancy(_snap({"ix_a": "member_id", "ix_b": "created_at"}))
+    assert report["items"] == []
+    # expression + partial indexes are skipped, not guessed
+    snap = _snap({"ix_a": "member_id"})
+    snap["indexes"].append({"relation_oid": 1, "index_name": "ix_expr",
+                            "index_def": "CREATE INDEX ix_expr ON public.orders (lower(email))"})
+    snap["indexes"].append({"relation_oid": 1, "index_name": "ix_part",
+                            "index_def": "CREATE INDEX ix_part ON public.orders (member_id) WHERE deleted_at IS NULL"})
+    assert detect_index_redundancy(snap)["items"] == []
+    assert detect_index_redundancy({})["summary"]["total"] == 0
diff --git a/backend/tests/test_mysql_introspect.py b/backend/tests/test_mysql_introspect.py
new file mode 100644
index 00000000..24424b91
--- /dev/null
+++ b/backend/tests/test_mysql_introspect.py
@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from app.db_introspect import detect_dsn_dialect
+from app.ddl.export import snapshot_json_to_sql
+from app.mysql_introspect.introspect import _parse_mysql_dsn, rows_to_snapshot
+
+TABLES = [
+    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "member", "TABLE_TYPE": "BASE TABLE", "TABLE_COMMENT": "회원"},
+    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "TABLE_TYPE": "BASE TABLE", "TABLE_COMMENT": ""},
+    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "v_sales", "TABLE_TYPE": "VIEW", "TABLE_COMMENT": ""},
+]
+COLUMNS = [
+    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "member", "COLUMN_NAME": "member_id", "ORDINAL_POSITION": 1,
+     "COLUMN_TYPE": "bigint", "DATA_TYPE": "bigint", "IS_NULLABLE": "NO", "COLUMN_DEFAULT": None, "COLUMN_COMMENT": ""},
+    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "member", "COLUMN_NAME": "email", "ORDINAL_POSITION": 2,
+     "COLUMN_TYPE": "varchar(255)", "DATA_TYPE": "varchar", "IS_NULLABLE": "YES", "COLUMN_DEFAULT": None, "COLUMN_COMMENT": ""},
+    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "COLUMN_NAME": "order_id", "ORDINAL_POSITION": 1,
+     "COLUMN_TYPE": "bigint", "DATA_TYPE": "bigint", "IS_NULLABLE": "NO", "COLUMN_DEFAULT": None, "COLUMN_COMMENT": ""},
+    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "COLUMN_NAME": "member_id", "ORDINAL_POSITION": 2,
+     "COLUMN_TYPE": "bigint", "DATA_TYPE": "bigint", "IS_NULLABLE": "NO", "COLUMN_DEFAULT": None, "COLUMN_COMMENT": ""},
+]
+KEY_USAGE = [
+    {"CONSTRAINT_NAME": "PRIMARY", "TABLE_SCHEMA": "shop", "TABLE_NAME": "member", "COLUMN_NAME": "member_id",
+     "ORDINAL_POSITION": 1, "REFERENCED_TABLE_SCHEMA": None, "REFERENCED_TABLE_NAME": None, "REFERENCED_COLUMN_NAME": None},
+    {"CONSTRAINT_NAME": "PRIMARY", "TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "COLUMN_NAME": "order_id",
+     "ORDINAL_POSITION": 1, "REFERENCED_TABLE_SCHEMA": None, "REFERENCED_TABLE_NAME": None, "REFERENCED_COLUMN_NAME": None},
+    {"CONSTRAINT_NAME": "fk_orders_member", "TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "COLUMN_NAME": "member_id",
+     "ORDINAL_POSITION": 1, "REFERENCED_TABLE_SCHEMA": "shop", "REFERENCED_TABLE_NAME": "member", "REFERENCED_COLUMN_NAME": "member_id"},
+]
+INDEXES = [
+    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "orders", "INDEX_NAME": "ix_orders_member",
+     "NON_UNIQUE": 1, "SEQ_IN_INDEX": 1, "COLUMN_NAME": "member_id"},
+    {"TABLE_SCHEMA": "shop", "TABLE_NAME": "member", "INDEX_NAME": "PRIMARY",
+     "NON_UNIQUE": 0, "SEQ_IN_INDEX": 1, "COLUMN_NAME": "member_id"},
+]
+
+
+def _snap():
+    return rows_to_snapshot("8.4.0", None, TABLES, COLUMNS, KEY_USAGE, INDEXES)
+
+
+def test_maps_tables_views_columns():
+    snap = _snap()
+    kinds = {r["relation_name"]: r["relation_kind"] for r in snap["relations"]}
+    assert kinds == {"member": "r", "orders": "r", "v_sales": "v"}
+    email = next(c for c in snap["columns"] if c["column_name"] == "email")
+    assert email["data_type"] == "varchar(255)" and email["is_not_null"] is False
+    assert snap["server_version"] == "8.4.0" and snap["source_dialect"] == "mysql"
+
+
+def test_maps_pks_and_fks_by_name():
+    snap = _snap()
+    assert {p["column_name"] for p in snap["pk_columns"]} == {"member_id", "order_id"}
+    edge = snap["fk_edges"][0]
+    rel = {r["relation_oid"]: r["relation_name"] for r in snap["relations"]}
+    assert rel[edge["child_relation_oid"]] == "orders"
+    assert rel[edge["parent_relation_oid"]] == "member"
+    # constraints derived so DDL export renders PK/FK
+    assert any(c["constraint_type"] == "p" for c in snap["constraints"])
+    assert any(c["constraint_type"] == "f" for c in snap["constraints"])
+
+
+def test_index_rows_grouped_into_defs():
+    snap = _snap()
+    ix = next(i for i in snap["indexes"] if i["index_name"] == "ix_orders_member")
+    assert "ON shop.orders (member_id)" in ix["index_def"]
+    assert ix["is_unique"] is False
+    primary = next(i for i in snap["indexes"] if i["index_name"] == "PRIMARY")
+    assert primary["is_primary"] is True
+
+
+def test_snapshot_feeds_ddl_export_and_dialect_detection():
+    ddl = snapshot_json_to_sql(_snap(), target_dialect="postgresql")
+    assert 'CREATE TABLE IF NOT EXISTS "shop"."member"' in ddl
+    assert "PRIMARY KEY" in ddl
+    assert detect_dsn_dialect("mysql://u:p@db.example.com/shop") == "mysql"
+    assert detect_dsn_dialect("mariadb://u:p@db.example.com/shop") == "mysql"
+
+
+@pytest.mark.asyncio
+async def test_dsn_parse_pins_validated_ip_and_rejects_bad():
+    with patch(
+        "app.mysql_introspect.introspect._validated_ip_hosts",
+        new_callable=AsyncMock,
+        return_value=["93.184.216.34"],
+    ) as guard:
+        cfg = await _parse_mysql_dsn("mysql://user:s3cret@db.example.com:3307/shop")
+    guard.assert_awaited_once_with("db.example.com", is_hostaddr=False, port=3307)
+    assert cfg.host == "93.184.216.34"  # pinned IP, not the hostname
+    assert cfg.server_hostname == "db.example.com"
+    assert cfg.port == 3307 and cfg.user == "user" and cfg.database == "shop"
+
+    with pytest.raises(ValueError):
+        await _parse_mysql_dsn("mysql:///nohost")
+    with pytest.raises(ValueError):
+        await _parse_mysql_dsn("postgres://u@h/db")
diff --git a/backend/tests/test_orm_codegen.py b/backend/tests/test_orm_codegen.py
new file mode 100644
index 00000000..51a50fad
--- /dev/null
+++ b/backend/tests/test_orm_codegen.py
@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import ast
+
+from app.spec.orm_codegen import generate_prisma_schema, generate_sqlalchemy_models
+
+SNAP = {
+    "relations": [
+        {"relation_oid": 1, "relation_kind": "r", "schema_name": "public", "relation_name": "member", "relation_comment": "회원"},
+        {"relation_oid": 2, "relation_kind": "r", "schema_name": "public", "relation_name": "orders", "relation_comment": None},
+        {"relation_oid": 3, "relation_kind": "v", "schema_name": "public", "relation_name": "v_report"},
+    ],
+    "columns": [
+        {"relation_oid": 1, "column_name": "member_id", "column_position": 1, "data_type": "bigint", "is_not_null": True},
+        {"relation_oid": 1, "column_name": "email", "column_position": 2, "data_type": "varchar(255)", "is_not_null": True},
+        {"relation_oid": 1, "column_name": "joined_at", "column_position": 3, "data_type": "timestamp with time zone", "is_not_null": False},
+        {"relation_oid": 2, "column_name": "order_id", "column_position": 1, "data_type": "bigint", "is_not_null": True},
+        {"relation_oid": 2, "column_name": "member_id", "column_position": 2, "data_type": "bigint", "is_not_null": True},
+        {"relation_oid": 2, "column_name": "total", "column_position": 3, "data_type": "numeric(10,2)", "is_not_null": False},
+    ],
+    "pk_columns": [
+        {"relation_oid": 1, "column_name": "member_id"},
+        {"relation_oid": 2, "column_name": "order_id"},
+    ],
+    "fk_edges": [
+        {"fk_constraint_oid": 10, "fk_constraint_name": "fk_orders_member",
+         "child_relation_oid": 2, "parent_relation_oid": 1,
+         "child_column_name": "member_id", "parent_column_name": "member_id", "column_ordinal": 1},
+    ],
+}
+
+
+def test_sqlalchemy_output_is_valid_python_with_expected_shapes():
+    code = generate_sqlalchemy_models(SNAP)
+    ast.parse(code)  # must always be syntactically valid Python
+    assert "class Member(Base):" in code
+    assert "class Orders(Base):" in code
+    assert "class VReport" not in code  # views excluded
+    assert "member_id: Mapped[int] = mapped_column(primary_key=True)" in code
+    assert "joined_at: Mapped[dt.datetime | None] = mapped_column()" in code
+    assert "ForeignKey('member.member_id')" in code
+    assert "total: Mapped[Decimal | None]" in code
+
+
+def test_sqlalchemy_unknown_type_falls_back_with_comment():
+    snap = {
+        "relations": [{"relation_oid": 1, "relation_kind": "r", "schema_name": "public", "relation_name": "t"}],
+        "columns": [{"relation_oid": 1, "column_name": "shape", "column_position": 1, "data_type": "polygon", "is_not_null": False}],
+        "pk_columns": [], "fk_edges": [],
+    }
+    code = generate_sqlalchemy_models(snap)
+    ast.parse(code)
+    assert "shape: Mapped[str | None] = mapped_column()  # type: polygon" in code
+
+
+def test_prisma_models_relations_and_map():
+    schema = generate_prisma_schema(SNAP)
+    assert "model Member {" in schema and "model Orders {" in schema
+    assert "member_id BigInt @id" in schema
+    assert "member Member @relation(fields: [member_id], references: [member_id])" in schema
+    assert "orderss Orders[]" in schema or "orders Orders[]" in schema  # reverse side exists
+    assert '@@map("orders")' in schema
+    assert "total Decimal?" in schema
+
+
+def test_composite_pk_and_empty_snapshot():
+    snap = {
+        "relations": [{"relation_oid": 1, "relation_kind": "r", "schema_name": "public", "relation_name": "m2m"}],
+        "columns": [
+            {"relation_oid": 1, "column_name": "a_id", "column_position": 1, "data_type": "bigint", "is_not_null": True},
+            {"relation_oid": 1, "column_name": "b_id", "column_position": 2, "data_type": "bigint", "is_not_null": True},
+        ],
+        "pk_columns": [
+            {"relation_oid": 1, "column_name": "a_id"},
+            {"relation_oid": 1, "column_name": "b_id"},
+        ],
+        "fk_edges": [],
+    }
+    schema = generate_prisma_schema(snap)
+    assert "@@id([a_id, b_id])" in schema
+    assert "@id\n" not in schema.replace("@@id", "")  # no single-column @id emitted
+    ast.parse(generate_sqlalchemy_models({}))  # empty snapshot still valid
+
+
+def test_typeorm_entities_decorators_and_relations():
+    from app.spec.orm_codegen import generate_typeorm_entities
+
+    code = generate_typeorm_entities(SNAP)
+    assert '@Entity("member")' in code
+    assert "export class Member {" in code
+    assert "@PrimaryColumn()" in code
+    assert "member_id!: number;" in code
+    assert "joined_at?: Date | null;" in code
+    assert "@ManyToOne(() => Member)" in code
+    assert '@JoinColumn({ name: "member_id" })' in code
+    assert "@OneToMany(() => Orders" in code
+    # balanced braces => structurally sound TS
+    assert code.count("{") == code.count("}")
+
+
+def test_non_snake_db_names_are_mapped_to_safe_identifiers():
+    from app.spec.orm_codegen import generate_typeorm_entities
+
+    snap = {
+        "relations": [
+            {
+                "relation_oid": 1,
+                "relation_kind": "r",
+                "schema_name": "public",
+                "relation_name": "Order Items",
+                "relation_comment": 'quote " is fine',
+            }
+        ],
+        "columns": [
+            {"relation_oid": 1, "column_name": "Order ID", "column_position": 1, "data_type": "bigint", "is_not_null": True},
+            {"relation_oid": 1, "column_name": "class", "column_position": 2, "data_type": "text", "is_not_null": False},
+            {"relation_oid": 1, "column_name": "2FA Enabled", "column_position": 3, "data_type": "boolean", "is_not_null": True},
+        ],
+        "pk_columns": [{"relation_oid": 1, "column_name": "Order ID"}],
+        "fk_edges": [],
+    }
+
+    py_code = generate_sqlalchemy_models(snap)
+    ast.parse(py_code)
+    assert "class OrderItems(Base):" in py_code
+    assert "order_id: Mapped[int] = mapped_column('Order ID', primary_key=True)" in py_code
+    assert "class_: Mapped[str | None] = mapped_column('class')" in py_code
+    assert "column_2_fa_enabled: Mapped[bool] = mapped_column('2FA Enabled')" in py_code
+
+    prisma = generate_prisma_schema(snap)
+    assert "model OrderItems {" in prisma
+    assert 'order_id BigInt @id @map("Order ID")' in prisma
+    assert 'class_ String? @map("class")' in prisma
+    assert 'column_2_fa_enabled Boolean @map("2FA Enabled")' in prisma
+
+    ts_code = generate_typeorm_entities(snap)
+    assert '@Entity("Order Items")' in ts_code
+    assert '@PrimaryColumn({name: "Order ID"})' in ts_code
+    assert 'order_id!: number;' in ts_code
+    assert '@Column({name: "class", nullable: true})' in ts_code
+    assert 'class_?: string | null;' in ts_code
diff --git a/backend/tests/test_schema_stats.py b/backend/tests/test_schema_stats.py
new file mode 100644
index 00000000..37023eb2
--- /dev/null
+++ b/backend/tests/test_schema_stats.py
@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from app.spec.schema_stats import compute_schema_stats
+
+
+def _snap():
+    return {
+        "relations": [
+            {"relation_oid": 1, "relation_kind": "r", "schema_name": "public", "relation_name": "member"},
+            {"relation_oid": 2, "relation_kind": "r", "schema_name": "public", "relation_name": "orders"},
+            {"relation_oid": 3, "relation_kind": "v", "schema_name": "public", "relation_name": "v_report"},
+        ],
+        "columns": [
+            {"relation_oid": 1, "column_name": "member_id", "data_type": "bigint", "is_not_null": True},
+            {"relation_oid": 1, "column_name": "email", "data_type": "text", "is_not_null": True},
+            {"relation_oid": 1, "column_name": "nickname", "data_type": "text", "is_not_null": False},
+            {"relation_oid": 2, "column_name": "order_id", "data_type": "bigint", "is_not_null": True},
+        ],
+        "pk_columns": [{"relation_oid": 1, "column_name": "member_id"}],
+        "fk_edges": [{"child_relation_oid": 2, "parent_relation_oid": 1, "child_column_name": "member_id", "parent_column_name": "member_id"}],
+        "indexes": [{"relation_oid": 1, "index_name": "pk_member"}],
+    }
+
+
+def test_counts_relations_by_kind():
+    s = compute_schema_stats(_snap())
+    assert s["relations"]["table"] == 2
+    assert s["relations"]["view"] == 1
+    assert s["relations"]["total"] == 3
+
+
+def test_column_stats_and_widest_table():
+    s = compute_schema_stats(_snap())
+    assert s["columns"]["total"] == 4
+    assert s["columns"]["nullable"] == 1
+    assert s["columns"]["not_null"] == 3
+    assert s["columns"]["avg_per_table"] == 2.0  # 4 columns / 2 tables
+    assert s["columns"]["max_per_table"] == 3    # member has 3
+    assert s["widest_tables"][0] == {"table": "public.member", "columns": 3}
+
+
+def test_constraint_and_pk_coverage():
+    s = compute_schema_stats(_snap())
+    assert s["constraints"]["primary_keys"] == 1
+    assert s["constraints"]["foreign_keys"] == 1
+    assert s["constraints"]["indexes"] == 1
+    assert s["tables_without_primary_key"] == 1  # orders has no PK
+
+
+def test_data_type_distribution_and_empty():
+    s = compute_schema_stats(_snap())
+    assert s["data_types"]["bigint"] == 2
+    assert s["data_types"]["text"] == 2
+    empty = compute_schema_stats({})
+    assert empty["relations"]["total"] == 0
+    assert empty["columns"]["avg_per_table"] == 0.0
diff --git a/backend/tests/test_sensitive_columns.py b/backend/tests/test_sensitive_columns.py
new file mode 100644
index 00000000..d30af25d
--- /dev/null
+++ b/backend/tests/test_sensitive_columns.py
@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from app.spec.sensitive_columns import detect_sensitive_columns
+
+
+def _snap(columns):
+    return {
+        "relations": [{"relation_oid": 1, "schema_name": "public", "relation_name": "member"}],
+        "columns": [{"relation_oid": 1, "column_name": c} for c in columns],
+    }
+
+
+def _by_col(report):
+    return {i["column"]: (i["category"], i["severity"]) for i in report["items"]}
+
+
+def test_classifies_common_sensitive_columns():
+    report = detect_sensitive_columns(
+        _snap(["password_hash", "ssn", "credit_card_no", "email", "home_address", "date_of_birth", "first_name"])
+    )
+    byc = _by_col(report)
+    assert byc["password_hash"] == ("credential", "high")
+    assert byc["ssn"] == ("national_id", "high")
+    assert byc["credit_card_no"] == ("payment", "high")
+    assert byc["email"] == ("contact", "medium")
+    assert byc["home_address"] == ("location", "medium")
+    assert byc["date_of_birth"] == ("personal", "medium")
+    assert byc["first_name"] == ("name", "low")
+
+
+def test_ignores_plain_columns_and_sorts_high_first():
+    report = detect_sensitive_columns(_snap(["id", "created_at", "quantity", "email", "api_key"]))
+    cols = _by_col(report)
+    assert "id" not in cols and "quantity" not in cols
+    severities = [i["severity"] for i in report["items"]]
+    assert severities == sorted(severities, key={"high": 0, "medium": 1, "low": 2}.get)
+    assert report["summary"]["high"] == 1  # api_key
+
+
+def test_maps_findings_to_compliance_frameworks():
+    report = detect_sensitive_columns(_snap(["card_number", "email", "medical_history"]))
+    fw = {i["column"]: i["framework"] for i in report["items"]}
+    assert "PCI DSS" in fw["card_number"]
+    assert "GDPR" in fw["email"]
+    assert "sensitive" in fw["medical_history"].lower()  # special category
+    # per-framework breakdown lets a user answer "what is in PCI DSS scope?"
+    assert report["summary"]["by_framework"]["PCI DSS (cardholder data environment)"] == 1
+
+
+def test_first_most_sensitive_match_wins():
+    # a column matching multiple rules is classified by the most sensitive one
+    report = detect_sensitive_columns(_snap(["account_password"]))
+    assert _by_col(report)["account_password"][0] == "credential"
+
+
+def test_empty_snapshot():
+    assert detect_sensitive_columns({})["items"] == []
+    assert detect_sensitive_columns(None)["summary"]["total"] == 0
diff --git a/docs/ci-drift-check.md b/docs/ci-drift-check.md
new file mode 100644
index 00000000..07edf673
--- /dev/null
+++ b/docs/ci-drift-check.md
@@ -0,0 +1,57 @@
+# CI schema-drift gate
+
+Gate deploys on "the database schema matches the approved baseline". This is
+the highest-leverage automation the snapshot/diff APIs enable: schema changes
+stop sneaking into production unreviewed.
+
+## How it works
+
+1. **Baseline**: after a reviewed migration lands, take a snapshot and record
+   its UUID as the approved baseline (e.g. in your pipeline variables).
+2. **Check**: on every deploy, take a fresh snapshot of the target database and
+   diff it against the baseline:
+   `GET /api/snapshots/{target}/diff?against={baseline}`.
+3. **Gate**: `diff.summary.has_changes == false` → deploy proceeds. Otherwise
+   the pipeline fails and prints both the structured summary and the exact
+   migration SQL that would reconcile the drift
+   (`GET /api/snapshots/{target}/migration.sql?against={baseline}`).
+
+The diff is name-keyed (never `relation_oid`), so re-introspecting the same
+database yields a stable, empty diff — no false drift between runs.
+
+## Ready-made script
+
+[`scripts/ci/check_schema_drift.sh`](../scripts/ci/check_schema_drift.sh):
+
+```bash
+PG_ERD_BASE_URL=https://erd.example.com \
+PG_ERD_COOKIE="session=..." \
+./scripts/ci/check_schema_drift.sh "$BASELINE_SNAPSHOT_UUID" "$TARGET_SNAPSHOT_UUID"
+```
+
+Exit codes: `0` no drift · `1` drift detected (summary + migration SQL on
+stderr) · `2` snapshot missing/unauthorized.
+
+### GitHub Actions example
+
+```yaml
+- name: Schema drift gate
+  env:
+    PG_ERD_BASE_URL: ${{ vars.PG_ERD_BASE_URL }}
+    PG_ERD_COOKIE: ${{ secrets.PG_ERD_SESSION_COOKIE }}
+  run: |
+    ./scripts/ci/check_schema_drift.sh \
+      "${{ vars.SCHEMA_BASELINE_UUID }}" \
+      "${{ steps.snapshot.outputs.snapshot_uuid }}"
+```
+
+## Reviewing drift before promoting a baseline
+
+When drift is intentional (a planned migration), review it with:
+
+- `GET /diff?against=` — structured change list
+- `GET /migration-safety?against=` — each change classified
+  safe / warning / destructive
+- `GET /migration.sql?against=` — the reconciling SQL
+
+then promote the new snapshot UUID as the baseline.
diff --git a/docs/clearfolio-integration.md b/docs/clearfolio-integration.md
new file mode 100644
index 00000000..ffb77c11
--- /dev/null
+++ b/docs/clearfolio-integration.md
@@ -0,0 +1,51 @@
+# Clearfolio reference-document viewer — integration
+
+[Clearfolio](https://github.com/ContextualWisdomLab/clearfolio) is a document-viewer
+platform (Java backend + JS preview). pg-erd-cloud links it so a project can attach
+external reference documents (requirements, design specs, contracts — PDF/DOCX/PPT)
+and view them next to the ERD.
+
+## Architecture: pg-erd-cloud is the *buyer gateway*
+
+pg-erd-cloud authenticates its own user (OIDC / API key), maps the principal to
+Clearfolio tenant claims, **HMAC-signs** them, and proxies to Clearfolio's
+connector API. Clearfolio verifies the signature, enforces permissions, and
+isolates tenants.
+
+### Signing contract (must match Clearfolio's verifier)
+
+```
+payload   = "\n".join([tenantId, subjectId, canonicalPermissions, issuedAt])
+signature = base64url( HMAC_SHA256(secret, payload) )        # no padding
+```
+
+Sent as `X-Clearfolio-{Tenant-Id, Subject-Id, Permissions, Claims-Issued-At,
+Claims-Signature}`. Implemented in `app/integrations/clearfolio.py`
+(`sign_tenant_claims`, `build_tenant_headers`) and covered by a golden-vector test.
+
+### Connector calls (proxied, SSRF-validated gateway host)
+
+| Step | Clearfolio endpoint |
+| --- | --- |
+| Submit document | `POST /api/v1/convert/jobs` (multipart) |
+| Poll status | `GET /api/v1/convert/jobs/{jobId}` |
+| Viewer bootstrap | `GET /api/v1/viewer/{docId}` (signed previewResourcePath) |
+| Artifact link | `POST /api/v1/viewer/{docId}/artifact-links` |
+
+## Configuration
+
+```bash
+CLEARFOLIO_GATEWAY_URL=https://clearfolio.example.com
+CLEARFOLIO_TENANT_CLAIMS_HMAC_SECRET=<shared gateway secret>
+CLEARFOLIO_TENANT_ID=pg-erd-cloud            # default
+CLEARFOLIO_PERMISSIONS=job:create,job:read,job:retry,viewer:read,artifact-link:create,analytics:read
+```
+
+Unset → the connector raises `ClearfolioNotConfigured` (feature is opt-in; no live
+Clearfolio instance required for the rest of pg-erd-cloud).
+
+## Status / next
+
+- ✅ Connector core (signing + gateway client + config) — this PR, contract-mocked tests.
+- ⬜ Project-scoped endpoints + `reference_document` persistence (IDOR per project) — follow-up (needs the alembic chain).
+- ⬜ Frontend: attach/upload panel + embedded Clearfolio viewer bootstrap.
diff --git a/docs/llm-orchestrator-integration.md b/docs/llm-orchestrator-integration.md
new file mode 100644
index 00000000..8e8ddb14
--- /dev/null
+++ b/docs/llm-orchestrator-integration.md
@@ -0,0 +1,53 @@
+# LLM via Contextual Orchestrator
+
+pg-erd-cloud's LLM features (`reversing-spec.md?mode=llm-draft`,
+`index-design.md?mode=llm-draft`) call an **OpenAI-compatible** chat-completions
+endpoint (`app/spec/llm.py`: `POST {base}/chat/completions`, `Authorization:
+Bearer`, `{model, messages}`). [contextual-orchestrator](https://github.com/ContextualWisdomLab/contextual-orchestrator)
+exposes exactly that interface (`/v1/chat/completions`) while routing,
+delegating, verifying, and synthesizing across a pool of model agents.
+
+So the integration is **configuration only — no code change**.
+
+## Point pg-erd-cloud at the orchestrator
+
+```bash
+LLM_API_BASE_URL=https://<orchestrator-host>/v1
+LLM_API_KEY=<orchestrator inference bearer token>   # NOT the OpenAI key
+LLM_MODEL=contextual-orchestrator
+```
+
+pg-erd-cloud calls `${LLM_API_BASE_URL}/chat/completions` → the orchestrator's
+`/v1/chat/completions`. The orchestrator authenticates the Bearer token,
+orchestrates, and returns an OpenAI-shaped response.
+
+## Secret isolation (why this is better than calling OpenAI directly)
+
+The real **OpenAI API key lives only in the orchestrator's agent pool**, backed
+by the org Secret — pg-erd-cloud never holds it. pg-erd holds only the
+orchestrator's inference token.
+
+Orchestrator agent config (on the orchestrator side, env-backed key):
+
+```json
+{
+  "agents": [
+    {
+      "id": "coding_agent",
+      "endpoint": "https://api.openai.com/v1",
+      "api_key_env": "OPENAI_API_KEY",
+      "model": "gpt-4o"
+    }
+  ]
+}
+```
+
+Run: `python -m contextual_orchestrator --serve --agents agents.json \
+--inference-token "$CONTEXTUAL_ORCHESTRATOR_TOKEN" --port 8000` with
+`OPENAI_API_KEY` supplied from the org Secret at deploy time.
+
+## Fallback
+
+Unset `LLM_API_*` → the LLM-draft endpoints raise `LlmConfigurationError`
+(503); the non-LLM `mode=markdown|llm-prompt` paths are unaffected. The
+integration is fully opt-in.
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index edaeeea0..01e62762 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -54,12 +54,15 @@ import {
   downloadText,
   exportDDL,
   exportDiagramSvg,
+  exportDictionaryCsv,
+  exportDictionaryMarkdown,
   exportPlantUml,
 } from "./erd/export";
 import { exportMermaid } from "./erd/mermaid";
 import { inferRelationships } from "./erd/autoInfer";
 import { exportDbml } from "./erd/dbml";
 import { GRID_COLUMNS, GRID_X_GAP, GRID_Y_GAP } from "./erd/layoutConstants";
+import { findSearchMatchedNodeIds } from "./erd/search";
 import type { Connection, Project, Snapshot, SnapshotDetail } from "./types";
 
 const TERMINAL_SNAPSHOT_STATUSES = new Set([
@@ -192,25 +195,7 @@ export default function App() {
   const nodeTypes = useMemo<NodeTypes>(() => ({ tableNode: TableNode }), []);
   const normalizedNodeSearch = nodeSearch.trim().toLocaleLowerCase();
   const searchMatchedNodeIds = useMemo(() => {
-    if (!normalizedNodeSearch) return new Set<string>();
-    const matches = new Set<string>();
-    for (const node of nodes) {
-      const haystack = [
-        node.data.title,
-        node.data.comment ?? "",
-        ...node.data.columns.flatMap((column) => [
-          column.column_name,
-          column.data_type,
-          column.column_comment ?? "",
-        ]),
-      ]
-        .join(" ")
-        .toLocaleLowerCase();
-      if (haystack.includes(normalizedNodeSearch)) {
-        matches.add(node.id);
-      }
-    }
-    return matches;
+    return findSearchMatchedNodeIds(nodes, normalizedNodeSearch);
   }, [nodes, normalizedNodeSearch]);
   const visibleNodes = useMemo(() => {
     if (!normalizedNodeSearch) return nodes;
@@ -637,6 +622,22 @@ export default function App() {
     downloadText("pg-erd-diagram.mermaid", exportMermaid(nodes, edges), "text/plain");
   }
 
+  function onExportDictionaryCsv() {
+    downloadText(
+      "data_dictionary.csv",
+      exportDictionaryCsv(nodes, edges),
+      "text/csv;charset=utf-8",
+    );
+  }
+
+  function onExportDictionaryMarkdown() {
+    downloadText(
+      "data_dictionary.md",
+      exportDictionaryMarkdown(nodes, edges),
+      "text/markdown;charset=utf-8",
+    );
+  }
+
   function onDownloadDbml() {
     downloadText("pg-erd-diagram.dbml", exportDbml(nodes, edges), "text/plain");
   }
@@ -1597,6 +1598,7 @@ export default function App() {
             isOpen={isExportModalOpen}
             isCopied={isCopied}
             hasDdlExport={nodes.length > 0}
+            hasDictionaryExport={nodes.length > 0}
             hasDiagramExport={nodes.length > 0}
             shareLinkUrl={shareLinkUrl}
             isCreatingShareLink={isCreatingShareLink}
@@ -1608,6 +1610,8 @@ export default function App() {
             onDownloadSvg={onDownloadSvg}
             onDownloadUml={onDownloadUml}
             onDownloadMermaid={onDownloadMermaid}
+            onExportDictionaryCsv={onExportDictionaryCsv}
+            onExportDictionaryMarkdown={onExportDictionaryMarkdown}
             onCreateShareLink={onCreateShareLink}
             onCopyShareLink={onCopyShareLink}
           />
diff --git a/frontend/src/components/modals/ExportModal.test.tsx b/frontend/src/components/modals/ExportModal.test.tsx
index 36fbd1f7..5e101d71 100644
--- a/frontend/src/components/modals/ExportModal.test.tsx
+++ b/frontend/src/components/modals/ExportModal.test.tsx
@@ -8,6 +8,7 @@ const baseProps = {
   isOpen: true,
   isCopied: false,
   hasDdlExport: true,
+  hasDictionaryExport: true,
   hasDiagramExport: true,
   shareLinkUrl: '',
   isCreatingShareLink: false,
@@ -19,6 +20,8 @@ const baseProps = {
   onDownloadSvg: vi.fn(),
   onDownloadUml: vi.fn(),
   onDownloadMermaid: vi.fn(),
+  onExportDictionaryCsv: vi.fn(),
+  onExportDictionaryMarkdown: vi.fn(),
   onCreateShareLink: vi.fn(),
   onCopyShareLink: vi.fn(),
 };
@@ -46,6 +49,8 @@ describe('ExportModal', () => {
     expect(screen.getByText('SVG 이미지')).toBeInTheDocument();
     expect(screen.getByText('PlantUML')).toBeInTheDocument();
     expect(screen.getByText('Mermaid')).toBeInTheDocument();
+    expect(screen.getByText('Data Dictionary CSV')).toBeInTheDocument();
+    expect(screen.getByText('Data Dictionary MD')).toBeInTheDocument();
   });
 
   it('copies an already generated share link', () => {
@@ -71,6 +76,8 @@ describe('ExportModal', () => {
     const onDownloadSvg = vi.fn();
     const onDownloadUml = vi.fn();
     const onDownloadMermaid = vi.fn();
+    const onExportDictionaryCsv = vi.fn();
+    const onExportDictionaryMarkdown = vi.fn();
 
     render(
       <ExportModal
@@ -79,6 +86,8 @@ describe('ExportModal', () => {
         onDownloadSvg={onDownloadSvg}
         onDownloadUml={onDownloadUml}
         onDownloadMermaid={onDownloadMermaid}
+        onExportDictionaryCsv={onExportDictionaryCsv}
+        onExportDictionaryMarkdown={onExportDictionaryMarkdown}
       />,
     );
 
@@ -86,11 +95,15 @@ describe('ExportModal', () => {
     fireEvent.click(screen.getByRole('button', { name: 'SVG 이미지 내보내기' }));
     fireEvent.click(screen.getByRole('button', { name: 'PlantUML 내보내기' }));
     fireEvent.click(screen.getByRole('button', { name: 'Mermaid 내보내기' }));
+    fireEvent.click(screen.getByRole('button', { name: '데이터 사전 CSV 내보내기' }));
+    fireEvent.click(screen.getByRole('button', { name: '데이터 사전 Markdown 내보내기' }));
 
     expect(onCopyExportDdl).toHaveBeenCalledOnce();
     expect(onDownloadSvg).toHaveBeenCalledOnce();
     expect(onDownloadUml).toHaveBeenCalledOnce();
     expect(onDownloadMermaid).toHaveBeenCalledOnce();
+    expect(onExportDictionaryCsv).toHaveBeenCalledOnce();
+    expect(onExportDictionaryMarkdown).toHaveBeenCalledOnce();
   });
 
   it('shows share link copy or creation errors', () => {
@@ -109,15 +122,18 @@ describe('ExportModal', () => {
       <ExportModal
         {...baseProps}
         hasDdlExport={false}
+        hasDictionaryExport={false}
         hasDiagramExport={false}
       />,
     );
 
-    expect(screen.getAllByText('먼저 테이블을 추가하세요')).toHaveLength(4);
+    expect(screen.getAllByText('먼저 테이블을 추가하세요')).toHaveLength(6);
     expect(screen.getByRole('button', { name: 'SQL DDL 복사' })).toBeDisabled();
     expect(screen.getByRole('button', { name: 'SVG 이미지 내보내기' })).toBeDisabled();
     expect(screen.getByRole('button', { name: 'PlantUML 내보내기' })).toBeDisabled();
     expect(screen.getByRole('button', { name: 'Mermaid 내보내기' })).toBeDisabled();
+    expect(screen.getByRole('button', { name: '데이터 사전 CSV 내보내기' })).toBeDisabled();
+    expect(screen.getByRole('button', { name: '데이터 사전 Markdown 내보내기' })).toBeDisabled();
   });
 
   it('exposes access-control guidance for disabled button', () => {
diff --git a/frontend/src/components/modals/ExportModal.tsx b/frontend/src/components/modals/ExportModal.tsx
index 1d4370a0..9feebd03 100644
--- a/frontend/src/components/modals/ExportModal.tsx
+++ b/frontend/src/components/modals/ExportModal.tsx
@@ -5,6 +5,7 @@ interface ExportModalProps {
   isOpen: boolean;
   isCopied: boolean;
   hasDdlExport: boolean;
+  hasDictionaryExport: boolean;
   hasDiagramExport: boolean;
   shareLinkUrl: string;
   isCreatingShareLink: boolean;
@@ -16,6 +17,8 @@ interface ExportModalProps {
   onDownloadSvg: () => void;
   onDownloadUml: () => void;
   onDownloadMermaid: () => void;
+  onExportDictionaryCsv: () => void;
+  onExportDictionaryMarkdown: () => void;
   onCreateShareLink: () => void;
   onCopyShareLink: () => void;
 }
@@ -33,6 +36,7 @@ export function ExportModal({
   isOpen,
   isCopied,
   hasDdlExport,
+  hasDictionaryExport,
   hasDiagramExport,
   shareLinkUrl,
   isCreatingShareLink,
@@ -44,6 +48,8 @@ export function ExportModal({
   onDownloadSvg,
   onDownloadUml,
   onDownloadMermaid,
+  onExportDictionaryCsv,
+  onExportDictionaryMarkdown,
   onCreateShareLink,
   onCopyShareLink,
 }: ExportModalProps) {
@@ -93,6 +99,22 @@ export function ExportModal({
       onExport: onDownloadMermaid,
       ariaLabel: 'Mermaid 내보내기',
     },
+    {
+      label: 'Data Dictionary CSV',
+      description: hasDictionaryExport ? '테이블/컬럼 목록' : '먼저 테이블을 추가하세요',
+      buttonLabel: '내보내기',
+      disabled: !hasDictionaryExport,
+      onExport: onExportDictionaryCsv,
+      ariaLabel: '데이터 사전 CSV 내보내기',
+    },
+    {
+      label: 'Data Dictionary MD',
+      description: hasDictionaryExport ? '마크다운 문서' : '먼저 테이블을 추가하세요',
+      buttonLabel: '내보내기',
+      disabled: !hasDictionaryExport,
+      onExport: onExportDictionaryMarkdown,
+      ariaLabel: '데이터 사전 Markdown 내보내기',
+    },
   ];
 
   return (
diff --git a/frontend/src/erd/TableNode.tsx b/frontend/src/erd/TableNode.tsx
index 8e364a4b..bf7c4709 100644
--- a/frontend/src/erd/TableNode.tsx
+++ b/frontend/src/erd/TableNode.tsx
@@ -157,9 +157,13 @@ function TableNode(props: NodeProps<TableNodeNode>) {
                 </abbr>
               ) : null}
               {c.is_not_null ? (
-                <span className="tableNode__badge" title="Not Null" aria-label="필수 입력 (Not Null)">
-                  NOT NULL
-                </span>
+                <abbr
+                  className="tableNode__badge"
+                  title="Not Null"
+                  aria-label="필수 입력 (Not Null)"
+                >
+                  NN
+                </abbr>
               ) : null}
               <Handle
                 type="source"
diff --git a/frontend/src/erd/__tests__/TableNode.test.tsx b/frontend/src/erd/__tests__/TableNode.test.tsx
index ae2154c0..412e9533 100644
--- a/frontend/src/erd/__tests__/TableNode.test.tsx
+++ b/frontend/src/erd/__tests__/TableNode.test.tsx
@@ -82,7 +82,7 @@ describe('TableNode', () => {
 
     const [notNullBadge] = screen.getAllByLabelText('필수 입력 (Not Null)');
     expect(notNullBadge).toHaveAttribute('title', 'Not Null');
-    expect(notNullBadge).toHaveTextContent('NOT NULL');
+    expect(notNullBadge).toHaveTextContent('NN');
   });
 
   it('uses a fallback accessible name for blank table titles', () => {
diff --git a/frontend/src/erd/__tests__/exportDataDictionary.test.ts b/frontend/src/erd/__tests__/exportDataDictionary.test.ts
new file mode 100644
index 00000000..85fa2737
--- /dev/null
+++ b/frontend/src/erd/__tests__/exportDataDictionary.test.ts
@@ -0,0 +1,187 @@
+import type { Edge, Node } from '@xyflow/react';
+import { describe, expect, it } from 'vitest';
+
+import type { TableNodeData } from '../convert';
+import { exportDictionaryCsv, exportDictionaryMarkdown } from '../exportDataDictionary';
+
+describe('exportDataDictionary', () => {
+  const nodes: Node<TableNodeData>[] = [
+    {
+      id: 'users',
+      type: 'tableNode',
+      position: { x: 0, y: 0 },
+      data: {
+        title: 'public.users',
+        comment: 'User accounts',
+        badges: { pk: true, fk: false },
+        columns: [
+          {
+            column_name: 'id',
+            data_type: 'integer',
+            is_pk: true,
+            is_not_null: true,
+            column_comment: 'Primary Key',
+            example_value: 1,
+          },
+          {
+            column_name: 'account_id',
+            data_type: 'integer',
+            is_pk: false,
+            is_not_null: true,
+            column_comment: null,
+            example_value: 42,
+          },
+          {
+            column_name: 'email',
+            data_type: 'varchar',
+            is_pk: false,
+            is_not_null: true,
+            column_comment: null,
+            example_value: 'test@example.com',
+          },
+        ],
+      },
+    },
+    {
+      id: 'accounts',
+      type: 'tableNode',
+      position: { x: 0, y: 0 },
+      data: {
+        title: 'public.accounts',
+        comment: null,
+        badges: { pk: true, fk: false },
+        columns: [
+          {
+            column_name: 'id',
+            data_type: 'integer',
+            is_pk: true,
+            is_not_null: true,
+            column_comment: null,
+            example_value: 1,
+          },
+        ],
+      },
+    },
+    {
+      id: 'empty_table',
+      type: 'tableNode',
+      position: { x: 0, y: 0 },
+      data: {
+        title: 'empty_table',
+        comment: null,
+        badges: { pk: false, fk: false },
+        columns: [],
+      },
+    },
+  ];
+
+  const edges: Edge[] = [
+    {
+      id: 'fk_users_accounts',
+      source: 'users',
+      target: 'accounts',
+      data: { sourceColumns: ['account_id'], targetColumns: ['id'] },
+    },
+  ];
+
+  it('exports table and column metadata to CSV', () => {
+    const csv = exportDictionaryCsv(nodes, edges);
+
+    expect(csv).toContain('"Table Name","Table Comment","Column Name","Data Type","PK","FK","Not Null","Column Comment","Example Value"');
+    expect(csv).toContain('"public.users","User accounts","id","integer","Y","N","Y","Primary Key","1"');
+    expect(csv).toContain('"public.users","User accounts","account_id","integer","N","Y","Y","","42"');
+    expect(csv).toContain('"public.users","User accounts","email","varchar","N","N","Y","","test@example.com"');
+    expect(csv).toContain('"empty_table","","","","","","","",""');
+  });
+
+  it('handles empty CSV exports', () => {
+    expect(exportDictionaryCsv([], edges)).toBe(
+      '"Table Name","Table Comment","Column Name","Data Type","PK","FK","Not Null","Column Comment","Example Value"',
+    );
+  });
+
+  it('neutralizes CSV formula injection and normalizes control characters', () => {
+    const csv = exportDictionaryCsv(
+      [
+        {
+          id: 'attack',
+          type: 'tableNode',
+          position: { x: 0, y: 0 },
+          data: {
+            title: '=HYPERLINK("https://example.invalid")',
+            comment: '@note\r\nsecond line',
+            badges: { pk: false, fk: false },
+            columns: [
+              {
+                column_name: '+cmd',
+                data_type: '-integer',
+                is_pk: false,
+                is_not_null: false,
+                column_comment: '@comment',
+                example_value: '\t=2+2',
+              },
+            ],
+          },
+        },
+      ],
+      [],
+    );
+
+    expect(csv).toContain('"\'=HYPERLINK(""https://example.invalid"")"');
+    expect(csv).toContain('"\'@note second line"');
+    expect(csv).toContain('"\'+cmd"');
+    expect(csv).toContain('"\'-integer"');
+    expect(csv).toContain('"\'@comment"');
+    expect(csv).toContain('"\' =2+2"');
+  });
+
+  it('exports table and column metadata to Markdown', () => {
+    const markdown = exportDictionaryMarkdown(nodes, edges);
+
+    expect(markdown).toContain('# Data Dictionary');
+    expect(markdown).toContain('## Table: public.users (User accounts)');
+    expect(markdown).toContain('| id | integer | Y | N | Y | Primary Key | 1 |');
+    expect(markdown).toContain('| account_id | integer | N | Y | Y |  | 42 |');
+    expect(markdown).toContain('## Table: empty_table');
+    expect(markdown).toContain('No columns.');
+  });
+
+  it('escapes Markdown table breakers and HTML-like content', () => {
+    const markdown = exportDictionaryMarkdown(
+      [
+        {
+          id: 'danger',
+          type: 'tableNode',
+          position: { x: 0, y: 0 },
+          data: {
+            title: 'orders|<script>\nnext',
+            comment: '<b>note</b>',
+            badges: { pk: false, fk: false },
+            columns: [
+              {
+                column_name: 'name|x',
+                data_type: 'text',
+                is_pk: false,
+                is_not_null: false,
+                column_comment: 'see [docs](javascript:alert(1))',
+                example_value: '<img src=x onerror=alert(1)>',
+              },
+            ],
+          },
+        },
+      ],
+      [],
+    );
+
+    expect(markdown).toContain('## Table: orders\\|&lt;script&gt; next (&lt;b&gt;note&lt;/b&gt;)');
+    expect(markdown).toContain('name\\|x');
+    expect(markdown).toContain('see \\[docs\\]\\(javascript:alert\\(1\\)\\)');
+    expect(markdown).toContain('&lt;img src=x onerror=alert\\(1\\)&gt;');
+    expect(markdown).not.toContain('<script>');
+    expect(markdown).not.toContain('<img');
+  });
+
+  it('handles empty Markdown exports', () => {
+    expect(exportDictionaryMarkdown([], edges)).toBe('# Data Dictionary\n\nNo tables found.');
+  });
+});
diff --git a/frontend/src/erd/__tests__/search.test.ts b/frontend/src/erd/__tests__/search.test.ts
new file mode 100644
index 00000000..de341603
--- /dev/null
+++ b/frontend/src/erd/__tests__/search.test.ts
@@ -0,0 +1,77 @@
+import type { Node } from "@xyflow/react";
+import { describe, expect, it } from "vitest";
+
+import type { TableNodeData } from "../convert";
+import { findSearchMatchedNodeIds, tableNodeMatchesSearch } from "../search";
+
+function tableNode(
+  id: string,
+  data: Pick<TableNodeData, "title" | "columns"> &
+    Partial<Pick<TableNodeData, "comment">>,
+): Node<TableNodeData> {
+  return {
+    id,
+    type: "tableNode",
+    position: { x: 0, y: 0 },
+    data: {
+      badges: { pk: false, fk: false },
+      comment: null,
+      ...data,
+    },
+  };
+}
+
+describe("ERD node search", () => {
+  const users = tableNode("users", {
+    title: "public.users",
+    comment: "Customer profile records",
+    columns: [
+      {
+        column_name: "id",
+        data_type: "uuid",
+        is_not_null: true,
+        is_pk: true,
+      },
+      {
+        column_name: "email_address",
+        data_type: "text",
+        is_not_null: true,
+        is_pk: false,
+        column_comment: "Login email",
+      },
+    ],
+  });
+
+  const audit = tableNode("audit", {
+    title: "ops.audit_log",
+    columns: [
+      {
+        column_name: "payload",
+        data_type: "jsonb",
+        is_not_null: false,
+        is_pk: false,
+      },
+    ],
+  });
+
+  it("returns no matches for an empty search", () => {
+    expect([...findSearchMatchedNodeIds([users, audit], "   ")]).toEqual([]);
+  });
+
+  it("matches table and column fields without building a joined haystack", () => {
+    expect([...findSearchMatchedNodeIds([users, audit], "PUBLIC uuid")]).toEqual([
+      "users",
+    ]);
+    expect([...findSearchMatchedNodeIds([users, audit], "customer email")]).toEqual([
+      "users",
+    ]);
+    expect([...findSearchMatchedNodeIds([users, audit], "audit jsonb")]).toEqual([
+      "audit",
+    ]);
+  });
+
+  it("requires every search term to appear somewhere on the same node", () => {
+    expect(tableNodeMatchesSearch(users, "users jsonb")).toBe(false);
+    expect(tableNodeMatchesSearch(audit, "audit missing")).toBe(false);
+  });
+});
diff --git a/frontend/src/erd/export.ts b/frontend/src/erd/export.ts
index b172947e..edd481d6 100644
--- a/frontend/src/erd/export.ts
+++ b/frontend/src/erd/export.ts
@@ -4,6 +4,8 @@ import type { IndexRecommendation } from './cardinality';
 import type { ForeignKeyEdgeData, TableNodeData } from './convert';
 import { sourceColumnHandleId, targetColumnHandleId } from './handleUtils';
 
+export * from './exportDataDictionary';
+
 type SnapshotJson = {
   relations?: Array<{ relation_oid: number; schema_name: string; relation_name: string; relation_kind: string; relation_comment?: string | null }>
   columns?: Array<{ relation_oid: number; column_name: string; data_type: string; is_not_null: boolean; example_value?: string | number | boolean | null }>
@@ -92,7 +94,11 @@ export function exportDDL(nodes: Node<TableNodeData>[], edges: Edge[]): string {
   let ddl = '-- Generated DDL\n\n';
 
   // Bolt: Use map for O(1) node lookup instead of O(N) array find
-  const nodesById = new Map(nodes.map(n => [n.id, n]));
+  // Avoid Map(array.map) to prevent O(N) intermediate tuple array allocation overhead
+  const nodesById = new Map<string, Node<TableNodeData>>();
+  for (const n of nodes) {
+    nodesById.set(n.id, n);
+  }
 
   // Export tables
   for (const node of nodes) {
@@ -281,19 +287,24 @@ export function exportDiagramSvg(
   snapshot?: SnapshotJson | null,
 ): string {
   // Bolt: Use map for O(1) node lookup instead of O(N) array find
-  const nodesById = new Map(nodes.map(n => [n.id, n]));
+  // Avoid Map(array.map) to prevent O(N) intermediate tuple array allocation overhead
+  const nodesById = new Map<string, Node<TableNodeData>>();
+  for (const n of nodes) {
+    nodesById.set(n.id, n);
+  }
   const width = 280;
   const headerHeight = 34;
   const rowHeight = 22;
   const padding = 40;
   const indexes = indexesByRelation(snapshot);
-  const heights = new Map(
-    nodes.map((node) => {
-      // ponytail: cap rendered index rows; add full index export when the canvas carries index nodes.
-      const indexRows = Math.min((indexes.get(node.id)?.length || 0) + (node.data.indexes?.length || 0), 8);
-      return [node.id, headerHeight + rowHeight * ((node.data.columns?.length || 0) + indexRows + (indexRows ? 1 : 0))];
-    }),
-  );
+
+  // Avoid Map(array.map) to prevent O(N) intermediate tuple array allocation overhead
+  const heights = new Map<string, number>();
+  for (const node of nodes) {
+    // ponytail: cap rendered index rows; add full index export when the canvas carries index nodes.
+    const indexRows = Math.min((indexes.get(node.id)?.length || 0) + (node.data.indexes?.length || 0), 8);
+    heights.set(node.id, headerHeight + rowHeight * ((node.data.columns?.length || 0) + indexRows + (indexRows ? 1 : 0)));
+  }
   let minX = 0;
   let minY = 0;
   let maxX = width;
diff --git a/frontend/src/erd/exportDataDictionary.ts b/frontend/src/erd/exportDataDictionary.ts
new file mode 100644
index 00000000..fe821640
--- /dev/null
+++ b/frontend/src/erd/exportDataDictionary.ts
@@ -0,0 +1,162 @@
+import type { Edge, Node } from '@xyflow/react';
+
+import type { ForeignKeyEdgeData, TableNodeData } from './convert';
+import { sourceColumnHandleId } from './handleUtils';
+
+const CONTROL_TEXT_RE = /[\u0000-\u001f\u007f]+/g;
+const CSV_FORMULA_RE = /^[=+\-@]/;
+const MARKDOWN_ESCAPE_RE = /[\\|`\[\]()]/g;
+const MARKDOWN_HTML_RE = /[&<>]/g;
+const MARKDOWN_HTML_ESCAPES: Record<string, string> = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+};
+
+function cellText(value: unknown): string {
+  return String(value ?? '').replace(CONTROL_TEXT_RE, ' ');
+}
+
+function csvCell(value: unknown): string {
+  const text = cellText(value);
+  const neutralized = CSV_FORMULA_RE.test(text.trimStart()) ? `'${text}` : text;
+  return `"${neutralized.replace(/"/g, '""')}"`;
+}
+
+function markdownText(value: unknown): string {
+  return cellText(value)
+    .replace(MARKDOWN_HTML_RE, (char) => MARKDOWN_HTML_ESCAPES[char] ?? char)
+    .replace(MARKDOWN_ESCAPE_RE, (char) => `\\${char}`);
+}
+
+function sourceColumnsForEdge(edge: Edge): Set<string> {
+  const columns = new Set<string>();
+  const data = edge.data as ForeignKeyEdgeData | undefined;
+  for (const column of data?.sourceColumns || []) {
+    if (column) columns.add(column);
+  }
+  return columns;
+}
+
+function foreignKeyColumnsByNode(edges: Edge[]): Map<string, Set<string>> {
+  const map = new Map<string, Set<string>>();
+
+  for (const edge of edges) {
+    let columns = map.get(edge.source);
+    if (!columns) {
+      columns = new Set<string>();
+      map.set(edge.source, columns);
+    }
+
+    for (const column of sourceColumnsForEdge(edge)) {
+      columns.add(column);
+    }
+  }
+
+  return map;
+}
+
+function isForeignKeyColumn(
+  edgeColumnsByNode: Map<string, Set<string>>,
+  node: Node<TableNodeData>,
+  columnName: string,
+  edges: Edge[],
+): boolean {
+  if (edgeColumnsByNode.get(node.id)?.has(columnName)) {
+    return true;
+  }
+
+  const handleId = sourceColumnHandleId(columnName);
+  return edges.some((edge) => edge.source === node.id && edge.sourceHandle === handleId);
+}
+
+function exampleValue(value: TableNodeData['columns'][number]['example_value']): string {
+  return value === null || value === undefined ? '' : String(value);
+}
+
+export function exportDictionaryCsv(
+  nodes: Node<TableNodeData>[],
+  edges: Edge[],
+): string {
+  const header = [
+    'Table Name',
+    'Table Comment',
+    'Column Name',
+    'Data Type',
+    'PK',
+    'FK',
+    'Not Null',
+    'Column Comment',
+    'Example Value',
+  ];
+  const rows: unknown[][] = [header];
+  const fkColumnsByNode = foreignKeyColumnsByNode(edges);
+
+  for (const node of nodes) {
+    const tableName = node.data.title || node.id;
+    const tableComment = node.data.comment || '';
+    const columns = node.data.columns || [];
+
+    if (columns.length === 0) {
+      rows.push([tableName, tableComment, '', '', '', '', '', '', '']);
+      continue;
+    }
+
+    for (const column of columns) {
+      rows.push([
+        tableName,
+        tableComment,
+        column.column_name,
+        column.data_type,
+        column.is_pk ? 'Y' : 'N',
+        isForeignKeyColumn(fkColumnsByNode, node, column.column_name, edges) ? 'Y' : 'N',
+        column.is_not_null ? 'Y' : 'N',
+        column.column_comment || '',
+        exampleValue(column.example_value),
+      ]);
+    }
+  }
+
+  return rows.map((row) => row.map(csvCell).join(',')).join('\n');
+}
+
+export function exportDictionaryMarkdown(
+  nodes: Node<TableNodeData>[],
+  edges: Edge[],
+): string {
+  const lines: string[] = ['# Data Dictionary', ''];
+  const fkColumnsByNode = foreignKeyColumnsByNode(edges);
+
+  if (nodes.length === 0) {
+    lines.push('No tables found.');
+    return lines.join('\n');
+  }
+
+  for (const node of nodes) {
+    const tableName = markdownText(node.data.title || node.id);
+    const tableComment = node.data.comment ? ` (${markdownText(node.data.comment)})` : '';
+    const columns = node.data.columns || [];
+    lines.push(`## Table: ${tableName}${tableComment}`);
+
+    if (columns.length === 0) {
+      lines.push('No columns.', '');
+      continue;
+    }
+
+    lines.push('| Column Name | Data Type | PK | FK | Not Null | Comment | Example |');
+    lines.push('|---|---|---|---|---|---|---|');
+
+    for (const column of columns) {
+      const pk = column.is_pk ? 'Y' : 'N';
+      const fk = isForeignKeyColumn(fkColumnsByNode, node, column.column_name, edges) ? 'Y' : 'N';
+      const notNull = column.is_not_null ? 'Y' : 'N';
+      const comment = column.column_comment || '';
+      lines.push(
+        `| ${markdownText(column.column_name)} | ${markdownText(column.data_type)} | ${pk} | ${fk} | ${notNull} | ${markdownText(comment)} | ${markdownText(exampleValue(column.example_value))} |`,
+      );
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n').trim();
+}
diff --git a/frontend/src/erd/search.ts b/frontend/src/erd/search.ts
new file mode 100644
index 00000000..7e169562
--- /dev/null
+++ b/frontend/src/erd/search.ts
@@ -0,0 +1,44 @@
+import type { Node } from "@xyflow/react";
+
+import type { TableNodeData } from "./convert";
+
+function fieldIncludes(value: string | null | undefined, term: string): boolean {
+  return Boolean(value && value.toLocaleLowerCase().includes(term));
+}
+
+function nodeIncludesTerm(node: Node<TableNodeData>, term: string): boolean {
+  if (fieldIncludes(node.data.title, term)) return true;
+  if (fieldIncludes(node.data.comment, term)) return true;
+
+  for (const column of node.data.columns) {
+    if (fieldIncludes(column.column_name, term)) return true;
+    if (fieldIncludes(column.data_type, term)) return true;
+    if (fieldIncludes(column.column_comment, term)) return true;
+  }
+
+  return false;
+}
+
+export function tableNodeMatchesSearch(
+  node: Node<TableNodeData>,
+  search: string,
+): boolean {
+  const terms = Array.from(
+    new Set(search.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean)),
+  );
+  if (terms.length === 0) return false;
+  return terms.every((term) => nodeIncludesTerm(node, term));
+}
+
+export function findSearchMatchedNodeIds(
+  nodes: Array<Node<TableNodeData>>,
+  search: string,
+): Set<string> {
+  const matches = new Set<string>();
+  for (const node of nodes) {
+    if (tableNodeMatchesSearch(node, search)) {
+      matches.add(node.id);
+    }
+  }
+  return matches;
+}
diff --git a/scripts/ci/check_schema_drift.sh b/scripts/ci/check_schema_drift.sh
new file mode 100755
index 00000000..89feb4da
--- /dev/null
+++ b/scripts/ci/check_schema_drift.sh
@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+# Gate a deploy on "no unexpected schema drift".
+#
+# Compares the latest schema snapshot (target) against an approved baseline
+# snapshot (base) via the diff API and fails the pipeline when the schema
+# changed. Pair with GET .../migration.sql to print the SQL that would
+# reconcile the drift.
+#
+# Usage:
+#   PG_ERD_BASE_URL=https://erd.example.com \
+#   PG_ERD_COOKIE="session=..." \
+#   ./check_schema_drift.sh <baseline_snapshot_uuid> <target_snapshot_uuid>
+#
+# Exit codes:
+#   0  no drift (schemas identical)
+#   1  drift detected (diff summary printed, migration SQL printed)
+#   2  usage / API error (snapshot missing or unauthorized)
+set -euo pipefail
+
+usage() {
+  echo "usage: check_schema_drift.sh <baseline_uuid> <target_uuid>" >&2
+  echo "required env: PG_ERD_BASE_URL and PG_ERD_COOKIE" >&2
+}
+
+if [ "$#" -ne 2 ]; then
+  echo "drift-check: expected exactly 2 snapshot UUID arguments; got $#." >&2
+  usage
+  exit 2
+fi
+
+if [ -z "${PG_ERD_BASE_URL:-}" ]; then
+  echo "drift-check: PG_ERD_BASE_URL is not set." >&2
+  usage
+  exit 2
+fi
+
+if [ -z "${PG_ERD_COOKIE:-}" ]; then
+  echo "drift-check: PG_ERD_COOKIE is not set." >&2
+  usage
+  exit 2
+fi
+
+BASE_UUID="$1"
+TARGET_UUID="$2"
+
+api() {
+  local path="$1"
+  if ! curl --fail --silent --show-error \
+    --cookie "${PG_ERD_COOKIE}" \
+    "${PG_ERD_BASE_URL}${path}"
+  then
+    echo "drift-check: API request failed for ${path}." >&2
+    return 1
+  fi
+}
+
+if ! DIFF_JSON="$(api "/api/snapshots/${TARGET_UUID}/diff?against=${BASE_UUID}")"; then
+  echo "drift-check: unable to fetch schema diff for target=${TARGET_UUID} against baseline=${BASE_UUID}." >&2
+  exit 2
+fi
+
+if ! STATUS="$(printf '%s' "${DIFF_JSON}" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("status",""))')"; then
+  echo "drift-check: diff API response was not valid JSON." >&2
+  exit 2
+fi
+if [ "${STATUS}" != "ok" ]; then
+  echo "drift-check: snapshot not found or unauthorized (status=${STATUS})" >&2
+  exit 2
+fi
+
+if ! HAS_CHANGES="$(printf '%s' "${DIFF_JSON}" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(str(d["diff"]["summary"]["has_changes"]).lower())')"; then
+  echo "drift-check: diff API response is missing diff.summary.has_changes." >&2
+  exit 2
+fi
+
+if [ "${HAS_CHANGES}" = "false" ]; then
+  echo "drift-check: OK - schema matches the approved baseline."
+  exit 0
+fi
+
+echo "drift-check: DRIFT DETECTED - schema differs from the approved baseline." >&2
+printf '%s' "${DIFF_JSON}" | python3 -c 'import json,sys; print(json.dumps(json.load(sys.stdin)["diff"]["summary"], indent=2))' >&2
+echo "--- migration SQL that would reconcile the drift ---" >&2
+api "/api/snapshots/${TARGET_UUID}/migration.sql?against=${BASE_UUID}" >&2 || true
+exit 1