@opengeni/core 0.12.7 → 0.14.3

package/dist/index.js

@@ -3,6 +3,79 @@ var SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID = "opengeni-session-workflow-wa
 var SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE = "sessionWorkflowWakeDispatcherWorkflow";
 var SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS = 1e4;
 
+// src/transcription.ts
+var TranscriptionServiceError = class extends Error {
+  code;
+  status;
+  retryable;
+  constructor(input) {
+    super(input.message);
+    this.name = "TranscriptionServiceError";
+    this.code = input.code;
+    this.status = input.status ?? statusForVoiceInputError(input.code);
+    this.retryable = input.retryable ?? false;
+  }
+};
+function statusForVoiceInputError(code) {
+  switch (code) {
+    case "permission_denied":
+      return 403;
+    case "policy_blocked":
+      return 403;
+    case "not_supported":
+      return 415;
+    case "unavailable":
+      return 503;
+    case "too_large":
+      return 413;
+    case "invalid_audio":
+      return 400;
+    case "timeout":
+      return 504;
+    case "cancelled":
+      return 499;
+    case "network":
+    case "provider":
+      return 502;
+    case "unknown":
+    default:
+      return 500;
+  }
+}
+function normalizeMimeType(mimeType) {
+  return mimeType.trim().toLowerCase();
+}
+function isAcceptedMimeType(mimeType, accepted) {
+  const normalized = normalizeMimeType(mimeType);
+  if (accepted.some((candidate) => normalizeMimeType(candidate) === normalized)) {
+    return true;
+  }
+  const bare = normalized.split(";")[0]?.trim() ?? normalized;
+  return accepted.some((candidate) => {
+    const allowed = normalizeMimeType(candidate);
+    return allowed === bare || allowed.split(";")[0]?.trim() === bare;
+  });
+}
+function filenameForMimeType(mimeType) {
+  const bare = normalizeMimeType(mimeType).split(";")[0] ?? "audio/webm";
+  switch (bare) {
+    case "audio/mp4":
+    case "audio/m4a":
+      return "audio.mp4";
+    case "audio/ogg":
+      return "audio.ogg";
+    case "audio/mpeg":
+    case "audio/mp3":
+      return "audio.mp3";
+    case "audio/wav":
+    case "audio/x-wav":
+      return "audio.wav";
+    case "audio/webm":
+    default:
+      return "audio.webm";
+  }
+}
+
 // src/sandbox/fleet.ts
 import {
   getEnrollment,
@@ -22,6 +95,7 @@ import {
 import { HTTPException } from "hono/http-exception";
 
 // src/sandbox/routing.ts
+import { sandboxArchiveCaptureTimeoutMs } from "@opengeni/config";
 import {
   advanceWorkspaceGenerationForDirectRequest,
   advanceWorkspaceGenerationForRetainedProcess,
@@ -40,7 +114,8 @@ import {
   isProviderSandboxGoneDuringRoutedOperation,
   makeActiveBackendResolver,
   NatsControlRpc,
-  RoutingSandboxSession
+  RoutingSandboxSession,
+  resolveModalCheckpointProviderBindingForSession
 } from "@opengeni/runtime/sandbox";
 function relayConfigFromSettings(settings) {
   const raw = settings.selfhostedRelayUrl?.trim();
@@ -94,7 +169,8 @@ function wrapChannelABoxWithRouting(services, ids, established) {
     if (backend.activeEpoch === void 0) {
       throw new Error("API-direct workspace mutation resolved without an active route epoch");
     }
-    return await advanceWorkspaceGenerationForDirectRequest(db, {
+    const providerBinding = homeLease.backend === "modal" ? await resolveModalCheckpointProviderBindingForSession(settings, backend.session) : null;
+    const admission = await advanceWorkspaceGenerationForDirectRequest(db, {
       accountId: ids.accountId,
       workspaceId: ids.workspaceId,
       sessionId: ids.sessionId,
@@ -105,8 +181,10 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       expectedInstanceId: backend.providerInstanceId,
       routeTargetId: backend.sandboxId,
       routeEpoch: backend.activeEpoch,
-      operation: op
+      operation: op,
+      captureWaitMs: sandboxArchiveCaptureTimeoutMs(settings)
     });
+    return { admission, providerBinding };
   } : void 0;
   const afterMutation = homeLease ? async ({
     op,
@@ -116,10 +194,14 @@ function wrapChannelABoxWithRouting(services, ids, established) {
     retainedProcess
   }) => {
     if (admission === null) return;
-    if (!admission || typeof admission !== "object" || typeof admission.id !== "string" || typeof admission.workspaceGeneration !== "number" || backend.leaseEpoch === void 0 || backend.providerInstanceId === void 0 || backend.activeEpoch === void 0) {
+    if (!admission || typeof admission !== "object" || backend.leaseEpoch === void 0 || backend.providerInstanceId === void 0 || backend.activeEpoch === void 0) {
       throw new Error("API-direct workspace mutation settlement lacked its exact admission");
     }
-    const exactAdmission = admission;
+    const boundAdmission = admission;
+    const exactAdmission = boundAdmission.admission;
+    if (!exactAdmission || typeof exactAdmission.id !== "string" || typeof exactAdmission.workspaceGeneration !== "number" || !("providerBinding" in boundAdmission)) {
+      throw new Error("API-direct workspace mutation settlement lacked its bound admission");
+    }
     if (outcome === "resolved" && retainedProcess) {
       await retainWorkspaceMutationProcess(db, {
         accountId: ids.accountId,
@@ -130,6 +212,7 @@ function wrapChannelABoxWithRouting(services, ids, established) {
         admissionId: exactAdmission.id,
         admittedWorkspaceGeneration: exactAdmission.workspaceGeneration,
         operation: op,
+        providerBinding: boundAdmission.providerBinding ?? null,
         owner: {
           kind: "direct",
           requestId: ids.directRequest.requestId,
@@ -167,7 +250,8 @@ function wrapChannelABoxWithRouting(services, ids, established) {
     workspaceId: ids.workspaceId,
     sessionId: ids.sessionId,
     processId: process.id,
-    operation: op
+    operation: op,
+    captureWaitMs: sandboxArchiveCaptureTimeoutMs(settings)
   }) : void 0;
   const afterProcessMutation = homeLease ? async ({
     op,
@@ -555,47 +639,37 @@ async function swapActiveSandbox(services, ctx, target, workingDir) {
     await readinessHold?.release().catch(() => void 0);
   }
 }
-async function runOnSandbox(services, ctx, target, op) {
-  const sandbox = await getSandbox2(services.db, ctx.workspaceId, target);
-  if (!sandbox) {
-    return {
-      target,
-      kind: op.kind,
-      ok: false,
-      reason: `sandbox ${target} not found in this workspace`
-    };
-  }
-  if (sandbox.kind !== "selfhosted" || !sandbox.enrollmentId) {
-    return {
-      target,
-      kind: op.kind,
-      ok: false,
-      reason: `run_on routes one-off ops to enrolled selfhosted machines; ${sandbox.kind} targets are reached via the active sandbox (swap to it first)`
-    };
-  }
-  const enrollment = await getEnrollment(services.db, ctx.workspaceId, sandbox.enrollmentId);
-  if (!enrollment || enrollment.status !== "active") {
-    return { target, kind: op.kind, ok: false, reason: `sandbox ${target} is not enrolled/active` };
-  }
+async function executeRunOnSelfhostedMachine(machine, target, op) {
   const session = new SelfhostedSession({
-    workspaceId: ctx.workspaceId,
-    agentId: sandbox.enrollmentId,
-    controlRpc: controlRpc(services.bus),
-    relay: relayConfigFromSettings(services.settings)
+    workspaceId: machine.workspaceId,
+    agentId: machine.agentId,
+    controlRpc: machine.controlRpc,
+    relay: machine.relay,
+    timeoutMs: machine.controlTimeoutMs,
+    execTimeoutMs: machine.execTimeoutMs
   });
   try {
     if (op.kind === "exec") {
+      const deadlineMs = session.effectiveExecDeadlineMs;
       const res = await session.exec({
         cmd: op.cmd,
         ...op.workdir ? { workdir: op.workdir } : {}
       });
+      const timedOut = res.timedOut === true;
+      const hasTerminalExit = res.exitCode !== null;
       return {
         target,
         kind: "exec",
-        ok: true,
+        // `ok` means the one-off operation reached a terminal response. Preserve
+        // the established non-zero-exit behavior, but never claim success when
+        // the machine killed the child or returned no terminal exit proof.
+        ok: !timedOut && hasTerminalExit,
         stdout: res.stdout,
         stderr: res.stderr,
-        exitCode: res.exitCode
+        exitCode: res.exitCode,
+        timedOut,
+        deadlineMs,
+        ...timedOut ? { reason: `command exceeded the ${deadlineMs} ms execution deadline` } : !hasTerminalExit ? { reason: "machine returned no terminal exit code" } : {}
       };
     }
     if (op.kind === "read") {
@@ -606,8 +680,51 @@ async function runOnSandbox(services, ctx, target, op) {
     return { target, kind: "write", ok: true, bytesWritten };
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
-    return { target, kind: op.kind, ok: false, reason };
+    return {
+      target,
+      kind: op.kind,
+      ok: false,
+      reason,
+      // A transport failure is not evidence that the process itself timed out,
+      // so leave `timedOut` absent while still reporting the enforced deadline.
+      ...op.kind === "exec" ? { deadlineMs: session.effectiveExecDeadlineMs } : {}
+    };
+  }
+}
+async function runOnSandbox(services, ctx, target, op) {
+  const sandbox = await getSandbox2(services.db, ctx.workspaceId, target);
+  if (!sandbox) {
+    return {
+      target,
+      kind: op.kind,
+      ok: false,
+      reason: `sandbox ${target} not found in this workspace`
+    };
   }
+  if (sandbox.kind !== "selfhosted" || !sandbox.enrollmentId) {
+    return {
+      target,
+      kind: op.kind,
+      ok: false,
+      reason: `run_on routes one-off ops to enrolled selfhosted machines; ${sandbox.kind} targets are reached via the active sandbox (swap to it first)`
+    };
+  }
+  const enrollment = await getEnrollment(services.db, ctx.workspaceId, sandbox.enrollmentId);
+  if (!enrollment || enrollment.status !== "active") {
+    return { target, kind: op.kind, ok: false, reason: `sandbox ${target} is not enrolled/active` };
+  }
+  return executeRunOnSelfhostedMachine(
+    {
+      workspaceId: ctx.workspaceId,
+      agentId: sandbox.enrollmentId,
+      controlRpc: controlRpc(services.bus),
+      relay: relayConfigFromSettings(services.settings),
+      controlTimeoutMs: services.settings.sandboxSelfhostedControlTimeoutMs,
+      execTimeoutMs: services.settings.sandboxSelfhostedExecTimeoutMs
+    },
+    target,
+    op
+  );
 }
 async function provisionSandbox(services, ctx, input) {
   if (input.kind === "selfhosted") {
@@ -660,8 +777,34 @@ async function requireAccessContext(c, deps) {
   return context;
 }
 async function requireAccessGrant(c, deps, workspaceId, permission) {
+  return (await requireAccessGrantAuthorization(c, deps, workspaceId, permission)).grant;
+}
+function accessGrantAuthorizationFromContext(context, grant) {
+  const matchingAccountGrants = context.accountGrants.filter(
+    (candidate) => candidate.accountId === grant.accountId
+  );
+  const delegated = grant.metadata?.delegated === true;
+  const contextIntegrity = context.subjectId === grant.subjectId && context.accountGrants.every((candidate) => candidate.subjectId === context.subjectId) && context.workspaceGrants.every(
+    (candidate) => candidate.subjectId === context.subjectId && candidate.principalKind === grant.principalKind && candidate.metadata?.delegated === true === delegated && Boolean(candidate.serviceInitiator) === Boolean(grant.serviceInitiator) && Boolean(candidate.serviceInitiatorContext) === Boolean(grant.serviceInitiatorContext) && context.accountGrants.filter(
+      (accountGrant) => accountGrant.accountId === candidate.accountId
+    ).length === 1
+  ) && matchingAccountGrants.length === 1 && matchingAccountGrants[0]?.subjectId === context.subjectId;
+  return {
+    grant,
+    accountGrant: contextIntegrity ? matchingAccountGrants[0] : null,
+    authenticatedSubjectId: context.subjectId,
+    contextIntegrity
+  };
+}
+async function requireAccessGrantAuthorization(c, deps, workspaceId, permission) {
   const context = await requireAccessContext(c, deps);
-  const grant = context.workspaceGrants.find((candidate) => candidate.workspaceId === workspaceId) ?? await getWorkspaceGrant(deps.db, context.subjectId, workspaceId);
+  const principalKind = hostedHumanSessionPrincipalKind(context);
+  const grant = context.workspaceGrants.find((candidate) => candidate.workspaceId === workspaceId) ?? await getWorkspaceGrant(
+    deps.db,
+    context.subjectId,
+    workspaceId,
+    principalKind ? { principalKind } : void 0
+  );
   if (!grant) {
     const workspace = await requireWorkspace(deps.db, workspaceId).catch(() => null);
     if (!workspace) {
@@ -672,7 +815,15 @@ async function requireAccessGrant(c, deps, workspaceId, permission) {
   if (permission) {
     requirePermission(grant, permission);
   }
-  return grant;
+  return accessGrantAuthorizationFromContext(context, grant);
+}
+function hostedHumanSessionPrincipalKind(context) {
+  if (context.mode !== "managed" || context.workspaceGrants.length === 0) {
+    return void 0;
+  }
+  return context.workspaceGrants.every(
+    (grant) => grant.principalKind === "human_session" && grant.metadata?.delegated !== true && !grant.serviceInitiator
+  ) ? "human_session" : void 0;
 }
 function requirePermission(grant, permission) {
   if (!hasPermission(grant.permissions, permission)) {
@@ -790,7 +941,8 @@ async function apiKeyAccessContext(c, deps, mode) {
         accountId: apiKey.accountId,
         subjectId,
         subjectLabel: apiKey.name,
-        permissions: apiKey.permissions
+        permissions: apiKey.permissions,
+        principalKind: "api_key"
       }
     ] : [],
     defaultAccountId: apiKey.accountId,
@@ -824,6 +976,7 @@ async function delegatedAccessContext(c, deps, mode, token = bearerToken(c)) {
         subjectId: payload.subjectId,
         ...payload.subjectLabel ? { subjectLabel: payload.subjectLabel } : {},
         permissions: payload.permissions,
+        principalKind: payload.principalKind,
         // sessionId is worker-asserted (HMAC-signed token claim), not agent
         // controlled; it scopes session-bound MCP tools such as goal management.
         metadata: {
@@ -3241,6 +3394,10 @@ var PROJECTABLE_REGISTRY_ID = /^[A-Za-z0-9_-]+$/;
 function sortedIds(ids) {
   return [...new Set(ids)].sort();
 }
+function defaultSessionMcpServerIds(servers) {
+  const mandatory = new Set(MANDATORY_SESSION_MCP_SERVER_IDS);
+  return sortedIds([...servers].map((server) => server.id).filter((id) => !mandatory.has(id)));
+}
 function projectIds(ids) {
   const projectable = ids.filter(
     (id) => id.length <= SESSION_EFFECTIVE_TOOL_POLICY_ID_MAX_LENGTH && PROJECTABLE_REGISTRY_ID.test(id)
@@ -3251,16 +3408,16 @@ function projectIds(ids) {
   };
 }
 function resolveSessionToolPolicy(input) {
-  const policy = input.toolPolicy ?? { mode: "legacy", inheritedFromSessionId: null };
+  const policy = input.toolPolicy;
   const availableIds = new Set(input.availableMcpServerIds);
   const defaultIds = new Set(input.defaultMcpServerIds ?? []);
   const mandatoryIds = MANDATORY_SESSION_MCP_SERVER_IDS.filter(
     (id) => availableIds.has(id)
   );
   const mandatoryIdSet = new Set(mandatoryIds);
-  const selectedRefs = input.turnToolsProvided === true ? mergeToolRefs2([], input.turnTools ?? []) : input.turnToolsProvided === false ? mergeToolRefs2([], input.sessionTools) : mergeToolRefs2(input.sessionTools, input.turnTools ?? []);
-  const tracksWorkspaceDefaults = policy.mode === "workspace_default" && input.turnToolsProvided !== true;
-  let toolRefs = selectedRefs.filter((tool) => tool.optional !== true || availableIds.has(tool.id));
+  const selectedRefs = mergeToolRefs2([], input.sessionTools);
+  const tracksWorkspaceDefaults = policy.mode === "workspace_default";
+  let toolRefs = selectedRefs.filter((tool) => availableIds.has(tool.id));
   if (tracksWorkspaceDefaults) {
     toolRefs = mergeToolRefs2(
       toolRefs,
@@ -3326,16 +3483,13 @@ function resolveSessionToolPolicy(input) {
     }
   };
 }
-function sessionToolPolicyAllowsDefaultNativeTools(policy) {
-  return policy.mode === "workspace_default" && policy.lazyRouter.state === "required";
-}
 async function workspaceSessionToolPolicyServerIds(db, workspaceId, settings) {
   const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings);
   return sortedIds(runtimeSettings.mcpServers.map((server) => server.id));
 }
 async function workspaceSessionToolPolicyDefaultServerIds(db, workspaceId, settings) {
   const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings);
-  return sortedIds(enabledCapabilityMcpToolRefs(settings, runtimeSettings).map((tool) => tool.id));
+  return defaultSessionMcpServerIds(runtimeSettings.mcpServers);
 }
 function sessionWithEffectiveToolPolicy(session, workspaceServerIds, workspaceDefaultServerIds = []) {
   const availableIds = new Set(workspaceServerIds);
@@ -3345,7 +3499,7 @@ function sessionWithEffectiveToolPolicy(session, workspaceServerIds, workspaceDe
   return {
     ...session,
     effectiveToolPolicy: resolveSessionToolPolicy({
-      ...session.toolPolicy ? { toolPolicy: session.toolPolicy } : {},
+      toolPolicy: session.toolPolicy,
       sessionTools: session.tools,
       availableMcpServerIds: availableIds,
       defaultMcpServerIds: workspaceDefaultServerIds
@@ -3367,7 +3521,7 @@ import {
 import { HTTPException as HTTPException11 } from "hono/http-exception";
 
 // src/domain/sessions.ts
-import { CODEX_MODEL_ID_PREFIX } from "@opengeni/codex";
+import { CODEX_MODEL_ID_PREFIX, isCodexBilledModel } from "@opengeni/codex";
 import {
   canonicalizeConfiguredModelId,
   configuredAllowedModels,
@@ -3378,11 +3532,13 @@ import {
   CreateSessionRequest,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
   DEFAULT_FIRST_PARTY_MCP_TOOLS,
+  FIRST_PARTY_MCP_TOOL_NAMES,
   OPENGENI_SLACK_BOT_SESSION_METADATA_KEY as OPENGENI_SLACK_BOT_SESSION_METADATA_KEY2,
   SessionSpawnDenial,
   ServiceTurnInitiator,
   ServiceTurnInitiatorContext,
   evaluateWorkspaceModelPolicy,
+  latencyModeForMetadata,
   reasoningEffortForMetadata,
   stableJson as stableJson2,
   SessionMcpApprovalPolicy
@@ -3430,10 +3586,10 @@ import { HTTPException as HTTPException10 } from "hono/http-exception";
 // src/domain/slack-bot.ts
 import {
   OPENGENI_SLACK_BOT_CREDENTIAL_LABEL,
-  OPENGENI_SLACK_BOT_REQUIRED_SCOPES,
   OPENGENI_SLACK_BOT_CREDENTIAL_ROLE,
   OPENGENI_SLACK_BOT_SESSION_METADATA_KEY,
-  OpenGeniSlackBotConnectionMetadata
+  OpenGeniSlackBotConnectionMetadata,
+  areOpenGeniSlackBotScopesAccepted
 } from "@opengeni/contracts";
 import {
   getConnectionMetadata as getConnectionMetadata2
@@ -3444,8 +3600,7 @@ function openGeniSlackBotMetadata(metadata) {
   return parsed.success ? parsed.data : null;
 }
 function isOpenGeniSlackBotConnection(connection) {
-  const granted = new Set(connection.grantedScopes);
-  return connection.verifiedInstallAt != null && connection.verifiedInstallVersion === connection.version && connection.subjectId === null && connection.providerDomain === "slack.com" && connection.kind === "app_install" && granted.size === OPENGENI_SLACK_BOT_REQUIRED_SCOPES.length && OPENGENI_SLACK_BOT_REQUIRED_SCOPES.every((scope) => granted.has(scope)) && openGeniSlackBotMetadata(connection.metadata)?.credentialRole === OPENGENI_SLACK_BOT_CREDENTIAL_ROLE;
+  return connection.verifiedInstallAt != null && connection.verifiedInstallVersion === connection.version && connection.subjectId === null && connection.providerDomain === "slack.com" && connection.kind === "app_install" && areOpenGeniSlackBotScopesAccepted(connection.grantedScopes) && openGeniSlackBotMetadata(connection.metadata)?.credentialRole === OPENGENI_SLACK_BOT_CREDENTIAL_ROLE;
 }
 function hasReservedOpenGeniSlackBotMetadata(metadata) {
   return metadata?.credentialRole === OPENGENI_SLACK_BOT_CREDENTIAL_ROLE || metadata?.credentialLabel === OPENGENI_SLACK_BOT_CREDENTIAL_LABEL;
@@ -3502,7 +3657,7 @@ var SessionSpawnDeniedError = class extends Error {
 };
 function resolveFirstPartyMcpToolsForCreate(requested, parentStored) {
   if (requested !== void 0) return [...requested];
-  if (parentStored === void 0) return null;
+  if (parentStored === void 0) return [...DEFAULT_FIRST_PARTY_MCP_TOOLS];
   return [...parentStored ?? DEFAULT_FIRST_PARTY_MCP_TOOLS];
 }
 function sessionSpawnDeniedMessage(denial) {
@@ -3786,7 +3941,8 @@ async function createAndStartSession(input) {
   const sessionMetadata = {
     ...input.metadata,
     model: input.model,
-    reasoningEffort: input.reasoningEffort
+    reasoningEffort: input.reasoningEffort,
+    ...input.latencyMode !== void 0 ? { latencyMode: input.latencyMode } : {}
   };
   if (input.createIdempotencyKey) {
     const keyedResult = await createSessionWithIdempotencyKeyResult(input.db, {
@@ -3798,7 +3954,7 @@ async function createAndStartSession(input) {
       resources: input.resources,
       skills: input.skills ?? [],
       tools: input.tools,
-      ...input.toolPolicy ? { toolPolicy: input.toolPolicy } : {},
+      toolPolicy: input.toolPolicy,
       metadata: sessionMetadata,
       ...input.createdBy ? { createdBy: input.createdBy } : {},
       ...input.createdByContext ? { createdByContext: input.createdByContext } : {},
@@ -3809,7 +3965,7 @@ async function createAndStartSession(input) {
       rigId: input.rigId ?? null,
       rigVersionId: input.rigVersionId ?? null,
       firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
-      firstPartyMcpTools: input.firstPartyMcpTools ?? null,
+      firstPartyMcpTools: input.firstPartyMcpTools,
       instructions: input.instructions ?? null,
       parentSessionId: input.parentSessionId ?? null,
       createIdempotencyKey: input.createIdempotencyKey,
@@ -3843,7 +3999,7 @@ async function createAndStartSession(input) {
       resources: input.resources,
       skills: input.skills ?? [],
       tools: input.tools,
-      ...input.toolPolicy ? { toolPolicy: input.toolPolicy } : {},
+      toolPolicy: input.toolPolicy,
       metadata: sessionMetadata,
       ...input.createdBy ? { createdBy: input.createdBy } : {},
       ...input.createdByContext ? { createdByContext: input.createdByContext } : {},
@@ -3854,7 +4010,7 @@ async function createAndStartSession(input) {
       rigId: input.rigId ?? null,
       rigVersionId: input.rigVersionId ?? null,
       firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
-      firstPartyMcpTools: input.firstPartyMcpTools ?? null,
+      firstPartyMcpTools: input.firstPartyMcpTools,
       instructions: input.instructions ?? null,
       parentSessionId: input.parentSessionId ?? null,
       sandboxGroupId: input.sandboxGroupId ?? null,
@@ -3908,7 +4064,7 @@ async function finishStartSession(input, session) {
     reasoningEffortFallback: input.reasoningEffort,
     turnExecutionPolicy: input.turnExecutionPolicy,
     createdEventPayload: {
-      ...input.toolPolicy ? { toolPolicy: input.toolPolicy } : {},
+      toolPolicy: input.toolPolicy,
       ...input.variableSet ? { variableSetId: input.variableSet.id, variableSetName: input.variableSet.name } : {},
       ...input.sessionMcpServers?.length ? { mcpServers: input.sessionMcpServers } : {}
     },
@@ -3952,6 +4108,24 @@ function canonicalConfiguredModel(settings, model) {
 function assertConfiguredModel(settings, model) {
   canonicalConfiguredModel(settings, model);
 }
+var CODEX_COMPACTION_V2_PROVIDER_LOCKED = "codex_compaction_v2_provider_locked";
+var CodexCompactionV2ProviderLockedError = class extends Error {
+  code = CODEX_COMPACTION_V2_PROVIDER_LOCKED;
+  productModelId;
+  constructor(productModelId) {
+    super(
+      `session is locked to Codex remote compaction v2; model "${productModelId}" is not a Codex subscription model`
+    );
+    this.name = "CodexCompactionV2ProviderLockedError";
+    this.productModelId = productModelId;
+  }
+};
+function assertSessionAllowsProductModel(session, productModelId) {
+  if (productModelId === null || productModelId === void 0) return;
+  if (session.codexCompactionMode !== "remote_v2") return;
+  if (isCodexBilledModel(productModelId)) return;
+  throw new CodexCompactionV2ProviderLockedError(productModelId);
+}
 async function assertWorkspaceModelPolicyAllows(db, settings, workspaceId, model) {
   if (model === null || model === void 0) {
     return;
@@ -3990,12 +4164,25 @@ async function requireQueuedTurnForApi(db, workspaceId, sessionId, turnId) {
 function reasoningEffortForSession(metadata, fallback) {
   return reasoningEffortForMetadata(metadata, fallback);
 }
+function latencyModeForSession(metadata, fallback = "standard") {
+  return latencyModeForMetadata(metadata, fallback);
+}
 async function postUserMessageTurn(input) {
   const { db, bus, workflowClient, settings, accountId, workspaceId, sessionId } = input;
   const requestedModel = canonicalConfiguredModel(settings, input.model ?? null) ?? null;
   const requestedReasoningEffort = input.reasoningEffort ?? null;
   assertConfiguredModel(settings, requestedModel);
   await assertWorkspaceModelPolicyAllows(db, settings, workspaceId, requestedModel);
+  const sessionForModelGate = await requireSession2(db, workspaceId, sessionId);
+  const effectiveModelForGate = requestedModel ?? sessionForModelGate.model;
+  try {
+    assertSessionAllowsProductModel(sessionForModelGate, effectiveModelForGate);
+  } catch (error) {
+    if (error instanceof CodexCompactionV2ProviderLockedError) {
+      throw new HTTPException10(422, { message: error.message, cause: error });
+    }
+    throw error;
+  }
   const operationKey = input.clientEventId ?? crypto.randomUUID();
   let result;
   try {
@@ -4021,10 +4208,9 @@ async function postUserMessageTurn(input) {
           text: input.text,
           turnInstructions: input.turnInstructions ?? null,
           resources: input.resources,
-          tools: input.tools,
-          toolsProvided: input.toolsProvided,
           model: requestedModel,
           reasoningEffort: requestedReasoningEffort,
+          latencyMode: input.latencyMode ?? null,
           reasoningEffortFallback: input.reasoningEffortFallback ?? settings.openaiReasoningEffort,
           turnExecutionPolicy: input.turnExecutionPolicy,
           source: input.origin === "operator" ? "api" : "user",
@@ -4215,12 +4401,15 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   }
   await assertWorkspaceModelPolicyAllows(db, settings, workspaceId, model);
   const reasoningEffort = payload.reasoningEffort ?? settings.openaiReasoningEffort;
+  const latencyMode = payload.latencyMode ?? "standard";
   const turnExecutionPolicy = resolveTurnExecutionPolicyV1(settings, {
     modelId: model,
     requestedModelId: payload.model ?? null,
     modelSource: payload.model === void 0 ? "deployment" : "explicit",
     reasoningEffort,
-    reasoningSource: payload.reasoningEffort === void 0 ? "deployment" : "explicit"
+    reasoningSource: payload.reasoningEffort === void 0 ? "deployment" : "explicit",
+    latencyMode,
+    latencyModeSource: payload.latencyMode === void 0 ? "deployment" : "explicit"
   });
   const parentFirstPartyMcpPermissions = parentSession ? [...parentSession.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS] : null;
   if (parentFirstPartyMcpPermissions && payload.firstPartyMcpPermissions?.some(
@@ -4255,9 +4444,8 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
     parentSession ? parentSession.firstPartyMcpTools : void 0
   );
   if (payload.goal) {
-    const effectiveTools = firstPartyMcpTools ?? [...DEFAULT_FIRST_PARTY_MCP_TOOLS];
     const missingGoalTools = ["goal_update", "goal_complete", "goal_pause"].filter(
-      (name) => !effectiveTools.includes(name)
+      (name) => !firstPartyMcpTools.includes(name)
     );
     if (missingGoalTools.length > 0) {
       throw new HTTPException10(422, {
@@ -4385,6 +4573,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
       ...payload.clientEventId ? { clientEventId: payload.clientEventId } : {},
       model,
       reasoningEffort,
+      latencyMode,
       turnExecutionPolicy,
       // A shared spawn inherits the box's backend; a caller-supplied
       // sandboxBackend on a shared spawn is ignored (it is the same box). A
@@ -4458,61 +4647,43 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   return session;
 }
 async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, input) {
-  if (input.toolsProvided && !deps.settings.sessionTurnToolReplacementEnabled) {
-    throw new HTTPException10(503, {
-      message: "explicit follow-up tool replacement is temporarily unavailable until provenance-aware turn workers finish rolling out; omit tools to inherit the session policy and retry"
-    });
-  }
   const { settings, db, bus, workflowClient, objectStorage } = deps;
   await requireSessionAuthorization(deps, grant, {
     sessionId,
     operation: input.delivery === "steer" ? "session.steer" : "session.append",
     surface: "core"
   });
-  const capabilityRuntimeSettings = await settingsWithEnabledCapabilityMcpServers(
-    db,
-    workspaceId,
-    settings
-  );
   const existingSession = await requireSession2(db, workspaceId, sessionId);
   const requestedModel = canonicalConfiguredModel(settings, input.model ?? null) ?? null;
   const effectiveModel = canonicalConfiguredModel(settings, requestedModel ?? existingSession.model) ?? null;
   if (effectiveModel === null) {
     throw new Error("effective follow-up model unexpectedly resolved to null");
   }
+  try {
+    assertSessionAllowsProductModel(existingSession, effectiveModel);
+  } catch (error) {
+    if (error instanceof CodexCompactionV2ProviderLockedError) {
+      throw new HTTPException10(422, { message: error.message, cause: error });
+    }
+    throw error;
+  }
   const sessionReasoningEffort = reasoningEffortForSession(
     existingSession.metadata,
     settings.openaiReasoningEffort
   );
   const effectiveReasoningEffort = input.reasoningEffort ?? sessionReasoningEffort;
+  const sessionLatencyMode = latencyModeForSession(existingSession.metadata, "standard");
+  const effectiveLatencyMode = input.latencyMode ?? sessionLatencyMode;
   const turnExecutionPolicy = resolveTurnExecutionPolicyV1(settings, {
     modelId: effectiveModel,
     requestedModelId: input.model ?? null,
     modelSource: input.model == null ? "session" : "explicit",
     reasoningEffort: effectiveReasoningEffort,
-    reasoningSource: input.reasoningEffort == null ? "session" : "explicit"
+    reasoningSource: input.reasoningEffort == null ? "session" : "explicit",
+    latencyMode: effectiveLatencyMode,
+    latencyModeSource: input.latencyMode == null ? "session" : "explicit"
   });
-  const runtimeSettings = settingsWithSessionMcpServerMetadata(
-    capabilityRuntimeSettings,
-    existingSession.mcpServers
-  );
   const requestedResources = normalizeResources(input.resources ?? []);
-  const tracksWorkspaceDefaults = existingSession.toolPolicy?.mode === "workspace_default";
-  const sessionPolicyTools = withFirstPartyTools(
-    tracksWorkspaceDefaults ? withDefaultEnabledCapabilityMcpTools(
-      availableToolRefs(existingSession.tools, runtimeSettings),
-      settings,
-      capabilityRuntimeSettings
-    ) : existingSession.tools,
-    runtimeSettings
-  );
-  const validatedTools = input.toolsProvided ? validateToolRefsForSessionPolicy({
-    requested: input.tools ?? [],
-    settings: runtimeSettings,
-    allowedTools: sessionPolicyTools,
-    message: "message tools may only narrow the session tool policy"
-  }) : [];
-  const requestedTools = input.toolsProvided ? validatedTools : [];
   await requireLimit(deps, {
     accountId: grant.accountId,
     workspaceId,
@@ -4546,10 +4717,9 @@ async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, inp
     text: input.text,
     turnInstructions: input.turnInstructions ?? null,
     resources: requestedResources,
-    tools: requestedTools,
-    toolsProvided: input.toolsProvided,
     model: input.model ?? null,
     reasoningEffort: input.reasoningEffort ?? null,
+    latencyMode: input.latencyMode ?? null,
     reasoningEffortFallback: sessionReasoningEffort,
     turnExecutionPolicy,
     mcpCredentialUpdates,
@@ -4654,7 +4824,7 @@ async function updateSessionMcpApprovalPolicy(deps, grant, sessionId, serverId,
     effectiveFrom: "next_attempt"
   };
 }
-function toolPolicyAuditSnapshot(session, tools, policy = session.toolPolicy ?? { mode: "legacy", inheritedFromSessionId: null }) {
+function toolPolicyAuditSnapshot(session, tools, firstPartyMcpTools, policy = session.toolPolicy) {
   const allToolRefs = mergeToolRefs([], tools).sort((left, right) => {
     const leftMandatory = left.kind === "mcp" && left.id === "opengeni";
     const rightMandatory = right.kind === "mcp" && right.id === "opengeni";
@@ -4673,6 +4843,8 @@ function toolPolicyAuditSnapshot(session, tools, policy = session.toolPolicy ??
     toolIds: [...toolRefs].sort((left, right) => `${left.kind}:${left.id}`.localeCompare(`${right.kind}:${right.id}`)).map((tool) => tool.id),
     toolRefs,
     toolCount: allToolRefs.length,
+    firstPartyMcpTools: [...firstPartyMcpTools].sort(),
+    firstPartyMcpToolCount: firstPartyMcpTools.length,
     truncated: allToolRefs.length > toolRefs.length
   };
 }
@@ -4706,10 +4878,12 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
     }
     return withFirstPartyTools(validatedTools, runtimeSettings);
   })() : null;
+  const explicitRequestedFirstPartyTools = explicitRequest ? [...explicitRequest.firstPartyMcpTools] : null;
   const workspaceDefaultTools = withFirstPartyTools(
     withDefaultEnabledCapabilityMcpTools([], deps.settings, capabilityRuntimeSettings),
     runtimeSettings
   );
+  const workspaceDefaultFirstPartyTools = [...FIRST_PARTY_MCP_TOOL_NAMES];
   const events = await appendSessionEventsWithLockedSessionUpdate(
     deps.db,
     grant.workspaceId,
@@ -4720,6 +4894,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
         throw new SessionToolPolicyVersionConflictError(currentVersion);
       }
       let nextTools;
+      let nextFirstPartyMcpTools;
       let nextPolicy;
       if (session.parentSessionId) {
         const parent = await context.getLockedSession(session.parentSessionId);
@@ -4735,6 +4910,9 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
           ) : parent.tools,
           runtimeSettings
         );
+        const parentFirstPartyMcpTools = [
+          ...parent.firstPartyMcpTools ?? DEFAULT_FIRST_PARTY_MCP_TOOLS
+        ];
         if (requestedMode === "workspace_default") {
           if (!parentTracksWorkspaceDefaults) {
             throw new HTTPException10(403, {
@@ -4742,6 +4920,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
             });
           }
           nextTools = parentEffective;
+          nextFirstPartyMcpTools = parentFirstPartyMcpTools;
           nextPolicy = {
             mode: "workspace_default",
             inheritedFromSessionId: parent.id
@@ -4753,6 +4932,16 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
             parentEffective,
             "session tools may only narrow the parent session tool policy"
           );
+          const parentFirstPartySet = new Set(parentFirstPartyMcpTools);
+          const widenedFirstPartyTool = explicitRequestedFirstPartyTools.find(
+            (tool) => !parentFirstPartySet.has(tool)
+          );
+          if (widenedFirstPartyTool) {
+            throw new HTTPException10(403, {
+              message: `session OpenGeni tools may only narrow the parent policy: ${widenedFirstPartyTool}`
+            });
+          }
+          nextFirstPartyMcpTools = explicitRequestedFirstPartyTools;
           nextPolicy = {
             mode: "explicit",
             inheritedFromSessionId: parent.id
@@ -4760,13 +4949,19 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
         }
       } else {
         nextTools = requestedMode === "workspace_default" ? workspaceDefaultTools : explicitRequestedTools;
+        nextFirstPartyMcpTools = requestedMode === "workspace_default" ? workspaceDefaultFirstPartyTools : explicitRequestedFirstPartyTools;
         nextPolicy = { mode: requestedMode, inheritedFromSessionId: null };
       }
-      const currentPolicy = session.toolPolicy ?? {
-        mode: "legacy",
-        inheritedFromSessionId: null
-      };
-      const unchanged = stableJson2({ tools: session.tools, policy: currentPolicy }) === stableJson2({ tools: nextTools, policy: nextPolicy });
+      const currentPolicy = session.toolPolicy;
+      const unchanged = stableJson2({
+        tools: session.tools,
+        firstPartyMcpTools: session.firstPartyMcpTools ?? DEFAULT_FIRST_PARTY_MCP_TOOLS,
+        policy: currentPolicy
+      }) === stableJson2({
+        tools: nextTools,
+        firstPartyMcpTools: nextFirstPartyMcpTools,
+        policy: nextPolicy
+      });
       if (unchanged) {
         return { events: [] };
       }
@@ -4776,8 +4971,18 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
           {
             type: "session.tool_policy.updated",
             payload: {
-              before: toolPolicyAuditSnapshot(session, session.tools, currentPolicy),
-              after: toolPolicyAuditSnapshot(session, nextTools, nextPolicy),
+              before: toolPolicyAuditSnapshot(
+                session,
+                session.tools,
+                [...session.firstPartyMcpTools ?? DEFAULT_FIRST_PARTY_MCP_TOOLS],
+                currentPolicy
+              ),
+              after: toolPolicyAuditSnapshot(
+                session,
+                nextTools,
+                nextFirstPartyMcpTools,
+                nextPolicy
+              ),
               version: nextVersion,
               effectiveFrom: "next_attempt"
             }
@@ -4785,6 +4990,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
         ],
         update: {
           tools: nextTools,
+          firstPartyMcpTools: nextFirstPartyMcpTools,
           toolPolicy: nextPolicy,
           toolPolicyVersion: nextVersion,
           expectedToolPolicyVersion: request.expectedVersion
@@ -5076,6 +5282,424 @@ function trimmedScheduledTaskName(name) {
   return trimmed;
 }
 
+// src/domain/insights.ts
+import { configuredStaticUsageLimits as configuredStaticUsageLimits2 } from "@opengeni/config";
+import {
+  WorkspaceInsightsSnapshot
+} from "@opengeni/contracts";
+import {
+  aggregateModelCallFacts,
+  aggregateModelCallFactsByDay,
+  aggregateRootSessionDrivers,
+  aggregateScheduleFacts,
+  aggregateSessionDepth,
+  aggregateWarmSecondsByGroup,
+  countOnlineMachines,
+  countScheduledTaskFires,
+  countSessionsAttachedToGroups,
+  enumerateUtcDays,
+  listFloorSessions,
+  listLiveWarmLeases,
+  listModelCallFacets,
+  listScheduledTasks,
+  requireWorkspace as requireWorkspace3,
+  sumUsageQuantity as sumUsageQuantity2,
+  sumUsageQuantityByDay,
+  sumUsageQuantityInRange
+} from "@opengeni/db";
+var MACHINE_HEARTBEAT_FRESH_MS = 12e4;
+function microsToUsd(micros) {
+  return Math.round(micros / 1e6 * 100) / 100;
+}
+function cacheHitPct(cached, input) {
+  if (input <= 0) return 0;
+  return Math.min(100, Math.max(0, Math.round(cached / input * 100)));
+}
+function startOfUtcDay(date) {
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+function startOfUtcMonth2(date) {
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1));
+}
+function startOfUtcYear(date) {
+  return new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+}
+function resolveRangeWindow(range, now) {
+  const until = now;
+  let since;
+  let rangeLabel;
+  let priorLabel;
+  let seriesLabel;
+  let cacheSeriesLabel;
+  switch (range) {
+    case "today":
+      since = startOfUtcDay(now);
+      rangeLabel = "Today (UTC)";
+      priorLabel = "Prior equal window";
+      seriesLabel = "Credit $ (UTC day)";
+      cacheSeriesLabel = "Cache hit %";
+      break;
+    case "week":
+      since = new Date(startOfUtcDay(now).getTime() - 6 * 24 * 60 * 60 * 1e3);
+      rangeLabel = "Last 7 days (UTC)";
+      priorLabel = "Prior 7 days";
+      seriesLabel = "Credit $ / day";
+      cacheSeriesLabel = "Cache hit % / day";
+      break;
+    case "month":
+      since = startOfUtcMonth2(now);
+      rangeLabel = "This month (UTC)";
+      priorLabel = "Prior equal window";
+      seriesLabel = "Credit $ / day";
+      cacheSeriesLabel = "Cache hit % / day";
+      break;
+    case "ytd":
+      since = startOfUtcYear(now);
+      rangeLabel = "Year to date (UTC)";
+      priorLabel = "Prior equal window";
+      seriesLabel = "Credit $ / day";
+      cacheSeriesLabel = "Cache hit % / day";
+      break;
+    default: {
+      const _exhaustive = range;
+      throw new Error(`Unknown insights range: ${_exhaustive}`);
+    }
+  }
+  const durationMs = until.getTime() - since.getTime();
+  const priorUntil = since;
+  const priorSince = new Date(priorUntil.getTime() - Math.max(durationMs, 1));
+  return {
+    since,
+    until,
+    priorSince,
+    priorUntil,
+    rangeLabel,
+    priorLabel,
+    seriesLabel,
+    cacheSeriesLabel
+  };
+}
+function ageLabel(updatedAt, now) {
+  const ms = Math.max(0, now.getTime() - updatedAt.getTime());
+  const minutes = Math.floor(ms / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+function floorState(input) {
+  if (input.directControlState === "paused") return "paused";
+  switch (input.status) {
+    case "running":
+      return "running";
+    case "failed":
+      return "failed";
+    case "requires_action":
+    case "waiting":
+      return "waiting";
+    case "compacting":
+      return "compacting";
+    case "completed":
+    case "idle":
+    case "queued":
+      return "idle";
+    default:
+      return "idle";
+  }
+}
+function billingPathOf(value) {
+  return value === "external" ? "external" : "opengeni_credits";
+}
+async function getWorkspaceInsights(db, settings, input) {
+  await requireWorkspace3(db, input.workspaceId);
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const window = resolveRangeWindow(input.range, now);
+  const provider = input.provider?.trim() || null;
+  const model = input.model?.trim() || null;
+  const modelFilterActive = Boolean(provider || model);
+  const filter = { provider, model };
+  const [
+    workspaceCreditMicros,
+    priorWorkspaceCreditMicros,
+    warmSeconds,
+    priorWarmSeconds,
+    modelRows,
+    priorModelRows,
+    factDays,
+    warmDays,
+    costDays,
+    warmGroups,
+    liveWarm,
+    rootDrivers,
+    scheduleFacts,
+    tasks,
+    depth,
+    floorRows,
+    machinesOnline,
+    billableTokensUsed,
+    agentRunsUsed,
+    facets
+  ] = await Promise.all([
+    sumUsageQuantityInRange(db, {
+      workspaceId: input.workspaceId,
+      eventType: "model.cost",
+      since: window.since,
+      until: window.until
+    }),
+    sumUsageQuantityInRange(db, {
+      workspaceId: input.workspaceId,
+      eventType: "model.cost",
+      since: window.priorSince,
+      until: window.priorUntil
+    }),
+    sumUsageQuantityInRange(db, {
+      workspaceId: input.workspaceId,
+      eventType: "sandbox.warm_seconds",
+      since: window.since,
+      until: window.until
+    }),
+    sumUsageQuantityInRange(db, {
+      workspaceId: input.workspaceId,
+      eventType: "sandbox.warm_seconds",
+      since: window.priorSince,
+      until: window.priorUntil
+    }),
+    aggregateModelCallFacts(db, {
+      workspaceId: input.workspaceId,
+      since: window.since,
+      until: window.until,
+      ...filter
+    }),
+    aggregateModelCallFacts(db, {
+      workspaceId: input.workspaceId,
+      since: window.priorSince,
+      until: window.priorUntil,
+      ...filter
+    }),
+    aggregateModelCallFactsByDay(db, {
+      workspaceId: input.workspaceId,
+      since: window.since,
+      until: window.until,
+      ...filter
+    }),
+    sumUsageQuantityByDay(db, {
+      workspaceId: input.workspaceId,
+      eventType: "sandbox.warm_seconds",
+      since: window.since,
+      until: window.until
+    }),
+    sumUsageQuantityByDay(db, {
+      workspaceId: input.workspaceId,
+      eventType: "model.cost",
+      since: window.since,
+      until: window.until
+    }),
+    aggregateWarmSecondsByGroup(db, {
+      workspaceId: input.workspaceId,
+      since: window.since,
+      until: window.until,
+      limit: 24
+    }),
+    listLiveWarmLeases(db, input.workspaceId),
+    aggregateRootSessionDrivers(db, {
+      workspaceId: input.workspaceId,
+      since: window.since,
+      until: window.until,
+      ...filter,
+      limit: 8
+    }),
+    aggregateScheduleFacts(db, {
+      workspaceId: input.workspaceId,
+      since: window.since,
+      until: window.until,
+      ...filter
+    }),
+    listScheduledTasks(db, input.workspaceId, 100),
+    aggregateSessionDepth(db, input.workspaceId),
+    listFloorSessions(db, input.workspaceId, 24),
+    settings.sandboxSelfhostedEnabled ? countOnlineMachines(db, input.workspaceId, MACHINE_HEARTBEAT_FRESH_MS) : Promise.resolve(0),
+    sumUsageQuantity2(db, {
+      workspaceId: input.workspaceId,
+      eventType: "model.tokens",
+      since: startOfUtcMonth2(now)
+    }),
+    sumUsageQuantity2(db, {
+      workspaceId: input.workspaceId,
+      eventType: "agent_run.created",
+      since: startOfUtcMonth2(now)
+    }),
+    listModelCallFacets(db, {
+      workspaceId: input.workspaceId,
+      since: window.since,
+      until: window.until
+    })
+  ]);
+  const priorRootDrivers = await aggregateRootSessionDrivers(db, {
+    workspaceId: input.workspaceId,
+    since: window.priorSince,
+    until: window.priorUntil,
+    ...filter,
+    rootSessionIds: rootDrivers.map((row) => row.rootSessionId)
+  });
+  const attached = await countSessionsAttachedToGroups(
+    db,
+    input.workspaceId,
+    warmGroups.map((group) => group.groupId)
+  );
+  const backendByGroup = new Map(liveWarm.map((lease) => [lease.groupId, lease.backend]));
+  const warmSecondsByGroup = new Map(warmGroups.map((group) => [group.groupId, group.warmSeconds]));
+  const models = modelRows.map((row) => ({
+    id: `${row.provider}:${row.model}:${row.billingPath}`,
+    model: row.model,
+    provider: row.provider,
+    billing: billingPathOf(row.billingPath),
+    calls: row.calls,
+    inputTokens: row.inputTokens,
+    outputTokens: row.outputTokens,
+    cachedTokens: row.cachedTokens,
+    cacheWriteTokens: row.cacheWriteTokens,
+    reasoningTokens: row.reasoningTokens,
+    creditUsd: microsToUsd(row.pricedCostMicros)
+  })).sort((a, b) => b.inputTokens - a.inputTokens);
+  const creditMicros = modelRows.reduce((sum, row) => sum + row.pricedCostMicros, 0);
+  const priorCreditMicros = priorModelRows.reduce((sum, row) => sum + row.pricedCostMicros, 0);
+  const priorInputTokens = priorModelRows.reduce((sum, row) => sum + row.inputTokens, 0);
+  const priorCachedTokens = priorModelRows.reduce((sum, row) => sum + row.cachedTokens, 0);
+  const priorCalls = priorModelRows.reduce((sum, row) => sum + row.calls, 0);
+  const days = enumerateUtcDays(window.since, window.until);
+  const series = days.map((day) => {
+    const facts = factDays.get(day) ?? {
+      costMicros: 0,
+      inputTokens: 0,
+      cachedTokens: 0,
+      calls: 0
+    };
+    const modelCostMicros = modelFilterActive ? facts.costMicros : costDays.get(day) ?? facts.costMicros;
+    return {
+      label: day.slice(5),
+      modelCostUsd: microsToUsd(modelCostMicros),
+      warmSeconds: warmDays.get(day) ?? 0,
+      inputTokens: facts.inputTokens,
+      cachedTokens: facts.cachedTokens,
+      cacheHitPct: cacheHitPct(facts.cachedTokens, facts.inputTokens),
+      calls: facts.calls
+    };
+  });
+  const priorDriverByRoot = new Map(
+    priorRootDrivers.map((row) => [row.rootSessionId, row.pricedCostMicros])
+  );
+  const creditUsdForPct = Math.max(microsToUsd(creditMicros), 0.01);
+  const drivers = rootDrivers.map((row) => {
+    const creditUsd = microsToUsd(row.pricedCostMicros);
+    const priorUsd = microsToUsd(priorDriverByRoot.get(row.rootSessionId) ?? 0);
+    return {
+      id: `root:${row.rootSessionId}`,
+      groupBy: "root_session",
+      label: row.title?.trim() || row.rootSessionId.slice(0, 8),
+      creditUsd,
+      tokens: row.inputTokens,
+      cacheHitPct: cacheHitPct(row.cachedTokens, row.inputTokens),
+      pctOfCreditUsd: Math.min(100, Math.round(creditUsd / creditUsdForPct * 100)),
+      deltaUsdVsPrior: Math.round((creditUsd - priorUsd) * 100) / 100
+    };
+  });
+  const fireCounts = await countScheduledTaskFires(db, {
+    workspaceId: input.workspaceId,
+    since: window.since,
+    until: window.until,
+    taskIds: tasks.map((task) => task.id)
+  });
+  const scheduleFactById = new Map(scheduleFacts.map((row) => [row.scheduledTaskId, row]));
+  const schedules = tasks.map((task) => {
+    const fact = scheduleFactById.get(task.id);
+    return {
+      id: task.id,
+      name: task.name,
+      fires: fireCounts.get(task.id) ?? 0,
+      creditUsd: fact ? microsToUsd(fact.pricedCostMicros) : null,
+      tokens: fact ? fact.inputTokens : null,
+      cacheHitPct: fact ? cacheHitPct(fact.cachedTokens, fact.inputTokens) : null,
+      billing: fact ? billingPathOf(fact.billingPath) : null
+    };
+  });
+  const limits = configuredStaticUsageLimits2(settings);
+  const floor = floorRows.filter((row) => {
+    if (!model) return true;
+    return row.model === model;
+  }).map((row) => ({
+    id: row.id,
+    title: row.title?.trim() || "Untitled session",
+    state: floorState(row),
+    depth: row.nestedAgentDepth,
+    model: row.model,
+    provider: null,
+    ageLabel: ageLabel(row.updatedAt, now),
+    cacheHitPct: null,
+    route: row.sandboxBackend
+  }));
+  const snapshot = WorkspaceInsightsSnapshot.parse({
+    range: input.range,
+    rangeLabel: window.rangeLabel,
+    priorLabel: window.priorLabel,
+    seriesLabel: window.seriesLabel,
+    cacheSeriesLabel: window.cacheSeriesLabel,
+    timezone: "UTC",
+    models,
+    facets,
+    series,
+    depth: depth.buckets.map((bucket) => ({
+      depth: bucket.depth,
+      sessions: bucket.sessions
+    })),
+    drivers,
+    schedules,
+    warmSeconds,
+    priorWarmSeconds,
+    warmGroups: warmGroups.map((group) => ({
+      id: group.groupId,
+      groupId: group.groupId,
+      label: group.groupId.slice(0, 8),
+      backend: backendByGroup.get(group.groupId) ?? null,
+      warmSeconds: group.warmSeconds,
+      sessionsAttached: attached.get(group.groupId) ?? 0
+    })),
+    liveWarm: liveWarm.map((lease) => ({
+      id: lease.id,
+      groupId: lease.groupId,
+      backend: lease.backend,
+      turnHolders: lease.turnHolders,
+      viewerHolders: lease.viewerHolders,
+      warmForLabel: lease.turnHolders > 0 ? "in use" : "idle warm",
+      warmSeconds: warmSecondsByGroup.get(lease.groupId) ?? 0
+    })),
+    floor,
+    selfhostedEnabled: settings.sandboxSelfhostedEnabled,
+    machinesOnline,
+    workspaceCreditUsd: microsToUsd(workspaceCreditMicros),
+    priorWorkspaceCreditUsd: microsToUsd(priorWorkspaceCreditMicros),
+    creditUsd: microsToUsd(creditMicros),
+    priorCreditUsd: microsToUsd(priorCreditMicros),
+    priorInputTokens,
+    priorCacheHitPct: cacheHitPct(priorCachedTokens, priorInputTokens),
+    priorCalls,
+    goalsActive: depth.goalsActive,
+    goalsCompleted: depth.goalsCompleted,
+    sessionsTouched: depth.sessionsTouched,
+    rootSessions: depth.rootSessions,
+    deepestDepth: depth.deepestDepth,
+    deepestSessionTitle: depth.deepestSessionTitle || "",
+    avgDepth: Math.round(depth.avgDepth * 10) / 10,
+    warmIdleNow: liveWarm.filter((lease) => lease.turnHolders === 0).length,
+    billableTokensUsed,
+    billableTokenCap: limits.maxMonthlyTokensPerWorkspace ?? null,
+    agentRunsUsed,
+    agentRunCap: limits.maxMonthlyAgentRunsPerWorkspace ?? null,
+    modelFilterActive
+  });
+  return { snapshot };
+}
+
 // src/domain/workspace-members.ts
 import { HTTPException as HTTPException12 } from "hono/http-exception";
 var MEMBER_ADMIN_PERMISSIONS = ["workspace:admin", "members:manage"];
@@ -5154,6 +5778,7 @@ function mapNewSessionDraft(row) {
     toolsProvided: newSessionDraftToolsProvided(row),
     model: row.model,
     reasoningEffort: row.reasoningEffort,
+    latencyMode: row.latencyMode,
     options: publicNewSessionDraftOptions(row),
     updatedAt: row.updatedAt.toISOString()
   });
@@ -5246,6 +5871,7 @@ async function getActorNewSessionDraft(deps, grant, workspaceId) {
     toolsProvided: false,
     model: deps.settings.openaiModel,
     reasoningEffort: deps.settings.openaiReasoningEffort,
+    latencyMode: "standard",
     options: {},
     updatedAt: null
   };
@@ -5284,6 +5910,7 @@ async function saveActorNewSessionDraft(deps, grant, workspaceId, rawInput) {
           toolsProvided,
           model: input.model,
           reasoningEffort: input.reasoningEffort,
+          latencyMode: input.latencyMode,
           options: input.options,
           // Only managed people are removed through removeWorkspaceMember().
           // API keys and delegated service actors (for example the first-party
@@ -5303,7 +5930,7 @@ async function saveActorNewSessionDraft(deps, grant, workspaceId, rawInput) {
 }
 
 // src/application/session-commands.ts
-import { reasoningEffortForMetadata as reasoningEffortForMetadata2 } from "@opengeni/contracts";
+import { latencyModeForMetadata as latencyModeForMetadata2, reasoningEffortForMetadata as reasoningEffortForMetadata2 } from "@opengeni/contracts";
 import {
   deleteSessionQueueItemInTransaction,
   editQueuedTurnInTransaction,
@@ -5355,14 +5982,14 @@ async function authorizeHumanSessionCommand(deps, context, operation) {
   return await requireSessionAuthorization(deps, humanAccessGrant(context), {
     sessionId: context.sessionId,
     operation,
-    surface: "core"
+    surface: context.authorizationSurface ?? "core"
   });
 }
 async function authorizeAgentSessionCommand(deps, context, targetSessionId, operation) {
   return await requireSessionAuthorization(deps, agentAccessGrant(context), {
     sessionId: targetSessionId,
     operation,
-    surface: "core"
+    surface: context.authorizationSurface ?? "core"
   });
 }
 function agentActor(context) {
@@ -5493,7 +6120,12 @@ async function steerAgentSession(deps, context, input) {
   return result;
 }
 async function controlAgentSessionWorkstream(deps, context, input) {
-  await authorizeAgentSessionCommand(deps, context, input.targetSessionId, "session.control");
+  const authorization = await authorizeAgentSessionCommand(
+    deps,
+    context,
+    input.targetSessionId,
+    "session.control"
+  );
   const result = await withWorkspaceRls(
     deps.db,
     context.workspaceId,
@@ -5514,7 +6146,7 @@ async function controlAgentSessionWorkstream(deps, context, input) {
   ]);
   await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
   await requestControlWakeDispatch(deps, result.wakeCount);
-  return result;
+  return { ...result, authorization };
 }
 function receipt(row) {
   return {
@@ -5536,10 +6168,9 @@ function composerDraft(row) {
     revision: row.revision,
     text: row.text,
     resources: row.resources,
-    tools: row.tools,
-    toolsProvided: row.toolsProvided,
     model: row.model,
     reasoningEffort: row.reasoningEffort,
+    latencyMode: row.latencyMode,
     sourceTurnId: row.sourceTurnId,
     sourceTurnVersion: row.sourceTurnVersion,
     updatedAt: row.updatedAt.toISOString()
@@ -5755,10 +6386,9 @@ async function getHumanComposerDraft(deps, context) {
     revision: 0,
     text: "",
     resources: [],
-    tools: [],
-    toolsProvided: false,
     model: session.model,
     reasoningEffort: reasoningEffortForMetadata2(session.metadata, "medium"),
+    latencyMode: latencyModeForMetadata2(session.metadata, "standard"),
     sourceTurnId: null,
     sourceTurnVersion: null,
     updatedAt: null
@@ -5781,6 +6411,8 @@ async function saveHumanComposerDraft(deps, context, input) {
   return composerDraft(row);
 }
 export {
+  CODEX_COMPACTION_V2_PROVIDER_LOCKED,
+  CodexCompactionV2ProviderLockedError,
   MARKETING_SOCIAL_PACK_ID,
   MAX_CHECKS_PER_RIG,
   MAX_CREDENTIAL_HOOKS_PER_RIG,
@@ -5795,7 +6427,9 @@ export {
   SessionAuthorizationDeniedError,
   SessionAuthorizationUnavailableError,
   SessionSpawnDeniedError,
+  TranscriptionServiceError,
   acceptSessionUserMessage,
+  accessGrantAuthorizationFromContext,
   activateRigVersionForApi,
   appendRigSetupCommand,
   applyCapabilityEnablement,
@@ -5803,6 +6437,7 @@ export {
   assertAllowedVariableSetVariableName,
   assertConfiguredModel,
   assertPackSandboxImageCompatible,
+  assertSessionAllowsProductModel,
   assertToolRefsSubset,
   assertWorkspaceDeletable,
   assertWorkspaceMemberRemovable,
@@ -5823,6 +6458,7 @@ export {
   createRigVersionForApi,
   createSessionForRequest,
   createValidatedScheduledTask,
+  defaultSessionMcpServerIds,
   deleteHumanQueuePrompt,
   deleteRigForApi,
   disableCapability,
@@ -5830,17 +6466,22 @@ export {
   editHumanQueuePrompt,
   enableCapability,
   enabledCapabilityMcpToolRefs,
+  executeRunOnSelfhostedMachine,
+  filenameForMimeType,
   getActorNewSessionDraft,
   getCapabilityPack,
   getHumanComposerDraft,
+  getWorkspaceInsights,
   hasPermission,
   hasReservedOpenGeniSlackBotMetadata,
   hasReservedOpenGeniSlackBotSessionMetadata,
+  isAcceptedMimeType,
   isAuthoritativeGitHubRepositorySelectionError,
   isBuiltInCapabilityPack,
   isOpenGeniSlackBotConnection,
   isTrustedScheduledSlackBotSession,
   isUserMember,
+  latencyModeForSession,
   listCapabilityPacks,
   listFleet,
   listRigChangesForApi,
@@ -5852,6 +6493,7 @@ export {
   mergeResourceRefs,
   mergeToolRefs,
   moveHumanQueuePrompt,
+  normalizeMimeType,
   normalizeResources,
   officialMcpRegistryUrl,
   openGeniSlackBotMetadata,
@@ -5869,6 +6511,7 @@ export {
   relayDialBaseFromSettings,
   requireAccessContext,
   requireAccessGrant,
+  requireAccessGrantAuthorization,
   requireEnvironmentEncryption,
   requireLimit,
   requireOpenGeniSlackBotConnection,
@@ -5897,13 +6540,13 @@ export {
   scheduledTaskTriggerToken,
   sendAgentSessionMessage,
   sessionSpawnDenialEnvelope,
-  sessionToolPolicyAllowsDefaultNativeTools,
   sessionWithEffectiveToolPolicy,
   settingsWithCodexAppsMcpServer,
   settingsWithEnabledCapabilityMcpServers,
   settingsWithMcpCapabilityServers,
   settingsWithSessionMcpServerMetadata,
   stableJson,
+  statusForVoiceInputError,
   steerAgentSession,
   steerHumanQueuePrompt,
   swapActiveSandbox,