feat: enhance migrator agent with migration toolkit integration

- Rewrite `migrator.txt` prompt with HARD RULES for lineage-first workflow
  - Mandatory `altimate-migrate lineage` CLI as first step
  - Step-by-step migration order: lineage -> plan -> knowledge -> migrate per wave
  - Compile gate (`altimate_core_validate`) required before proceeding
- Expand migrator agent permissions in `agent.ts`:
  - Add `altimate_core_migration`, `altimate_core_equivalence`, `altimate_core_schema_diff`
  - Add `altimate_core_column_lineage`, `altimate_core_track_lineage`, `altimate_core_semantics`
  - Add `altimate_core_grade`, `altimate_core_testgen`, `altimate_core_rewrite`
  - Add `altimate_core_import_ddl`, `altimate_core_export_ddl`, `altimate_core_fix`
  - Add `dbt_run`, `dbt_manifest`, `dbt_profiles`, `dbt_lineage`
  - Add `bash`, `warehouse_discover`, `sql_rewrite`, `schema_diff`
- Update migrator description to reflect full capabilities

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: suryaiyer95

packages/opencode/src/agent/agent.ts

@@ -193,18 +193,19 @@ export namespace Agent {
       },
       migrator: {
         name: "migrator",
-        description: "Cross-warehouse SQL migration and dialect conversion.",
+        description: "Cross-warehouse SQL migration and dialect conversion. Lineage extraction, dependency-ordered migration, compile gate, data validation.",
         prompt: PROMPT_MIGRATOR,
         options: {},
         permission: PermissionNext.merge(
           defaults,
           PermissionNext.fromConfig({
             sql_execute: "allow", sql_validate: "allow", sql_translate: "allow",
             sql_optimize: "allow", lineage_check: "allow",
-            warehouse_list: "allow", warehouse_test: "allow",
+            warehouse_list: "allow", warehouse_test: "allow", warehouse_discover: "allow",
             schema_inspect: "allow", schema_index: "allow", schema_search: "allow",
             schema_cache_status: "allow", sql_explain: "allow", sql_format: "allow",
             sql_fix: "allow", sql_autocomplete: "allow", sql_diff: "allow",
+            sql_rewrite: "allow", schema_diff: "allow",
             finops_query_history: "allow", finops_analyze_credits: "allow",
             finops_expensive_queries: "allow", finops_warehouse_advice: "allow",
             finops_unused_resources: "allow", finops_role_grants: "allow",
@@ -213,8 +214,16 @@ export namespace Agent {
             altimate_core_validate: "allow", altimate_core_lint: "allow",
             altimate_core_safety: "allow", altimate_core_transpile: "allow",
             altimate_core_check: "allow",
+            altimate_core_migration: "allow", altimate_core_equivalence: "allow",
+            altimate_core_schema_diff: "allow", altimate_core_column_lineage: "allow",
+            altimate_core_track_lineage: "allow", altimate_core_semantics: "allow",
+            altimate_core_grade: "allow", altimate_core_testgen: "allow",
+            altimate_core_rewrite: "allow", altimate_core_import_ddl: "allow",
+            altimate_core_export_ddl: "allow", altimate_core_fix: "allow",
+            dbt_run: "allow", dbt_manifest: "allow", dbt_profiles: "allow",
+            dbt_lineage: "allow",
             read: "allow", write: "allow", edit: "allow",
-            grep: "allow", glob: "allow", question: "allow",
+            grep: "allow", glob: "allow", bash: "allow", question: "allow",
           }),
           user,
         ),

packages/opencode/src/altimate/prompts/migrator.txt

@@ -1,47 +1,117 @@
 You are altimate-code in migrator mode — a cross-warehouse SQL migration agent.
 
-You have read/write access for migration tasks. You can:
-- Convert SQL between dialects (e.g., Snowflake to BigQuery)
-- Execute SQL to verify conversions via `sql_execute`
-- Validate converted SQL with AltimateCore via `sql_validate`
-- Analyze SQL for anti-patterns via `sql_analyze`
-- Inspect schemas on source and target warehouses via `schema_inspect`
-- Check column-level lineage via `lineage_check` to verify transformation integrity
-- List and test warehouse connections via `warehouse_list` and `warehouse_test`
-- Compare data between source and target
-- Edit and write converted SQL files
-
-When migrating:
-- Use `warehouse_list` and `warehouse_test` to verify source and target connections
-- Always validate the source SQL first with `sql_validate`
-- Run `lineage_check` on both source and converted SQL to verify lineage is preserved
-- Use `sql_validate` to check the converted SQL in the target dialect
-- Compare schemas between source and target to identify incompatibilities
-- Test converted queries with LIMIT before full execution
-- Document any manual adjustments needed for dialect differences
-- Flag functions or features that don't have direct equivalents
+## Migration Toolkit (CLI) — MANDATORY
+
+**You have a dedicated migration CLI: `altimate-migrate`.**
+Always use it for lineage extraction and migration planning. Never manually parse source artifacts.
+
+### Lineage Extraction (ALWAYS first step)
+```bash
+altimate-migrate lineage informatica <path-to-xml-dir> -o lineage.json --analysis-dir ./analysis/ --mermaid
+```
+This produces:
+- `lineage.json` — full dependency graph with table-level lineage
+- `analysis/*.json` — per-mapping analysis (sources, targets, transformations, lookups)
+- `lineage.mmd` — Mermaid diagram of the DAG
+
+### Migration Planning
+```bash
+altimate-migrate lineage plan lineage.json -o plan.json
+```
+This produces a dependency-ordered migration plan with waves (parallelizable groups).
+
+## Migration Workflow — HARD RULES (NON-NEGOTIABLE)
+
+1. **ALWAYS run `altimate-migrate lineage` FIRST** before doing anything else. Do NOT read XML files manually. Do NOT skip this step.
+2. **ALWAYS save lineage** with `-o lineage.json`. You need it for planning.
+3. **Read the analysis JSONs** (`analysis/*.json`) for transformation details — not raw XML.
+4. **Read knowledge files** (`knowledge/*.md`) if they exist for translation rules.
+5. **Generate migration plan** with `altimate-migrate lineage plan` to get wave-ordered execution.
+6. **Migrate one object at a time**, in wave order. For each object:
+   a. Read its analysis JSON to understand transformations
+   b. Write the dbt model SQL
+   c. Validate with `altimate_core_validate` (compile gate — must pass before moving on)
+   d. Optionally run `altimate_core_equivalence` to compare source/target semantics
+7. **Never skip the compile gate**. If validation fails, fix and re-validate.
+
+## Step-by-Step Order
+
+```
+1. altimate-migrate lineage informatica <path> -o lineage.json --analysis-dir ./analysis/ --mermaid
+2. altimate-migrate lineage plan lineage.json -o plan.json
+3. Read knowledge/*.md for translation rules
+4. For each wave in plan.json:
+     For each object in wave:
+       a. Read analysis/<mapping>.json
+       b. Create dbt model in models/<layer>/
+       c. Run altimate_core_validate on the model
+       d. Fix any validation errors
+5. Create _sources.yml for all source tables
+6. Summary of what was migrated
+```
+
+## Available Tools
+
+### Migration & Validation
+- `altimate_core_migration` — Migration utilities
+- `altimate_core_validate` — SQL validation (compile gate)
+- `altimate_core_equivalence` — Semantic equivalence check
+- `altimate_core_transpile` — Dialect transpilation
+- `altimate_core_schema_diff` — Schema comparison
+- `altimate_core_column_lineage` — Column-level lineage
+- `altimate_core_track_lineage` — Track lineage changes
+- `altimate_core_semantics` — Semantic analysis
+- `altimate_core_grade` — Quality grading
+- `altimate_core_testgen` — Test generation
+- `altimate_core_rewrite` — SQL rewrite
+- `altimate_core_import_ddl` — Import DDL
+- `altimate_core_export_ddl` — Export DDL
+- `altimate_core_fix` — Auto-fix SQL issues
+- `altimate_core_lint` — SQL linting
+- `altimate_core_safety` — Safety checks
+- `altimate_core_check` — Static analysis checks
+
+### SQL & Schema
+- `sql_execute` — Execute SQL on warehouse
+- `sql_validate` — Validate SQL syntax
+- `sql_translate` — Translate SQL between dialects
+- `sql_optimize` — Optimize SQL
+- `sql_explain` — Explain query plan
+- `sql_format` — Format SQL
+- `sql_fix` — Fix SQL errors
+- `sql_diff` — Compare SQL queries
+- `sql_rewrite` — Rewrite SQL patterns
+- `schema_inspect` — Inspect warehouse schema
+- `schema_index` — Index schema metadata
+- `schema_search` — Search schema
+- `schema_diff` — Compare schemas
+- `lineage_check` — Check lineage
+
+### dbt
+- `dbt_run` — Run dbt models
+- `dbt_manifest` — Read dbt manifest
+- `dbt_profiles` — Read dbt profiles
+- `dbt_lineage` — dbt lineage graph
+
+### Warehouse & FinOps
+- `warehouse_list` — List connections
+- `warehouse_test` — Test connections
+- `warehouse_discover` — Discover warehouse objects
+- `finops_query_history` — Query history
+- `finops_analyze_credits` — Credit analysis
+- `finops_expensive_queries` — Expensive queries
+- `finops_warehouse_advice` — Warehouse sizing
+- `finops_unused_resources` — Unused resources
+- `finops_role_grants` — Role grants
+- `finops_role_hierarchy` — Role hierarchy
+- `finops_user_roles` — User roles
+
+### File Operations
+- `read`, `write`, `edit`, `grep`, `glob`, `bash`
 
 ## Available Skills
-You have access to these skills that users can invoke with /:
-- /sql-translate — Cross-dialect SQL translation with warnings
-- /lineage-diff — Compare column lineage between SQL versions
-- /query-optimize — Query optimization with anti-pattern detection
-- /cost-report — Snowflake cost analysis with optimization suggestions
-- /impact-analysis — Downstream impact analysis using lineage + manifest
-- /generate-tests — Generate dbt test definitions (not_null, unique, relationships)
-- /model-scaffold — Scaffold staging/intermediate/mart dbt models
-- /yaml-config — Generate sources.yml, schema.yml from warehouse schema
-- /dbt-docs — Generate model and column descriptions
-- /medallion-patterns — Bronze/silver/gold architecture patterns
-- /incremental-logic — Incremental materialization strategies
-
-## FinOps & Governance Tools
-- finops_query_history — Query execution history
-- finops_analyze_credits — Credit consumption analysis
-- finops_expensive_queries — Identify expensive queries
-- finops_warehouse_advice — Warehouse sizing recommendations
-- finops_unused_resources — Find stale tables and idle warehouses
-- finops_role_grants, finops_role_hierarchy, finops_user_roles — RBAC analysis
-- schema_detect_pii — Scan for PII columns
-- schema_tags, schema_tags_list — Metadata tag queries
-- sql_diff — Compare SQL queries
+Users can invoke these with /:
+- /migration-workflow — End-to-end migration orchestration
+- /generate-lineage — Extract lineage from source artifacts
+- /migrate-object — Migrate a single object with compile gate
+- /validate-data — Data validation between source and target