@opengeni/api-router 4.0.0 → 4.1.0-canary.35855175602001

package/dist/{chunk-E7TZFJ65.js → chunk-24C5LPNE.js}

@@ -267,6 +267,7 @@ var FIRST_PARTY_TOOL_AUTHORIZATION = {
   run_on: { sessionRequired: true, allOf: ["sessions:control"] },
   sandbox_provision: { sessionRequired: true, allOf: ["sessions:control"] },
   connected_machine_remove: { allOf: ["enrollments:manage"] },
+  connected_machine_enroll_token: { allOf: ["enrollments:manage"] },
   rig_list: { allOf: ["rigs:use"] },
   rig_get: { allOf: ["rigs:use"] },
   rig_propose_change: { allOf: ["rigs:use"] },
@@ -649,8 +650,8 @@ import { SiteSessionPathError, OrganizationIntegrationDeniedError as Organizatio
 
 // src/routes/model-connection-access.ts
 import {
-  configuredModels as configuredModels2,
-  withCodexCatalogProvider,
+  configuredModels as configuredModels3,
+  withCodexCatalogProvider as withCodexCatalogProvider2,
   withXaiSubscriptionCatalogProvider as withXaiSubscriptionCatalogProvider2,
   withOrganizationGatewayCatalogProvider,
   withOrganizationOpenRouterCatalogProvider
@@ -673,14 +674,17 @@ import { HTTPException as HTTPException4 } from "hono/http-exception";
 import { z as z5 } from "zod";
 
 // src/routes/codex.ts
-import { environmentsEncryptionKeyBytes, productLabelForModelId } from "@opengeni/config";
+import {
+  environmentsEncryptionKeyBytes,
+  configuredModels,
+  getSettings,
+  withCodexCatalogProvider
+} from "@opengeni/config";
 import {
   accessTokenExpiry,
   buildCodexUsageWindowFromCache,
   CODEX_CLIENT_VERSION,
-  CODEX_FALLBACK_MODEL_SLUGS,
   CODEX_FIVE_HOUR_WINDOW_SECONDS,
-  CODEX_MODEL_ID_PREFIX,
   CODEX_PROVIDER_ID,
   CODEX_WEEKLY_WINDOW_SECONDS,
   CodexDeviceError,
@@ -741,7 +745,8 @@ import {
   getManagedSession,
   hasPermission as hasPermission2,
   requireAccessGrant as requireAccessGrant2,
-  requireCanonicalLocalAccountAdministrator
+  requireCanonicalLocalAccountAdministrator,
+  resolveCatalogSettings
 } from "@opengeni/core";
 import { HTTPException as HTTPException2 } from "hono/http-exception";
 import * as z3 from "zod/v4";
@@ -863,10 +868,10 @@ function codexWorkerReadiness(input) {
 function codexUsageJson(payload) {
   return { status: payload.status, usage: payload };
 }
-function codexModelsForPicker() {
-  return CODEX_FALLBACK_MODEL_SLUGS.map((slug) => ({
-    id: `${CODEX_MODEL_ID_PREFIX}${slug}`,
-    label: productLabelForModelId(slug),
+function codexModelsForPicker(settings = getSettings()) {
+  return configuredModels(withCodexCatalogProvider(settings)).filter((model) => model.providerId === CODEX_PROVIDER_ID).map((model) => ({
+    id: model.id,
+    label: model.label,
     provider: CODEX_PROVIDER_ID,
     providerLabel: CODEX_PROVIDER_LABEL,
     api: "responses"
@@ -1687,7 +1692,7 @@ function registerCodexRoutes(app, deps) {
       now: /* @__PURE__ */ new Date()
     });
     let valid = false;
-    const models = codexModelsForPicker();
+    const models = codexModelsForPicker((await resolveCatalogSettings(db, settings)).settings);
     let catalogError = null;
     try {
       const cred = status?.credentialId ? await loadCodexCredentialForRun(db, settings, workspaceId, status.credentialId) : null;
@@ -2471,7 +2476,7 @@ import {
   updateOrganizationXaiRotation
 } from "@opengeni/db";
 import {
-  configuredModels,
+  configuredModels as configuredModels2,
   environmentsEncryptionKeyBytes as environmentsEncryptionKeyBytes2,
   withXaiSubscriptionCatalogProvider
 } from "@opengeni/config";
@@ -3184,7 +3189,7 @@ function registerSuperGrokRoutes(app, deps) {
       valid = false;
     }
     const catalogSettings = valid ? (await deps.resolveCatalogSettings()).settings : null;
-    const catalog = catalogSettings ? configuredModels(withXaiSubscriptionCatalogProvider(catalogSettings)).filter(
+    const catalog = catalogSettings ? configuredModels2(withXaiSubscriptionCatalogProvider(catalogSettings)).filter(
       (model) => model.credentialSource.kind === "connected_subscription" && model.credentialSource.provider === "xai"
     ).map(projectClientModel) : [];
     return c.json({
@@ -3426,7 +3431,7 @@ function registerModelConnectionAccessRoutes(app, deps) {
         accountId: connection.accountId,
         workspaceId: connection.workspaceId
       })).settings;
-      settings = withCodexCatalogProvider(withXaiSubscriptionCatalogProvider2(settings));
+      settings = withCodexCatalogProvider2(withXaiSubscriptionCatalogProvider2(settings));
       let workspaces = [];
       if (connection.workspaceId === null) {
         const actor = {
@@ -3448,7 +3453,7 @@ function registerModelConnectionAccessRoutes(app, deps) {
         ModelConnectionAccessResponse.parse({
           policy,
           workspaces,
-          models: configuredModels2(settings).filter((model) => model.id.startsWith(modelPrefix(connection))).map(({ id, label }) => ({ id, label })),
+          models: configuredModels3(settings).filter((model) => model.id.startsWith(modelPrefix(connection))).map(({ id, label }) => ({ id, label })),
           personalWorkspacesSupported: connection.workspaceId === null && (connection.kind === "codex" || connection.kind === "supergrok")
         })
       );
@@ -3482,10 +3487,10 @@ import {
   canonicalizeConfiguredModelId as canonicalizeConfiguredModelId2,
   configuredAllowedModels,
   configuredAllowedReasoningEfforts,
-  configuredModels as configuredModels3,
+  configuredModels as configuredModels4,
   resolveFirstPartyMcpToolPolicy as resolveFirstPartyMcpToolPolicy2,
   resolveVoiceInputProviderRegistry as resolveVoiceInputProviderRegistry2,
-  withCodexCatalogProvider as withCodexCatalogProvider2,
+  withCodexCatalogProvider as withCodexCatalogProvider3,
   withXaiSubscriptionCatalogProvider as withXaiSubscriptionCatalogProvider3
 } from "@opengeni/config";
 import {
@@ -3600,7 +3605,7 @@ import {
   requireAccessGrantAuthorization as requireAccessGrantAuthorization36,
   requirePermission as requirePermission9,
   releaseManagedAuthRequestActorLease,
-  resolveCatalogSettings,
+  resolveCatalogSettings as resolveCatalogSettings2,
   resolveWorkspaceCatalogSettings as resolveWorkspaceCatalogSettings10,
   validateManagedAuthRequestActorLease,
   requireSessionAuthorization as requireSessionAuthorization16,
@@ -5889,7 +5894,296 @@ import {
   deleteChannel,
   setSessionChannel
 } from "@opengeni/db";
-import { createHash as createHash11, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash12, randomUUID as randomUUID3 } from "crypto";
+
+// src/sandbox/enrollment.ts
+import { randomBytes } from "crypto";
+import {
+  resolveEnrollmentSigningSecret,
+  resolveRelayTokenSecret
+} from "@opengeni/config";
+import {
+  DeviceEnrollmentState,
+  signEnrollmentBearer,
+  signEnrollToken,
+  signRelayToken,
+  verifyEnrollToken
+} from "@opengeni/contracts";
+import {
+  approveDeviceEnrollmentRequest,
+  consumeDeviceEnrollmentRequest,
+  createDeviceEnrollmentRequest,
+  denyDeviceEnrollmentRequest,
+  finalizeEnrollmentByToken,
+  getDeviceEnrollmentRequestByDeviceCode,
+  getEnrollment,
+  getPendingDeviceEnrollmentRequestByUserCode,
+  getPendingDeviceEnrollmentRequestByUserCodeGlobal
+} from "@opengeni/db";
+import { relayDialBaseFromSettings } from "@opengeni/core";
+var DEVICE_CODE_TTL_SECONDS = 600;
+var DEVICE_POLL_INTERVAL_SECONDS = 5;
+var ENROLLMENT_BEARER_TTL_SECONDS = 30 * 24 * 3600;
+var RELAY_TOKEN_TTL_SECONDS = 30 * 24 * 3600;
+var ENROLL_TOKEN_TTL_SECONDS = 3600;
+function mintDeviceCode() {
+  return randomBytes(32).toString("base64url");
+}
+var USER_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+function mintUserCode() {
+  const bytes = randomBytes(8);
+  let out = "";
+  for (let i = 0; i < 8; i += 1) {
+    out += USER_CODE_ALPHABET[bytes[i] % USER_CODE_ALPHABET.length];
+  }
+  return `${out.slice(0, 4)}-${out.slice(4, 8)}`;
+}
+async function startDeviceEnrollment(services, input) {
+  const { db } = services;
+  const expiresAt = new Date(Date.now() + DEVICE_CODE_TTL_SECONDS * 1e3);
+  let request;
+  let lastError;
+  for (let attempt = 0; attempt < 5 && !request; attempt += 1) {
+    const deviceCode = mintDeviceCode();
+    const userCode = mintUserCode();
+    try {
+      request = await createDeviceEnrollmentRequest(db, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        deviceCode,
+        userCode,
+        pubkey: input.publicKey,
+        os: input.os,
+        arch: input.arch,
+        machineName: input.machineName ?? null,
+        requestedExposure: "whole-machine",
+        canOfferDisplay: input.canOfferDisplay,
+        requestsScreenControl: input.requestsScreenControl,
+        expiresAt
+      });
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  if (!request) {
+    throw lastError instanceof Error ? lastError : new Error("failed to start device enrollment");
+  }
+  const base = input.verificationOrigin.replace(/\/+$/, "");
+  const verificationUri = `${base}/device`;
+  const verificationUriComplete = `${verificationUri}?user_code=${encodeURIComponent(request.userCode)}`;
+  return {
+    deviceCode: request.deviceCode,
+    userCode: request.userCode,
+    verificationUri,
+    verificationUriComplete,
+    intervalSeconds: DEVICE_POLL_INTERVAL_SECONDS,
+    expiresInSeconds: DEVICE_CODE_TTL_SECONDS
+  };
+}
+async function approveDeviceEnrollment(services, input) {
+  const { db } = services;
+  const pending = await getPendingDeviceEnrollmentRequestByUserCode(
+    db,
+    input.workspaceId,
+    input.userCode
+  );
+  if (!pending) {
+    return null;
+  }
+  const sandboxName = (pending.machineName?.trim() || `${pending.os} machine`).slice(0, 256);
+  const result = await approveDeviceEnrollmentRequest(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    ...input.scope ? { scope: input.scope } : {},
+    allowOrganization: input.allowOrganization === true,
+    requestId: pending.id,
+    allowScreenControl: input.allowScreenControl,
+    approvedBySubjectId: input.approvedBySubjectId,
+    approvedBySubjectLabel: input.approvedBySubjectLabel ?? null,
+    sandboxName
+  });
+  if (!result.approved || !result.enrollment || !result.sandbox) {
+    return null;
+  }
+  return {
+    enrollmentId: result.enrollment.id,
+    sandboxId: result.sandbox.id,
+    allowScreenControl: result.enrollment.allowScreenControl
+  };
+}
+async function lookupDeviceEnrollment(services, input) {
+  const { db } = services;
+  return await getPendingDeviceEnrollmentRequestByUserCodeGlobal(db, input.userCode);
+}
+function toLookupResponse(record6) {
+  return {
+    workspaceId: record6.workspaceId,
+    userCode: record6.userCode,
+    machine: {
+      machineName: record6.machineName,
+      os: record6.os,
+      arch: record6.arch,
+      canOfferDisplay: record6.canOfferDisplay,
+      requestsScreenControl: record6.requestsScreenControl
+    },
+    expiresAt: record6.expiresAt
+  };
+}
+async function denyDeviceEnrollment(services, input) {
+  const { db } = services;
+  const pending = await getPendingDeviceEnrollmentRequestByUserCode(
+    db,
+    input.workspaceId,
+    input.userCode
+  );
+  if (!pending) {
+    return { denied: false };
+  }
+  return await denyDeviceEnrollmentRequest(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    requestId: pending.id
+  });
+}
+async function mintEnrollToken(services, input) {
+  const { settings } = services;
+  const secret = resolveEnrollmentSigningSecret(settings);
+  if (!secret) {
+    return null;
+  }
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const exp = nowSeconds + ENROLL_TOKEN_TTL_SECONDS;
+  const token = await signEnrollToken(secret, {
+    typ: "enroll",
+    workspaceId: input.workspaceId,
+    accountId: input.accountId,
+    allowScreenControl: input.allowScreenControl,
+    iat: nowSeconds,
+    exp
+  });
+  return {
+    token,
+    expiresAt: new Date(exp * 1e3).toISOString(),
+    expiresInSeconds: ENROLL_TOKEN_TTL_SECONDS
+  };
+}
+async function exchangeEnrollToken(services, input) {
+  const { db, settings } = services;
+  const secret = resolveEnrollmentSigningSecret(settings);
+  if (!secret) {
+    return { ok: false, reason: "disabled" };
+  }
+  const claims = await verifyEnrollToken(secret, input.token);
+  if (!claims) {
+    return { ok: false, reason: "invalid" };
+  }
+  const sandboxName = (input.machineName?.trim() || `${input.os} machine`).slice(0, 256);
+  const { enrollment } = await finalizeEnrollmentByToken(db, {
+    accountId: claims.accountId,
+    workspaceId: claims.workspaceId,
+    pubkey: input.publicKey,
+    hasDisplay: input.canOfferDisplay,
+    // The token's allowScreenControl is the AUTHORITATIVE consent (NOT the agent's
+    // requestsScreenControl) — it was baked in at mint by the authorizing user.
+    allowScreenControl: claims.allowScreenControl,
+    os: input.os,
+    arch: input.arch,
+    sandboxName
+  });
+  const credentials = await buildEnrollmentCredentials(services, {
+    secret,
+    workspaceId: claims.workspaceId,
+    agentId: enrollment.id,
+    credentialGeneration: enrollment.credentialGeneration,
+    consentedScreenControl: enrollment.allowScreenControl
+  });
+  return { ok: true, credentials };
+}
+async function pollDeviceEnrollment(services, input) {
+  const { db, settings } = services;
+  const request = await getDeviceEnrollmentRequestByDeviceCode(db, input.deviceCode);
+  if (!request) {
+    return { state: "expired" };
+  }
+  if (request.status === "denied") {
+    return { state: "denied" };
+  }
+  if (request.status === "pending") {
+    if (new Date(request.expiresAt).getTime() <= Date.now()) {
+      return { state: "expired" };
+    }
+    return { state: "pending" };
+  }
+  if (!request.enrollmentId) {
+    return { state: "expired" };
+  }
+  const secret = resolveEnrollmentSigningSecret(settings);
+  if (!secret) {
+    return { state: "disabled" };
+  }
+  const enrollment = await getEnrollment(db, request.workspaceId, request.enrollmentId);
+  if (!enrollment || enrollment.status !== "active") {
+    return { state: "denied" };
+  }
+  const credentials = await buildEnrollmentCredentials(services, {
+    secret,
+    workspaceId: request.workspaceId,
+    agentId: enrollment.id,
+    credentialGeneration: enrollment.credentialGeneration,
+    consentedScreenControl: enrollment.allowScreenControl
+  });
+  if (request.status === "approved") {
+    await consumeDeviceEnrollmentRequest(db, {
+      accountId: request.accountId,
+      workspaceId: request.workspaceId,
+      requestId: request.id
+    });
+  }
+  return { state: DeviceEnrollmentState.enum.authorized, credentials };
+}
+async function buildEnrollmentCredentials(services, input) {
+  const { settings } = services;
+  const subjectPrefix = `agent.${input.workspaceId}.${input.agentId}`;
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const exp = nowSeconds + ENROLLMENT_BEARER_TTL_SECONDS;
+  const bearer = await signEnrollmentBearer(input.secret, {
+    workspaceId: input.workspaceId,
+    agentId: input.agentId,
+    enrollmentId: input.agentId,
+    credentialGeneration: input.credentialGeneration,
+    subjectPrefix,
+    exp
+  });
+  const natsUrls = settings.selfhostedNatsUrl ? [settings.selfhostedNatsUrl] : [];
+  const relayTokenSecret = resolveRelayTokenSecret(settings);
+  const relayToken = relayTokenSecret ? await signRelayToken(relayTokenSecret, {
+    workspaceId: input.workspaceId,
+    agentId: input.agentId,
+    exp: nowSeconds + RELAY_TOKEN_TTL_SECONDS
+  }) : "";
+  return {
+    agentId: input.agentId,
+    workspaceId: input.workspaceId,
+    bearer,
+    subjectPrefix,
+    natsUrls,
+    // Hand the agent the canonical `/stream` dial base, NOT the raw configured URL.
+    // The agent's relay producer appends only its routing query and assumes the base
+    // already carries the relay's `/stream` route; a path-less base 400s the dial and
+    // makes the terminal/desktop streams unreachable.
+    relayUrl: relayDialBaseFromSettings(settings),
+    relayToken,
+    // M-AUTH closes the placeholder: there is NO per-machine NATS Account creds
+    // file. The agent presents the BEARER as the NATS connect auth-token; the
+    // server's auth-callout responder validates it and mints a workspace-scoped
+    // user JWT. We echo the bearer here so a consumer reading this (vestigial) field
+    // as the connect credential still works — the value IS the bearer.
+    natsAccountCreds: bearer,
+    updatePublicKey: settings.agentUpdatePublicKey ?? "",
+    consentedWholeMachine: true,
+    consentedScreenControl: input.consentedScreenControl
+  };
+}
 
 // src/mcp/capability-account-readiness.ts
 function capabilityAccountReadiness(availableRoutes, bindings) {
@@ -5905,6 +6199,7 @@ function capabilityAccountReadiness(availableRoutes, bindings) {
 
 // src/site-uploads.ts
 import { WorkspaceArtifactSourceBundle as WorkspaceArtifactSourceBundle2 } from "@opengeni/contracts";
+import { retryWhileMissing as retryWhileMissing2 } from "@opengeni/storage";
 import {
   createWorkspaceArtifactUpload,
   getWorkspaceArtifactUpload,
@@ -6017,7 +6312,12 @@ async function validateSiteSource(storage, key, sizeBytes) {
       "Editable source JSON must be at most 64 MiB. Exclude dependencies and build output; HTML has a separate storage limit."
     );
   }
-  const content = await storage.getObjectBytes(key);
+  const content = await retryWhileMissing2(() => storage.getObjectBytes(key));
+  if (!content) {
+    throw new WorkspaceArtifactOperationError(
+      "Site source is not available yet. Retry publication with the same upload."
+    );
+  }
   try {
     WorkspaceArtifactSourceBundle2.parse(
       JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(content.bytes))
@@ -6110,13 +6410,20 @@ async function freeze(storage, from, to, contentType, optional = false) {
     }
     decoder2.decode();
   }
-  await storage.putObjectStreamIfAbsent({
+  const created = await storage.putObjectStreamIfAbsent({
     key: to,
     contentType,
     byteSize: head.ContentLength,
     chunks: chunks()
   });
-  return (await storage.headObject(to)).ContentLength;
+  if (created) return head.ContentLength;
+  const stored = await retryWhileMissing2(() => storage.headObject(to));
+  if (!stored || stored.ContentLength === void 0) {
+    throw new WorkspaceArtifactOperationError(
+      "Frozen Site upload is unavailable. Retry publication with the same upload."
+    );
+  }
+  return stored.ContentLength;
 }
 async function prepareWorkspaceArtifactPublication(deps, grant, input) {
   const storage = deps.objectStorage;
@@ -7700,7 +8007,7 @@ import {
   recordSandboxFilePublication,
   withSessionRlsActorContext as withSessionRlsActorContext5
 } from "@opengeni/db";
-import { retryWhileMissing as retryWhileMissing3 } from "@opengeni/storage";
+import { retryWhileMissing as retryWhileMissing4 } from "@opengeni/storage";
 import { HTTPException as HTTPException12 } from "hono/http-exception";
 
 // src/sandbox/channel-a.ts
@@ -9059,7 +9366,7 @@ import {
   SessionAuthorizationUnavailableError as SessionAuthorizationUnavailableError3
 } from "@opengeni/core";
 import { recordWorkspaceUsage, requireLimit } from "@opengeni/core";
-import { retryWhileMissing as retryWhileMissing2 } from "@opengeni/storage";
+import { retryWhileMissing as retryWhileMissing3 } from "@opengeni/storage";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 
 // src/mcp/files.ts
@@ -9161,7 +9468,7 @@ function buildFilesMcpServer(deps, authority) {
 }
 
 // src/mcp-oauth.ts
-import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash2, randomBytes as randomBytes3 } from "crypto";
 import {
   MCP_OAUTH_ACCESS_TOKEN_TTL_SECONDS,
   MCP_OAUTH_AUTHORIZATION_CODE_TTL_SECONDS,
@@ -9219,7 +9526,7 @@ function normalizedAddress(value) {
 
 // src/workspace-tool-gateway.ts
 import { knowledgeContextForGateway } from "@opengeni/core";
-import { createHash, randomBytes } from "crypto";
+import { createHash, randomBytes as randomBytes2 } from "crypto";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { withSiteSessionOrigin } from "@opengeni/core";
@@ -9869,7 +10176,7 @@ async function approveWorkspaceToolGatewayCall(prepared, grant, db, input, issue
     operation: "approval",
     source: preparedCall.entry.source
   });
-  const approvalToken = `ogta_${randomBytes(32).toString("base64url")}`;
+  const approvalToken = `ogta_${randomBytes2(32).toString("base64url")}`;
   const expiresAt = new Date(Date.now() + 5 * 6e4);
   try {
     await prepared.reauthorize?.();
@@ -10501,7 +10808,7 @@ function pkceChallenge(verifier) {
   return createHash2("sha256").update(verifier, "ascii").digest("base64url");
 }
 function opaque(prefix) {
-  return `${prefix}${randomBytes2(32).toString("base64url")}`;
+  return `${prefix}${randomBytes3(32).toString("base64url")}`;
 }
 function tokenHash(value) {
   return createHash2("sha256").update(value, "utf8").digest("hex");
@@ -10954,7 +11261,7 @@ function registerFileRoutes(app, deps) {
       const file2 = await rejectAndCleanObject(409, "file upload has expired", "expired");
       return c.json(CompleteFileUploadResponse.parse({ file: file2 }));
     }
-    const head = await retryWhileMissing2(async () => {
+    const head = await retryWhileMissing3(async () => {
       if (!await objectStorage.fileExists(upload.file)) return null;
       return await objectStorage.headFile(upload.file);
     });
@@ -11086,7 +11393,7 @@ function registerFileRoutes(app, deps) {
       throw new HTTPException11(409, { message: `generated video is ${retained.file.status}` });
     }
     const file = generatedVideoFileAsset(retained.file);
-    const videoPresent = await retryWhileMissing2(
+    const videoPresent = await retryWhileMissing3(
       async () => await objectStorage.fileExists(file) ? true : null
     );
     if (!videoPresent) {
@@ -11196,7 +11503,7 @@ function registerFileRoutes(app, deps) {
     if (file.status !== "ready") {
       throw new HTTPException11(409, { message: `file is ${file.status}` });
     }
-    const present = await retryWhileMissing2(
+    const present = await retryWhileMissing3(
       async () => await objectStorage.fileExists(file) ? true : null
     );
     if (!present) {
@@ -11270,7 +11577,7 @@ async function serveRetainedArtifactContent(c, objectStorage, artifactId2, file,
     ...range.contentRange ? { "Content-Range": range.contentRange } : {}
   };
   if (range.kind === "empty") {
-    const present = await retryWhileMissing2(
+    const present = await retryWhileMissing3(
       async () => await objectStorage.fileExists(file) ? true : null
     );
     if (!present) {
@@ -11278,7 +11585,7 @@ async function serveRetainedArtifactContent(c, objectStorage, artifactId2, file,
     }
     return c.body(null, 200, headers);
   }
-  const bytes = await retryWhileMissing2(
+  const bytes = await retryWhileMissing3(
     async () => objectStorage.getFileRange(file, {
       start: range.start,
       end: range.end
@@ -11674,6 +11981,14 @@ function sandboxFileContentType(filename) {
     ".jpg": "image/jpeg",
     ".json": "application/json",
     ".md": "text/markdown",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".ogv": "video/ogg",
+    ".mp3": "audio/mpeg",
+    ".m4a": "audio/mp4",
+    ".ogg": "audio/ogg",
+    ".wav": "audio/wav",
+    ".flac": "audio/flac",
     ".pdf": "application/pdf",
     ".png": "image/png",
     ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
@@ -11685,7 +12000,9 @@ function sandboxFileContentType(filename) {
   }[extension] ?? "application/octet-stream";
 }
 function sandboxArtifactIdentity(input) {
-  const digest2 = createHash3("sha256").update("opengeni-sandbox-file-artifact-v1\0").update(input.workspaceId).update("\0").update(input.sessionId).update("\0").update(input.path).update("\0").update(input.sha256).digest("hex");
+  const digest2 = createHash3("sha256").update(
+    /^(audio|video)\//.test(sandboxFileContentType(input.path)) ? "opengeni-sandbox-media-artifact-v1\0" : "opengeni-sandbox-file-artifact-v1\0"
+  ).update(input.workspaceId).update("\0").update(input.sessionId).update("\0").update(input.path).update("\0").update(input.sha256).digest("hex");
   return {
     fileId: uuidFromDigest(digest2, 0),
     uploadId: uuidFromDigest(digest2, 16)
@@ -11704,7 +12021,7 @@ function assertSandboxArtifactFile(file, expected) {
   }
 }
 async function assertVisibleSandboxArtifact(storage, file) {
-  const head = await retryWhileMissing3(async () => await storage.headObject(file.objectKey));
+  const head = await retryWhileMissing4(async () => await storage.headObject(file.objectKey));
   assertStoredSandboxArtifact(head, file);
 }
 function assertStoredSandboxArtifact(head, file) {
@@ -11834,9 +12151,11 @@ import {
   getGlobalCatalogOAuthProfile,
   listConnectionsMetadata,
   loadIntegrationOAuthClient,
+  loadIntegrationOAuthPendingState,
   normalizeBearerScheme,
   replaceIntegrationOAuthClientIfCurrent,
   storeIntegrationOAuthClient,
+  storeIntegrationOAuthPendingState,
   updateConnection,
   withDatabaseStatementTimeout
 } from "@opengeni/db";
@@ -11854,7 +12173,7 @@ import {
   validateHttpUrl
 } from "@opengeni/network";
 import { Buffer as Buffer2 } from "buffer";
-import { createHash as createHash4, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash4, randomBytes as randomBytes4, randomUUID } from "crypto";
 import { HTTPException as HTTPException17 } from "hono/http-exception";
 
 // src/connection-ownership.ts
@@ -12406,7 +12725,7 @@ async function startMcpOAuthWithinDeadline(deps, context, deadline) {
     )
   );
   const key = requireEnvironmentEncryption(settings);
-  const state = createSignedState3(requireIntegrationsStateSecret(settings), {
+  const fullState = createSignedState3(requireIntegrationsStateSecret(settings), {
     ...context.integrationKey ? { integrationKey: context.integrationKey } : {},
     ...context.connectAttemptId ? { connectAttemptId: context.connectAttemptId } : {},
     accountId: context.accountId,
@@ -12448,6 +12767,30 @@ async function startMcpOAuthWithinDeadline(deps, context, deadline) {
     returnPath,
     ...existing ? { connectionId: existing.id, connectionVersion: existing.version } : {}
   });
+  const expiresAt = new Date(Date.now() + oauthStateTtlMs);
+  let state = fullState;
+  if (settings.integrationsOauthShortStateEnabled) {
+    const stateId = randomUUID();
+    state = createSignedState3(requireIntegrationsStateSecret(settings), {
+      kind: "mcp_oauth_reference",
+      id: stateId,
+      accountId: context.accountId,
+      workspaceId: context.workspaceId
+    });
+    if (state.length > 512) {
+      throw new Error("MCP OAuth reference state exceeded its provider-safe length");
+    }
+    await deadline.run(
+      "state_persist",
+      async () => storeIntegrationOAuthPendingState(db, {
+        id: stateId,
+        accountId: context.accountId,
+        workspaceId: context.workspaceId,
+        stateEncrypted: encryptEnvironmentValue3(key, fullState),
+        expiresAt
+      })
+    );
+  }
   const authorizationUrl = buildAuthorizationUrl({
     endpoint: discovery.as.authorizationEndpoint,
     settings,
@@ -12463,7 +12806,7 @@ async function startMcpOAuthWithinDeadline(deps, context, deadline) {
   return OAuthStartResponse.parse({
     state,
     authorizationUrl,
-    expiresAt: new Date(Date.now() + oauthStateTtlMs).toISOString()
+    expiresAt: expiresAt.toISOString()
   });
 }
 function assertOAuthStartProfile(settings, payload, mcpUrl, profile) {
@@ -12519,7 +12862,7 @@ async function completeMcpOAuthCallbackWithinDeadline(deps, input, deadline) {
     };
   }
   try {
-    state = readOAuthState(input.state, settings);
+    state = await resolveMcpOAuthState(db, settings, input.state, deadline);
     integrationKey = state.integrationKey ?? "custom:mcp";
     if (state.connectAttemptId) {
       const stored = await getConnectAttempt2(db, state, state.connectAttemptId);
@@ -13297,6 +13640,33 @@ function buildAuthorizationUrl(input) {
   }
   return url.toString();
 }
+async function resolveMcpOAuthState(db, settings, state, deadline) {
+  const reference = readSignedState4(state, requireIntegrationsStateSecret(settings));
+  if (reference?.kind !== "mcp_oauth_reference") {
+    return readOAuthState(state, settings);
+  }
+  const accountId = requiredString(reference.accountId, "state.accountId");
+  const workspaceId = requiredString(reference.workspaceId, "state.workspaceId");
+  const id = requiredString(reference.id, "state.id");
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id)) {
+    throw new HTTPException17(400, { message: "invalid OAuth state reference" });
+  }
+  const encrypted = await runCallbackDatabaseStage(
+    deadline,
+    "state_verify",
+    db,
+    (scopedDb) => loadIntegrationOAuthPendingState(scopedDb, { accountId, workspaceId, id })
+  );
+  if (!encrypted) {
+    throw new HTTPException17(400, { message: "invalid or expired OAuth state" });
+  }
+  const fullState = decryptEnvironmentValue2(requireEnvironmentEncryption(settings), encrypted);
+  const resolved = readOAuthState(fullState, settings);
+  if (resolved.accountId !== accountId || resolved.workspaceId !== workspaceId) {
+    throw new HTTPException17(400, { message: "OAuth state reference mismatch" });
+  }
+  return resolved;
+}
 function readOAuthState(state, settings) {
   const payload = readSignedState4(state, requireIntegrationsStateSecret(settings));
   if (!payload) {
@@ -13633,6 +14003,8 @@ function oauthStartStageLabel(stage) {
       return "authorization-server discovery";
     case "client_registration":
       return "OAuth client registration";
+    case "state_persist":
+      return "OAuth state persistence";
   }
 }
 function logOAuthVerificationWarning(observability, error, _state) {
@@ -13920,7 +14292,7 @@ function pkceChallenge2(verifier) {
   return createHash4("sha256").update(verifier).digest("base64url");
 }
 function randomPkceVerifier() {
-  return randomBytes3(32).toString("base64url");
+  return randomBytes4(32).toString("base64url");
 }
 function uniqueStrings(values) {
   return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
@@ -13964,7 +14336,7 @@ import {
 import { createSignedState as createSignedState4, readSignedState as readSignedState5 } from "@opengeni/github";
 import { OAUTH_MAX_RESPONSE_BYTES as OAUTH_MAX_RESPONSE_BYTES3, pinnedFetch as pinnedFetch2, readResponseJsonBounded as readResponseJsonBounded2 } from "@opengeni/network";
 import { Buffer as Buffer3 } from "buffer";
-import { createHash as createHash5, randomBytes as randomBytes4 } from "crypto";
+import { createHash as createHash5, randomBytes as randomBytes5 } from "crypto";
 import { HTTPException as HTTPException18 } from "hono/http-exception";
 var SOCIAL_USER_AGENT = "opengeni:social-connector:v0.1.0 (self-hosted)";
 var SOCIAL_TIMEOUT_MS = 1e4;
@@ -14033,7 +14405,7 @@ async function startSocialOAuth(deps, context) {
   const redirectUri = socialOAuthRedirectUri(settings, context.requestUrl);
   const returnPath = safeReturnPath2(context.payload.returnPath ?? "/integrations");
   const scopes = uniqueScopes(context.payload.scopes) ?? provider.defaultScopes;
-  const verifier = provider.pkce ? randomBytes4(32).toString("base64url") : null;
+  const verifier = provider.pkce ? randomBytes5(32).toString("base64url") : null;
   const key = requireEnvironmentEncryption2(settings);
   const state = createSignedState4(requireIntegrationsStateSecret(settings), {
     kind: "social_oauth",
@@ -15772,6 +16144,21 @@ function boundRigDetailMcp(rig, versionsPage, changesPage, maxBytes = RIG_DETAIL
   return result;
 }
 
+// src/mcp/child-read-evidence.ts
+function completeChildReadSequences(page) {
+  if (!page.sourceExact || !["conversation", "results"].includes(page.view)) return [];
+  return page.events.filter((event) => {
+    if (event.sourceOmitted) return false;
+    if (event.fragment === void 0) return true;
+    if (!event.fragment || typeof event.fragment !== "object") return false;
+    const fragment = event.fragment;
+    return fragment.offset === 0 && fragment.complete === true;
+  }).map((event) => event.sequence);
+}
+
+// src/mcp/server.ts
+import { acknowledgeConsumedChildEvents } from "@opengeni/db";
+
 // src/mcp/session-wait.ts
 import {
   SESSION_EVENT_SEMANTIC_CLASS_TYPES,
@@ -16069,6 +16456,7 @@ function summarizeSessionWaitEvent(event, textChars = SUMMARY_TEXT_TIERS[0]) {
   } else if (typeof compact.result === "string" && compact.result !== compact.text) {
     summary.result = clampSummaryString(compact.result, textChars);
   }
+  summary.contentComplete = ["turn.completed", "agent.message.completed"].includes(event.type) && !compact.truncation.truncated && text === compact.text && JSON.stringify(failure) === JSON.stringify(compact.failure) && (compact.output === null || compact.output === compact.text || JSON.stringify(compact.output) === JSON.stringify(summary.result)) && (compact.result === null || compact.result === void 0 || compact.result === compact.text || JSON.stringify(summary.result) === JSON.stringify(compact.result));
   return summary;
 }
 function prettyJsonBytes2(value) {
@@ -16100,6 +16488,7 @@ function boundSessionWaitResult(input, maxBytes = SESSION_EVENT_MCP_MAX_BYTES) {
     ...target,
     events: target.events.map((event) => ({
       ...event,
+      contentComplete: false,
       text: event.text === null ? null : clampSummaryString(event.text, textChars),
       ...typeof event.result === "string" ? { result: clampSummaryString(event.result, textChars) } : {}
     }))
@@ -17543,7 +17932,7 @@ function viewerIdAsUuid(rawViewerId) {
 }
 
 // src/integrations/slack-bot.ts
-import { createHmac as createHmac3, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createHash as createHash7, createHmac as createHmac3, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { environmentsEncryptionKeyBytes as environmentsEncryptionKeyBytes3 } from "@opengeni/config";
 import {
   OPENGENI_SLACK_BOT_CREDENTIAL_LABEL,
@@ -18228,6 +18617,7 @@ var OpenGeniSlackBotClient = class {
       const targetKind = input.userId ? "user" : "channel";
       const targetId = input.userId ?? input.channelId;
       const blocks = validateSlackMessageBlocks(input.blocks);
+      const wireBlocks = slackMessageWireBlocks(blocks);
       const requestDigest = this.postRequestDigest({
         operationId: input.operationId,
         targetKind,
@@ -18309,7 +18699,7 @@ var OpenGeniSlackBotClient = class {
       const posted = await this.call(headers, "chat.postMessage", {
         channel: channelId,
         text: input.text,
-        ...blocks ? { blocks: JSON.stringify(blocks) } : {},
+        ...wireBlocks ? { blocks: JSON.stringify(wireBlocks) } : {},
         client_msg_id: input.operationId,
         unfurl_links: "false",
         unfurl_media: "false",
@@ -18367,6 +18757,7 @@ var OpenGeniSlackBotClient = class {
     let providerCallStarted = false;
     const blocks = validateSlackMessageBlocks(input.blocks);
     try {
+      const wireBlocks = slackMessageWireBlocks(blocks);
       const headers = await this.headersFor(operation);
       await this.requireMemberChannel(headers, input.channelId);
       const requestDigest = this.updateRequestDigest({ ...input, ...blocks ? { blocks } : {} });
@@ -18405,7 +18796,7 @@ var OpenGeniSlackBotClient = class {
         channel: input.channelId,
         ts: input.timestamp,
         text: input.text,
-        ...blocks ? { blocks: JSON.stringify(blocks) } : {}
+        ...wireBlocks ? { blocks: JSON.stringify(wireBlocks) } : {}
       });
       const slackChannelId = requiredSlackString(updated.channel, "channel");
       const slackMessageTimestamp = requiredSlackString(updated.ts, "ts");
@@ -19713,6 +20104,20 @@ function nextSlackFilesListPage(payload, requested, returnedFileCount) {
   }
   return nextPage;
 }
+function slackMessageWireBlocks(blocks) {
+  if (!blocks) return void 0;
+  const wire = blocks.flatMap((block, index) => {
+    if (block.type !== "actions" || new Set(block.elements.map((e) => e.action_id)).size === block.elements.length)
+      return [block];
+    const id = createHash7("sha256").update(`${index}:${block.block_id}`).digest("hex").slice(0, 24);
+    return block.elements.map((element, position2) => ({
+      type: "actions",
+      block_id: `opengeni_wire_${id}_${position2}`,
+      elements: [element]
+    }));
+  });
+  return validateSlackMessageBlocks(wire);
+}
 function validateSlackMessageBlocks(blocks) {
   if (blocks === void 0) return void 0;
   if (blocks.length < 1 || blocks.length > MAX_SLACK_BLOCKS) {
@@ -19778,7 +20183,7 @@ function slackMutationOutcomeMayBeAmbiguous(error) {
 
 // src/integrations/fiken.ts
 import { withOrganizationIntegrationAcquisition as withOrganizationIntegrationAcquisition3 } from "@opengeni/db/organization-integration-policy";
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { ExternalActorContinuation as ExternalActorContinuation3 } from "@opengeni/contracts/external-identities";
 import { requireConnectOwnerAuthority as requireConnectOwnerAuthority2 } from "@opengeni/core";
 import {
@@ -20599,7 +21004,7 @@ async function completeFikenOAuthCallback(deps, input) {
       operation = {
         attemptId: state.connectAttemptId,
         operationId: `oauth:${state.nonce}`,
-        inputDigest: createHash7("sha256").update(input.state).digest("hex")
+        inputDigest: createHash8("sha256").update(input.state).digest("hex")
       };
       const claim = await claimOAuthAcquisition(
         deps.db,
@@ -20906,7 +21311,7 @@ import {
   knowledgeSourceAgentConfig,
   assertOrganizationIntegrationAllowed as assertOrganizationIntegrationAllowed2
 } from "@opengeni/contracts";
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import { ExternalActorContinuation as ExternalActorContinuation4 } from "@opengeni/contracts/external-identities";
 import {
   ATLASSIAN_CREDENTIAL_LABEL,
@@ -21032,7 +21437,7 @@ async function completeAtlassianOAuthCallback(deps, input) {
       operation = {
         attemptId: state.connectAttemptId,
         operationId: `oauth:${state.nonce}`,
-        inputDigest: createHash8("sha256").update(input.state).digest("hex")
+        inputDigest: createHash9("sha256").update(input.state).digest("hex")
       };
       const claim = await claimOAuthAcquisition(
         deps.db,
@@ -22466,7 +22871,7 @@ function adfText(value) {
 import { AtlassianConnectionMetadata as AtlassianConnectionMetadata2 } from "@opengeni/contracts/atlassian";
 
 // src/mcp/editable-artifacts.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import {
   editableArtifactClientTransactionId as editableArtifactClientTransactionId2,
   editableArtifactId as editableArtifactId2
@@ -22889,7 +23294,7 @@ function registerEditableArtifactAgentTools(input) {
 }
 function artifactAttemptContext(grant, sessionId, toolName, extra) {
   const operationId = trustedOperationId(extra);
-  const digest2 = createHash9("sha256").update("opengeni:editable-artifact-agent-call:v1\0", "utf8").update(grant.accountId, "utf8").update("\0", "utf8").update(grant.workspaceId, "utf8").update("\0", "utf8").update(sessionId, "utf8").update("\0", "utf8").update(String(grant.metadata?.["turnId"] ?? ""), "utf8").update("\0", "utf8").update(String(grant.metadata?.["attemptId"] ?? ""), "utf8").update("\0", "utf8").update(String(grant.metadata?.["executionGeneration"] ?? ""), "utf8").update("\0", "utf8").update(toolName, "utf8").update("\0", "utf8").update(operationId, "utf8").digest("hex");
+  const digest2 = createHash10("sha256").update("opengeni:editable-artifact-agent-call:v1\0", "utf8").update(grant.accountId, "utf8").update("\0", "utf8").update(grant.workspaceId, "utf8").update("\0", "utf8").update(sessionId, "utf8").update("\0", "utf8").update(String(grant.metadata?.["turnId"] ?? ""), "utf8").update("\0", "utf8").update(String(grant.metadata?.["attemptId"] ?? ""), "utf8").update("\0", "utf8").update(String(grant.metadata?.["executionGeneration"] ?? ""), "utf8").update("\0", "utf8").update(toolName, "utf8").update("\0", "utf8").update(operationId, "utf8").digest("hex");
   const replicaId = digest2.slice(0, 16) === "0".repeat(16) ? `1${digest2.slice(1, 16)}` : digest2.slice(0, 16);
   const actor = editableArtifactActorForGrant(grant, replicaId);
   if (actor.kind !== "agent" || actor.sessionId !== sessionId) {
@@ -23095,7 +23500,7 @@ import {
   knowledgeSourceAgentConfig as knowledgeSourceAgentConfig2,
   assertOrganizationIntegrationAllowed as assertOrganizationIntegrationAllowed3
 } from "@opengeni/contracts";
-import { createHash as createHash10, randomBytes as randomBytes5 } from "crypto";
+import { createHash as createHash11, randomBytes as randomBytes6 } from "crypto";
 import { ExternalActorContinuation as ExternalActorContinuation5 } from "@opengeni/contracts/external-identities";
 import {
   configuredGoogleDriveSyncLimits,
@@ -23216,7 +23621,7 @@ async function startGoogleDriveOAuth(deps, input) {
     requireGoogleDriveConnection(existing, input.subjectId);
   }
   const key = requireEnvironmentEncryption5(deps.settings);
-  const verifier = randomBytes5(48).toString("base64url");
+  const verifier = randomBytes6(48).toString("base64url");
   const redirectUri = requireGoogleDriveOAuthCallbackUrl(deps.settings);
   const state = createSignedState7(requireIntegrationsStateSecret(deps.settings), {
     accountId: input.accountId,
@@ -23262,7 +23667,7 @@ async function startGoogleDriveOAuth(deps, input) {
   authorizationUrl.searchParams.set("code_challenge_method", "S256");
   authorizationUrl.searchParams.set(
     "code_challenge",
-    createHash10("sha256").update(verifier).digest("base64url")
+    createHash11("sha256").update(verifier).digest("base64url")
   );
   return GoogleDriveOAuthStartResponse.parse({
     authorizationUrl: authorizationUrl.toString(),
@@ -23286,7 +23691,7 @@ async function completeGoogleDriveOAuthCallback(deps, input) {
       operation = {
         attemptId: state.connectAttemptId,
         operationId: `oauth:${state.nonce}`,
-        inputDigest: createHash10("sha256").update(input.state).digest("hex")
+        inputDigest: createHash11("sha256").update(input.state).digest("hex")
       };
       const claim = await claimOAuthAcquisition(
         deps.db,
@@ -25206,7 +25611,7 @@ function uniqueStrings3(values) {
 }
 
 // src/temporal-schedule-cleanup.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import {
   claimTemporalScheduleCleanups,
   completeTemporalScheduleConnectorCleanup,
@@ -25278,7 +25683,7 @@ async function processTemporalScheduleCleanupClaims(deps, claims) {
 }
 async function drainTemporalScheduleCleanupOutbox(deps) {
   const claims = await claimTemporalScheduleCleanups(deps.db, {
-    claimId: randomUUID(),
+    claimId: randomUUID2(),
     limit: CLEANUP_BATCH_SIZE,
     claimSeconds: CLEANUP_CLAIM_SECONDS
   });
@@ -26627,7 +27032,7 @@ function registerSandboxFileArtifactTool(server, deps, grant, sessionId, json) {
   server.registerTool(
     "sandbox_file_publish",
     {
-      description: "Publish one exact file from this session's /workspace into durable workspace storage. Use this before presenting a ZIP, CSV, JSON, Markdown, HTML, PDF, Office file, or other sandbox output as downloadable. Returns a permanent, authenticated artifact receipt; never invent or expose a sandbox: URL as the durable result.",
+      description: "Publish one exact file from this session's /workspace into durable workspace storage. Use this before presenting a video, ZIP, CSV, JSON, Markdown, HTML, PDF, Office file, or other sandbox output as downloadable. Present the returned artifact.artifactId as [Open file](artifact:<artifactId>), or ![Preview](artifact:<artifactId>) for inline image/video/audio/PDF previews. Replace <artifactId> with the exact returned ID and use a descriptive label. Never expose a sandbox: URL as the durable result.",
       inputSchema: {
         path: z43.string().min(1).max(4096)
       }
@@ -27369,7 +27774,7 @@ function registerGoalTools(server, deps, grant, sessionId, json) {
     async ({ reason, timeoutSeconds, idempotencyKey }) => {
       await authorizeFirstPartySession(deps, grant, sessionId, "session.control");
       const context = exactAgentCommandContext(grant, sessionId);
-      const operationKey = idempotencyKey ?? `wait-for-input:${context.callerTurnId}:${createHash11("sha256").update(JSON.stringify({ reason, timeoutSeconds })).digest("hex").slice(0, 32)}`;
+      const operationKey = idempotencyKey ?? `wait-for-input:${context.callerTurnId}:${createHash12("sha256").update(JSON.stringify({ reason, timeoutSeconds })).digest("hex").slice(0, 32)}`;
       const { events, operationId, replay, deadlineAt } = await waitForSessionInputWithEvent(
         deps.db,
         grant.workspaceId,
@@ -27610,7 +28015,7 @@ function registerWorkspaceArtifactTools(server, deps, grant, sessionId, json) {
     return {
       accountId: grant.accountId,
       workspaceId: grant.workspaceId,
-      operationKey: `attempt:${createHash11("sha256").update(`${claims.sessionId}:${claims.turnId}:${idempotencyKey}`).digest("hex")}`,
+      operationKey: `attempt:${createHash12("sha256").update(`${claims.sessionId}:${claims.turnId}:${idempotencyKey}`).digest("hex")}`,
       actorSubjectId: grant.subjectId,
       sourceSessionId: claims.sessionId,
       sourceTurnId: claims.turnId,
@@ -28300,7 +28705,7 @@ function registerFleetTools(server, deps, grant, sessionId, json) {
   server.registerTool(
     "sandbox_provision",
     {
-      description: "Provision a new sandbox for the fleet. kind=selfhosted returns device-flow enrollment instructions to share with a HUMAN (install the agent + enroll their machine with loud whole-machine consent \u2014 the agent cannot self-consent). kind=modal creates a named Modal sandbox record, but it is NOT yet attachable as a swap target: routing a session onto a second Modal box is not supported yet, so sandbox_swap to its id is rejected. Use the session's own box (the default) or attach a Connected Machine instead.",
+      description: "Provision a new sandbox for the fleet. kind=selfhosted returns interactive device-flow instructions for a human to approve. For authorized headless enrollment, use connected_machine_enroll_token when available instead. kind=modal creates a named Modal sandbox record, but it is NOT yet attachable as a swap target: routing a session onto a second Modal box is not supported yet, so sandbox_swap to its id is rejected. Use the session's own box (the default) or attach a Connected Machine instead.",
       inputSchema: {
         kind: z43.enum(["selfhosted", "modal"]),
         name: z43.string().min(1).max(120).optional()
@@ -28315,10 +28720,38 @@ function registerFleetTools(server, deps, grant, sessionId, json) {
   );
 }
 function registerConnectedMachineTools(server, deps, grant, sessionId, json) {
+  server.registerTool(
+    "connected_machine_enroll_token",
+    {
+      description: "Create a short-lived Connected Machine enrollment token for this workspace using existing enrollments:manage authority. Returns the token, expiry and Unix/PowerShell install commands. Run the appropriate command on the intended machine through an already-authorized execution path, then verify it with sandboxes_list. No separate device approval is required. Screen control is optional and defaults off. The token grants whole-machine access on enrollment; do not put it in public code or unrelated logs. Existing machine connections are preserved.",
+      inputSchema: { allowScreenControl: z43.boolean().optional() }
+    },
+    async ({ allowScreenControl }) => {
+      if (sessionId) {
+        await authorizeFirstPartySession(deps, grant, sessionId, "session.first_party_mcp.call");
+      }
+      const minted = await mintEnrollToken(deps, {
+        accountId: grant.accountId,
+        workspaceId: grant.workspaceId,
+        allowScreenControl: allowScreenControl ?? false
+      });
+      if (!minted) throw new Error("enrollment credential plane is not configured");
+      const base = (deps.settings.publicBaseUrl ?? "https://app.opengeni.ai").replace(/\/+$/, "");
+      const unixQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+      const windowsQuote = (value) => `'${value.replaceAll("'", "''")}'`;
+      return json({
+        ...minted,
+        workspaceId: grant.workspaceId,
+        allowScreenControl: allowScreenControl ?? false,
+        installCommandUnix: `curl -fsSL ${unixQuote(`${base}/install.sh`)} | OPENGENI_API_URL=${unixQuote(base)} OPENGENI_ENROLL_TOKEN=${unixQuote(minted.token)} sh`,
+        installCommandWindows: `$env:OPENGENI_API_URL=${windowsQuote(base)}; $env:OPENGENI_ENROLL_TOKEN=${windowsQuote(minted.token)}; irm ${windowsQuote(`${base}/install.ps1`)} | iex`
+      });
+    }
+  );
   server.registerTool(
     "connected_machine_remove",
     {
-      description: "Remove one enrolled self-hosted machine while it is offline. Access is revoked, future heartbeat/reconnect credentials are rejected, and session, route, lease, archive, and audit history is retained. Idle dependent sessions are detached atomically; machine-home sessions become compute-less (backend none) until another sandbox is selected. Active turns, live leases, and recovery work remain fail-closed blockers whose typed outcome explains what must settle before retrying. Pass the enrollmentId from the Machines surface, never a Modal sandbox id. Reconnecting later requires a fresh human-approved device-flow enrollment.",
+      description: "Remove one enrolled self-hosted machine while it is offline. Access is revoked, future heartbeat/reconnect credentials are rejected, and session, route, lease, archive, and audit history is retained. Idle dependent sessions are detached atomically; machine-home sessions become compute-less (backend none) until another sandbox is selected. Active turns, live leases, and recovery work remain fail-closed blockers whose typed outcome explains what must settle before retrying. Pass the enrollmentId from the Machines surface, never a Modal sandbox id. Reconnecting later requires fresh enrollment through device approval or an authorized enrollment token.",
       inputSchema: {
         enrollmentId: z43.string().uuid(),
         expectedUpdatedAt: z43.string().datetime({ offset: true }).optional(),
@@ -28343,7 +28776,7 @@ function registerConnectedMachineTools(server, deps, grant, sessionId, json) {
         accountId: grant.accountId,
         workspaceId: enrollment.workspaceId,
         enrollmentId,
-        operationKey: idempotencyKey?.trim() || randomUUID2(),
+        operationKey: idempotencyKey?.trim() || randomUUID3(),
         ...expectedUpdatedAt ? { expectedUpdatedAt } : {},
         subjectId: resourceGrant.subjectId
       });
@@ -28671,6 +29104,18 @@ function exactAgentCommandContext(grant, callerSessionId, authorizationSurface)
   };
 }
 function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSessionId, sessionCreateVisible, json) {
+  const acknowledgeReads = async (children) => {
+    if (!callerSessionId || !exactAgentAttemptClaims(grant) || !children.some((child) => child.sequences.length > 0))
+      return;
+    const actor = await requireLiveAgentAttemptAuthorization4(deps.db, grant, callerSessionId);
+    if (!actor.initiatingHumanSubjectId) return;
+    await acknowledgeConsumedChildEvents(deps.db, {
+      workspaceId: grant.workspaceId,
+      sessionId: callerSessionId,
+      subjectId: actor.initiatingHumanSubjectId,
+      children
+    });
+  };
   if (can("sessions:read")) {
     server.registerTool(
       "sessions_list",
@@ -28965,29 +29410,29 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
         if (view !== "debug" && !auditRequested) {
           const { readSessionEventView } = await import("./session-event-view-MU3HMNV3.js");
           const { listSessionEventSlices } = await import("@opengeni/db/session-event-slices");
-          return json(
-            await readSessionEventView(
-              {
-                sessionId,
-                view,
-                cursor,
-                callId,
-                includeArguments,
-                includeOutput,
-                after,
-                before,
-                direction: requestedDirection,
-                limit
-              },
-              (options) => listSessionEventSlices(
-                deps.db,
-                grant.workspaceId,
-                sessionId,
-                options,
-                (legacyOptions) => listSessionEventPage(deps.db, grant.workspaceId, sessionId, legacyOptions)
-              )
+          const page2 = await readSessionEventView(
+            {
+              sessionId,
+              view,
+              cursor,
+              callId,
+              includeArguments,
+              includeOutput,
+              after,
+              before,
+              direction: requestedDirection,
+              limit
+            },
+            (options) => listSessionEventSlices(
+              deps.db,
+              grant.workspaceId,
+              sessionId,
+              options,
+              (legacyOptions) => listSessionEventPage(deps.db, grant.workspaceId, sessionId, legacyOptions)
             )
           );
+          await acknowledgeReads([{ sessionId, sequences: completeChildReadSequences(page2) }]);
+          return json(page2);
         }
         if (cursor !== void 0 || callId !== void 0 || includeArguments !== void 0 || includeOutput !== void 0) {
           throw new Error("cursor/callId/includeArguments/includeOutput require a non-debug view");
@@ -29017,31 +29462,37 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
         });
         if (requestedResultMode === "compact") {
           const event = dbPage.events[0];
-          return json(
-            event ? boundSessionEventCompactResult(
-              compactSessionEventResult2(
-                event,
-                latestClass,
-                dbPage.coveredSequence ?? {
-                  first: event.sequence,
-                  last: event.sequence
-                }
-              )
-            ) : null
-          );
+          const result = event ? boundSessionEventCompactResult(
+            compactSessionEventResult2(
+              event,
+              latestClass,
+              dbPage.coveredSequence ?? {
+                first: event.sequence,
+                last: event.sequence
+              }
+            )
+          ) : null;
+          if (result && ["turn.completed", "agent.message.completed"].includes(result.type) && !result.truncation.truncated && dbPage.fullPayloadsExact) {
+            await acknowledgeReads([{ sessionId, sequences: [result.sequence] }]);
+          }
+          return json(result);
         }
-        return json(
-          boundSessionEventMcpPage({
-            events: dbPage.events,
-            mode,
-            payloadMode,
-            direction,
-            sourceHasMore: dbPage.hasMore,
-            sourceTruncatedBy: dbPage.truncatedBy,
-            after: after ?? 0,
-            before: before ?? null
-          })
-        );
+        const page = boundSessionEventMcpPage({
+          events: dbPage.events,
+          mode,
+          payloadMode,
+          direction,
+          sourceHasMore: dbPage.hasMore,
+          sourceTruncatedBy: dbPage.truncatedBy,
+          after: after ?? 0,
+          before: before ?? null
+        });
+        if (payloadMode === "full" && dbPage.fullPayloadsExact && !page.truncation?.reasons.includes("model_payload")) {
+          await acknowledgeReads([
+            { sessionId, sequences: page.events.map((event) => event.sequence) }
+          ]);
+        }
+        return json(page);
       }
     );
     server.registerTool(
@@ -29077,45 +29528,52 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
         const targetEventTypes = waitFor === "completion" ? SESSION_WAIT_COMPLETION_EVENT_TYPES : SESSION_WAIT_EVENT_TYPES;
         const signal = extra?.signal;
         const workspaceId = grant.workspaceId;
-        return json(
-          await waitForSessionChanges({
-            targets,
-            ownSessionId,
-            maxWaitMs: (maxWaitSeconds ?? SESSION_WAIT_DEFAULT_SECONDS) * 1e3,
-            targetEventTypes,
-            targetEventMatches: waitFor === "completion" ? sessionWaitCompletionEventMatches : void 0,
-            signal,
-            source: {
-              reauthorizeTargets: async (sessionIds) => {
-                for (const targetSessionId of sessionIds) {
-                  await authorizeFirstPartySession(
-                    deps,
-                    grant,
-                    targetSessionId,
-                    "session.events.read"
-                  );
-                }
-              },
-              readTargetEvents: async (target) => {
-                const page = await listSessionEventPage(deps.db, workspaceId, target.sessionId, {
-                  after: target.afterSequence,
-                  direction: "after",
-                  limit: SESSION_WAIT_EVENTS_PER_TARGET,
-                  payloadMode: "full",
-                  includeTypes: targetEventTypes,
-                  maxBytes: SESSION_EVENT_MCP_MAX_BYTES * 4
-                });
-                return { events: page.events, hasMore: page.hasMore };
-              },
-              readOwnPendingUpdateKinds: ownSessionId === null ? null : async () => (await listOutstandingSessionSystemUpdates(
-                deps.db,
-                workspaceId,
-                ownSessionId
-              )).map((update) => update.kind),
-              subscribe: (targetSessionId, onEvents) => deps.bus.subscribe(workspaceId, targetSessionId, onEvents)
-            }
-          })
-        );
+        const incompleteWaitEvents = /* @__PURE__ */ new Set();
+        const result = await waitForSessionChanges({
+          targets,
+          ownSessionId,
+          maxWaitMs: (maxWaitSeconds ?? SESSION_WAIT_DEFAULT_SECONDS) * 1e3,
+          targetEventTypes,
+          targetEventMatches: waitFor === "completion" ? sessionWaitCompletionEventMatches : void 0,
+          signal,
+          source: {
+            reauthorizeTargets: async (sessionIds) => {
+              for (const targetSessionId of sessionIds) {
+                await authorizeFirstPartySession(
+                  deps,
+                  grant,
+                  targetSessionId,
+                  "session.events.read"
+                );
+              }
+            },
+            readTargetEvents: async (target) => {
+              const page = await listSessionEventPage(deps.db, workspaceId, target.sessionId, {
+                after: target.afterSequence,
+                direction: "after",
+                limit: SESSION_WAIT_EVENTS_PER_TARGET,
+                payloadMode: "full",
+                includeTypes: targetEventTypes,
+                maxBytes: SESSION_EVENT_MCP_MAX_BYTES * 4
+              });
+              if (!page.fullPayloadsExact) {
+                for (const event of page.events) incompleteWaitEvents.add(event.id);
+              }
+              return { events: page.events, hasMore: page.hasMore };
+            },
+            readOwnPendingUpdateKinds: ownSessionId === null ? null : async () => (await listOutstandingSessionSystemUpdates(deps.db, workspaceId, ownSessionId)).map((update) => update.kind),
+            subscribe: (targetSessionId, onEvents) => deps.bus.subscribe(workspaceId, targetSessionId, onEvents)
+          }
+        });
+        if (!result.aborted && !result.truncated) {
+          await acknowledgeReads(
+            result.changed.map((target) => ({
+              sessionId: target.sessionId,
+              sequences: target.events.filter((event) => event.contentComplete && !incompleteWaitEvents.has(event.id)).map((event) => event.sequence)
+            }))
+          );
+        }
+        return json(result);
       }
     );
     if (callerSessionId !== null) {
@@ -60552,7 +61010,7 @@ function registerOrganizationIntegrationPolicyRoutes(app, deps) {
 }
 
 // src/routes/connections.ts
-import { createHash as createHash14, createHmac as createHmac4 } from "crypto";
+import { createHash as createHash15, createHmac as createHmac4 } from "crypto";
 import {
   createConnectionIdempotently,
   getConnectionCreationResult,
@@ -60721,7 +61179,7 @@ import { HTTPException as HTTPException35 } from "hono/http-exception";
 // src/integrations/provider-oauth.ts
 import { withOrganizationIntegrationAcquisition as withOrganizationIntegrationAcquisition6 } from "@opengeni/db/organization-integration-policy";
 import { Buffer as Buffer4 } from "buffer";
-import { createHash as createHash12, randomBytes as randomBytes6 } from "crypto";
+import { createHash as createHash13, randomBytes as randomBytes7 } from "crypto";
 import {
   integrationDefinitionProviderDomain as integrationDefinitionProviderDomain2,
   integrationDefinitionById
@@ -60804,7 +61262,7 @@ async function startApiIntegrationProviderOAuth(deps, input) {
     ...definition.authentication.scopes
   ]);
   const client = providerClientForDefinition(deps.settings, definition);
-  const verifier = randomBytes6(48).toString("base64url");
+  const verifier = randomBytes7(48).toString("base64url");
   const key = requireEnvironmentEncryption8(deps.settings);
   const baseUrl = integrationBaseUrl(deps.settings.publicBaseUrl, input.requestUrl);
   const redirectUri = `${baseUrl}${providerOAuthCallbackPath(definition)}`;
@@ -60849,7 +61307,7 @@ async function startApiIntegrationProviderOAuth(deps, input) {
   authorizationUrl.searchParams.set("code_challenge_method", "S256");
   authorizationUrl.searchParams.set(
     "code_challenge",
-    createHash12("sha256").update(verifier).digest("base64url")
+    createHash13("sha256").update(verifier).digest("base64url")
   );
   authorizationUrl.searchParams.set("prompt", "select_account");
   if (definition.provider.id === "google") {
@@ -60879,7 +61337,7 @@ async function completeApiIntegrationProviderOAuth(deps, input) {
       connectOperation = {
         attemptId: state.connectAttemptId,
         operationId: `oauth:${state.nonce}`,
-        inputDigest: createHash12("sha256").update(input.state).digest("hex")
+        inputDigest: createHash13("sha256").update(input.state).digest("hex")
       };
       const claim = await claimOAuthAcquisition(
         deps.db,
@@ -61172,7 +61630,7 @@ function providerClientKeys(definition) {
   ]);
 }
 function providerDefinitionFingerprint(definition) {
-  return createHash12("sha256").update(
+  return createHash13("sha256").update(
     JSON.stringify({
       id: definition.id,
       provider: definition.provider,
@@ -61425,7 +61883,7 @@ function numberValue4(value) {
 
 // src/integrations/personal-github.ts
 import { withOrganizationIntegrationAcquisition as withOrganizationIntegrationAcquisition7 } from "@opengeni/db/organization-integration-policy";
-import { createHash as createHash13, randomBytes as randomBytes7, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash14, randomBytes as randomBytes8, randomUUID as randomUUID4 } from "crypto";
 import { ExternalActorContinuation as ExternalActorContinuation8 } from "@opengeni/contracts/external-identities";
 import { personalGitHubOAuthCallbackUrl } from "@opengeni/config";
 import {
@@ -61472,7 +61930,7 @@ var PersonalGitHubCallbackError = class extends Error {
   }
 };
 function personalGitHubClientMarker(clientId) {
-  return createHash13("sha256").update(clientId).digest("hex").slice(0, 32);
+  return createHash14("sha256").update(clientId).digest("hex").slice(0, 32);
 }
 function requirePersonalGitHubOAuthSettings(settings) {
   if (!settings.githubPersonalOauthEnabled) {
@@ -61555,7 +62013,7 @@ async function startPersonalGitHubOAuth(deps, input) {
     });
   }
   const key = requireEnvironmentEncryption9(deps.settings);
-  const verifier = randomBytes7(48).toString("base64url");
+  const verifier = randomBytes8(48).toString("base64url");
   const returnPath = personalGitHubReturnPath(input.workspaceId, input.returnPath);
   const state = createSignedState11(requireIntegrationsStateSecret(deps.settings), {
     accountId: grant.accountId,
@@ -61584,7 +62042,7 @@ async function startPersonalGitHubOAuth(deps, input) {
   authorizationUrl.searchParams.set("state", state);
   authorizationUrl.searchParams.set(
     "code_challenge",
-    createHash13("sha256").update(verifier).digest("base64url")
+    createHash14("sha256").update(verifier).digest("base64url")
   );
   authorizationUrl.searchParams.set("code_challenge_method", "S256");
   return PersonalGitHubOAuthStartResponse.parse({
@@ -61608,7 +62066,7 @@ async function completePersonalGitHubOAuthCallback(deps, input) {
       operation = {
         attemptId: state.connectAttemptId,
         operationId: `oauth:${state.nonce}`,
-        inputDigest: createHash13("sha256").update(input.state).digest("hex")
+        inputDigest: createHash14("sha256").update(input.state).digest("hex")
       };
       const claim = await claimOAuthAcquisition(
         deps.db,
@@ -61710,7 +62168,7 @@ async function completePersonalGitHubOAuthCallback(deps, input) {
       githubLogin: identity2.login,
       oauthEnvironment: oauth.oauthEnvironment,
       oauthClientMarker: oauth.oauthClientMarker,
-      credentialBindingId: requestedMetadata?.credentialBindingId ?? randomUUID3(),
+      credentialBindingId: requestedMetadata?.credentialBindingId ?? randomUUID4(),
       connectedAt: requestedMetadata?.connectedAt ?? now,
       lastVerifiedAt: now,
       disconnectedAt: null,
@@ -62255,7 +62713,7 @@ function registerConnectionRoutes(app, deps) {
         operation = {
           attemptId: state.connectAttemptId,
           operationId: `oauth:${state.nonce}`,
-          inputDigest: createHash14("sha256").update(c.req.query("state")).digest("hex")
+          inputDigest: createHash15("sha256").update(c.req.query("state")).digest("hex")
         };
         const callbackState = state;
         const callbackOperation = operation;
@@ -62414,7 +62872,7 @@ function registerConnectionRoutes(app, deps) {
             accountId: state.accountId,
             workspaceId: state.workspaceId,
             subjectId: state.subjectId,
-            callbackDigest: createHash14("sha256").update(state.nonce).digest("hex"),
+            callbackDigest: createHash15("sha256").update(state.nonce).digest("hex"),
             installMode: state.connectionId ? "reinstall" : "connect",
             ...failure
           });
@@ -63445,7 +63903,7 @@ function slackBotCredentialBundle(token) {
 }
 
 // src/routes/connect.ts
-import { createHash as createHash17, createHmac as createHmac5, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash18, createHmac as createHmac5, randomUUID as randomUUID5 } from "crypto";
 import { HTTPException as HTTPException39 } from "hono/http-exception";
 import { getConnectBeginReplay } from "@opengeni/db/connect-attempts";
 import {
@@ -63496,7 +63954,7 @@ import {
 } from "@opengeni/core";
 
 // src/integrations/github-app-connect.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { z as z19 } from "zod";
 import { HTTPException as HTTPException37 } from "hono/http-exception";
 import {
@@ -63705,7 +64163,7 @@ async function completeGitHubAppConnect(deps, input) {
     const operation = {
       attemptId: state.connectAttemptId,
       operationId: `github:${state.nonce}`,
-      inputDigest: createHash15("sha256").update(input.state).digest("hex"),
+      inputDigest: createHash16("sha256").update(input.state).digest("hex"),
       authorize
     };
     const claim = await claimOAuthAcquisition(
@@ -63956,7 +64414,7 @@ import {
 import { HTTPException as HTTPException38 } from "hono/http-exception";
 
 // src/integrations/api-integrations.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import {
   compileGraphqlRevision,
   compileOpenApiRevision,
@@ -64175,7 +64633,7 @@ function resolvedPreview(input) {
   };
 }
 function integrationInstallationIdentity(protocol, label, locator2) {
-  const hash = createHash16("sha256").update(`${protocol}\0${locator2}`).digest("hex").slice(0, 12);
+  const hash = createHash17("sha256").update(`${protocol}\0${locator2}`).digest("hex").slice(0, 12);
   const slug = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "integration";
   return {
     sourceDerivedDefinitionId: `${slug}-${hash}`,
@@ -65000,7 +65458,7 @@ function registerConnectRoutes(app, deps) {
           attemptId: before.id,
           expectedRevision: input.expectedRevision,
           operationId: input.idempotencyKey,
-          inputDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+          inputDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
           authorize: (tx, _attempt, origin) => requireConnectOwnerAuthority(tx, scope, "capabilities:manage", origin),
           execute: async (attempt) => {
             if (attempt.state !== "credential_input")
@@ -65042,7 +65500,7 @@ function registerConnectRoutes(app, deps) {
           attemptId: before.id,
           expectedRevision: input.expectedRevision,
           operationId: input.idempotencyKey,
-          inputDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+          inputDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
           authorize: async (tx, _attempt, origin) => {
             await requireConnectOwnerAuthority(tx, scope, installationPermission, origin);
             if (before.providerId === "github-lens") {
@@ -65068,7 +65526,7 @@ function registerConnectRoutes(app, deps) {
           attemptId: before.id,
           expectedRevision: input.expectedRevision,
           operationId: input.idempotencyKey,
-          inputDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+          inputDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
           authorize: (tx, _attempt, origin) => requireConnectOwnerAuthority(tx, scope, "connections:write", origin),
           execute: async (attempt) => {
             if (attempt.state !== "credential_input")
@@ -65367,7 +65825,7 @@ function registerConnectRoutes(app, deps) {
         attemptId: c.req.param("attemptId"),
         expectedRevision: input.expectedRevision,
         operationId: input.idempotencyKey,
-        inputDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+        inputDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
         authorize: (tx, _attempt, origin) => requireConnectOwnerAuthority(tx, scope, permission, origin),
         execute: async (attempt) => {
           if (!attempt.source && (!attempt.credentialsCommitted || !attempt.account) || !["connected_but_incomplete", "preview"].includes(attempt.state))
@@ -65475,7 +65933,7 @@ function registerConnectRoutes(app, deps) {
         attemptId: c.req.param("attemptId"),
         expectedRevision: input.expectedRevision,
         operationId: input.idempotencyKey,
-        inputDigest: createHash17("sha256").update(stableJson4({ ...input, action: "cancel" })).digest("hex"),
+        inputDigest: createHash18("sha256").update(stableJson4({ ...input, action: "cancel" })).digest("hex"),
         purpose: "cancellation",
         authorize: async (tx, attempt, origin) => {
           const permission = attempt.providerId === "mcp-install" ? "capabilities:manage" : ["x", "reddit"].includes(attempt.providerId) ? attempt.ownership === "workspace" ? "workspace:admin" : "workspace:read" : attempt.providerId === "github-app" ? "github:manage" : attempt.providerId === "github-lens" ? "workspace:admin" : "connections:write";
@@ -65540,7 +65998,7 @@ function registerConnectRoutes(app, deps) {
               await requireConnectOwnerAuthority(actorTx, scope, setupPermission);
               const replay2 = await getConnectBeginReplay(actorTx, scope, {
                 idempotencyKey: input.idempotencyKey,
-                requestDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+                requestDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
                 returnUrl: input.returnUrl,
                 ...continuation ? { externalContinuation: continuation } : {}
               });
@@ -65574,7 +66032,7 @@ function registerConnectRoutes(app, deps) {
             }
           );
         });
-        const id = randomUUID4();
+        const id = randomUUID5();
         if (input.providerId === "mcp-install") {
           if (input.ownership !== "workspace" || input.reconnectAccountId || input.installationTarget)
             throw new HTTPException39(422, {
@@ -65596,7 +66054,7 @@ function registerConnectRoutes(app, deps) {
           return beginConnectAttempt(tx, scope, {
             ...continuation ? { externalContinuation: continuation } : {},
             idempotencyKey: input.idempotencyKey,
-            requestDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+            requestDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
             returnUrl: input.returnUrl,
             attempt: {
               id,
@@ -65654,7 +66112,7 @@ function registerConnectRoutes(app, deps) {
           return beginConnectAttempt(tx, scope, {
             ...continuation ? { externalContinuation: continuation } : {},
             idempotencyKey: input.idempotencyKey,
-            requestDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+            requestDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
             returnUrl: input.returnUrl,
             attempt: {
               id,
@@ -65704,7 +66162,7 @@ function registerConnectRoutes(app, deps) {
           return beginConnectAttempt(tx, scope, {
             ...continuation ? { externalContinuation: continuation } : {},
             idempotencyKey: input.idempotencyKey,
-            requestDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+            requestDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
             returnUrl: input.returnUrl,
             attempt: {
               id,
@@ -65739,7 +66197,7 @@ function registerConnectRoutes(app, deps) {
           return beginConnectAttempt(tx, scope, {
             ...continuation ? { externalContinuation: continuation } : {},
             idempotencyKey: input.idempotencyKey,
-            requestDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+            requestDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
             returnUrl: input.returnUrl,
             attempt: {
               id,
@@ -65820,7 +66278,7 @@ function registerConnectRoutes(app, deps) {
           return beginConnectAttempt(tx, scope, {
             ...continuation ? { externalContinuation: continuation } : {},
             idempotencyKey: input.idempotencyKey,
-            requestDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+            requestDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
             returnUrl: input.returnUrl,
             attempt: {
               id,
@@ -65958,7 +66416,7 @@ function registerConnectRoutes(app, deps) {
         return beginConnectAttempt(tx, scope, {
           ...continuation ? { externalContinuation: continuation } : {},
           idempotencyKey: input.idempotencyKey,
-          requestDigest: createHash17("sha256").update(stableJson4(input)).digest("hex"),
+          requestDigest: createHash18("sha256").update(stableJson4(input)).digest("hex"),
           returnUrl: input.returnUrl,
           attempt: {
             id,
@@ -67015,7 +67473,7 @@ function requireOrganizationDocumentAuthority(authorityKind, organizationAuthori
 }
 
 // src/routes/knowledge.ts
-import { retryWhileMissing as retryWhileMissing4 } from "@opengeni/storage";
+import { retryWhileMissing as retryWhileMissing5 } from "@opengeni/storage";
 import { allowedFirstPartyMcpToolsForSession as allowedFirstPartyMcpToolsForSession3 } from "@opengeni/config";
 import {
   AgentLearningContext,
@@ -67155,7 +67613,7 @@ function registerKnowledgeRoutes(app, deps) {
       if (!file) throw new HTTPException42(404, { message: "Original file unavailable" });
       if (!deps.objectStorage)
         throw new HTTPException42(503, { message: "File storage is unavailable" });
-      if (!await retryWhileMissing4(
+      if (!await retryWhileMissing5(
         async () => await deps.objectStorage.fileExists(file) ? true : null
       ))
         throw new HTTPException42(410, { message: "Original file bytes are unavailable" });
@@ -67432,7 +67890,7 @@ function registerKnowledgeRoutes(app, deps) {
 }
 
 // src/routes/enrollments.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import {
   DeviceEnrollmentApproveRequest,
   DeviceEnrollmentApproveResponse,
@@ -67464,297 +67922,6 @@ import {
   requireAccessGrantAuthorization as requireAccessGrantAuthorization10,
   requirePermission
 } from "@opengeni/core";
-
-// src/sandbox/enrollment.ts
-import { randomBytes as randomBytes8 } from "crypto";
-import {
-  resolveEnrollmentSigningSecret,
-  resolveRelayTokenSecret
-} from "@opengeni/config";
-import {
-  DeviceEnrollmentState,
-  signEnrollmentBearer,
-  signEnrollToken,
-  signRelayToken,
-  verifyEnrollToken
-} from "@opengeni/contracts";
-import {
-  approveDeviceEnrollmentRequest,
-  consumeDeviceEnrollmentRequest,
-  createDeviceEnrollmentRequest,
-  denyDeviceEnrollmentRequest,
-  finalizeEnrollmentByToken,
-  getDeviceEnrollmentRequestByDeviceCode,
-  getEnrollment,
-  getPendingDeviceEnrollmentRequestByUserCode,
-  getPendingDeviceEnrollmentRequestByUserCodeGlobal
-} from "@opengeni/db";
-import { relayDialBaseFromSettings } from "@opengeni/core";
-var DEVICE_CODE_TTL_SECONDS = 600;
-var DEVICE_POLL_INTERVAL_SECONDS = 5;
-var ENROLLMENT_BEARER_TTL_SECONDS = 30 * 24 * 3600;
-var RELAY_TOKEN_TTL_SECONDS = 30 * 24 * 3600;
-var ENROLL_TOKEN_TTL_SECONDS = 3600;
-function mintDeviceCode() {
-  return randomBytes8(32).toString("base64url");
-}
-var USER_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-function mintUserCode() {
-  const bytes = randomBytes8(8);
-  let out = "";
-  for (let i = 0; i < 8; i += 1) {
-    out += USER_CODE_ALPHABET[bytes[i] % USER_CODE_ALPHABET.length];
-  }
-  return `${out.slice(0, 4)}-${out.slice(4, 8)}`;
-}
-async function startDeviceEnrollment(services, input) {
-  const { db } = services;
-  const expiresAt = new Date(Date.now() + DEVICE_CODE_TTL_SECONDS * 1e3);
-  let request;
-  let lastError;
-  for (let attempt = 0; attempt < 5 && !request; attempt += 1) {
-    const deviceCode = mintDeviceCode();
-    const userCode = mintUserCode();
-    try {
-      request = await createDeviceEnrollmentRequest(db, {
-        accountId: input.accountId,
-        workspaceId: input.workspaceId,
-        deviceCode,
-        userCode,
-        pubkey: input.publicKey,
-        os: input.os,
-        arch: input.arch,
-        machineName: input.machineName ?? null,
-        requestedExposure: "whole-machine",
-        canOfferDisplay: input.canOfferDisplay,
-        requestsScreenControl: input.requestsScreenControl,
-        expiresAt
-      });
-    } catch (error) {
-      lastError = error;
-    }
-  }
-  if (!request) {
-    throw lastError instanceof Error ? lastError : new Error("failed to start device enrollment");
-  }
-  const base = input.verificationOrigin.replace(/\/+$/, "");
-  const verificationUri = `${base}/device`;
-  const verificationUriComplete = `${verificationUri}?user_code=${encodeURIComponent(request.userCode)}`;
-  return {
-    deviceCode: request.deviceCode,
-    userCode: request.userCode,
-    verificationUri,
-    verificationUriComplete,
-    intervalSeconds: DEVICE_POLL_INTERVAL_SECONDS,
-    expiresInSeconds: DEVICE_CODE_TTL_SECONDS
-  };
-}
-async function approveDeviceEnrollment(services, input) {
-  const { db } = services;
-  const pending = await getPendingDeviceEnrollmentRequestByUserCode(
-    db,
-    input.workspaceId,
-    input.userCode
-  );
-  if (!pending) {
-    return null;
-  }
-  const sandboxName = (pending.machineName?.trim() || `${pending.os} machine`).slice(0, 256);
-  const result = await approveDeviceEnrollmentRequest(db, {
-    accountId: input.accountId,
-    workspaceId: input.workspaceId,
-    ...input.scope ? { scope: input.scope } : {},
-    allowOrganization: input.allowOrganization === true,
-    requestId: pending.id,
-    allowScreenControl: input.allowScreenControl,
-    approvedBySubjectId: input.approvedBySubjectId,
-    approvedBySubjectLabel: input.approvedBySubjectLabel ?? null,
-    sandboxName
-  });
-  if (!result.approved || !result.enrollment || !result.sandbox) {
-    return null;
-  }
-  return {
-    enrollmentId: result.enrollment.id,
-    sandboxId: result.sandbox.id,
-    allowScreenControl: result.enrollment.allowScreenControl
-  };
-}
-async function lookupDeviceEnrollment(services, input) {
-  const { db } = services;
-  return await getPendingDeviceEnrollmentRequestByUserCodeGlobal(db, input.userCode);
-}
-function toLookupResponse(record6) {
-  return {
-    workspaceId: record6.workspaceId,
-    userCode: record6.userCode,
-    machine: {
-      machineName: record6.machineName,
-      os: record6.os,
-      arch: record6.arch,
-      canOfferDisplay: record6.canOfferDisplay,
-      requestsScreenControl: record6.requestsScreenControl
-    },
-    expiresAt: record6.expiresAt
-  };
-}
-async function denyDeviceEnrollment(services, input) {
-  const { db } = services;
-  const pending = await getPendingDeviceEnrollmentRequestByUserCode(
-    db,
-    input.workspaceId,
-    input.userCode
-  );
-  if (!pending) {
-    return { denied: false };
-  }
-  return await denyDeviceEnrollmentRequest(db, {
-    accountId: input.accountId,
-    workspaceId: input.workspaceId,
-    requestId: pending.id
-  });
-}
-async function mintEnrollToken(services, input) {
-  const { settings } = services;
-  const secret = resolveEnrollmentSigningSecret(settings);
-  if (!secret) {
-    return null;
-  }
-  const nowSeconds = Math.floor(Date.now() / 1e3);
-  const exp = nowSeconds + ENROLL_TOKEN_TTL_SECONDS;
-  const token = await signEnrollToken(secret, {
-    typ: "enroll",
-    workspaceId: input.workspaceId,
-    accountId: input.accountId,
-    allowScreenControl: input.allowScreenControl,
-    iat: nowSeconds,
-    exp
-  });
-  return {
-    token,
-    expiresAt: new Date(exp * 1e3).toISOString(),
-    expiresInSeconds: ENROLL_TOKEN_TTL_SECONDS
-  };
-}
-async function exchangeEnrollToken(services, input) {
-  const { db, settings } = services;
-  const secret = resolveEnrollmentSigningSecret(settings);
-  if (!secret) {
-    return { ok: false, reason: "disabled" };
-  }
-  const claims = await verifyEnrollToken(secret, input.token);
-  if (!claims) {
-    return { ok: false, reason: "invalid" };
-  }
-  const sandboxName = (input.machineName?.trim() || `${input.os} machine`).slice(0, 256);
-  const { enrollment } = await finalizeEnrollmentByToken(db, {
-    accountId: claims.accountId,
-    workspaceId: claims.workspaceId,
-    pubkey: input.publicKey,
-    hasDisplay: input.canOfferDisplay,
-    // The token's allowScreenControl is the AUTHORITATIVE consent (NOT the agent's
-    // requestsScreenControl) — it was baked in at mint by the authorizing user.
-    allowScreenControl: claims.allowScreenControl,
-    os: input.os,
-    arch: input.arch,
-    sandboxName
-  });
-  const credentials = await buildEnrollmentCredentials(services, {
-    secret,
-    workspaceId: claims.workspaceId,
-    agentId: enrollment.id,
-    credentialGeneration: enrollment.credentialGeneration,
-    consentedScreenControl: enrollment.allowScreenControl
-  });
-  return { ok: true, credentials };
-}
-async function pollDeviceEnrollment(services, input) {
-  const { db, settings } = services;
-  const request = await getDeviceEnrollmentRequestByDeviceCode(db, input.deviceCode);
-  if (!request) {
-    return { state: "expired" };
-  }
-  if (request.status === "denied") {
-    return { state: "denied" };
-  }
-  if (request.status === "pending") {
-    if (new Date(request.expiresAt).getTime() <= Date.now()) {
-      return { state: "expired" };
-    }
-    return { state: "pending" };
-  }
-  if (!request.enrollmentId) {
-    return { state: "expired" };
-  }
-  const secret = resolveEnrollmentSigningSecret(settings);
-  if (!secret) {
-    return { state: "disabled" };
-  }
-  const enrollment = await getEnrollment(db, request.workspaceId, request.enrollmentId);
-  if (!enrollment || enrollment.status !== "active") {
-    return { state: "denied" };
-  }
-  const credentials = await buildEnrollmentCredentials(services, {
-    secret,
-    workspaceId: request.workspaceId,
-    agentId: enrollment.id,
-    credentialGeneration: enrollment.credentialGeneration,
-    consentedScreenControl: enrollment.allowScreenControl
-  });
-  if (request.status === "approved") {
-    await consumeDeviceEnrollmentRequest(db, {
-      accountId: request.accountId,
-      workspaceId: request.workspaceId,
-      requestId: request.id
-    });
-  }
-  return { state: DeviceEnrollmentState.enum.authorized, credentials };
-}
-async function buildEnrollmentCredentials(services, input) {
-  const { settings } = services;
-  const subjectPrefix = `agent.${input.workspaceId}.${input.agentId}`;
-  const nowSeconds = Math.floor(Date.now() / 1e3);
-  const exp = nowSeconds + ENROLLMENT_BEARER_TTL_SECONDS;
-  const bearer = await signEnrollmentBearer(input.secret, {
-    workspaceId: input.workspaceId,
-    agentId: input.agentId,
-    enrollmentId: input.agentId,
-    credentialGeneration: input.credentialGeneration,
-    subjectPrefix,
-    exp
-  });
-  const natsUrls = settings.selfhostedNatsUrl ? [settings.selfhostedNatsUrl] : [];
-  const relayTokenSecret = resolveRelayTokenSecret(settings);
-  const relayToken = relayTokenSecret ? await signRelayToken(relayTokenSecret, {
-    workspaceId: input.workspaceId,
-    agentId: input.agentId,
-    exp: nowSeconds + RELAY_TOKEN_TTL_SECONDS
-  }) : "";
-  return {
-    agentId: input.agentId,
-    workspaceId: input.workspaceId,
-    bearer,
-    subjectPrefix,
-    natsUrls,
-    // Hand the agent the canonical `/stream` dial base, NOT the raw configured URL.
-    // The agent's relay producer appends only its routing query and assumes the base
-    // already carries the relay's `/stream` route; a path-less base 400s the dial and
-    // makes the terminal/desktop streams unreachable.
-    relayUrl: relayDialBaseFromSettings(settings),
-    relayToken,
-    // M-AUTH closes the placeholder: there is NO per-machine NATS Account creds
-    // file. The agent presents the BEARER as the NATS connect auth-token; the
-    // server's auth-callout responder validates it and mints a workspace-scoped
-    // user JWT. We echo the bearer here so a consumer reading this (vestigial) field
-    // as the connect credential still works — the value IS the bearer.
-    natsAccountCreds: bearer,
-    updatePublicKey: settings.agentUpdatePublicKey ?? "",
-    consentedWholeMachine: true,
-    consentedScreenControl: input.consentedScreenControl
-  };
-}
-
-// src/routes/enrollments.ts
 function registerEnrollmentRoutes(app, deps) {
   const { settings, db } = deps;
   function assertSelfhostedEnabled() {
@@ -68023,7 +68190,7 @@ function registerEnrollmentRoutes(app, deps) {
         message: "invalid machine removal request"
       });
     }
-    const idempotencyKey = parsed.data.idempotencyKey?.trim() || c.req.header("idempotency-key")?.trim() || randomUUID5();
+    const idempotencyKey = parsed.data.idempotencyKey?.trim() || c.req.header("idempotency-key")?.trim() || randomUUID6();
     try {
       const enrollmentId = c.req.param("enrollmentId");
       const enrollment = (await listEnrollments2(db, grant, { status: "active" })).find(
@@ -68154,7 +68321,7 @@ import {
   readMachineMetricsLatestForWorkspace
 } from "@opengeni/db";
 import { MachineView, MetricSample } from "@opengeni/contracts";
-import { managedSessionGroupBackend as managedSessionGroupBackend3 } from "@opengeni/core";
+import { managedSessionGroupBackend as managedSessionGroupBackend3, sessionGroupMachinePresentation } from "@opengeni/core";
 import { selfhostedHeartbeatLiveness } from "@opengeni/runtime/sandbox";
 var ACTIVE_UPDATE_STATUSES = /* @__PURE__ */ new Set([
   "requested",
@@ -68291,23 +68458,24 @@ async function listMachines(services, input) {
   if (session && groupBackend) {
     const groupActive = activeSandboxId === null;
     const groupLease = await readLease3(db, workspaceId, session.sandboxGroupId);
+    const presentation = sessionGroupMachinePresentation(groupBackend);
+    const localHost = groupBackend === "local";
     machines.push(
       MachineView.parse({
         sandboxId: session.sandboxGroupId,
         enrollmentId: null,
-        name: "session sandbox",
-        kind: groupBackend === "opensandbox" ? "opensandbox" : "modal",
+        name: presentation.name,
+        kind: presentation.kind,
         state: "online",
         active: groupActive,
         isSessionGroup: true,
         workspaceGeneration: groupLease?.workspaceGeneration ?? null,
         archiveGeneration: groupLease?.archiveGeneration ?? null,
         archiveComplete: groupLease?.archiveComplete ?? false,
-        // The Modal group box is a cloud Linux box; its precise OS/arch is not
-        // surfaced as a metric, so the dashboard shows the canonical linux/x86_64.
-        os: "linux",
-        arch: "x86_64",
-        hasDisplay: false,
+        // A local sandbox is this machine. Other managed providers run a Linux box.
+        os: localHost ? process.platform : "linux",
+        arch: localHost ? process.arch : "x86_64",
+        hasDisplay: localHost,
         desktopUnavailableReason: null,
         allowScreenControl: false,
         sharedSessionCount: 1,
@@ -70222,7 +70390,7 @@ function browserIdentityRouteError(error) {
 }
 
 // src/routes/browser-sessions.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import {
   environmentsEncryptionKeyBytes as environmentsEncryptionKeyBytes5,
   resolveFirstPartyDelegationSecret as resolveFirstPartyDelegationSecret3,
@@ -70374,7 +70542,7 @@ import {
   provisionBrowserControlClient,
   renewSandboxProviderExpiration as renewSandboxProviderExpiration2
 } from "@opengeni/runtime/sandbox";
-import { retryWhileMissing as retryWhileMissing5 } from "@opengeni/storage";
+import { retryWhileMissing as retryWhileMissing6 } from "@opengeni/storage";
 import { HTTPException as HTTPException51 } from "hono/http-exception";
 
 // src/browser-controller-authority.ts
@@ -70657,7 +70825,7 @@ async function withInteractionHolderHeartbeat(deps, input, run) {
 }
 
 // src/browser-state-authority.ts
-import { createCipheriv, createDecipheriv, createHash as createHash18, createHmac as createHmac7, randomBytes as randomBytes9 } from "crypto";
+import { createCipheriv, createDecipheriv, createHash as createHash19, createHmac as createHmac7, randomBytes as randomBytes9 } from "crypto";
 import { BROWSER_PROFILE_ARTIFACT_FORMAT } from "@opengeni/contracts";
 var ROOT_KEY_BYTES = 32;
 var DATA_KEY_BYTES = 32;
@@ -70721,7 +70889,7 @@ function browserStateObjectKey(workspaceIdInput, operationIdInput) {
   return `workspaces/${workspaceId}/browser-state/revisions/${operationId}/chromium-profile.ogbs`;
 }
 function browserStateManifestDigest(manifest) {
-  return createHash18("sha256").update(canonicalJson2(manifest), "utf8").digest("hex");
+  return createHash19("sha256").update(canonicalJson2(manifest), "utf8").digest("hex");
 }
 function operationScope(input) {
   const base = baseArtifactScope(input);
@@ -72013,7 +72181,7 @@ function registerBrowserSessionRoutes(app, deps) {
               message: `browser download exceeds single PUT limit of ${objectStorage.maxSinglePutSizeBytes} bytes`
             });
           }
-          const fileId = randomUUID6();
+          const fileId = randomUUID7();
           const safeFilename = sanitizeFilename(source.download.filename);
           save = await prepareBrowserDownloadSave(deps.db, {
             ...identity2,
@@ -72916,7 +73084,7 @@ function registerBrowserSessionRoutes(app, deps) {
           if (!targets.some((target) => target.id === request.targetId)) {
             throw new HTTPException51(404, { message: "browser target does not exist" });
           }
-          const grantId = randomUUID6();
+          const grantId = randomUUID7();
           const expiresAt = new Date(Date.now() + request.expiresInSeconds * 1e3).toISOString();
           const rootSecret = browserAuthorityRoot(deps);
           const relaySecret = placement.session.openBrowserFrames ? resolveStreamTokenSecret2(deps.settings) : null;
@@ -74664,7 +74832,7 @@ async function ensureDispatchedGeneration(deps, grant, workspaceId, browserSessi
     operationId
   });
   if (record6.operation?.state === "prepared") {
-    const controllerGeneration = randomUUID6();
+    const controllerGeneration = randomUUID7();
     try {
       await dispatchBrowserSessionOperation(deps.db, {
         accountId: grant.accountId,
@@ -75273,7 +75441,7 @@ async function finalizeBrowserDownloadFile(deps, grant, workspaceId, uploadId) {
     throw new InteractionResourceStateError("Browser download file upload authority expired");
   }
   const pendingFile = upload.file;
-  const head = await retryWhileMissing5(async () => {
+  const head = await retryWhileMissing6(async () => {
     if (!await objectStorage.fileExists(pendingFile)) return null;
     return await objectStorage.headFile(pendingFile);
   });
@@ -75364,7 +75532,7 @@ function isAbort(error) {
 }
 
 // src/routes/computer-sessions.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { resolveFirstPartyDelegationSecret as resolveFirstPartyDelegationSecret4, resolveStreamTokenSecret as resolveStreamTokenSecret3 } from "@opengeni/config";
 import {
   BROWSER_CONTROL_WEBSOCKET_BEARER_PREFIX as BROWSER_CONTROL_WEBSOCKET_BEARER_PREFIX2,
@@ -75888,7 +76056,7 @@ function registerComputerSessionRoutes(app, deps) {
               retryable: false
             });
           }
-          const grantId = randomUUID7();
+          const grantId = randomUUID8();
           const expiresAt = new Date(Date.now() + request.expiresInSeconds * 1e3).toISOString();
           const token = deriveComputerViewGrantToken({
             rootSecret: controllerAuthorityRoot(deps),
@@ -76599,7 +76767,7 @@ function registerComputerSessionRoutes(app, deps) {
       operationId
     });
     if (record6.operation?.state === "prepared") {
-      const controllerGeneration = randomUUID7();
+      const controllerGeneration = randomUUID8();
       try {
         await dispatchComputerSessionOperation(deps.db, {
           accountId: grant.accountId,
@@ -78712,7 +78880,7 @@ import {
   personalGitHubGitBrokerRouteId
 } from "@opengeni/github";
 import { readResponseTextBounded as readResponseTextBounded2 } from "@opengeni/network";
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import JSONBig2 from "json-bigint";
 var PERSONAL_GITHUB_SERVER_ID = "github:personal";
 var GITHUB_API_VERSION3 = "2022-11-28";
@@ -78930,7 +79098,7 @@ async function authorizeBrokerProviderRequest(deps, authority, destinationUrl, o
       turnId: claims.turnId,
       attemptId: claims.attemptId,
       executionGeneration: claims.executionGeneration,
-      physicalRequestId: randomUUID8(),
+      physicalRequestId: randomUUID9(),
       usePhase: "credential_resolution"
     }
   });
@@ -78945,7 +79113,7 @@ async function authorizeBrokerProviderRequest(deps, authority, destinationUrl, o
     turnId: claims.turnId,
     attemptId: claims.attemptId,
     executionGeneration: claims.executionGeneration,
-    physicalRequestId: randomUUID8(),
+    physicalRequestId: randomUUID9(),
     usePhase: "provider_request",
     serverId: PERSONAL_GITHUB_SERVER_ID,
     connectionId: claims.connectionId,
@@ -83105,7 +83273,7 @@ import {
   integrationSourceForOrganizationPolicy as integrationSourceForOrganizationPolicy2
 } from "@opengeni/core";
 import { withOrganizationIntegrationPolicyFence as withOrganizationIntegrationPolicyFence8 } from "@opengeni/db/organization-integration-policy";
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 import {
   createPinnedIntegrationTransport as createPinnedIntegrationTransport3,
   fetchIntegrationSourceDocument as fetchIntegrationSourceDocument2
@@ -83967,7 +84135,7 @@ function pluginFailureCode(error) {
   return "component_install_failed";
 }
 function sha2562(value) {
-  return createHash19("sha256").update(value).digest("hex");
+  return createHash20("sha256").update(value).digest("hex");
 }
 
 // src/routes/skills.ts
@@ -84002,14 +84170,14 @@ import {
   SkillSourceRemovalAuthorityError as SkillSourceRemovalAuthorityError2
 } from "@opengeni/db";
 import { loadSkillLibrarySkill, skillLibraryRepositoryUrl } from "@opengeni/runtime/skill-library";
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 import { HTTPException as HTTPException67 } from "hono/http-exception";
 
 // src/routes/skill-content.ts
 import { z as z24 } from "zod";
 import { HTTPException as HTTPException66 } from "hono/http-exception";
-import { SkillFile } from "@opengeni/contracts";
-import { readSkillRemovalScope } from "@opengeni/db";
+import { SkillFile, SKILL_MAX_FILES } from "@opengeni/contracts";
+import { getSessionForSubject, readSkillRemovalScope } from "@opengeni/db";
 import {
   approveSkill,
   rejectSkill,
@@ -84375,8 +84543,8 @@ var saveRequest = z24.object({
   expectedScopeVersion: z24.number().int().nonnegative(),
   scope: scopeSchema.default("workspace"),
   stableKey: z24.string().min(1).max(96),
-  files: z24.array(SkillFile).max(128),
-  deletions: z24.array(z24.string().min(1).max(512)).max(128).default([]),
+  files: z24.array(SkillFile).max(SKILL_MAX_FILES),
+  deletions: z24.array(z24.string().min(1).max(512)).max(SKILL_MAX_FILES).default([]),
   reason: z24.string().min(1).max(2e3)
 }).strict();
 var revisionRequest = z24.object({
@@ -84405,9 +84573,20 @@ function registerSkillContentRoutes(app, deps) {
     const grant = await requireAccessGrant27(c, deps, workspaceId, "workspace:read");
     const query = z24.object({
       limit: z24.coerce.number().int().min(1).max(250).default(100),
-      cursor: z24.string().max(2048).optional()
+      cursor: z24.string().max(2048).optional(),
+      sessionId: z24.uuid().optional()
     }).safeParse(c.req.query());
     if (!query.success) throw new HTTPException66(422, { message: "Invalid Skill list query" });
+    if (query.data.sessionId) {
+      await requireAccessGrant27(c, deps, workspaceId, "sessions:read");
+      const session = await getSessionForSubject(
+        deps.db,
+        workspaceId,
+        query.data.sessionId,
+        grant.subjectId
+      );
+      if (!session) throw new HTTPException66(404, { message: "Session not found" });
+    }
     let after;
     if (query.data.cursor !== void 0) {
       try {
@@ -84419,7 +84598,12 @@ function registerSkillContentRoutes(app, deps) {
     const rows2 = await listSkills(
       deps.db,
       { accountId: grant.accountId, workspaceId, subjectId: grant.subjectId },
-      { limit: query.data.limit + 1, metadataOnly: true, ...after ? { after } : {} }
+      {
+        limit: query.data.limit + 1,
+        metadataOnly: true,
+        ...after ? { after } : {},
+        ...query.data.sessionId ? { sessionId: query.data.sessionId } : {}
+      }
     );
     const page = rows2.slice(0, query.data.limit);
     const last = page.at(-1);
@@ -84626,7 +84810,7 @@ function registerSkillRoutes(app, deps, overrides = {}) {
         path: file.path,
         content: file.content,
         byteSize: bytes.byteLength,
-        contentSha256: createHash20("sha256").update(bytes).digest("hex")
+        contentSha256: createHash21("sha256").update(bytes).digest("hex")
       };
     });
     try {
@@ -85587,7 +85771,7 @@ import {
   readActiveSandbox as readActiveSandbox3,
   deleteSessionTreeIfQuiescent,
   getSessionEvent,
-  getSessionForSubject,
+  getSessionForSubject as getSessionForSubject2,
   getSessionGoal as getSessionGoal2,
   getLatestSessionModelContext,
   getSessionHumanInputRequest,
@@ -87289,7 +87473,7 @@ function registerSessionRoutes(app, deps) {
     if (!z27.string().uuid().safeParse(sessionId).success) {
       throw new HTTPException72(404, { message: "session not found" });
     }
-    const session = await getSessionForSubject(
+    const session = await getSessionForSubject2(
       db,
       workspaceId,
       sessionId,
@@ -87320,7 +87504,7 @@ function registerSessionRoutes(app, deps) {
     if (!z27.string().uuid().safeParse(sessionId).success) {
       throw new HTTPException72(404, { message: "session not found" });
     }
-    const session = await getSessionForSubject(
+    const session = await getSessionForSubject2(
       db,
       workspaceId,
       sessionId,
@@ -88346,7 +88530,7 @@ function registerSessionRoutes(app, deps) {
       }
       throw error;
     }
-    const session = await getSessionForSubject(
+    const session = await getSessionForSubject2(
       db,
       workspaceId,
       sessionId,
@@ -88421,7 +88605,7 @@ function registerSessionRoutes(app, deps) {
     if (result.status === "updated") {
       await publishDurableSessionEvents3(bus, workspaceId, sessionId, [result.event]);
     }
-    const session = await getSessionForSubject(
+    const session = await getSessionForSubject2(
       db,
       workspaceId,
       sessionId,
@@ -88440,7 +88624,7 @@ function registerSessionRoutes(app, deps) {
     await assertSessionExists(db, workspaceId, sessionId);
     const payload = UpdateSessionRequest.parse(await c.req.json());
     const titleUpdate = await updateSessionTitle2(deps, grant, sessionId, payload.title, "user");
-    const session = await getSessionForSubject(
+    const session = await getSessionForSubject2(
       db,
       workspaceId,
       sessionId,
@@ -91508,7 +91692,7 @@ import { SessionControlConflictError as SessionControlConflictError2, WorkspaceP
 import { updateWorkspaceSettingsWithToolDefaults } from "@opengeni/db/workspace-tool-defaults";
 import { WorkspacePauseTimerRequest } from "@opengeni/contracts";
 import { getWorkspaceConnectionModelRestrictions } from "@opengeni/db";
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash22 } from "crypto";
 import {
   AddWorkspaceMemberRequest,
   CreateWorkspaceRequest,
@@ -91775,7 +91959,7 @@ function projectWorkspaceOpenRouterCustomModel(model) {
   });
 }
 function workspaceCustomModelRequestHash(value) {
-  return createHash21("sha256").update(stableJson7(value), "utf8").digest("hex");
+  return createHash22("sha256").update(stableJson7(value), "utf8").digest("hex");
 }
 function workspaceMembersResponse(members) {
   return ListWorkspaceMembersResponse.parse({
@@ -92712,7 +92896,7 @@ function requireAccountPermission2(context, accountId, permission) {
 }
 
 // src/routes/workspace-instruction-policies.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import {
   ActivateWorkspaceInstructionPolicyRequest,
   CreateWorkspaceInstructionPolicyDraftRequest,
@@ -92878,7 +93062,7 @@ function registerWorkspaceInstructionPolicyRoutes(app, deps) {
       return context.json(
         WorkspaceInstructionPolicyRevision.parse(
           await createWorkspaceInstructionPolicyDraft(deps.db, {
-            operationId: request.operationId ?? randomUUID9(),
+            operationId: request.operationId ?? randomUUID10(),
             accountId: grant.accountId,
             workspaceId,
             createdBySubjectId: grant.subjectId,
@@ -92906,7 +93090,7 @@ function registerWorkspaceInstructionPolicyRoutes(app, deps) {
       return context.json(
         WorkspaceInstructionPolicyRevision.parse(
           await importLegacyWorkspaceInstructionPolicyDraft(deps.db, {
-            operationId: request.operationId ?? randomUUID9(),
+            operationId: request.operationId ?? randomUUID10(),
             accountId: grant.accountId,
             workspaceId,
             createdBySubjectId: grant.subjectId,
@@ -92948,7 +93132,7 @@ function registerWorkspaceInstructionPolicyRoutes(app, deps) {
       return context.json(
         WorkspaceInstructionPolicyOnboardingProposal.parse(
           await createWorkspaceInstructionPolicyOnboardingProposal(deps.db, {
-            operationId: request.operationId ?? randomUUID9(),
+            operationId: request.operationId ?? randomUUID10(),
             accountId: grant.accountId,
             workspaceId,
             createdBySubjectId: grant.subjectId,
@@ -92998,7 +93182,7 @@ function registerWorkspaceInstructionPolicyRoutes(app, deps) {
       return context.json(
         WorkspaceInstructionPolicyActivationResponse.parse(
           await rollbackWorkspaceInstructionPolicyRevision(deps.db, {
-            operationId: request.operationId ?? randomUUID9(),
+            operationId: request.operationId ?? randomUUID10(),
             accountId: grant.accountId,
             workspaceId,
             targetRevisionId: request.targetRevisionId,
@@ -93037,7 +93221,7 @@ function registerWorkspaceInstructionPolicyRoutes(app, deps) {
       return context.json(
         WorkspaceInstructionPolicyActivationResponse.parse(
           await activateWorkspaceInstructionPolicyRevision(deps.db, {
-            operationId: request.operationId ?? randomUUID9(),
+            operationId: request.operationId ?? randomUUID10(),
             accountId: grant.accountId,
             workspaceId,
             revisionId: revisionId2,
@@ -93055,7 +93239,7 @@ function registerWorkspaceInstructionPolicyRoutes(app, deps) {
 }
 
 // src/routes/workspace-learning.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import {
   UndoGovernedLearningActivationHttpRequest,
   WorkspaceLearningHistoryResponse,
@@ -93178,7 +93362,7 @@ function registerWorkspaceLearningRoutes(app, deps) {
       const undo = await undoGovernedLearningActivation(deps.db, {
         caller: { workspaceId, subjectId: grant.subjectId },
         request: {
-          operationId: request.operationId ?? randomUUID10(),
+          operationId: request.operationId ?? randomUUID11(),
           activationReceiptId: activationReceiptId.data
         }
       });
@@ -93193,7 +93377,7 @@ function registerWorkspaceLearningRoutes(app, deps) {
 }
 
 // src/routes/company-profile.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 import {
   ActivateCompanyProfileRevisionRequest,
   CompanyProfileAgentPolicy,
@@ -93370,7 +93554,7 @@ function registerCompanyProfileRoutes(app, deps) {
       return context.json(
         CompanyProfileMutationResponse.parse(
           await updateCompanyProfile(deps.db, {
-            operationId: request.operationId ?? randomUUID11(),
+            operationId: request.operationId ?? randomUUID12(),
             accountId: access.grant.accountId,
             workspaceId,
             profile: request.profile,
@@ -93422,7 +93606,7 @@ function registerCompanyProfileRoutes(app, deps) {
       return context.json(
         CompanyProfileMutationResponse.parse(
           await rollbackCompanyProfileRevision(deps.db, {
-            operationId: request.operationId ?? randomUUID11(),
+            operationId: request.operationId ?? randomUUID12(),
             accountId: access.grant.accountId,
             workspaceId,
             targetRevisionId: request.targetRevisionId,
@@ -93469,7 +93653,7 @@ function registerCompanyProfileRoutes(app, deps) {
       return context.json(
         CompanyProfileMutationResponse.parse(
           await activateCompanyProfileRevision(deps.db, {
-            operationId: request.operationId ?? randomUUID11(),
+            operationId: request.operationId ?? randomUUID12(),
             accountId: access.grant.accountId,
             workspaceId,
             revisionId: revisionId(context),
@@ -93488,7 +93672,7 @@ function registerCompanyProfileRoutes(app, deps) {
 }
 
 // src/routes/company-brain.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash24 } from "crypto";
 import {
   COMPANY_BRAIN_INSPECTOR_CURSOR_MAX_CHARS,
   COMPANY_BRAIN_INSPECTOR_DEFAULT_LIMIT,
@@ -93759,14 +93943,14 @@ function serializeCompanyBrainOkf(value) {
 }
 
 // src/workspace-state-projection.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import {
   WORKSPACE_STATE_MAX_ACTIVE_POLICY_HEADS,
   WORKSPACE_STATE_KNOWLEDGE_SAMPLE_LIMIT,
   WorkspaceStateResponse
 } from "@opengeni/contracts";
 function hashIdentities(values) {
-  return createHash22("sha256").update(values.join("\n"), "utf8").digest("hex");
+  return createHash23("sha256").update(values.join("\n"), "utf8").digest("hex");
 }
 function policyTargetKey(value) {
   return `${value.kind}:${value.scope}:${value.roleKey ?? ""}`;
@@ -93996,7 +94180,7 @@ var inspectorQuery = z32.object({
   message: "attemptId cannot be combined with cursor"
 });
 function receiptCursorScope(workspaceId, subjectId) {
-  return createHash23("sha256").update("opengeni:company-brain-context-receipts:v1\0").update(workspaceId).update("\0").update(subjectId).digest("hex");
+  return createHash24("sha256").update("opengeni:company-brain-context-receipts:v1\0").update(workspaceId).update("\0").update(subjectId).digest("hex");
 }
 function encodeReceiptCursor(workspaceId, subjectId, cursor) {
   return Buffer.from(
@@ -94212,7 +94396,7 @@ function registerCompanyBrainRoutes(app, deps) {
 }
 
 // src/routes/slack-task-policy.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 import {
   SlackTaskPolicyListResponse,
   SlackTaskPolicyMutationResponse,
@@ -94295,7 +94479,7 @@ function registerSlackTaskPolicyRoutes(app, deps) {
       return context.json(
         SlackTaskPolicyMutationResponse.parse(
           await updateSlackTaskPolicy(deps.db, {
-            operationId: parsed.data.operationId ?? randomUUID12(),
+            operationId: parsed.data.operationId ?? randomUUID13(),
             accountId: access.grant.accountId,
             workspaceId,
             policy: parsed.data.policy,
@@ -94334,7 +94518,7 @@ import {
 import { HTTPException as HTTPException81 } from "hono/http-exception";
 
 // src/workspace-state-export.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 import {
   WORKSPACE_STATE_EXPORT_SCHEMA_VERSION,
   WorkspaceStateExportResponse
@@ -94365,7 +94549,7 @@ function createWorkspaceStateExport(state) {
     kind: "opengeni.workspace_state.sanitized_export",
     schemaVersion: WORKSPACE_STATE_EXPORT_SCHEMA_VERSION,
     generatedAt: state.generatedAt,
-    stateSha256: createHash24("sha256").update(canonicalState, "utf8").digest("hex"),
+    stateSha256: createHash25("sha256").update(canonicalState, "utf8").digest("hex"),
     omissions: WORKSPACE_STATE_EXPORT_OMISSIONS,
     state
   });
@@ -94473,7 +94657,7 @@ function registerWorkspaceStateRoutes(app, deps) {
 }
 
 // src/routes/workspace-artifacts.ts
-import { createHash as createHash25 } from "crypto";
+import { createHash as createHash26 } from "crypto";
 import {
   CreateWorkspaceArtifactRequest,
   PublishWorkspaceArtifactVersionRequest,
@@ -94565,7 +94749,7 @@ function prepareContent(deps, grant, input) {
 }
 function provenance(subjectId, idempotencyKey) {
   return {
-    operationKey: `subject:${createHash25("sha256").update(`${subjectId}:${idempotencyKey}`).digest("hex")}`,
+    operationKey: `subject:${createHash26("sha256").update(`${subjectId}:${idempotencyKey}`).digest("hex")}`,
     actorSubjectId: subjectId,
     sourceSessionId: null,
     sourceTurnId: null,
@@ -94924,7 +95108,7 @@ import {
 import { HTTPException as HTTPException84 } from "hono/http-exception";
 
 // src/artifact-catalog-cursor.ts
-import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, createHash as createHash26, randomBytes as randomBytes11 } from "crypto";
+import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, createHash as createHash27, randomBytes as randomBytes11 } from "crypto";
 import { ArtifactCatalogKind } from "@opengeni/contracts";
 import { HTTPException as HTTPException83 } from "hono/http-exception";
 import { z as z34 } from "zod";
@@ -94939,8 +95123,8 @@ var Cursor = z34.object({
   }).strict()
 }).strict();
 function artifactCatalogCursorCodec(secret, binding) {
-  const key = createHash26("sha256").update("opengeni:artifact-catalog:v1\0").update(secret).digest();
-  const aad = createHash26("sha256").update(binding).digest();
+  const key = createHash27("sha256").update("opengeni:artifact-catalog:v1\0").update(secret).digest();
+  const aad = createHash27("sha256").update(binding).digest();
   return {
     encode(value) {
       const iv = randomBytes11(12);
@@ -95257,7 +95441,7 @@ import { requireAccessGrant as requireAccessGrant43, TranscriptionServiceError a
 import { getWorkspace as getWorkspace6 } from "@opengeni/db";
 
 // src/routes/transcription-recordings.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 import {
   CreateTranscriptionRecordingRequest,
   FinalizeTranscriptionRecordingRequest,
@@ -95273,7 +95457,7 @@ import {
   TRANSCRIPTION_PROVIDER_REQUEST_TIMEOUT_MILLISECONDS,
   TranscriptionServiceError
 } from "@opengeni/core";
-import { retryWhileMissing as retryWhileMissing6 } from "@opengeni/storage";
+import { retryWhileMissing as retryWhileMissing7 } from "@opengeni/storage";
 import {
   claimNextTranscriptionRecordingSegment,
   claimTranscriptionRecordingAssembly,
@@ -95859,7 +96043,7 @@ function registerResumableTranscriptionRoutes(app, deps) {
         attemptedProvider = claim.segment.providerId;
         fallbackAllowed = claim.fallbackAllowed === true;
         const segmentKey = claim.segment.objectKey;
-        const stored = deps.objectStorage ? await retryWhileMissing6(async () => deps.objectStorage.getObjectBytes(segmentKey)) : null;
+        const stored = deps.objectStorage ? await retryWhileMissing7(async () => deps.objectStorage.getObjectBytes(segmentKey)) : null;
         if (!stored) {
           throw new RecordingProcessingError("Provider segment is missing", "invalid_audio", false);
         }
@@ -96018,7 +96202,7 @@ async function* verifiedChunkBytes(deps, chunks, signal) {
     }
     let stored;
     try {
-      stored = await retryWhileMissing6(
+      stored = await retryWhileMissing7(
         async () => deps.objectStorage.getObjectBytes(chunk.objectKey)
       );
     } catch {
@@ -96102,7 +96286,7 @@ function valueAsUuid(value) {
   if (/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
     return value;
   }
-  const hex2 = createHash27("sha256").update(value).digest("hex").slice(0, 32);
+  const hex2 = createHash28("sha256").update(value).digest("hex").slice(0, 32);
   return `${hex2.slice(0, 8)}-${hex2.slice(8, 12)}-4${hex2.slice(13, 16)}-a${hex2.slice(17, 20)}-${hex2.slice(20, 32)}`;
 }
 function nonnegativeInteger(value) {
@@ -96166,7 +96350,7 @@ async function readBoundedBody(request, maxBytes) {
   return body3;
 }
 function sha256Hex3(bytes) {
-  return createHash27("sha256").update(bytes).digest("hex");
+  return createHash28("sha256").update(bytes).digest("hex");
 }
 
 // src/routes/transcriptions.ts
@@ -96457,7 +96641,7 @@ function videoGenerationFundingOptions(input) {
 }
 
 // src/routes/canonical-human-identities.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 import {
   CanonicalHumanBindingOperationRequest,
   CanonicalHumanIdentityMutationResponse,
@@ -96506,7 +96690,7 @@ import { HTTPException as HTTPException88 } from "hono/http-exception";
 import { z as z36 } from "zod";
 
 // src/routes/managed-auth-session-sets.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 import {
   BeginManagedAuthLoginTransactionRequest,
   BootstrapManagedAuthSessionSetRequest,
@@ -96717,7 +96901,7 @@ function registerManagedAuthSessionSetRoutes(app, deps) {
   app.post("/v1/auth/session-set/transactions", async (context) => {
     const body3 = await bodyAs(context, BeginManagedAuthLoginTransactionRequest);
     const { authority, actorEpoch } = await requireMutation(context, deps, body3.expectedGeneration);
-    const transactionId = randomUUID13();
+    const transactionId = randomUUID14();
     const transactionSecret = managedAuthTransactionSecret(
       requireSigningSecret(deps),
       authority,
@@ -97938,7 +98122,7 @@ function registerCanonicalHumanIdentityRoutes(app, deps) {
     return await mutate(context, deps, {
       operationType: "link",
       ...request,
-      operationId: request.operationId ?? randomUUID14()
+      operationId: request.operationId ?? randomUUID15()
     });
   });
   app.delete(`${base}/login-bindings/:bindingId`, async (context) => {
@@ -97956,7 +98140,7 @@ function registerCanonicalHumanIdentityRoutes(app, deps) {
       operationType: "unlink",
       bindingId: bindingId(context),
       ...request,
-      operationId: request.operationId ?? randomUUID14()
+      operationId: request.operationId ?? randomUUID15()
     });
   });
   app.post(`${base}/login-bindings/:bindingId/recovery`, async (context) => {
@@ -97974,7 +98158,7 @@ function registerCanonicalHumanIdentityRoutes(app, deps) {
       operationType: "begin_recovery",
       bindingId: bindingId(context),
       ...request,
-      operationId: request.operationId ?? randomUUID14()
+      operationId: request.operationId ?? randomUUID15()
     });
   });
   app.post(`${base}/login-bindings/:bindingId/recovery/complete`, async (context) => {
@@ -97989,7 +98173,7 @@ function registerCanonicalHumanIdentityRoutes(app, deps) {
       operationType: "recover",
       bindingId: bindingId(context),
       ...request,
-      operationId: request.operationId ?? randomUUID14(),
+      operationId: request.operationId ?? randomUUID15(),
       ...managed ? { verifiedManagedRecovery: true } : {}
     });
   });
@@ -100297,11 +100481,12 @@ async function exactAvailable(providers, providerId, context) {
 }
 
 // src/integrations/slack-interactions.ts
-import { createHash as createHash29, createHmac as createHmac10, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash30, createHmac as createHmac10, timingSafeEqual as timingSafeEqual3 } from "crypto";
 import {
   approvalIdentifier,
   ApproveSlackUserLinkAccessRequest,
   DEFAULT_FIRST_PARTY_MCP_TOOLS,
+  resolveWorkspaceSessionToolDefaults,
   hasOpenGeniSlackReactionScope,
   ListSlackUserLinkAccessRequestsResponse,
   PrepareSlackUserLinkAccessRequest,
@@ -100341,6 +100526,7 @@ import {
   getOrCreateSlackInteraction,
   getLatestSessionModelForSubject,
   getSession as getSession11,
+  getSessionByCreateIdempotencyKey,
   getSessionEvent as getSessionEvent2,
   getSessionHumanInputRequest as getSessionHumanInputRequest2,
   childRequiresActionResolutionExists,
@@ -100400,6 +100586,7 @@ import {
   acceptSessionUserMessage as acceptSessionUserMessage2,
   controlHumanSessionWorkstream as controlHumanSessionWorkstream2,
   createSessionForRequest as createSessionForRequest2,
+  getActorNewSessionDefaults,
   hasPermission as hasPermission26,
   requireAccessContext as requireAccessContext8,
   requireAccessGrant as requireAccessGrant45,
@@ -100775,9 +100962,9 @@ function record4(value) {
 }
 
 // src/slack-reaction-files.ts
-import { createHash as createHash28 } from "crypto";
+import { createHash as createHash29 } from "crypto";
 import { completeFileUpload as completeFileUpload5, prepareGeneratedWorkspaceFile as prepareGeneratedWorkspaceFile2 } from "@opengeni/db";
-import { retryWhileMissing as retryWhileMissing7 } from "@opengeni/storage";
+import { retryWhileMissing as retryWhileMissing8 } from "@opengeni/storage";
 var IMPORT_IDENTITY_VERSION = "slack-reaction-image-v1";
 var UPLOAD_INTENT_TTL_MS2 = 60 * 6e4;
 var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
@@ -100792,7 +100979,7 @@ async function importSlackReactionImage(dependencies, source, image, ordinal) {
   if (image.bytes.byteLength < 1 || image.bytes.byteLength > 4 * 1024 * 1024) {
     throw new Error("Slack reaction image size is invalid");
   }
-  const sha2563 = createHash28("sha256").update(image.bytes).digest("hex");
+  const sha2563 = createHash29("sha256").update(image.bytes).digest("hex");
   const identity2 = slackReactionImageIdentity(source, image.fileId);
   const fileId = deterministicUuid(`${identity2}:file`);
   const uploadId = deterministicUuid(`${identity2}:upload`);
@@ -100877,7 +101064,7 @@ function safeSlackImageFilename(value, contentType) {
   return `${stem}${extension}`;
 }
 async function assertVisibleSlackImage(storage, objectKey, image, sha2563) {
-  const head = await retryWhileMissing7(async () => await storage.headObject(objectKey));
+  const head = await retryWhileMissing8(async () => await storage.headObject(objectKey));
   assertStoredSlackImage(head, image, sha2563);
 }
 function assertStoredSlackImage(head, image, sha2563) {
@@ -100886,7 +101073,7 @@ function assertStoredSlackImage(head, image, sha2563) {
   }
 }
 function deterministicUuid(seed) {
-  const bytes = createHash28("sha256").update(seed, "utf8").digest().subarray(0, 16);
+  const bytes = createHash29("sha256").update(seed, "utf8").digest().subarray(0, 16);
   bytes[6] = (bytes[6] ?? 0) & 15 | 80;
   bytes[8] = (bytes[8] ?? 0) & 63 | 128;
   const hex2 = bytes.toString("hex");
@@ -101045,7 +101232,7 @@ function slackReactionInboxEntry(payload, bot, settings) {
   if (!settings.enabled || !event || event.type !== "reaction_added" || item?.type !== "message" || !teamId || !eventId || !userId || userId === bot.botUserId || !reaction || reaction !== settings.emoji || !channelId || !workspaceSlackReactionChannelAllowed(settings, channelId) || !timestamp) {
     return null;
   }
-  const stableReactionIdentity = createHash29("sha256").update([teamId, userId, channelId, timestamp, reaction].join("\n")).digest("hex");
+  const stableReactionIdentity = createHash30("sha256").update([teamId, userId, channelId, timestamp, reaction].join("\n")).digest("hex");
   return {
     providerEventId: eventId,
     providerMessageId: `reaction:${stableReactionIdentity}`,
@@ -101235,7 +101422,7 @@ function registerSlackInteractionRoutes(app, deps) {
       const prepared = await prepareSlackUserLinkAccessRequest(deps.db, {
         accountId: installation.accountId,
         workspaceId,
-        tokenDigest: createHash29("sha256").update(payload.linkToken).digest("hex"),
+        tokenDigest: createHash30("sha256").update(payload.linkToken).digest("hex"),
         connectionId: link.connectionId,
         slackTeamId: link.slackTeamId,
         slackUserId: link.slackUserId,
@@ -101442,7 +101629,7 @@ function registerSlackInteractionRoutes(app, deps) {
       const prepared = await prepareSlackUserLinkAccessRequest(deps.db, {
         accountId: grant.accountId,
         workspaceId,
-        tokenDigest: createHash29("sha256").update(linkToken).digest("hex"),
+        tokenDigest: createHash30("sha256").update(linkToken).digest("hex"),
         connectionId: link.connectionId,
         slackTeamId: link.slackTeamId,
         slackUserId: link.slackUserId,
@@ -102405,6 +102592,14 @@ async function processSlackInboxEntry(deps, entry2) {
   );
   let session;
   try {
+    const defaults = await slackNewSessionDefaults(
+      deps,
+      grant,
+      interaction,
+      `slack:${entry2.connectionId}:${entry2.providerEventId}`
+    );
+    const workspace = await getWorkspace7(deps.db, interaction.workspaceId);
+    const defaultTools = defaults.firstPartyMcpTools ?? resolveWorkspaceSessionToolDefaults(workspace?.settings)?.firstPartyMcpTools;
     const prepared = slackInvocationPreparedMessage(
       preparedEntry,
       preparedAttachments,
@@ -102415,13 +102610,14 @@ async function processSlackInboxEntry(deps, entry2) {
       grant,
       interaction.workspaceId,
       {
+        ...defaults,
         requestedSessionId: interaction.sessionReservationId,
         initialMessage: prepared.entry.text,
         ...prepared.modelContext ? { modelContext: prepared.modelContext } : {},
         instructions: SLACK_SESSION_INSTRUCTIONS,
-        firstPartyMcpTools: slackTaskFirstPartyMcpTools(deps.settings),
-        resources: preparedAttachments.resources,
-        ...preferredModel ? { model: preferredModel } : {},
+        firstPartyMcpTools: defaultTools !== void 0 ? allowedFirstPartyMcpToolsForSession4(deps.settings, defaultTools) : slackTaskFirstPartyMcpTools(deps.settings),
+        resources: [...defaults.resources, ...preparedAttachments.resources],
+        ...!defaults.model && preferredModel ? { model: preferredModel } : {},
         idempotencyKey: `slack:${entry2.connectionId}:${entry2.providerEventId}`,
         clientEventId: `slack:${entry2.providerEventId}`
       }
@@ -102842,19 +103038,25 @@ async function processSlackReactionInboxEntry(deps, entry2) {
   const preparedEntry = slackReactionPreparedEntry(entry2, context, preparedTask);
   let session;
   try {
+    const defaults = await slackNewSessionDefaults(
+      deps,
+      grant,
+      interaction,
+      `slack-interaction:${interaction.id}`
+    );
     session = await createSessionForRequest2(
       await withCatalogSettings(deps, grant),
       grant,
       interaction.workspaceId,
       {
+        ...defaults,
         requestedSessionId: interaction.sessionReservationId,
         initialMessage: preparedEntry.text,
         instructions: SLACK_SESSION_INSTRUCTIONS,
-        // The exact reacted message and bounded containing thread are already in
-        // the prompt; do not expose general Slack history tools for this trigger.
-        firstPartyMcpTools: resolveFirstPartyMcpToolPolicy(deps.settings).default,
-        resources: preparedTask.resources,
-        ...preferredModel ? { model: preferredModel } : {},
+        // Reaction context stays bounded; ordinary tools follow the same saved
+        // selection/workspace defaults as the website, without adding Slack tools.
+        resources: [...defaults.resources, ...preparedTask.resources],
+        ...!defaults.model && preferredModel ? { model: preferredModel } : {},
         // Every reaction entry converging on this route must use the same create
         // key. This closes the same-owner multi-event race while the owner check
         // above prevents a different subject from winning creation authority.
@@ -102904,6 +103106,35 @@ function slackReactionPreparedEntry(entry2, context, prepared) {
     text: slackReactionTaskText(context, prepared)
   };
 }
+async function slackNewSessionDefaults(deps, grant, interaction, createKey) {
+  const pending = await getSessionByCreateIdempotencyKey(
+    deps.db,
+    interaction.workspaceId,
+    createKey
+  );
+  if (!pending) return getActorNewSessionDefaults(deps, grant, interaction.workspaceId);
+  if (pending.id !== interaction.sessionReservationId || interaction.owningSubjectId !== grant.subjectId || pending.createdBy.kind !== "subject" || pending.createdBy.subjectId !== grant.subjectId) {
+    throw new SlackInteractionPermanentError("slack_session_create_identity_mismatch");
+  }
+  return {
+    model: pending.model,
+    reasoningEffort: pending.reasoningEffort,
+    latencyMode: pending.latencyMode,
+    resources: pending.resources.filter((resource) => resource.kind === "repository"),
+    ...pending.toolPolicy.mode === "explicit" ? { tools: pending.tools } : {
+      excludedMcpServerIds: pending.toolPolicy.excludedMcpServerIds
+    },
+    firstPartyMcpTools: pending.firstPartyMcpTools,
+    ...pending.firstPartyMcpPermissions ? { firstPartyMcpPermissions: pending.firstPartyMcpPermissions } : {},
+    variableSetIds: pending.variableSetIds,
+    ...pending.rigId ? { rigId: pending.rigId } : {},
+    sandboxBackend: pending.sandboxBackend,
+    ...pending.sandboxBackend === "selfhosted" && pending.activeSandboxId ? {
+      targetSandboxId: pending.activeSandboxId,
+      ...pending.workingDir ? { workingDir: pending.workingDir } : {}
+    } : {}
+  };
+}
 async function remountSlackReactionTaskForSession(deps, workspaceId, sessionId, prepared) {
   if (prepared.attachments.length === 0) return prepared;
   const session = await getSession11(deps.db, workspaceId, sessionId);
@@ -104335,7 +104566,7 @@ function normalizedBlockActionInteraction(payload) {
   if (!teamId || !userId || !channelId || !messageTs || !actionTs || !actionId || !SLACK_BLOCK_ACTION_IDS.has(actionId) || !handleId || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(handleId) || !Array.isArray(payload.actions) || payload.actions.length !== 1) {
     throw new HTTPException95(400, { message: "invalid Slack block action" });
   }
-  const identity2 = createHash29("sha256").update([teamId, userId, channelId, messageTs, actionTs, actionId, handleId].join("\n")).digest("hex");
+  const identity2 = createHash30("sha256").update([teamId, userId, channelId, messageTs, actionTs, actionId, handleId].join("\n")).digest("hex");
   return {
     providerEventId: `block:${identity2}`,
     providerMessageId: `block:${identity2}`,
@@ -104600,7 +104831,7 @@ function usesPrivateBotDm(interaction, entry2) {
   return isDirectMessageShortcut(entry2) || interaction.visibility === "private" && entry2.triggerKind !== "dm";
 }
 function deterministicUuid2(value) {
-  const bytes = createHash29("sha256").update(value).digest().subarray(0, 16);
+  const bytes = createHash30("sha256").update(value).digest().subarray(0, 16);
   bytes[6] = bytes[6] & 15 | 80;
   bytes[8] = bytes[8] & 63 | 128;
   const hex2 = bytes.toString("hex");
@@ -104825,7 +105056,7 @@ function createAppComposition(deps) {
   }) : deps.transcriptionSegmenter;
   const routeDeps = {
     ...deps,
-    resolveCatalogSettings: () => resolveCatalogSettings(deps.db, deps.settings),
+    resolveCatalogSettings: () => resolveCatalogSettings2(deps.db, deps.settings),
     observability,
     githubStateSecret: deps.githubStateSecret ?? deps.settings.githubAppManifestStateSecret ?? crypto.randomUUID(),
     managedAuth,
@@ -105255,9 +105486,9 @@ function createAppComposition(deps) {
   registerMcpOAuthRoutes(app, routeDeps);
   app.get("/v1/config/client", async (c) => {
     c.header("cache-control", "no-store");
-    const resolvedCatalog = await resolveCatalogSettings(deps.db, deps.settings);
+    const resolvedCatalog = await resolveCatalogSettings2(deps.db, deps.settings);
     const baseCatalogSettings = resolvedCatalog.settings;
-    const codexCatalogSettings = baseCatalogSettings.codexSubscriptionEnabled ? withCodexCatalogProvider2(baseCatalogSettings) : baseCatalogSettings;
+    const codexCatalogSettings = baseCatalogSettings.codexSubscriptionEnabled ? withCodexCatalogProvider3(baseCatalogSettings) : baseCatalogSettings;
     const catalogSettings = baseCatalogSettings.supergrokSubscriptionEnabled ? withXaiSubscriptionCatalogProvider3(codexCatalogSettings) : codexCatalogSettings;
     return c.json(
       ClientConfig.parse({
@@ -105270,7 +105501,7 @@ function createAppComposition(deps) {
         // union of the built-in allow-list and every registry provider's models, in
         // selection order (default model first); project each to the client-safe
         // provider-blind ClientModel shape (execution topology remains server-side).
-        models: configuredModels3(catalogSettings).map(projectClientModel),
+        models: configuredModels4(catalogSettings).map(projectClientModel),
         defaultReasoningEffort: deps.settings.openaiReasoningEffort,
         allowedReasoningEfforts: configuredAllowedReasoningEfforts(deps.settings),
         defaultSandboxBackend: deps.settings.sandboxBackend,
@@ -105952,7 +106183,7 @@ function readinessChecks(deps) {
       } else {
         await deps.db.execute(dbSql`select 1`);
       }
-      await resolveCatalogSettings(deps.db, deps.settings);
+      await resolveCatalogSettings2(deps.db, deps.settings);
     },
     nats: async () => {
       requireSessionEventDurableFanoutCapability2(deps.bus);
@@ -106882,4 +107113,4 @@ export {
   withDefaultEnabledCapabilityMcpTools,
   workflowIdForSession4 as workflowIdForSession
 };
-//# sourceMappingURL=chunk-E7TZFJ65.js.map
+//# sourceMappingURL=chunk-24C5LPNE.js.map