db-mcp 1.1.1 → 2.0.0

package/test-server/test-advanced/test-codemode-advanced-introspection.md

@@ -0,0 +1,171 @@
+# db-mcp Advanced Stress Test — [introspection]
+
+> [!IMPORTANT]
+> **Do not track progress in this file.** Track your test progress, coverage matrix, and findings in your internal task tracking system (artifact). However, you SHOULD edit this file to fix any factual errors, broken code, or incorrect assertions in the test prompts.
+> If there is nothing to fix, don't update UNRELEASED.md.
+> We're currently testing Native mode.
+
+**Step 1:** Read `C:\Users\chris\Desktop\db-mcp\src\constants\server-instructions\gotchas.md` using `view_file`.
+
+**Step 2:** Execute each numbered stress test below using `sqlite_execute_code` (code mode).
+
+**Step 3:** The agent should update C:\Users\chris\Desktop\db-mcp\UNRELEASED.md with any/all changes/fixes.
+
+## WASM Mode
+
+> When testing against a **WASM backend** (`--sqlite` / sql.js): All 9 introspection tools are fully WASM-compatible. No categories to skip.
+>
+> **Minor difference**: `schemaSnapshot` may report `test_articles_fts` in virtual tables but it is not queryable (FTS5 is unavailable in WASM). Treat its presence as expected but non-functional.
+
+> **Code Mode Required:** Several optional params (`table`, `direction`, `sections`, `compact`, `checks`, `includeTableDetails`, `limit`) are defined in tool schemas but NOT exposed in MCP tool definitions. Use `sqlite_execute_code` to test these params via `sqlite.introspection.*` API.
+
+## Code Mode Execution
+
+- **Code Over Docs**: Fix the handler code if standards (Structured Errors/Zod) are violated. Do NOT change docs/prompts to accommodate broken code.
+
+All tests via `sqlite_execute_code`. Use `sqlite.introspection.*` for all introspection tools.
+State persists across calls. All introspection tools are **read-only** — no cleanup needed.
+
+## Test Database Schema
+
+| Table             | Rows | Key Columns                                            |
+| ----------------- | ---- | ------------------------------------------------------ |
+| test_products     | 16   | id, name, price, category                              |
+| test_orders       | 20   | id, product_id (FK→test_products), total_price, status |
+| test_measurements | 200  | id, sensor_id, temperature, humidity, pressure         |
+
+**Key FK:** `test_orders.product_id → test_products.id`
+**Redundant index (intentional):** `idx_orders_status` is a prefix of `idx_orders_status_date` — used to test index audit.
+
+## Reporting Format
+
+- ❌ Fail | ⚠️ Issue | 📦 Payload (monitor `metrics.tokenEstimate`) | ✅ Confirmed (inline only)
+
+## Structured Error Response Pattern
+
+Handler error ✅ = JSON with `success` + `error`. MCP error ❌ = raw text, `isError: true`.
+
+---
+
+## introspection Group Tools (9)
+
+1. sqlite_dependency_graph
+2. sqlite_topological_sort
+3. sqlite_cascade_simulator
+4. sqlite_schema_snapshot
+5. sqlite_constraint_analysis
+6. sqlite_migration_risks
+7. sqlite_storage_analysis
+8. sqlite_index_audit
+9. sqlite_query_plan
+
+---
+
+### Category 1: Graph Analysis Edge Cases
+
+**1.1 Full Dependency Graph**
+
+1. `sqlite.introspection.dependencyGraph({})` → full graph. Verify edge `test_orders → test_products` present.
+2. `sqlite.introspection.dependencyGraph({includeRowCounts: false})` → verify rowCount omitted.
+3. Verify `stats.rootTables` and `stats.leafTables` are populated and disjoint.
+
+**1.2 Topological Sort Direction Stress**
+
+4. `sqlite.introspection.topologicalSort({direction: "create"})` → `test_products` BEFORE `test_orders`
+5. `sqlite.introspection.topologicalSort({direction: "drop"})` → `test_orders` BEFORE `test_products`
+6. Verify both directions list the same set of tables (just reordered)
+
+**1.3 Cascade Chains**
+
+7. `sqlite.introspection.cascadeSimulator({table: "test_products"})` → affectedTables includes `test_orders` with FK action
+8. `sqlite.introspection.cascadeSimulator({table: "test_measurements"})` → affectedTables empty (leaf table)
+9. `sqlite.introspection.cascadeSimulator({table: "test_orders"})` → affectedTables empty (nothing references test_orders via FK)
+
+---
+
+### Category 2: Schema Snapshot Completeness
+
+10. `sqlite.introspection.schemaSnapshot({})` → full snapshot:
+    - tables ≥ 11 (10 regular + FTS virtual)
+    - indexes ≥ 4 (`idx_orders_status`, `idx_orders_date`, `idx_products_category`, `idx_orders_status_date`)
+    - generatedAt is valid ISO timestamp
+11. `sqlite.introspection.schemaSnapshot({sections: ["indexes"]})` → only indexes section. Tables absent.
+12. `sqlite.introspection.schemaSnapshot({sections: ["tables", "indexes"]})` → both sections present
+13. `sqlite.introspection.schemaSnapshot({compact: true})` → tables present but columns arrays absent
+14. `sqlite.introspection.schemaSnapshot({compact: false})` → column details (name, type, nullable, pk) present
+
+---
+
+### Category 3: Constraint Analysis Stress
+
+15. `sqlite.introspection.constraintAnalysis({})` → all tables analyzed. Verify summary.byType and summary.bySeverity keys.
+16. `sqlite.introspection.constraintAnalysis({checks: ["unindexed_fk"]})` → only unindexed FK findings.
+17. `sqlite.introspection.constraintAnalysis({table: "test_users"})` → only test_users findings. No other tables referenced.
+18. `sqlite.introspection.constraintAnalysis({table: "nonexistent_table_xyz"})` → report behavior: empty findings or structured error?
+
+---
+
+### Category 4: Storage Analysis & Index Audit Depth
+
+**4.1 Storage Analysis Verification**
+
+19. `sqlite.introspection.storageAnalysis({})` → verify database.totalSizeBytes = pageSize × totalPages (arithmetic check)
+20. `sqlite.introspection.storageAnalysis({})` → verify tables sorted by size descending
+21. `sqlite.introspection.storageAnalysis({includeTableDetails: false})` → tables absent. Database-level metrics present.
+22. `sqlite.introspection.storageAnalysis({limit: 3})` → only top 3 tables (if supported)
+23. `sqlite.introspection.storageAnalysis({})` → verify fragmentationPct 0-100, journalMode and autoVacuum non-empty
+
+**4.2 Index Audit Cross-Validation**
+
+24. `sqlite.introspection.indexAudit({})` → flag `idx_orders_status` as `type: "redundant"` (prefix of `idx_orders_status_date`). Field name is `index`.
+25. `sqlite.introspection.indexAudit({})` → verify `redundantOf` points to `idx_orders_status_date`
+26. `sqlite.introspection.indexAudit({})` → check for `missing_fk_index` on `test_orders.product_id`
+27. `sqlite.introspection.indexAudit({table: "test_products"})` → only test_products findings. `idx_products_category` NOT redundant.
+28. `sqlite.introspection.indexAudit({table: "test_measurements"})` → 200 rows, no secondary indexes. `unindexed_large_table` threshold is 1000 → no finding expected.
+
+---
+
+### Category 5: Query Plan Deep Analysis
+
+29. `sqlite.introspection.queryPlan({sql: "SELECT * FROM test_orders WHERE status = 'completed'"})` → use `idx_orders_status`
+30. `sqlite.introspection.queryPlan({sql: "SELECT * FROM test_products WHERE name = 'Laptop Pro 15'"})` → full scan (no index on name). Verify `analysis.fullScans` includes `test_products`, `suggestions` array exists.
+31. `sqlite.introspection.queryPlan({sql: "SELECT p.name, o.quantity FROM test_products p JOIN test_orders o ON o.product_id = p.id WHERE o.status = 'completed'"})` → join plan with multiple entries.
+32. `sqlite.introspection.queryPlan({sql: "SELECT * FROM test_orders WHERE status = 'completed' AND order_date > '2026-01-20'"})` → compound WHERE. Verify index choice.
+33. `sqlite.introspection.queryPlan({sql: "SELECT COUNT(*) FROM test_measurements GROUP BY sensor_id"})` → GROUP BY without dedicated index. Expect full scan.
+34. `sqlite.introspection.queryPlan({sql: "WITH top_orders AS (SELECT * FROM test_orders ORDER BY total_price DESC LIMIT 5) SELECT t.*, p.name FROM top_orders t JOIN test_products p ON p.id = t.product_id"})` → CTE + JOIN plan.
+
+---
+
+### Category 6: Migration Risk Assessment Depth
+
+35. `sqlite.introspection.migrationRisks({statements: ["DROP TABLE test_products"]})` → critical/high risk. Mentions FK dependents.
+36. `sqlite.introspection.migrationRisks({statements: ["ALTER TABLE test_products ADD COLUMN temp_col TEXT"]})` → low risk (additive)
+37. `sqlite.introspection.migrationRisks({statements: ["CREATE INDEX idx_temp ON test_products(name)"]})` → low risk
+38. `sqlite.introspection.migrationRisks({statements: ["DROP INDEX idx_orders_status"]})` → medium risk. Verify `riskLevel: "medium"`, `category: "index_removal"`.
+39. `sqlite.introspection.migrationRisks({statements: ["ALTER TABLE test_products ADD COLUMN temp1 TEXT", "DROP TABLE test_orders", "CREATE TABLE new_orders (id INTEGER PRIMARY KEY)"]})` → 3 statements, mixed risk. `summary.totalStatements = 3`, `summary.highestRisk ≥ "high"`.
+
+---
+
+### Category 7: Error Message Quality
+
+40. `sqlite.introspection.queryPlan({sql: "DELETE FROM test_products WHERE id = 1"})` → structured error rejecting non-SELECT
+41. `sqlite.introspection.queryPlan({sql: "SELECT * FROM nonexistent_table_xyz"})` → structured error mentioning table
+42. `sqlite.introspection.queryPlan({})` → Zod error for missing `sql` — must be handler error, NOT raw MCP
+43. `sqlite.introspection.cascadeSimulator({})` → Zod error for missing `table`
+44. `sqlite.introspection.migrationRisks({})` → Zod error for missing `statements`
+45. `sqlite.introspection.storageAnalysis({limit: 0})` → Zod error (min: 1)
+46. `sqlite.introspection.storageAnalysis({limit: -5})` → Zod error
+
+---
+
+### Final Cleanup
+
+All tools read-only — no cleanup needed. Confirm `test_products` (16), `test_orders` (20), `test_measurements` (200) unchanged.
+
+## Post-Test Procedures
+
+1. **Fix EVERY finding** — ❌, ⚠️, 📦
+2. **Validate**: Instruct the user to run the test suite (Vitest/Playwright), lint, and typecheck. Do NOT run them yourself.
+3. **Commit**: Stage and commit — do NOT push
+4. **Re-test**: After server rebuild
+5. **Token audit**: Report most expensive block

package/test-server/test-advanced/test-codemode-advanced-json.md

@@ -0,0 +1,169 @@
+# db-mcp Advanced Stress Test — [json]
+
+> [!IMPORTANT]
+> **Do not track progress in this file.** Track your test progress, coverage matrix, and findings in your internal task tracking system (artifact). However, you SHOULD edit this file to fix any factual errors, broken code, or incorrect assertions in the test prompts.
+> If there is nothing to fix, don't update UNRELEASED.md.
+> We're currently testing Native mode.
+
+**Step 1:** Read `C:\Users\chris\Desktop\db-mcp\src\constants\server-instructions\gotchas.md` using `view_file`.
+
+**Step 2:** Execute each numbered stress test below using `sqlite_execute_code` (code mode).
+
+**Step 3:** The agent should update C:\Users\chris\Desktop\db-mcp\UNRELEASED.md with any/all changes/fixes.
+
+## WASM Mode
+
+> When testing against a **WASM backend** (`--sqlite` / sql.js): All 24 JSON tools are fully WASM-compatible. No categories to skip or adjust.
+
+## Code Mode Execution
+
+- **Code Over Docs**: Fix the handler code if standards (Structured Errors/Zod) are violated. Do NOT change docs/prompts to accommodate broken code.
+
+All tests via `sqlite_execute_code`. Use `sqlite.json.*` for JSON tools, `sqlite.core.*` for read/write.
+State persists across calls. Do NOT pass `readonly: true`. Group related tests into single calls.
+
+## Test Database Schema
+
+| Table           | Rows | Key Columns                                                    |
+| --------------- | ---- | -------------------------------------------------------------- |
+| test_jsonb_docs | 6    | id, doc (JSON), metadata (JSON), tags (JSON array), created_at |
+| test_events     | 100  | id, event_type, user_id, payload (JSON), event_date            |
+
+**test_jsonb_docs key data:**
+
+- Row 1: `doc.type="article"`, `doc.author="Alice"`, `doc.views=1250`, `doc.rating=4.5`
+- Row 4: `doc.nested.level1.level2 = "deep value"`
+- Row 5: `doc.type="podcast"` (no `doc.views` field)
+
+## Naming & Cleanup
+
+- **Temporary tables**: `stress_*` prefix. Drop at end.
+- If DROP fails due to lock, note and move on.
+
+## Reporting Format
+
+- ❌ Fail | ⚠️ Issue | 📦 Payload (monitor `metrics.tokenEstimate`) | ✅ Confirmed (inline only)
+
+### Error Message Quality Rating
+
+| Level                                  | Verdict |
+| -------------------------------------- | ------- |
+| 5 - Excellent (name + code + context)  | ✅      |
+| 4 - Good (name)                        | ✅      |
+| 3 - Adequate (raw SQLite, informative) | ⚠️      |
+| 2 - Poor (no object name)              | ⚠️      |
+| 1 - Useless (generic)                  | ❌      |
+
+## Structured Error Response Pattern
+
+Handler error ✅ = JSON with `success` + `error`. MCP error ❌ = raw text, `isError: true`.
+
+---
+
+## json Group Tools (24 + codemode)
+
+1. sqlite_json_valid
+2. sqlite_json_extract
+3. sqlite_json_set
+4. sqlite_json_remove
+5. sqlite_json_type
+6. sqlite_json_array_length
+7. sqlite_json_array_append
+8. sqlite_json_keys
+9. sqlite_json_each
+10. sqlite_json_group_array
+11. sqlite_json_group_object
+12. sqlite_json_pretty
+13. sqlite_jsonb_convert
+14. sqlite_json_storage_info
+15. sqlite_json_normalize_column
+16. sqlite_json_insert
+17. sqlite_json_update
+18. sqlite_json_select
+19. sqlite_json_query
+20. sqlite_json_validate_path
+21. sqlite_json_merge
+22. sqlite_json_analyze_schema
+23. sqlite_create_json_collection
+24. sqlite_json_security_scan
+
+---
+
+### Category 1: Deep JSON Operations
+
+**1.1 Deeply Nested Access**
+
+1. `sqlite.json.extract({table: "test_jsonb_docs", column: "doc", path: "$.nested.level1.level2", whereClause: "id = 4"})` → `"deep value"`
+2. `sqlite.json.extract({table: "test_jsonb_docs", column: "doc", path: "$.nested.level1.nonexistent", whereClause: "id = 4"})` → null or empty (not error)
+3. `sqlite.json.extract({table: "test_jsonb_docs", column: "doc", path: "$.nonexistent_key", whereClause: "id = 1"})` → null or empty
+
+**1.2 Array Manipulation Edge Cases**
+
+4. `sqlite.json.arrayLength({table: "test_jsonb_docs", column: "tags", whereClause: "id = 3"})` → 3 (["mcp","protocol","ai"])
+5. Create `stress_json_test` with a row containing `tags = '[]'` (empty array) → `sqlite.json.arrayLength` → 0
+6. `sqlite.json.each` on an empty array → 0 expanded rows (not error)
+
+**1.3 Merge Conflict Behavior**
+
+> `sqlite_json_merge` uses `json_patch()` which follows RFC 7396 merge-patch semantics.
+
+Insert test rows into `stress_json_test`: row 2 = `{"a": 1, "b": {"c": 2}}`, row 3 = `{"a": [1, 2]}`:
+
+7. `sqlite.json.merge({table: "stress_json_test", column: "tags", mergeData: {"b": {"d": 3}}, whereClause: "id = 2"})` → verify deep merge: `b.c` preserved, `b.d` added
+8. `sqlite.json.merge({table: "stress_json_test", column: "tags", mergeData: {"a": [3, 4]}, whereClause: "id = 3"})` → arrays replaced (not concatenated) per RFC 7396
+
+**1.4 Type Coercion Edge Cases**
+
+9. `sqlite.json.type({table: "test_jsonb_docs", column: "doc", path: "$.views", whereClause: "id = 1"})` → `"integer"` (views=1250)
+10. `sqlite.json.type({table: "test_jsonb_docs", column: "doc", path: "$.rating", whereClause: "id = 1"})` → `"real"` (rating=4.5)
+11. `sqlite.json.type({table: "test_jsonb_docs", column: "doc", path: "$.nested", whereClause: "id = 4"})` → `"object"`
+
+---
+
+### Category 2: JSON Query & Filter Stress
+
+> `sqlite_json_query` uses `filterPaths` (equality-only, `Record<path, value>`) and `selectPaths`.
+
+12. `sqlite.json.query({table: "test_jsonb_docs", column: "doc", filterPaths: {"$.type": "article"}})` → 4 rows
+13. `sqlite.json.query({table: "test_jsonb_docs", column: "doc", filterPaths: {"$.type": "article", "$.author": "Alice"}, selectPaths: ["$.title", "$.views"]})` → 1 row (Alice's article)
+14. `sqlite.json.query({table: "test_events", column: "payload", filterPaths: {"$.page": "home"}})` → 25 rows (every 4th event)
+
+---
+
+### Category 3: Error Message Quality
+
+15. `sqlite.json.extract({table: "nonexistent_table_xyz", column: "doc", path: "$.x"})` → structured error mentioning table name
+16. `sqlite.json.extract({table: "test_jsonb_docs", column: "nonexistent_col", path: "$.x"})` → structured error mentioning column
+17. `sqlite.json.set({table: "test_jsonb_docs", column: "doc", path: "$.author", value: "\"Modified\"", whereClause: "id = 99999"})` → report behavior for nonexistent row
+18. `sqlite.json.validatePath({path: ""})` → report behavior for empty path
+
+---
+
+### Category 4: Write Operation Safety
+
+19. Create `stress_json_write` table → insert 3 JSON documents → perform `sqlite.json.set`, `sqlite.json.remove`, `sqlite.json.insert` → verify mutations → cleanup
+    > **Note:** `sqlite_json_insert` is a **row-level INSERT** (creates new row with JSON data, provided via the `data` parameter), not a path-level JSON insert.
+20. `sqlite.json.normalizeColumn(...)` on `stress_json_write` → verify keys sorted/compacted without data loss
+
+---
+
+### Category 5: Security Scan Stress
+
+21. `sqlite.json.securityScan({table: "test_jsonb_docs", column: "doc"})` → scan result with `riskLevel`
+22. Create `stress_json_inject` with rows containing suspicious patterns (`<script>`, `' OR 1=1`, `${cmd}`) → `sqlite.json.securityScan` → verify detection
+23. Cleanup: drop `stress_json_inject`
+
+---
+
+### Final Cleanup
+
+Drop all `stress_*` tables. Confirm `test_jsonb_docs` row count is still 6 and contents unchanged.
+
+## Post-Test Procedures
+
+1. **Cleanup**: Drop all `stress_*` objects
+2. **Fix EVERY finding** — ❌, ⚠️, 📦. Consistent with `code-map.md`
+3. **Validate**: Instruct the user to run the test suite (Vitest/Playwright), lint, and typecheck. Do NOT run them yourself.
+4. **Commit**: Stage and commit — do NOT push
+5. **Re-test**: After server rebuild
+6. **Token audit**: Report most expensive block

package/test-server/test-advanced/test-codemode-advanced-migration.md

@@ -0,0 +1,160 @@
+# db-mcp Advanced Stress Test — [migration]
+
+> [!IMPORTANT]
+> **Do not track progress in this file.** Track your test progress, coverage matrix, and findings in your internal task tracking system (artifact). However, you SHOULD edit this file to fix any factual errors, broken code, or incorrect assertions in the test prompts.
+> If there is nothing to fix, don't update UNRELEASED.md.
+> We're currently testing Native mode.
+
+**Step 1:** Read `C:\Users\chris\Desktop\db-mcp\src\constants\server-instructions\gotchas.md` using `view_file`.
+
+**Step 2:** Execute each numbered stress test below using `sqlite_execute_code` (code mode).
+
+**Step 3:** The agent should update C:\Users\chris\Desktop\db-mcp\UNRELEASED.md with any/all changes/fixes.
+
+> **⚠️ After testing, run `Set-Location C:\Users\chris\Desktop\db-mcp\test-server; .\reset-database.ps1`** — migration testing creates the `_mcp_migrations` tracking table and may ALTER/CREATE/DROP tables. Always reset after.
+
+## WASM Mode
+
+> When testing against a **WASM backend** (`--sqlite` / sql.js): All 6 migration tools are fully WASM-compatible. No categories to skip or adjust.
+
+## Code Mode Execution
+
+- **Code Over Docs**: Fix the handler code if standards (Structured Errors/Zod) are violated. Do NOT change docs/prompts to accommodate broken code.
+
+All tests via `sqlite_execute_code`. Use `sqlite.migration.*` for migration tools, `sqlite.core.*` for read/write.
+State persists across calls. Do NOT pass `readonly: true`.
+
+> **⚠️ Migration tests are stateful** — each depends on state from the previous. Run lifecycle tests sequentially.
+
+## Test Database Schema
+
+| Table         | Rows | Key Columns                              |
+| ------------- | ---- | ---------------------------------------- |
+| test_products | 16   | id, name, price, category                |
+| test_orders   | 20   | id, product_id (FK), total_price, status |
+
+## Naming & Cleanup
+
+- **Temporary tables**: `stress_*` prefix.
+- **After testing**: Run `Set-Location C:\Users\chris\Desktop\db-mcp\test-server; .\reset-database.ps1` to undo schema modifications.
+
+## Reporting Format
+
+- ❌ Fail | ⚠️ Issue | 📦 Payload (monitor `metrics.tokenEstimate`) | ✅ Confirmed (inline only)
+
+## Structured Error Response Pattern
+
+Handler error ✅ = JSON with `success` + `error`. MCP error ❌ = raw text, `isError: true`.
+
+---
+
+## migration Group Tools (6)
+
+1. sqlite_migration_init
+2. sqlite_migration_record
+3. sqlite_migration_apply
+4. sqlite_migration_rollback
+5. sqlite_migration_history
+6. sqlite_migration_status
+
+---
+
+### Category 1: Initialization & Idempotency
+
+1. `sqlite.migration.migrationInit({})` → success, `_mcp_migrations` table created
+2. `sqlite.migration.migrationInit({})` → idempotent: should succeed without error
+3. `sqlite.migration.migrationStatus({})` → empty/clean state
+4. `sqlite.migration.migrationHistory({})` → empty list
+
+---
+
+### Category 2: Full Lifecycle (Record → Apply → Rollback)
+
+**2.1 Simple ALTER TABLE Migration**
+
+5. `sqlite.migration.migrationRecord({version: "stress_001_add_col", description: "Add stress flag", sql: "ALTER TABLE test_products ADD COLUMN stress_flag INTEGER DEFAULT 0"})` → recorded (SQL not executed)
+6. `sqlite.migration.migrationStatus({})` → shows 1 recorded migration
+7. Verify column is NOT yet added
+8. `sqlite.migration.migrationApply({version: "stress_001_add_col", description: "Add stress flag", sql: "ALTER TABLE test_products ADD COLUMN stress_flag INTEGER DEFAULT 0"})` → applied (SQL executed)
+9. `sqlite.migration.migrationStatus({})` → shows 1 applied
+
+**2.2 CREATE TABLE Migration**
+
+10. `sqlite.migration.migrationApply({version: "stress_002_create_table", description: "Create data table", sql: "CREATE TABLE stress_migration_data (id INTEGER PRIMARY KEY, name TEXT NOT NULL, value REAL)", rollbackSql: "DROP TABLE IF EXISTS stress_migration_data"})` → applied
+11. `sqlite.migration.migrationHistory({})` → both migrations with timestamps
+
+**2.3 Rollback Chain**
+
+12. `sqlite.migration.migrationRollback({version: "stress_002_create_table"})` → rollback with stored rollbackSql
+13. Verify `stress_migration_data` is gone
+14. `sqlite.migration.migrationHistory({})` → check status
+
+---
+
+### Category 3: State Pollution & Ordering
+
+**3.1 Re-Record After Rollback**
+
+15. `sqlite.migration.migrationApply({version: "stress_003_recreate", description: "Recreate", sql: "CREATE TABLE stress_migration_data (id INTEGER PRIMARY KEY, value TEXT)", rollbackSql: "DROP TABLE IF EXISTS stress_migration_data"})` → applied
+16. `sqlite.migration.migrationStatus({})` → verify counts
+
+**3.2 Duplicate Detection**
+
+17. `sqlite.migration.migrationRecord({version: "stress_001_add_col", description: "Duplicate", sql: "SELECT 1"})` → report behavior: should error (duplicate version) or allow?
+
+**3.3 SHA-256 Duplicate SQL Detection**
+
+18. `sqlite.migration.migrationRecord({version: "stress_004_dup_sql", description: "Dup SQL", sql: "ALTER TABLE test_products ADD COLUMN stress_flag INTEGER DEFAULT 0"})` → report behavior: same SQL hash as stress_001
+
+**3.4 Multi-Statement Apply Verification**
+
+19. `sqlite.migration.migrationApply({version: "stress_005_index", description: "Add index", sql: "CREATE INDEX stress_idx_flag ON test_products(stress_flag)", rollbackSql: "DROP INDEX IF EXISTS stress_idx_flag"})` → applied
+20. Verify index created with `sqlite.core.getIndexes({table: "test_products"})`
+
+---
+
+### Category 4: Error Paths & Recovery
+
+**4.1 Apply Failures**
+
+21. `sqlite.migration.migrationApply({version: "stress_006_bad_sql", description: "Bad SQL", sql: "ALTER TABLE nonexistent_xyz ADD COLUMN foo TEXT"})` → records but execute fails
+22. `sqlite.migration.migrationStatus({})` → verify failed migration state is tracked
+
+**4.2 Nonexistent Migration Operations**
+
+23. `sqlite.migration.migrationRollback({version: "nonexistent_migration_xyz"})` → structured error (not raw MCP)
+
+**4.3 Zod Validation Errors**
+
+24. `sqlite.migration.migrationRecord({})` → Zod error for missing required params — must be handler error
+25. `sqlite.migration.migrationApply({})` → Zod error for missing required params
+26. `sqlite.migration.migrationRollback({})` → Zod error for missing `version`
+
+---
+
+### Category 5: Error Message Quality
+
+Rate each error response 1-5:
+
+27. `sqlite.migration.migrationRollback({version: "nonexistent_migration_xyz"})` → does it mention the version?
+28. `sqlite.migration.migrationRecord({})` → does it list missing required fields?
+29. `sqlite.migration.migrationRollback({version: "stress_001_add_col"})` → rate error clarity (no rollbackSql stored)
+
+---
+
+### Final Cleanup
+
+1. Drop `_mcp_migrations`: `sqlite.admin.dropTable({table: "_mcp_migrations"})`
+2. Drop `stress_migration_data`: `sqlite.admin.dropTable({table: "stress_migration_data"})`
+3. Drop `stress_idx_flag`: _Handled by database reset below_
+4. **Reset database** with `Set-Location C:\Users\chris\Desktop\db-mcp\test-server; .\reset-database.ps1` to undo `stress_flag` column on `test_products`
+5. After reset, verify: `test_products` has 16 rows and original columns (no `stress_flag`)
+
+## Post-Test Procedures
+
+1. **⚠️ Reset database**: `Set-Location C:\Users\chris\Desktop\db-mcp\test-server; .\reset-database.ps1`
+2. **Fix EVERY finding** — ❌, ⚠️, 📦
+3. **Validate**: Instruct the user to run the test suite (Vitest/Playwright), lint, and typecheck. Do NOT run them yourself.
+4. **Commit**: Stage and commit — do NOT push
+5. **Re-test**: After server rebuild
+6. **Token audit**: Report most expensive block