@carllee1983/dbcli 1.39.1 → 1.41.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dbcli-agent",
-  "version": "1.37.1",
+  "version": "1.41.0",
   "description": "Database CLI skill and command reference for AI agents.",
   "author": {
     "name": "Carl Lee",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dbcli-agent",
-  "version": "1.37.1",
+  "version": "1.41.0",
   "description": "Database CLI skill and command reference for AI agents",
   "author": {
     "name": "Carl Lee",

package/.cursor/rules/dbcli.mdc

@@ -18,7 +18,16 @@ the CLI package has not been installed globally.
 
 1. `dbcli blacklist list` — confirm sensitive-data boundaries.
 2. `dbcli schema <object> --format json` — confirm real column/field names. **Never guess.**
-3. All writes: `--dry-run` (SQL/Mongo) → run → `query` read-back to confirm.
+3. All writes: `--dry-run` (SQL/Mongo) → run → `query` read-back to confirm. Redis
+   `query` has **no `--dry-run`** (see **Redis**); Elasticsearch is **read-only**.
+
+**`update` / `delete` `--where` is equality-only (SQL).** It accepts **only** `col=val` or
+`col1=v1 AND col2=v2`. A comparison / pattern operator (`>`, `>=`, `<`, `!=`, `LIKE`, `IN`)
+is a **parse error**; worse, `OR` is **silently swallowed into the value** — `a=1 OR b=2`
+parses as `a = "1 OR b=2"` and matches the wrong rows (or none). For a range or compound
+condition, first `query` / `export` the target rows' primary keys, then run one
+`update` / `delete --where "id=<pk>"` per key — or escalate to a human. (MongoDB `--where`
+takes a full JSON filter and is exempt.)
 
 > `report` and `guide` already embed an `inspect` snapshot — you do **not** need to run
 > `dbcli inspect` first. Run `dbcli inspect --for-agent` manually only when you want the
@@ -36,7 +45,7 @@ the CLI package has not been installed globally.
 
 Slow-query diagnosis has three canonical paths (pick by what you already know):
 
-- Known slow SQL → `skill tasks plan diagnose-slow-query --param query="<SQL>"` → `guide missing-index-for "<SQL>"`
+- Known slow SQL → `skill tasks plan diagnose-slow-query --param query="<SQL>"` → `lint "<SQL>"` → `guide missing-index-for "<SQL>"`
 - Known hot table → `skill tasks plan analyze-table-perf --param table=<table>`
 - Whole-environment scan → `report --section perf` → `guide slow-query`
 
@@ -45,7 +54,7 @@ afterwards add only the `@diag/*` it does not cover (`missing-indexes`, `locks`,
 `table-sizes`). Once you have a specific slow statement, `explain --analyze "<SQL>"` shows its plan.
 
 **On failure:** pass `--recovery` to `query` / `q` / `insert` / `update` / `delete` /
-`export` / `schema` / `inspect`. The command emits a `RecoveryEnvelope` to stdout and saves
+`export` / `schema` / `inspect` / `lint` / `diff --against-orm`. The command emits a `RecoveryEnvelope` to stdout and saves
 it to `.dbcli/last-recovery.json`; then `dbcli recover` inspects it and `dbcli recover --apply`
 runs the saved plan under risk gating. Multi-turn `--next`, connection branching, and the
 post-apply verify probe are documented in reference.md §Recovery Cookbook.
@@ -72,12 +81,16 @@ The plan is an ordered list of dbcli commands with rationale and risk labels. Ex
 one at a time — task plans do **not** override blacklist, schema, dry-run, or confirmation
 requirements.
 
-Builtin packs: `diagnose-slow-query` (targets a specific SQL), `analyze-table-perf` (targets
-a specific table; `dbcli inspect` auto-suggests it for the hottest table in recent audit
-activity), `audit-permissions`, `safe-backfill`, `schema-drift-review`, `connection-health`.
-Review/verify packs: `pr-database-review`, `migration-review`, `safe-backfill-verify`,
-`slow-endpoint-investigation`. All are read-only `plan-only` — pick the pack matching the
-situation, and run any index/DDL proposal through `migration-review` before writing.
+Builtin packs (SQL — postgres/mysql): `diagnose-slow-query` (targets a specific SQL),
+`analyze-table-perf` (targets a specific table; `dbcli inspect` auto-suggests it for the
+hottest table in recent audit activity), `audit-permissions`, `safe-backfill`,
+`schema-drift-review`, `orm-drift-review` (ORM definition vs cached DB schema),
+`connection-health`. Review/verify packs: `pr-database-review`,
+`migration-review`, `safe-backfill-verify`, `slow-endpoint-investigation`. MongoDB packs:
+`mongo-safe-backfill` (dry-run–previewed backfill), `mongo-schema-drift-review` (sampled
+dot-path drift). All are read-only `plan-only` — pick the pack matching the situation, and
+run any index/DDL proposal through `migration-review` before writing. Redis/Elasticsearch
+have no packs yet — lead with `guide` / `report` there.
 
 Tasks live under `assets/tasks/` (builtin), `.dbcli-shared/tasks/` (shared), and
 `.dbcli/tasks/` (local override).
@@ -92,9 +105,9 @@ in **How to use dbcli** still applies.
 | DB-backed feature | `blacklist list` → `schema <object>` → `queries suggest <intent>` |
 | DB report / dashboard request | `blacklist list` → `queries search <keywords>` / `queries suggest <intent>` → `queries show @<name>` → `q @<name> --ui` or `--format html` |
 | Application data bug | `audit tail --for-agent --n 10` → `blacklist list` → `schema <object>` → narrow query |
-| ORM or migration work | `schema --format json` → `diff --snapshot <name>` → `migrate add-index`/`add-column` (preview SQL) → `diff --against <snapshot>` |
+| ORM or migration work | `schema --format json` → `diff --against-orm <orm-schema>` → review error-level drift → proposals via `migrate` (dry-run) → `migration-review` task pack → `diff --against <snapshot>` after applying. |
 | PR database review | Review changed persistence paths, then propose concrete `schema` / `plan` / `dry-run` / `report` / `guide` commands per material claim. |
-| Slow endpoint or query | `report --section perf` → task pack `analyze-table-perf` → `guide missing-index-for "<query>"`; use `proxy analyze` when logs exist. |
+| Slow endpoint or query | `report --section perf` → task pack `analyze-table-perf` → `lint "<query>"` → `guide missing-index-for "<query>"`; use `proxy analyze` when logs exist. |
 | Safe data backfill | `blacklist list` → `schema <object>` → count/scope query → `update … --dry-run` → read-back or snippet `--verify`. |
 | Environment validation | `status --format json` → `doctor --format json` → `inspect --for-agent --no-connect`. |
 
@@ -112,9 +125,13 @@ dbcli q @<name> --param k=v --format html > report.html
 dbcli export "<SQL>" --format html --output report.html
 dbcli audit tail --for-agent --n 10
 dbcli diff --snapshot <name>
+dbcli diff --against-orm prisma/schema.prisma --format json
+dbcli diff --against-orm "migrations/*.sql" --format markdown
+dbcli skill tasks plan orm-drift-review --param orm_path=prisma/schema.prisma --format json
 dbcli report --section perf --format json
 dbcli skill tasks plan analyze-table-perf --param table=<table> --format json
 dbcli guide missing-index-for "<query>" --format json
+dbcli lint "<SQL>" --format json
 dbcli update <object> --where "<bounded predicate>" --set '<json>' --dry-run --format json
 dbcli inspect --for-agent --no-connect --format json
 ```
@@ -281,6 +298,7 @@ Full flags and edge cases: see [reference.md](reference.md) `init` section.
 | `schema` | query-only+ | SQL: per-table or full scan into `.dbcli/schemas/`. MongoDB: sampled. ES: flattened mapping. Redis: per-key only (type/TTL/size). Supports `--recovery`. |
 | `query` | query-only+ | SQL, Mongo JSON (`--collection`), Redis command, or ES DSL/Lucene (`--collection`). `--format table\|json\|csv\|html`, `--ui` to open the interactive dashboard in a browser. Supports `--recovery`. |
 | `explain` | query-only+ | **(v1.23)** Read-only query plan with annotations. SQL only. Single query, `@saved-query`, `@file.sql`, or `--bulk @glob/*`. `--analyze` (EXPLAIN ANALYZE / MariaDB ANALYZE SELECT), `--format markdown\|json\|table`. |
+| `lint` | n/a | Static SQL anti-pattern advisor (no DB connection). 9 rules incl. schema-aware implicit-cast / NOT IN-nullable checks via the layered `.dbcli/schemas/` cache; global `--use <conn>` selects a named cache. Findings carry rewrite drafts + guarded `explain` verify commands (`--analyze` only for proven read-only SQL) — report-only, never executes. `--format text\|json\|markdown`, `--min-severity`, `--no-schema`, `--bulk`. Supports `--recovery`. |
 | `plan` | n/a | Static SQL risk analyzer (`--format text\|json`); classifies a statement without connecting to the database. |
 | `q` | query-only+ | Run a saved snippet by `@name` with `--param k=v`. Supports `--verify` to run assertions. |
 | `queries` | n/a | Manage saved snippets: `list` / `show` / `search` / `suggest` / `new` / `edit` / `check` / `delete` / `rename` / `copy` / `import` / `export`. |
@@ -289,7 +307,7 @@ Full flags and edge cases: see [reference.md](reference.md) `init` section.
 | `export` | query-only+ | SQL, MongoDB, or **(v1.22)** Elasticsearch (DSL `--index` or whole-index scroll). Query → `--format json\|jsonl\|csv\|html` file or stdout. `html` emits a standalone interactive dashboard. Supports `--recovery`. |
 | `blacklist` | n/a | `list` / `table` / `column` subcommands redact sensitive data from query results. |
 | `check` | query-only+ | SQL only (best on MySQL/MariaDB). |
-| `diff` | query-only+ | SQL only. Save/compare schema snapshots. |
+| `diff` | query-only+ | SQL only. Save/compare schema snapshots. **(P1b)** `--against-orm <path>` compares a Prisma schema / DDL file / normalized JSON against the local schema cache (no DB connection): categorized drift (`missing_in_db` = error, `missing_in_orm` = warn, `mismatch` per tolerance table, `unmanaged`) with dry-run `migrate` proposals; exit 1 on error-level drift. `--orm-format prisma\|ddl\|json`, `--ignore <globs>`, `--format json\|table\|markdown`. |
 | `snapshot` | query-only+ | **(v1.25)** SQL only. Capture a result fingerprint (`rowCount` + per-column null/distinct/min/max/sum + order-independent checksum). `--out` (default `.dbcli/snapshots/snap-<ts>.json`), `--rows`, `--stdout`, `--format`, `--no-limit`. Baseline for `assert --against`. |
 | `assert` | query-only+ | **(v1.25)** SQL only. Verify an invariant; exit 1 on failure unless `--no-fail`. `--expect "rows>0\|value==X\|col:c not null\|unique\|between a and b\|>= n"`, `--vs <query> --compare rows\|value` (reconcile), `--against <snapshot> --tolerance <pct>`. |
 | `verification` | n/a | Inspect and manage local verification artifacts. `list` / `show <id-or-path>` / `summary` are read-only; `prune` is dry-run by default and deletes only with `--execute --force`. Reads `<cwd>/.dbcli/verification/`; no DB connection, no audit writes. |
@@ -309,7 +327,7 @@ Full flags and edge cases: see [reference.md](reference.md) `init` section.
 
 `--use <name>` on any subcommand (including `status` / `doctor`) targets a v2 connection
 without changing the default. `--recovery` is honoured by `query`, `q`, `insert`, `update`,
-`delete`, `export`, `schema`, and `inspect` (see **On failure** above).
+`delete`, `export`, `schema`, `inspect`, `lint`, and `diff --against-orm` (see **On failure** above).
 
 **Write & query flag semantics** (SQL/Mongo `insert`/`update`):
 
@@ -364,12 +382,18 @@ without changing the default. `--recovery` is honoured by `query`, `q`, `insert`
   → `data-admin`. A command not in the whitelist is refused.
 - **No `--dry-run` for Redis `query`** — write safety comes from the permission gate and key
   blacklist (matching reads/writes are rejected). To preview a delete, use `delete <key> --dry-run`.
-- `database` is the logical DB index (default `0`). `dbcli blacklist add 'secrets:*'`
+- `database` is the logical DB index (default `0`). `dbcli blacklist table add 'secrets:*'`
   registers a key glob; an optional `redis.mask` block masks values on read. Size guards
   (SCAN/HGETALL truncation, `--no-limit` to bypass) and masking details: reference.md Redis section.
 
 ## Elasticsearch
 
+**dbcli is read-only against Elasticsearch — `insert` / `update` / `delete` are not supported.**
+
+```bash
+dbcli query '{"query":{"match":{"status":"active"}}}' --collection orders
+```
+
 - `query` takes a DSL (JSON body) or Lucene query string; `--collection <index>` is required.
 - **Supported:** `init`, `list` (indices with doc count), `schema [index]` (flattened mapping),
   `query`, `export` (v1.22), `shell` (v1.22), `status`, `use`, `doctor`. **Not supported:**

package/.cursor/skills/dbcli/reference.md

@@ -105,6 +105,7 @@ dbcli schema --use prod             # Scan prod DB; saves to .dbcli/schemas/prod
 
 **Schema storage (v1.4+):** Schema is persisted as layered files under `.dbcli/schemas/`. With v2 multi-connection config each connection gets its own subdirectory (`.dbcli/schemas/<connection>/`). Run `dbcli schema --use <connection>` once per connection before querying it — otherwise `schema <table>` may return data from the wrong connection's cache.
 
+> **PostgreSQL:** Introspection uses the exact `public` catalog identity throughout. Full catalog/schema/table joins prevent a reused constraint name from contaminating another table; enum lookup includes its namespace; composite primary-key order comes from the exact table OID and index ordinality; and row estimates are scoped to the exact `public` relation. Row-count SQL qualifies and quotes both `"public"` and the exact table identifier, escaping embedded quotes so mixed-case or punctuation-bearing names remain distinct and safe.
 > **Redis:** `schema <key>` is required (no full scan). The output exposes `type`, `ttl`, `size`, and a small `sample` (e.g. first 5 hash keys). `--reset` / `--refresh` are rejected — Redis caches no schema.
 > **Elasticsearch:** `schema [index]` flattens the `_mapping` properties (nested `a.b.c`) and emits each `.fields` multi-field as a separate column (e.g. `text` + `text.keyword`). Full scan iterates all non-system indices and stores per-connection caches alongside SQL engines.
 > **MongoDB:** schema is sampled via `$sample` (default 100, max 1000). `--sample-method natural` switches to `find().limit()`; `random` (default) falls back to natural order on driver error. Output columns surface nested dot-paths with `presence` (0..1) and `redacted: true` flags for blacklist-matched paths. The persisted cache records `sampleMethod` and `sampleSize`; `dbcli doctor` reports them via a `sampled: method=…, size=…` line.
@@ -192,9 +193,134 @@ dbcli explain --bulk @analytics/*                     # glob over saved queries
 | `nested-loop-large` | yellow | PG `Nested Loop` with planner rows > 10,000 |
 
 > Notes:
-> - `--analyze` executes the statement — do not use against destructive SQL.
+> - `--analyze` executes the statement, so dbcli accepts it only for SQL that is
+>   structurally proven to be a read-only, function-free `SELECT` (including
+>   SELECT-only CTEs). Explicit function and table-function calls are unproven
+>   because user-defined and built-in functions may have side effects. DML, DDL,
+>   data-modifying CTEs, session assignments, function-bearing SQL, and
+>   unrecognized SQL are rejected before the adapter is invoked; use plain
+>   `dbcli explain` for those statements.
 > - Auto-`LIMIT` is **not** applied to EXPLAIN statements (since v1.23 P1).
 
+### lint
+
+Static, report-only SQL anti-pattern analysis for PostgreSQL, MySQL, and
+MariaDB. `lint` never opens a database connection, never runs the SQL, and
+never applies a rewrite. Schema-aware findings use only the layered schema
+cache under `.dbcli/schemas/`.
+
+```text
+dbcli lint [queries...]
+dbcli lint --bulk <input>
+dbcli --use <conn> lint [queries...]
+```
+
+An input may be inline SQL, a saved query such as `@analytics/live-summary`, a
+SQL file such as `@queries.sql`, or a saved-query/filesystem glob such as
+`@analytics/*` or `@queries/**/*.sql`. `--bulk` accepts a comma-separated mix
+of those `@file`, `@glob`, and `@saved-query` inputs; quote a filesystem glob
+in a shell so the `@` reference reaches dbcli unchanged.
+
+```bash
+dbcli lint "SELECT * FROM users WHERE email LIKE '%@example.com'" --format json
+dbcli lint --bulk '@queries/**/*.sql' --format markdown
+dbcli --use staging lint @analytics/live-summary --min-severity warn
+```
+
+| Option | Default | Meaning |
+|---|---|---|
+| `--format <text\|json\|markdown>` | `text` | Render one report per resolved input. |
+| `--min-severity <info\|warn\|error>` | `info` | Omit findings below the selected severity. |
+| `--no-schema` | off | Skip schema-only checks without reading schema-cache paths; static `NOT IN` NULL checks still run. |
+| `--bulk <input>` | none | Resolve a comma-separated list of `@file`, `@glob`, or `@saved-query` inputs. |
+| `--recovery` | off | On command failure, emit and save a linked `RecoveryEnvelope`. |
+| global `--use <conn>` | configured default | Select a v2 named connection and its isolated cache; place it before `lint`: `dbcli --use <conn> lint …`. |
+
+**Rules:**
+
+| Rule | Severity | What it reports |
+|---|---|---|
+| `select-star` | warn | A top-level `SELECT *`; when one table and its cached columns are unambiguous, the finding may include a column-list rewrite draft. |
+| `unanchored-like` | warn | A `LIKE` / `ILIKE` pattern beginning with `%`, which a conventional B-tree index cannot anchor. |
+| `missing-limit-offset` | info | Deep pagination with `OFFSET >= 1000`; prefer keyset pagination. |
+| `non-sargable-where` | warn | A function or arithmetic expression applied to the column side of a predicate. |
+| `or-to-union` | info | A top-level `OR` across different columns that can complicate index selection; any UNION alternative must preserve identity and multiplicity. |
+| `subquery-to-join` | info | `IN (SELECT …)` where an equivalent `EXISTS`, or a JOIN with proven uniqueness/deduplication, may plan better. |
+| `distinct-groupby-abuse` | warn | Redundant `DISTINCT` when simple projected columns exactly cover the `GROUP BY` columns. |
+| `implicit-cast` | warn | A schema-verified column/literal type mismatch that can disable index use; safe, unambiguous numeric drafts may be included. |
+| `not-in-nullable` | warn | A right-hand `NOT IN` value that can be NULL: explicit `NULL`, outer-join null extension, a nullable subquery projection, or a known nullable CASE/cast/aggregate expression. A nullable left-hand column is not this rule. |
+
+`implicit-cast` and the schema-enriched portion of `not-in-nullable` read the
+selected cache through the schema loader abstraction. Static `not-in-nullable`
+checks still run without it. All schema caches live beneath `.dbcli/schemas/`. A v2
+configuration always uses `.dbcli/schemas/<resolved-connection>/`, including
+the configured default. The root `.dbcli/schemas/` directory is only the
+v1/legacy unnamed cache. Global `dbcli --use <conn> lint …` selects another
+named v2 slot. The command never refreshes the cache and never falls back to
+schema embedded in config.
+
+Skipped rules are returned with machine-readable `blocked:` reasons:
+
+- Invalid SQL blocks all nine rules with `blocked: parse failed` and includes
+  `parseError`.
+- `--no-schema` blocks `implicit-cast` and the schema-dependent portion of
+  `not-in-nullable` with `blocked: --no-schema`; static RHS hazards still run.
+- A missing layered cache records
+  `blocked: schema cache unavailable (run dbcli schema)` for those unavailable
+  schema checks while retaining static RHS findings.
+
+Every finding includes its rule, severity, source span, message, and
+`schemaVerified` state. Some findings also carry a confidence-labelled rewrite
+draft and a shell-safe verification command. It uses
+`dbcli explain --analyze` only when the statement is structurally proven read-only;
+function-bearing and session-assignment statements are unproven, so lint
+falls back to plain `dbcli explain`. These are suggestions only: `lint` neither
+executes the verification command nor changes the query.
+
+When schema identifiers collide after case folding, schema-aware findings and
+rewrites are withheld. The SQL parser does not preserve reliable quote
+provenance, so an exact-looking mixed-case AST identifier cannot disambiguate
+that collision. CTE, derived, schema-qualified, and database-qualified
+relations also never borrow facts from the unqualified cache.
+
+For `not-in-nullable`, remove or filter right-hand NULL values. In a subquery,
+filter the projected value with `IS NOT NULL`; `NOT EXISTS` may be a better
+semantic form when appropriate. dbcli does not automatically rewrite this case
+unless correlation, type classification, qualified-column resolution, and the
+rewrite target are all unambiguous. A direct or `AND`-conjoined `IS NOT NULL`
+filter on the exact projected expression suppresses the finding; aggregates
+apply the same proof in `HAVING`. Filters under `OR` or ambiguous expression
+matches do not. The rule recursively checks projection, JOIN `ON`, `WHERE`, and
+`HAVING` expressions, using each nested SELECT/CTE/derived statement's own
+scope. Qualified outer-join null extension remains detectable without a cache,
+but a join's synthetic NULL row is not applied inside that join's own `ON`;
+declared nullability and completed earlier joins still apply there.
+
+Trimmed JSON example:
+
+```json
+[
+  {
+    "sql": "SELECT * FROM users",
+    "dialect": "postgresql",
+    "findings": [
+      {
+        "rule": "select-star",
+        "severity": "warn",
+        "message": "SELECT * fetches every column; list the columns you need.",
+        "span": { "start": 0, "end": 8 },
+        "schemaVerified": false
+      }
+    ],
+    "skippedRules": [],
+    "relatedCommands": [
+      "dbcli guide missing-index-for \"SELECT * FROM users\"",
+      "dbcli explain --analyze \"SELECT * FROM users\""
+    ]
+  }
+]
+```
+
 ### plan
 
 Static SQL risk analyzer. Classifies a statement into the same permission tiers
@@ -249,6 +375,7 @@ dbcli q @analytics/revenue --param days=30 --format html > report.html
 - `--dry-run` — print the bound SQL + values without executing
 - `--use <name>` — pick a v2 named connection
 - `--recovery` — emit a `RecoveryEnvelope` on failure (see `recover`)
+- `--verify` — run the snippet's verification assertions after execution (only if the snippet defines them)
 
 **Permission:** query-only+
 
@@ -474,9 +601,10 @@ Insert data into a table.
 dbcli insert users --data '{"name":"Alice","email":"alice@example.com"}'
 dbcli insert users --data '{"name":"Alice"}' --dry-run
 dbcli insert users --data '{"name":"Alice"}' --force
+dbcli insert users --data '{"name":"Alice"}' --plan --format json   # risk analysis only; no DB connection
 ```
 
-**Options:** `--data <json>`, `--dry-run`, `--force`
+**Options:** `--data <json>`, `--dry-run`, `--force`, `--plan` (analyze risk without connecting or executing), `--format <text|json>` (`--plan` output), `--recovery`
 **Permission:** read-write+
 
 ### update
@@ -486,11 +614,19 @@ Update existing data.
 ```bash
 dbcli update users --where "id=1" --set '{"name":"Bob"}'
 dbcli update users --where "id=1" --set '{"name":"Bob"}' --dry-run
+dbcli update users --where "id=1" --set '{"name":"Bob"}' --plan --format json   # risk analysis only; no DB connection
 ```
 
-**Options:** `--where <condition>` (required), `--set <json>` (required), `--dry-run`, `--force`
+**Options:** `--where <condition>` (required), `--set <json>` (required), `--dry-run`, `--force`, `--plan` (analyze risk without connecting or executing), `--format <text|json>` (`--plan` output), `--recovery`
 **Permission:** read-write+
 
+> **`--where` grammar (SQL `update` / `delete`)** — equality only: `col=val` or
+> `col1=v1 AND col2=v2`. Comparison / pattern operators (`>`, `>=`, `<`, `!=`, `LIKE`, `IN`)
+> raise a parse error, and `OR` is **silently folded into the value** (`a=1 OR b=2` parses as
+> `a = "1 OR b=2"`, matching nothing intended). For ranges or compound predicates, select the
+> target primary keys first, then issue one `update` / `delete --where "id=<pk>"` per key.
+> (MongoDB `--where` accepts a full JSON filter and is exempt.)
+
 ### delete
 
 Delete data from a table.
@@ -499,9 +635,10 @@ Delete data from a table.
 dbcli delete users --where "id=1"
 dbcli delete users --where "id=1" --dry-run
 dbcli delete users --where "id=1" --force
+dbcli delete users --where "id=1" --plan --format json   # risk analysis only; no DB connection
 ```
 
-**Options:** `--where <condition>` (required), `--dry-run`, `--force`
+**Options:** `--where <condition>` (required), `--dry-run`, `--force`, `--plan` (analyze risk without connecting or executing), `--format <text|json>` (`--plan` output), `--recovery`
 **Permission:** data-admin+
 
 ### export
@@ -521,7 +658,7 @@ dbcli export orders --format csv --output orders.csv      # index name as query
 dbcli export orders --no-limit --format jsonl             # scroll the whole index in batches
 ```
 
-**Options:** `--format <json|jsonl|csv|html>` (required), `--output <path>`, `--force`, `--recovery`, `--index <name>` (Elasticsearch), `--no-limit` (Elasticsearch full-index scroll)
+**Options:** `--format <json|jsonl|csv|html>` (required), `--output <path>`, `--force`, `--recovery`, `--collection <name>` (MongoDB collection) / `--index <name>` (Elasticsearch index; alias for `--collection`), `--limit <number>` (overrides auto-limit), `--no-limit` (Elasticsearch full-index scroll)
 **Permission:** query-only+ — SQL, MongoDB, and **(v1.22)** Elasticsearch.
 
 The `html` format emits the same self-contained dashboard as `query --ui` (see [Interactive HTML dashboard](#interactive-html-dashboard)). Because `export` runs raw SQL (no snippet metadata), the HTML report is always rendered as a sortable / filterable table — no KPIs or charts. Use `dbcli q @<name> --format html` (or `--ui`) for the charted view.
@@ -572,6 +709,147 @@ dbcli diff --against before.json --format json
 **Options:** `--snapshot <path>`, `--against <path>`, `--format <json|table>`
 **Permission:** query-only+
 
+#### `diff --against-orm`
+
+Compare an ORM definition with the local SQL schema cache. This mode reads
+`config.schema`; it does not open a database connection, refresh the cache, or
+execute a proposal. An empty cache fails with
+`Schema cache is empty. Run 'dbcli schema' first.` Snapshot mode remains a
+separate `--snapshot` / `--against` workflow.
+
+```bash
+# Prisma and normalized JSON accept exactly one file
+dbcli diff --against-orm prisma/schema.prisma --format json
+dbcli diff --against-orm schema.normalized.json --orm-format json --format table
+
+# DDL accepts repeatable or comma-separated paths and real filesystem globs
+dbcli diff --against-orm "migrations/*.sql" --format markdown
+dbcli diff --against-orm migrations/base.sql,migrations/accounts.sql \
+  --against-orm migrations/orders.sql --orm-format ddl --format json
+
+# Ignore patterns are comma-separated and match qualified table identity
+dbcli diff --against-orm prisma/schema.prisma --ignore 'public.audit_*,public.Legacy'
+```
+
+| Option | Behavior |
+| :--- | :--- |
+| `--against-orm <paths>` | Repeatable or comma-separated input. DDL inputs support real filesystem globs; matches are deduplicated and put in deterministic path order, then parsed as one shared ordered context so an index in a later file can attach to a table declared in an earlier file. Prisma and normalized JSON accept exactly one file, and globs are rejected for those formats. |
+| `--orm-format prisma\|ddl\|json` | Override extension/content detection. Without it, dbcli detects Prisma, DDL, or normalized JSON from the path and content. |
+| `--ignore <globs>` | Comma-separated, case-sensitive table globs. Patterns match the qualified display identity (for example `public.Users`). `_prisma_migrations` is always unmanaged. |
+| `--format json\|table\|markdown` | Select machine JSON, human table, or Markdown output. Markdown is available only in ORM drift mode. |
+| `--recovery` | On an I/O, configuration, empty-cache, invalid-format, or unsupported-engine failure, emit and save a structured recovery envelope. Invalid Prisma/DDL constructs normally become `unparsed` entries instead of throwing. |
+
+The command supports PostgreSQL, MySQL, and MariaDB configurations. Only
+error-level **scored drift** determines the report's drift exit code: one or more
+scored errors exits `1`; warnings, infos, `unmanaged`, or `unparsed` entries alone
+exit `0`. Command/configuration failures independently exit code `1`. The four
+drift categories and tolerance rules are:
+
+| Category | Severity and comparison rule |
+| :--- | :--- |
+| `missing_in_db` | `error` — a table, column, or index exists in the ORM definition but not in the cached DB schema. |
+| `missing_in_orm` | `warn` — a table, column, or index exists in the cached DB schema but not in the ORM definition. |
+| `mismatch` | `error` when the type family or nullability differs; `info` for same-family type spelling, default, or primary-key differences. |
+| `unmanaged` | `info`, excluded from error/warn scoring — the table matched the built-in or user `--ignore` patterns. |
+
+Type-family tolerance deliberately treats engine spellings such as `text` and
+`varchar(191)` as the same family: the spelling difference is still visible as
+`info`, while an integer/text family difference is an `error`. Indexes compare
+by structural index signatures — ordered, case-folded column names plus
+uniqueness — rather than by engine-specific index names. Duplicate signatures
+are emitted once. Drift entries sort deterministically by table, object, category,
+and detail using Unicode code-point order, never locale-dependent collation.
+
+**Schema and table identity.** Storage preserves exact, case-sensitive schema
+and table names from the database catalog. Exact, case-sensitive `(schema, table)`
+tuples are the comparison key, so PostgreSQL `users` and `"Users"` can coexist.
+DDL resolution rules: unquoted SQL identifiers fold to lowercase; quoted identifiers match exactly.
+For example, unquoted `Users` resolves to `users`, and quoted
+`"Users"` resolves only to `Users`. Quote state comes from the parsed identifier representation;
+dbcli never infers it from display text, catalog spelling, or a
+Prisma mapping. Qualified components resolve independently, and unqualified ORM
+identities use the cached DB default schema when one is known. Qualified display
+names and `--ignore` matching remain case-sensitive. Duplicate exact or
+duplicate resolved table identities fail closed instead of overwriting one
+another.
+
+**Prisma subset.** The parser supports `model` blocks; scalar `String`, `Int`,
+`BigInt`, `Float`, `Decimal`, `Boolean`, `DateTime`, `Json`, and `Bytes` fields;
+`?`; relation-side `[]`; `@id`, `@unique`, `@default(...)`, `@map("...")`,
+`@@map("...")`, `@@index([...])`, `@@unique([...])`; relations with
+`fields` / `references`; and the validated native mappings `@db.Text`,
+`@db.VarChar(n)`, `@db.Uuid`, `@db.Timestamptz([precision])`, `@db.Date`,
+`@db.SmallInt`, and `@db.JsonB`. Views, composite types, enums used as scalar
+columns, multi-schema datasource configuration, malformed declarations, unknown
+attributes, and unsupported native mappings are never guessed.
+
+Prisma and DDL constructs outside the supported subset are retained in
+`unparsed` with a `blocked:` reason. These entries are separate from scored drift:
+inspect and resolve them before treating an otherwise clean summary as complete.
+Multi-file DDL is consumed as one deterministic shared ordered statement context,
+so later `CREATE INDEX` statements can reference tables declared in earlier
+files. PostgreSQL `PARTITION BY` and MySQL/MariaDB table engine, charset, and
+other `CREATE TABLE` table options are unsupported: the construct produces a
+`blocked:` `unparsed` entry and does not emit a managed ORM table.
+The normalized JSON escape hatch is Zod-validated and uses an array of tables
+with explicit exact `identity` objects; optional parsed identifiers must include
+their `quoted` flags, and every normalized JSON `unparsed.reason` must start with
+`blocked:`.
+
+```json
+{
+  "ormSource": "prisma",
+  "entries": [
+    {
+      "category": "missing_in_db",
+      "severity": "error",
+      "table": "public.users",
+      "object": "email",
+      "detail": "column 'email' (text) is defined in prisma but absent in the database",
+      "proposedCommands": [
+        "# escalate: schema-qualified table 'public.users' is not losslessly representable by dbcli migrate — run: dbcli skill tasks plan migration-review"
+      ]
+    }
+  ],
+  "unparsed": [],
+  "summary": { "errors": 1, "warns": 0, "infos": 0, "unmanaged": 0 }
+}
+```
+
+Missing unqualified columns and indexes may receive shell-safe, dry-run-by-default
+`dbcli migrate add-column` or `add-index` proposal strings. Simple arguments stay
+unquoted; unsafe shell characters are POSIX single-quoted. Table creation,
+removal, mismatch, and DB-only drift escalate to `migration-review`. A
+schema-qualified target, or index columns that the current `migrate --columns`
+CLI cannot represent losslessly, also escalates instead of emitting a corrupt
+command. Any table, column, or type positional beginning with `-` also escalates
+so Commander cannot reinterpret it as an option. A leading-dash option value is
+rendered with option-safe attached syntax, for example `--default=-1` or
+`--columns=--config,email`. Proposals are text only and never add `--execute`.
+
+For a guided, cache-refreshing review, use the built-in `orm-drift-review` pack:
+
+```bash
+dbcli skill tasks plan orm-drift-review \
+  --param orm_path=prisma/schema.prisma \
+  --format json
+```
+
+The plan is `blacklist list` → `schema --format json` →
+`diff --against-orm ... --format json`. Run any proposed `migrate` command in its
+default dry-run mode, capture the emitted DDL, confirm its exact target, and pass
+both values to the separate migration review:
+
+```sh
+dbcli skill tasks plan migration-review \
+  --param "table=${exact_table}" \
+  --param "ddl=${captured_ddl}"
+```
+
+Both parameters are required. Keep each expansion as one quoted shell argument;
+never use `eval`, and consider `--execute` only after the plan and captured DDL
+have been reviewed.
+
 ### snapshot
 
 Capture a **result fingerprint** of a query (not schema): `rowCount` plus per-column
@@ -892,6 +1170,7 @@ Boundaries:
 | `--from <path>` | Read the envelope from this file instead of `.dbcli/last-recovery.json`. Accepts raw `RecoveryEnvelope` or `SavedRecoveryEnvelope`. | — |
 | `--allow-write <tier>` | Open the risk gate. Values: `readonly-cmd` (local-side writes) \| `write-cmd` (database writes). | `none` |
 | `--no-verify` | Skip the verify step appended after a successful `--apply`. | off (verify runs by default) |
+| `--write-verification-artifact` | After a successful `--apply`, persist a secret-free `VerificationArtifact` JSON under `.dbcli/verification/`. | off |
 | `--format <format>` | `markdown` \| `json`. | `markdown` for inspect, `json` for `--apply` |
 
 #### Plan source resolution
@@ -1650,6 +1929,7 @@ dbcli skill --install codex                  # install to ~/.codex/skills/dbcli/
 **Options:**
 - `--install <platform>` — `claude` | `gemini` | `antigravity` | `copilot` | `cursor` | `codex` | `windsurf`. Writes `SKILL.md` plus `reference.md` next to it so the agent gets progressive disclosure.
 - `--output <path>` — write `SKILL.md` to a file instead of stdout. Does not install `reference.md`.
+- `--lang <en|zh-TW>` — source language for the emitted SKILL content (default `en`). It selects `assets/SKILL.md` vs `assets/SKILL.zh-TW.md`; the install/output filename stays `SKILL.md` regardless.
 
 **Notes:**
 - Both files come straight from `assets/SKILL.md` + `assets/reference.md` inside the dbcli package — no runtime rendering. Keep these in sync when shipping a release.
@@ -1662,6 +1942,21 @@ dbcli skill --install codex                  # install to ~/.codex/skills/dbcli/
 
 **Permission:** n/a.
 
+### skill context
+
+Emit an AI-friendly snapshot of the connected database's schema and saved-query snippets (blacklist-filtered) so an agent can be primed with the current context.
+
+```bash
+dbcli skill context                      # XML (default)
+dbcli skill context --format json
+dbcli skill context --format markdown
+```
+
+**Options:**
+- `--format <xml|json|markdown>` — output format (default: `xml`)
+
+**Permission:** query-only+ — read-only; blacklisted objects are never emitted.
+
 ### skill tasks (Agent Task Packs)
 
 ```bash
@@ -1685,8 +1980,12 @@ a read-only (`plan-only`) pack taking a required `table` parameter that walks
 in recent audit activity. Additional read-only packs ship for common agent
 workflows: `audit-permissions` (permission/blacklist audit), `safe-backfill`
 (plan a write with blacklist+schema+risk checks), `schema-drift-review` (cached
-vs live schema diff), and `connection-health` (reachability/config/capacity
-triage). Run `dbcli skill tasks list` for the full set.
+vs live schema diff), `orm-drift-review` (ORM definition vs cached DB schema),
+and `connection-health` (reachability/config/capacity
+triage). **MongoDB packs:** `mongo-safe-backfill` (dry-run–previewed backfill)
+and `mongo-schema-drift-review` (sampled dot-path drift, with a `sample_size` knob
+to damp sampling noise); filter them with `dbcli skill tasks list --engine mongodb`.
+Run `dbcli skill tasks list` for the full set.
 
 ```bash
 dbcli skill tasks plan analyze-table-perf --param table=betting_logs --format json
@@ -2201,7 +2500,7 @@ Rewrites emit a `REDIS_SIZE_REWRITE` warning; truncations emit `REDIS_SIZE_TRUNC
 Blacklist rules are enforced as **Redis-native key globs** (`*`, `?`, `[abc]`, `[a-z]`):
 
 ```bash
-dbcli blacklist add 'secrets:*'          # register a key-glob rule
+dbcli blacklist table add 'secrets:*'    # register a key-glob rule
 dbcli query "GET secrets:api_key"        # → BlacklistRejection (exit non-zero)
 dbcli query "MGET safe:k secrets:api"    # → rejected (any matching key fails the whole command)
 dbcli query "KEYS secrets:*"             # → rejected (pattern overlaps a rule)

package/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "dbcli-agent",
   "displayName": "dbcli Agent",
   "description": "Database CLI skill and command reference for AI agents.",
-  "version": "1.37.1",
+  "version": "1.41.0",
   "author": {
     "name": "Carl Lee",
     "url": "https://github.com/CarlLee1983"
@@ -10,6 +10,7 @@
   "homepage": "https://github.com/CarlLee1983/dbcli",
   "repository": "https://github.com/CarlLee1983/dbcli",
   "license": "MIT",
+  "logo": "docs/assets/dbcli-intro/cursor-marketplace.png",
   "keywords": [
     "database",
     "cli",