@opengeni/db 4.2.2 → 4.3.0-canary.0

package/dist/{chunk-6GAPAYZR.js → chunk-7JPLGBSA.js}

@@ -1,11 +1,16 @@
 import {
   cancelUnacceptedVideoGenerationsForToolCallsInTransaction
-} from "./chunk-MGVOYVPS.js";
+} from "./chunk-NCSPNCQK.js";
 import {
   nestedPostgresSqlState,
+  rawRows,
+  setSubjectRlsContext,
+  withAccountRls,
   withRlsContext,
-  withSessionActivityRlsContext
-} from "./chunk-B2KR3TEM.js";
+  withSessionActivityRlsContext,
+  withWorkspaceRls,
+  withWorkspaceSubjectRls
+} from "./chunk-SGJDIF2D.js";
 import {
   LOSSLESS_CONTENT_CODEC_VERSION,
   auditEvents,
@@ -32,22 +37,460 @@ import {
   workspaceControlEvents,
   workspaceInferenceControls,
   workspaces
-} from "./chunk-S4Y42VSX.js";
+} from "./chunk-Y5XFVJJM.js";
 
 // src/session-background-commands.ts
 import { SessionCommandFailure } from "@opengeni/contracts";
 import { isDeepStrictEqual } from "util";
-import { and as and4, asc as asc2, desc as desc2, eq as eq4, getTableColumns, gte, inArray as inArray3, sql as sql4 } from "drizzle-orm";
+import { and as and4, asc as asc2, desc as desc2, eq as eq4, getTableColumns, gte, inArray as inArray3, sql as sql7 } from "drizzle-orm";
 
 // src/session-control.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import {
   boundWorkspaceControlEvent,
   childPausedClassification,
   McpPersonalConnectionDelegations,
   workspaceControlUtf8Bytes
 } from "@opengeni/contracts";
-import { and as and3, eq as eq3, inArray as inArray2, sql as sql3 } from "drizzle-orm";
+import { and as and3, eq as eq3, inArray as inArray2, sql as sql6 } from "drizzle-orm";
+
+// src/external-link-work.ts
+import { sql as sql3 } from "drizzle-orm";
+import { stableJson } from "@opengeni/contracts";
+import { ExternalLinkWorkSnapshot } from "@opengeni/contracts/external-identities";
+
+// src/external-identities.ts
+import { sql } from "drizzle-orm";
+import { Permission } from "@opengeni/contracts";
+import {
+  ExternalIdentity,
+  ExternalIdentityReference
+} from "@opengeni/contracts/external-identities";
+async function lockActiveExternalOrganizationKey(tx, accountId, keyId) {
+  return withAccountRls(tx, accountId, async (scoped) => {
+    const [row] = await rawRows(
+      scoped,
+      sql`select permissions from api_keys
+      where account_id = ${accountId}::uuid and id = ${keyId}::uuid
+        and workspace_id is null and credential_kind = 'organization'
+        and revoked_at is null and (expires_at is null or expires_at > clock_timestamp()) for share`
+    );
+    return row ? Permission.array().parse(row.permissions) : null;
+  });
+}
+async function lockExternalWorkspaceMembershipLifecycle(tx, accountId) {
+  await tx.execute(
+    sql`select pg_advisory_xact_lock(hashtextextended(${`organization-membership:${accountId}`}, 0))`
+  );
+}
+async function ensureExternalIdentity(db, input) {
+  const accountId = input.accountId;
+  const reference = ExternalIdentityReference.parse({
+    externalId: input.externalId,
+    source: input.source
+  });
+  return withAccountRls(db, accountId, async (tx) => {
+    const [row] = await rawRows(
+      tx,
+      sql`select ensure_external_identity(
+      ${accountId}::uuid, ${reference.source}, ${reference.externalId}) as result`
+    );
+    const result = ExternalIdentity.parse(row?.result);
+    if (result.accountId !== accountId || result.source !== reference.source || result.externalId !== reference.externalId) {
+      throw new Error("External identity scope mismatch");
+    }
+    return result;
+  });
+}
+
+// src/external-identity-links.ts
+import { createHash, randomBytes, randomUUID } from "crypto";
+import { sql as sql2 } from "drizzle-orm";
+import {
+  BeginExternalIdentityLinkRequest,
+  BeginExternalIdentityLinkResponse,
+  ConfirmExternalIdentityLinkRequest,
+  ExternalIdentityLink,
+  ExternalIdentityLinkPage,
+  ExternalIdentityReference as ExternalIdentityReference2
+} from "@opengeni/contracts/external-identities";
+var ExternalIdentityLinkConflictError = class extends Error {
+  name = "ExternalIdentityLinkConflictError";
+  constructor() {
+    super("Identity link changed or is unavailable");
+  }
+};
+var digest = (value) => createHash("sha256").update(value).digest("hex");
+var iso = (value) => new Date(value).toISOString();
+function project(row) {
+  const expiry = row.status === "pending" ? row.confirm_before : row.expires_at;
+  return ExternalIdentityLink.parse({
+    id: row.id,
+    accountId: row.account_id,
+    externalIdentityId: row.external_identity_id,
+    nativeSubjectId: row.native_subject_id,
+    status: row.status !== "revoked" && expiry !== null && new Date(expiry).getTime() <= Date.now() ? "expired" : row.status,
+    revision: Number(row.revision),
+    permissions: row.permissions,
+    expiresAt: row.expires_at === null ? null : iso(row.expires_at)
+  });
+}
+async function activeMembership(tx, accountId, subjectId) {
+  const [prior] = await rawRows(
+    tx,
+    sql2`select coalesce(current_setting('opengeni.subject_id', true), '') as subject`
+  );
+  let succeeded = false;
+  let row;
+  try {
+    await setSubjectRlsContext(tx, subjectId);
+    [row] = await rawRows(
+      tx,
+      sql2`select value as membership from jsonb_array_elements(list_self_organization_memberships(${subjectId}))
+        where value ->> 'organizationId' = ${accountId} and value ->> 'status' = 'active'`
+    );
+    succeeded = true;
+  } finally {
+    const restore = tx.execute(
+      sql2`select set_config('opengeni.subject_id', ${prior?.subject ?? ""}, true)`
+    );
+    if (succeeded) await restore;
+    else await restore.catch(() => void 0);
+  }
+  if (!row) throw new ExternalIdentityLinkConflictError();
+  return row.membership;
+}
+async function beginExternalIdentityLink(db, identity, raw) {
+  const input = BeginExternalIdentityLinkRequest.parse(raw);
+  return withAccountRls(db, identity.accountId, async (tx) => {
+    await lockExternalWorkspaceMembershipLifecycle(tx, identity.accountId);
+    const membership = await activeMembership(tx, identity.accountId, identity.subjectId);
+    if (membership.id !== identity.organizationMembershipId || Number(membership.authorizationRevision) !== identity.authorizationRevision || identity.status !== "active")
+      throw new ExternalIdentityLinkConflictError();
+    const [quota] = await rawRows(
+      tx,
+      sql2`select count(*) as count
+      from external_identity_links where account_id = ${identity.accountId}::uuid
+        and external_identity_id = ${identity.id}::uuid and status = 'pending'
+        and confirm_before > clock_timestamp()`
+    );
+    if (Number(quota?.count ?? 0) >= 32) throw new ExternalIdentityLinkConflictError();
+    const challenge = randomBytes(32).toString("base64url");
+    const permissions = [...new Set(input.permissions)].sort();
+    const [row] = await rawRows(
+      tx,
+      sql2`insert into external_identity_links
+      (id, account_id, external_identity_id, external_subject_id, external_authorization_revision,
+        permissions, challenge_digest, confirm_before, expires_at)
+      values (${randomUUID()}::uuid, ${identity.accountId}::uuid, ${identity.id}::uuid,
+        ${identity.subjectId}, ${identity.authorizationRevision}, ${JSON.stringify(permissions)}::jsonb,
+        ${digest(challenge)}, clock_timestamp() + interval '10 minutes', ${input.expiresAt}::timestamptz)
+      returning *`
+    );
+    if (!row) throw new Error("Identity link insert returned no row");
+    return BeginExternalIdentityLinkResponse.parse({
+      link: project(row),
+      challenge,
+      confirmBefore: iso(row.confirm_before)
+    });
+  });
+}
+async function getExternalIdentityLink(db, input) {
+  return withAccountRls(db, input.accountId, async (tx) => {
+    const [row] = await rawRows(
+      tx,
+      sql2`select * from external_identity_links
+      where account_id = ${input.accountId}::uuid and id = ${input.linkId}::uuid
+      and (external_subject_id = ${input.subjectId} or native_subject_id = ${input.subjectId})`
+    );
+    return row ? project(row) : null;
+  });
+}
+async function listExternalIdentityLinks(db, input) {
+  return withAccountRls(db, input.accountId, async (tx) => {
+    const rows = await rawRows(
+      tx,
+      sql2`
+      select * from external_identity_links
+      where account_id = ${input.accountId}::uuid
+        and (external_subject_id = ${input.subjectId} or native_subject_id = ${input.subjectId})
+        ${input.cursor ? sql2`and id > ${input.cursor}::uuid` : sql2``}
+      order by id limit 51`
+    );
+    const links = rows.slice(0, 50).map(project);
+    await setSubjectRlsContext(tx, input.subjectId);
+    const [labels] = links.length ? await rawRows(
+      tx,
+      sql2`select get_external_identity_link_inventory_references(${input.accountId}::uuid, ARRAY[${sql2.join(
+        links.map((link) => sql2`${link.id}::uuid`),
+        sql2`, `
+      )}]) as references`
+    ) : [];
+    return ExternalIdentityLinkPage.parse({
+      links: links.map((link) => ({
+        ...link,
+        ...labels?.references[link.id] ? { externalIdentity: ExternalIdentityReference2.parse(labels.references[link.id]) } : {}
+      })),
+      nextCursor: rows.length > 50 ? links.at(-1).id : null
+    });
+  });
+}
+async function previewExternalIdentityLink(db, input) {
+  return withAccountRls(db, input.accountId, async (tx) => {
+    const [row] = await rawRows(
+      tx,
+      sql2`select * from external_identity_links
+      where account_id = ${input.accountId}::uuid and id = ${input.linkId}::uuid
+        and challenge_digest = ${digest(input.challenge)} and status = 'pending'
+        and confirm_before > clock_timestamp()
+        and (expires_at is null or expires_at > clock_timestamp())`
+    );
+    if (!row) return null;
+    const [identity] = await rawRows(
+      tx,
+      sql2`select get_external_identity_link_reference(${input.accountId}::uuid, ${input.linkId}::uuid, ${digest(input.challenge)}) as reference`
+    );
+    return identity?.reference ? {
+      link: project(row),
+      externalIdentity: ExternalIdentityReference2.parse(identity.reference)
+    } : null;
+  });
+}
+async function confirmExternalIdentityLink(db, input) {
+  const request = ConfirmExternalIdentityLinkRequest.parse(input.request);
+  if (!/^user:[^\r\n]+$/.test(input.nativeSubjectId)) throw new ExternalIdentityLinkConflictError();
+  return withAccountRls(db, input.accountId, async (tx) => {
+    await lockExternalWorkspaceMembershipLifecycle(tx, input.accountId);
+    const [row] = await rawRows(
+      tx,
+      sql2`select * from external_identity_links
+      where account_id = ${input.accountId}::uuid and id = ${input.linkId}::uuid
+        and challenge_digest = ${digest(request.challenge)} for update`
+    );
+    if (!row) throw new ExternalIdentityLinkConflictError();
+    const external = await activeMembership(tx, input.accountId, row.external_subject_id);
+    const native = await activeMembership(tx, input.accountId, input.nativeSubjectId);
+    if (Number(external.authorizationRevision) !== Number(row.external_authorization_revision))
+      throw new ExternalIdentityLinkConflictError();
+    const permissions = [...new Set(request.permissions)].sort();
+    if (row.status === "active" && Number(row.revision) === request.expectedRevision + 1 && row.native_subject_id === input.nativeSubjectId && row.native_membership_id === native.id && Number(row.native_authorization_revision) === Number(native.authorizationRevision) && JSON.stringify(row.permissions) === JSON.stringify(permissions) && project(row).status === "active")
+      return project(row);
+    if (row.status !== "pending" || Number(row.revision) !== request.expectedRevision || project(row).status !== "pending" || permissions.some((permission) => !row.permissions.includes(permission)))
+      throw new ExternalIdentityLinkConflictError();
+    const [confirmed] = await rawRows(
+      tx,
+      sql2`update external_identity_links set
+      status = 'active', revision = revision + 1, native_subject_id = ${input.nativeSubjectId},
+      native_membership_id = ${native.id}::uuid, native_authorization_revision = ${Number(native.authorizationRevision)},
+      permissions = ${JSON.stringify(permissions)}::jsonb, confirmed_at = clock_timestamp()
+      where id = ${row.id}::uuid returning *`
+    );
+    if (!confirmed) throw new ExternalIdentityLinkConflictError();
+    return project(confirmed);
+  });
+}
+async function revokeExternalIdentityLink(db, input) {
+  return withAccountRls(db, input.accountId, async (tx) => {
+    await lockExternalWorkspaceMembershipLifecycle(tx, input.accountId);
+    const [row] = await rawRows(
+      tx,
+      sql2`select * from external_identity_links
+      where account_id = ${input.accountId}::uuid and id = ${input.linkId}::uuid
+      and (external_subject_id = ${input.subjectId} or native_subject_id = ${input.subjectId}) for update`
+    );
+    if (!row) throw new ExternalIdentityLinkConflictError();
+    if (row.status === "revoked" && Number(row.revision) === input.expectedRevision + 1)
+      return project(row);
+    if (row.status === "revoked" || Number(row.revision) !== input.expectedRevision)
+      throw new ExternalIdentityLinkConflictError();
+    const [revoked] = await rawRows(
+      tx,
+      sql2`update external_identity_links
+      set status = 'revoked', revision = revision + 1, revoked_at = clock_timestamp()
+      where id = ${row.id}::uuid returning *`
+    );
+    if (!revoked) throw new ExternalIdentityLinkConflictError();
+    return project(revoked);
+  });
+}
+async function resolveExternalIdentityLink(db, input) {
+  return withAccountRls(db, input.identity.accountId, async (tx) => {
+    await lockExternalWorkspaceMembershipLifecycle(tx, input.identity.accountId);
+    const [row] = await rawRows(
+      tx,
+      sql2`select * from external_identity_links
+      where id = ${input.linkId}::uuid and account_id = ${input.identity.accountId}::uuid
+        and external_identity_id = ${input.identity.id}::uuid for share`
+    );
+    if (!row || row.status !== "active" || !row.native_subject_id || Number(row.revision) !== input.expectedRevision || Number(row.external_authorization_revision) !== input.identity.authorizationRevision || input.identity.status !== "active" || project(row).status !== "active")
+      return null;
+    try {
+      const external = await activeMembership(
+        tx,
+        input.identity.accountId,
+        input.identity.subjectId
+      );
+      const native = await activeMembership(tx, input.identity.accountId, row.native_subject_id);
+      if (external.id !== input.identity.organizationMembershipId || Number(external.authorizationRevision) !== input.identity.authorizationRevision || native.id !== row.native_membership_id || Number(native.authorizationRevision) !== Number(row.native_authorization_revision))
+        return null;
+      return { link: project(row), personalWorkspaceId: native.personalWorkspaceId };
+    } catch (error) {
+      if (error instanceof ExternalIdentityLinkConflictError) return null;
+      throw error;
+    }
+  });
+}
+
+// src/external-link-work.ts
+async function externalLinkWorkSnapshotIsLive(db, raw) {
+  const snapshot = ExternalLinkWorkSnapshot.parse(raw);
+  try {
+    const identity = await ensureExternalIdentity(db, {
+      accountId: snapshot.actor.accountId,
+      ...snapshot.identity
+    });
+    if (identity.id !== snapshot.actor.externalIdentityId || identity.subjectId !== snapshot.actor.externalSubjectId || identity.authorizationRevision !== snapshot.actor.externalAuthorizationRevision)
+      return false;
+    const resolved = await resolveExternalIdentityLink(db, {
+      identity,
+      linkId: snapshot.actor.linkId,
+      expectedRevision: snapshot.actor.linkRevision
+    });
+    return resolved !== null && resolved.link.nativeSubjectId === snapshot.actor.effectiveSubjectId && snapshot.permissions.every(
+      (permission) => resolved.link.permissions.includes(permission) || permission !== "secrets:read" && resolved.link.permissions.includes("workspace:admin")
+    );
+  } catch (error) {
+    if (nestedPostgresSqlState(error) === "42501") return false;
+    throw error;
+  }
+}
+async function getExternalLinkTurnSnapshot(db, scope, turnId) {
+  return withWorkspaceRls(db, scope.workspaceId, async (tx) => {
+    const [row] = await rawRows(
+      tx,
+      sql3`select canonical_snapshot
+      from external_link_turn_authorities where account_id = ${scope.accountId}::uuid
+        and workspace_id = ${scope.workspaceId}::uuid and turn_id = ${turnId}::uuid`
+    );
+    return row ? ExternalLinkWorkSnapshot.parse(row.canonical_snapshot) : null;
+  });
+}
+async function getExternalLinkTurnAuthorization(db, scope, turnId) {
+  const snapshot = await getExternalLinkTurnSnapshot(db, scope, turnId);
+  if (!snapshot) return null;
+  return {
+    authorized: await externalLinkWorkSnapshotIsLive(db, snapshot),
+    permissions: snapshot.permissions
+  };
+}
+async function captureExternalLinkTurnAuthority(db, input) {
+  const snapshot = ExternalLinkWorkSnapshot.parse(input.snapshot);
+  const source = input.source ?? { kind: "direct" };
+  if (snapshot.actor.accountId !== input.accountId)
+    throw new Error("Linked turn organization mismatch");
+  if (source.kind === "direct" && !await externalLinkWorkSnapshotIsLive(db, snapshot))
+    throw new Error("Linked turn authority revoked");
+  await withWorkspaceSubjectRls(
+    db,
+    input.workspaceId,
+    snapshot.actor.effectiveSubjectId,
+    async (tx) => {
+      const existing = await getExternalLinkTurnSnapshot(tx, input, input.turnId);
+      if (existing) {
+        if (stableJson(existing) !== stableJson(snapshot))
+          throw new Error("Linked turn replay changed authority");
+        return;
+      }
+      await tx.execute(sql3`insert into external_link_turn_authorities
+      (turn_id, account_id, workspace_id, session_id, link_id, link_revision, canonical_snapshot,
+        source_kind, source_turn_id, source_task_id, source_task_revision)
+      values (${input.turnId}::uuid, ${input.accountId}::uuid, ${input.workspaceId}::uuid, ${input.sessionId}::uuid,
+        ${snapshot.actor.linkId}::uuid, ${snapshot.actor.linkRevision}, ${JSON.stringify(snapshot)}::jsonb, ${source.kind},
+        ${source.kind === "causal" || source.kind === "child" ? source.turnId : null}::uuid,
+        ${source.kind === "scheduled" ? source.taskId : null}::uuid,
+        ${source.kind === "scheduled" ? source.taskRevision : null})`);
+    }
+  );
+}
+async function inheritExternalLinkTurnAuthority(db, input) {
+  const snapshot = await getExternalLinkTurnSnapshot(db, input, input.sourceTurnId);
+  if (!snapshot) return;
+  await captureExternalLinkTurnAuthority(db, {
+    ...input,
+    snapshot,
+    source: { kind: input.kind, turnId: input.sourceTurnId }
+  });
+}
+async function getExternalLinkTaskSnapshot(db, input) {
+  return withWorkspaceRls(db, input.workspaceId, async (tx) => {
+    const [row] = await rawRows(
+      tx,
+      sql3`select canonical_snapshot
+      from external_link_task_authorities where account_id = ${input.accountId}::uuid
+        and workspace_id = ${input.workspaceId}::uuid and task_id = ${input.taskId}::uuid and task_revision = ${input.taskRevision}`
+    );
+    return row ? ExternalLinkWorkSnapshot.parse(row.canonical_snapshot) : null;
+  });
+}
+async function captureExternalLinkTaskAuthority(db, task, raw) {
+  const snapshot = ExternalLinkWorkSnapshot.parse(raw);
+  if (task.accountId !== snapshot.actor.accountId)
+    throw new Error("Linked task organization mismatch");
+  await withWorkspaceSubjectRls(
+    db,
+    task.workspaceId,
+    snapshot.actor.effectiveSubjectId,
+    async (tx) => {
+      const existing = await getExternalLinkTaskSnapshot(tx, {
+        ...task,
+        taskId: task.id,
+        taskRevision: task.authorityRevision
+      });
+      if (existing) {
+        if (stableJson(existing) !== stableJson(snapshot))
+          throw new Error("Linked task replay changed authority");
+        return;
+      }
+      await tx.execute(sql3`insert into external_link_task_authorities
+      (task_id, task_revision, account_id, workspace_id, link_id, link_revision, canonical_snapshot)
+      values (${task.id}::uuid, ${task.authorityRevision}, ${task.accountId}::uuid, ${task.workspaceId}::uuid,
+        ${snapshot.actor.linkId}::uuid, ${snapshot.actor.linkRevision}, ${JSON.stringify(snapshot)}::jsonb)`);
+    }
+  );
+}
+async function cloneExternalLinkTaskAuthority(db, task, sourceRevision) {
+  if (task.authorityRevision === sourceRevision) return;
+  const snapshot = await getExternalLinkTaskSnapshot(db, {
+    ...task,
+    taskId: task.id,
+    taskRevision: sourceRevision
+  });
+  if (snapshot) await captureExternalLinkTaskAuthority(db, task, snapshot);
+}
+async function captureScheduledExternalLinkTurnAuthority(db, input) {
+  const run = await withWorkspaceRls(db, input.workspaceId, async (tx) => {
+    const [row] = await rawRows(
+      tx,
+      sql3`select task_id, task_authority_revision from scheduled_task_runs
+        where account_id = ${input.accountId}::uuid and workspace_id = ${input.workspaceId}::uuid
+          and session_id = ${input.sessionId}::uuid and id = ${input.runId}::uuid`
+    );
+    return row;
+  });
+  if (!run) throw new Error("Linked schedule run unavailable");
+  const taskRevision = Number(run.task_authority_revision);
+  const snapshot = await getExternalLinkTaskSnapshot(db, {
+    ...input,
+    taskId: run.task_id,
+    taskRevision
+  });
+  if (snapshot)
+    await captureExternalLinkTurnAuthority(db, {
+      ...input,
+      snapshot,
+      source: { kind: "scheduled", taskId: run.task_id, taskRevision }
+    });
+}
 
 // src/child-lifecycle-notices.ts
 import {
@@ -194,7 +637,7 @@ function boundedChildProgressNote(note) {
 
 // src/session-tool-call-settlement.ts
 import { canonicalizePersistedHistoryItem, omitOutputOnlyHistoryItemFields } from "@opengeni/codex";
-import { and, asc, eq, inArray, sql } from "drizzle-orm";
+import { and, asc, eq, inArray, sql as sql4 } from "drizzle-orm";
 var TOOL_RESULT_TYPE_BY_CALL_TYPE = {
   function_call: "function_call_result",
   computer_call: "computer_call_result",
@@ -313,13 +756,13 @@ async function closePendingSessionToolCallsInTransaction(tx, input) {
     ...row,
     item: fromPostgresLosslessJson(row.item, row.itemCodecVersion)
   }));
-  const [{ maxPosition } = { maxPosition: -1 }] = await tx.select({ maxPosition: sql`coalesce(max(${sessionHistoryItems.position}), -1)` }).from(sessionHistoryItems).where(
+  const [{ maxPosition } = { maxPosition: -1 }] = await tx.select({ maxPosition: sql4`coalesce(max(${sessionHistoryItems.position}), -1)` }).from(sessionHistoryItems).where(
     and(
       eq(sessionHistoryItems.workspaceId, input.workspaceId),
       eq(sessionHistoryItems.sessionId, input.sessionId)
     )
   );
-  const existingOutputEvents = await tx.select({ callId: sql`${sessionEvents.payload} ->> 'id'` }).from(sessionEvents).where(
+  const existingOutputEvents = await tx.select({ callId: sql4`${sessionEvents.payload} ->> 'id'` }).from(sessionEvents).where(
     and(
       eq(sessionEvents.workspaceId, input.workspaceId),
       eq(sessionEvents.sessionId, input.sessionId),
@@ -460,13 +903,13 @@ async function closePendingSessionToolCallsInTransaction(tx, input) {
 }
 
 // src/session-realtime-mirror.ts
-import { createHash } from "crypto";
-import { and as and2, desc, eq as eq2, gt, sql as sql2 } from "drizzle-orm";
+import { createHash as createHash2 } from "crypto";
+import { and as and2, desc, eq as eq2, gt, sql as sql5 } from "drizzle-orm";
 var SESSION_REALTIME_MIRROR_MAX_TEXT_BYTES = 131072;
 var SESSION_REALTIME_MIRROR_MAX_PAYLOAD_BYTES = 131072;
 var TRUNCATION_MARKER = "\n\u2026realtime context truncated\u2026";
 function deterministicUuid(seed) {
-  const bytes = createHash("sha256").update(seed, "utf8").digest().subarray(0, 16);
+  const bytes = createHash2("sha256").update(seed, "utf8").digest().subarray(0, 16);
   bytes[6] = (bytes[6] ?? 0) & 15 | 80;
   bytes[8] = (bytes[8] ?? 0) & 63 | 128;
   const hex = bytes.toString("hex");
@@ -517,7 +960,7 @@ async function mirrorSessionRealtimeContextInTransaction(db, input) {
     )
   ).limit(1);
   if (existing) return { entry: existing, replay: true };
-  const [sequenceRow] = await db.select({ next: sql2`coalesce(max(${sessionRealtimeEntries.sequence}), 0) + 1` }).from(sessionRealtimeEntries).where(eq2(sessionRealtimeEntries.realtimeId, mode.id));
+  const [sequenceRow] = await db.select({ next: sql5`coalesce(max(${sessionRealtimeEntries.sequence}), 0) + 1` }).from(sessionRealtimeEntries).where(eq2(sessionRealtimeEntries.realtimeId, mode.id));
   const payload = boundedPayload({
     ...input.payload ?? {},
     source: input.sourceKind,
@@ -718,7 +1161,7 @@ async function assertAgentCommandAuthorityInTransaction(db, input) {
   if (!targetSession) {
     throw new SessionControlInvariantError(`Target session not found: ${input.targetSessionId}`);
   }
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     select
       attempt.id as "attemptId",
       attempt.state as "attemptState",
@@ -756,6 +1199,19 @@ async function assertAgentCommandAuthorityInTransaction(db, input) {
       "The calling agent attempt is being interrupted"
     );
   }
+  const linked = await getExternalLinkTurnAuthorization(
+    db,
+    {
+      accountId: callerSession.accountId,
+      workspaceId: input.workspaceId
+    },
+    input.actor.turnId
+  );
+  if (linked && !linked.authorized)
+    throw new AgentCommandAuthorityError(
+      "CALLER_STALE",
+      "The calling agent's native identity link is no longer active"
+    );
   if (input.action === "steer" && input.targetSessionId === input.actor.sessionId) {
     throw new AgentCommandAuthorityError("SELF_STEER", "An agent cannot steer its own session");
   }
@@ -782,14 +1238,14 @@ function canonicalize(value) {
   return value;
 }
 function canonicalSessionCommandHash(value) {
-  return createHash2("sha256").update(JSON.stringify(canonicalize(value))).digest("hex");
+  return createHash3("sha256").update(JSON.stringify(canonicalize(value))).digest("hex");
 }
 function controlEtag(value) {
   return `sc1:${canonicalSessionCommandHash(value)}`;
 }
 function lockClause(mode) {
-  if (mode === "none") return sql3.empty();
-  return mode === "update" ? sql3.raw("for update") : sql3.raw("for share");
+  if (mode === "none") return sql6.empty();
+  return mode === "update" ? sql6.raw("for update") : sql6.raw("for share");
 }
 var WORKSPACE_CONTROL_REQUEST_LOCK_TIMEOUT_MS = 2e4;
 var configuredRequestLockTimeoutMs = WORKSPACE_CONTROL_REQUEST_LOCK_TIMEOUT_MS;
@@ -819,7 +1275,7 @@ function workspaceControlLockBudget(lockTimeoutMs) {
   return { totalMs, deadlineAt: Date.now() + totalMs };
 }
 function advisoryLockFunction(mode) {
-  return mode === "update" ? sql3.raw("pg_advisory_xact_lock") : sql3.raw("pg_advisory_xact_lock_shared");
+  return mode === "update" ? sql6.raw("pg_advisory_xact_lock") : sql6.raw("pg_advisory_xact_lock_shared");
 }
 function lockBudgetFor(options) {
   if (options.budget) return options.budget;
@@ -831,7 +1287,7 @@ async function boundedLockStep(db, workspaceId, budget, step) {
   const remainingMs = budget.deadlineAt - Date.now();
   if (remainingMs <= 0) throw new WorkspaceControlBusyError(workspaceId, budget.totalMs);
   await db.execute(
-    sql3`select set_config('lock_timeout', ${`${Math.max(1, Math.floor(remainingMs))}ms`}, true)`
+    sql6`select set_config('lock_timeout', ${`${Math.max(1, Math.floor(remainingMs))}ms`}, true)`
   );
   try {
     return await step();
@@ -844,14 +1300,14 @@ async function boundedLockStep(db, workspaceId, budget, step) {
 }
 async function lockWorkspaceInferenceControl(db, workspaceId, mode, options = {}) {
   const budget = lockBudgetFor(options);
-  const [prior] = budget ? await db.execute(sql3`select current_setting('lock_timeout') as value`) : [];
+  const [prior] = budget ? await db.execute(sql6`select current_setting('lock_timeout') as value`) : [];
   if (mode !== "none") {
     await boundedLockStep(
       db,
       workspaceId,
       budget,
       () => db.execute(
-        sql3`select ${advisoryLockFunction(mode)}(hashtextextended(${`workspace-control:${workspaceId}`}, 0))`
+        sql6`select ${advisoryLockFunction(mode)}(hashtextextended(${`workspace-control:${workspaceId}`}, 0))`
       )
     );
   }
@@ -859,7 +1315,7 @@ async function lockWorkspaceInferenceControl(db, workspaceId, mode, options = {}
     db,
     workspaceId,
     budget,
-    () => db.execute(sql3`
+    () => db.execute(sql6`
       select
         workspace_id as "workspaceId",
         account_id as "accountId",
@@ -878,7 +1334,7 @@ async function lockWorkspaceInferenceControl(db, workspaceId, mode, options = {}
     `)
   );
   if (budget) {
-    await db.execute(sql3`select set_config('lock_timeout', ${prior?.value ?? "0"}, true)`);
+    await db.execute(sql6`select set_config('lock_timeout', ${prior?.value ?? "0"}, true)`);
   }
   const row = rows[0];
   if (!row) {
@@ -891,21 +1347,21 @@ async function lockWorkspaceInferenceControl(db, workspaceId, mode, options = {}
 var WORKSPACE_CONTROL_ADMISSION_SAVEPOINT = "opengeni_workspace_control_admission";
 async function lockWorkspaceInferenceControlForAdmission(db, input) {
   const lockOptions = input.lockTimeoutMs === void 0 ? {} : { budget: workspaceControlLockBudget(input.lockTimeoutMs) };
-  await db.execute(sql3.raw(`savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
+  await db.execute(sql6.raw(`savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
   const shared = await lockWorkspaceInferenceControl(db, input.workspaceId, "share", lockOptions);
   if (!input.resumePausedBranch) {
-    await db.execute(sql3.raw(`release savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
+    await db.execute(sql6.raw(`release savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
     return { control: shared, mode: "share" };
   }
   const effective = await evaluateSessionControl(db, input.workspaceId, input.sessionId, {
     workspaceControl: shared
   });
   if (effective.state === "active") {
-    await db.execute(sql3.raw(`release savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
+    await db.execute(sql6.raw(`release savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
     return { control: shared, mode: "share" };
   }
-  await db.execute(sql3.raw(`rollback to savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
-  await db.execute(sql3.raw(`release savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
+  await db.execute(sql6.raw(`rollback to savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
+  await db.execute(sql6.raw(`release savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
   return {
     control: await lockWorkspaceInferenceControl(db, input.workspaceId, "update", lockOptions),
     mode: "update"
@@ -1068,7 +1524,7 @@ async function closeSessionTurnAttemptInTransaction(db, input) {
     and3(
       eq3(sessionTurnAttempts.workspaceId, input.workspaceId),
       eq3(sessionTurnAttempts.id, input.id),
-      sql3`${sessionTurnAttempts.state} in ('claimed', 'running')`
+      sql6`${sessionTurnAttempts.state} in ('claimed', 'running')`
     )
   ).returning({ id: sessionTurnAttempts.id });
   if (!closed) {
@@ -1080,14 +1536,14 @@ function targetValues(sessionIds) {
   if (sessionIds.length === 0) {
     throw new SessionControlInvariantError("At least one target session is required");
   }
-  return sql3.join(
-    sessionIds.map((id) => sql3`(${id}::uuid)`),
-    sql3`, `
+  return sql6.join(
+    sessionIds.map((id) => sql6`(${id}::uuid)`),
+    sql6`, `
   );
 }
 var TARGET_PATH_PROJECTION_LIMIT = 128;
 async function loadTargetAncestryRows(db, workspaceId, sessionIds) {
-  return await db.execute(sql3`
+  return await db.execute(sql6`
     with recursive targets(id) as (values ${targetValues(sessionIds)}),
     ancestry as (
       select
@@ -1150,7 +1606,7 @@ async function loadTargetAncestryRows(db, workspaceId, sessionIds) {
   `);
 }
 async function loadAncestryNodes(db, workspaceId, sessionIds) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with recursive targets(id) as (values ${targetValues(sessionIds)}),
     ancestry_ids(id) as (
       select session.id
@@ -1344,7 +1800,7 @@ function projectEffectiveControl(workspace, targetId, rows, settlementAttempts,
   };
 }
 async function stoppingBackgroundCommandCounts(db, workspaceId, sessionIds) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with recursive targets(id) as (values ${targetValues(sessionIds)}),
     descendants(target_id, session_id, depth, path) as (
       select target.id, target.id, 0::integer, array[target.id]::uuid[] from targets target
@@ -1370,7 +1826,7 @@ async function stoppingBackgroundCommandCounts(db, workspaceId, sessionIds) {
   );
 }
 async function settlementAttemptCounts(db, workspaceId, sessionIds) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with recursive targets(id) as (values ${targetValues(sessionIds)}),
     descendant_sessions(target_id, session_id, depth, path) as (
       select target.id, target.id, 0::integer, array[target.id]::uuid[]
@@ -1524,7 +1980,7 @@ async function evaluateSessionDiscoveryControls(db, workspaceId, sessionIds) {
   if (workspace.workspaceState === "paused" && workspacePauseRevision === null) {
     throw new SessionControlInvariantError("Paused workspace is missing its pause revision");
   }
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with recursive targets(id) as (values ${targetValues(uniqueIds)}),
     ancestry as (
       select
@@ -1696,16 +2152,16 @@ async function findCommandReceipt(db, input) {
     eq3(sessionCommandReceipts.actorType, "agent_attempt"),
     eq3(sessionCommandReceipts.action, input.action),
     eq3(sessionCommandReceipts.targetSessionId, input.targetSessionId),
-    sql3`${sessionCommandReceipts.targetTurnId} is null`,
+    sql6`${sessionCommandReceipts.targetTurnId} is null`,
     eq3(sessionCommandReceipts.operationKey, input.operationKey)
   ) : and3(
     eq3(sessionCommandReceipts.workspaceId, input.workspaceId),
     eq3(sessionCommandReceipts.actorType, input.actor.type),
-    sql3`${sessionCommandReceipts.actorSubjectId} is not distinct from ${actorSubjectId}`,
-    sql3`${sessionCommandReceipts.actorAttemptId} is not distinct from ${actorAttemptId}::uuid`,
+    sql6`${sessionCommandReceipts.actorSubjectId} is not distinct from ${actorSubjectId}`,
+    sql6`${sessionCommandReceipts.actorAttemptId} is not distinct from ${actorAttemptId}::uuid`,
     eq3(sessionCommandReceipts.action, input.action),
-    sql3`${sessionCommandReceipts.targetSessionId} is not distinct from ${input.targetSessionId}::uuid`,
-    sql3`${sessionCommandReceipts.targetTurnId} is not distinct from ${input.targetTurnId}::uuid`,
+    sql6`${sessionCommandReceipts.targetSessionId} is not distinct from ${input.targetSessionId}::uuid`,
+    sql6`${sessionCommandReceipts.targetTurnId} is not distinct from ${input.targetTurnId}::uuid`,
     eq3(sessionCommandReceipts.operationKey, input.operationKey)
   );
   const rows = await db.select().from(sessionCommandReceipts).where(identity).for("update");
@@ -1718,8 +2174,8 @@ async function findPromptCommandReceipts(db, input) {
     and3(
       eq3(sessionCommandReceipts.workspaceId, input.workspaceId),
       eq3(sessionCommandReceipts.actorType, input.actor.type),
-      sql3`${sessionCommandReceipts.actorSubjectId} is not distinct from ${actorSubjectId}`,
-      sql3`${sessionCommandReceipts.actorAttemptId} is not distinct from ${actorAttemptId}::uuid`,
+      sql6`${sessionCommandReceipts.actorSubjectId} is not distinct from ${actorSubjectId}`,
+      sql6`${sessionCommandReceipts.actorAttemptId} is not distinct from ${actorAttemptId}::uuid`,
       inArray2(sessionCommandReceipts.action, ["prompt.send", "prompt.steer"]),
       eq3(sessionCommandReceipts.operationKey, input.operationKey)
     )
@@ -1780,7 +2236,7 @@ async function reserveSessionPromptCommandReceipt(db, input) {
 async function lockSessionPromptCommandOperation(db, input) {
   const actorIdentity = input.actor.type === "agent_attempt" ? `attempt:${input.actor.attemptId}` : `${input.actor.type}:${input.actor.subjectId}`;
   await db.execute(
-    sql3`select pg_advisory_xact_lock(hashtextextended(${`session-prompt:${input.workspaceId}:${actorIdentity}:${input.operationKey}`}, 0))`
+    sql6`select pg_advisory_xact_lock(hashtextextended(${`session-prompt:${input.workspaceId}:${actorIdentity}:${input.operationKey}`}, 0))`
   );
 }
 async function getCompletedSessionPromptCommandReceipt(db, input) {
@@ -1857,7 +2313,7 @@ async function advanceWorkspaceRevision(db, workspaceId, revision) {
   }
 }
 async function registerContinuableWakes(db, input) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with eligible as (
       select *
       from opengeni_private.list_continuable_sessions(
@@ -1899,7 +2355,7 @@ async function registerWorkspaceWakes(db, input) {
   });
 }
 async function registerInterruptionWakes(db, input) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with eligible as (
       select distinct
         session.id as session_id,
@@ -1935,11 +2391,11 @@ async function registerInterruptionWakes(db, input) {
 }
 async function registerCancellationWakes(db, input) {
   if (input.sessionIds.length === 0) return 0;
-  const sessionIds = sql3.join(
-    input.sessionIds.map((id) => sql3`${id}::uuid`),
-    sql3`, `
+  const sessionIds = sql6.join(
+    input.sessionIds.map((id) => sql6`${id}::uuid`),
+    sql6`, `
   );
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with eligible as (
       select
         session.id as session_id,
@@ -1983,8 +2439,8 @@ async function registerSessionWorkflowWakeInTransaction(db, input) {
     target: sessionWorkflowWakeOutbox.sessionId,
     set: {
       temporalWorkflowId: input.temporalWorkflowId,
-      wakeRevision: sql3`${sessionWorkflowWakeOutbox.wakeRevision} + 1`,
-      controlRevision: input.controlRequested ? sql3`${sessionWorkflowWakeOutbox.wakeRevision} + 1` : sql3`${sessionWorkflowWakeOutbox.controlRevision}`,
+      wakeRevision: sql6`${sessionWorkflowWakeOutbox.wakeRevision} + 1`,
+      controlRevision: input.controlRequested ? sql6`${sessionWorkflowWakeOutbox.wakeRevision} + 1` : sql6`${sessionWorkflowWakeOutbox.controlRevision}`,
       reason: input.reason,
       attempts: 0,
       nextAttemptAt: /* @__PURE__ */ new Date(),
@@ -2023,7 +2479,7 @@ async function registerInternalUpdateWakeInTransaction(db, input) {
   };
 }
 async function interruptDescendantAttempts(db, input) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with recursive live_attempts as (
       select attempt.id, attempt.account_id, attempt.workspace_id, attempt.session_id
       from ${sessionTurnAttempts} attempt
@@ -2071,7 +2527,7 @@ async function interruptDescendantAttempts(db, input) {
   return Number(rows[0]?.count ?? 0);
 }
 async function interruptWorkspaceAttempts(db, input) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with inserted as (
       insert into ${sessionAttemptInterruptions} (
         account_id, workspace_id, session_id, operation_id, attempt_id,
@@ -2127,7 +2583,7 @@ async function pendingSessionControlWorkflowWake(db, workspaceId, sessionId, wak
   };
 }
 async function sessionPauseEffectsNeeded(db, input) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with recursive subtree(id, path, cycle) as (
       select session.id, array[session.id]::uuid[], false
       from ${sessions} session
@@ -2178,7 +2634,7 @@ async function sessionPauseEffectsNeeded(db, input) {
   return rows[0]?.needed ?? false;
 }
 async function workspacePauseEffectsNeeded(db, input) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     select exists (
       select 1
       from ${sessions} session
@@ -2207,7 +2663,7 @@ async function workspacePauseEffectsNeeded(db, input) {
   return rows[0]?.needed ?? false;
 }
 async function continuableWakeRepairNeeded(db, input) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     select exists (
       select 1
       from opengeni_private.list_continuable_sessions(
@@ -2224,7 +2680,7 @@ async function continuableWakeRepairNeeded(db, input) {
   return rows[0]?.needed ?? false;
 }
 async function loadSessionSubtreeIds(db, workspaceId, rootSessionId) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with recursive subtree(id, root_parent_session_id, depth, path, cycle) as (
       select session.id, session.parent_session_id, 0::integer, array[session.id]::uuid[], false
       from ${sessions} session
@@ -2418,7 +2874,7 @@ async function enqueueCancelledChildRequiresActionResolvedOutboxInTransaction(db
   }
 }
 async function assertSessionBranchIsNotCancelled(db, workspaceId, sessionId) {
-  const rows = await db.execute(sql3`
+  const rows = await db.execute(sql6`
     with recursive ancestry(id, parent_id, status, depth, path, cycle) as (
       select session.id, session.parent_session_id, session.status, 0::integer,
              array[session.id]::uuid[], false
@@ -2493,7 +2949,7 @@ async function cancelSessionSubtreeInTransaction(db, input) {
       activeAttemptId: null,
       cancelledBy: input.actor,
       cancelReason: input.reason ?? "session_cancelled",
-      version: sql3`${sessionTurns.version} + 1`,
+      version: sql6`${sessionTurns.version} + 1`,
       finishedAt: now,
       updatedAt: now
     }).where(inArray2(sessionTurns.id, immediatelyCancelledTurnIds));
@@ -2677,7 +3133,7 @@ async function cancelSessionSubtreeInTransaction(db, input) {
     await db.update(sessions).set({
       status: "cancelled",
       activeTurnId: liveTurnId,
-      queueVersion: sql3`${sessions.queueVersion} + 1`,
+      queueVersion: sql6`${sessions.queueVersion} + 1`,
       queueHeadPosition: 0,
       queueTailPosition: 0,
       lastSequence: sequence,
@@ -2826,7 +3282,7 @@ async function mutateSessionControlInTransaction(db, input) {
       rootSessionId: input.sessionId
     });
     if (!changed) {
-      const [quiescence] = input.action === "pause" ? await db.execute(sql3`
+      const [quiescence] = input.action === "pause" ? await db.execute(sql6`
             select exists (
               select 1 from ${sessionTurnAttempts} attempt
               where attempt.workspace_id = ${input.workspaceId}
@@ -3372,7 +3828,7 @@ async function setWorkspacePauseTimerInTransaction(db, input) {
     }
   }
   const hasTimer = input.action === "set" && delay > 0;
-  const [clock] = await db.execute(sql3`select clock_timestamp() as now`);
+  const [clock] = await db.execute(sql6`select clock_timestamp() as now`);
   const revision = nextRevision(workspace);
   await db.update(workspaceInferenceControls).set({
     ...clearWorkspaceTimerFields,
@@ -3407,7 +3863,7 @@ async function fireWorkspacePauseTimerInTransaction(db, input) {
   const workspace = await lockWorkspaceInferenceControl(db, input.workspaceId, "update", {
     lockTimeoutMs: 1e3
   });
-  const [clock] = await db.execute(sql3`select clock_timestamp() as now`);
+  const [clock] = await db.execute(sql6`select clock_timestamp() as now`);
   if (workspace.timerId !== input.timerId || !workspace.timerDueAt || new Date(workspace.timerDueAt).getTime() > new Date(clock.now).getTime())
     return null;
   const action = workspace.timerAction;
@@ -3423,7 +3879,7 @@ async function fireWorkspacePauseTimerInTransaction(db, input) {
     action,
     timerExecution: true
   });
-  const [applied] = await db.execute(sql3`select clock_timestamp() as now`);
+  const [applied] = await db.execute(sql6`select clock_timestamp() as now`);
   await db.update(workspaceInferenceControls).set({
     ...clearWorkspaceTimerFields,
     ...action === "pause" && workspace.timerPauseForSeconds !== null ? {
@@ -3457,7 +3913,7 @@ function commandPreview(value) {
   const normalized = value.replace(/\s+/g, " ").trim();
   return Array.from(normalized).slice(0, 512).join("");
 }
-var commandObservationUnavailable = sql4`
+var commandObservationUnavailable = sql7`
   ${sessionBackgroundCommands.state} in ('running','stopping') and exists (
     select 1 from sandbox_retained_processes process
     where process.id = ${sessionBackgroundCommands.retainedProcessId}
@@ -3510,9 +3966,9 @@ async function backgroundCommandActivityForSessions(db, input) {
     async (scopedDb) => {
       const rows = await scopedDb.select({
         sessionId: sessionBackgroundCommands.sessionId,
-        count: sql4`count(*)::int`,
-        stoppingCount: sql4`count(*) filter (where ${sessionBackgroundCommands.state} = 'stopping')::int`,
-        unavailableCount: sql4`count(*) filter (where ${commandObservationUnavailable})::int`
+        count: sql7`count(*)::int`,
+        stoppingCount: sql7`count(*) filter (where ${sessionBackgroundCommands.state} = 'stopping')::int`,
+        unavailableCount: sql7`count(*) filter (where ${commandObservationUnavailable})::int`
       }).from(sessionBackgroundCommands).where(
         and4(
           eq4(sessionBackgroundCommands.workspaceId, input.workspaceId),
@@ -3581,7 +4037,7 @@ async function insertManagedSessionBackgroundCommandInTransaction(db, input) {
     launchExecutionGeneration: input.executionGeneration ?? null
   }).onConflictDoUpdate({
     target: sessionBackgroundCommands.retainedProcessId,
-    targetWhere: sql4`${sessionBackgroundCommands.retainedProcessId} is not null`,
+    targetWhere: sql7`${sessionBackgroundCommands.retainedProcessId} is not null`,
     set: { updatedAt: /* @__PURE__ */ new Date() }
   }).returning();
   if (!row) throw new Error("Managed background command adoption returned no row");
@@ -3614,7 +4070,7 @@ async function insertConnectedMachineSessionBackgroundCommandInTransaction(db, i
       sessionBackgroundCommands.connectionInstanceId,
       sessionBackgroundCommands.opId
     ],
-    targetWhere: sql4`${sessionBackgroundCommands.provider} = 'connected_machine'`,
+    targetWhere: sql7`${sessionBackgroundCommands.provider} = 'connected_machine'`,
     set: { updatedAt: /* @__PURE__ */ new Date() }
   }).returning();
   if (!row) throw new Error("Connected Machine background command adoption returned no row");
@@ -3632,7 +4088,7 @@ async function claimConnectedMachineSessionBackgroundCommands(db, input) {
   if (!Number.isSafeInteger(input.claimTtlMs) || input.claimTtlMs < 0 || input.claimTtlMs > 36e5) {
     throw new Error("Connected command reconciliation claim TTL is invalid");
   }
-  const rows = await db.execute(sql4`
+  const rows = await db.execute(sql7`
     select account_id as "accountId",
       workspace_id as "workspaceId",
       session_id as "sessionId",
@@ -3767,7 +4223,7 @@ async function settleClaimedConnectedMachineBackgroundCommandWithMutation(db, in
     { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
     async (tx) => {
       await mutateTerminal.prepare(tx);
-      const rows = await tx.execute(sql4`
+      const rows = await tx.execute(sql7`
           update ${sessionBackgroundCommands} command set
             state = command.reconcile_proof_outcome,
             exit_code = case
@@ -3834,7 +4290,7 @@ async function requestSessionBackgroundCommandCancellation(db, input) {
           and4(
             eq4(sandboxRetainedProcesses.id, current.retainedProcessId),
             eq4(sandboxRetainedProcesses.state, "active"),
-            sql4`${sandboxRetainedProcesses.reconcileClaimId} is null`
+            sql7`${sandboxRetainedProcesses.reconcileClaimId} is null`
           )
         );
       }
@@ -3845,11 +4301,11 @@ async function requestSessionBackgroundCommandCancellation(db, input) {
 async function requestSessionBackgroundCommandCancellationsInTransaction(db, input) {
   const rootSessionIds = [...new Set(input.rootSessionIds)];
   if (rootSessionIds.length === 0) return 0;
-  const rows = await db.execute(sql4`
+  const rows = await db.execute(sql7`
     with recursive roots(id) as (
-      values ${sql4.join(
-    rootSessionIds.map((sessionId) => sql4`(${sessionId}::uuid)`),
-    sql4`, `
+      values ${sql7.join(
+    rootSessionIds.map((sessionId) => sql7`(${sessionId}::uuid)`),
+    sql7`, `
   )}
     ), subtree(id, path, cycle) as (
       select session.id, array[session.id]::uuid[], false
@@ -3896,7 +4352,7 @@ async function requestSessionBackgroundCommandCancellationsInTransaction(db, inp
   return Number(rows[0]?.commandCount ?? 0);
 }
 async function requestWorkspaceBackgroundCommandCancellationsInTransaction(db, input) {
-  const rows = await db.execute(sql4`
+  const rows = await db.execute(sql7`
     with stopped as (
       update ${sessionBackgroundCommands} command set
         state = 'stopping',
@@ -3968,7 +4424,7 @@ async function settleSessionBackgroundCommandForRetainedProcessInTransaction(tx,
         eq4(sessionEvents.workspaceId, input.workspaceId),
         eq4(sessionEvents.sessionId, input.sessionId),
         eq4(sessionEvents.type, "session.command.finished"),
-        sql4`${sessionEvents.payload} ->> 'commandId' = ${current.id}`
+        sql7`${sessionEvents.payload} ->> 'commandId' = ${current.id}`
       )
     ).limit(1);
     if (existingEvent) return mapCommand(current);
@@ -4024,7 +4480,7 @@ async function settleConnectedMachineSessionBackgroundCommandWithMutation(db, in
           eq4(sessionBackgroundCommands.opId, input.opId),
           // A fast owner settlement cannot erase or replace metadata already
           // checkpointed by the reconciler under the exact command identity.
-          sql4`(${sessionBackgroundCommands.runnerFailure} is null or
+          sql7`(${sessionBackgroundCommands.runnerFailure} is null or
               ${sessionBackgroundCommands.runnerFailure} = ${failure ? JSON.stringify(failure) : null}::jsonb)`,
           inArray3(sessionBackgroundCommands.state, ["running", "stopping"])
         )
@@ -4173,7 +4629,7 @@ async function readSessionBackgroundCommandOutput(db, input) {
       // Bound legacy payloads in SQL too: LIMIT alone cannot bound one old event.
       // Oversized historical rows carry explicit loss rather than allocating an
       // unbounded JSON value in the API process.
-      payload: sql4`case when octet_length(${sessionEvents.payload}::text) <= 262144
+      payload: sql7`case when octet_length(${sessionEvents.payload}::text) <= 262144
       then ${sessionEvents.payload}
       else jsonb_build_object('commandReadProjectionGap', true) end`,
       payloadCodecVersion: sessionEvents.payloadCodecVersion
@@ -4182,7 +4638,7 @@ async function readSessionBackgroundCommandOutput(db, input) {
         eq4(sessionEvents.workspaceId, input.workspaceId),
         eq4(sessionEvents.sessionId, input.sessionId),
         eq4(sessionEvents.type, "sandbox.command.output.delta"),
-        sql4`${sessionEvents.payload} ->> 'commandId' = ${input.commandId}`,
+        sql7`${sessionEvents.payload} ->> 'commandId' = ${input.commandId}`,
         gte(sessionEvents.sequence, cursor.sequence)
       )
     ).orderBy(asc2(sessionEvents.sequence)).limit(COMMAND_OUTPUT_PAGE_ROWS + 1)
@@ -4203,6 +4659,26 @@ async function readSessionBackgroundCommandOutput(db, input) {
 }
 
 export {
+  lockActiveExternalOrganizationKey,
+  lockExternalWorkspaceMembershipLifecycle,
+  ensureExternalIdentity,
+  ExternalIdentityLinkConflictError,
+  beginExternalIdentityLink,
+  getExternalIdentityLink,
+  listExternalIdentityLinks,
+  previewExternalIdentityLink,
+  confirmExternalIdentityLink,
+  revokeExternalIdentityLink,
+  resolveExternalIdentityLink,
+  externalLinkWorkSnapshotIsLive,
+  getExternalLinkTurnSnapshot,
+  getExternalLinkTurnAuthorization,
+  captureExternalLinkTurnAuthority,
+  inheritExternalLinkTurnAuthority,
+  getExternalLinkTaskSnapshot,
+  captureExternalLinkTaskAuthority,
+  cloneExternalLinkTaskAuthority,
+  captureScheduledExternalLinkTurnAuthority,
   configureChildLifecycleNotices,
   childLifecycleNoticesEnabled,
   boundedChildNoticeText,
@@ -4293,4 +4769,4 @@ export {
   setWorkspacePauseTimerInTransaction,
   fireWorkspacePauseTimerInTransaction
 };
-//# sourceMappingURL=chunk-6GAPAYZR.js.map
+//# sourceMappingURL=chunk-7JPLGBSA.js.map