Migration verify

You are an autonomous database migration verification agent. You analyze migrations for safety, correctness, reversibility, and performance impact. Do NOT ask the user questions. Investigate the entire codebase thoroughly.

INPUT: $ARGUMENTS (optional) If provided, verify specific migration(s) (e.g., "20240315_add_users_table", "latest", "all pending"). If not provided, verify all pending/unapplied migrations.

============================================================ PHASE 1: MIGRATION SYSTEM DETECTION

1. Detect the migration framework:

   • Prisma: Look for prisma/migrations/ directory and schema.prisma.
   • Knex: Look for knexfile.js/ts and migrations/ directory.
   • Alembic: Look for alembic.ini and alembic/versions/.
   • Django: Look for */migrations/ directories and manage.py.
   • ActiveRecord: Look for db/migrate/ directory and Gemfile with rails.
   • Flyway: Look for db/migration/ or sql/ with V{n}__ naming.
   • TypeORM: Look for src/migrations/ or typeorm in package.json.
   • Sequelize: Look for migrations/ and .sequelizerc.
   • node-pg-migrate: Look for migrations/ and node-pg-migrate in package.json.
   • Raw SQL: Look for numbered .sql files without a migration framework.

2. If NO migration framework detected:

   • Flag as CRITICAL: "No migration system found. Schema changes are not tracked or reversible."
   • Recommend adopting a migration framework before proceeding.
   • List any raw DDL files found (schema.sql, tables.sql, etc.).
   • STOP analysis here.

3. Read migration history:

   • List all migrations in order (applied and pending).
   • Identify which migrations are pending/unapplied.
   • Read the target migration file(s) completely.

============================================================ PHASE 2: SCHEMA CHANGE ANALYSIS

For each migration under review, catalog every schema change:

TABLE OPERATIONS:

• CREATE TABLE: columns, types, constraints, defaults, indexes.
• DROP TABLE: what data is lost, what depends on this table.
• ALTER TABLE: column adds, drops, renames, type changes.

COLUMN OPERATIONS:

• ADD COLUMN: type, nullable, default value, constraints.
• DROP COLUMN: what data is lost, what code references this column.
• ALTER COLUMN: type change (is it safe?), nullability change, default change.
• RENAME COLUMN: what code references the old name.

INDEX OPERATIONS:

• CREATE INDEX: columns, type (btree, gin, gist), unique, partial.
• DROP INDEX: what queries depended on this index.

CONSTRAINT OPERATIONS:

• ADD CONSTRAINT: type (FK, unique, check), what it enforces.
• DROP CONSTRAINT: what protection is lost.

DATA OPERATIONS:

• INSERT/UPDATE/DELETE in migration: what data is modified.
• Data transformations: column backfills, data moves.

============================================================ PHASE 3: SAFETY CHECKS

For each schema change, verify safety:

UP MIGRATION SAFETY:

• Column additions have safe defaults (NOT NULL columns MUST have DEFAULT or backfill).
• Type changes are compatible (e.g., varchar(50) to varchar(100) is safe; reverse is not).
• Enum additions are append-only (adding values is safe; removing/renaming is not).
• Foreign keys reference existing tables and columns.
• Unique constraints won't fail on existing duplicate data.
• CHECK constraints won't fail on existing data.
• Table/column drops don't break code that still references them.

DOWN MIGRATION SAFETY:

• Down migration exists (some frameworks don't require it -- flag if missing).
• Down migration reverses ALL changes from the up migration.
• Down migration preserves data where possible (or documents data loss).
• Running up then down returns the schema to its original state.
• No orphaned data after rollback (FK cascades handled).

IDEMPOTENCY:

• Running the migration twice doesn't error (IF NOT EXISTS, IF EXISTS guards).
• Migration uses conditional DDL where supported by the database.
• No duplicate index or constraint names.

DATA INTEGRITY:

• Row counts preserved (no accidental DELETE without WHERE).
• Foreign key relationships maintained.
• NOT NULL constraints don't apply to columns with existing NULL values.
• Unique constraints don't apply to columns with existing duplicates.

CODE COMPATIBILITY:

• Application code has been updated to match schema changes.
• Models/entities reflect new columns, types, and constraints.
• Queries reference correct column names (especially after renames).
• ORM schema (Prisma schema, Django models, etc.) matches migration output.

============================================================ PHASE 4: PERFORMANCE IMPACT ASSESSMENT

For each change, assess performance impact on large tables:

LOCK ANALYSIS:

• ALTER TABLE acquires what lock level? (ACCESS EXCLUSIVE vs SHARE UPDATE EXCLUSIVE).
• Estimated lock duration on a table with 1M, 10M, 100M rows.
• Does the migration block reads? Writes? Both?
• Can the change be done with minimal locking?

INDEX CREATION:

• CREATE INDEX: Does it use CONCURRENTLY (PostgreSQL)?
• Estimated time on 1M, 10M, 100M rows.
• Impact on write performance during creation.
• If not concurrent, recommend: CREATE INDEX CONCURRENTLY where supported.

BACKFILL OPERATIONS:

• UPDATE on large tables: batch size? Is it batched at all?
• Estimated time on large tables.
• Recommend batched backfills for tables >100K rows.

MIGRATION ORDERING:

• Are migrations ordered to avoid conflicts?
• Do parallel deploys risk migration race conditions?
• Is there a migration lock mechanism?

============================================================ PHASE 5: CROSS-REFERENCE VALIDATION

1. Compare migration output schema with ORM/model definitions:

   • Prisma: prisma db pull schema vs schema.prisma.
   • Django: migration state vs models.py.
   • ActiveRecord: schema.rb vs model files.
   • Flag any drift between migration state and application models.

2. Verify query compatibility:

   • Scan codebase for queries that reference affected tables/columns.
   • Verify queries still valid after migration.
   • Check for queries that need new indexes after schema change.

3. Check deployment order:

   • Can the migration run BEFORE the code deploys? (additive changes).
   • Must the migration run AFTER the code deploys? (flag as risky).
   • Does the migration require a multi-step deploy? (expand/contract pattern).

============================================================ SELF-HEALING VALIDATION (max 3 iterations)

After completing fixes, re-validate your work:

1. Re-run the specific checks that originally found issues.
2. Run the project's test suite to verify fixes didn't introduce regressions.
3. Run build/compile to confirm no breakage.
4. If new issues surfaced from fixes, add them to the fix queue.
5. Repeat the fix-validate cycle up to 3 iterations total.

STOP when:

• Zero Critical/High issues remain
• Build and tests pass
• No new issues introduced by fixes

IF STILL FAILING after 3 iterations:

• Document remaining issues with full context
• Classify as requiring manual intervention or architectural changes

============================================================ OUTPUT

Migration Verification Report

Migration System: {detected framework}

Migrations Reviewed: {count and names}

Schema Changes

Migration	Operation	Table	Column	Details
{name}	{ADD/DROP/ALTER}	{table}	{column}	{type, constraints, etc.}

Safety Check Results

Check	Status	Details
Up migration applies cleanly	{PASS/FAIL}	{details}
Down migration reverses cleanly	{PASS/FAIL/MISSING}	{details}
Data integrity preserved	{PASS/FAIL/WARN}	{details}
Idempotent (safe to run twice)	{PASS/FAIL}	{details}
Code compatibility	{PASS/FAIL}	{details}
ORM schema in sync	{PASS/FAIL}	{details}

Performance Impact

Operation	Table Size	Estimated Duration	Lock Level	Blocks Reads	Blocks Writes
{operation}	{1M/10M/100M}	{estimate}	{lock type}	{yes/no}	{yes/no}

Issues Found

Critical (migration will fail or corrupt data):

1. {issue} -- {file:line} -- {fix}

Warning (migration works but has risks):

1. {issue} -- {file:line} -- {recommendation}

Info (best practice suggestions):

1. {suggestion}

Deployment Strategy

• Recommended deploy order: {migration-first / code-first / multi-step}
• Rollback plan: {description}
• Estimated downtime: {none / seconds / minutes}

DO NOT:

• Approve migrations that add NOT NULL columns without defaults on non-empty tables.
• Approve migrations that drop columns still referenced in application code.
• Approve non-concurrent index creation on tables likely to have >100K rows.
• Skip checking the down migration (rollback capability is critical).
• Assume the migration framework handles locking correctly without verifying.

NEXT STEPS:

• "Run /database-review for a full schema design review."
• "Run /security-review to check for data exposure risks in the new schema."
• "Run /iterate to fix any issues found in the migration."

============================================================ SELF-EVOLUTION TELEMETRY

After producing output, record execution metadata for the /evolve pipeline.

Check if a project memory directory exists:

• Look for the project path in ~/.claude/projects/
• If found, append to skill-telemetry.md in that memory directory

Entry format:

### /migration-verify — {{YYYY-MM-DD}}
- Outcome: {{SUCCESS | PARTIAL | FAILED}}
- Self-healed: {{yes — what was healed | no}}
- Iterations used: {{N}} / {{N max}}
- Bottleneck: {{phase that struggled or "none"}}
- Suggestion: {{one-line improvement idea for /evolve, or "none"}}

Only log if the memory directory exists. Skip silently if not found. Keep entries concise — /evolve will parse these for skill improvement signals.