@triagepilot/db 1.1.0

package/dist/outbox.js

@@ -0,0 +1,230 @@
+import { isDeepStrictEqual } from "node:util";
+import { buildNextRunAt } from "./jobs.js";
+const PLATFORM_OUTBOX_LEASE_MS = 15 * 60 * 1000;
+export async function stagePlatformEvent(db, workspaceId, sourceId, event) {
+    if (db.isTransaction) {
+        await stagePlatformEventInTransaction(db, workspaceId, sourceId, event);
+        return;
+    }
+    await db.transaction().execute(async (trx) => {
+        await stagePlatformEventInTransaction(trx, workspaceId, sourceId, event);
+    });
+}
+async function stagePlatformEventInTransaction(db, workspaceId, sourceId, event) {
+    if (event.workspaceId !== workspaceId)
+        throw new Error("platform event workspace does not match persistence scope");
+    if (event.eventType === "routing_decision" && event.decisionId !== sourceId) {
+        throw new Error("platform event decision id does not match persisted decision");
+    }
+    if (event.eventType === "reviewer_replacement") {
+        const replacement = await db
+            .selectFrom("reviewer_replacements")
+            .select([
+            "provider",
+            "provider_connection_id",
+            "absence_id",
+            "absence_revision",
+            "decision_id",
+            "unavailable_actor_id",
+            "replacement_actor_id",
+            "outcome",
+        ])
+            .where("workspace_id", "=", workspaceId)
+            .where("id", "=", sourceId)
+            .forUpdate()
+            .executeTakeFirst();
+        if (replacement === undefined
+            || replacement.provider !== event.provider
+            || replacement.provider_connection_id !== event.providerConnectionId
+            || replacement.absence_id !== event.absenceId
+            || replacement.absence_revision !== event.absenceRevision
+            || replacement.decision_id !== event.decisionId
+            || replacement.unavailable_actor_id !== event.unavailableActor
+            || replacement.replacement_actor_id !== event.replacementActor
+            || replacement.outcome !== event.outcome) {
+            throw new Error("reviewer replacement event does not match persisted source");
+        }
+    }
+    const source = event.eventType === "routing_decision"
+        ? { decision_id: sourceId, reviewer_replacement_id: null }
+        : { decision_id: null, reviewer_replacement_id: sourceId };
+    const inserted = await db
+        .insertInto("decision_outbox")
+        .values({
+        workspace_id: workspaceId,
+        ...source,
+        event_id: event.eventId,
+        event_type: event.eventType,
+        schema_version: event.schemaVersion,
+        payload: event,
+        occurred_at: event.occurredAt,
+        available_at: event.occurredAt,
+    })
+        .onConflict((conflict) => conflict.columns(["workspace_id", "event_id"]).doNothing())
+        .returning("id")
+        .executeTakeFirst();
+    if (inserted !== undefined)
+        return;
+    const existing = await db
+        .selectFrom("decision_outbox")
+        .select([
+        "decision_id",
+        "reviewer_replacement_id",
+        "event_type",
+        "schema_version",
+        "payload",
+        "occurred_at",
+    ])
+        .where("workspace_id", "=", workspaceId)
+        .where("event_id", "=", event.eventId)
+        .forUpdate()
+        .executeTakeFirst();
+    if (existing === undefined
+        || existing.decision_id !== source.decision_id
+        || existing.reviewer_replacement_id !== source.reviewer_replacement_id
+        || existing.event_type !== event.eventType
+        || existing.schema_version !== event.schemaVersion
+        || existing.occurred_at.getTime() !== new Date(event.occurredAt).getTime()
+        || !isDeepStrictEqual(existing.payload, event)) {
+        throw new Error("platform event id conflicts with a different persisted event");
+    }
+}
+export async function claimPlatformEvents(input) {
+    return await createPlatformOutboxRepository(input.db, input.workspaceId).claim({
+        limit: input.limit,
+        now: input.now ?? new Date(),
+    });
+}
+export async function markPlatformEventPublished(input) {
+    return await createPlatformOutboxRepository(input.db, input.workspaceId).markPublished({
+        id: input.id,
+        attemptCount: input.attemptCount,
+        now: input.now ?? new Date(),
+    });
+}
+export function createPlatformOutboxRepository(db, workspaceId) {
+    return {
+        async claim(input) {
+            if (input.limit <= 0)
+                return [];
+            return await db.transaction().execute(async (trx) => {
+                const candidates = await trx
+                    .selectFrom("decision_outbox")
+                    .selectAll()
+                    .where("workspace_id", "=", workspaceId)
+                    .where("published_at", "is", null)
+                    .where("available_at", "<=", input.now)
+                    .orderBy("available_at", "asc")
+                    .orderBy("occurred_at", "asc")
+                    .orderBy("id", "asc")
+                    .limit(input.limit)
+                    .forUpdate()
+                    .skipLocked()
+                    .execute();
+                const claimed = [];
+                for (const candidate of candidates) {
+                    const nextAttemptCount = candidate.attempt_count + 1;
+                    const updated = await trx
+                        .updateTable("decision_outbox")
+                        .set({
+                        attempt_count: nextAttemptCount,
+                        available_at: buildLeaseExpiresAt(input.now),
+                    })
+                        .where("workspace_id", "=", workspaceId)
+                        .where("id", "=", candidate.id)
+                        .where("published_at", "is", null)
+                        .returningAll()
+                        .executeTakeFirst();
+                    if (updated)
+                        claimed.push(toPlatformOutboxRecord(updated));
+                }
+                return claimed;
+            });
+        },
+        async markPublished(input) {
+            const updated = await db
+                .updateTable("decision_outbox")
+                .set({ published_at: input.now, last_error: null })
+                .where("workspace_id", "=", workspaceId)
+                .where("id", "=", input.id)
+                .where("attempt_count", "=", input.attemptCount)
+                .where("published_at", "is", null)
+                .returning("id")
+                .execute();
+            return updated.length > 0;
+        },
+        async markFailed(input) {
+            const updated = await db
+                .updateTable("decision_outbox")
+                .set({
+                last_error: sanitizeError(input.error),
+                available_at: buildNextRunAt(input.now, input.attemptCount),
+            })
+                .where("workspace_id", "=", workspaceId)
+                .where("id", "=", input.id)
+                .where("attempt_count", "=", input.attemptCount)
+                .where("published_at", "is", null)
+                .returning("id")
+                .execute();
+            return updated.length > 0;
+        },
+        async listUnpublished() {
+            const rows = await db
+                .selectFrom("decision_outbox")
+                .selectAll()
+                .where("workspace_id", "=", workspaceId)
+                .where("published_at", "is", null)
+                .orderBy("occurred_at", "asc")
+                .orderBy("id", "asc")
+                .execute();
+            return rows.map(toPlatformOutboxRecord);
+        },
+    };
+}
+export async function publishPlatformOutbox(input) {
+    const now = input.now ?? new Date();
+    const events = await input.repository.claim({ limit: input.limit, now });
+    let published = 0;
+    for (const event of events) {
+        try {
+            await input.sink.emit(event.payload);
+            if (await input.repository.markPublished({ id: event.id, attemptCount: event.attemptCount, now })) {
+                published += 1;
+            }
+        }
+        catch (error) {
+            await input.repository.markFailed({
+                id: event.id,
+                attemptCount: event.attemptCount,
+                error,
+                now,
+            });
+            throw error;
+        }
+    }
+    return { published };
+}
+function toPlatformOutboxRecord(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspace_id,
+        decisionId: row.decision_id,
+        reviewerReplacementId: row.reviewer_replacement_id,
+        eventId: row.event_id,
+        eventType: row.event_type,
+        schemaVersion: row.schema_version,
+        payload: row.payload,
+        occurredAt: row.occurred_at,
+        availableAt: row.available_at,
+        publishedAt: row.published_at,
+        attemptCount: row.attempt_count,
+        lastError: row.last_error,
+    };
+}
+function sanitizeError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replaceAll(/[\u0000-\u001f\u007f]+/g, " ").trim().slice(0, 1_000) || "platform event sink failed";
+}
+function buildLeaseExpiresAt(now) {
+    return new Date(now.getTime() + PLATFORM_OUTBOX_LEASE_MS);
+}

package/dist/provider-connections.d.ts

@@ -0,0 +1,34 @@
+import { type Kysely, type Transaction } from "kysely";
+import type { ProviderConnectionId, ProviderKind, RepositoryId, WorkspaceId } from "@triagepilot/contracts";
+import type { Database } from "./kysely.js";
+export interface ProviderConnectionMetadata {
+    provider: ProviderKind;
+    externalConnectionId: string;
+    workspaceLogin: string;
+    accountType: string;
+}
+export interface ProviderRepositoryMetadata {
+    provider: ProviderKind;
+    externalRepositoryId: RepositoryId;
+    owner: string;
+    name: string;
+}
+export interface ConfiguredProviderConnectionInput extends ProviderConnectionMetadata {
+    repositories: ProviderRepositoryMetadata[];
+}
+export interface ProviderConnectionRepositoryUpdateInput extends ProviderConnectionMetadata {
+    repositoriesAdded: ProviderRepositoryMetadata[];
+    repositoryIdsRemoved: RepositoryId[];
+}
+export declare function upsertConfiguredProviderConnection(db: Kysely<Database>, workspaceId: WorkspaceId, input: ConfiguredProviderConnectionInput): Promise<void>;
+export declare function activateConfiguredProviderConnection(db: Kysely<Database>, workspaceId: WorkspaceId, input: ProviderConnectionMetadata): Promise<void>;
+export declare function replaceProviderConnectionRepositories(db: Kysely<Database>, workspaceId: WorkspaceId, input: ConfiguredProviderConnectionInput): Promise<void>;
+export declare function updateProviderConnectionRepositories(db: Kysely<Database>, workspaceId: WorkspaceId, input: ProviderConnectionRepositoryUpdateInput): Promise<void>;
+export declare function suspendConfiguredProviderConnection(db: Kysely<Database>, workspaceId: WorkspaceId, input: ProviderConnectionMetadata): Promise<void>;
+export declare function revokeConfiguredProviderConnection(db: Kysely<Database>, workspaceId: WorkspaceId, input: Pick<ProviderConnectionMetadata, "provider" | "externalConnectionId">): Promise<void>;
+export declare function cleanupRevokedProviderConnections(db: Kysely<Database>, workspaceId: WorkspaceId, now: Date, limit?: number): Promise<number>;
+export declare function upsertDeliveryRepository(trx: Transaction<Database>, workspaceId: WorkspaceId, connection: ProviderConnectionMetadata, repository: ProviderRepositoryMetadata): Promise<{
+    providerConnectionId: ProviderConnectionId;
+    repositoryId: string;
+} | null>;
+export declare function lockProviderConnectionProjection(trx: Transaction<Database>, workspaceId: WorkspaceId): Promise<void>;

package/dist/provider-connections.js

@@ -0,0 +1,302 @@
+import { sql } from "kysely";
+export async function upsertConfiguredProviderConnection(db, workspaceId, input) {
+    await replaceProviderConnectionRepositories(db, workspaceId, input);
+}
+export async function activateConfiguredProviderConnection(db, workspaceId, input) {
+    await db.transaction().execute(async (trx) => {
+        await upsertActiveProviderConnection(trx, workspaceId, input);
+    });
+}
+export async function replaceProviderConnectionRepositories(db, workspaceId, input) {
+    assertRepositoryProviders(input.provider, input.repositories);
+    await db.transaction().execute(async (trx) => {
+        const providerConnectionId = await upsertActiveProviderConnection(trx, workspaceId, input);
+        if (providerConnectionId === null)
+            return;
+        for (const repository of input.repositories) {
+            await upsertRepository(trx, workspaceId, providerConnectionId, repository);
+        }
+        let deletion = trx
+            .deleteFrom("repositories")
+            .where("workspace_id", "=", workspaceId)
+            .where("provider_connection_id", "=", providerConnectionId);
+        if (input.repositories.length > 0) {
+            deletion = deletion.where("external_repository_id", "not in", input.repositories.map((repository) => repository.externalRepositoryId));
+        }
+        await deletion.execute();
+    });
+}
+export async function updateProviderConnectionRepositories(db, workspaceId, input) {
+    assertRepositoryProviders(input.provider, input.repositoriesAdded);
+    await db.transaction().execute(async (trx) => {
+        await lockProviderConnectionProjection(trx, workspaceId);
+        const connection = await trx
+            .selectFrom("provider_connections")
+            .select("id")
+            .where("workspace_id", "=", workspaceId)
+            .where("provider", "=", input.provider)
+            .where("status", "=", "active")
+            .where("external_connection_id", "=", input.externalConnectionId)
+            .forUpdate()
+            .executeTakeFirst();
+        if (!connection)
+            return;
+        await trx
+            .updateTable("provider_connections")
+            .set({
+            workspace_login: input.workspaceLogin,
+            account_type: input.accountType,
+            updated_at: new Date(),
+        })
+            .where("workspace_id", "=", workspaceId)
+            .where("id", "=", connection.id)
+            .execute();
+        for (const repository of input.repositoriesAdded) {
+            await upsertRepository(trx, workspaceId, connection.id, repository);
+        }
+        if (input.repositoryIdsRemoved.length > 0) {
+            await trx
+                .deleteFrom("repositories")
+                .where("workspace_id", "=", workspaceId)
+                .where("provider_connection_id", "=", connection.id)
+                .where("provider", "=", input.provider)
+                .where("external_repository_id", "in", input.repositoryIdsRemoved)
+                .execute();
+        }
+    });
+}
+export async function suspendConfiguredProviderConnection(db, workspaceId, input) {
+    await db.transaction().execute(async (trx) => {
+        await lockProviderConnectionProjection(trx, workspaceId);
+        await trx
+            .updateTable("provider_connections")
+            .set({
+            workspace_login: input.workspaceLogin,
+            account_type: input.accountType,
+            status: "suspended",
+            updated_at: new Date(),
+        })
+            .where("workspace_id", "=", workspaceId)
+            .where("provider", "=", input.provider)
+            .where("external_connection_id", "=", input.externalConnectionId)
+            .where("status", "=", "active")
+            .execute();
+    });
+}
+export async function revokeConfiguredProviderConnection(db, workspaceId, input) {
+    await db.transaction().execute(async (trx) => {
+        await lockProviderConnectionProjection(trx, workspaceId);
+        const connection = await trx
+            .selectFrom("provider_connections")
+            .select("id")
+            .where("workspace_id", "=", workspaceId)
+            .where("provider", "=", input.provider)
+            .where("external_connection_id", "=", input.externalConnectionId)
+            .where("status", "!=", "revoked")
+            .forUpdate()
+            .executeTakeFirst();
+        const revokedAt = new Date();
+        await trx.insertInto("provider_connection_revocations").values({
+            workspace_id: workspaceId,
+            provider: input.provider,
+            external_connection_id: input.externalConnectionId,
+            ...(connection === undefined ? {} : { revoked_connection_id: connection.id }),
+            physical_connection_id: connection?.id ?? null,
+            revoked_at: revokedAt,
+            cleanup_completed_at: null,
+        }).onConflict((conflict) => conflict
+            .columns(["workspace_id", "provider", "external_connection_id"])
+            .doNothing()).execute();
+        if (connection === undefined)
+            return;
+        await trx.updateTable("provider_connections").set({
+            status: "revoked",
+            updated_at: revokedAt,
+        }).where("workspace_id", "=", workspaceId)
+            .where("provider", "=", input.provider)
+            .where("id", "=", connection.id)
+            .execute();
+    });
+}
+export async function cleanupRevokedProviderConnections(db, workspaceId, now, limit = 25) {
+    if (!Number.isSafeInteger(limit) || limit <= 0) {
+        throw new Error("provider connection cleanup limit must be a positive integer");
+    }
+    const pending = await db.selectFrom("provider_connection_revocations")
+        .select(["provider", "revoked_connection_id", "physical_connection_id"])
+        .where("workspace_id", "=", workspaceId)
+        .where("cleanup_completed_at", "is", null)
+        .where("physical_connection_id", "is not", null)
+        .orderBy("revoked_at")
+        .orderBy("revoked_connection_id")
+        .limit(limit)
+        .execute();
+    let cleaned = 0;
+    for (const candidate of pending) {
+        const physicalConnectionId = candidate.physical_connection_id;
+        if (physicalConnectionId === null)
+            continue;
+        const completed = await cleanupRevokedProviderConnection(db, workspaceId, { ...candidate, physical_connection_id: physicalConnectionId }, now);
+        if (completed)
+            cleaned += 1;
+    }
+    return cleaned;
+}
+async function cleanupRevokedProviderConnection(db, workspaceId, candidate, now) {
+    return await db.transaction().execute(async (trx) => {
+        const revocation = await trx.selectFrom("provider_connection_revocations")
+            .select("revoked_connection_id")
+            .where("workspace_id", "=", workspaceId)
+            .where("provider", "=", candidate.provider)
+            .where("revoked_connection_id", "=", candidate.revoked_connection_id)
+            .where("cleanup_completed_at", "is", null)
+            .forUpdate()
+            .executeTakeFirst();
+        if (revocation === undefined)
+            return false;
+        const deleted = await trx.deleteFrom("provider_connections")
+            .where("workspace_id", "=", workspaceId)
+            .where("provider", "=", candidate.provider)
+            .where("id", "=", candidate.physical_connection_id)
+            .where("status", "=", "revoked")
+            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("jobs").select("id")
+            .where("workspace_id", "=", workspaceId)
+            .where("provider", "=", candidate.provider)
+            .where("provider_connection_id", "=", candidate.physical_connection_id)
+            .where("status", "in", ["queued", "running"]))))
+            .returning("id")
+            .executeTakeFirst();
+        if (deleted === undefined) {
+            const connection = await trx.selectFrom("provider_connections").select("status")
+                .where("workspace_id", "=", workspaceId)
+                .where("provider", "=", candidate.provider)
+                .where("id", "=", candidate.physical_connection_id)
+                .executeTakeFirst();
+            if (connection !== undefined)
+                return false;
+        }
+        await trx.updateTable("provider_connection_revocations")
+            .set({ cleanup_completed_at: now })
+            .where("workspace_id", "=", workspaceId)
+            .where("provider", "=", candidate.provider)
+            .where("revoked_connection_id", "=", candidate.revoked_connection_id)
+            .where("cleanup_completed_at", "is", null)
+            .execute();
+        return true;
+    });
+}
+export async function upsertDeliveryRepository(trx, workspaceId, connection, repository) {
+    assertRepositoryProviders(connection.provider, [repository]);
+    const providerConnectionId = await upsertActiveProviderConnection(trx, workspaceId, connection);
+    if (providerConnectionId === null)
+        return null;
+    const repositoryId = await upsertRepository(trx, workspaceId, providerConnectionId, repository);
+    return { providerConnectionId, repositoryId };
+}
+async function upsertActiveProviderConnection(trx, workspaceId, input) {
+    await lockProviderConnectionProjection(trx, workspaceId);
+    const now = new Date();
+    const revocation = await trx.selectFrom("provider_connection_revocations")
+        .select("revoked_connection_id")
+        .where("workspace_id", "=", workspaceId)
+        .where("provider", "=", input.provider)
+        .where("external_connection_id", "=", input.externalConnectionId)
+        .forUpdate()
+        .executeTakeFirst();
+    if (revocation !== undefined)
+        return null;
+    const exact = await trx.selectFrom("provider_connections")
+        .select(["id", "status"])
+        .where("workspace_id", "=", workspaceId)
+        .where("provider", "=", input.provider)
+        .where("external_connection_id", "=", input.externalConnectionId)
+        .where("status", "!=", "revoked")
+        .forUpdate()
+        .executeTakeFirst();
+    if (exact !== undefined) {
+        const updated = await trx.updateTable("provider_connections").set({
+            workspace_login: input.workspaceLogin,
+            account_type: input.accountType,
+            status: "active",
+            updated_at: now,
+        }).where("workspace_id", "=", workspaceId)
+            .where("provider", "=", input.provider)
+            .where("id", "=", exact.id)
+            .returning("id")
+            .executeTakeFirstOrThrow();
+        return updated.id;
+    }
+    const active = await trx
+        .selectFrom("provider_connections")
+        .select("id")
+        .where("workspace_id", "=", workspaceId)
+        .where("status", "=", "active")
+        .forUpdate()
+        .executeTakeFirst();
+    if (active) {
+        const updated = await trx
+            .updateTable("provider_connections")
+            .set({
+            provider: input.provider,
+            external_connection_id: input.externalConnectionId,
+            workspace_login: input.workspaceLogin,
+            account_type: input.accountType,
+            status: "active",
+            updated_at: now,
+        })
+            .where("workspace_id", "=", workspaceId)
+            .where("id", "=", active.id)
+            .returning("id")
+            .executeTakeFirstOrThrow();
+        return updated.id;
+    }
+    const inserted = await trx
+        .insertInto("provider_connections")
+        .values({
+        workspace_id: workspaceId,
+        provider: input.provider,
+        external_connection_id: input.externalConnectionId,
+        workspace_login: input.workspaceLogin,
+        account_type: input.accountType,
+        status: "active",
+        permissions: {},
+    })
+        .returning("id")
+        .executeTakeFirstOrThrow();
+    return inserted.id;
+}
+async function upsertRepository(db, workspaceId, providerConnectionId, repository) {
+    const now = new Date();
+    const row = await db
+        .insertInto("repositories")
+        .values({
+        workspace_id: workspaceId,
+        provider: repository.provider,
+        provider_connection_id: providerConnectionId,
+        external_repository_id: repository.externalRepositoryId,
+        owner: repository.owner,
+        name: repository.name,
+        default_branch: null,
+        config_state: "unknown",
+    })
+        .onConflict((conflict) => conflict.columns(["workspace_id", "provider", "external_repository_id"]).doUpdateSet({
+        provider_connection_id: providerConnectionId,
+        owner: repository.owner,
+        name: repository.name,
+        updated_at: now,
+    }))
+        .returning("id")
+        .executeTakeFirstOrThrow();
+    return row.id;
+}
+export async function lockProviderConnectionProjection(trx, workspaceId) {
+    // Lifecycle projection changes serialize on this workspace lock before taking a provider row lock.
+    // Worker authority keeps its canonical job -> absence -> provider row order. Revocation never locks
+    // child rows, and deferred cleanup cascades only after no queued/running job references the generation.
+    await sql `select pg_advisory_xact_lock(hashtextextended(${workspaceId}, 764737450))`.execute(trx);
+}
+function assertRepositoryProviders(connectionProvider, repositories) {
+    if (repositories.some((repository) => repository.provider !== connectionProvider)) {
+        throw new Error("repository provider must match its provider connection");
+    }
+}

package/dist/retention.d.ts

@@ -0,0 +1,6 @@
+import type { Kysely } from "kysely";
+import type { WorkspaceId } from "@triagepilot/contracts";
+import type { Database } from "./kysely.js";
+export declare const RECEIPT_AND_COMPLETED_JOB_DAYS = 30;
+export declare const DECISION_AND_FAILURE_DAYS = 90;
+export declare function applyFixedRetention(db: Kysely<Database>, workspaceId: WorkspaceId, now: Date): Promise<void>;

package/dist/retention.js

@@ -0,0 +1,44 @@
+export const RECEIPT_AND_COMPLETED_JOB_DAYS = 30;
+export const DECISION_AND_FAILURE_DAYS = 90;
+export async function applyFixedRetention(db, workspaceId, now) {
+    const receiptAndCompletedJobCutoff = daysAgo(now, RECEIPT_AND_COMPLETED_JOB_DAYS);
+    const decisionAndFailureCutoff = daysAgo(now, DECISION_AND_FAILURE_DAYS);
+    await db.deleteFrom("webhook_receipts").where("workspace_id", "=", workspaceId).where("created_at", "<", receiptAndCompletedJobCutoff).execute();
+    await db
+        .deleteFrom("jobs")
+        .where("workspace_id", "=", workspaceId)
+        .where("status", "=", "succeeded")
+        .where("updated_at", "<", receiptAndCompletedJobCutoff)
+        .execute();
+    await db
+        .deleteFrom("jobs")
+        .where("workspace_id", "=", workspaceId)
+        .where("status", "=", "failed")
+        .where("updated_at", "<", decisionAndFailureCutoff)
+        .execute();
+    await db.deleteFrom("routing_decisions")
+        .where("workspace_id", "=", workspaceId)
+        .where("created_at", "<", decisionAndFailureCutoff)
+        .where(({ not, exists, selectFrom }) => not(exists(selectFrom("reviewer_mutation_intents")
+        .select("reviewer_mutation_intents.id")
+        .whereRef("reviewer_mutation_intents.workspace_id", "=", "routing_decisions.workspace_id")
+        .whereRef("reviewer_mutation_intents.decision_id", "=", "routing_decisions.id"))))
+        .where(({ not, exists, selectFrom }) => not(exists(selectFrom("reviewer_replacements")
+        .select("reviewer_replacements.id")
+        .whereRef("reviewer_replacements.workspace_id", "=", "routing_decisions.workspace_id")
+        .whereRef("reviewer_replacements.decision_id", "=", "routing_decisions.id"))))
+        .where(({ not, exists, selectFrom }) => not(exists(selectFrom("jobs")
+        .innerJoin("repositories", (join) => join
+        .onRef("repositories.workspace_id", "=", "jobs.workspace_id")
+        .onRef("repositories.provider", "=", "jobs.provider")
+        .onRef("repositories.provider_connection_id", "=", "jobs.provider_connection_id"))
+        .select("jobs.id")
+        .whereRef("jobs.workspace_id", "=", "routing_decisions.workspace_id")
+        .whereRef("repositories.id", "=", "routing_decisions.repository_id")
+        .where("jobs.kind", "=", "activate_reviewer_absence")
+        .where("jobs.status", "in", ["queued", "running"]))))
+        .execute();
+}
+function daysAgo(now, days) {
+    return new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
+}

package/dist/routing-recovery.d.ts

@@ -0,0 +1,55 @@
+import { type Kysely } from "kysely";
+import type { ChangeRequestId, ProviderConnectionId, ProviderKind, RepositoryRef, RoutingJobPayload, WorkspaceId } from "@triagepilot/contracts";
+import type { Database } from "./kysely.js";
+export type RoutingRecoveryTargetRequest = {
+    decisionId: string;
+} | {
+    changeRequest: {
+        repository: RepositoryRef;
+        externalId: ChangeRequestId;
+        number: number;
+    };
+};
+export interface RoutingRecoveryTarget {
+    providerConnectionId: ProviderConnectionId;
+    repository: RepositoryRef;
+    changeRequestId: ChangeRequestId;
+    changeRequestNumber: number;
+}
+export interface RoutingRecoveryEnqueueInput {
+    provider: ProviderKind;
+    providerConnectionId: ProviderConnectionId;
+    payload: RoutingJobPayload;
+    idempotencyKey: string;
+}
+export interface WorkspaceRoutingRecoveryRepository {
+    findTarget(request: RoutingRecoveryTargetRequest): Promise<RoutingRecoveryTarget | null>;
+    findActiveRepository(input: {
+        provider: ProviderKind;
+        owner: string;
+        name: string;
+    }): Promise<RepositoryRef | null>;
+    findActiveExternalConnectionId(input: {
+        provider: ProviderKind;
+        providerConnectionId: ProviderConnectionId;
+    }): Promise<string | null>;
+    enqueue(input: RoutingRecoveryEnqueueInput): Promise<{
+        inserted: boolean;
+        jobId: string;
+    } | null>;
+}
+export declare function createWorkspaceRoutingRecoveryRepository(db: Kysely<Database>, workspaceId: WorkspaceId): WorkspaceRoutingRecoveryRepository;
+export declare function findRoutingRecoveryTarget(db: Kysely<Database>, workspaceId: WorkspaceId, request: RoutingRecoveryTargetRequest): Promise<RoutingRecoveryTarget | null>;
+export declare function findActiveRecoveryRepository(db: Kysely<Database>, workspaceId: WorkspaceId, input: {
+    provider: ProviderKind;
+    owner: string;
+    name: string;
+}): Promise<RepositoryRef | null>;
+export declare function findActiveExternalConnectionId(db: Kysely<Database>, workspaceId: WorkspaceId, input: {
+    provider: ProviderKind;
+    providerConnectionId: ProviderConnectionId;
+}): Promise<string | null>;
+export declare function enqueueRoutingRecovery(db: Kysely<Database>, workspaceId: WorkspaceId, input: RoutingRecoveryEnqueueInput): Promise<{
+    inserted: boolean;
+    jobId: string;
+} | null>;