@opengeni/db 5.0.1 → 6.0.0

package/src/organization-usage.ts

@@ -0,0 +1,83 @@
+import {
+  OrganizationUsageQuery,
+  OrganizationUsageSummary,
+  OrganizationUsageWorkspacePage,
+  OrganizationUsageWorkspacePageQuery,
+  type OrganizationUsagePeriod,
+} from "@opengeni/contracts";
+import { sql } from "drizzle-orm";
+import { withAccountRls, type Database } from "./database";
+
+/** Same UTC semantics as Insights: week is today and the previous six days. */
+export function organizationUsageWindow(period: OrganizationUsagePeriod, now = new Date()) {
+  const until = new Date(now);
+  const since = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+  if (period === "week") since.setUTCDate(since.getUTCDate() - 6);
+  if (period === "month") since.setUTCDate(1);
+  if (period === "ytd") since.setUTCMonth(0, 1);
+  if (!Number.isFinite(until.getTime())) throw new Error("Invalid usage window");
+  return {
+    since: since.toISOString(),
+    until: until.toISOString(),
+    granularity: period === "today" ? ("hour" as const) : ("day" as const),
+  };
+}
+
+type UsageInput = { accountId: string; period?: OrganizationUsagePeriod | undefined };
+
+/** One set-based, actor-visible aggregate. Must use the writable primary. */
+export async function getOrganizationUsageSummary(
+  db: Database,
+  input: UsageInput,
+  now = new Date(),
+): Promise<OrganizationUsageSummary> {
+  const query = OrganizationUsageQuery.parse(input);
+  const window = organizationUsageWindow(query.period, now);
+  const result = await readOrganizationUsage(db, input.accountId, window, true);
+  return OrganizationUsageSummary.parse({
+    ...result,
+    accountId: input.accountId,
+    period: query.period,
+    ...window,
+  });
+}
+
+/** Bounded page-only scan; never recomputes organization-wide totals/buckets. */
+export async function getOrganizationUsageWorkspacePage(
+  db: Database,
+  input: UsageInput & { until: string; afterWorkspaceId?: string | undefined },
+): Promise<OrganizationUsageWorkspacePage> {
+  const query = OrganizationUsageWorkspacePageQuery.parse(input);
+  const window = organizationUsageWindow(query.period, new Date(query.until));
+  const result = await readOrganizationUsage(
+    db,
+    input.accountId,
+    window,
+    false,
+    query.afterWorkspaceId,
+  );
+  return OrganizationUsageWorkspacePage.parse({
+    ...result,
+    accountId: input.accountId,
+    period: query.period,
+    ...window,
+  });
+}
+
+async function readOrganizationUsage(
+  db: Database,
+  accountId: string,
+  window: ReturnType<typeof organizationUsageWindow>,
+  includePeriod: boolean,
+  afterWorkspaceId?: string,
+) {
+  return await withAccountRls(db, accountId, async (scopedDb) => {
+    await scopedDb.execute(sql`select set_config('statement_timeout', '10s', true)`);
+    const result = await scopedDb.execute(sql`select opengeni_private.organization_usage_summary(
+      ${accountId}::uuid, ${window.since}::timestamptz, ${window.until}::timestamptz,
+      ${window.granularity}::text, ${afterWorkspaceId ?? null}::uuid, ${includePeriod}::boolean
+    ) as summary`);
+    const rows = Array.isArray(result) ? result : (result as { rows: unknown[] }).rows;
+    return (rows[0] as { summary: Record<string, unknown> }).summary;
+  });
+}

package/src/plugin-packages.ts

@@ -1,6 +1,12 @@
 import { createHash } from "node:crypto";
 
-import { stableJson, type CapabilityCatalogAuthKind, type SkillActor } from "@opengeni/contracts";
+import {
+  stableJson,
+  type CapabilityCatalogAuthKind,
+  type SkillActor,
+  type PluginUninstallComponentImpact,
+  type PluginUninstallPreview,
+} from "@opengeni/contracts";
 import { and, asc, eq, inArray, ne, or, sql } from "drizzle-orm";
 
 import {
@@ -8,8 +14,19 @@ import {
   cleanupOrphanedCapabilityComponents,
   lockCapabilityComponentIdentity,
 } from "./capability-components";
-import { setSubjectRlsContext, withRlsContext, withWorkspaceRls, type Database } from "./database";
-import type { SkillSourceReleaseReceipt } from "./skill-source-release";
+import {
+  rawRows,
+  setSubjectRlsContext,
+  withRlsContext,
+  withWorkspaceRls,
+  type Database,
+} from "./database";
+import {
+  readSkillSourceReleaseHeads,
+  SkillSourceReleaseSnapshotChangedError,
+  type SkillSourceReleaseReceipt,
+} from "./skill-source-release";
+import { classifySkillSourceRelease } from "./skill-source-release-impact";
 import {
   removeIntegrationFacetBindingOwner,
   removeIntegrationFacetBindingOwnersForOwner,
@@ -21,6 +38,8 @@ import {
   readSkillPublications,
 } from "./skill-publication";
 import type { SkillPublicationReceipt } from "@opengeni/contracts";
+import { withOrganizationIntegrationAcquisition } from "./organization-integration-policy";
+import { nestedPostgresSqlState } from "./persistence-errors";
 
 export type PluginBomComponent = {
   key: string;
@@ -70,6 +89,14 @@ export class PluginInstallationVersionConflictError extends Error {
   readonly name = "PluginInstallationVersionConflictError";
 }
 
+export class PluginUninstallPreviewChangedError extends Error {
+  readonly code = "plugin_uninstall_preview_changed";
+  constructor(readonly preview?: PluginUninstallPreview) {
+    super("Plugin removal impact changed. Review the refreshed preview before confirming again.");
+    this.name = "PluginUninstallPreviewChangedError";
+  }
+}
+
 export class PluginInstallationVersionRequiredError extends Error {
   readonly name = "PluginInstallationVersionRequiredError";
 }
@@ -626,6 +653,16 @@ export async function installPluginMcpReference(
     authKind: CapabilityCatalogAuthKind;
     digest: string;
   },
+): Promise<{ capabilityId: string; facetInstallationId: string }> {
+  const snapshot = structuredClone(input);
+  return withOrganizationIntegrationAcquisition(db, snapshot, ["custom:mcp"], (tx) =>
+    installPluginMcpReferenceInScope(tx, snapshot),
+  );
+}
+
+async function installPluginMcpReferenceInScope(
+  db: Database,
+  input: Parameters<typeof installPluginMcpReference>[1],
 ): Promise<{ capabilityId: string; facetInstallationId: string }> {
   const capabilityId = `mcp:configured:${input.serverId}`;
   const pluginKey = `plugin-mcp/${input.serverId}`;
@@ -898,31 +935,21 @@ export async function getPluginPackageUninstallPreview(
   db: Database,
   workspaceId: string,
   pluginKey: string,
-): Promise<{
-  installed: boolean;
-  version: string | null;
-  installationVersion: number | null;
-  components: Array<{
-    capabilityId: string;
-    kind: "skill" | "integration" | "mcp";
-    retainedByOtherOwners: boolean;
-  }>;
-}> {
+  subjectId?: string,
+): Promise<Omit<PluginUninstallPreview, "pluginKey">> {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
+    if (subjectId) await setSubjectRlsContext(scopedDb, subjectId);
     const plugin = await pluginPackageInScope(scopedDb, workspaceId, pluginKey);
     if (!plugin || plugin.status === "disabled") {
       return { installed: false, version: null, installationVersion: null, components: [] };
     }
-    const components = await pluginOwnedComponents(
-      scopedDb,
-      workspaceId,
-      plugin.pluginInstallationId,
-    );
+    const impact = await pluginOwnedComponents(scopedDb, workspaceId, plugin.pluginInstallationId);
     return {
       installed: true,
       version: plugin.version,
       installationVersion: plugin.installationVersion,
-      components,
+      components: impact.components,
+      previewToken: pluginUninstallPreviewToken(plugin, impact.stateToken),
     };
   });
 }
@@ -935,6 +962,7 @@ export async function uninstallPluginPackage(
     subjectId: string;
     pluginKey: string;
     expectedInstallationVersion: number;
+    expectedPreviewToken?: string;
     idempotencyKey: string;
     skillActor?: SkillActor;
   },
@@ -947,6 +975,7 @@ export async function uninstallPluginPackage(
     stableJson({
       pluginKey: input.pluginKey,
       expectedInstallationVersion: input.expectedInstallationVersion,
+      ...(input.expectedPreviewToken ? { expectedPreviewToken: input.expectedPreviewToken } : {}),
     }),
   );
   return await withRlsContext(
@@ -956,6 +985,7 @@ export async function uninstallPluginPackage(
       await setSubjectRlsContext(scopedDb, input.subjectId);
       return await scopedDb.transaction(async (txRaw) => {
         const tx = txRaw as unknown as Database;
+        await lockSkillPublication(tx, input.workspaceId);
         await tx.execute(
           sql`select pg_advisory_xact_lock(hashtextextended(${`capability-operation:${input.workspaceId}:${input.idempotencyKey}`}, 0))`,
         );
@@ -1004,11 +1034,78 @@ export async function uninstallPluginPackage(
         if (plugin.installationVersion !== input.expectedInstallationVersion) {
           throw new PluginInstallationVersionConflictError("Plugin installation changed");
         }
-        const components = await pluginOwnedComponents(
+        // Match cleanup/source-refresh ordering: child installations, then canonical
+        // registry heads. Hold these locks through token comparison AND release.
+        await tx.execute(sql`SELECT p.id FROM capability_plugin_installations p
+          WHERE p.workspace_id=${input.workspaceId}::uuid AND p.id IN (
+            SELECT fi.plugin_installation_id FROM capability_facet_installations fi
+            JOIN capability_component_owners o ON o.facet_installation_id=fi.id
+            WHERE o.workspace_id=${input.workspaceId}::uuid AND o.owner_kind='plugin'
+              AND o.owner_id=${plugin.pluginInstallationId}
+          ) ORDER BY p.id FOR UPDATE`);
+        try {
+          // Facet FK locks fence new owners; owner row locks fence releases by
+
+          // Those paths may remove an owner before acquiring the child lock, so
+          // fail for a refreshed preview rather than creating a lock-order cycle.
+          await tx.execute(sql`SELECT fi.id FROM capability_facet_installations fi
+            WHERE fi.workspace_id=${input.workspaceId}::uuid AND EXISTS (
+              SELECT 1 FROM capability_component_owners own
+              WHERE own.facet_installation_id=fi.id AND own.owner_kind='plugin'
+                AND own.owner_id=${plugin.pluginInstallationId}
+            ) ORDER BY fi.id FOR UPDATE NOWAIT`);
+          await tx.execute(sql`SELECT o.id FROM capability_component_owners o
+            WHERE o.workspace_id=${input.workspaceId}::uuid AND EXISTS (
+              SELECT 1 FROM capability_component_owners own
+              WHERE own.facet_installation_id=o.facet_installation_id
+                AND own.owner_kind='plugin' AND own.owner_id=${plugin.pluginInstallationId}
+            ) ORDER BY o.id FOR UPDATE NOWAIT`);
+        } catch (error) {
+          if (nestedPostgresSqlState(error) === "55P03")
+            throw new PluginUninstallPreviewChangedError();
+          throw error;
+        }
+        const skillBindings = await rawRows<{ id: string }>(
+          tx,
+          sql`
+          SELECT DISTINCT h.id FROM skill_source_bindings b
+          JOIN capability_facet_installations fi ON fi.facet_id=b.skill_facet_id
+            AND fi.account_id=b.account_id AND fi.workspace_id=b.workspace_id
+          JOIN capability_component_owners o ON o.facet_installation_id=fi.id
+          JOIN preference_registry_preferences h ON h.id=b.preference_id AND h.account_id=b.account_id
+          WHERE b.workspace_id=${input.workspaceId}::uuid AND o.owner_kind='plugin'
+            AND o.owner_id=${plugin.pluginInstallationId} ORDER BY h.id`,
+        );
+        for (const head of skillBindings) {
+          try {
+            await tx.execute(
+              sql`SELECT preference_id FROM preference_registry_lock_heads(ARRAY[${head.id}::uuid])`,
+            );
+          } catch (error) {
+            // A concurrent scope move can make the selected head invisible while
+            // this lock waits. Roll back and obtain the refreshed preview outside
+            // the failed transaction, without disclosing the hidden head.
+            if (nestedPostgresSqlState(error) === "42501")
+              throw new PluginUninstallPreviewChangedError();
+            throw error;
+          }
+        }
+        const impact = await pluginOwnedComponents(
           tx,
           input.workspaceId,
           plugin.pluginInstallationId,
         );
+        const previewToken = pluginUninstallPreviewToken(plugin, impact.stateToken);
+        if (input.expectedPreviewToken && input.expectedPreviewToken !== previewToken) {
+          throw new PluginUninstallPreviewChangedError({
+            pluginKey: input.pluginKey,
+            installed: true,
+            version: plugin.version,
+            installationVersion: plugin.installationVersion,
+            previewToken,
+            components: impact.components,
+          });
+        }
         await removeIntegrationFacetBindingOwnersForOwner(tx, {
           workspaceId: input.workspaceId,
           owner: { kind: "plugin", id: plugin.pluginInstallationId },
@@ -1023,12 +1120,20 @@ export async function uninstallPluginPackage(
             ),
           )
           .returning({ facetInstallationId: schema.capabilityComponentOwners.facetInstallationId });
-        const skillReleases = await cleanupOrphanedCapabilityComponents(
-          tx,
-          input.workspaceId,
-          owned.map((row) => row.facetInstallationId),
-          input.skillActor,
-        );
+        let skillReleases: SkillSourceReleaseReceipt[];
+        try {
+          skillReleases = await cleanupOrphanedCapabilityComponents(
+            tx,
+            input.workspaceId,
+            owned.map((row) => row.facetInstallationId),
+            input.skillActor,
+            skillBindings.map((head) => head.id),
+          );
+        } catch (error) {
+          if (error instanceof SkillSourceReleaseSnapshotChangedError)
+            throw new PluginUninstallPreviewChangedError();
+          throw error;
+        }
         await tx
           .update(schema.capabilityPluginInstallations)
           .set({
@@ -1037,8 +1142,8 @@ export async function uninstallPluginPackage(
             updatedAt: new Date(),
           })
           .where(eq(schema.capabilityPluginInstallations.id, plugin.pluginInstallationId));
-        const retainedComponents = components
-          .filter((component) => component.retainedByOtherOwners)
+        const retainedComponents = impact.components
+          .filter((component) => component.disposition === "retained")
           .map((component) => component.capabilityId);
         await completeInlineOperation(tx, input, requestDigest, {
           status: "uninstalled",
@@ -1097,18 +1202,13 @@ async function pluginOwnedComponents(
   db: Database,
   workspaceId: string,
   ownerPluginInstallationId: string,
-): Promise<
-  Array<{
-    capabilityId: string;
-    kind: "skill" | "integration" | "mcp";
-    retainedByOtherOwners: boolean;
-  }>
-> {
+): Promise<{ components: PluginUninstallComponentImpact[]; stateToken: string }> {
   const rows = await db
     .select({
       facetInstallationId: schema.capabilityFacetInstallations.id,
       facetKind: schema.capabilityFacets.kind,
       skillCapabilityId: schema.capabilitySkillFacets.capabilityId,
+      name: schema.capabilityPlugins.name,
       manifest: schema.capabilityPluginVersions.manifest,
     })
     .from(schema.capabilityComponentOwners)
@@ -1134,6 +1234,10 @@ async function pluginOwnedComponents(
       schema.capabilityPluginVersions,
       eq(schema.capabilityPluginVersions.id, schema.capabilityPluginInstallations.pluginVersionId),
     )
+    .innerJoin(
+      schema.capabilityPlugins,
+      eq(schema.capabilityPlugins.id, schema.capabilityPluginInstallations.pluginId),
+    )
     .leftJoin(
       schema.capabilitySkillFacets,
       eq(schema.capabilitySkillFacets.facetId, schema.capabilityFacets.id),
@@ -1148,7 +1252,12 @@ async function pluginOwnedComponents(
     .orderBy(asc(schema.capabilityFacets.kind), asc(schema.capabilityFacets.facetKey));
   const components = new Map<
     string,
-    { capabilityId: string; kind: "skill" | "integration" | "mcp"; facetIds: string[] }
+    {
+      capabilityId: string;
+      name: string;
+      kind: "skill" | "integration" | "mcp";
+      facetIds: string[];
+    }
   >();
   for (const row of rows) {
     const manifest = objectValue(row.manifest);
@@ -1164,15 +1273,26 @@ async function pluginOwnedComponents(
     if (!capabilityId || !kind) continue;
     const existing = components.get(capabilityId);
     if (existing) existing.facetIds.push(row.facetInstallationId);
-    else components.set(capabilityId, { capabilityId, kind, facetIds: [row.facetInstallationId] });
+    else
+      components.set(capabilityId, {
+        capabilityId,
+        kind,
+        name: row.name,
+        facetIds: [row.facetInstallationId],
+      });
   }
-  const result = [];
+  const result: PluginUninstallComponentImpact[] = [];
+  const state: unknown[] = [];
   for (const component of components.values()) {
-    const [ownerCount] = await db
-      .select({ count: sql<number>`count(*)::int` })
+    const owners = await db
+      .select({
+        kind: schema.capabilityComponentOwners.ownerKind,
+        id: schema.capabilityComponentOwners.ownerId,
+      })
       .from(schema.capabilityComponentOwners)
       .where(
         and(
+          eq(schema.capabilityComponentOwners.workspaceId, workspaceId),
           inArray(schema.capabilityComponentOwners.facetInstallationId, component.facetIds),
           // Retention is deliberately physical, not runtime-effective. A Plugin
           // in needs_attention may be resumable and must keep shared component
@@ -1185,13 +1305,77 @@ async function pluginOwnedComponents(
           ),
         ),
       );
+    const remainingOwners: PluginUninstallComponentImpact["remainingOwners"] = [];
+    for (const owner of owners.sort((a, b) =>
+      `${a.kind}:${a.id}`.localeCompare(`${b.kind}:${b.id}`),
+    )) {
+      let name =
+        owner.kind === "direct"
+          ? "Direct installation"
+          : owner.kind === "migration"
+            ? "Migrated installation"
+            : "Another installed owner";
+      if (owner.kind === "plugin") {
+        const [named] = await db
+          .select({ manifest: schema.capabilityPluginVersions.manifest })
+          .from(schema.capabilityPluginInstallations)
+          .innerJoin(
+            schema.capabilityPluginVersions,
+            eq(
+              schema.capabilityPluginVersions.id,
+              schema.capabilityPluginInstallations.pluginVersionId,
+            ),
+          )
+          .where(
+            and(
+              eq(schema.capabilityPluginInstallations.workspaceId, workspaceId),
+              sql`${schema.capabilityPluginInstallations.id}::text = ${owner.id}`,
+            ),
+          );
+        name = stringValue(objectValue(named?.manifest).name) ?? name;
+      }
+      if (!remainingOwners.some((item) => item.kind === owner.kind && item.name === name))
+        remainingOwners.push({
+          kind: owner.kind as PluginUninstallComponentImpact["remainingOwners"][number]["kind"],
+          name,
+        });
+    }
+    const heads =
+      component.kind === "skill"
+        ? await readSkillSourceReleaseHeads(db, workspaceId, component.facetIds)
+        : [];
+    const head = heads[0];
+    const skillImpact = head ? classifySkillSourceRelease(head, workspaceId) : null;
+    const retainedByOtherOwners = owners.length > 0;
+    const retentionReasons: PluginUninstallComponentImpact["retentionReasons"] = [];
+    if (retainedByOtherOwners) retentionReasons.push("other_owners");
+    if (skillImpact) retentionReasons.push(...skillImpact.retentionReasons);
+    else if (component.kind === "skill") retentionReasons.push("registry_unavailable");
+    state.push({ facetIds: component.facetIds, owners, heads });
     result.push({
       capabilityId: component.capabilityId,
       kind: component.kind,
-      retainedByOtherOwners: (ownerCount?.count ?? 0) > 0,
+      name: head?.title ?? component.name,
+      retainedByOtherOwners,
+      disposition: retainedByOtherOwners
+        ? "retained"
+        : (skillImpact?.disposition ?? (component.kind === "skill" ? "retained" : "removed")),
+      retentionReasons,
+      remainingOwners,
+      ...(head ? { skillId: head.id } : {}),
     });
   }
-  return result;
+  return { components: result, stateToken: sha256(stableJson({ state, components: result })) };
+}
+
+function pluginUninstallPreviewToken(plugin: InstalledPluginPackage, stateToken: string): string {
+  return sha256(
+    stableJson({
+      installationId: plugin.pluginInstallationId,
+      version: plugin.installationVersion,
+      stateToken,
+    }),
+  );
 }
 
 async function completeInlineOperation(

package/src/pr-review.ts

@@ -1,6 +1,5 @@
 import {
   AutomationSessionTemplate,
-  OPENGENI_PR_REVIEW_PACK_ID,
   OPENGENI_PR_REVIEW_SESSION_ROLE,
   type PrReviewAppRegistration,
   type GitHubRepository,
@@ -43,8 +42,6 @@ export async function createPrReviewAppRegistration(
     webhookSecretEncrypted: string;
     webhookUsername: string | null;
     createdBySubjectId: string;
-    packInstallationId: string;
-    packConnectorId: string;
   },
 ): Promise<PrReviewAppRegistration> {
   return await withRlsContext(db, input, async (scopedDb) => {
@@ -64,8 +61,7 @@ export async function createPrReviewAppRegistration(
             webhookUsername: input.webhookUsername,
           },
           webhookSecretEncrypted: input.webhookSecretEncrypted,
-          packInstallationId: input.packInstallationId,
-          packConnectorId: input.packConnectorId,
+
           createdBySubjectId: input.createdBySubjectId,
         })
         .returning();
@@ -312,8 +308,7 @@ export async function createPrReviewRepositoryBinding(
     additionalInstructions: string | null;
     status: "active" | "disabled";
     createdBySubjectId: string;
-    packInstallationId: string;
-    packTemplateId: string;
+
     adapterId: string;
     eventTypes: string[];
     configuration: Record<string, unknown>;
@@ -357,8 +352,7 @@ export async function createPrReviewRepositoryBinding(
           sourceId: registration.sourceId,
           name: `Review ${input.repositoryFullName}`,
           status: input.status,
-          packInstallationId: input.packInstallationId,
-          packTemplateId: input.packTemplateId,
+
           createdBySubjectId: input.createdBySubjectId,
         })
         .returning();
@@ -401,10 +395,6 @@ export async function createPrReviewRepositoryBinding(
   });
 }
 
-/** Atomically converge one owner-authorized installation of the deployment
- * review App onto the Pack's ordinary source/trigger/binding model. Re-running
- * the browser flow repairs disabled rows, follows GitHub repository selection,
- * and removes shared-webhook routes for repositories no longer selected. */
 export async function syncManagedGitHubPrReviewInstallation(
   db: Database,
   input: {
@@ -422,9 +412,7 @@ export async function syncManagedGitHubPrReviewInstallation(
     webhookSecretEncrypted: string;
     repositories: GitHubRepository[];
     createdBySubjectId: string;
-    packInstallationId: string;
-    packConnectorId: string;
-    packTemplateId: string;
+
     adapterId: string;
     eventTypes: string[];
     configuration: Record<string, unknown>;
@@ -439,22 +427,6 @@ export async function syncManagedGitHubPrReviewInstallation(
     input,
     async (scopedDb) =>
       await scopedDb.transaction(async (tx) => {
-        const [packInstallation] = await tx
-          .select({ id: schema.packInstallations.id })
-          .from(schema.packInstallations)
-          .where(
-            and(
-              eq(schema.packInstallations.workspaceId, input.workspaceId),
-              eq(schema.packInstallations.id, input.packInstallationId),
-              eq(schema.packInstallations.packId, OPENGENI_PR_REVIEW_PACK_ID),
-              eq(schema.packInstallations.status, "active"),
-            ),
-          )
-          .limit(1)
-          .for("update");
-        if (!packInstallation) {
-          throw new PrReviewDispatchAuthorityError("OpenGeni Review Bot Pack is not active");
-        }
         const installationId = String(input.installationId);
         const [nonceReceipt] = await tx
           .insert(schema.prReviewManagedGithubAuthorityNonces)
@@ -507,8 +479,7 @@ export async function syncManagedGitHubPrReviewInstallation(
               configuration: nextSourceConfiguration,
               webhookSecretEncrypted: input.webhookSecretEncrypted,
               status: "active",
-              packInstallationId: input.packInstallationId,
-              packConnectorId: input.packConnectorId,
+
               version: sql`${schema.automationSources.version} + 1`,
               updatedAt: new Date(),
             })
@@ -559,8 +530,7 @@ export async function syncManagedGitHubPrReviewInstallation(
                 webhookUsername: null,
               },
               webhookSecretEncrypted: input.webhookSecretEncrypted,
-              packInstallationId: input.packInstallationId,
-              packConnectorId: input.packConnectorId,
+
               createdBySubjectId: input.createdBySubjectId,
             })
             .returning();
@@ -655,8 +625,7 @@ export async function syncManagedGitHubPrReviewInstallation(
                 sourceId: source.id,
                 name: `Review ${repository.fullName}`,
                 status: "active",
-                packInstallationId: input.packInstallationId,
-                packTemplateId: input.packTemplateId,
+
                 createdBySubjectId: input.createdBySubjectId,
               })
               .returning();
@@ -1079,10 +1048,6 @@ export async function resolvePrReviewGitCredential(
         runSessionId: schema.automationRuns.sessionId,
         triggerStatus: schema.automationTriggers.status,
         sourceStatus: schema.automationSources.status,
-        sourcePackInstallationId: schema.automationSources.packInstallationId,
-        sourcePackConnectorId: schema.automationSources.packConnectorId,
-        packInstallationId: schema.packInstallations.id,
-        packStatus: schema.packInstallations.status,
         bindingStatus: schema.prReviewRepositoryBindings.status,
         registrationStatus: schema.prReviewAppRegistrations.status,
       })
@@ -1116,13 +1081,6 @@ export async function resolvePrReviewGitCredential(
           eq(schema.prReviewAppRegistrations.sourceId, schema.automationRuns.sourceId),
         ),
       )
-      .innerJoin(
-        schema.packInstallations,
-        and(
-          eq(schema.packInstallations.workspaceId, schema.automationRuns.workspaceId),
-          eq(schema.packInstallations.id, schema.automationTriggers.packInstallationId),
-        ),
-      )
       .where(
         and(
           eq(schema.automationRuns.workspaceId, input.workspaceId),
@@ -1131,7 +1089,6 @@ export async function resolvePrReviewGitCredential(
           eq(schema.automationRuns.sessionId, input.sessionId),
           eq(schema.prReviewRepositoryBindings.id, bindingId),
           eq(schema.prReviewAppRegistrations.id, input.registrationId),
-          eq(schema.packInstallations.packId, OPENGENI_PR_REVIEW_PACK_ID),
         ),
       )
       .limit(1);
@@ -1141,9 +1098,6 @@ export async function resolvePrReviewGitCredential(
       execution.runSessionId !== input.sessionId ||
       execution.triggerStatus !== "active" ||
       execution.sourceStatus !== "active" ||
-      execution.sourcePackInstallationId !== execution.packInstallationId ||
-      execution.sourcePackConnectorId !== prReviewProviderPackConnectorId(input.provider) ||
-      execution.packStatus !== "active" ||
       execution.bindingStatus !== "active" ||
       execution.registrationStatus !== "active"
     ) {
@@ -1194,18 +1148,6 @@ export async function resolvePrReviewGitCredential(
           "PR Review credential is not authorized for this repository",
         );
     }
-    const [pack] = await scopedDb
-      .select({ status: schema.packInstallations.status })
-      .from(schema.packInstallations)
-      .where(
-        and(
-          eq(schema.packInstallations.workspaceId, input.workspaceId),
-          eq(schema.packInstallations.packId, OPENGENI_PR_REVIEW_PACK_ID),
-        ),
-      )
-      .limit(1);
-    if (pack?.status !== "active")
-      throw new PrReviewDispatchAuthorityError("OpenGeni Review Bot Pack is not active");
     return {
       credentialKind: registration.credentialKind as
         | "github_app"
@@ -1218,10 +1160,6 @@ export async function resolvePrReviewGitCredential(
   });
 }
 
-function prReviewProviderPackConnectorId(provider: PrReviewProvider): string {
-  return provider === "azure_devops" ? "azure-devops" : provider;
-}
-
 function prReviewMetadataText(metadata: unknown, key: string): string | null {
   if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) return null;
   const value = (metadata as Record<string, unknown>)[key];

package/src/preference-registry-schema.ts

@@ -80,6 +80,7 @@ export const preferenceRegistryRevisions = pgTable(
     contentHash: text("content_hash").notNull(),
     skillFiles: jsonb("skill_files").$type<Array<{ path: string; content: string }> | null>(),
     skillActivationMode: text("skill_activation_mode"),
+    skillRemovalOperationId: uuid("skill_removal_operation_id"),
     precedenceRank: integer("precedence_rank").notNull().default(0),
     conflictStrategy: text("conflict_strategy").notNull(),
     conflictsWith: jsonb("conflicts_with").$type<string[]>().notNull().default([]),