@opengeni/db 0.12.0 → 0.12.6

package/dist/index.js

@@ -32,9 +32,11 @@ import {
   rigChanges,
   rigVersions,
   rigs,
+  sandboxLeaseHolders,
   sandboxPtySessions,
   sandboxRetainedProcesses,
   sandboxSessionEnvelopes,
+  sandboxWorkspaceMutationAdmissions,
   sandboxes,
   scheduledTaskRuns,
   scheduledTasks,
@@ -70,14 +72,27 @@ import {
   workspaceVariableSetVariables,
   workspaceVariableSets,
   workspaces
-} from "./chunk-VUKRIBO5.js";
+} from "./chunk-CYA6BHV6.js";
 import {
   migrate,
   runMigrations
 } from "./chunk-Y5WZZVQK.js";
 import {
-  provisionRoles
-} from "./chunk-BMFDXFPA.js";
+  FORCE_RLS_TABLES,
+  NON_RLS_RUNTIME_TABLES,
+  PROTECTED_NO_DIRECT_DML_TABLES,
+  RUNTIME_DML_TABLES,
+  RUNTIME_FULL_DML_TABLES,
+  RUNTIME_READ_INSERT_TABLES,
+  RUNTIME_READ_ONLY_TABLES,
+  RUNTIME_TABLE_PRIVILEGES,
+  RuntimeDatabasePostureError,
+  assertRuntimeDatabasePosture,
+  evaluateRuntimeDatabasePosture,
+  inspectRuntimeDatabasePosture,
+  provisionRoles,
+  runtimeDatabaseReadyCheck
+} from "./chunk-XRVNI2GB.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/index.ts
@@ -284,24 +299,15 @@ function assertKey(key) {
 }
 
 // src/event-payload-sanitizer.ts
-import { boundSessionEventPayload } from "@opengeni/contracts";
+import {
+  boundSessionEventPayload,
+  isCredentialHeaderName,
+  isSensitiveFieldName,
+  redactSensitiveKey,
+  redactSensitiveText
+} from "@opengeni/contracts";
 var REPLACEMENT = "\uFFFD";
 var REDACTED = "[redacted]";
-var SENSITIVE_FIELD_NAMES = /* @__PURE__ */ new Set([
-  "authorization",
-  "headers",
-  "accesstoken",
-  "refreshtoken",
-  "idtoken",
-  "token",
-  "apikey",
-  "secret",
-  "clientsecret",
-  "credential",
-  "credentialencrypted",
-  "encryptedpkceverifier",
-  "codeverifier"
-]);
 function sanitizeEventString(value) {
   let needsWork = false;
   for (let i = 0; i < value.length; i++) {
@@ -343,7 +349,8 @@ function sanitizeEventPayload(payload, options = {}) {
     fullEvidence: options.fullEvidence
   });
   return sanitizeEventPayloadDeep(
-    bounded === payload ? removeProducerTruncationMetadata(bounded) : bounded
+    bounded === payload ? removeProducerTruncationMetadata(bounded) : bounded,
+    options.knownSecrets ?? []
   );
 }
 function removeProducerTruncationMetadata(payload) {
@@ -354,33 +361,38 @@ function removeProducerTruncationMetadata(payload) {
   delete cleaned.truncation;
   return cleaned;
 }
-function sanitizeEventPayloadDeep(payload) {
+function sanitizeEventPayloadDeep(payload, knownSecrets = []) {
   if (typeof payload === "string") {
-    return sanitizeEventString(payload);
+    return sanitizeEventString(redactSensitiveText(payload, knownSecrets));
   }
   if (Array.isArray(payload)) {
-    return payload.map((item) => sanitizeEventPayloadDeep(item));
+    return payload.map((item) => sanitizeEventPayloadDeep(item, knownSecrets));
   }
   if (payload instanceof Date) {
     return safeDateIso(payload);
   }
   if (payload && typeof payload === "object") {
-    const entries = Object.entries(payload).map(
-      ([key, value]) => [sanitizeEventString(key), sanitizeSensitiveEventField(key, value)]
-    );
+    const usedKeys = /* @__PURE__ */ new Set();
+    const entries = Object.entries(payload).map(([key, value]) => {
+      const safeKey = nextUniqueKey(
+        sanitizeEventString(redactSensitiveKey(key, knownSecrets)),
+        usedKeys
+      );
+      return [safeKey, sanitizeSensitiveEventField(key, value, knownSecrets)];
+    });
     return Object.fromEntries(entries);
   }
   return payload;
 }
-function sanitizeModelPayload(payload) {
-  return sanitizeModelPayloadDeep(payload, /* @__PURE__ */ new WeakSet(), 0);
+function sanitizeModelPayload(payload, knownSecrets = []) {
+  return sanitizeModelPayloadDeep(payload, /* @__PURE__ */ new WeakSet(), 0, knownSecrets);
 }
 var MODEL_PAYLOAD_SANITIZE_MAX_DEPTH = 64;
 var MODEL_PAYLOAD_CYCLE_MARKER = "[OpenGeni omitted cyclic model payload]";
 var MODEL_PAYLOAD_DEPTH_MARKER = "[OpenGeni omitted model payload beyond database-safety depth]";
-function sanitizeModelPayloadDeep(payload, seen, depth) {
+function sanitizeModelPayloadDeep(payload, seen, depth, knownSecrets = []) {
   if (typeof payload === "string") {
-    return sanitizeEventString(payload);
+    return sanitizeEventString(redactSensitiveText(payload, knownSecrets));
   }
   if (!payload || typeof payload !== "object") return payload;
   if (payload instanceof Date) {
@@ -393,13 +405,25 @@ function sanitizeModelPayloadDeep(payload, seen, depth) {
   seen.add(payload);
   try {
     if (Array.isArray(payload)) {
-      return payload.map((item) => sanitizeModelPayloadDeep(item, seen, depth + 1));
+      return payload.map(
+        (item) => sanitizeModelPayloadDeep(item, seen, depth + 1, knownSecrets)
+      );
     }
+    const usedKeys = /* @__PURE__ */ new Set();
     return Object.fromEntries(
-      Object.entries(payload).map(([key, value]) => [
-        sanitizeEventString(key),
-        sanitizeModelPayloadDeep(value, seen, depth + 1)
-      ])
+      Object.entries(payload).map(([key, value]) => {
+        const safeKey = nextUniqueKey(
+          sanitizeEventString(redactSensitiveKey(key, knownSecrets)),
+          usedKeys
+        );
+        if (isSensitiveFieldName(key)) {
+          return [safeKey, REDACTED];
+        }
+        if (normalizeFieldName(key) === "headers") {
+          return [safeKey, sanitizeModelHeaders(value, seen, depth + 1, knownSecrets)];
+        }
+        return [safeKey, sanitizeModelPayloadDeep(value, seen, depth + 1, knownSecrets)];
+      })
     );
   } finally {
     seen.delete(payload);
@@ -413,57 +437,118 @@ function safeDateIso(value) {
     return null;
   }
 }
-function sanitizeSensitiveEventField(key, value) {
+function sanitizeSensitiveEventField(key, value, knownSecrets) {
   if (key === "mcpServers") {
-    return sanitizeSessionMcpServerList(value);
+    return sanitizeSessionMcpServerList(value, knownSecrets);
   }
   if (key === "mcpCredentialUpdates") {
-    return sanitizeMcpCredentialUpdateList(value);
+    return sanitizeMcpCredentialUpdateList(value, knownSecrets);
   }
-  if (SENSITIVE_FIELD_NAMES.has(normalizeFieldName(key))) {
+  if (normalizeFieldName(key) === "headers") {
+    return sanitizeEventHeaders(value, knownSecrets);
+  }
+  if (isSensitiveFieldName(key)) {
     return REDACTED;
   }
-  return sanitizeEventPayloadDeep(value);
+  return sanitizeEventPayloadDeep(value, knownSecrets);
+}
+function sanitizeEventHeaders(value, knownSecrets) {
+  if (!isPlainObject(value)) {
+    return sanitizeEventPayloadDeep(value, knownSecrets);
+  }
+  const usedKeys = /* @__PURE__ */ new Set();
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => {
+      const safeKey = nextUniqueKey(
+        sanitizeEventString(redactSensitiveKey(key, knownSecrets)),
+        usedKeys
+      );
+      return [
+        safeKey,
+        isCredentialHeaderName(key) ? REDACTED : sanitizeEventPayloadDeep(child, knownSecrets)
+      ];
+    })
+  );
+}
+function sanitizeModelHeaders(value, seen, depth, knownSecrets) {
+  if (!isPlainObject(value)) {
+    return sanitizeModelPayloadDeep(value, seen, depth, knownSecrets);
+  }
+  if (depth >= MODEL_PAYLOAD_SANITIZE_MAX_DEPTH) {
+    return MODEL_PAYLOAD_DEPTH_MARKER;
+  }
+  if (seen.has(value)) return MODEL_PAYLOAD_CYCLE_MARKER;
+  seen.add(value);
+  try {
+    const usedKeys = /* @__PURE__ */ new Set();
+    return Object.fromEntries(
+      Object.entries(value).map(([key, child]) => {
+        const safeKey = nextUniqueKey(
+          sanitizeEventString(redactSensitiveKey(key, knownSecrets)),
+          usedKeys
+        );
+        return [
+          safeKey,
+          isCredentialHeaderName(key) ? REDACTED : sanitizeModelPayloadDeep(child, seen, depth + 1, knownSecrets)
+        ];
+      })
+    );
+  } finally {
+    seen.delete(value);
+  }
 }
-function sanitizeSessionMcpServerList(value) {
+function sanitizeSessionMcpServerList(value, knownSecrets) {
   if (!Array.isArray(value)) {
-    return sanitizeEventPayloadDeep(value);
+    return sanitizeEventPayloadDeep(value, knownSecrets);
   }
   return value.map((item) => {
     if (!isPlainObject(item)) {
-      return sanitizeEventPayloadDeep(item);
+      return sanitizeEventPayloadDeep(item, knownSecrets);
     }
     const { headers, headersEncrypted, ...rest } = item;
-    const cleaned = sanitizeEventPayloadDeep(rest);
-    const headerNames = safeHeaderNames(headers) ?? safeHeaderNames(headersEncrypted);
+    const cleaned = sanitizeEventPayloadDeep(rest, knownSecrets);
+    const headerNames = safeHeaderNames(headers, knownSecrets) ?? safeHeaderNames(headersEncrypted, knownSecrets);
     if (headerNames) {
       cleaned.headerNames = headerNames;
     }
     return cleaned;
   });
 }
-function sanitizeMcpCredentialUpdateList(value) {
+function sanitizeMcpCredentialUpdateList(value, knownSecrets) {
   if (!Array.isArray(value)) {
-    return sanitizeEventPayloadDeep(value);
+    return sanitizeEventPayloadDeep(value, knownSecrets);
   }
   return value.map((item) => {
     if (!isPlainObject(item)) {
-      return sanitizeEventPayloadDeep(item);
+      return sanitizeEventPayloadDeep(item, knownSecrets);
     }
     const { headers, headersEncrypted, ...rest } = item;
-    const cleaned = sanitizeEventPayloadDeep(rest);
-    const headerNames = safeHeaderNames(headers) ?? safeHeaderNames(headersEncrypted);
+    const cleaned = sanitizeEventPayloadDeep(rest, knownSecrets);
+    const headerNames = safeHeaderNames(headers, knownSecrets) ?? safeHeaderNames(headersEncrypted, knownSecrets);
     if (headerNames) {
       cleaned.headerNames = headerNames;
     }
     return cleaned;
   });
 }
-function safeHeaderNames(value) {
+function safeHeaderNames(value, knownSecrets) {
   if (!isPlainObject(value)) {
     return null;
   }
-  return Object.keys(value).map(sanitizeEventString).sort();
+  const usedKeys = /* @__PURE__ */ new Set();
+  return Object.keys(value).map(
+    (key) => nextUniqueKey(sanitizeEventString(redactSensitiveKey(key, knownSecrets)), usedKeys)
+  ).sort();
+}
+function nextUniqueKey(base, usedKeys) {
+  let candidate = base;
+  let suffix = 2;
+  while (usedKeys.has(candidate)) {
+    candidate = `${base}#${suffix}`;
+    suffix += 1;
+  }
+  usedKeys.add(candidate);
+  return candidate;
 }
 function isPlainObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -487,6 +572,18 @@ var NewSessionDraftAccessError = class extends Error {
     super("New-session draft access changed");
   }
 };
+function storedOptions(options, toolsProvided) {
+  return { ...options, toolsProvided };
+}
+function newSessionDraftToolsProvided(row) {
+  const options = row.sessionOptions;
+  return options.toolsProvided === true || !Object.hasOwn(options, "toolsProvided");
+}
+function publicNewSessionDraftOptions(row) {
+  const options = { ...row.sessionOptions };
+  delete options.toolsProvided;
+  return options;
+}
 async function getNewSessionDraftInTransaction(db, input) {
   const query = db.select().from(newSessionDrafts).where(
     and2(
@@ -523,7 +620,9 @@ async function saveNewSessionDraftInTransaction(db, input) {
     tools: input.tools,
     model: input.model,
     reasoningEffort: input.reasoningEffort,
-    sessionOptions: input.options,
+    // Keep the explicit/omitted policy in the existing JSONB extension point;
+    // adding a column here would turn a client preference into a migration.
+    sessionOptions: storedOptions(input.options, input.toolsProvided),
     updatedAt: /* @__PURE__ */ new Date()
   };
   if (current) {
@@ -538,17 +637,69 @@ async function saveNewSessionDraftInTransaction(db, input) {
   const raced = await getNewSessionDraftInTransaction(db, { ...input, lock: true });
   throw new NewSessionDraftConflictError(raced?.revision ?? 0);
 }
-async function consumeNewSessionDraftInTransaction(db, input) {
+function safeRepositoryResource(resource) {
+  return {
+    kind: "repository",
+    uri: resource.uri,
+    ref: resource.ref,
+    ...resource.mountPath ? { mountPath: resource.mountPath } : {},
+    ...resource.subpath ? { subpath: resource.subpath } : {},
+    ...resource.githubInstallationId ? { githubInstallationId: resource.githubInstallationId } : {},
+    ...resource.githubRepositoryId ? { githubRepositoryId: resource.githubRepositoryId } : {}
+  };
+}
+function safeWorkingDir(value, targetSandboxId) {
+  if (!targetSandboxId || typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "." || trimmed === ".." || trimmed.includes("\0") || trimmed.startsWith("/") || trimmed.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(trimmed) || trimmed.split(/[\\/]+/).some((part) => part === "..")) {
+    return void 0;
+  }
+  return trimmed;
+}
+async function seedNewSessionDraftInTransaction(db, input) {
   if (input.expectedRevision === 0) return false;
-  const deleted = await db.delete(newSessionDrafts).where(
+  const [current] = await db.select().from(newSessionDrafts).where(
     and2(
       eq2(newSessionDrafts.workspaceId, input.workspaceId),
-      eq2(newSessionDrafts.subjectId, input.subjectId),
+      eq2(newSessionDrafts.subjectId, input.subjectId)
+    )
+  ).for("update").limit(1);
+  if (!current || current.revision !== input.expectedRevision) return false;
+  const options = current.sessionOptions;
+  const targetSandboxId = typeof options.targetSandboxId === "string" ? options.targetSandboxId : void 0;
+  const safeOptions = {
+    ...options.sandboxBackend ? { sandboxBackend: options.sandboxBackend } : {},
+    ...targetSandboxId ? { targetSandboxId } : {},
+    ...safeWorkingDir(options.workingDir, targetSandboxId) ? { workingDir: safeWorkingDir(options.workingDir, targetSandboxId) } : {},
+    ...options.variableSetId ? { variableSetId: options.variableSetId } : {},
+    ...options.rigId ? { rigId: options.rigId } : {}
+  };
+  const resources = (Array.isArray(current.resources) ? current.resources : []).flatMap((raw) => {
+    if (!raw || typeof raw !== "object" || raw.kind !== "repository") {
+      return [];
+    }
+    return [safeRepositoryResource(raw)];
+  });
+  const [seeded] = await db.update(newSessionDrafts).set({
+    revision: current.revision + 1,
+    text: "",
+    resources,
+    // The explicit array is retained only when the caller explicitly pinned
+    // tools. Omitted workspace-default policy is represented by [] + false.
+    tools: newSessionDraftToolsProvided(current) ? current.tools : [],
+    model: current.model,
+    reasoningEffort: current.reasoningEffort,
+    sessionOptions: storedOptions(safeOptions, newSessionDraftToolsProvided(current)),
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(
+    and2(
+      eq2(newSessionDrafts.id, current.id),
       eq2(newSessionDrafts.revision, input.expectedRevision)
     )
   ).returning({ id: newSessionDrafts.id });
-  return deleted.length > 0;
+  return Boolean(seeded);
 }
+var consumeNewSessionDraftInTransaction = seedNewSessionDraftInTransaction;
 
 // src/persistence-errors.ts
 var SQLSTATE_KEYS = ["sqlState", "sqlstate", "code"];
@@ -5020,6 +5171,14 @@ async function cancelResponseBody(response) {
 }
 
 // src/index.ts
+var SessionToolPolicyVersionConflictError = class extends Error {
+  constructor(currentVersion) {
+    super("The session tool policy changed in another client");
+    this.currentVersion = currentVersion;
+    this.name = "SessionToolPolicyVersionConflictError";
+  }
+  code = "SESSION_TOOL_POLICY_CONFLICT";
+};
 var SessionSpawnDeniedDbError = class extends Error {
   constructor(denial) {
     super(denial.code);
@@ -5367,14 +5526,23 @@ async function withRlsContext(db, context, fn, transactionConfig) {
     const scoped = tx;
     await setRlsContext(scoped, context);
     const applied = await tx.execute(
-      sql4`select current_setting('opengeni.account_id', true) as account_id`
+      sql4`select
+        current_setting('opengeni.account_id', true) as account_id,
+        current_setting('opengeni.workspace_id', true) as workspace_id`
     );
     const appliedAccountId = applied[0]?.account_id ?? "";
+    const expectedWorkspaceId = context.workspaceId ?? "";
+    const appliedWorkspaceId = applied[0]?.workspace_id ?? "";
     if (appliedAccountId !== context.accountId) {
       throw new Error(
         `RLS context not applied on the active backend: expected account ${context.accountId}, got "${appliedAccountId}"`
       );
     }
+    if (appliedWorkspaceId !== expectedWorkspaceId) {
+      throw new Error(
+        `RLS context not applied on the active backend: expected workspace "${expectedWorkspaceId}", got "${appliedWorkspaceId}"`
+      );
+    }
     return await fn(scoped);
   }, transactionConfig);
 }
@@ -6000,6 +6168,21 @@ async function findActiveApiKeyByHash(db, keyHash) {
     return mapApiKey({ ...row, lastUsedAt: now });
   });
 }
+var GitHubInstallationAuthorityCommitError = class extends Error {
+  constructor() {
+    super("GitHub installation authority expired before the binding transaction completed");
+  }
+};
+var githubInstallationAuthorityMaxAgeMs = 10 * 6e4;
+function hasAuditableGitHubInstallationAuthority(installation) {
+  const checkedAt = installation.authorityCheckedAt ? Date.parse(installation.authorityCheckedAt) : Number.NaN;
+  const expiresAt = installation.authorityExpiresAt ? Date.parse(installation.authorityExpiresAt) : Number.NaN;
+  const common = installation.repositoryScope === "selected" && installation.repositoryIds.length > 0 && installation.repositoryIds.every((id) => Number.isSafeInteger(id) && id > 0) && installation.githubAccountId !== null && Number.isSafeInteger(installation.githubAccountId) && installation.githubAccountId > 0 && Boolean(installation.accountLogin) && installation.githubActorId !== null && Number.isSafeInteger(installation.githubActorId) && installation.githubActorId > 0 && Boolean(installation.githubActorLogin) && Boolean(installation.linkedBySubjectId) && Boolean(installation.authorityNonce) && Number.isFinite(checkedAt) && Number.isFinite(expiresAt) && checkedAt < expiresAt;
+  if (!common) {
+    return false;
+  }
+  return installation.authorityKind === "personal_owner" ? installation.accountType === "User" && installation.githubActorId === installation.githubAccountId : installation.authorityKind === "organization_owner" && installation.accountType === "Organization";
+}
 async function upsertGitHubInstallation(db, input) {
   return await withRlsContext(
     db,
@@ -6023,7 +6206,10 @@ async function upsertGitHubInstallation(db, input) {
           accountType: input.accountType ?? null,
           ...input.linkedBySubjectId !== void 0 ? { linkedBySubjectId: input.linkedBySubjectId } : {},
           updatedAt: /* @__PURE__ */ new Date()
-        }
+        },
+        // This legacy metadata helper cannot mutate an owner-authorized row.
+        // New bindings use bindAuthorizedGitHubInstallationRepositories.
+        setWhere: isNull(githubInstallations.authorityNonce)
       }).returning();
       if (!row) {
         throw new Error("Failed to upsert GitHub installation");
@@ -6064,6 +6250,114 @@ async function bindGitHubInstallationRepositories(db, input) {
           repositoryScope: "selected",
           linkedBySubjectId: input.linkedBySubjectId,
           updatedAt: /* @__PURE__ */ new Date()
+        },
+        // Preserve the immutable authority + allowlist audit boundary.
+        setWhere: isNull(githubInstallations.authorityNonce)
+      }).returning();
+      if (!row) {
+        throw new Error("Failed to bind GitHub installation");
+      }
+      await tx.delete(githubInstallationRepositories).where(
+        and6(
+          eq6(githubInstallationRepositories.workspaceId, input.workspaceId),
+          eq6(githubInstallationRepositories.installationId, input.installationId)
+        )
+      );
+      for (let offset = 0; offset < repositoryIds.length; offset += 1e3) {
+        await tx.insert(githubInstallationRepositories).values(
+          repositoryIds.slice(offset, offset + 1e3).map((repositoryId) => ({
+            accountId: input.accountId,
+            workspaceId: input.workspaceId,
+            installationId: input.installationId,
+            repositoryId
+          }))
+        );
+      }
+      return { ...mapGitHubInstallation(row), repositoryIds };
+    })
+  );
+}
+async function bindAuthorizedGitHubInstallationRepositories(db, input) {
+  if (!Number.isSafeInteger(input.installationId) || input.installationId <= 0) {
+    throw new Error("GitHub installation id must be a positive safe integer");
+  }
+  if (!Number.isSafeInteger(input.githubAccountId) || input.githubAccountId <= 0) {
+    throw new Error("GitHub account id must be a positive safe integer");
+  }
+  if (!Number.isSafeInteger(input.githubActorId) || input.githubActorId <= 0) {
+    throw new Error("GitHub actor id must be a positive safe integer");
+  }
+  const authorityCheckedAtMs = input.authorityCheckedAt.getTime();
+  const authorityExpiresAtMs = input.authorityExpiresAt.getTime();
+  if (!Number.isFinite(authorityCheckedAtMs) || !Number.isFinite(authorityExpiresAtMs) || authorityCheckedAtMs >= authorityExpiresAtMs || authorityExpiresAtMs - authorityCheckedAtMs > githubInstallationAuthorityMaxAgeMs || !input.authorityNonce || !input.githubActorLogin.trim() || !input.accountLogin?.trim() || !input.linkedBySubjectId.trim() || input.authorityKind !== "personal_owner" && input.authorityKind !== "organization_owner" || input.authorityKind === "personal_owner" && (input.accountType !== "User" || input.githubActorId !== input.githubAccountId) || input.authorityKind === "organization_owner" && input.accountType !== "Organization") {
+    throw new Error("GitHub installation authority proof is invalid or expired");
+  }
+  const repositoryIds = [...new Set(input.repositoryIds)];
+  if (repositoryIds.length === 0 || repositoryIds.length !== input.repositoryIds.length || repositoryIds.some((id) => !Number.isSafeInteger(id) || id <= 0)) {
+    throw new Error(
+      "GitHub repository ids must be a nonempty, unique list of positive safe integers"
+    );
+  }
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await scopedDb.transaction(async (tx) => {
+      await assertGitHubAuthorityWindowOpen(
+        tx,
+        input.authorityCheckedAt,
+        input.authorityExpiresAt
+      );
+      await tx.delete(integrationOauthStateNonces).where(
+        and6(
+          eq6(integrationOauthStateNonces.workspaceId, input.workspaceId),
+          lt(integrationOauthStateNonces.expiresAt, input.authorityCheckedAt)
+        )
+      );
+      const consumed = await tx.insert(integrationOauthStateNonces).values({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        subjectId: input.linkedBySubjectId,
+        nonce: input.authorityNonce,
+        expiresAt: input.authorityExpiresAt,
+        usedAt: input.authorityCheckedAt
+      }).onConflictDoNothing({ target: integrationOauthStateNonces.nonce }).returning({ nonce: integrationOauthStateNonces.nonce });
+      if (consumed.length === 0) {
+        return null;
+      }
+      const [row] = await tx.insert(githubInstallations).values({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        installationId: input.installationId,
+        githubAccountId: input.githubAccountId,
+        accountLogin: input.accountLogin,
+        accountType: input.accountType,
+        repositoryScope: "selected",
+        linkedBySubjectId: input.linkedBySubjectId,
+        githubActorId: input.githubActorId,
+        githubActorLogin: input.githubActorLogin,
+        authorityKind: input.authorityKind,
+        authorityCheckedAt: input.authorityCheckedAt,
+        authorityExpiresAt: input.authorityExpiresAt,
+        authorityNonce: input.authorityNonce
+      }).onConflictDoUpdate({
+        target: [
+          githubInstallations.workspaceId,
+          githubInstallations.installationId
+        ],
+        set: {
+          accountId: input.accountId,
+          githubAccountId: input.githubAccountId,
+          accountLogin: input.accountLogin,
+          accountType: input.accountType,
+          repositoryScope: "selected",
+          linkedBySubjectId: input.linkedBySubjectId,
+          githubActorId: input.githubActorId,
+          githubActorLogin: input.githubActorLogin,
+          authorityKind: input.authorityKind,
+          authorityCheckedAt: input.authorityCheckedAt,
+          authorityExpiresAt: input.authorityExpiresAt,
+          authorityNonce: input.authorityNonce,
+          updatedAt: input.authorityCheckedAt
         }
       }).returning();
       if (!row) {
@@ -6085,10 +6379,29 @@ async function bindGitHubInstallationRepositories(db, input) {
           }))
         );
       }
+      await assertGitHubAuthorityWindowOpen(
+        tx,
+        input.authorityCheckedAt,
+        input.authorityExpiresAt
+      );
       return { ...mapGitHubInstallation(row), repositoryIds };
     })
   );
 }
+async function assertGitHubAuthorityWindowOpen(tx, checkedAt, expiresAt) {
+  const checkedAtIso = checkedAt.toISOString();
+  const expiresAtIso = expiresAt.toISOString();
+  const result = await tx.execute(sql4`
+    select (
+      ${checkedAtIso}::timestamptz <= clock_timestamp()
+      and clock_timestamp() < ${expiresAtIso}::timestamptz
+      and ${expiresAtIso}::timestamptz <= ${checkedAtIso}::timestamptz + interval '10 minutes'
+    ) as valid
+  `);
+  if (result[0]?.valid !== true) {
+    throw new GitHubInstallationAuthorityCommitError();
+  }
+}
 async function listGitHubInstallationsForWorkspace(db, workspaceId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const rows = await scopedDb.select().from(githubInstallations).where(eq6(githubInstallations.workspaceId, workspaceId)).orderBy(desc(githubInstallations.updatedAt));
@@ -6128,7 +6441,7 @@ async function areGitHubRepositoriesAllowedForWorkspace(db, workspaceId, install
     return false;
   }
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
-    const [installation] = await scopedDb.select({ repositoryScope: githubInstallations.repositoryScope }).from(githubInstallations).where(
+    const [installation] = await scopedDb.select().from(githubInstallations).where(
       and6(
         eq6(githubInstallations.workspaceId, workspaceId),
         eq6(githubInstallations.installationId, installationId)
@@ -6137,9 +6450,6 @@ async function areGitHubRepositoriesAllowedForWorkspace(db, workspaceId, install
     if (!installation) {
       return false;
     }
-    if (installation.repositoryScope === "all") {
-      return true;
-    }
     const allowed = await scopedDb.select({
       repositoryId: githubInstallationRepositories.repositoryId
     }).from(githubInstallationRepositories).where(
@@ -6149,7 +6459,13 @@ async function areGitHubRepositoriesAllowedForWorkspace(db, workspaceId, install
         inArray3(githubInstallationRepositories.repositoryId, requestedIds)
       )
     );
-    return allowed.length === requestedIds.length;
+    if (allowed.length !== requestedIds.length) {
+      return false;
+    }
+    return hasAuditableGitHubInstallationAuthority({
+      ...mapGitHubInstallation(installation),
+      repositoryIds: allowed.map((row) => row.repositoryId)
+    });
   });
 }
 async function deleteGitHubInstallationBinding(db, input) {
@@ -10365,6 +10681,7 @@ function mapCodexCapacityWaiter(row) {
     sessionId: row.sessionId,
     goalId: row.goalId,
     blockedTurnId: row.blockedTurnId,
+    blockedTurnGeneration: row.blockedTurnGeneration,
     workflowId: row.workflowId,
     generation: row.generation,
     status: row.status,
@@ -10411,6 +10728,11 @@ function nextCodexCapacityCheckAt(earliestResetAt, resetKind, refreshAttempt, no
 }
 async function armCodexCapacityWait(db, input) {
   const now = input.now ?? /* @__PURE__ */ new Date();
+  const goalId = input.goalId ?? null;
+  const goalVersion = input.goalVersion ?? null;
+  if (goalId === null !== (goalVersion === null) || goalVersion !== null && (!Number.isSafeInteger(goalVersion) || goalVersion < 1)) {
+    throw new Error("Codex capacity goal fence must be absent or contain a positive version");
+  }
   return await withRlsContext(
     db,
     { accountId: input.accountId, workspaceId: input.workspaceId },
@@ -10433,13 +10755,13 @@ async function armCodexCapacityWait(db, input) {
       const effectiveControl = session ? await evaluateSessionControl(tx, input.workspaceId, input.sessionId, {
         workspaceControl: locks.control ?? void 0
       }) : null;
-      const [goal] = await tx.select().from(sessionGoals).where(
+      const [goal] = goalId ? await tx.select().from(sessionGoals).where(
         and6(
           eq6(sessionGoals.workspaceId, input.workspaceId),
-          eq6(sessionGoals.id, input.goalId),
+          eq6(sessionGoals.id, goalId),
           eq6(sessionGoals.sessionId, input.sessionId)
         )
-      ).for("update").limit(1);
+      ).for("update").limit(1) : [];
       const leaseRows = input.leaseFence ? await tx.execute(sql4`
               select holder_id, generation
               from codex_credential_leases
@@ -10463,7 +10785,7 @@ async function armCodexCapacityWait(db, input) {
           events: []
         };
       }
-      if (existing?.status === "waiting" && existing.blockedTurnId === input.turnId && turn?.status === "failed") {
+      if (existing?.status === "waiting" && existing.blockedTurnId === input.turnId && existing.blockedTurnGeneration === turn?.executionGeneration && turn?.status === "waiting_capacity" && session?.status === "waiting_capacity" && session.activeTurnId === input.turnId) {
         return {
           action: "waiting",
           waiter: mapCodexCapacityWaiter(existing),
@@ -10474,7 +10796,7 @@ async function armCodexCapacityWait(db, input) {
       const currentRedispatches = Number(turn?.metadata?.workerDeathRedispatches ?? 0);
       const lease = leaseRows[0];
       const leaseFenceValid = !input.leaseFence || lease?.holder_id === input.leaseFence.holderId && Number(lease.generation) === input.leaseFence.generation && currentRedispatches === (input.expectedRedispatches ?? currentRedispatches);
-      if (!goal || effectiveControl?.state !== "active" || effectiveControl.settlement !== null || session.activeTurnId !== input.turnId || session.status !== "running" || goal.status !== "active" || goal.version !== input.goalVersion || turn.status !== "running" || turn.activeAttemptId !== input.attemptId || !leaseFenceValid || codexCapacityPolicyHashFromTurnMetadata(turn.metadata) !== policyHash) {
+      if (!session || !turn || effectiveControl?.state !== "active" || effectiveControl.settlement !== null || session.activeTurnId !== input.turnId || session.status !== "running" || goalId !== null && (!goal || goal.status !== "active" || goal.version !== goalVersion) || turn.status !== "running" || turn.activeAttemptId !== input.attemptId || !leaseFenceValid || codexCapacityPolicyHashFromTurnMetadata(turn.metadata) !== policyHash) {
         return {
           action: "stale",
           waiter: existing ? mapCodexCapacityWaiter(existing) : null,
@@ -10488,7 +10810,7 @@ async function armCodexCapacityWait(db, input) {
         sessionId: input.sessionId,
         turnId: input.turnId,
         executionGeneration: turn.executionGeneration,
-        outcome: "failed",
+        outcome: "waiting_capacity",
         closedAt: now
       });
       const generation = (existing?.generation ?? 0) + 1;
@@ -10503,12 +10825,13 @@ async function armCodexCapacityWait(db, input) {
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         sessionId: input.sessionId,
-        goalId: input.goalId,
+        goalId,
         blockedTurnId: input.turnId,
+        blockedTurnGeneration: turn.executionGeneration,
         workflowId: input.workflowId,
         generation,
         status: "waiting",
-        goalVersion: input.goalVersion,
+        goalVersion,
         policyHash,
         earliestResetAt: input.earliestResetAt,
         nextCheckAt,
@@ -10544,32 +10867,17 @@ async function armCodexCapacityWait(db, input) {
           workspaceId: input.workspaceId,
           sessionId: input.sessionId,
           sequence: ++sequence,
-          type: "turn.failed",
+          type: "codex.capacity.waiting",
           payload: sanitizeEventPayload({
             ...input.failurePayload,
             recovery: "codex_capacity",
-            retryable: false,
+            retryable: true,
             rotated: true,
-            capacityWaiterId: waiterRow.id,
-            capacityWaitGeneration: waiterRow.generation
-          }),
-          turnId: input.turnId,
-          turnGeneration: turn.executionGeneration,
-          turnAttemptId: input.attemptId,
-          turnAssociation: "current",
-          occurredAt: now
-        },
-        {
-          accountId: input.accountId,
-          workspaceId: input.workspaceId,
-          sessionId: input.sessionId,
-          sequence: ++sequence,
-          type: "codex.capacity.waiting",
-          payload: sanitizeEventPayload({
             waiterId: waiterRow.id,
             generation: waiterRow.generation,
-            goalId: input.goalId,
-            goalVersion: input.goalVersion,
+            goalId,
+            goalVersion,
+            blockedTurnGeneration: turn.executionGeneration,
             policyHash,
             resetKind: input.resetKind,
             earliestResetAt: input.earliestResetAt?.toISOString() ?? null,
@@ -10587,7 +10895,7 @@ async function armCodexCapacityWait(db, input) {
           sessionId: input.sessionId,
           sequence: ++sequence,
           type: "session.status.changed",
-          payload: { status: "idle", reason: "codex_capacity" },
+          payload: { status: "waiting_capacity", reason: "codex_capacity" },
           turnId: input.turnId,
           turnGeneration: turn.executionGeneration,
           turnAttemptId: input.attemptId,
@@ -10595,37 +10903,50 @@ async function armCodexCapacityWait(db, input) {
           occurredAt: now
         }
       ]).returning();
-      await tx.update(sessionTurns).set({
-        status: "failed",
+      const [waitingTurn] = await tx.update(sessionTurns).set({
+        status: "waiting_capacity",
         activeAttemptId: null,
+        metadata: metadataWithoutTurnDispatchAttempt(turn.metadata),
         version: turn.version + 1,
-        finishedAt: now,
+        finishedAt: null,
         updatedAt: now
       }).where(
         and6(
           eq6(sessionTurns.workspaceId, input.workspaceId),
           eq6(sessionTurns.id, input.turnId),
-          eq6(sessionTurns.status, "running")
+          eq6(sessionTurns.status, "running"),
+          eq6(sessionTurns.activeAttemptId, input.attemptId)
         )
-      );
-      await tx.update(sessions).set({
-        status: "idle",
-        activeTurnId: null,
+      ).returning({ id: sessionTurns.id });
+      if (!waitingTurn) {
+        throw new Error("Codex capacity blocked turn changed during atomic arm");
+      }
+      const [waitingSession] = await tx.update(sessions).set({
+        status: "waiting_capacity",
+        activeTurnId: input.turnId,
         lastSequence: sequence,
         updatedAt: now
       }).where(
         and6(
           eq6(sessions.workspaceId, input.workspaceId),
           eq6(sessions.id, input.sessionId),
+          eq6(sessions.status, "running"),
           eq6(sessions.activeTurnId, input.turnId)
         )
-      );
-      await tx.execute(sql4`
-          delete from codex_credential_leases
-          where account_id = ${input.accountId}
-            and workspace_id = ${input.workspaceId}
-            and turn_id = ${input.turnId}
-        `);
+      ).returning({ id: sessions.id });
+      if (!waitingSession) {
+        throw new Error("Codex capacity session changed during atomic arm");
+      }
+      if (input.leaseFence) {
+        await tx.execute(sql4`
+            delete from codex_credential_leases
+            where account_id = ${input.accountId}
+              and workspace_id = ${input.workspaceId}
+              and turn_id = ${input.turnId}
+              and holder_id = ${input.leaseFence.holderId}
+              and generation = ${input.leaseFence.generation}
+          `);
+      }
       return {
         action: "waiting",
         waiter: mapCodexCapacityWaiter(waiterRow),
@@ -10742,26 +11063,87 @@ async function supersedeCodexCapacityWaitInTransaction(tx, input) {
   if (!updated) {
     return { waiter: mapCodexCapacityWaiter(input.waiter), events: [] };
   }
-  const inserted = await tx.insert(sessionEvents).values({
-    accountId: input.session.accountId,
-    workspaceId: input.session.workspaceId,
-    sessionId: input.session.id,
-    sequence: input.session.lastSequence + 1,
-    type: "codex.capacity.superseded",
-    payload: sanitizeEventPayload({
-      waiterId: updated.id,
-      generation: updated.generation,
-      reason: input.reason
-    }),
-    turnId: updated.blockedTurnId,
-    occurredAt: input.now
-  }).returning();
-  await tx.update(sessions).set({ lastSequence: input.session.lastSequence + 1, updatedAt: input.now }).where(
+  const turnWasCurrent = input.session.activeTurnId === input.blockedTurn.id;
+  const turnStillWaiting = input.blockedTurn.status === "waiting_capacity";
+  const terminalTurnStatus = input.session.status === "cancelled" ? "cancelled" : "superseded";
+  if (turnStillWaiting) {
+    const [supersededTurn] = await tx.update(sessionTurns).set({
+      status: terminalTurnStatus,
+      activeAttemptId: null,
+      cancelledBy: "codex_capacity_reconcile",
+      cancelReason: input.reason,
+      version: input.blockedTurn.version + 1,
+      finishedAt: input.now,
+      updatedAt: input.now
+    }).where(
+      and6(
+        eq6(sessionTurns.workspaceId, input.session.workspaceId),
+        eq6(sessionTurns.id, input.blockedTurn.id),
+        eq6(sessionTurns.status, "waiting_capacity"),
+        isNull(sessionTurns.activeAttemptId),
+        eq6(sessionTurns.executionGeneration, input.waiter.blockedTurnGeneration)
+      )
+    ).returning({ id: sessionTurns.id });
+    if (!supersededTurn) {
+      throw new Error("Codex capacity blocked turn changed during atomic supersession");
+    }
+  }
+  const [queued] = turnWasCurrent ? await tx.select({ id: sessionTurns.id }).from(sessionTurns).where(
+    and6(
+      eq6(sessionTurns.workspaceId, input.session.workspaceId),
+      eq6(sessionTurns.sessionId, input.session.id),
+      eq6(sessionTurns.status, "queued")
+    )
+  ).limit(1) : [];
+  const nextSessionStatus = input.session.status === "cancelled" ? "cancelled" : queued ? "queued" : "idle";
+  const eventValues = [
+    {
+      accountId: input.session.accountId,
+      workspaceId: input.session.workspaceId,
+      sessionId: input.session.id,
+      sequence: input.session.lastSequence + 1,
+      type: "codex.capacity.superseded",
+      payload: sanitizeEventPayload({
+        waiterId: updated.id,
+        generation: updated.generation,
+        reason: input.reason
+      }),
+      turnId: updated.blockedTurnId,
+      turnGeneration: input.blockedTurn.executionGeneration,
+      ...turnWasCurrent ? { turnAssociation: "current" } : {},
+      occurredAt: input.now
+    }
+  ];
+  if (turnWasCurrent && input.session.status !== nextSessionStatus) {
+    eventValues.push({
+      accountId: input.session.accountId,
+      workspaceId: input.session.workspaceId,
+      sessionId: input.session.id,
+      sequence: input.session.lastSequence + 2,
+      type: "session.status.changed",
+      payload: { status: nextSessionStatus, reason: input.reason },
+      turnId: updated.blockedTurnId,
+      turnGeneration: input.blockedTurn.executionGeneration,
+      turnAssociation: "current",
+      occurredAt: input.now
+    });
+  }
+  const inserted = await tx.insert(sessionEvents).values(eventValues).returning();
+  const lastSequence = input.session.lastSequence + inserted.length;
+  const [updatedSession] = await tx.update(sessions).set({
+    ...turnWasCurrent ? { status: nextSessionStatus, activeTurnId: null } : {},
+    lastSequence,
+    updatedAt: input.now
+  }).where(
     and6(
       eq6(sessions.workspaceId, input.session.workspaceId),
-      eq6(sessions.id, input.session.id)
+      eq6(sessions.id, input.session.id),
+      ...turnWasCurrent ? [eq6(sessions.activeTurnId, input.blockedTurn.id)] : []
     )
-  );
+  ).returning({ id: sessions.id });
+  if (!updatedSession) {
+    throw new Error("Codex capacity session changed during atomic supersession");
+  }
   return {
     waiter: mapCodexCapacityWaiter(updated),
     events: inserted.map(mapEvent2)
@@ -10808,61 +11190,47 @@ async function reconcileCodexCapacityWait(db, input, decide, policy) {
       const effectiveControl = session ? await evaluateSessionControl(tx, input.workspaceId, input.sessionId, {
         workspaceControl: prefix.control ?? void 0
       }) : null;
-      const [goal] = await tx.select().from(sessionGoals).where(
+      const [goal] = waiterRead.goalId ? await tx.select().from(sessionGoals).where(
         and6(
           eq6(sessionGoals.workspaceId, input.workspaceId),
           eq6(sessionGoals.id, waiterRead.goalId),
           eq6(sessionGoals.sessionId, input.sessionId)
         )
-      ).for("update").limit(1);
+      ).for("update").limit(1) : [];
       const [waiter] = await tx.select().from(codexCapacityWaiters).where(eq6(codexCapacityWaiters.id, input.waiterId)).for("update").limit(1);
-      if (!session || !goal || !blockedTurn || !waiter || session.accountId !== input.accountId || blockedTurn.accountId !== input.accountId || blockedTurn.sessionId !== input.sessionId || waiter.accountId !== input.accountId || waiter.workspaceId !== input.workspaceId || waiter.sessionId !== input.sessionId || waiter.blockedTurnId !== blockedTurn.id || waiter.generation !== input.generation || waiter.status !== "waiting") {
+      if (!session || !blockedTurn || !waiter || session.accountId !== input.accountId || blockedTurn.accountId !== input.accountId || blockedTurn.sessionId !== input.sessionId || waiter.accountId !== input.accountId || waiter.workspaceId !== input.workspaceId || waiter.sessionId !== input.sessionId || waiter.blockedTurnId !== blockedTurn.id || waiter.generation !== input.generation || waiter.status !== "waiting") {
         return {
           action: "stale",
           waiter: waiter ? mapCodexCapacityWaiter(waiter) : null,
           events: []
         };
       }
-      const [pending] = await tx.select({ id: sessionTurns.id }).from(sessionTurns).where(
-        and6(
-          eq6(sessionTurns.workspaceId, input.workspaceId),
-          eq6(sessionTurns.sessionId, input.sessionId),
-          inArray3(sessionTurns.status, [
-            "queued",
-            "running",
-            "requires_action",
-            "recovering",
-            "waiting_capacity"
-          ])
-        )
-      ).limit(1);
-      const [laterTurn] = await tx.select({ id: sessionTurns.id }).from(sessionTurns).where(
-        and6(
-          eq6(sessionTurns.workspaceId, input.workspaceId),
-          eq6(sessionTurns.sessionId, input.sessionId),
-          gt(sessionTurns.position, blockedTurn.position)
-        )
-      ).limit(1);
+      if (effectiveControl?.state !== "active" || effectiveControl.settlement !== null) {
+        return {
+          action: "paused",
+          waiter: mapCodexCapacityWaiter(waiter),
+          events: []
+        };
+      }
       const currentPolicyHash = codexCapacityPolicyHashFromTurnMetadata(blockedTurn.metadata);
       let supersedeReason = null;
-      if (effectiveControl?.state !== "active" || effectiveControl.settlement !== null) {
-        supersedeReason = "control_changed";
-      } else if (goal.status !== "active" || goal.version !== waiter.goalVersion) {
+      if (session.status === "cancelled") {
+        supersedeReason = "session_cancelled";
+      } else if (waiter.goalId !== null && (!goal || goal.status !== "active" || goal.version !== waiter.goalVersion)) {
         supersedeReason = "goal_changed";
       } else if (currentPolicyHash !== waiter.policyHash) {
         supersedeReason = "credential_policy_changed";
-      } else if (session.status !== "idle" || session.activeTurnId !== null) {
-        supersedeReason = "session_not_capacity_idle";
-      } else if (blockedTurn.status !== "failed") {
+      } else if (session.activeTurnId !== blockedTurn.id) {
+        supersedeReason = "active_turn_changed";
+      } else if (session.status !== "waiting_capacity") {
+        supersedeReason = "session_not_waiting_capacity";
+      } else if (blockedTurn.status !== "waiting_capacity" || blockedTurn.activeAttemptId !== null || blockedTurn.executionGeneration !== waiter.blockedTurnGeneration) {
         supersedeReason = "blocked_turn_changed";
-      } else if (pending) {
-        supersedeReason = "pending_work_exists";
-      } else if (laterTurn) {
-        supersedeReason = "newer_turn_exists";
       }
       if (supersedeReason) {
         const superseded = await supersedeCodexCapacityWaitInTransaction(tx, {
           session,
+          blockedTurn,
           waiter,
           reason: supersedeReason,
           now
@@ -10927,77 +11295,26 @@ async function reconcileCodexCapacityWait(db, input, decide, policy) {
           events: []
         };
       }
-      const prompt = [
-        "[CODEX CAPACITY RESUME] Codex subscription capacity is available again.",
-        `Continue the existing active goal from durable conversation history: ${goal.text}`,
-        `Success criteria: ${goal.successCriteria ?? "none specified"}.`,
-        "Do not replay completed tool side effects; verify any ambiguous in-flight effect before repeating it.",
-        "If the goal is complete, call opengeni__goal_complete. If blocked for another reason, call opengeni__goal_pause."
-      ].join("\n");
-      const [update] = await tx.insert(sessionSystemUpdates).values({
-        accountId: input.accountId,
-        workspaceId: input.workspaceId,
-        sessionId: input.sessionId,
-        kind: "goal_continuation",
-        classification: "info",
-        sourceId: goal.id,
-        dedupeKey: `codex-capacity-resume:${waiter.id}:${waiter.generation}`,
-        summary: prompt,
-        payload: {
-          type: "goal_continuation",
-          goalId: goal.id,
-          goalVersion: goal.version,
-          prompt,
-          reason: "codex_capacity",
-          capacityWaiterId: waiter.id,
-          capacityWaitGeneration: waiter.generation,
-          policy: {
-            model: blockedTurn.model,
-            reasoningEffort: blockedTurn.reasoningEffort,
-            tools: blockedTurn.tools,
-            sandboxBackend: blockedTurn.sandboxBackend
-          }
-        },
-        lineage: {
-          goalId: goal.id,
-          blockedTurnId: blockedTurn.id,
-          capacityWaiterId: waiter.id
-        },
-        state: "pending"
-      }).returning();
-      if (!update) {
-        throw new Error("Codex capacity resume did not create an internal update");
-      }
-      await tx.insert(usageEvents).values({
-        accountId: input.accountId,
-        workspaceId: input.workspaceId,
-        eventType: "agent_run.created",
-        quantity: 1,
-        unit: "run",
-        sourceResourceType: "session_system_update",
-        sourceResourceId: update.id,
-        sessionId: input.sessionId,
-        initiatorKind: "service",
-        initiatorSubjectId: "goal-continuation",
-        initiatorContext: { goalId: goal.id, reason: "codex_capacity" },
-        origin: "goal",
-        idempotencyKey: `agent_run.created:codex-capacity:${input.workspaceId}:${update.id}`,
-        occurredAt: now
-      }).onConflictDoNothing({ target: usageEvents.idempotencyKey });
       const events = await tx.insert(sessionEvents).values([
         {
           accountId: input.accountId,
           workspaceId: input.workspaceId,
           sessionId: input.sessionId,
           sequence: session.lastSequence + 1,
-          type: "system.update.pending",
+          type: "codex.capacity.resumed",
           payload: sanitizeEventPayload({
-            updateId: update.id,
-            kind: update.kind,
-            classification: update.classification,
-            sourceId: update.sourceId,
-            summary: update.summary
+            waiterId: waiter.id,
+            generation: waiter.generation,
+            wakeRevision: waiter.wakeRevision,
+            goalId: waiter.goalId,
+            goalVersion: waiter.goalVersion,
+            blockedTurnGeneration: waiter.blockedTurnGeneration,
+            policyHash: waiter.policyHash,
+            diagnostic: decision.diagnostic ?? null
           }),
+          turnId: blockedTurn.id,
+          turnGeneration: blockedTurn.executionGeneration,
+          turnAssociation: "current",
           occurredAt: now
         },
         {
@@ -11005,24 +11322,17 @@ async function reconcileCodexCapacityWait(db, input, decide, policy) {
           workspaceId: input.workspaceId,
           sessionId: input.sessionId,
           sequence: session.lastSequence + 2,
-          type: "codex.capacity.resumed",
-          payload: sanitizeEventPayload({
-            waiterId: waiter.id,
-            generation: waiter.generation,
-            wakeRevision: waiter.wakeRevision,
-            goalId: goal.id,
-            goalVersion: goal.version,
-            policyHash: waiter.policyHash,
-            diagnostic: decision.diagnostic ?? null,
-            updateId: update.id
-          }),
+          type: "session.status.changed",
+          payload: { status: "recovering", reason: "codex_capacity" },
           turnId: blockedTurn.id,
+          turnGeneration: blockedTurn.executionGeneration,
+          turnAssociation: "current",
           occurredAt: now
         }
       ]).returning();
       const [updatedWaiter] = await tx.update(codexCapacityWaiters).set({
         status: "resumed",
-        resumedUpdateId: update.id,
+        resumedUpdateId: null,
         observedWakeRevision: waiter.wakeRevision,
         lastWakeReason: "capacity_available",
         updatedAt: now
@@ -11036,22 +11346,44 @@ async function reconcileCodexCapacityWait(db, input, decide, policy) {
       if (!updatedWaiter) {
         throw new Error("Codex capacity waiter changed during atomic resume");
       }
-      await tx.update(sessions).set({
-        status: "queued",
-        activeTurnId: null,
+      const [recoveringTurn] = await tx.update(sessionTurns).set({
+        status: "recovering",
+        activeAttemptId: null,
+        metadata: metadataWithoutTurnDispatchAttempt(blockedTurn.metadata),
+        version: blockedTurn.version + 1,
+        finishedAt: null,
+        updatedAt: now
+      }).where(
+        and6(
+          eq6(sessionTurns.workspaceId, input.workspaceId),
+          eq6(sessionTurns.id, blockedTurn.id),
+          eq6(sessionTurns.status, "waiting_capacity"),
+          isNull(sessionTurns.activeAttemptId),
+          eq6(sessionTurns.executionGeneration, waiter.blockedTurnGeneration)
+        )
+      ).returning({ id: sessionTurns.id });
+      if (!recoveringTurn) {
+        throw new Error("Codex capacity blocked turn changed during atomic resume");
+      }
+      const [recoveringSession] = await tx.update(sessions).set({
+        status: "recovering",
+        activeTurnId: blockedTurn.id,
         lastSequence: session.lastSequence + 2,
         updatedAt: now
       }).where(
         and6(
           eq6(sessions.workspaceId, input.workspaceId),
           eq6(sessions.id, input.sessionId),
-          isNull(sessions.activeTurnId)
+          eq6(sessions.status, "waiting_capacity"),
+          eq6(sessions.activeTurnId, blockedTurn.id)
         )
-      );
+      ).returning({ id: sessions.id });
+      if (!recoveringSession) {
+        throw new Error("Codex capacity session changed during atomic resume");
+      }
       return {
         action: "resumed",
         waiter: mapCodexCapacityWaiter(updatedWaiter),
-        update: mapSessionSystemUpdate(update),
         events: events.map(mapEvent2)
       };
     })
@@ -13349,17 +13681,19 @@ async function listSessionsForSubject(db, workspaceId, options) {
           if (ordinaryIds.length > limit) {
             let snapshot = reusableSnapshot;
             if (!snapshot) {
-              const activeSnapshots = await tx.select({ id: sessionListSnapshots.id }).from(sessionListSnapshots).where(
-                and6(
-                  eq6(sessionListSnapshots.workspaceId, workspaceId),
-                  eq6(sessionListSnapshots.subjectId, options.subjectId)
-                )
-              ).limit(SESSION_LIST_SNAPSHOT_MAX_ACTIVE_PER_SUBJECT);
-              if (activeSnapshots.length >= SESSION_LIST_SNAPSHOT_MAX_ACTIVE_PER_SUBJECT) {
-                throw new SessionListSnapshotLimitError(
-                  "too many active session list snapshots; retry after an existing cursor expires"
-                );
-              }
+              await tx.execute(sql4`
+                delete from ${sessionListSnapshots} snapshot
+                where snapshot.workspace_id = ${workspaceId}
+                  and snapshot.subject_id = ${options.subjectId}
+                  and snapshot.id in (
+                    select evicted.id
+                    from ${sessionListSnapshots} evicted
+                    where evicted.workspace_id = ${workspaceId}
+                      and evicted.subject_id = ${options.subjectId}
+                    order by evicted.created_at desc, evicted.id desc
+                    offset ${SESSION_LIST_SNAPSHOT_MAX_ACTIVE_PER_SUBJECT - 1}
+                  )
+              `);
               const [workspace] = await tx.select({ accountId: workspaces.accountId }).from(workspaces).where(eq6(workspaces.id, workspaceId)).limit(1);
               if (!workspace) {
                 throw new Error("session list workspace disappeared while creating a snapshot");
@@ -16163,7 +16497,7 @@ async function acquireLease(db, input) {
       }
       if (liveness === "cold") {
         const recovery = recoveryStateFromLeaseRow(row);
-        if (recovery.restore.status === "degraded" || recovery.restore.status === "unrecoverable") {
+        if (recovery.restore.status === "degraded" && recovery.restore.retryable !== true || recovery.restore.status === "unrecoverable") {
           return {
             role: "blocked",
             code: recovery.restore.status === "degraded" ? "restore_degraded" : "restore_unrecoverable",
@@ -16642,12 +16976,148 @@ async function recordWarmingSandboxCreated(db, input) {
     })
   );
 }
+var LOST_PROVIDER_PROCESS_REASON = "provider_instance_lost";
+async function lockExactLostProviderWorkspaceBlockersTx(tx, input) {
+  await tx.execute(sql4`
+    select id from sandbox_retained_processes
+    where account_id = ${input.accountId}
+      and workspace_id = ${input.workspaceId}
+      and lease_id = ${input.leaseId}
+      and sandbox_group_id = ${input.sandboxGroupId}
+      and lease_epoch = ${input.lostEpoch}
+      and provider_instance_id = ${input.lostInstanceId}
+      and state = 'active'
+    order by id
+    for update
+  `);
+  await tx.execute(sql4`
+    select id from sandbox_workspace_mutation_admissions
+    where account_id = ${input.accountId}
+      and workspace_id = ${input.workspaceId}
+      and lease_id = ${input.leaseId}
+      and sandbox_group_id = ${input.sandboxGroupId}
+      and lease_epoch = ${input.lostEpoch}
+      and provider_instance_id = ${input.lostInstanceId}
+      and settled_at is null
+    order by id
+    for update
+  `);
+  await tx.execute(sql4`
+    select id from sandbox_pty_sessions
+    where account_id = ${input.accountId}
+      and workspace_id = ${input.workspaceId}
+      and lease_id = ${input.leaseId}
+      and sandbox_group_id = ${input.sandboxGroupId}
+      and lease_epoch = ${input.lostEpoch}
+      and provider_instance_id = ${input.lostInstanceId}
+      and status = 'open'
+    order by id
+    for update
+  `);
+}
+async function settleExactLostProviderWorkspaceBlockersTx(tx, input) {
+  const lostProcesses = await tx.update(sandboxRetainedProcesses).set({
+    state: "lost",
+    exitCode: null,
+    settlementReason: LOST_PROVIDER_PROCESS_REASON,
+    settledAt: /* @__PURE__ */ new Date()
+  }).where(
+    and6(
+      eq6(sandboxRetainedProcesses.accountId, input.accountId),
+      eq6(sandboxRetainedProcesses.workspaceId, input.workspaceId),
+      eq6(sandboxRetainedProcesses.leaseId, input.leaseId),
+      eq6(sandboxRetainedProcesses.sandboxGroupId, input.sandboxGroupId),
+      eq6(sandboxRetainedProcesses.leaseEpoch, input.lostEpoch),
+      eq6(sandboxRetainedProcesses.providerInstanceId, input.lostInstanceId),
+      eq6(sandboxRetainedProcesses.state, "active")
+    )
+  ).returning({
+    id: sandboxRetainedProcesses.id,
+    holderId: sandboxRetainedProcesses.holderId
+  });
+  const rejectedAdmissions = await tx.update(sandboxWorkspaceMutationAdmissions).set({ providerOutcome: "rejected", settledAt: /* @__PURE__ */ new Date() }).where(
+    and6(
+      eq6(sandboxWorkspaceMutationAdmissions.accountId, input.accountId),
+      eq6(sandboxWorkspaceMutationAdmissions.workspaceId, input.workspaceId),
+      eq6(sandboxWorkspaceMutationAdmissions.leaseId, input.leaseId),
+      eq6(sandboxWorkspaceMutationAdmissions.sandboxGroupId, input.sandboxGroupId),
+      eq6(sandboxWorkspaceMutationAdmissions.leaseEpoch, input.lostEpoch),
+      eq6(sandboxWorkspaceMutationAdmissions.providerInstanceId, input.lostInstanceId),
+      isNull(sandboxWorkspaceMutationAdmissions.settledAt)
+    )
+  ).returning({ id: sandboxWorkspaceMutationAdmissions.id });
+  const closedPtys = await tx.update(sandboxPtySessions).set({ status: "closed", closedAt: /* @__PURE__ */ new Date() }).where(
+    and6(
+      eq6(sandboxPtySessions.accountId, input.accountId),
+      eq6(sandboxPtySessions.workspaceId, input.workspaceId),
+      eq6(sandboxPtySessions.leaseId, input.leaseId),
+      eq6(sandboxPtySessions.sandboxGroupId, input.sandboxGroupId),
+      eq6(sandboxPtySessions.leaseEpoch, input.lostEpoch),
+      eq6(sandboxPtySessions.providerInstanceId, input.lostInstanceId),
+      eq6(sandboxPtySessions.status, "open")
+    )
+  ).returning({ id: sandboxPtySessions.id });
+  const deletedHolders = lostProcesses.length === 0 ? [] : await tx.delete(sandboxLeaseHolders).where(
+    and6(
+      eq6(sandboxLeaseHolders.accountId, input.accountId),
+      eq6(sandboxLeaseHolders.workspaceId, input.workspaceId),
+      eq6(sandboxLeaseHolders.leaseId, input.leaseId),
+      eq6(sandboxLeaseHolders.kind, "process"),
+      inArray3(
+        sandboxLeaseHolders.holderId,
+        lostProcesses.map((process) => process.holderId)
+      )
+    )
+  ).returning({ holderId: sandboxLeaseHolders.holderId });
+  await tx.execute(sql4`
+    update sandbox_leases as lease set
+      refcount = counts.total,
+      turn_holders = counts.turns,
+      viewer_holders = counts.viewers,
+      updated_at = now()
+    from (
+      select count(*)::int as total,
+        count(*) filter (where kind = 'turn')::int as turns,
+        count(*) filter (where kind = 'viewer')::int as viewers
+      from sandbox_lease_holders
+      where lease_id = ${input.leaseId}
+    ) as counts
+    where lease.id = ${input.leaseId}
+  `);
+  return {
+    processesLost: lostProcesses.length,
+    admissionsRejected: rejectedAdmissions.length,
+    ptysClosed: closedPtys.length,
+    processHoldersDeleted: deletedHolders.length
+  };
+}
 async function markWarmLeaseInstanceLost(db, input) {
   return await withRlsContext(
     db,
     { accountId: input.accountId, workspaceId: input.workspaceId },
     async (scopedDb) => await scopedDb.transaction(async (txRaw) => {
       const tx = txRaw;
+      const observedRows = await tx.execute(sql4`
+          select * from sandbox_leases
+          where workspace_id = ${input.workspaceId}
+            and sandbox_group_id = ${input.sandboxGroupId}
+        `);
+      const observed = observedRows[0];
+      if (!observed || observed.liveness !== "warm" || Number(observed.lease_epoch) !== input.expectedEpoch || observed.instance_id !== input.expectedInstanceId) {
+        return {
+          status: "stale",
+          lease: observed ? mapLeaseRow(observed) : null
+        };
+      }
+      const blockerScope = {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        leaseId: observed.id,
+        sandboxGroupId: input.sandboxGroupId,
+        lostEpoch: input.expectedEpoch,
+        lostInstanceId: input.expectedInstanceId
+      };
+      await lockExactLostProviderWorkspaceBlockersTx(tx, blockerScope);
       const currentRows = await tx.execute(sql4`
           select * from sandbox_leases
           where workspace_id = ${input.workspaceId}
@@ -16655,12 +17125,13 @@ async function markWarmLeaseInstanceLost(db, input) {
           for update
         `);
       const current = currentRows[0];
-      if (!current || current.liveness !== "warm" || Number(current.lease_epoch) !== input.expectedEpoch || current.instance_id !== input.expectedInstanceId) {
+      if (!current || current.id !== observed.id || current.liveness !== "warm" || Number(current.lease_epoch) !== input.expectedEpoch || current.instance_id !== input.expectedInstanceId) {
         return {
           status: "stale",
           lease: current ? mapLeaseRow(current) : null
         };
       }
+      const settlement = await settleExactLostProviderWorkspaceBlockersTx(tx, blockerScope);
       const observedAt = (/* @__PURE__ */ new Date()).toISOString();
       const before = recoveryStateFromLeaseRow(current);
       const archiveStatus = before.archive.status;
@@ -16711,7 +17182,66 @@ async function markWarmLeaseInstanceLost(db, input) {
       if (!updated) {
         throw new Error(`Warm sandbox lease vanished while retiring instance ${current.id}`);
       }
-      return { status: "marked", lease: mapLeaseRow(updated) };
+      return { status: "marked", lease: mapLeaseRow(updated), settlement };
+    })
+  );
+}
+async function reconcileColdLostLeaseInstanceBlockers(db, input) {
+  if (!Number.isSafeInteger(input.expectedCurrentEpoch) || !Number.isSafeInteger(input.expectedLostEpoch) || input.expectedCurrentEpoch !== input.expectedLostEpoch + 1) {
+    throw new Error("Cold lost-provider reconciliation requires currentEpoch = lostEpoch + 1");
+  }
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await scopedDb.transaction(async (txRaw) => {
+      const tx = txRaw;
+      const observedRows = await tx.execute(sql4`
+          select * from sandbox_leases
+          where workspace_id = ${input.workspaceId}
+            and sandbox_group_id = ${input.sandboxGroupId}
+        `);
+      const observed = observedRows[0];
+      const observedRecovery = observed ? recoveryStateFromLeaseRow(observed) : null;
+      if (!observed || observed.liveness !== "cold" || observed.instance_id !== null || Number(observed.lease_epoch) !== input.expectedCurrentEpoch || Number(observed.workspace_generation) !== input.expectedWorkspaceGeneration || (observed.archive_generation === null ? null : Number(observed.archive_generation)) !== input.expectedArchiveGeneration || hasCompleteWorkspaceArchive(observed) !== input.expectedArchiveComplete || observedRecovery?.provider.status !== "missing" || observedRecovery.provider.instanceId !== input.expectedLostInstanceId) {
+        return {
+          status: "stale",
+          lease: observed ? mapLeaseRow(observed) : null
+        };
+      }
+      const blockerScope = {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        leaseId: observed.id,
+        sandboxGroupId: input.sandboxGroupId,
+        lostEpoch: input.expectedLostEpoch,
+        lostInstanceId: input.expectedLostInstanceId
+      };
+      await lockExactLostProviderWorkspaceBlockersTx(tx, blockerScope);
+      const currentRows = await tx.execute(sql4`
+          select * from sandbox_leases
+          where workspace_id = ${input.workspaceId}
+            and sandbox_group_id = ${input.sandboxGroupId}
+          for update
+        `);
+      const current = currentRows[0];
+      const recovery = current ? recoveryStateFromLeaseRow(current) : null;
+      if (!current || current.id !== observed.id || current.liveness !== "cold" || current.instance_id !== null || Number(current.lease_epoch) !== input.expectedCurrentEpoch || Number(current.workspace_generation) !== input.expectedWorkspaceGeneration || (current.archive_generation === null ? null : Number(current.archive_generation)) !== input.expectedArchiveGeneration || hasCompleteWorkspaceArchive(current) !== input.expectedArchiveComplete || recovery?.provider.status !== "missing" || recovery.provider.instanceId !== input.expectedLostInstanceId) {
+        return {
+          status: "stale",
+          lease: current ? mapLeaseRow(current) : null
+        };
+      }
+      const settlement = await settleExactLostProviderWorkspaceBlockersTx(tx, blockerScope);
+      const refreshedRows = await tx.execute(sql4`
+          select * from sandbox_leases where id = ${current.id}
+        `);
+      const refreshed = refreshedRows[0];
+      if (!refreshed) throw new Error("Cold sandbox lease vanished during reconciliation");
+      return {
+        status: "reconciled",
+        lease: mapLeaseRow(refreshed),
+        settlement
+      };
     })
   );
 }
@@ -17204,6 +17734,45 @@ var SandboxWorkspaceMutationFencedError = class extends Error {
   }
   name = "SandboxWorkspaceMutationFencedError";
 };
+function retainedProcessSettlementIdentity(process) {
+  return {
+    leaseId: process.leaseId,
+    sandboxGroupId: process.sandboxGroupId,
+    parentAdmissionId: process.parentAdmissionId,
+    holderId: process.holderId,
+    leaseEpoch: process.leaseEpoch,
+    providerBackend: process.providerBackend,
+    providerInstanceId: process.providerInstanceId,
+    routeKind: process.routeKind,
+    routeTargetId: process.routeTargetId,
+    routeEpoch: process.routeEpoch,
+    providerSessionId: process.providerSessionId
+  };
+}
+function retainedProcessReconciliationProof(process) {
+  if (process.reconcileProofOutcome === "exited" && process.reconcileProofReason === "provider_exit_banner" && process.reconcileProofExitCode !== null) {
+    return {
+      outcome: "exited",
+      exitCode: process.reconcileProofExitCode,
+      reason: "provider_exit_banner"
+    };
+  }
+  if (process.reconcileProofOutcome === "lost" && (process.reconcileProofReason === "provider_session_lost_banner" || process.reconcileProofReason === "provider_instance_not_found")) {
+    return {
+      outcome: "lost",
+      exitCode: null,
+      reason: process.reconcileProofReason
+    };
+  }
+  return null;
+}
+var SandboxRetainedProcessPromotionFencedError = class extends SandboxWorkspaceMutationFencedError {
+  constructor(code, message, process) {
+    super(code, message);
+    this.process = process;
+  }
+  name = "SandboxRetainedProcessPromotionFencedError";
+};
 function normalizeWorkspaceMutationOperation(operation) {
   const normalized = operation.trim();
   const byteLength = new TextEncoder().encode(normalized).byteLength;
@@ -17233,6 +17802,17 @@ function normalizeRetainedProcessSettlementReason(reason) {
   }
   return bounded;
 }
+function normalizeRetainedProcessReconciliationOutcome(outcome) {
+  const normalized = outcome.trim();
+  const byteLength = Buffer.byteLength(normalized, "utf8");
+  if (byteLength < 1 || byteLength > 64) {
+    throw new SandboxWorkspaceMutationFencedError(
+      "process_fenced",
+      "Retained process reconciliation outcome must contain between 1 and 64 UTF-8 bytes"
+    );
+  }
+  return normalized;
+}
 function mapWorkspaceMutationAdmission(row) {
   return {
     id: row.id,
@@ -17278,9 +17858,21 @@ function mapRetainedProcess(row) {
     exitCode: row.exitCode ?? null,
     settlementReason: row.settlementReason ?? null,
     startedAt: row.startedAt.toISOString(),
-    settledAt: row.settledAt?.toISOString() ?? null
+    settledAt: row.settledAt?.toISOString() ?? null,
+    reconcileAfter: row.reconcileAfter.toISOString(),
+    reconcileClaimId: row.reconcileClaimId ?? null,
+    reconcileClaimedAt: row.reconcileClaimedAt?.toISOString() ?? null,
+    reconcileAttempts: row.reconcileAttempts,
+    lastReconcileOutcome: row.lastReconcileOutcome ?? null,
+    reconcileProofOutcome: row.reconcileProofOutcome ?? null,
+    reconcileProofExitCode: row.reconcileProofExitCode ?? null,
+    reconcileProofReason: row.reconcileProofReason ?? null,
+    reconcileProofObservedAt: row.reconcileProofObservedAt?.toISOString() ?? null
   };
 }
+function retainedProcessMatchesSettlementIdentity(process, expected) {
+  return process.leaseId === expected.leaseId && process.sandboxGroupId === expected.sandboxGroupId && process.parentAdmissionId === expected.parentAdmissionId && process.holderId === expected.holderId && process.leaseEpoch === expected.leaseEpoch && process.providerBackend === expected.providerBackend && process.providerInstanceId === expected.providerInstanceId && process.routeKind === expected.routeKind && (process.routeTargetId ?? null) === expected.routeTargetId && process.routeEpoch === expected.routeEpoch && process.providerSessionId === expected.providerSessionId;
+}
 async function lockWorkspaceMutationSessionTx(tx, workspaceId, sessionId) {
   const locks = await lockSessionEventWriteRows(tx, {
     workspaceId,
@@ -17901,7 +18493,11 @@ async function retainWorkspaceMutationProcess(db, input) {
     })
   );
   if (result.failure.failure !== null) {
-    throw new SandboxWorkspaceMutationFencedError(result.failure.failure, result.failure.detail);
+    throw new SandboxRetainedProcessPromotionFencedError(
+      result.failure.failure,
+      result.failure.detail,
+      result.process
+    );
   }
   return result.process;
 }
@@ -17917,6 +18513,186 @@ async function getRetainedProcess(db, input) {
     return row ? mapRetainedProcess(row) : null;
   });
 }
+async function claimTerminalRetainedProcesses(db, input) {
+  if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100) {
+    throw new Error("Retained process reconciliation limit must be between 1 and 100");
+  }
+  if (!Number.isSafeInteger(input.claimTtlMs) || input.claimTtlMs < 0 || input.claimTtlMs > 36e5) {
+    throw new Error("Retained process reconciliation claim TTL is invalid");
+  }
+  const rows = await rawRows(
+    db,
+    sql4`
+      select account_id, workspace_id, session_id, process_id, claim_id,
+        owner_state, owner_attempt_outcome
+      from opengeni_private.claim_terminal_retained_processes(
+        ${input.claimId}::uuid, ${input.limit}::integer, ${input.claimTtlMs}::bigint
+      )
+    `
+  );
+  const claims = [];
+  for (const row of rows) {
+    const process = await getRetainedProcess(db, {
+      workspaceId: row.workspace_id,
+      sessionId: row.session_id,
+      processId: row.process_id
+    });
+    if (!process || process.accountId !== row.account_id || process.state !== "active" || process.reconcileClaimId !== row.claim_id) {
+      continue;
+    }
+    claims.push({
+      process,
+      claimId: row.claim_id,
+      ownerState: row.owner_state,
+      ownerAttemptOutcome: row.owner_attempt_outcome
+    });
+  }
+  return claims;
+}
+async function recordRetainedProcessReconciliationProof(db, input) {
+  if (input.proof.outcome === "exited" && (!Number.isSafeInteger(input.proof.exitCode) || input.proof.exitCode === null)) {
+    throw new SandboxWorkspaceMutationFencedError(
+      "process_fenced",
+      "Retained process reconciliation exit proof requires a safe integer exit code"
+    );
+  }
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await scopedDb.transaction(async (txRaw) => {
+      const tx = txRaw;
+      const [process] = await tx.select().from(sandboxRetainedProcesses).where(
+        and6(
+          eq6(sandboxRetainedProcesses.accountId, input.accountId),
+          eq6(sandboxRetainedProcesses.workspaceId, input.workspaceId),
+          eq6(sandboxRetainedProcesses.sessionId, input.sessionId),
+          eq6(sandboxRetainedProcesses.id, input.processId)
+        )
+      ).for("update").limit(1);
+      if (!process || process.state !== "active" || !retainedProcessMatchesSettlementIdentity(process, input.expected)) {
+        throw new SandboxWorkspaceMutationFencedError(
+          "process_fenced",
+          "Retained process proof did not match an active copied durable identity"
+        );
+      }
+      if (process.reconcileClaimId !== input.claimId) {
+        throw new SandboxWorkspaceMutationFencedError(
+          "process_fenced",
+          "Retained process proof claim was lost or superseded"
+        );
+      }
+      const existing = mapRetainedProcess(process);
+      const existingProof = retainedProcessReconciliationProof(existing);
+      if (existingProof) {
+        if (existingProof.outcome !== input.proof.outcome || existingProof.exitCode !== input.proof.exitCode || existingProof.reason !== input.proof.reason) {
+          throw new SandboxWorkspaceMutationFencedError(
+            "process_fenced",
+            "Retained process already carries different provider proof"
+          );
+        }
+        return existing;
+      }
+      const [updated] = await tx.update(sandboxRetainedProcesses).set({
+        reconcileProofOutcome: input.proof.outcome,
+        reconcileProofExitCode: input.proof.exitCode,
+        reconcileProofReason: input.proof.reason,
+        reconcileProofObservedAt: /* @__PURE__ */ new Date(),
+        lastReconcileOutcome: `proof_${input.proof.outcome}`
+      }).where(
+        and6(
+          eq6(sandboxRetainedProcesses.id, process.id),
+          eq6(sandboxRetainedProcesses.state, "active"),
+          eq6(sandboxRetainedProcesses.reconcileClaimId, input.claimId)
+        )
+      ).returning();
+      if (!updated) {
+        throw new SandboxWorkspaceMutationFencedError(
+          "process_fenced",
+          "Retained process changed while checkpointing provider proof"
+        );
+      }
+      return mapRetainedProcess(updated);
+    })
+  );
+}
+async function deferRetainedProcessReconciliation(db, input) {
+  const outcome = normalizeRetainedProcessReconciliationOutcome(input.outcome);
+  if (!Number.isSafeInteger(input.retryAfterMs) || input.retryAfterMs < 0 || input.retryAfterMs > 864e5) {
+    throw new SandboxWorkspaceMutationFencedError(
+      "process_fenced",
+      "Retained process reconciliation retry delay is invalid"
+    );
+  }
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await scopedDb.transaction(async (txRaw) => {
+      const tx = txRaw;
+      const [process] = await tx.select().from(sandboxRetainedProcesses).where(
+        and6(
+          eq6(sandboxRetainedProcesses.accountId, input.accountId),
+          eq6(sandboxRetainedProcesses.workspaceId, input.workspaceId),
+          eq6(sandboxRetainedProcesses.sessionId, input.sessionId),
+          eq6(sandboxRetainedProcesses.id, input.processId)
+        )
+      ).for("update").limit(1);
+      if (!process || !retainedProcessMatchesSettlementIdentity(process, input.expected)) {
+        throw new SandboxWorkspaceMutationFencedError(
+          "process_fenced",
+          "Retained process reconciliation did not match the copied durable identity"
+        );
+      }
+      if (process.state !== "active") return false;
+      if (process.reconcileClaimId !== input.claimId) {
+        throw new SandboxWorkspaceMutationFencedError(
+          "process_fenced",
+          "Retained process reconciliation claim was lost or superseded"
+        );
+      }
+      const [updated] = await tx.update(sandboxRetainedProcesses).set({
+        reconcileAfter: new Date(Date.now() + input.retryAfterMs),
+        reconcileClaimId: null,
+        reconcileClaimedAt: null,
+        lastReconcileOutcome: outcome
+      }).where(
+        and6(
+          eq6(sandboxRetainedProcesses.id, process.id),
+          eq6(sandboxRetainedProcesses.state, "active"),
+          eq6(sandboxRetainedProcesses.reconcileClaimId, input.claimId)
+        )
+      ).returning({ id: sandboxRetainedProcesses.id });
+      return Boolean(updated);
+    })
+  );
+}
+async function countActiveRetainedProcessesByOwnerState(db) {
+  const rows = await rawRows(
+    db,
+    sql4`
+      select owner_state, active_count, terminal_owner_count
+      from opengeni_private.count_active_retained_processes_by_owner_state()
+    `
+  );
+  return rows.map((row) => ({
+    ownerState: row.owner_state,
+    activeCount: Number(row.active_count),
+    terminalOwnerCount: Number(row.terminal_owner_count)
+  }));
+}
+async function countExpiredDrainingSandboxLeases(db) {
+  const rows = await rawRows(
+    db,
+    sql4`
+      select backend, age_bucket, count
+      from opengeni_private.count_expired_draining_sandbox_leases()
+    `
+  );
+  return rows.map((row) => ({
+    backend: row.backend,
+    ageBucket: row.age_bucket,
+    count: Number(row.count)
+  }));
+}
 async function settleRetainedProcess(db, input) {
   const reason = normalizeRetainedProcessSettlementReason(input.reason);
   const exitCode = input.outcome === "exited" ? input.exitCode ?? null : null;
@@ -17946,6 +18722,12 @@ async function settleRetainedProcess(db, input) {
           "Retained process settlement did not match a durable process"
         );
       }
+      if (!retainedProcessMatchesSettlementIdentity(process, input.expected)) {
+        throw new SandboxWorkspaceMutationFencedError(
+          "process_fenced",
+          "Retained process settlement did not match the copied durable identity"
+        );
+      }
       if (process.state !== "active") {
         if (process.state !== input.outcome || process.exitCode !== exitCode || process.settlementReason !== reason) {
           throw new SandboxWorkspaceMutationFencedError(
@@ -17961,6 +18743,19 @@ async function settleRetainedProcess(db, input) {
         );
         return { settled: false, process: mapRetainedProcess(process) };
       }
+      if (input.reconciliationClaimId !== void 0 && process.reconcileClaimId !== input.reconciliationClaimId) {
+        throw new SandboxWorkspaceMutationFencedError(
+          "process_fenced",
+          "Retained process settlement reconciliation claim was lost or superseded"
+        );
+      }
+      const durableProof = retainedProcessReconciliationProof(mapRetainedProcess(process));
+      if (durableProof && (durableProof.outcome !== input.outcome || durableProof.exitCode !== exitCode || durableProof.reason !== reason)) {
+        throw new SandboxWorkspaceMutationFencedError(
+          "process_fenced",
+          "Retained process settlement conflicts with checkpointed provider proof"
+        );
+      }
       const admissions = await tx.execute(sql4`
           select * from sandbox_workspace_mutation_admissions
           where id = ${process.parentAdmissionId}
@@ -17968,6 +18763,13 @@ async function settleRetainedProcess(db, input) {
             and workspace_id = ${input.workspaceId}
             and session_id = ${input.sessionId}
             and lease_id = ${process.leaseId}
+            and sandbox_group_id = ${process.sandboxGroupId}
+            and lease_epoch = ${process.leaseEpoch}
+            and provider_backend = ${process.providerBackend}
+            and provider_instance_id = ${process.providerInstanceId}
+            and route_kind = ${process.routeKind}
+            and route_target_id is not distinct from ${process.routeTargetId}
+            and route_epoch = ${process.routeEpoch}
             and provider_outcome = 'retained'
             and settled_at is null
           for update
@@ -17978,6 +18780,23 @@ async function settleRetainedProcess(db, input) {
           "Retained process parent admission is not open"
         );
       }
+      const leases = await tx.execute(sql4`
+          select * from sandbox_leases
+          where id = ${process.leaseId}
+            and account_id = ${input.accountId}
+            and workspace_id = ${input.workspaceId}
+            and sandbox_group_id = ${process.sandboxGroupId}
+            and lease_epoch = ${process.leaseEpoch}
+            and backend = ${process.providerBackend}
+            and instance_id = ${process.providerInstanceId}
+          for update
+        `);
+      if (!leases[0]) {
+        throw new SandboxWorkspaceMutationFencedError(
+          "lease_fenced",
+          "Retained process settlement cannot mutate a successor lease identity"
+        );
+      }
       await tx.update(sandboxPtySessions).set({ status: "closed", closedAt: /* @__PURE__ */ new Date() }).where(
         and6(
           eq6(sandboxPtySessions.retainedProcessId, process.id),
@@ -17988,7 +18807,10 @@ async function settleRetainedProcess(db, input) {
         state: input.outcome,
         exitCode,
         settlementReason: reason,
-        settledAt: /* @__PURE__ */ new Date()
+        settledAt: /* @__PURE__ */ new Date(),
+        reconcileClaimId: null,
+        reconcileClaimedAt: null,
+        lastReconcileOutcome: input.reconciliationClaimId === void 0 ? `owner_settled_${input.outcome}` : `reconciled_${input.outcome}`
       }).where(
         and6(
           eq6(sandboxRetainedProcesses.id, process.id),
@@ -18011,6 +18833,8 @@ async function settleRetainedProcess(db, input) {
       await tx.execute(sql4`
           delete from sandbox_lease_holders
           where lease_id = ${process.leaseId}
+            and account_id = ${input.accountId}
+            and workspace_id = ${input.workspaceId}
             and kind = 'process' and holder_id = ${process.holderId}
         `);
       const [counts] = await tx.execute(sql4`
@@ -18031,6 +18855,10 @@ async function settleRetainedProcess(db, input) {
                         else expires_at end,` : sql4``}
             updated_at = now()
           where id = ${process.leaseId}
+            and sandbox_group_id = ${process.sandboxGroupId}
+            and lease_epoch = ${process.leaseEpoch}
+            and backend = ${process.providerBackend}
+            and instance_id = ${process.providerInstanceId}
         `);
       return { settled: true, process: mapRetainedProcess(updated) };
     })
@@ -20840,13 +21668,14 @@ async function initializeSessionStartAtomically(db, input) {
         }).returning();
         if (!goal) throw new Error("Failed to create initial session goal");
       }
-      let [userEvent] = await tx.select().from(sessionEvents).where(
+      const existingUserEvents = await tx.select().from(sessionEvents).where(
         and6(
           eq6(sessionEvents.workspaceId, input.workspaceId),
           eq6(sessionEvents.sessionId, session.id),
           eq6(sessionEvents.type, "user.message")
         )
       ).orderBy(asc3(sessionEvents.sequence)).limit(1);
+      let userEvent = existingUserEvents[0];
       let sequence = session.lastSequence;
       const insertedEvents = [];
       const runnable = effectiveControl.state === "active";
@@ -21013,7 +21842,7 @@ async function initializeSessionStartAtomically(db, input) {
           tx,
           input.consumeNewSessionDraft.subjectId
         );
-        await consumeNewSessionDraftInTransaction(tx, {
+        await seedNewSessionDraftInTransaction(tx, {
           workspaceId: input.workspaceId,
           subjectId: input.consumeNewSessionDraft.subjectId,
           expectedRevision: input.consumeNewSessionDraft.expectedRevision
@@ -22324,7 +23153,7 @@ async function peekSessionWork(db, workspaceId, sessionId) {
       workspaceId,
       sessionId
     );
-    if (latestInterruption && latestInterruption.quiescedAt === null && ["settled", "rejected_stale"].includes(latestInterruption.interruptionState)) {
+    if (latestInterruption && latestInterruption.quiescedAt === null && latestInterruption.interruptionState === "settled") {
       return {
         kind: "cancellation-wait",
         attemptId: latestInterruption.attemptId
@@ -24992,17 +25821,28 @@ async function appendSessionEventsAndUpdateSession(db, workspaceId, sessionId, i
     })
   );
 }
-async function appendSessionEventsWithLockedSessionUpdate(db, workspaceId, sessionId, build) {
+async function appendSessionEventsWithLockedSessionUpdate(db, workspaceId, sessionId, build, options = {}) {
   return await withWorkspaceRls(
     db,
     workspaceId,
     async (scopedDb) => await scopedDb.transaction(async (tx) => {
-      const locks = await lockSessionEventWriteRows(tx, {
+      const firstLocks = await lockSessionEventWriteRows(tx, {
         workspaceId,
         controlLock: "share",
         sessionIds: [sessionId]
       });
-      const sessionRow = locks.sessions[0];
+      const firstSessionRow = firstLocks.sessions.find((row) => row.id === sessionId);
+      if (!firstSessionRow) {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+      const lockSessionIds = options.lockParentSession ? [sessionId, firstSessionRow.parentSessionId].filter((id) => Boolean(id)) : [sessionId];
+      const locks = lockSessionIds.length === 1 ? firstLocks : await lockSessionEventWriteRows(tx, {
+        workspaceId,
+        controlLock: "already_locked",
+        workspaceLock: "already_locked",
+        sessionIds: lockSessionIds
+      });
+      const sessionRow = locks.sessions.find((row) => row.id === sessionId);
       if (!sessionRow) {
         throw new Error(`Session not found: ${sessionId}`);
       }
@@ -25034,6 +25874,16 @@ async function appendSessionEventsWithLockedSessionUpdate(db, workspaceId, sessi
             )
           ).orderBy(asc3(sessionTurns.position), asc3(sessionTurns.createdAt));
           return rows.map(mapSessionTurn);
+        },
+        getLockedSession: async (lockedSessionId) => {
+          const row = locks.sessions.find((candidate) => candidate.id === lockedSessionId);
+          return row ? await mapSessionWithControl(
+            tx,
+            row,
+            [],
+            void 0,
+            locks.control ?? void 0
+          ) : null;
         }
       });
       if (built.events.length === 0) {
@@ -25067,18 +25917,32 @@ async function appendSessionEventsWithLockedSessionUpdate(db, workspaceId, sessi
       const inserted = await tx.insert(sessionEvents).values(values).returning();
       const update = built.update ?? {};
       const advancesActivity = sessionMutationAdvancesActivity(update) || sessionEventTypesAdvanceActivity(values);
-      await tx.update(sessions).set({
+      const updated = await tx.update(sessions).set({
         lastSequence: sequence,
         ...update.resources !== void 0 ? { resources: update.resources } : {},
         ...update.tools !== void 0 ? { tools: update.tools } : {},
+        ...update.toolPolicy !== void 0 ? { toolPolicy: update.toolPolicy } : {},
+        ...update.toolPolicyVersion !== void 0 ? { toolPolicyVersion: update.toolPolicyVersion } : {},
         ...update.model !== void 0 ? { model: update.model } : {},
         ...update.metadata !== void 0 ? { metadata: update.metadata } : {},
         ...update.status !== void 0 ? { status: update.status } : {},
         ...update.activeTurnId !== void 0 ? { activeTurnId: update.activeTurnId } : {},
         ...advancesActivity ? { updatedAt: now } : {}
       }).where(
-        and6(eq6(sessions.workspaceId, workspaceId), eq6(sessions.id, sessionId))
-      );
+        and6(
+          eq6(sessions.workspaceId, workspaceId),
+          eq6(sessions.id, sessionId),
+          ...update.expectedToolPolicyVersion !== void 0 ? [eq6(sessions.toolPolicyVersion, update.expectedToolPolicyVersion)] : []
+        )
+      ).returning({ id: sessions.id });
+      if (updated.length === 0) {
+        const [current] = await tx.select({ toolPolicyVersion: sessions.toolPolicyVersion }).from(sessions).where(
+          and6(eq6(sessions.workspaceId, workspaceId), eq6(sessions.id, sessionId))
+        ).limit(1);
+        throw new SessionToolPolicyVersionConflictError(
+          Number(current?.toolPolicyVersion ?? update.expectedToolPolicyVersion ?? 1)
+        );
+      }
       return inserted.map(mapEvent2);
     })
   );
@@ -25119,6 +25983,7 @@ function mapSession(row, effectiveControl, mcpServers = [], pin = mapSessionPin(
       mode: "legacy",
       inheritedFromSessionId: null
     },
+    toolPolicyVersion: Number(row.toolPolicyVersion ?? 1),
     metadata: row.metadata,
     createdBy: initiatorFromStorage(
       row.createdByKind,
@@ -25598,10 +26463,17 @@ function mapGitHubInstallation(row) {
     accountId: row.accountId,
     workspaceId: row.workspaceId,
     installationId: row.installationId,
+    githubAccountId: row.githubAccountId,
     accountLogin: row.accountLogin,
     accountType: row.accountType,
     repositoryScope: row.repositoryScope,
     linkedBySubjectId: row.linkedBySubjectId,
+    githubActorId: row.githubActorId,
+    githubActorLogin: row.githubActorLogin,
+    authorityKind: row.authorityKind,
+    authorityCheckedAt: row.authorityCheckedAt?.toISOString() ?? null,
+    authorityExpiresAt: row.authorityExpiresAt?.toISOString() ?? null,
+    authorityNonce: row.authorityNonce,
     createdAt: row.createdAt.toISOString(),
     updatedAt: row.updatedAt.toISOString()
   };
@@ -25758,6 +26630,8 @@ export {
   CODEX_RESET_REDEMPTION_OUTCOMES,
   CODEX_ROTATION_STRATEGIES,
   ConnectionRefreshHttpError,
+  FORCE_RLS_TABLES,
+  GitHubInstallationAuthorityCommitError,
   HostExportPayloadError,
   HostMcpCredentialBindingError,
   HostMcpCredentialScopeError,
@@ -25779,12 +26653,20 @@ export {
   MEMORY_SEARCH_TOOL_DESCRIPTION,
   MEMORY_TEXT_MAX_CHARS,
   MEMORY_VISIBLE_RECORD_CAP,
+  NON_RLS_RUNTIME_TABLES,
   NewSessionDraftAccessError,
   NewSessionDraftConflictError,
+  PROTECTED_NO_DIRECT_DML_TABLES,
   QueueCommandConflictError,
+  RUNTIME_DML_TABLES,
+  RUNTIME_FULL_DML_TABLES,
+  RUNTIME_READ_INSERT_TABLES,
+  RUNTIME_READ_ONLY_TABLES,
+  RUNTIME_TABLE_PRIVILEGES,
   RigActiveVersionChangedError,
   RigChangeAlreadyVerifyingError,
   RigChangeTransitionError,
+  RuntimeDatabasePostureError,
   SESSION_ANCESTRY_LIMIT,
   SESSION_DISCOVERY_CONTROL_TARGET_LIMIT,
   SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS,
@@ -25796,6 +26678,7 @@ export {
   SandboxImageConflictError,
   SandboxLeaseRecoveryBlockedError,
   SandboxLeaseSupersededError,
+  SandboxRetainedProcessPromotionFencedError,
   SandboxRigConflictError,
   SandboxWorkspaceMutationFencedError,
   SanitizedDatabasePersistenceCause,
@@ -25812,6 +26695,7 @@ export {
   SessionPinAccessError,
   SessionPinVersionConflictError,
   SessionSpawnDeniedDbError,
+  SessionToolPolicyVersionConflictError,
   WORKSPACE_MEMORY_BLOCK_EMPTY,
   WORKSPACE_MEMORY_BLOCK_HEADER_POPULATED,
   WORKSPACE_MEMORY_BLOCK_TOKEN_BUDGET,
@@ -25847,9 +26731,11 @@ export {
   areGitHubRepositoriesAllowedForWorkspace,
   armCodexCapacityWait,
   assertAgentCommandAuthorityInTransaction,
+  assertRuntimeDatabasePosture,
   autoResumeSessionBranchInTransaction,
   beginRigChangeVerificationAttempt,
   beginSandboxRematerialization,
+  bindAuthorizedGitHubInstallationRepositories,
   bindGitHubInstallationRepositories,
   bootstrapWorkspace,
   buildChildCompletionDigest,
@@ -25864,6 +26750,7 @@ export {
   claimPendingSessionSystemUpdateOutbox,
   claimPendingSessionWorkflowWakes,
   claimSessionWorkForAttempt,
+  claimTerminalRetainedProcesses,
   clearDurablePendingSessionToolCalls,
   clearEnrollmentWentOffline,
   clearPendingSessionToolspaceCall,
@@ -25885,11 +26772,13 @@ export {
   consumeNewSessionDraftInTransaction,
   correctWorkspaceMemory,
   countActiveApiKeysForWorkspace,
+  countActiveRetainedProcessesByOwnerState,
   countActiveSessionHistoryItems,
   countActiveSessionsForWorkspace,
   countActiveSessionsUsingEnvironment,
   countActiveSessionsUsingVariableSet,
   countConsecutiveReactiveRotations,
+  countExpiredDrainingSandboxLeases,
   countQueuedTurns,
   countRigs,
   countSandboxLeasesByLiveness,
@@ -25933,6 +26822,7 @@ export {
   decryptEnvironmentValue,
   decryptEnvironmentValue as decryptVariableSetValue,
   decryptedCapabilityHeaders,
+  deferRetainedProcessReconciliation,
   deleteGitHubInstallationBinding,
   deleteRecording,
   deleteRig,
@@ -25965,6 +26855,7 @@ export {
   ensureManagedAccessForUser,
   estimateMemoryTokens,
   evaluateGoalContinuation,
+  evaluateRuntimeDatabasePosture,
   evaluateSessionControl,
   evaluateSessionControls,
   evaluateSessionDiscoveryControls,
@@ -26057,6 +26948,7 @@ export {
   getWorkspaceModelPolicy,
   getWorkspacePack,
   grantWorkspaceAccess,
+  hasAuditableGitHubInstallationAuthority,
   hasCreditLedgerEntry,
   hashMemoryText,
   heartbeatCodexCredentialLease,
@@ -26069,6 +26961,7 @@ export {
   insertPtySession,
   insertRecording,
   insertWorkspaceCapture,
+  inspectRuntimeDatabasePosture,
   installOrReadTurnExecutionPolicyForAttempt,
   interruptedToolCallResult,
   isCodexBilledModel2 as isCodexBilledModel,
@@ -26162,6 +27055,7 @@ export {
   mutateSessionControlInTransaction,
   mutateWorkspaceControlInTransaction,
   nestedPostgresSqlState,
+  newSessionDraftToolsProvided,
   nextSessionHistoryPosition,
   normalizeBearerScheme,
   normalizeMemoryText,
@@ -26174,6 +27068,7 @@ export {
   projectSessionForRelatedAccess,
   provisionRoles,
   pruneHostExportOutbox,
+  publicNewSessionDraftOptions,
   quarantineCodexCredentialForLease,
   reArmDrainingLease,
   readActiveSandbox,
@@ -26186,6 +27081,7 @@ export {
   reapStaleLeaseHolders,
   reapStaleLeaseHoldersGlobal,
   reconcileCodexCapacityWait,
+  reconcileColdLostLeaseInstanceBlockers,
   recordAuditEvent,
   recordCodexAccountConnectors,
   recordCodexAccountUsage,
@@ -26196,6 +27092,7 @@ export {
   recordLeaseDataPlaneUrl,
   recordLeaseTerminalDataPlaneUrl,
   recordPendingSessionToolCallResult,
+  recordRetainedProcessReconciliationProof,
   recordSessionActiveCodexCredential,
   recordSkippedContextCompaction,
   recordStreamAcknowledgment,
@@ -26230,6 +27127,8 @@ export {
   resolveWorkspaceMemoryBlock,
   resumeHostExportConsumer,
   retainWorkspaceMutationProcess,
+  retainedProcessReconciliationProof,
+  retainedProcessSettlementIdentity,
   retireHostExportConsumer,
   revokeApiKey,
   revokeConnection,
@@ -26241,6 +27140,7 @@ export {
   rotateWorkspaceArchives,
   runIdempotentPersistenceTransaction,
   runMigrations,
+  runtimeDatabaseReadyCheck,
   safeDatabaseErrorFacts,
   sanitizeEventPayload,
   sanitizeEventString,
@@ -26251,6 +27151,7 @@ export {
   saveRunState,
   saveWorkspaceMemory,
   searchWorkspaceMemories,
+  seedNewSessionDraftInTransaction,
   sendAgentMessageInTransaction,
   serializeEffectiveSessionControl,
   sessionAuthorizationScopeFilter,