@cat-factory/node-server 0.6.0

package/dist/repositories/drizzle.js

@@ -0,0 +1,1872 @@
+import { LLM_WARNING_FINISH_REASONS } from '@cat-factory/kernel';
+import { blockInsertValues, blockPatchToColumns, rowToBlock, rowToExecution, executionToDetail, rowToPipeline, rowToWorkspace, } from '@cat-factory/server';
+import { and, desc, eq, gte, inArray, isNull, lt, or, sql } from 'drizzle-orm';
+import { accountInvitations, accounts, agentRuns, blocks, consensusSessions, emailConnections, llmCallMetrics, memberships, mergeThresholdPresets, repoBlueprints, pipelineScheduleRuns, pipelineSchedules, pipelines, requirementReviews, clarityReviews, services, tokenUsage, trackerSettings, userIdentities, users, workspaceFragmentDefaults, workspaceModelDefaults, workspaceServices, workspaces, } from '../db/schema.js';
+// Drizzle/Postgres implementations of the core kernel repository ports. The
+// row<->domain mapping is the SAME shared mapping the Cloudflare D1 repos use
+// (@cat-factory/server), so behaviour matches across stores; this layer only owns
+// the Drizzle queries. This is the single persistence used in dev, test and prod.
+class DrizzleWorkspaceRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async listVisible(scope) {
+        if (scope === null) {
+            const rows = await this.db.select().from(workspaces).orderBy(desc(workspaces.created_at));
+            return rows.map(rowToWorkspace);
+        }
+        const legacy = and(isNull(workspaces.account_id), eq(workspaces.owner_user_id, scope.ownerUserId));
+        const where = scope.accountIds.length > 0
+            ? or(inArray(workspaces.account_id, scope.accountIds), legacy)
+            : legacy;
+        const rows = await this.db
+            .select()
+            .from(workspaces)
+            .where(where)
+            .orderBy(desc(workspaces.created_at));
+        return rows.map(rowToWorkspace);
+    }
+    async get(id) {
+        const [row] = await this.db.select().from(workspaces).where(eq(workspaces.id, id));
+        return row ? rowToWorkspace(row) : null;
+    }
+    async ownerOf(id) {
+        const [row] = await this.db
+            .select({ owner: workspaces.owner_user_id })
+            .from(workspaces)
+            .where(eq(workspaces.id, id));
+        return row ? row.owner : undefined;
+    }
+    async accountOf(id) {
+        const [row] = await this.db
+            .select({ account: workspaces.account_id })
+            .from(workspaces)
+            .where(eq(workspaces.id, id));
+        return row ? row.account : undefined;
+    }
+    async create(workspace, ownerUserId, accountId) {
+        await this.db.insert(workspaces).values({
+            id: workspace.id,
+            name: workspace.name,
+            description: workspace.description,
+            created_at: workspace.createdAt,
+            owner_user_id: ownerUserId,
+            account_id: accountId,
+        });
+    }
+    async rename(id, name) {
+        await this.db.update(workspaces).set({ name }).where(eq(workspaces.id, id));
+    }
+    async setDescription(id, description) {
+        await this.db.update(workspaces).set({ description }).where(eq(workspaces.id, id));
+    }
+    async delete(id) {
+        await this.db.transaction(async (tx) => {
+            await tx.delete(agentRuns).where(eq(agentRuns.workspace_id, id));
+            await tx.delete(blocks).where(eq(blocks.workspace_id, id));
+            await tx.delete(pipelines).where(eq(pipelines.workspace_id, id));
+            await tx.delete(workspaces).where(eq(workspaces.id, id));
+        });
+    }
+}
+class DrizzleBlockRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async listByWorkspace(workspaceId) {
+        const rows = await this.db.select().from(blocks).where(eq(blocks.workspace_id, workspaceId));
+        return rows.map(rowToBlock);
+    }
+    async listByService(serviceId) {
+        const rows = await this.db.select().from(blocks).where(eq(blocks.service_id, serviceId));
+        return rows.map(rowToBlock);
+    }
+    async listByServices(serviceIds) {
+        if (serviceIds.length === 0)
+            return [];
+        const out = [];
+        // Chunk the IN list to stay well under the bind-parameter limit.
+        for (let i = 0; i < serviceIds.length; i += 500) {
+            const rows = await this.db
+                .select()
+                .from(blocks)
+                .where(inArray(blocks.service_id, serviceIds.slice(i, i + 500)));
+            for (const row of rows)
+                out.push(rowToBlock(row));
+        }
+        return out;
+    }
+    async get(workspaceId, id) {
+        const [row] = await this.db
+            .select()
+            .from(blocks)
+            .where(and(eq(blocks.workspace_id, workspaceId), eq(blocks.id, id)));
+        return row ? rowToBlock(row) : null;
+    }
+    async findById(blockId) {
+        const [row] = await this.db.select().from(blocks).where(eq(blocks.id, blockId)).limit(1);
+        if (!row)
+            return null;
+        return {
+            workspaceId: row.workspace_id,
+            serviceId: row.service_id ?? null,
+            block: rowToBlock(row),
+        };
+    }
+    async insert(workspaceId, block, serviceId) {
+        await this.db.insert(blocks).values({
+            workspace_id: workspaceId,
+            service_id: serviceId ?? null,
+            ...blockInsertValues(block),
+        });
+    }
+    async update(workspaceId, id, patch) {
+        const set = blockPatchToColumns(patch);
+        if (Object.keys(set).length === 0)
+            return;
+        await this.db
+            .update(blocks)
+            .set(set)
+            .where(and(eq(blocks.workspace_id, workspaceId), eq(blocks.id, id)));
+    }
+    async setService(workspaceId, ids, serviceId) {
+        if (ids.length === 0)
+            return;
+        await this.db
+            .update(blocks)
+            .set({ service_id: serviceId })
+            .where(and(eq(blocks.workspace_id, workspaceId), inArray(blocks.id, ids)));
+    }
+    async deleteMany(workspaceId, ids) {
+        if (ids.length === 0)
+            return;
+        await this.db
+            .delete(blocks)
+            .where(and(eq(blocks.workspace_id, workspaceId), inArray(blocks.id, ids)));
+    }
+}
+class DrizzlePipelineRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async listByWorkspace(workspaceId) {
+        const rows = await this.db
+            .select()
+            .from(pipelines)
+            .where(eq(pipelines.workspace_id, workspaceId))
+            // Order by the monotonic insert `seq` so the catalog comes back in the curated
+            // `seedPipelines()` order it was inserted in (Postgres gives no row order without
+            // ORDER BY) — deterministic snapshots, a stable default `pipelines[0]`, and parity
+            // with the Cloudflare facade's `ORDER BY rowid`.
+            .orderBy(pipelines.seq);
+        return rows.map(rowToPipeline);
+    }
+    async get(workspaceId, id) {
+        const [row] = await this.db
+            .select()
+            .from(pipelines)
+            .where(and(eq(pipelines.workspace_id, workspaceId), eq(pipelines.id, id)));
+        return row ? rowToPipeline(row) : null;
+    }
+    async insert(workspaceId, pipeline) {
+        await this.db.insert(pipelines).values({
+            workspace_id: workspaceId,
+            id: pipeline.id,
+            name: pipeline.name,
+            agent_kinds: JSON.stringify(pipeline.agentKinds),
+            gates: pipeline.gates ? JSON.stringify(pipeline.gates) : null,
+            thresholds: pipeline.thresholds ? JSON.stringify(pipeline.thresholds) : null,
+            enabled: pipeline.enabled ? JSON.stringify(pipeline.enabled) : null,
+            consensus: pipeline.consensus ? JSON.stringify(pipeline.consensus) : null,
+            builtin: pipeline.builtin ? 1 : null,
+        });
+    }
+    async update(workspaceId, pipeline) {
+        // UPDATE in place preserves the row's `seq`, so an edited pipeline keeps its place
+        // in the catalog order. `builtin` is immutable, so it is not rewritten.
+        await this.db
+            .update(pipelines)
+            .set({
+            name: pipeline.name,
+            agent_kinds: JSON.stringify(pipeline.agentKinds),
+            gates: pipeline.gates ? JSON.stringify(pipeline.gates) : null,
+            thresholds: pipeline.thresholds ? JSON.stringify(pipeline.thresholds) : null,
+            enabled: pipeline.enabled ? JSON.stringify(pipeline.enabled) : null,
+            consensus: pipeline.consensus ? JSON.stringify(pipeline.consensus) : null,
+        })
+            .where(and(eq(pipelines.workspace_id, workspaceId), eq(pipelines.id, pipeline.id)));
+    }
+    async delete(workspaceId, id) {
+        await this.db
+            .delete(pipelines)
+            .where(and(eq(pipelines.workspace_id, workspaceId), eq(pipelines.id, id)));
+    }
+}
+/** Execution runs live as `kind='execution'` rows of the unified agent_runs table. */
+class DrizzleExecutionRepository {
+    db;
+    clock;
+    constructor(db, clock) {
+        this.db = db;
+        this.clock = clock;
+    }
+    isExecution = eq(agentRuns.kind, 'execution');
+    async listByWorkspace(workspaceId) {
+        const rows = await this.db
+            .select()
+            .from(agentRuns)
+            .where(and(eq(agentRuns.workspace_id, workspaceId), this.isExecution))
+            .orderBy(agentRuns.created_at);
+        return rows.map((r) => rowToExecution(r));
+    }
+    async listByService(serviceId) {
+        const rows = await this.db
+            .select()
+            .from(agentRuns)
+            .where(and(eq(agentRuns.service_id, serviceId), this.isExecution))
+            .orderBy(agentRuns.created_at);
+        return rows.map((r) => rowToExecution(r));
+    }
+    async listByServices(serviceIds) {
+        if (serviceIds.length === 0)
+            return [];
+        const out = [];
+        // Chunk the IN list to stay well under the bind-parameter limit.
+        for (let i = 0; i < serviceIds.length; i += 500) {
+            const rows = await this.db
+                .select()
+                .from(agentRuns)
+                .where(and(inArray(agentRuns.service_id, serviceIds.slice(i, i + 500)), this.isExecution))
+                .orderBy(agentRuns.created_at);
+            for (const r of rows)
+                out.push(rowToExecution(r));
+        }
+        return out;
+    }
+    async get(workspaceId, id) {
+        const [row] = await this.db
+            .select()
+            .from(agentRuns)
+            .where(and(eq(agentRuns.workspace_id, workspaceId), eq(agentRuns.id, id), this.isExecution));
+        return row ? rowToExecution(row) : null;
+    }
+    async getByBlock(workspaceId, blockId) {
+        const [row] = await this.db
+            .select()
+            .from(agentRuns)
+            .where(and(eq(agentRuns.workspace_id, workspaceId), eq(agentRuns.block_id, blockId), this.isExecution));
+        return row ? rowToExecution(row) : null;
+    }
+    async upsert(workspaceId, execution) {
+        const now = this.clock.now();
+        const detail = executionToDetail(execution);
+        // Stamp `service_id` from the run's block (subquery) so a shared service's runs surface on
+        // every board that mounts it via `listByService`; refreshed on every write so it follows a
+        // reparent that re-homes the block. Mirrors the D1 repo.
+        const serviceIdSub = sql `(SELECT ${blocks.service_id} FROM ${blocks} WHERE ${blocks.workspace_id} = ${workspaceId} AND ${blocks.id} = ${execution.blockId})`;
+        await this.db
+            .insert(agentRuns)
+            .values({
+            workspace_id: workspaceId,
+            id: execution.id,
+            kind: 'execution',
+            block_id: execution.blockId,
+            status: execution.status,
+            detail,
+            created_at: now,
+            updated_at: now,
+            workflow_instance_id: execution.id,
+            service_id: serviceIdSub,
+        })
+            // error/failure/workflow_instance_id are left out of the update so they survive
+            // normal step writes (see markFailed) — mirrors the D1 repo.
+            .onConflictDoUpdate({
+            target: [agentRuns.workspace_id, agentRuns.id],
+            set: {
+                block_id: execution.blockId,
+                status: execution.status,
+                detail,
+                updated_at: now,
+                service_id: serviceIdSub,
+            },
+        });
+    }
+    async deleteByBlock(workspaceId, blockId) {
+        await this.db
+            .delete(agentRuns)
+            .where(and(eq(agentRuns.workspace_id, workspaceId), eq(agentRuns.block_id, blockId), this.isExecution));
+    }
+    async listStale(olderThanEpochMs) {
+        const rows = await this.db
+            .select({ workspaceId: agentRuns.workspace_id, id: agentRuns.id })
+            .from(agentRuns)
+            .where(and(this.isExecution, eq(agentRuns.status, 'running'), lt(agentRuns.updated_at, olderThanEpochMs)))
+            .orderBy(agentRuns.updated_at);
+        return rows;
+    }
+    async markFailed(workspaceId, id, failure) {
+        await this.db
+            .update(agentRuns)
+            .set({
+            status: 'failed',
+            error: failure.message,
+            failure: JSON.stringify(failure),
+            updated_at: this.clock.now(),
+        })
+            .where(and(eq(agentRuns.workspace_id, workspaceId), eq(agentRuns.id, id), this.isExecution));
+    }
+}
+class DrizzleAgentRunRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getRef(workspaceId, id) {
+        const [row] = await this.db
+            .select({ kind: agentRuns.kind })
+            .from(agentRuns)
+            .where(and(eq(agentRuns.workspace_id, workspaceId), eq(agentRuns.id, id)));
+        return row ? { workspaceId, id, kind: row.kind } : null;
+    }
+    async listStale(olderThanEpochMs) {
+        const rows = await this.db
+            .select({ workspaceId: agentRuns.workspace_id, id: agentRuns.id, kind: agentRuns.kind })
+            .from(agentRuns)
+            .where(and(eq(agentRuns.status, 'running'), lt(agentRuns.updated_at, olderThanEpochMs)))
+            .orderBy(agentRuns.updated_at);
+        return rows.map((r) => ({ workspaceId: r.workspaceId, id: r.id, kind: r.kind }));
+    }
+}
+function rowToAccount(row) {
+    return {
+        id: row.id,
+        type: row.type === 'org' ? 'org' : 'personal',
+        name: row.name,
+        githubAccountLogin: row.github_account_login,
+        ownerUserId: row.owner_user_id,
+        createdAt: row.created_at,
+        ...(row.default_cloud_provider
+            ? { defaultCloudProvider: row.default_cloud_provider }
+            : {}),
+    };
+}
+class DrizzleAccountRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(id) {
+        const [row] = await this.db.select().from(accounts).where(eq(accounts.id, id));
+        return row ? rowToAccount(row) : null;
+    }
+    async create(account) {
+        await this.db.insert(accounts).values({
+            id: account.id,
+            type: account.type,
+            name: account.name,
+            github_account_login: account.githubAccountLogin,
+            owner_user_id: account.ownerUserId,
+            created_at: account.createdAt,
+            default_cloud_provider: account.defaultCloudProvider ?? null,
+        });
+    }
+    async rename(id, name) {
+        await this.db.update(accounts).set({ name }).where(eq(accounts.id, id));
+    }
+    async updateSettings(id, patch) {
+        if (!('defaultCloudProvider' in patch))
+            return;
+        await this.db
+            .update(accounts)
+            .set({ default_cloud_provider: patch.defaultCloudProvider ?? null })
+            .where(eq(accounts.id, id));
+    }
+    async findPersonalByUser(userId) {
+        const [row] = await this.db
+            .select()
+            .from(accounts)
+            .where(and(eq(accounts.type, 'personal'), eq(accounts.owner_user_id, userId)));
+        return row ? rowToAccount(row) : null;
+    }
+}
+/** Parse the CSV `roles` column into a non-empty role set (defaults to developer). */
+function parseRoles(csv) {
+    const roles = (csv ?? '')
+        .split(',')
+        .map((r) => r.trim())
+        .filter((r) => r === 'admin' || r === 'developer' || r === 'product');
+    return roles.length > 0 ? [...new Set(roles)] : ['developer'];
+}
+function rowToMembership(row) {
+    return {
+        accountId: row.account_id,
+        userId: row.user_id,
+        roles: parseRoles(row.roles),
+        createdAt: row.created_at,
+    };
+}
+class DrizzleMembershipRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async listByUser(userId) {
+        const rows = await this.db
+            .select()
+            .from(memberships)
+            .where(eq(memberships.user_id, userId))
+            .orderBy(memberships.created_at);
+        return rows.map(rowToMembership);
+    }
+    async listByAccount(accountId) {
+        const rows = await this.db
+            .select()
+            .from(memberships)
+            .where(eq(memberships.account_id, accountId))
+            .orderBy(memberships.created_at);
+        return rows.map(rowToMembership);
+    }
+    async get(accountId, userId) {
+        const [row] = await this.db
+            .select()
+            .from(memberships)
+            .where(and(eq(memberships.account_id, accountId), eq(memberships.user_id, userId)));
+        return row ? rowToMembership(row) : null;
+    }
+    async upsert(membership) {
+        await this.db
+            .insert(memberships)
+            .values({
+            account_id: membership.accountId,
+            user_id: membership.userId,
+            roles: membership.roles.join(','),
+            created_at: membership.createdAt,
+        })
+            .onConflictDoUpdate({
+            target: [memberships.account_id, memberships.user_id],
+            set: { roles: membership.roles.join(',') },
+        });
+    }
+    async remove(accountId, userId) {
+        await this.db
+            .delete(memberships)
+            .where(and(eq(memberships.account_id, accountId), eq(memberships.user_id, userId)));
+    }
+}
+function rowToUser(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        email: row.email,
+        avatarUrl: row.avatar_url,
+        createdAt: row.created_at,
+    };
+}
+function rowToIdentity(row) {
+    return {
+        userId: row.user_id,
+        provider: row.provider,
+        subject: row.subject,
+        secret: row.secret,
+        metadata: row.metadata,
+        createdAt: row.created_at,
+    };
+}
+class DrizzleUserRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(id) {
+        const [row] = await this.db.select().from(users).where(eq(users.id, id));
+        return row ? rowToUser(row) : null;
+    }
+    async create(user) {
+        await this.db.insert(users).values({
+            id: user.id,
+            name: user.name,
+            email: user.email,
+            avatar_url: user.avatarUrl,
+            created_at: user.createdAt,
+        });
+    }
+    async update(id, patch) {
+        const set = {};
+        if ('name' in patch)
+            set.name = patch.name;
+        if ('email' in patch)
+            set.email = patch.email;
+        if ('avatarUrl' in patch)
+            set.avatar_url = patch.avatarUrl;
+        if (Object.keys(set).length === 0)
+            return;
+        await this.db.update(users).set(set).where(eq(users.id, id));
+    }
+    async findByIdentity(provider, subject) {
+        const [row] = await this.db
+            .select()
+            .from(users)
+            .innerJoin(userIdentities, eq(userIdentities.user_id, users.id))
+            .where(and(eq(userIdentities.provider, provider), eq(userIdentities.subject, subject)));
+        return row ? rowToUser(row.users) : null;
+    }
+    async findByEmail(email) {
+        const [row] = await this.db
+            .select()
+            .from(users)
+            .where(eq(users.email, email.toLowerCase().trim()));
+        return row ? rowToUser(row) : null;
+    }
+    async listByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        const rows = await this.db.select().from(users).where(inArray(users.id, ids));
+        return rows.map(rowToUser);
+    }
+    async getIdentity(provider, subject) {
+        const [row] = await this.db
+            .select()
+            .from(userIdentities)
+            .where(and(eq(userIdentities.provider, provider), eq(userIdentities.subject, subject)));
+        return row ? rowToIdentity(row) : null;
+    }
+    async linkIdentity(identity) {
+        await this.db
+            .insert(userIdentities)
+            .values({
+            user_id: identity.userId,
+            provider: identity.provider,
+            subject: identity.subject,
+            secret: identity.secret,
+            metadata: identity.metadata,
+            created_at: identity.createdAt,
+        })
+            .onConflictDoUpdate({
+            target: [userIdentities.provider, userIdentities.subject],
+            set: { user_id: identity.userId, secret: identity.secret, metadata: identity.metadata },
+        });
+    }
+    async listIdentities(userId) {
+        const rows = await this.db
+            .select()
+            .from(userIdentities)
+            .where(eq(userIdentities.user_id, userId));
+        return rows.map(rowToIdentity);
+    }
+}
+function rowToInvitation(row) {
+    return {
+        id: row.id,
+        accountId: row.account_id,
+        email: row.email,
+        roles: parseRoles(row.roles),
+        tokenHash: row.token_hash,
+        invitedBy: row.invited_by,
+        status: row.status,
+        expiresAt: row.expires_at,
+        createdAt: row.created_at,
+    };
+}
+class DrizzleAccountInvitationRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(record) {
+        await this.db.insert(accountInvitations).values({
+            id: record.id,
+            account_id: record.accountId,
+            email: record.email,
+            roles: record.roles.join(','),
+            token_hash: record.tokenHash,
+            invited_by: record.invitedBy,
+            status: record.status,
+            expires_at: record.expiresAt,
+            created_at: record.createdAt,
+        });
+    }
+    async get(id) {
+        const [row] = await this.db
+            .select()
+            .from(accountInvitations)
+            .where(eq(accountInvitations.id, id));
+        return row ? rowToInvitation(row) : null;
+    }
+    async findByTokenHash(tokenHash) {
+        const [row] = await this.db
+            .select()
+            .from(accountInvitations)
+            .where(eq(accountInvitations.token_hash, tokenHash));
+        return row ? rowToInvitation(row) : null;
+    }
+    async listByAccount(accountId) {
+        const rows = await this.db
+            .select()
+            .from(accountInvitations)
+            .where(eq(accountInvitations.account_id, accountId))
+            .orderBy(desc(accountInvitations.created_at));
+        return rows.map(rowToInvitation);
+    }
+    async setStatus(id, status) {
+        await this.db.update(accountInvitations).set({ status }).where(eq(accountInvitations.id, id));
+    }
+}
+function rowToEmailConnection(row) {
+    return {
+        accountId: row.account_id,
+        provider: row.provider,
+        fromAddress: row.from_address,
+        apiKeyCipher: row.api_key_cipher,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        deletedAt: row.deleted_at,
+    };
+}
+class DrizzleEmailConnectionRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getByAccount(accountId) {
+        const [row] = await this.db
+            .select()
+            .from(emailConnections)
+            .where(and(eq(emailConnections.account_id, accountId), isNull(emailConnections.deleted_at)));
+        return row ? rowToEmailConnection(row) : null;
+    }
+    async upsert(record) {
+        await this.db
+            .insert(emailConnections)
+            .values({
+            account_id: record.accountId,
+            provider: record.provider,
+            from_address: record.fromAddress,
+            api_key_cipher: record.apiKeyCipher,
+            created_at: record.createdAt,
+            updated_at: record.updatedAt,
+            deleted_at: record.deletedAt,
+        })
+            .onConflictDoUpdate({
+            target: emailConnections.account_id,
+            set: {
+                provider: record.provider,
+                from_address: record.fromAddress,
+                api_key_cipher: record.apiKeyCipher,
+                updated_at: record.updatedAt,
+                deleted_at: record.deletedAt,
+            },
+        });
+    }
+    async softDelete(accountId, at) {
+        await this.db
+            .update(emailConnections)
+            .set({ deleted_at: at, updated_at: at })
+            .where(eq(emailConnections.account_id, accountId));
+    }
+}
+class DrizzleTokenUsageRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async record(usage) {
+        await this.db.insert(tokenUsage).values({
+            id: usage.id,
+            workspace_id: usage.workspaceId,
+            execution_id: usage.executionId,
+            agent_kind: usage.agentKind,
+            provider: usage.provider,
+            model: usage.model,
+            input_tokens: usage.inputTokens,
+            output_tokens: usage.outputTokens,
+            cost_estimate: usage.costEstimate,
+            created_at: usage.createdAt,
+        });
+    }
+    async totalsSince(epochMs) {
+        // sum() of int columns is bigint in Postgres — cast to bigint (NOT int4, which
+        // overflows past ~2.1B tokens) and coerce: node-postgres returns bigint as a
+        // string to avoid precision loss, and token totals stay well within Number's
+        // safe-integer range. Matches the 64-bit sum the D1/SQLite store returns.
+        const [row] = await this.db
+            .select({
+            input: sql `coalesce(sum(${tokenUsage.input_tokens}), 0)::bigint`,
+            output: sql `coalesce(sum(${tokenUsage.output_tokens}), 0)::bigint`,
+            cost: sql `coalesce(sum(${tokenUsage.cost_estimate}), 0)::float8`,
+        })
+            .from(tokenUsage)
+            .where(gte(tokenUsage.created_at, epochMs));
+        return {
+            inputTokens: Number(row?.input ?? 0),
+            outputTokens: Number(row?.output ?? 0),
+            costEstimate: row?.cost ?? 0,
+        };
+    }
+    async deleteOlderThan(epochMs) {
+        const deleted = await this.db
+            .delete(tokenUsage)
+            .where(lt(tokenUsage.created_at, epochMs))
+            .returning({ id: tokenUsage.id });
+        return deleted.length;
+    }
+}
+function rowToLlmMetric(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspace_id,
+        executionId: row.execution_id,
+        agentKind: row.agent_kind,
+        provider: row.provider,
+        model: row.model,
+        createdAt: row.created_at,
+        streaming: row.streaming === 1,
+        messageCount: row.message_count,
+        toolCount: row.tool_count,
+        requestMaxTokens: row.request_max_tokens,
+        promptTokens: row.prompt_tokens,
+        cachedPromptTokens: row.cached_prompt_tokens,
+        completionTokens: row.completion_tokens,
+        totalTokens: row.total_tokens,
+        finishReason: row.finish_reason,
+        upstreamMs: row.upstream_ms,
+        overheadMs: row.overhead_ms,
+        totalMs: row.total_ms,
+        ok: row.ok === 1,
+        httpStatus: row.http_status,
+        errorMessage: row.error_message,
+        promptText: row.prompt_text,
+        promptPrefixCount: row.prompt_prefix_count,
+        promptHash: row.prompt_hash,
+        responseText: row.response_text,
+        reasoningText: row.reasoning_text,
+    };
+}
+class DrizzleLlmCallMetricRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async record(metric) {
+        await this.db.insert(llmCallMetrics).values({
+            id: metric.id,
+            workspace_id: metric.workspaceId,
+            execution_id: metric.executionId,
+            agent_kind: metric.agentKind,
+            provider: metric.provider,
+            model: metric.model,
+            created_at: metric.createdAt,
+            streaming: metric.streaming ? 1 : 0,
+            message_count: metric.messageCount,
+            tool_count: metric.toolCount,
+            request_max_tokens: metric.requestMaxTokens,
+            prompt_tokens: metric.promptTokens,
+            cached_prompt_tokens: metric.cachedPromptTokens,
+            completion_tokens: metric.completionTokens,
+            total_tokens: metric.totalTokens,
+            finish_reason: metric.finishReason,
+            upstream_ms: metric.upstreamMs,
+            overhead_ms: metric.overheadMs,
+            total_ms: metric.totalMs,
+            ok: metric.ok ? 1 : 0,
+            http_status: metric.httpStatus,
+            error_message: metric.errorMessage,
+            prompt_text: metric.promptText,
+            prompt_prefix_count: metric.promptPrefixCount,
+            prompt_hash: metric.promptHash,
+            response_text: metric.responseText,
+            reasoning_text: metric.reasoningText,
+        });
+    }
+    async latestChainTip(workspaceId, executionId, agentKind) {
+        // The newest call for the conversation; one indexed row, no text columns.
+        const rows = await this.db
+            .select({
+            messageCount: llmCallMetrics.message_count,
+            promptHash: llmCallMetrics.prompt_hash,
+        })
+            .from(llmCallMetrics)
+            .where(and(eq(llmCallMetrics.workspace_id, workspaceId), eq(llmCallMetrics.execution_id, executionId), eq(llmCallMetrics.agent_kind, agentKind)))
+            // message_count breaks a same-millisecond createdAt tie in chain order (it grows
+            // monotonically as the conversation appends); id is the last resort.
+            .orderBy(desc(llmCallMetrics.created_at), desc(llmCallMetrics.message_count), desc(llmCallMetrics.id))
+            .limit(1);
+        const row = rows[0];
+        return row ? { messageCount: row.messageCount, promptHash: row.promptHash } : null;
+    }
+    async listByExecution(workspaceId, executionId, limit) {
+        const base = this.db
+            .select()
+            .from(llmCallMetrics)
+            .where(and(eq(llmCallMetrics.workspace_id, workspaceId), eq(llmCallMetrics.execution_id, executionId)))
+            .orderBy(desc(llmCallMetrics.created_at), desc(llmCallMetrics.id));
+        const rows = await (limit == null ? base : base.limit(limit));
+        return rows.map(rowToLlmMetric);
+    }
+    async summarizeByExecution(workspaceId, executionId) {
+        // Aggregate-only: selects no prompt/response text, so it stays cheap on every
+        // execution emit (it backs the live board rollups). int sums fit Number's safe
+        // range here (per-run call counts/tokens are small), so a plain ::bigint cast
+        // matching the SQLite 64-bit sum is unnecessary — totals are coerced below.
+        const reasons = [...LLM_WARNING_FINISH_REASONS];
+        const rows = await this.db
+            .select({
+            agentKind: llmCallMetrics.agent_kind,
+            calls: sql `count(*)::int`,
+            promptTokens: sql `coalesce(sum(${llmCallMetrics.prompt_tokens}), 0)::int`,
+            completionTokens: sql `coalesce(sum(${llmCallMetrics.completion_tokens}), 0)::int`,
+            peakCompletionTokens: sql `coalesce(max(${llmCallMetrics.completion_tokens}), 0)::int`,
+            maxOutputTokens: sql `max(${llmCallMetrics.request_max_tokens})`,
+            truncatedCalls: sql `coalesce(sum(case when ${llmCallMetrics.finish_reason} = 'length' then 1 else 0 end), 0)::int`,
+            upstreamMs: sql `coalesce(sum(${llmCallMetrics.upstream_ms}), 0)::int`,
+            overheadMs: sql `coalesce(sum(${llmCallMetrics.overhead_ms}), 0)::int`,
+            errors: sql `coalesce(sum(case when ${llmCallMetrics.ok} = 0 then 1 else 0 end), 0)::int`,
+            // `inArray` builds the IN-list membership: idiomatic, type-checked, and tied to
+            // the shared constant. (A raw `${...finish_reason} in ${reasons}` renders the same
+            // `in ($1, $2)` on this drizzle version; inArray just documents intent and can't
+            // silently mis-bind the array.)
+            warnings: sql `coalesce(sum(case when ${llmCallMetrics.ok} = 1 and ${inArray(llmCallMetrics.finish_reason, reasons)} then 1 else 0 end), 0)::int`,
+        })
+            .from(llmCallMetrics)
+            .where(and(eq(llmCallMetrics.workspace_id, workspaceId), eq(llmCallMetrics.execution_id, executionId)))
+            .groupBy(llmCallMetrics.agent_kind);
+        return rows.map((r) => ({
+            agentKind: r.agentKind,
+            calls: Number(r.calls),
+            promptTokens: Number(r.promptTokens),
+            completionTokens: Number(r.completionTokens),
+            peakCompletionTokens: Number(r.peakCompletionTokens),
+            maxOutputTokens: r.maxOutputTokens == null ? null : Number(r.maxOutputTokens),
+            truncatedCalls: Number(r.truncatedCalls),
+            upstreamMs: Number(r.upstreamMs),
+            overheadMs: Number(r.overheadMs),
+            errors: Number(r.errors),
+            warnings: Number(r.warnings),
+        }));
+    }
+    async deleteOlderThan(epochMs) {
+        const deleted = await this.db
+            .delete(llmCallMetrics)
+            .where(lt(llmCallMetrics.created_at, epochMs))
+            .returning({ id: llmCallMetrics.id });
+        return deleted.length;
+    }
+}
+/**
+ * A workspace's per-agent-kind default models, one row per (workspace, agent kind)
+ * in `workspace_model_defaults`. `replace` rewrites the whole map for a workspace
+ * in a transaction (delete-all then insert-each), so a kind omitted is cleared.
+ */
+class DrizzleModelDefaultsRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(workspaceId) {
+        const rows = await this.db
+            .select({
+            agentKind: workspaceModelDefaults.agent_kind,
+            modelId: workspaceModelDefaults.model_id,
+        })
+            .from(workspaceModelDefaults)
+            .where(eq(workspaceModelDefaults.workspace_id, workspaceId));
+        const map = {};
+        for (const row of rows)
+            map[row.agentKind] = row.modelId;
+        return map;
+    }
+    async getForKind(workspaceId, agentKind) {
+        const [row] = await this.db
+            .select({ modelId: workspaceModelDefaults.model_id })
+            .from(workspaceModelDefaults)
+            .where(and(eq(workspaceModelDefaults.workspace_id, workspaceId), eq(workspaceModelDefaults.agent_kind, agentKind)));
+        return row ? row.modelId : null;
+    }
+    async replace(workspaceId, defaults) {
+        const updatedAt = Date.now();
+        const values = Object.entries(defaults).map(([agentKind, modelId]) => ({
+            workspace_id: workspaceId,
+            agent_kind: agentKind,
+            model_id: modelId,
+            updated_at: updatedAt,
+        }));
+        // Rewrite the whole per-kind map atomically: clear the workspace's rows, then
+        // insert one per entry, so a reader never sees a partial map.
+        await this.db.transaction(async (tx) => {
+            await tx
+                .delete(workspaceModelDefaults)
+                .where(eq(workspaceModelDefaults.workspace_id, workspaceId));
+            if (values.length > 0)
+                await tx.insert(workspaceModelDefaults).values(values);
+        });
+    }
+}
+/**
+ * A workspace's default service-fragment selection — one row per workspace in
+ * `workspace_fragment_defaults`, the fragment ids stored as a JSON array (mirror of the
+ * D1 `D1ServiceFragmentDefaultsRepository`). `set` upserts the whole list.
+ */
+class DrizzleServiceFragmentDefaultsRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(workspaceId) {
+        const [row] = await this.db
+            .select({ fragmentIds: workspaceFragmentDefaults.fragment_ids })
+            .from(workspaceFragmentDefaults)
+            .where(eq(workspaceFragmentDefaults.workspace_id, workspaceId));
+        return row ? JSON.parse(row.fragmentIds) : [];
+    }
+    async set(workspaceId, fragmentIds) {
+        await this.db
+            .insert(workspaceFragmentDefaults)
+            .values({
+            workspace_id: workspaceId,
+            fragment_ids: JSON.stringify(fragmentIds),
+            updated_at: Date.now(),
+        })
+            .onConflictDoUpdate({
+            target: workspaceFragmentDefaults.workspace_id,
+            set: { fragment_ids: JSON.stringify(fragmentIds), updated_at: Date.now() },
+        });
+    }
+}
+function rowToSchedule(row) {
+    const recurrence = {
+        intervalHours: row.interval_hours,
+        weekdays: safeWeekdays(row.weekdays),
+        windowStartHour: row.window_start_hour,
+        windowEndHour: row.window_end_hour,
+        timezone: row.timezone,
+    };
+    return {
+        id: row.id,
+        serviceId: row.service_id,
+        blockId: row.block_id,
+        frameId: row.frame_id,
+        pipelineId: row.pipeline_id,
+        template: row.template,
+        name: row.name,
+        recurrence,
+        enabled: row.enabled === 1,
+        lastRunAt: row.last_run_at,
+        nextRunAt: row.next_run_at,
+        createdAt: row.created_at,
+    };
+}
+function safeWeekdays(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed.filter((n) => typeof n === 'number') : [];
+    }
+    catch {
+        return [];
+    }
+}
+function rowToRun(row) {
+    return {
+        id: row.id,
+        scheduleId: row.schedule_id,
+        executionId: row.execution_id,
+        status: row.status,
+        startedAt: row.started_at,
+        finishedAt: row.finished_at,
+        outcome: row.outcome,
+    };
+}
+class DrizzlePipelineScheduleRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    values(workspaceId, schedule) {
+        const r = schedule.recurrence;
+        return {
+            workspace_id: workspaceId,
+            id: schedule.id,
+            service_id: schedule.serviceId,
+            block_id: schedule.blockId,
+            frame_id: schedule.frameId,
+            pipeline_id: schedule.pipelineId,
+            template: schedule.template,
+            name: schedule.name,
+            interval_hours: r.intervalHours,
+            weekdays: JSON.stringify(r.weekdays),
+            window_start_hour: r.windowStartHour,
+            window_end_hour: r.windowEndHour,
+            timezone: r.timezone,
+            enabled: schedule.enabled ? 1 : 0,
+            last_run_at: schedule.lastRunAt,
+            next_run_at: schedule.nextRunAt,
+            created_at: schedule.createdAt,
+        };
+    }
+    async get(workspaceId, id) {
+        const [row] = await this.db
+            .select()
+            .from(pipelineSchedules)
+            .where(and(eq(pipelineSchedules.workspace_id, workspaceId), eq(pipelineSchedules.id, id)));
+        return row ? rowToSchedule(row) : null;
+    }
+    async getByBlock(workspaceId, blockId) {
+        const [row] = await this.db
+            .select()
+            .from(pipelineSchedules)
+            .where(and(eq(pipelineSchedules.workspace_id, workspaceId), eq(pipelineSchedules.block_id, blockId)));
+        return row ? rowToSchedule(row) : null;
+    }
+    async list(workspaceId) {
+        const rows = await this.db
+            .select()
+            .from(pipelineSchedules)
+            .where(eq(pipelineSchedules.workspace_id, workspaceId))
+            .orderBy(pipelineSchedules.created_at);
+        return rows.map(rowToSchedule);
+    }
+    async listByService(serviceId) {
+        const rows = await this.db
+            .select()
+            .from(pipelineSchedules)
+            .where(eq(pipelineSchedules.service_id, serviceId))
+            .orderBy(pipelineSchedules.created_at);
+        return rows.map(rowToSchedule);
+    }
+    async listByServices(serviceIds) {
+        if (serviceIds.length === 0)
+            return [];
+        const out = [];
+        // Chunk the IN list to stay well under the bind-parameter limit.
+        for (let i = 0; i < serviceIds.length; i += 500) {
+            const rows = await this.db
+                .select()
+                .from(pipelineSchedules)
+                .where(inArray(pipelineSchedules.service_id, serviceIds.slice(i, i + 500)))
+                .orderBy(pipelineSchedules.created_at);
+            for (const row of rows)
+                out.push(rowToSchedule(row));
+        }
+        return out;
+    }
+    async listDue(asOf) {
+        const rows = await this.db
+            .select()
+            .from(pipelineSchedules)
+            .where(and(eq(pipelineSchedules.enabled, 1), lt(pipelineSchedules.next_run_at, asOf + 1)))
+            .orderBy(pipelineSchedules.next_run_at);
+        return rows.map((row) => ({ workspaceId: row.workspace_id, schedule: rowToSchedule(row) }));
+    }
+    async upsert(workspaceId, schedule) {
+        const values = this.values(workspaceId, schedule);
+        await this.db
+            .insert(pipelineSchedules)
+            .values(values)
+            .onConflictDoUpdate({
+            target: [pipelineSchedules.workspace_id, pipelineSchedules.id],
+            set: {
+                service_id: values.service_id,
+                block_id: values.block_id,
+                frame_id: values.frame_id,
+                pipeline_id: values.pipeline_id,
+                template: values.template,
+                name: values.name,
+                interval_hours: values.interval_hours,
+                weekdays: values.weekdays,
+                window_start_hour: values.window_start_hour,
+                window_end_hour: values.window_end_hour,
+                timezone: values.timezone,
+                enabled: values.enabled,
+                last_run_at: values.last_run_at,
+                next_run_at: values.next_run_at,
+            },
+        });
+    }
+    async remove(workspaceId, id) {
+        await this.db
+            .delete(pipelineSchedules)
+            .where(and(eq(pipelineSchedules.workspace_id, workspaceId), eq(pipelineSchedules.id, id)));
+    }
+    async insertRun(workspaceId, run) {
+        await this.db.insert(pipelineScheduleRuns).values({
+            workspace_id: workspaceId,
+            id: run.id,
+            schedule_id: run.scheduleId,
+            execution_id: run.executionId,
+            status: run.status,
+            started_at: run.startedAt,
+            finished_at: run.finishedAt,
+            outcome: run.outcome,
+        });
+    }
+    async updateRun(workspaceId, runId, patch) {
+        const set = {};
+        if (patch.status !== undefined)
+            set.status = patch.status;
+        if (patch.finishedAt !== undefined)
+            set.finished_at = patch.finishedAt;
+        if (patch.outcome !== undefined)
+            set.outcome = patch.outcome;
+        if (patch.executionId !== undefined)
+            set.execution_id = patch.executionId;
+        if (Object.keys(set).length === 0)
+            return;
+        await this.db
+            .update(pipelineScheduleRuns)
+            .set(set)
+            .where(and(eq(pipelineScheduleRuns.workspace_id, workspaceId), eq(pipelineScheduleRuns.id, runId)));
+    }
+    async listRuns(workspaceId, scheduleId) {
+        const rows = await this.db
+            .select()
+            .from(pipelineScheduleRuns)
+            .where(and(eq(pipelineScheduleRuns.workspace_id, workspaceId), eq(pipelineScheduleRuns.schedule_id, scheduleId)))
+            .orderBy(desc(pipelineScheduleRuns.started_at));
+        return rows.map(rowToRun);
+    }
+    async pruneRunsBefore(before) {
+        const rows = await this.db
+            .delete(pipelineScheduleRuns)
+            .where(lt(pipelineScheduleRuns.started_at, before))
+            .returning({ id: pipelineScheduleRuns.id });
+        return rows.length;
+    }
+}
+class DrizzleTrackerSettingsRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(workspaceId) {
+        const [row] = await this.db
+            .select()
+            .from(trackerSettings)
+            .where(eq(trackerSettings.workspace_id, workspaceId));
+        if (!row)
+            return null;
+        return {
+            tracker: row.tracker ?? null,
+            jiraProjectKey: row.jira_project_key,
+            updatedAt: row.updated_at,
+        };
+    }
+    async put(workspaceId, settings) {
+        await this.db
+            .insert(trackerSettings)
+            .values({
+            workspace_id: workspaceId,
+            tracker: settings.tracker,
+            jira_project_key: settings.jiraProjectKey,
+            updated_at: settings.updatedAt,
+        })
+            .onConflictDoUpdate({
+            target: trackerSettings.workspace_id,
+            set: {
+                tracker: settings.tracker,
+                jira_project_key: settings.jiraProjectKey,
+                updated_at: settings.updatedAt,
+            },
+        });
+    }
+}
+function rowToService(row) {
+    return {
+        id: row.id,
+        accountId: row.account_id,
+        frameBlockId: row.frame_block_id,
+        installationId: row.installation_id,
+        repoGithubId: row.repo_github_id,
+        directory: row.directory,
+        createdAt: row.created_at,
+    };
+}
+/** Account-owned services (migration 0030). The canonical, shareable board unit. */
+class DrizzleServiceRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(id) {
+        const [row] = await this.db.select().from(services).where(eq(services.id, id));
+        return row ? rowToService(row) : null;
+    }
+    async getByFrameBlock(frameBlockId) {
+        const [row] = await this.db
+            .select()
+            .from(services)
+            .where(eq(services.frame_block_id, frameBlockId));
+        return row ? rowToService(row) : null;
+    }
+    async listByAccount(accountId) {
+        // NULL-safe match so the legacy/unscoped org (accountId null) lists cleanly.
+        const rows = await this.db
+            .select()
+            .from(services)
+            .where(sql `${services.account_id} IS NOT DISTINCT FROM ${accountId}`)
+            .orderBy(services.created_at);
+        return rows.map(rowToService);
+    }
+    async listByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        const out = [];
+        // Chunk the IN list to stay well under the bind-parameter limit.
+        for (let i = 0; i < ids.length; i += 500) {
+            const rows = await this.db
+                .select()
+                .from(services)
+                .where(inArray(services.id, ids.slice(i, i + 500)));
+            for (const row of rows)
+                out.push(rowToService(row));
+        }
+        return out;
+    }
+    async getByRepo(installationId, repoGithubId) {
+        const [row] = await this.db
+            .select()
+            .from(services)
+            .where(and(eq(services.installation_id, installationId), eq(services.repo_github_id, repoGithubId)));
+        return row ? rowToService(row) : null;
+    }
+    async insert(service) {
+        await this.db.insert(services).values({
+            id: service.id,
+            account_id: service.accountId,
+            frame_block_id: service.frameBlockId,
+            installation_id: service.installationId,
+            repo_github_id: service.repoGithubId,
+            directory: service.directory ?? null,
+            created_at: service.createdAt,
+        });
+    }
+    async update(id, patch) {
+        const set = {};
+        if ('accountId' in patch)
+            set.account_id = patch.accountId ?? null;
+        if ('installationId' in patch)
+            set.installation_id = patch.installationId ?? null;
+        if ('repoGithubId' in patch)
+            set.repo_github_id = patch.repoGithubId ?? null;
+        if ('directory' in patch)
+            set.directory = patch.directory ?? null;
+        if (Object.keys(set).length === 0)
+            return;
+        await this.db.update(services).set(set).where(eq(services.id, id));
+    }
+    async delete(id) {
+        await this.db.delete(services).where(eq(services.id, id));
+    }
+    async deleteMany(ids) {
+        if (ids.length === 0)
+            return;
+        // Chunk the IN list to stay well under the bind-parameter limit.
+        for (let i = 0; i < ids.length; i += 500) {
+            await this.db.delete(services).where(inArray(services.id, ids.slice(i, i + 500)));
+        }
+    }
+}
+function rowToMount(row) {
+    return {
+        workspaceId: row.workspace_id,
+        serviceId: row.service_id,
+        position: { x: row.pos_x, y: row.pos_y },
+        size: row.width !== null && row.height !== null ? { w: row.width, h: row.height } : null,
+        createdAt: row.created_at,
+    };
+}
+/** A service mounted onto a workspace board + its per-workspace layout (migration 0030). */
+class DrizzleWorkspaceMountRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async listByWorkspace(workspaceId) {
+        const rows = await this.db
+            .select()
+            .from(workspaceServices)
+            .where(eq(workspaceServices.workspace_id, workspaceId))
+            .orderBy(workspaceServices.created_at);
+        return rows.map(rowToMount);
+    }
+    async listByService(serviceId) {
+        const rows = await this.db
+            .select()
+            .from(workspaceServices)
+            .where(eq(workspaceServices.service_id, serviceId))
+            .orderBy(workspaceServices.created_at);
+        return rows.map(rowToMount);
+    }
+    async listWorkspaceIdsMountingBlock(originWorkspaceId, blockId) {
+        // One join: the service owning the block → the workspaces that mount it. A block with no
+        // service makes the subquery NULL, which matches no rows (`service_id = NULL`) → empty.
+        const rows = await this.db
+            .select({ workspaceId: workspaceServices.workspace_id })
+            .from(workspaceServices)
+            .where(sql `${workspaceServices.service_id} = (SELECT ${blocks.service_id} FROM ${blocks} WHERE ${blocks.workspace_id} = ${originWorkspaceId} AND ${blocks.id} = ${blockId})`);
+        return rows.map((r) => r.workspaceId);
+    }
+    async countByServiceIds(serviceIds) {
+        if (serviceIds.length === 0)
+            return {};
+        const rows = await this.db
+            .select({ serviceId: workspaceServices.service_id, n: sql `count(*)` })
+            .from(workspaceServices)
+            .where(inArray(workspaceServices.service_id, serviceIds))
+            .groupBy(workspaceServices.service_id);
+        const counts = {};
+        for (const row of rows)
+            counts[row.serviceId] = Number(row.n);
+        return counts;
+    }
+    async get(workspaceId, serviceId) {
+        const [row] = await this.db
+            .select()
+            .from(workspaceServices)
+            .where(and(eq(workspaceServices.workspace_id, workspaceId), eq(workspaceServices.service_id, serviceId)));
+        return row ? rowToMount(row) : null;
+    }
+    async upsert(mount) {
+        await this.db
+            .insert(workspaceServices)
+            .values({
+            workspace_id: mount.workspaceId,
+            service_id: mount.serviceId,
+            pos_x: mount.position.x,
+            pos_y: mount.position.y,
+            width: mount.size?.w ?? null,
+            height: mount.size?.h ?? null,
+            created_at: mount.createdAt,
+        })
+            .onConflictDoUpdate({
+            target: [workspaceServices.workspace_id, workspaceServices.service_id],
+            set: {
+                pos_x: mount.position.x,
+                pos_y: mount.position.y,
+                width: mount.size?.w ?? null,
+                height: mount.size?.h ?? null,
+            },
+        });
+    }
+    async update(workspaceId, serviceId, patch) {
+        const set = {};
+        if (patch.position) {
+            set.pos_x = patch.position.x;
+            set.pos_y = patch.position.y;
+        }
+        if ('size' in patch) {
+            set.width = patch.size?.w ?? null;
+            set.height = patch.size?.h ?? null;
+        }
+        if (Object.keys(set).length === 0)
+            return;
+        await this.db
+            .update(workspaceServices)
+            .set(set)
+            .where(and(eq(workspaceServices.workspace_id, workspaceId), eq(workspaceServices.service_id, serviceId)));
+    }
+    async remove(workspaceId, serviceId) {
+        await this.db
+            .delete(workspaceServices)
+            .where(and(eq(workspaceServices.workspace_id, workspaceId), eq(workspaceServices.service_id, serviceId)));
+    }
+    async removeByServices(serviceIds) {
+        if (serviceIds.length === 0)
+            return;
+        // Chunk the IN list to stay well under the bind-parameter limit.
+        for (let i = 0; i < serviceIds.length; i += 500) {
+            await this.db
+                .delete(workspaceServices)
+                .where(inArray(workspaceServices.service_id, serviceIds.slice(i, i + 500)));
+        }
+    }
+}
+function rowToRequirementReview(row) {
+    let items = [];
+    try {
+        const parsed = JSON.parse(row.items);
+        if (Array.isArray(parsed))
+            items = parsed;
+    }
+    catch {
+        items = [];
+    }
+    return {
+        id: row.id,
+        blockId: row.block_id,
+        status: row.status,
+        items,
+        model: row.model,
+        incorporatedRequirements: row.incorporated_requirements,
+        iteration: row.iteration,
+        maxIterations: row.max_iterations,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Requirements reviews over Postgres (the Drizzle mirror of the Worker's
+ * `D1RequirementReviewRepository`, migration 0021). The reviewed items live as a JSON
+ * array in `items`; the service keeps at most one live review per block (it deletes
+ * the block's prior review before inserting a fresh one), so `getByBlock` returns the
+ * latest. Behaviourally identical to the D1 repo so the cross-runtime conformance
+ * suite asserts the same requirements-rework substitution against both stores.
+ */
+export class DrizzleRequirementReviewRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getByBlock(workspaceId, blockId) {
+        const rows = await this.db
+            .select()
+            .from(requirementReviews)
+            .where(and(eq(requirementReviews.workspace_id, workspaceId), eq(requirementReviews.block_id, blockId)))
+            .orderBy(desc(requirementReviews.created_at))
+            .limit(1);
+        return rows[0] ? rowToRequirementReview(rows[0]) : null;
+    }
+    async get(workspaceId, id) {
+        const rows = await this.db
+            .select()
+            .from(requirementReviews)
+            .where(and(eq(requirementReviews.workspace_id, workspaceId), eq(requirementReviews.id, id)))
+            .limit(1);
+        return rows[0] ? rowToRequirementReview(rows[0]) : null;
+    }
+    async upsert(workspaceId, review) {
+        const values = {
+            workspace_id: workspaceId,
+            id: review.id,
+            block_id: review.blockId,
+            status: review.status,
+            items: JSON.stringify(review.items),
+            model: review.model,
+            incorporated_requirements: review.incorporatedRequirements,
+            iteration: review.iteration ?? 1,
+            max_iterations: review.maxIterations ?? 1,
+            created_at: review.createdAt,
+            updated_at: review.updatedAt,
+        };
+        await this.db
+            .insert(requirementReviews)
+            .values(values)
+            .onConflictDoUpdate({
+            target: [requirementReviews.workspace_id, requirementReviews.id],
+            set: {
+                block_id: values.block_id,
+                status: values.status,
+                items: values.items,
+                model: values.model,
+                incorporated_requirements: values.incorporated_requirements,
+                iteration: values.iteration,
+                max_iterations: values.max_iterations,
+                updated_at: values.updated_at,
+            },
+        });
+    }
+    async deleteByBlock(workspaceId, blockId) {
+        await this.db
+            .delete(requirementReviews)
+            .where(and(eq(requirementReviews.workspace_id, workspaceId), eq(requirementReviews.block_id, blockId)));
+    }
+}
+function parseJsonArray(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function rowToConsensusSession(row) {
+    return {
+        id: row.id,
+        blockId: row.block_id,
+        executionId: row.execution_id,
+        stepIndex: row.step_index,
+        agentKind: row.agent_kind,
+        strategy: row.strategy,
+        status: row.status,
+        participants: parseJsonArray(row.participants),
+        rounds: parseJsonArray(row.rounds),
+        synthesis: row.synthesis,
+        confidence: row.confidence,
+        dissent: parseJsonArray(row.dissent),
+        error: row.error,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function rowToClarityReview(row) {
+    let items = [];
+    try {
+        const parsed = JSON.parse(row.items);
+        if (Array.isArray(parsed))
+            items = parsed;
+    }
+    catch {
+        items = [];
+    }
+    return {
+        id: row.id,
+        blockId: row.block_id,
+        status: row.status,
+        items,
+        model: row.model,
+        clarifiedReport: row.clarified_report,
+        iteration: row.iteration,
+        maxIterations: row.max_iterations,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Consensus session transcripts (`consensus_sessions`), the Drizzle/Postgres mirror of
+ * {@link D1ConsensusSessionRepository}. One row per (execution, step); the
+ * participants/rounds/dissent live as JSON columns, upserted as the process streams.
+ */
+export class DrizzleConsensusSessionRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(workspaceId, id) {
+        const rows = await this.db
+            .select()
+            .from(consensusSessions)
+            .where(and(eq(consensusSessions.workspace_id, workspaceId), eq(consensusSessions.id, id)))
+            .limit(1);
+        return rows[0] ? rowToConsensusSession(rows[0]) : null;
+    }
+    async getByStep(workspaceId, executionId, stepIndex) {
+        const rows = await this.db
+            .select()
+            .from(consensusSessions)
+            .where(and(eq(consensusSessions.workspace_id, workspaceId), eq(consensusSessions.execution_id, executionId), eq(consensusSessions.step_index, stepIndex)))
+            .orderBy(desc(consensusSessions.created_at))
+            .limit(1);
+        return rows[0] ? rowToConsensusSession(rows[0]) : null;
+    }
+    async getByBlock(workspaceId, blockId) {
+        const rows = await this.db
+            .select()
+            .from(consensusSessions)
+            .where(and(eq(consensusSessions.workspace_id, workspaceId), eq(consensusSessions.block_id, blockId)))
+            .orderBy(desc(consensusSessions.created_at))
+            .limit(1);
+        return rows[0] ? rowToConsensusSession(rows[0]) : null;
+    }
+    async upsert(workspaceId, session) {
+        const values = {
+            workspace_id: workspaceId,
+            id: session.id,
+            block_id: session.blockId,
+            execution_id: session.executionId,
+            step_index: session.stepIndex,
+            agent_kind: session.agentKind,
+            strategy: session.strategy,
+            status: session.status,
+            participants: JSON.stringify(session.participants),
+            rounds: JSON.stringify(session.rounds),
+            synthesis: session.synthesis,
+            confidence: session.confidence ?? null,
+            dissent: JSON.stringify(session.dissent ?? []),
+            error: session.error ?? null,
+            created_at: session.createdAt,
+            updated_at: session.updatedAt,
+        };
+        await this.db
+            .insert(consensusSessions)
+            .values(values)
+            .onConflictDoUpdate({
+            target: [consensusSessions.workspace_id, consensusSessions.id],
+            set: {
+                block_id: values.block_id,
+                execution_id: values.execution_id,
+                step_index: values.step_index,
+                agent_kind: values.agent_kind,
+                strategy: values.strategy,
+                status: values.status,
+                participants: values.participants,
+                rounds: values.rounds,
+                synthesis: values.synthesis,
+                confidence: values.confidence,
+                dissent: values.dissent,
+                error: values.error,
+                updated_at: values.updated_at,
+            },
+        });
+    }
+}
+/**
+ * Clarity (bug-report triage) reviews over Postgres — the Drizzle mirror of the Worker's
+ * `D1ClarityReviewRepository`. Behaviourally identical to the D1 repo so the cross-runtime
+ * conformance suite asserts the same clarified-brief substitution against both stores.
+ */
+export class DrizzleClarityReviewRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getByBlock(workspaceId, blockId) {
+        const rows = await this.db
+            .select()
+            .from(clarityReviews)
+            .where(and(eq(clarityReviews.workspace_id, workspaceId), eq(clarityReviews.block_id, blockId)))
+            .orderBy(desc(clarityReviews.created_at))
+            .limit(1);
+        return rows[0] ? rowToClarityReview(rows[0]) : null;
+    }
+    async get(workspaceId, id) {
+        const rows = await this.db
+            .select()
+            .from(clarityReviews)
+            .where(and(eq(clarityReviews.workspace_id, workspaceId), eq(clarityReviews.id, id)))
+            .limit(1);
+        return rows[0] ? rowToClarityReview(rows[0]) : null;
+    }
+    async upsert(workspaceId, review) {
+        const values = {
+            workspace_id: workspaceId,
+            id: review.id,
+            block_id: review.blockId,
+            status: review.status,
+            items: JSON.stringify(review.items),
+            model: review.model,
+            clarified_report: review.clarifiedReport,
+            iteration: review.iteration ?? 1,
+            max_iterations: review.maxIterations ?? 1,
+            created_at: review.createdAt,
+            updated_at: review.updatedAt,
+        };
+        await this.db
+            .insert(clarityReviews)
+            .values(values)
+            .onConflictDoUpdate({
+            target: [clarityReviews.workspace_id, clarityReviews.id],
+            set: {
+                block_id: values.block_id,
+                status: values.status,
+                items: values.items,
+                model: values.model,
+                clarified_report: values.clarified_report,
+                iteration: values.iteration,
+                max_iterations: values.max_iterations,
+                updated_at: values.updated_at,
+            },
+        });
+    }
+    async deleteByBlock(workspaceId, blockId) {
+        await this.db
+            .delete(clarityReviews)
+            .where(and(eq(clarityReviews.workspace_id, workspaceId), eq(clarityReviews.block_id, blockId)));
+    }
+}
+function rowToMergePreset(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        maxComplexity: row.max_complexity,
+        maxRisk: row.max_risk,
+        maxImpact: row.max_impact,
+        ciMaxAttempts: row.ci_max_attempts,
+        maxRequirementIterations: row.max_requirement_iterations,
+        maxRequirementConcernAllowed: row.max_requirement_concern_allowed,
+        isDefault: row.is_default === 1,
+        createdAt: row.created_at,
+    };
+}
+/**
+ * Per-workspace merge threshold presets over Postgres (the Drizzle mirror of the
+ * Worker's `D1MergePresetRepository`, migration 0024). Enforces the single-default
+ * invariant: promoting a preset to default demotes every other in the workspace
+ * before the upsert. The default preset cannot be removed (the service keeps that
+ * rule too; the DELETE also guards `is_default = 0`). Behaviourally identical to the
+ * D1 repo so the cross-runtime conformance suite asserts the same preset resolution.
+ */
+export class DrizzleMergePresetRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(workspaceId, id) {
+        const rows = await this.db
+            .select()
+            .from(mergeThresholdPresets)
+            .where(and(eq(mergeThresholdPresets.workspace_id, workspaceId), eq(mergeThresholdPresets.id, id)))
+            .limit(1);
+        return rows[0] ? rowToMergePreset(rows[0]) : null;
+    }
+    async list(workspaceId) {
+        const rows = await this.db
+            .select()
+            .from(mergeThresholdPresets)
+            .where(eq(mergeThresholdPresets.workspace_id, workspaceId))
+            .orderBy(mergeThresholdPresets.created_at);
+        return rows.map(rowToMergePreset);
+    }
+    async getDefault(workspaceId) {
+        const rows = await this.db
+            .select()
+            .from(mergeThresholdPresets)
+            .where(and(eq(mergeThresholdPresets.workspace_id, workspaceId), eq(mergeThresholdPresets.is_default, 1)))
+            .orderBy(mergeThresholdPresets.created_at)
+            .limit(1);
+        return rows[0] ? rowToMergePreset(rows[0]) : null;
+    }
+    async upsert(workspaceId, preset) {
+        const values = {
+            workspace_id: workspaceId,
+            id: preset.id,
+            name: preset.name,
+            max_complexity: preset.maxComplexity,
+            max_risk: preset.maxRisk,
+            max_impact: preset.maxImpact,
+            ci_max_attempts: preset.ciMaxAttempts,
+            max_requirement_iterations: preset.maxRequirementIterations,
+            max_requirement_concern_allowed: preset.maxRequirementConcernAllowed,
+            is_default: preset.isDefault ? 1 : 0,
+            created_at: preset.createdAt,
+        };
+        // Demote + upsert run in one transaction so the single-default invariant can never
+        // be observed broken (zero or two defaults) by a concurrent reader or a partial failure.
+        await this.db.transaction(async (tx) => {
+            // Promoting this preset to default demotes any other default first.
+            if (preset.isDefault) {
+                await tx
+                    .update(mergeThresholdPresets)
+                    .set({ is_default: 0 })
+                    .where(and(eq(mergeThresholdPresets.workspace_id, workspaceId), sql `${mergeThresholdPresets.id} <> ${preset.id}`));
+            }
+            await tx
+                .insert(mergeThresholdPresets)
+                .values(values)
+                .onConflictDoUpdate({
+                target: [mergeThresholdPresets.workspace_id, mergeThresholdPresets.id],
+                set: {
+                    name: values.name,
+                    max_complexity: values.max_complexity,
+                    max_risk: values.max_risk,
+                    max_impact: values.max_impact,
+                    ci_max_attempts: values.ci_max_attempts,
+                    max_requirement_iterations: values.max_requirement_iterations,
+                    max_requirement_concern_allowed: values.max_requirement_concern_allowed,
+                    is_default: values.is_default,
+                },
+            });
+        });
+    }
+    async remove(workspaceId, id) {
+        await this.db
+            .delete(mergeThresholdPresets)
+            .where(and(eq(mergeThresholdPresets.workspace_id, workspaceId), eq(mergeThresholdPresets.id, id), eq(mergeThresholdPresets.is_default, 0)));
+    }
+}
+function rowToBlueprintRecord(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspace_id,
+        repoOwner: row.repo_owner,
+        repoName: row.repo_name,
+        source: row.source,
+        service: JSON.parse(row.service_json),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Repository blueprints over Postgres (the Drizzle mirror of the Worker's
+ * `D1RepoBlueprintRepository`, migration 0011). One row per (workspace, repo):
+ * `upsert` replaces the existing blueprint in place, keyed by the unique
+ * `(workspace_id, repo_owner, repo_name)` index, so the row is always the single
+ * current decomposition. The service → modules tree is persisted whole as JSON.
+ */
+export class DrizzleRepoBlueprintRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async upsert(record) {
+        const values = {
+            id: record.id,
+            workspace_id: record.workspaceId,
+            repo_owner: record.repoOwner,
+            repo_name: record.repoName,
+            source: record.source,
+            service_json: JSON.stringify(record.service),
+            created_at: record.createdAt,
+            updated_at: record.updatedAt,
+        };
+        await this.db
+            .insert(repoBlueprints)
+            .values(values)
+            .onConflictDoUpdate({
+            target: [repoBlueprints.workspace_id, repoBlueprints.repo_owner, repoBlueprints.repo_name],
+            set: {
+                source: values.source,
+                service_json: values.service_json,
+                updated_at: values.updated_at,
+            },
+        });
+    }
+    async get(workspaceId, id) {
+        const rows = await this.db
+            .select()
+            .from(repoBlueprints)
+            .where(and(eq(repoBlueprints.workspace_id, workspaceId), eq(repoBlueprints.id, id)))
+            .limit(1);
+        return rows[0] ? rowToBlueprintRecord(rows[0]) : null;
+    }
+    async getByRepo(workspaceId, repoOwner, repoName) {
+        const rows = await this.db
+            .select()
+            .from(repoBlueprints)
+            .where(and(eq(repoBlueprints.workspace_id, workspaceId), eq(repoBlueprints.repo_owner, repoOwner), eq(repoBlueprints.repo_name, repoName)))
+            .limit(1);
+        return rows[0] ? rowToBlueprintRecord(rows[0]) : null;
+    }
+    async listByWorkspace(workspaceId) {
+        const rows = await this.db
+            .select()
+            .from(repoBlueprints)
+            .where(eq(repoBlueprints.workspace_id, workspaceId))
+            .orderBy(desc(repoBlueprints.updated_at));
+        return rows.map(rowToBlueprintRecord);
+    }
+    async delete(workspaceId, id) {
+        await this.db
+            .delete(repoBlueprints)
+            .where(and(eq(repoBlueprints.workspace_id, workspaceId), eq(repoBlueprints.id, id)));
+    }
+}
+/** Build the Drizzle/Postgres-backed core repositories. */
+export function createDrizzleRepositories(db, clock) {
+    return {
+        workspaceRepository: new DrizzleWorkspaceRepository(db),
+        accountRepository: new DrizzleAccountRepository(db),
+        membershipRepository: new DrizzleMembershipRepository(db),
+        userRepository: new DrizzleUserRepository(db),
+        invitationRepository: new DrizzleAccountInvitationRepository(db),
+        emailConnectionRepository: new DrizzleEmailConnectionRepository(db),
+        blockRepository: new DrizzleBlockRepository(db),
+        pipelineRepository: new DrizzlePipelineRepository(db),
+        executionRepository: new DrizzleExecutionRepository(db, clock),
+        tokenUsageRepository: new DrizzleTokenUsageRepository(db),
+        llmCallMetricRepository: new DrizzleLlmCallMetricRepository(db),
+        agentRunRepository: new DrizzleAgentRunRepository(db),
+        modelDefaultsRepository: new DrizzleModelDefaultsRepository(db),
+        serviceFragmentDefaultsRepository: new DrizzleServiceFragmentDefaultsRepository(db),
+        pipelineScheduleRepository: new DrizzlePipelineScheduleRepository(db),
+        trackerSettingsRepository: new DrizzleTrackerSettingsRepository(db),
+        serviceRepository: new DrizzleServiceRepository(db),
+        workspaceMountRepository: new DrizzleWorkspaceMountRepository(db),
+        requirementReviewRepository: new DrizzleRequirementReviewRepository(db),
+        consensusSessionRepository: new DrizzleConsensusSessionRepository(db),
+        clarityReviewRepository: new DrizzleClarityReviewRepository(db),
+        mergePresetRepository: new DrizzleMergePresetRepository(db),
+        repoBlueprintRepository: new DrizzleRepoBlueprintRepository(db),
+    };
+}
+//# sourceMappingURL=drizzle.js.map