@rudderhq/db 0.7.2-canary.0 → 0.7.3

package/dist/client.test.js

@@ -7,13 +7,15 @@ import os from "node:os";
 import path from "node:path";
 import postgres from "postgres";
 import { afterEach, describe, expect, it } from "vitest";
-import { applyPendingMigrations, ensurePostgresDatabase, ensurePostgresRolePassword, inspectMigrations, reconcilePendingMigrationHistory, } from "./client.js";
+import { runDatabaseBackup, runDatabaseRestore } from "./backup-lib.js";
+import { applyPendingMigrations, ensurePostgresDatabase, ensurePostgresRolePassword, inspectMigrations, listLegacyColumnRenames, MIGRATION_ADVISORY_LOCK_NAME, normalizeLegacyColumnNames, reconcilePendingMigrationHistory, validatePostMigrationInvariants, } from "./client.js";
 const tempPaths = [];
 const runningInstances = [];
 async function getEmbeddedPostgresCtor() {
     const mod = await import("embedded-postgres");
     return mod.default;
 }
+const migrationTestTimeout = (timeoutMs) => process.platform === "win32" ? timeoutMs * 4 : timeoutMs;
 async function getAvailablePort() {
     return await new Promise((resolve, reject) => {
         const server = net.createServer();
@@ -152,20 +154,155 @@ function createCurrentMigrationsFolderThrough(maxIdx) {
     return migrationsFolder;
 }
 afterEach(async () => {
-    while (runningInstances.length > 0) {
-        const instance = runningInstances.pop();
-        if (!instance)
-            continue;
-        await instance.stop();
+    const instances = runningInstances.splice(0).reverse();
+    const results = await Promise.allSettled(instances.map((instance) => instance.stop()));
+    const failures = results.filter((result) => result.status === "rejected");
+    if (failures.length > 0) {
+        throw new AggregateError(failures.map((failure) => failure.reason), `Failed to stop ${failures.length} embedded PostgreSQL test instance(s)`);
     }
     while (tempPaths.length > 0) {
         const tempPath = tempPaths.pop();
         if (!tempPath)
             continue;
-        fs.rmSync(tempPath, { recursive: true, force: true });
+        await fs.promises.rm(tempPath, {
+            recursive: true,
+            force: true,
+            maxRetries: 20,
+            retryDelay: 250,
+        });
     }
-});
+}, migrationTestTimeout(30_000));
 describe("applyPendingMigrations", () => {
+    it("serializes migration attempts with a database advisory lock", async () => {
+        const connectionString = await createTempDatabase();
+        const blocker = postgres(connectionString, { max: 1, onnotice: () => { } });
+        let lockReleased = false;
+        try {
+            await blocker `
+          SELECT pg_advisory_lock(
+            hashtext(current_database()),
+            hashtext(${MIGRATION_ADVISORY_LOCK_NAME})
+          )
+        `;
+            const migration = applyPendingMigrations(connectionString);
+            const initialOutcome = await Promise.race([
+                migration.then(() => "completed"),
+                new Promise((resolve) => setTimeout(() => resolve("waiting"), 150)),
+            ]);
+            expect(initialOutcome).toBe("waiting");
+            await blocker `
+          SELECT pg_advisory_unlock(
+            hashtext(current_database()),
+            hashtext(${MIGRATION_ADVISORY_LOCK_NAME})
+          )
+        `;
+            lockReleased = true;
+            await migration;
+        }
+        finally {
+            if (!lockReleased) {
+                await blocker `
+            SELECT pg_advisory_unlock(
+              hashtext(current_database()),
+              hashtext(${MIGRATION_ADVISORY_LOCK_NAME})
+            )
+          `;
+            }
+            await blocker.end();
+        }
+    }, migrationTestTimeout(30_000));
+    it("reports journal, core table, foreign key, and index invariants after migration", async () => {
+        const connectionString = await createTempDatabase();
+        await applyPendingMigrations(connectionString);
+        const report = await validatePostMigrationInvariants(connectionString);
+        expect(report).toMatchObject({
+            valid: true,
+            migrationJournalSchema: "drizzle",
+            organizationsTablePresent: true,
+            organizationsPrimaryKeyValid: true,
+            unvalidatedForeignKeys: [],
+            invalidIndexes: [],
+            issues: [],
+        });
+        expect(report.manifestFingerprint).toMatch(/^[0-9a-f]{64}$/);
+        expect(report.expectedMigrationCount).toBeGreaterThan(0);
+        expect(report.migrationJournalEntryCount).toBeGreaterThan(0);
+        expect(report.foreignKeyCount).toBeGreaterThan(0);
+        const journalTamperSql = postgres(connectionString, { max: 1, onnotice: () => { } });
+        try {
+            await journalTamperSql.unsafe(`
+          INSERT INTO "drizzle"."__drizzle_migrations" ("hash", "created_at")
+          SELECT legacy."hash", latest."created_at" + legacy."offset"
+          FROM (VALUES
+            ('31ba03166f91d84423463bf986219371786078bde80241379cab83d53a4df6d5', 1),
+            ('e5c12f75cba0ee38da04e5175c762a4b3b5e9e9c523ea97f9956448b44e11570', 2),
+            ('f48a179c17c3ae9b2b419a3f8d4ee8d78de6e4acec3a077fe0d4bcb9a73d57c6', 3),
+            ('a531d1d8383becb9090492d1b763aeb11a4c2ade4f325a29500511900b29888d', 4),
+            ('cbf2988159818d54929cda6119f3ca3b6cd6d265c08fb73c6221198ff99d070e', 5)
+          ) AS legacy("hash", "offset")
+          CROSS JOIN (
+            SELECT COALESCE(MAX("created_at"), 0) AS "created_at"
+            FROM "drizzle"."__drizzle_migrations"
+          ) AS latest
+        `);
+            const legacyReport = await validatePostMigrationInvariants(connectionString);
+            expect(legacyReport.valid).toBe(true);
+            expect(legacyReport.issues).toEqual([]);
+            await journalTamperSql.unsafe(`
+          UPDATE "drizzle"."__drizzle_migrations"
+          SET "hash" = repeat('0', 64)
+          WHERE "id" = (SELECT min("id") FROM "drizzle"."__drizzle_migrations")
+        `);
+        }
+        finally {
+            await journalTamperSql.end();
+        }
+        const tamperedReport = await validatePostMigrationInvariants(connectionString);
+        expect(tamperedReport.valid).toBe(false);
+        expect(tamperedReport.issues).toContainEqual(expect.objectContaining({
+            code: "migration_journal_invalid",
+        }));
+        const unknownLegacyConnectionString = await createTempDatabase();
+        await applyPendingMigrations(unknownLegacyConnectionString);
+        const legacyJournalTamperSql = postgres(unknownLegacyConnectionString, { max: 1, onnotice: () => { } });
+        try {
+            await legacyJournalTamperSql.unsafe(`
+          INSERT INTO "drizzle"."__drizzle_migrations" ("hash", "created_at")
+          SELECT 'legacy-corrupt', COALESCE(MAX("created_at"), 0) + 1
+          FROM "drizzle"."__drizzle_migrations"
+        `);
+        }
+        finally {
+            await legacyJournalTamperSql.end();
+        }
+        const unknownLegacyReport = await validatePostMigrationInvariants(unknownLegacyConnectionString);
+        expect(unknownLegacyReport.valid).toBe(false);
+        expect(unknownLegacyReport.issues).toContainEqual(expect.objectContaining({
+            code: "migration_journal_invalid",
+            message: expect.stringContaining("does not match any current migration manifest entry"),
+        }));
+        const sql = postgres(connectionString, { max: 1, onnotice: () => { } });
+        try {
+            await sql.unsafe(`CREATE TABLE "migration_invariant_parent" ("id" integer PRIMARY KEY)`);
+            await sql.unsafe(`CREATE TABLE "migration_invariant_child" ("parent_id" integer)`);
+            await sql.unsafe(`
+          ALTER TABLE "migration_invariant_child"
+          ADD CONSTRAINT "migration_invariant_child_parent_fk"
+          FOREIGN KEY ("parent_id") REFERENCES "migration_invariant_parent"("id") NOT VALID
+        `);
+        }
+        finally {
+            await sql.end();
+        }
+        const invalidReport = await validatePostMigrationInvariants(connectionString);
+        expect(invalidReport.valid).toBe(false);
+        expect(invalidReport.unvalidatedForeignKeys).toEqual([
+            "migration_invariant_child.migration_invariant_child_parent_fk",
+        ]);
+        expect(invalidReport.issues).toContainEqual(expect.objectContaining({
+            code: "foreign_keys_not_validated",
+        }));
+    }, migrationTestTimeout(30_000));
     it("normalizes legacy embedded cluster passwords back to rudder", async () => {
         const legacyConnectionString = await createTempDatabaseWithPassword("password");
         const legacyUrl = new URL(legacyConnectionString);
@@ -190,7 +327,7 @@ describe("applyPendingMigrations", () => {
         finally {
             await sql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
     it("rebuilds schema when migration journal exists but core tables are missing", async () => {
         const connectionString = await createTempDatabase();
         await applyPendingMigrations(connectionString);
@@ -223,7 +360,7 @@ describe("applyPendingMigrations", () => {
         finally {
             await verifySql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
     it("applies the organization schema on a fresh database", async () => {
         const connectionString = await createTempDatabase();
         await applyPendingMigrations(connectionString);
@@ -246,7 +383,184 @@ describe("applyPendingMigrations", () => {
         finally {
             await verifySql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
+    it("preserves dormant legacy plugin storage across restart, upgrade, and backup restore", async () => {
+        const connectionString = await createTempDatabase();
+        await applyPendingMigrations(connectionString);
+        const pluginId = "00000000-0000-0000-0000-000000000202";
+        const jobId = "00000000-0000-0000-0000-000000000206";
+        const legacyTables = [
+            "plugin_config",
+            "plugin_entities",
+            "plugin_job_runs",
+            "plugin_jobs",
+            "plugin_logs",
+            "plugin_organization_settings",
+            "plugin_state",
+            "plugin_webhook_deliveries",
+            "plugins",
+        ];
+        const sql = postgres(connectionString, { max: 1, onnotice: () => { } });
+        try {
+            await sql.unsafe(`
+          INSERT INTO "organizations" ("id", "url_key", "name", "issue_prefix")
+          VALUES ('00000000-0000-0000-0000-000000000201', 'legacy-plugin-storage', 'Legacy Plugin Storage', 'LPS')
+        `);
+            await sql.unsafe(`
+          INSERT INTO "plugins" (
+            "id", "plugin_key", "package_name", "version", "categories",
+            "manifest_json", "status", "package_path"
+          ) VALUES (
+            '${pluginId}', 'legacy-linear', '@legacy/linear', '1.2.3',
+            '["integration"]'::jsonb, '{"name":"Linear","apiVersion":1}'::jsonb,
+            'active', '/legacy/plugins/linear'
+          )
+        `);
+            await sql.unsafe(`
+          INSERT INTO "plugin_config" ("id", "plugin_id", "config_json", "last_error")
+          VALUES (
+            '00000000-0000-0000-0000-000000000203', '${pluginId}',
+            '{"token":"preserved","team":"ENG"}'::jsonb, 'historical config error'
+          )
+        `);
+            await sql.unsafe(`
+          INSERT INTO "plugin_state" (
+            "id", "plugin_id", "scope_kind", "scope_id", "namespace", "state_key", "value_json"
+          ) VALUES (
+            '00000000-0000-0000-0000-000000000204', '${pluginId}',
+            'organization', '00000000-0000-0000-0000-000000000201',
+            'sync', 'cursor', '{"after":"LIN-42"}'::jsonb
+          )
+        `);
+            await sql.unsafe(`
+          INSERT INTO "plugin_entities" (
+            "id", "plugin_id", "entity_type", "scope_kind", "scope_id",
+            "external_id", "title", "status", "data"
+          ) VALUES (
+            '00000000-0000-0000-0000-000000000205', '${pluginId}', 'issue',
+            'organization', '00000000-0000-0000-0000-000000000201',
+            'LIN-42', 'Preserved issue', 'closed', '{"priority":2}'::jsonb
+          )
+        `);
+            await sql.unsafe(`
+          INSERT INTO "plugin_jobs" ("id", "plugin_id", "job_key", "schedule", "status")
+          VALUES ('${jobId}', '${pluginId}', 'sync', '0 * * * *', 'paused')
+        `);
+            await sql.unsafe(`
+          INSERT INTO "plugin_job_runs" (
+            "id", "job_id", "plugin_id", "trigger", "status", "duration_ms", "logs"
+          ) VALUES (
+            '00000000-0000-0000-0000-000000000207', '${jobId}', '${pluginId}',
+            'scheduled', 'succeeded', 1250, '["legacy run complete"]'::jsonb
+          )
+        `);
+            await sql.unsafe(`
+          INSERT INTO "plugin_webhook_deliveries" (
+            "id", "plugin_id", "webhook_key", "external_id", "status",
+            "duration_ms", "payload", "headers"
+          ) VALUES (
+            '00000000-0000-0000-0000-000000000208', '${pluginId}', 'linear-event',
+            'delivery-42', 'succeeded', 25, '{"type":"Issue"}'::jsonb,
+            '{"x-delivery-id":"delivery-42"}'::jsonb
+          )
+        `);
+            await sql.unsafe(`
+          INSERT INTO "plugin_organization_settings" (
+            "id", "org_id", "plugin_id", "enabled", "settings_json", "last_error"
+          ) VALUES (
+            '00000000-0000-0000-0000-000000000209',
+            '00000000-0000-0000-0000-000000000201', '${pluginId}', false,
+            '{"project":"ENG"}'::jsonb, 'disabled before removal'
+          )
+        `);
+            await sql.unsafe(`
+          INSERT INTO "plugin_logs" ("id", "plugin_id", "level", "message", "meta")
+          VALUES (
+            '00000000-0000-0000-0000-000000000210', '${pluginId}', 'warn',
+            'legacy log preserved', '{"attempt":3}'::jsonb
+          )
+        `);
+        }
+        finally {
+            await sql.end();
+        }
+        const readSnapshot = async (databaseUrl) => {
+            const readSql = postgres(databaseUrl, { max: 1, onnotice: () => { } });
+            try {
+                const tables = await readSql.unsafe(`
+            SELECT table_name
+            FROM information_schema.tables
+            WHERE table_schema = 'public'
+              AND table_name LIKE 'plugin%'
+            ORDER BY table_name
+          `);
+                const [data] = await readSql.unsafe(`
+            SELECT
+              jsonb_build_object(
+                'plugin_config', (SELECT count(*)::int FROM "plugin_config" WHERE "plugin_id" = '${pluginId}'),
+                'plugin_entities', (SELECT count(*)::int FROM "plugin_entities" WHERE "plugin_id" = '${pluginId}'),
+                'plugin_job_runs', (SELECT count(*)::int FROM "plugin_job_runs" WHERE "plugin_id" = '${pluginId}'),
+                'plugin_jobs', (SELECT count(*)::int FROM "plugin_jobs" WHERE "plugin_id" = '${pluginId}'),
+                'plugin_logs', (SELECT count(*)::int FROM "plugin_logs" WHERE "plugin_id" = '${pluginId}'),
+                'plugin_organization_settings', (SELECT count(*)::int FROM "plugin_organization_settings" WHERE "plugin_id" = '${pluginId}'),
+                'plugin_state', (SELECT count(*)::int FROM "plugin_state" WHERE "plugin_id" = '${pluginId}'),
+                'plugin_webhook_deliveries', (SELECT count(*)::int FROM "plugin_webhook_deliveries" WHERE "plugin_id" = '${pluginId}'),
+                'plugins', (SELECT count(*)::int FROM "plugins" WHERE "id" = '${pluginId}')
+              ) AS counts,
+              (SELECT "manifest_json" FROM "plugins" WHERE "id" = '${pluginId}') AS manifest,
+              (SELECT "config_json" FROM "plugin_config" WHERE "plugin_id" = '${pluginId}') AS config,
+              (SELECT "value_json" FROM "plugin_state" WHERE "plugin_id" = '${pluginId}') AS state,
+              (SELECT "data" FROM "plugin_entities" WHERE "plugin_id" = '${pluginId}') AS entity,
+              (SELECT jsonb_build_object('schedule', "schedule", 'status', "status") FROM "plugin_jobs" WHERE "id" = '${jobId}') AS job,
+              (SELECT "logs" FROM "plugin_job_runs" WHERE "plugin_id" = '${pluginId}') AS job_logs,
+              (SELECT jsonb_build_object('payload', "payload", 'headers', "headers") FROM "plugin_webhook_deliveries" WHERE "plugin_id" = '${pluginId}') AS webhook,
+              (SELECT "settings_json" FROM "plugin_organization_settings" WHERE "plugin_id" = '${pluginId}') AS org_settings,
+              (SELECT jsonb_build_object('message', "message", 'meta', "meta") FROM "plugin_logs" WHERE "plugin_id" = '${pluginId}') AS log_entry
+          `);
+                const foreignKeys = await readSql.unsafe(`
+            SELECT conname
+            FROM pg_constraint
+            WHERE contype = 'f'
+              AND conrelid::regclass::text LIKE 'plugin%'
+            ORDER BY conname
+          `);
+                return {
+                    tables: tables.map((row) => row.table_name),
+                    data,
+                    foreignKeys: foreignKeys.map((row) => row.conname),
+                };
+            }
+            finally {
+                await readSql.end();
+            }
+        };
+        const beforeRestart = await readSnapshot(connectionString);
+        expect(beforeRestart.tables).toEqual(expect.arrayContaining(legacyTables));
+        expect(beforeRestart.data?.counts).toEqual(Object.fromEntries(legacyTables.map((table) => [table, 1])));
+        expect(beforeRestart.foreignKeys.length).toBeGreaterThanOrEqual(10);
+        const instance = runningInstances.at(-1);
+        expect(instance).toBeDefined();
+        await instance.stop();
+        await instance.start();
+        await expect(applyPendingMigrations(connectionString)).resolves.toBeUndefined();
+        expect(await readSnapshot(connectionString)).toEqual(beforeRestart);
+        const backupDir = fs.mkdtempSync(path.join(os.tmpdir(), "rudder-legacy-plugin-backup-"));
+        tempPaths.push(backupDir);
+        const backup = await runDatabaseBackup({
+            connectionString,
+            backupDir,
+            retentionDays: 1,
+            includeMigrationJournal: true,
+        });
+        const restoreAdminUrl = new URL(connectionString);
+        restoreAdminUrl.pathname = "/postgres";
+        await ensurePostgresDatabase(restoreAdminUrl.toString(), "rudder_restore");
+        const restoreUrl = new URL(connectionString);
+        restoreUrl.pathname = "/rudder_restore";
+        await runDatabaseRestore({ connectionString: restoreUrl.toString(), backupFile: backup.backupFile });
+        expect((await inspectMigrations(restoreUrl.toString())).status).toBe("upToDate");
+        expect(await readSnapshot(restoreUrl.toString())).toEqual(beforeRestart);
+    }, 60_000);
     it("completes migration 0100 when an older version already created the alias table", async () => {
         const connectionString = await createTempDatabase();
         await applyPendingMigrations(connectionString);
@@ -333,7 +647,7 @@ describe("applyPendingMigrations", () => {
         finally {
             await verifySql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
     it("reapplies consolidated migration 0102 over the legacy 0102-0104 feature shape", async () => {
         const connectionString = await createTempDatabase();
         const { manifest, migrationsFolder } = createLegacyTerminalMigrationsFolder();
@@ -429,6 +743,15 @@ describe("applyPendingMigrations", () => {
                 "0140_faulty_kitty_pryde.sql",
                 "0141_product_analytics_revision_origin.sql",
                 "0142_product_analytics_quality_counters.sql",
+                "0143_goal_contract.sql",
+                "0144_eminent_umar.sql",
+                "0145_public_nehzno.sql",
+                "0146_medical_roulette.sql",
+                "0147_github_mcp_provider.sql",
+                "0148_chat_message_transcript_entries.sql",
+                "0149_app_builder_verified_source_ready.sql",
+                "0150_rudder_plugins_v1.sql",
+                "0151_agent_issue_creation_requests.sql",
             ],
             reason: "pending-migrations",
         });
@@ -488,7 +811,7 @@ describe("applyPendingMigrations", () => {
         finally {
             await verifySql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(40_000));
     it("upgrades databases that applied the legacy 0102 chat runtime controls migration", async () => {
         const connectionString = await createTempDatabase();
         const { historicalHash, migrationsFolder } = createLegacyChatRuntimeControlsMigrationsFolder();
@@ -586,6 +909,15 @@ describe("applyPendingMigrations", () => {
                 "0140_faulty_kitty_pryde.sql",
                 "0141_product_analytics_revision_origin.sql",
                 "0142_product_analytics_quality_counters.sql",
+                "0143_goal_contract.sql",
+                "0144_eminent_umar.sql",
+                "0145_public_nehzno.sql",
+                "0146_medical_roulette.sql",
+                "0147_github_mcp_provider.sql",
+                "0148_chat_message_transcript_entries.sql",
+                "0149_app_builder_verified_source_ready.sql",
+                "0150_rudder_plugins_v1.sql",
+                "0151_agent_issue_creation_requests.sql",
             ],
             reason: "pending-migrations",
         });
@@ -620,7 +952,7 @@ describe("applyPendingMigrations", () => {
         finally {
             await verifySql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(40_000));
     it("upgrades 0102 heartbeat runs with durable session lineage columns", async () => {
         const connectionString = await createTempDatabase();
         const migrationsThrough0102 = createCurrentMigrationsFolderThrough(102);
@@ -683,7 +1015,7 @@ describe("applyPendingMigrations", () => {
         finally {
             await verifySql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(40_000));
     it("reconciles legacy chat control states before creating active-generation constraints", async () => {
         const connectionString = await createTempDatabase();
         const migrationsThrough0103 = createCurrentMigrationsFolderThrough(103);
@@ -947,7 +1279,7 @@ describe("applyPendingMigrations", () => {
         finally {
             await verifySql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
     it("rolls back migration 0100 when a legacy alias conflicts with another organization route", async () => {
         const connectionString = await createTempDatabase();
         await applyPendingMigrations(connectionString);
@@ -1021,7 +1353,7 @@ describe("applyPendingMigrations", () => {
         finally {
             await verifySql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
     it("replays migration 0044 safely when its schema changes already exist", async () => {
         const connectionString = await createTempDatabase();
         await applyPendingMigrations(connectionString);
@@ -1050,7 +1382,7 @@ describe("applyPendingMigrations", () => {
         await applyPendingMigrations(connectionString);
         const finalState = await inspectMigrations(connectionString);
         expect(finalState.status).toBe("upToDate");
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
     it("replays migration 0063 safely when the experimental settings column is already absent", async () => {
         const connectionString = await createTempDatabase();
         await applyPendingMigrations(connectionString);
@@ -1079,7 +1411,7 @@ describe("applyPendingMigrations", () => {
         await applyPendingMigrations(connectionString);
         const finalState = await inspectMigrations(connectionString);
         expect(finalState.status).toBe("upToDate");
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
     it("repairs missing migration history when the schema changes are still directly verifiable", async () => {
         const connectionString = await createTempDatabase();
         await applyPendingMigrations(connectionString);
@@ -1113,7 +1445,7 @@ describe("applyPendingMigrations", () => {
         await applyPendingMigrations(connectionString);
         const finalState = await inspectMigrations(connectionString);
         expect(finalState.status).toBe("upToDate");
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
     it("normalizes legacy adapter column names before using an up-to-date migration journal", async () => {
         const connectionString = await createTempDatabase();
         await applyPendingMigrations(connectionString);
@@ -1132,6 +1464,15 @@ describe("applyPendingMigrations", () => {
         }
         const driftedState = await inspectMigrations(connectionString);
         expect(driftedState.status).toBe("upToDate");
+        await expect(listLegacyColumnRenames(connectionString)).resolves.toEqual([
+            "agents.adapter_type->agent_runtime_type",
+            "agents.adapter_config->agent_runtime_config",
+            "agent_runtime_state.adapter_type->agent_runtime_type",
+            "agent_task_sessions.adapter_type->agent_runtime_type",
+            "join_requests.adapter_type->agent_runtime_type",
+            "finance_events.execution_adapter_type->execution_agent_runtime_type",
+            "issues.assignee_adapter_overrides->assignee_agent_runtime_overrides",
+        ]);
         await applyPendingMigrations(connectionString);
         const verifySql = postgres(connectionString, { max: 1, onnotice: () => { } });
         try {
@@ -1164,7 +1505,7 @@ describe("applyPendingMigrations", () => {
         finally {
             await verifySql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
     it("keeps a missing migration pending until the schema change really exists", async () => {
         const connectionString = await createTempDatabase();
         await applyPendingMigrations(connectionString);
@@ -1209,7 +1550,59 @@ describe("applyPendingMigrations", () => {
         finally {
             await verifySql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
+    it("rolls back every legacy column rename when a later rename fails", async () => {
+        const connectionString = await createTempDatabase();
+        await applyPendingMigrations(connectionString);
+        const sql = postgres(connectionString, { max: 1, onnotice: () => { } });
+        try {
+            await sql.unsafe(`ALTER TABLE "agents" RENAME COLUMN "agent_runtime_type" TO "adapter_type"`);
+            await sql.unsafe(`ALTER TABLE "agents" RENAME COLUMN "agent_runtime_config" TO "adapter_config"`);
+            await sql.unsafe(`ALTER TABLE "agent_runtime_state" RENAME COLUMN "agent_runtime_type" TO "adapter_type"`);
+            await sql.unsafe(`
+          CREATE FUNCTION fail_legacy_column_rename() RETURNS event_trigger
+          LANGUAGE plpgsql AS $$
+          BEGIN
+            IF current_query() LIKE '%"agent_runtime_state"%' THEN
+              RAISE EXCEPTION 'intentional legacy rename failure';
+            END IF;
+          END;
+          $$
+        `);
+            await sql.unsafe(`
+          CREATE EVENT TRIGGER fail_legacy_column_rename_trigger
+          ON ddl_command_start
+          EXECUTE FUNCTION fail_legacy_column_rename()
+        `);
+        }
+        finally {
+            await sql.end();
+        }
+        await expect(normalizeLegacyColumnNames(connectionString)).rejects.toThrow("intentional legacy rename failure");
+        const cleanupSql = postgres(connectionString, { max: 1, onnotice: () => { } });
+        try {
+            await cleanupSql.unsafe(`DROP EVENT TRIGGER fail_legacy_column_rename_trigger`);
+            await cleanupSql.unsafe(`DROP FUNCTION fail_legacy_column_rename()`);
+            const columns = await cleanupSql.unsafe(`
+          SELECT table_name, column_name
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+            AND table_name IN ('agents', 'agent_runtime_state')
+            AND column_name IN (
+              'agent_runtime_type', 'agent_runtime_config', 'adapter_type', 'adapter_config'
+            )
+          ORDER BY table_name, column_name
+        `);
+            expect(columns).toEqual([
+                { table_name: "agent_runtime_state", column_name: "adapter_type" },
+                { table_name: "agents", column_name: "adapter_config" },
+                { table_name: "agents", column_name: "adapter_type" },
+            ]);
+        }
+        finally {
+            await cleanupSql.end();
+        }
+    }, migrationTestTimeout(20_000));
     it("enforces a unique board_api_keys.key_hash after migration 0044", async () => {
         const connectionString = await createTempDatabase();
         await applyPendingMigrations(connectionString);
@@ -1231,6 +1624,6 @@ describe("applyPendingMigrations", () => {
         finally {
             await sql.end();
         }
-    }, 20_000);
+    }, migrationTestTimeout(20_000));
 });
 //# sourceMappingURL=client.test.js.map