@opengeni/db 6.0.1 → 6.0.3

package/src/insights.ts

@@ -990,34 +990,45 @@ export async function aggregateSessionDepth(
 }> {
   const context = await rlsContextForWorkspace(db, workspaceId);
   return await withRlsContext(db, context, async (scopedDb) => {
-    const buckets = await scopedDb
-      .select({
-        depth: schema.sessions.nestedAgentDepth,
-        sessions: sql<number>`count(*)::int`,
-      })
-      .from(schema.sessions)
-      .where(eq(schema.sessions.workspaceId, workspaceId))
-      .groupBy(schema.sessions.nestedAgentDepth)
-      .orderBy(schema.sessions.nestedAgentDepth);
-    const [stats] = await scopedDb
-      .select({
-        sessionsTouched: sql<number>`count(*)::int`,
-        rootSessions: sql<number>`count(*) filter (where ${schema.sessions.nestedAgentDepth} = 0)::int`,
-        deepestDepth: sql<number>`coalesce(max(${schema.sessions.nestedAgentDepth}), 0)`,
-        avgDepth: sql<number>`coalesce(avg(${schema.sessions.nestedAgentDepth}), 0)`,
-      })
-      .from(schema.sessions)
-      .where(eq(schema.sessions.workspaceId, workspaceId));
-    const [deepest] = await scopedDb
-      .select({
-        id: schema.sessions.id,
-        title: schema.sessions.title,
-        depth: schema.sessions.nestedAgentDepth,
-      })
-      .from(schema.sessions)
-      .where(eq(schema.sessions.workspaceId, workspaceId))
-      .orderBy(desc(schema.sessions.nestedAgentDepth), desc(schema.sessions.updatedAt))
-      .limit(1);
+    // One grouped pass over the workspace's sessions yields every count the
+    // summary needs; the totals, root count, deepest depth, and mean are
+    // derived from the buckets instead of rescanning a wide sessions heap.
+    const buckets = (
+      await scopedDb
+        .select({
+          depth: schema.sessions.nestedAgentDepth,
+          sessions: sql<number>`count(*)::int`,
+        })
+        .from(schema.sessions)
+        .where(eq(schema.sessions.workspaceId, workspaceId))
+        .groupBy(schema.sessions.nestedAgentDepth)
+        .orderBy(schema.sessions.nestedAgentDepth)
+    ).map((row) => ({ depth: row.depth, sessions: Number(row.sessions) }));
+    const sessionsTouched = buckets.reduce((sum, bucket) => sum + bucket.sessions, 0);
+    const rootSessions = buckets.find((bucket) => bucket.depth === 0)?.sessions ?? 0;
+    const deepestDepth = buckets.reduce((max, bucket) => Math.max(max, bucket.depth), 0);
+    const avgDepth =
+      sessionsTouched > 0
+        ? buckets.reduce((sum, bucket) => sum + bucket.depth * bucket.sessions, 0) / sessionsTouched
+        : 0;
+    const [deepest] =
+      sessionsTouched > 0
+        ? await scopedDb
+            .select({
+              id: schema.sessions.id,
+              title: schema.sessions.title,
+              depth: schema.sessions.nestedAgentDepth,
+            })
+            .from(schema.sessions)
+            .where(
+              and(
+                eq(schema.sessions.workspaceId, workspaceId),
+                eq(schema.sessions.nestedAgentDepth, deepestDepth),
+              ),
+            )
+            .orderBy(desc(schema.sessions.updatedAt))
+            .limit(1)
+        : [];
     const [goals] = await scopedDb
       .select({
         active: sql<number>`count(*) filter (where ${schema.sessionGoals.status} = 'active')::int`,
@@ -1026,16 +1037,13 @@ export async function aggregateSessionDepth(
       .from(schema.sessionGoals)
       .where(eq(schema.sessionGoals.workspaceId, workspaceId));
     return {
-      buckets: buckets.map((row) => ({
-        depth: row.depth,
-        sessions: Number(row.sessions),
-      })),
-      sessionsTouched: Number(stats?.sessionsTouched ?? 0),
-      rootSessions: Number(stats?.rootSessions ?? 0),
-      deepestDepth: Number(stats?.deepestDepth ?? 0),
+      buckets,
+      sessionsTouched,
+      rootSessions,
+      deepestDepth,
       deepestSessionId: deepest?.id ?? null,
       deepestSessionTitle: deepest?.title?.trim() || "",
-      avgDepth: Number(stats?.avgDepth ?? 0),
+      avgDepth,
       goalsActive: Number(goals?.active ?? 0),
       goalsCompleted: Number(goals?.completed ?? 0),
     };

package/src/knowledge-entries.ts

@@ -19,6 +19,7 @@ import {
   KnowledgeEntryRestoreRequest,
   KnowledgeEntrySaveRequest,
   KnowledgeEntrySummary,
+  KnowledgeIndexStatus,
   KnowledgeEntryWriteReceipt,
   type AgentLearningContext,
   type KnowledgeEntryScope,
@@ -319,6 +320,39 @@ function decodeProjection(value: unknown, full: boolean) {
       });
 }
 
+/** The owner-definer seam rechecks canonical visibility for every exact revision. */
+async function withIndexStatus<T extends KnowledgeEntryRecord | KnowledgeEntrySummary>(
+  db: Database,
+  context: KnowledgeContext,
+  entries: T[],
+  view: "published" | "needs_review" | "archived" | "rejected",
+): Promise<T[]> {
+  if (view === "archived" || view === "rejected") return entries;
+  const items = entries
+    .filter(
+      (entry) =>
+        ("entry" in entry.revision ? entry.revision.entry.kind : entry.revision.kind) === "source",
+    )
+    .map((entry) => ({ entryId: entry.id, revisionId: entry.revision.id }));
+  if (!items.length) return entries;
+  const statuses = await inKnowledgeContext(db, context, async (tx) => {
+    const [row] = await rawRows<{ result: unknown }>(
+      tx,
+      sql`SELECT knowledge_visible_index_status(${context.accountId}::uuid,
+        ${context.workspaceId}::uuid,${JSON.stringify(context.actor)}::jsonb,
+        ${JSON.stringify(items)}::jsonb,${view}) AS result`,
+    );
+    return z
+      .array(z.object({ entryId: z.uuid(), revisionId: z.uuid(), status: KnowledgeIndexStatus }))
+      .parse(row?.result);
+  });
+  const byRevision = new Map(statuses.map((item) => [item.revisionId, item.status]));
+  return entries.map((entry) => {
+    const indexStatus = byRevision.get(entry.revision.id);
+    return indexStatus ? { ...entry, indexStatus } : entry;
+  });
+}
+
 async function read(
   db: Database,
   context: KnowledgeContext,
@@ -353,7 +387,9 @@ export async function getKnowledgeEntry(
     .strict()
     .parse({ entryId, ...options });
   const rows = await read(db, context, { ...request, operation: "get", limit: 1 });
-  return rows[0] ? decodeProjection(rows[0], true) : null;
+  if (!rows[0]) return null;
+  const record = decodeProjection(rows[0], true);
+  return (await withIndexStatus(db, context, [record], request.view ?? "published"))[0]!;
 }
 
 const Cursor = z
@@ -400,7 +436,12 @@ export async function listKnowledgeEntries(
         }
       : {}),
   });
-  const entries = rows.slice(0, request.limit).map((row) => decodeProjection(row, false));
+  const entries = await withIndexStatus(
+    db,
+    context,
+    rows.slice(0, request.limit).map((row) => decodeProjection(row, false)),
+    request.view,
+  );
   return {
     entries,
     nextCursor:

package/src/knowledge-indexing.ts

@@ -2,7 +2,7 @@ import { namedSubjectPersonalWorkspaceId } from "./slack-routing-personal-worksp
 import { sql } from "drizzle-orm";
 import { z } from "zod";
 import { StoredKnowledgeEntryContent } from "@opengeni/contracts";
-import { rawRows, withRlsContext, type Database } from "./database";
+import { rawRows, withRlsContext, withWorkspaceUsageLock, type Database } from "./database";
 import { fromPostgresLosslessJson, toPostgresLosslessText } from "./lossless-json";
 
 const Claim = z.object({
@@ -17,6 +17,57 @@ const Claim = z.object({
 });
 export type KnowledgeIndexClaim = z.infer<typeof Claim>;
 
+/** DB-clock cutoff for this worker's first indexing poll, not a host-clock guess. */
+export async function knowledgeIndexBillingActivationTime(db: Database): Promise<Date> {
+  const [row] = await rawRows<{ activatedAt: Date }>(
+    db,
+    sql`SELECT clock_timestamp() AS "activatedAt"`,
+  );
+  return z.coerce.date().parse(row?.activatedAt);
+}
+
+/** Persist the chosen mode for exactly this leased generation. Paid review-first
+ * revisions release the lease without embedding until published. */
+export async function freezeKnowledgeIndexBillingMode(
+  db: Database,
+  raw: KnowledgeIndexClaim,
+  requested: "usage_only" | "shadow" | "credits",
+  activatedAt: Date,
+  rateMicrosPerMillionBytes: number,
+) {
+  const claim = Claim.parse(raw);
+  return withRlsContext(db, { accountId: claim.accountId }, async (tx) => {
+    const [row] = await rawRows<{ policy: unknown }>(
+      tx,
+      sql`SELECT knowledge_index_billing_policy(${claim.accountId}::uuid,
+        ${claim.revisionId}::uuid,${claim.leaseId}::uuid,${requested},
+        ${activatedAt.toISOString()}::timestamptz,
+        ${rateMicrosPerMillionBytes}::bigint) AS policy`,
+    );
+    return z
+      .object({
+        mode: z.enum(["usage_only", "shadow", "credits", "awaiting_review", "obsolete"]),
+        rateMicrosPerMillionBytes: z.number().int().nonnegative(),
+      })
+      .parse(row?.policy);
+  });
+}
+
+/** Serialize paid query admission and settlement across an entire account. */
+export async function withKnowledgeQueryAccountLock<T>(
+  db: Database,
+  accountId: string,
+  workspaceId: string,
+  fn: (db: Database) => Promise<T>,
+): Promise<T> {
+  return withWorkspaceUsageLock(db, workspaceId, async (tx) => {
+    await tx.execute(
+      sql`SELECT pg_advisory_xact_lock(hashtext(${`knowledge-query-account:${accountId}`}))`,
+    );
+    return fn(tx);
+  });
+}
+
 /** Internal projection dispatcher. No HTTP, MCP or agent tool exposes this capability. */
 export async function claimKnowledgeIndexJobs(
   db: Database,
@@ -121,6 +172,33 @@ export async function deferKnowledgeIndexJob(db: Database, claim: KnowledgeIndex
   return work(db, claim, { operation: "fail" });
 }
 
+/** A funding wait is not a provider failure. Keep the lease checkpoint intact. */
+export async function waitKnowledgeIndexForFunding(db: Database, raw: KnowledgeIndexClaim) {
+  const claim = Claim.parse(raw);
+  return withRlsContext(db, { accountId: claim.accountId }, async (tx) => {
+    const [row] = await rawRows<{ result: unknown }>(
+      tx,
+      sql`SELECT knowledge_index_wait_for_funding(${claim.accountId}::uuid,
+        ${claim.revisionId}::uuid,${claim.leaseId}::uuid) AS result`,
+    );
+    return z.object({ status: z.enum(["pending", "obsolete"]) }).parse(row?.result);
+  });
+}
+
+/** Hold publication stable through the paid append + post-use debit commit.
+ * Call only after embedding, inside the same transaction as settlement. */
+export async function guardPaidKnowledgeIndexPublication(db: Database, raw: KnowledgeIndexClaim) {
+  const claim = Claim.parse(raw);
+  return withRlsContext(db, { accountId: claim.accountId }, async (tx) => {
+    const [row] = await rawRows<{ status: string }>(
+      tx,
+      sql`SELECT knowledge_index_paid_publication_guard(${claim.accountId}::uuid,
+        ${claim.revisionId}::uuid,${claim.leaseId}::uuid) AS status`,
+    );
+    return z.enum(["published", "awaiting_review", "obsolete"]).parse(row?.status);
+  });
+}
+
 export async function continueKnowledgeIndexJob(db: Database, claim: KnowledgeIndexClaim) {
   return work(db, claim, { operation: "continue" });
 }

package/src/managed-user-setup.ts

@@ -83,15 +83,32 @@ export async function completeSelfServiceOrganizationSetup(
     organizationName: string;
     operationId: string;
     requestFingerprint: string;
+    trialCreditsEnabled?: boolean;
   },
 ): Promise<CompleteSelfServiceOrganizationSetupResponseType> {
   return await db.transaction(async (tx) => {
     const txDb = tx as unknown as Database;
     await setSubjectRlsContext(txDb, input.actorSubjectId);
+    // Transaction-local and set by the trusted API, never the request body.
+    // The AFTER INSERT receipt trigger handles the grant atomically with setup;
+    // replaying an old receipt cannot create a new grant after launch.
+    await rawRows(
+      txDb,
+      sql`select pg_catalog.set_config(
+      'opengeni.verified_signup_trial_enabled',
+      ${input.trialCreditsEnabled === true ? "on" : "off"}, true
+    )`,
+    );
     const [row] = await rawRows<{ result: unknown }>(
       txDb,
       sql`select complete_self_service_organization_setup(
-        ${JSON.stringify(input)}::jsonb
+        ${JSON.stringify({
+          authUserId: input.authUserId,
+          actorSubjectId: input.actorSubjectId,
+          organizationName: input.organizationName,
+          operationId: input.operationId,
+          requestFingerprint: input.requestFingerprint,
+        })}::jsonb
       ) as result`,
     );
     return CompleteSelfServiceOrganizationSetupResponse.parse(row?.result);

package/src/migrate.ts

@@ -40,6 +40,13 @@ export interface ConcurrentIndexMigration {
 
 export type MigrationRuntimeOptions = {
   maxNestedAgentDepth?: number;
+  /**
+   * For managed Postgres where an administrator preinstalls pgvector but the
+   * migration owner cannot execute CREATE EXTENSION, verify the public vector
+   * type and omit only 0000's exact vector installation statement. The default
+   * continues to execute the shipped migration verbatim.
+   */
+  preinstalledVector?: boolean;
   /**
    * Exact database login roles that may run an OpenGeni API or worker against
    * this target. Maintenance cutovers use this list to reject a live mixed-
@@ -173,7 +180,11 @@ export async function executeMigrationFile(
   sql: postgres.Sql,
   file: string,
   sqlText: string,
+  options?: Pick<MigrationRuntimeOptions, "preinstalledVector">,
 ): Promise<void> {
+  if (file === "0000_initial.sql" && options?.preinstalledVector) {
+    sqlText = await initialMigrationWithPreinstalledVector(sql, sqlText);
+  }
   if (sqlText.includes(SKILL_METADATA_MIGRATION_MARKER)) {
     if (file !== "0433_unified_skill_lifecycle.sql")
       throw new Error("Skill metadata stage is restricted to migration 0433");
@@ -253,8 +264,13 @@ export async function executeMigrationFile(
     // makes a fresh database capable of applying maintenance migration 0138
     // and later migrations capable of crossing the 0352 sessions policy
     // without a process-global PGOPTIONS escape hatch.
+    // Bound ordinary DDL lock acquisition in that same implicit transaction.
+    // The migration body follows this preamble, so its own SET LOCAL can still
+    // override the default; a lock timeout aborts the whole body before the
+    // caller writes its separate success receipt.
     await sql.unsafe(
       `SELECT
+  pg_catalog.set_config('lock_timeout', '5s', true),
   pg_catalog.set_config('opengeni.sandbox_recovery_protocol_v2', '1', true),
   pg_catalog.set_config('opengeni.session_variable_set_attachments_v1', '1', true);\n${file === "0434_ordered_model_history.sql" ? "SET CONSTRAINTS ALL IMMEDIATE;\n" : ""}${sqlText}`,
     );
@@ -282,6 +298,46 @@ export async function executeMigrationFile(
   }
 }
 
+const initialExtensionPreamble =
+  "CREATE EXTENSION IF NOT EXISTS pgcrypto;\nCREATE EXTENSION IF NOT EXISTS vector;\n";
+
+/** Never rewrite arbitrary migrations or trust a same-named type in another schema. */
+export async function initialMigrationWithPreinstalledVector(
+  sql: postgres.Sql,
+  sqlText: string,
+): Promise<string> {
+  if (!sqlText.startsWith(initialExtensionPreamble)) {
+    throw new Error("0000 initial extension preamble changed; review managed Postgres admission");
+  }
+  const [installed] = await sql<Array<{ present: boolean }>>`
+    SELECT EXISTS (
+      SELECT 1 FROM pg_catalog.pg_extension extension
+      JOIN pg_catalog.pg_namespace namespace ON namespace.oid = extension.extnamespace
+      JOIN pg_catalog.pg_type type ON type.typnamespace = namespace.oid AND type.typname = 'vector'
+      JOIN pg_catalog.pg_depend dependency
+        ON dependency.classid = 'pg_catalog.pg_type'::regclass
+       AND dependency.objid = type.oid
+       AND dependency.refclassid = 'pg_catalog.pg_extension'::regclass
+       AND dependency.refobjid = extension.oid AND dependency.deptype = 'e'
+      WHERE extension.extname = 'vector' AND namespace.nspname = 'public'
+    ) AS present
+  `;
+  if (!installed?.present) {
+    throw new Error("Preinstalled public pgvector extension and type are required");
+  }
+  return (
+    "CREATE EXTENSION IF NOT EXISTS pgcrypto;\n" + sqlText.slice(initialExtensionPreamble.length)
+  );
+}
+
+function preinstalledVectorPolicy(options: MigrationRuntimeOptions | undefined): boolean {
+  if (options !== undefined) return options.preinstalledVector === true;
+  const configured = process.env.OPENGENI_MIGRATIONS_PREINSTALLED_VECTOR;
+  if (configured === undefined || configured === "false") return false;
+  if (configured === "true") return true;
+  throw new Error("OPENGENI_MIGRATIONS_PREINSTALLED_VECTOR must be true or false");
+}
+
 function deploymentDepthPolicy(
   options: MigrationRuntimeOptions | undefined,
 ): DeploymentDepthPolicy {
@@ -425,6 +481,7 @@ export async function migrate(
   const migrationsDir = join(dirname(fileURLToPath(import.meta.url)), "../drizzle");
   const files = (await readdir(migrationsDir)).filter((file) => file.endsWith(".sql")).sort();
   const depthPolicy = deploymentDepthPolicy(runtimeOptions);
+  const preinstalledVector = preinstalledVectorPolicy(runtimeOptions);
   const sql = postgres(databaseUrl, { max: 1 });
   try {
     // Serialize concurrent migrate() runs; the session-level lock is released
@@ -477,7 +534,7 @@ export async function migrate(
       if (sqlText === undefined) {
         throw new Error(`Pending migration source was not loaded: ${file}`);
       }
-      await executeMigrationFile(sql, file, sqlText);
+      await executeMigrationFile(sql, file, sqlText, { preinstalledVector });
       await sql`INSERT INTO "schema_migrations" ("name") VALUES (${file}) ON CONFLICT DO NOTHING`;
     }
     // Reconcile even when all migration names were already recorded. This is

package/src/organization-membership-lifecycle.ts

@@ -59,10 +59,21 @@ export async function createManagedOrganization(
     subjectLabel: string;
     name: string;
     operationId: string;
+    trialCreditsEnabled?: boolean;
   },
 ): Promise<CreateOrganizationResponseType> {
   return await db.transaction(async (tx) => {
     await setSubjectRlsContext(tx as unknown as Database, input.subjectId);
+    // This legacy first-organization route delegates to the same self-service
+    // receipt writer. Do not let it consume the one-shot receipt while the
+    // trial is enabled without issuing its transaction-atomic grant.
+    await rawRows(
+      tx,
+      sql`select pg_catalog.set_config(
+      'opengeni.verified_signup_trial_enabled',
+      ${input.trialCreditsEnabled === true ? "on" : "off"}, true
+    )`,
+    );
     const [row] = await rawRows<{ result: unknown }>(
       tx,
       sql`select create_managed_organization(

package/src/provision-roles.ts

@@ -840,6 +840,18 @@ BEGIN
     IF to_regprocedure(format('%I.knowledge_entry_apply(uuid,uuid,jsonb,jsonb)', ${literal(schema)})) IS NOT NULL THEN
       EXECUTE format('GRANT EXECUTE ON FUNCTION %I.knowledge_index_claim(text,integer,integer) TO %I', ${literal(schema)}, ${literal(role)});
       EXECUTE format('GRANT EXECUTE ON FUNCTION %I.knowledge_index_work(uuid,uuid,uuid,jsonb) TO %I', ${literal(schema)}, ${literal(role)});
+      IF to_regprocedure(format('%I.knowledge_index_billing_policy(uuid,uuid,uuid,text,timestamptz,bigint)', ${literal(schema)})) IS NOT NULL THEN
+        EXECUTE format('GRANT EXECUTE ON FUNCTION %I.knowledge_index_billing_policy(uuid,uuid,uuid,text,timestamptz,bigint) TO %I', ${literal(schema)}, ${literal(role)});
+      END IF;
+      IF to_regprocedure(format('%I.knowledge_index_wait_for_funding(uuid,uuid,uuid)', ${literal(schema)})) IS NOT NULL THEN
+        EXECUTE format('GRANT EXECUTE ON FUNCTION %I.knowledge_index_wait_for_funding(uuid,uuid,uuid) TO %I', ${literal(schema)}, ${literal(role)});
+      END IF;
+      IF to_regprocedure(format('%I.knowledge_index_paid_publication_guard(uuid,uuid,uuid)', ${literal(schema)})) IS NOT NULL THEN
+        EXECUTE format('GRANT EXECUTE ON FUNCTION %I.knowledge_index_paid_publication_guard(uuid,uuid,uuid) TO %I', ${literal(schema)}, ${literal(role)});
+      END IF;
+      IF to_regprocedure(format('%I.knowledge_visible_index_status(uuid,uuid,jsonb,jsonb,text)', ${literal(schema)})) IS NOT NULL THEN
+        EXECUTE format('GRANT EXECUTE ON FUNCTION %I.knowledge_visible_index_status(uuid,uuid,jsonb,jsonb,text) TO %I', ${literal(schema)}, ${literal(role)});
+      END IF;
       EXECUTE format('GRANT EXECUTE ON FUNCTION %I.agent_instruction_apply(uuid,uuid,jsonb,jsonb) TO %I', ${literal(schema)}, ${literal(role)});
       EXECUTE format('GRANT EXECUTE ON FUNCTION %I.knowledge_entry_apply(uuid,uuid,jsonb,jsonb) TO %I', ${literal(schema)}, ${literal(role)});
       EXECUTE format('GRANT EXECUTE ON FUNCTION %I.knowledge_entry_confirm_legacy(uuid,uuid,jsonb,jsonb) TO %I', ${literal(schema)}, ${literal(role)});

package/src/retained-provider-commands.ts

@@ -406,8 +406,10 @@ export async function retainedProcessCancellationRequested(
   });
 }
 
-/** Called by the reaper for an exact retained command. Ordinary completed turns
- * are intentionally irrelevant. Lock order remains process -> lease. */
+/** Record deadline cancellation for an exact retained Modal command. Legacy
+ * PTY callers send Ctrl-C first because cancellation fences stdin; non-PTY
+ * callers only probe, since Ctrl-C would be data. An earlier explicit stop
+ * remains immutable; the deadline uses its own clock. Lock order: process -> lease. */
 export async function requestRetainedProcessDeadlineCancellation(
   db: Database,
   scope: ProcessScope,
@@ -422,8 +424,8 @@ export async function requestRetainedProcessDeadlineCancellation(
     if (
       !row ||
       row.state !== "active" ||
-      !row.providerCommand ||
-      !supervisionDescriptor(row.providerCommand)
+      row.providerBackend !== "modal" ||
+      row.routeTargetId !== null
     )
       return false;
     const [lease] = await tx.execute<{ id: string }>(sql`
@@ -434,11 +436,19 @@ export async function requestRetainedProcessDeadlineCancellation(
         and rotation_requested_at is not null and rotation_reason = 'provider_deadline' for update
     `);
     if (!lease) return false;
-    if (!row.cancellationRequestedAt)
+    if (!row.deadlineCancellationRequestedAt || !row.cancellationRequestedAt) {
       await tx
         .update(schema.sandboxRetainedProcesses)
-        .set({ cancellationRequestedAt: new Date(), cancellationReason: "provider_deadline" })
+        .set({
+          ...(!row.cancellationRequestedAt
+            ? { cancellationRequestedAt: sql`now()`, cancellationReason: "provider_deadline" }
+            : {}),
+          ...(!row.deadlineCancellationRequestedAt
+            ? { deadlineCancellationRequestedAt: sql`now()` }
+            : {}),
+        })
         .where(processWhere(scope));
+    }
     return true;
   });
 }

package/src/runtime-posture.ts

@@ -586,6 +586,10 @@ const XAI_AUTHORITY_TABLES = [
 const UNIFIED_KNOWLEDGE_ROUTINES = [
   "knowledge_index_claim(text, integer, integer)",
   "knowledge_index_work(uuid, uuid, uuid, jsonb)",
+  "knowledge_index_billing_policy(uuid, uuid, uuid, text, timestamp with time zone, bigint)",
+  "knowledge_index_wait_for_funding(uuid, uuid, uuid)",
+  "knowledge_index_paid_publication_guard(uuid, uuid, uuid)",
+  "knowledge_visible_index_status(uuid, uuid, jsonb, jsonb, text)",
   "knowledge_entry_apply(uuid, uuid, jsonb, jsonb)",
   "knowledge_entry_confirm_legacy(uuid, uuid, jsonb, jsonb)",
   "agent_instruction_apply(uuid, uuid, jsonb, jsonb)",

package/src/schema.ts

@@ -9960,6 +9960,9 @@ export const sandboxRetainedProcesses = pgTable(
     supervisionOutputCaptured: boolean("supervision_output_captured").notNull().default(false),
     cancellationRequestedAt: timestamp("cancellation_requested_at", { withTimezone: true }),
     cancellationReason: text("cancellation_reason"),
+    deadlineCancellationRequestedAt: timestamp("deadline_cancellation_requested_at", {
+      withTimezone: true,
+    }),
     providerCommandInputIndex: bigint("provider_command_input_index", { mode: "number" })
       .notNull()
       .default(0),