@sealkeeper/schema 0.4.4 → 0.4.6

package/dist/db/client.d.ts

@@ -1,6 +1,11 @@
+import type { Logger } from 'drizzle-orm/logger';
 import postgres from 'postgres';
 export type DbOptions = {
     max?: number;
+    statementTimeoutMs?: number;
+    lockTimeoutMs?: number;
+    idleInTxTimeoutMs?: number;
+    logger?: Logger;
 };
 export declare function createDb(url: string, options?: DbOptions): import("drizzle-orm/postgres-js").PostgresJsDatabase<{
     operators: import("drizzle-orm/pg-core").PgTableWithColumns<{
@@ -92,6 +97,91 @@ export declare function createDb(url: string, options?: DbOptions): import("driz
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            slug: import("drizzle-orm/pg-core").PgColumn<{
+                name: "slug";
+                tableName: "operators";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            displayName: import("drizzle-orm/pg-core").PgColumn<{
+                name: "display_name";
+                tableName: "operators";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            displayNameKey: import("drizzle-orm/pg-core").PgColumn<{
+                name: "display_name_key";
+                tableName: "operators";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            slugChangedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "slug_changed_at";
+                tableName: "operators";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            slugNoticeDismissedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "slug_notice_dismissed_at";
+                tableName: "operators";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
             accountCreatedAt: import("drizzle-orm/pg-core").PgColumn<{
                 name: "account_created_at";
                 tableName: "operators";
@@ -109,6 +199,40 @@ export declare function createDb(url: string, options?: DbOptions): import("driz
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            termsVersion: import("drizzle-orm/pg-core").PgColumn<{
+                name: "terms_version";
+                tableName: "operators";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            privacyVersion: import("drizzle-orm/pg-core").PgColumn<{
+                name: "privacy_version";
+                tableName: "operators";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;
@@ -252,6 +376,42 @@ export declare function createDb(url: string, options?: DbOptions): import("driz
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            runtime: import("drizzle-orm/pg-core").PgColumn<{
+                name: "runtime";
+                tableName: "agents";
+                dataType: "string";
+                columnType: "PgText";
+                data: "claude-code" | "codex" | "cursor" | "gemini-cli" | "mastra" | "openclaw" | "other" | "unknown";
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: "claude-code" | "codex" | "cursor" | "gemini-cli" | "mastra" | "openclaw" | "other" | "unknown";
+            }>;
+            runtimeIssuedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "runtime_issued_at";
+                tableName: "agents";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
             dirtySince: import("drizzle-orm/pg-core").PgColumn<{
                 name: "dirty_since";
                 tableName: "agents";
@@ -303,6 +463,125 @@ export declare function createDb(url: string, options?: DbOptions): import("driz
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            termsVersion: import("drizzle-orm/pg-core").PgColumn<{
+                name: "terms_version";
+                tableName: "agents";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            privacyVersion: import("drizzle-orm/pg-core").PgColumn<{
+                name: "privacy_version";
+                tableName: "agents";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            eventCount: import("drizzle-orm/pg-core").PgColumn<{
+                name: "event_count";
+                tableName: "agents";
+                dataType: "number";
+                columnType: "PgBigInt53";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            sessionCount: import("drizzle-orm/pg-core").PgColumn<{
+                name: "session_count";
+                tableName: "agents";
+                dataType: "number";
+                columnType: "PgBigInt53";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            toolCallCount: import("drizzle-orm/pg-core").PgColumn<{
+                name: "tool_call_count";
+                tableName: "agents";
+                dataType: "number";
+                columnType: "PgBigInt53";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            incidentCount: import("drizzle-orm/pg-core").PgColumn<{
+                name: "incident_count";
+                tableName: "agents";
+                dataType: "number";
+                columnType: "PgBigInt53";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            lastSeenAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "last_seen_at";
+                tableName: "agents";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;
@@ -767,6 +1046,66 @@ export declare function createDb(url: string, options?: DbOptions): import("driz
                     text: string;
                 };
             }>;
+            failedSubmits: import("drizzle-orm/pg-core").PgColumn<{
+                name: "failed_submits";
+                tableName: "tasks";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            barredAgentIds: import("drizzle-orm/pg-core").PgColumn<{
+                name: "barred_agent_ids";
+                tableName: "tasks";
+                dataType: "array";
+                columnType: "PgArray";
+                data: string[];
+                driverParam: string | string[];
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: import("drizzle-orm").Column<{
+                    name: "barred_agent_ids";
+                    tableName: "tasks";
+                    dataType: "string";
+                    columnType: "PgText";
+                    data: string;
+                    driverParam: string;
+                    notNull: false;
+                    hasDefault: false;
+                    isPrimaryKey: false;
+                    isAutoincrement: false;
+                    hasRuntimeDefault: false;
+                    enumValues: [string, ...string[]];
+                    baseColumn: never;
+                    identity: undefined;
+                    generated: undefined;
+                }, {}, {}>;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
+                    name: "barred_agent_ids";
+                    dataType: 'string';
+                    columnType: 'PgText';
+                    data: string;
+                    enumValues: [string, ...string[]];
+                    driverParam: string;
+                }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
+                size: undefined;
+            }>;
             expiresAt: import("drizzle-orm/pg-core").PgColumn<{
                 name: "expires_at";
                 tableName: "tasks";
@@ -2123,6 +2462,98 @@ export declare function createDb(url: string, options?: DbOptions): import("driz
         };
         dialect: 'pg';
     }>;
+    operatorSlugs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "operator_slugs";
+        schema: undefined;
+        columns: {
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "created_at";
+                tableName: "operator_slugs";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "updated_at";
+                tableName: "operator_slugs";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "operator_slugs";
+                dataType: "number";
+                columnType: "PgBigSerial53";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            operatorId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "operator_id";
+                tableName: "operator_slugs";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            oldSlug: import("drizzle-orm/pg-core").PgColumn<{
+                name: "old_slug";
+                tableName: "operator_slugs";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: 'pg';
+    }>;
 }> & {
     $client: postgres.Sql<{}>;
 };

package/dist/db/client.js

@@ -7,6 +7,7 @@ import { credentials } from './credentials.js';
 import { deletedOperators } from './deleted-operators.js';
 import { events } from './events.js';
 import { feedItems } from './feed-items.js';
+import { operatorSlugs } from './operator-slugs.js';
 import { operators } from './operators.js';
 import { quotaCounters } from './quota-counters.js';
 import { ratings } from './ratings.js';
@@ -30,9 +31,31 @@ const schema = {
     agentRenames,
     agentMilestones,
     deletedOperators,
+    operatorSlugs,
 };
 export function createDb(url, options = {}) {
     const [conn, pgOptions] = pgArgs(url);
     const max = options.max === undefined ? {} : { max: options.max };
-    return drizzle(postgres(conn, { ...pgOptions, ...max }), { schema });
+    const connection = timeoutParameters(options);
+    const logger = options.logger === undefined ? {} : { logger: options.logger };
+    return drizzle(postgres(conn, {
+        ...pgOptions,
+        ...max,
+        ...(Object.keys(connection).length > 0 ? { connection } : {}),
+    }), { schema, ...logger });
+}
+// The postgres.js connection parameters for the timeouts that are set. A
+// bare number is read by Postgres as milliseconds.
+function timeoutParameters(options) {
+    const params = {};
+    if (options.statementTimeoutMs !== undefined) {
+        params.statement_timeout = options.statementTimeoutMs;
+    }
+    if (options.lockTimeoutMs !== undefined) {
+        params.lock_timeout = options.lockTimeoutMs;
+    }
+    if (options.idleInTxTimeoutMs !== undefined) {
+        params.idle_in_transaction_session_timeout = options.idleInTxTimeoutMs;
+    }
+    return params;
 }

package/dist/db/events.js

@@ -1,3 +1,4 @@
+import { sql } from 'drizzle-orm';
 import { bigint, index, jsonb, pgTable, text, timestamp, unique, uuid, } from 'drizzle-orm/pg-core';
 import { agents } from './agents.js';
 // Append only. No created_at or updated_at, received_at is the server timestamp.
@@ -31,4 +32,10 @@ export const events = pgTable('events', {
     // Range reads on the server clock across agents. The stats count of
     // the last 24 hours and the evidence counts over a window.
     index('events_received_at_agent_id_idx').on(t.receivedAt, t.agentId),
+    // The single agent answer reads the model from the agent's newest usage
+    // event, newest by the server's id. Partial, so an agent with many
+    // events and few usage events is still one short index walk.
+    index('events_agent_id_usage_idx')
+        .on(t.agentId, t.id.desc())
+        .where(sql `${t.type} = 'usage'`),
 ]);

package/dist/db/index.d.ts

@@ -4,11 +4,15 @@ import type { credentials } from './credentials.js';
 import type { deletedOperators } from './deleted-operators.js';
 import type { events } from './events.js';
 import type { feedItems } from './feed-items.js';
+import type { operatorIdentities } from './operator-identities.js';
+import type { operatorLevelGrants } from './operator-level-grants.js';
+import type { operatorSlugs } from './operator-slugs.js';
 import type { operators } from './operators.js';
 import type { quotaCounters } from './quota-counters.js';
 import type { ratings } from './ratings.js';
 import type { scores } from './scores.js';
 import type { standing } from './standing.js';
+import type { taskClaimFailures } from './task-claim-failures.js';
 import type { taskOutcomes } from './task-outcomes.js';
 import type { tasks } from './tasks.js';
 export { and, asc, desc, eq, gt, inArray, isNotNull, isNull, lt, lte, max, ne, notInArray, or, type SQL, sql, } from 'drizzle-orm';
@@ -23,11 +27,15 @@ export { deletedOperators } from './deleted-operators.js';
 export { events } from './events.js';
 export { feedItems } from './feed-items.js';
 export { migrationsFolder, runMigrations } from './migrator.js';
+export { operatorIdentities } from './operator-identities.js';
+export { operatorLevelGrants } from './operator-level-grants.js';
+export { operatorSlugs } from './operator-slugs.js';
 export { operators } from './operators.js';
 export { quotaCounters } from './quota-counters.js';
 export { ratings } from './ratings.js';
 export { scores } from './scores.js';
 export { type StoredCounts, type StoredLevelInputs, standing, } from './standing.js';
+export { taskClaimFailures } from './task-claim-failures.js';
 export { taskOutcomes } from './task-outcomes.js';
 export { tasks } from './tasks.js';
 export { timestamps } from './timestamps.js';
@@ -40,6 +48,8 @@ export type Task = typeof tasks.$inferSelect;
 export type NewTask = typeof tasks.$inferInsert;
 export type TaskOutcome = typeof taskOutcomes.$inferSelect;
 export type NewTaskOutcome = typeof taskOutcomes.$inferInsert;
+export type TaskClaimFailure = typeof taskClaimFailures.$inferSelect;
+export type NewTaskClaimFailure = typeof taskClaimFailures.$inferInsert;
 export type Rating = typeof ratings.$inferSelect;
 export type NewRating = typeof ratings.$inferInsert;
 export type Credential = typeof credentials.$inferSelect;
@@ -56,5 +66,11 @@ export type FeedItem = typeof feedItems.$inferSelect;
 export type NewFeedItem = typeof feedItems.$inferInsert;
 export type AgentMilestone = typeof agentMilestones.$inferSelect;
 export type NewAgentMilestone = typeof agentMilestones.$inferInsert;
+export type OperatorSlugRow = typeof operatorSlugs.$inferSelect;
+export type NewOperatorSlugRow = typeof operatorSlugs.$inferInsert;
 export type DeletedOperator = typeof deletedOperators.$inferSelect;
 export type NewDeletedOperator = typeof deletedOperators.$inferInsert;
+export type OperatorLevelGrant = typeof operatorLevelGrants.$inferSelect;
+export type NewOperatorLevelGrant = typeof operatorLevelGrants.$inferInsert;
+export type OperatorIdentity = typeof operatorIdentities.$inferSelect;
+export type NewOperatorIdentity = typeof operatorIdentities.$inferInsert;

package/dist/db/index.js

@@ -13,11 +13,15 @@ export { deletedOperators } from './deleted-operators.js';
 export { events } from './events.js';
 export { feedItems } from './feed-items.js';
 export { migrationsFolder, runMigrations } from './migrator.js';
+export { operatorIdentities } from './operator-identities.js';
+export { operatorLevelGrants } from './operator-level-grants.js';
+export { operatorSlugs } from './operator-slugs.js';
 export { operators } from './operators.js';
 export { quotaCounters } from './quota-counters.js';
 export { ratings } from './ratings.js';
 export { scores } from './scores.js';
 export { standing, } from './standing.js';
+export { taskClaimFailures } from './task-claim-failures.js';
 export { taskOutcomes } from './task-outcomes.js';
 export { tasks } from './tasks.js';
 export { timestamps } from './timestamps.js';

package/dist/db/migrate.js

@@ -10,7 +10,11 @@ if (!url) {
     process.exit(1);
 }
 try {
-    await runMigrations(url);
+    // A notice is a migration telling the operator of the database something,
+    // such as 0025 listing the operators whose slug got a suffix.
+    await runMigrations(url, {
+        onNotice: (notice) => console.log(JSON.stringify({ msg: 'migration notice', notice })),
+    });
     console.log(JSON.stringify({ msg: 'migrations applied' }));
 }
 catch (err) {

package/dist/db/migrator.d.ts

@@ -1,2 +1,6 @@
 export declare const migrationsFolder: string;
-export declare function runMigrations(databaseUrl: string): Promise<void>;
+export declare const MIGRATION_LOCK_TIMEOUT_MS = 5000;
+export declare const MIGRATION_STATEMENT_TIMEOUT_MS = 120000;
+export declare function runMigrations(databaseUrl: string, { onNotice }?: {
+    onNotice?: (message: string) => void;
+}): Promise<void>;

package/dist/db/migrator.js

@@ -8,9 +8,25 @@ import postgres from 'postgres';
 import { pgArgs } from './url.js';
 // Resolves to packages/schema/drizzle from both src/db and dist/db.
 export const migrationsFolder = fileURLToPath(new URL('../../drizzle', import.meta.url));
-export async function runMigrations(databaseUrl) {
+// A migration that waits on a lock, such as an ALTER TABLE queued behind the
+// scoring run's transaction, fails after MIGRATION_LOCK_TIMEOUT_MS instead of
+// waiting with no bound and blocking every query queued behind it. One
+// statement may run for MIGRATION_STATEMENT_TIMEOUT_MS (VOU-205).
+export const MIGRATION_LOCK_TIMEOUT_MS = 5_000;
+export const MIGRATION_STATEMENT_TIMEOUT_MS = 120_000;
+// onNotice receives the text of each notice a migration raises, such as
+// the operators 0025 gave a suffixed slug. Silent when left out.
+export async function runMigrations(databaseUrl, { onNotice } = {}) {
     const [connUrl, options] = pgArgs(databaseUrl);
-    const sql = postgres(connUrl, { ...options, max: 1, onnotice: () => { } });
+    const sql = postgres(connUrl, {
+        ...options,
+        max: 1,
+        connection: {
+            lock_timeout: MIGRATION_LOCK_TIMEOUT_MS,
+            statement_timeout: MIGRATION_STATEMENT_TIMEOUT_MS,
+        },
+        onnotice: (notice) => onNotice?.(notice.message),
+    });
     try {
         await migrate(drizzle(sql), { migrationsFolder });
     }