@opengeni/core 3.0.1 → 4.0.0

package/src/domain/connector-tool-permissions.ts

@@ -0,0 +1,305 @@
+import { createHash } from "node:crypto";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import {
+  boundMcpResponseBody,
+  MCP_MAX_RESPONSE_BYTES,
+  assertMcpToolListWithinBounds,
+} from "@opengeni/runtime/mcp-network";
+import { createPinnedIntegrationTransport } from "@opengeni/capabilities";
+import type { Settings } from "@opengeni/config";
+import type {
+  AccessGrant,
+  ConnectorToolPermission,
+  ConnectorToolPermissionEntry,
+  ConnectorToolPermissionsResponse,
+  UpdateConnectorToolPermissionsRequest,
+} from "@opengeni/contracts";
+import {
+  buildConnectionTokenResolver,
+  getConnectionMetadata,
+  listConnectionsMetadata,
+  listEnabledMcpCapabilityServers,
+  listConnectorToolPermissionPolicies,
+  updateConnectorToolPermissionPolicies,
+  resolveConnectorActionPolicy,
+  type Database,
+} from "@opengeni/db";
+import { HTTPException } from "hono/http-exception";
+import { GMAIL_REST_MCP_TOOLS, isOfficialGmailMcpConfig } from "@opengeni/runtime";
+import { hasPermission } from "../access";
+import { buildCapabilityCatalog, settingsWithMcpCapabilityServers } from "./capabilities";
+
+type Input = {
+  db: Database;
+  settings: Settings;
+  workspaceId: string;
+  grant: AccessGrant;
+  capabilityId: string;
+  personalOwnerVerified: boolean;
+};
+type ListedTool = {
+  name: string;
+  title?: string | undefined;
+  description?: string | undefined;
+  annotations?:
+    | {
+        readOnlyHint?: boolean | undefined;
+        destructiveHint?: boolean | undefined;
+        title?: string | undefined;
+      }
+    | undefined;
+};
+
+export function connectorToolGroup(tool: ListedTool): "read" | "write" | "other" {
+  if (tool.annotations?.destructiveHint === true || tool.annotations?.readOnlyHint === false)
+    return "write";
+  if (tool.annotations?.readOnlyHint === true) return "read";
+  return "other";
+}
+
+async function resolveTarget(input: Input) {
+  const catalog = await buildCapabilityCatalog(input);
+  const item = catalog.items.find((candidate) => candidate.id === input.capabilityId);
+  if (
+    !item ||
+    !item.enabled ||
+    item.kind !== "mcp" ||
+    !item.runtime.mcpServerId ||
+    item.source === "built_in"
+  ) {
+    throw new HTTPException(404, { message: "Connected MCP connector not found" });
+  }
+  const enabled = await listEnabledMcpCapabilityServers(input.db, input.workspaceId);
+  const settings = settingsWithMcpCapabilityServers(input.settings, enabled);
+  const server = settings.mcpServers.find((candidate) => candidate.id === item.runtime.mcpServerId);
+  if (!server || server.url !== item.endpointUrl)
+    throw new HTTPException(409, { message: "Connector configuration is unavailable" });
+  const ref = server.connectionRef;
+  if (ref?.authoritySource === "host")
+    throw new HTTPException(409, {
+      message: "Tool permissions for this connection are managed by its host",
+    });
+  let connection = ref?.connectionId
+    ? await getConnectionMetadata(
+        input.db,
+        input.workspaceId,
+        ref.connectionId,
+        input.grant.subjectId,
+      )
+    : null;
+  if (ref?.subjectScope === "subject" && !ref.connectionId) {
+    const visible = await listConnectionsMetadata(
+      input.db,
+      input.workspaceId,
+      input.grant.subjectId,
+    );
+    connection =
+      visible.find(
+        (candidate) =>
+          candidate.subjectId === input.grant.subjectId &&
+          candidate.providerDomain === ref.providerDomain &&
+          (!ref.kind || candidate.kind === ref.kind) &&
+          candidate.status === "active",
+      ) ?? null;
+  }
+  if (
+    ref &&
+    (!connection ||
+      connection.providerDomain !== ref.providerDomain ||
+      (ref.kind && connection.kind !== ref.kind) ||
+      (ref.subjectScope === "subject"
+        ? connection.subjectId !== input.grant.subjectId
+        : connection.subjectId !== null))
+  ) {
+    throw new HTTPException(409, { message: "Reconnect this connector to manage its tools" });
+  }
+  if (connection?.subjectId && !input.personalOwnerVerified)
+    throw new HTTPException(403, {
+      message: "Only the authenticated connection owner may manage personal tool permissions",
+    });
+  // Same secret-free target identity used by runtime sessionMcpApprovalConnectionId.
+  const connectionId =
+    connection?.id ??
+    `session-mcp:${server.id}:${createHash("sha256").update(server.url, "utf8").digest("hex")}`;
+  return { server, connection, connectionId };
+}
+
+async function listTools(
+  input: Input,
+  target: Awaited<ReturnType<typeof resolveTarget>>,
+): Promise<ListedTool[]> {
+  // Runtime substitutes the reviewed REST bridge for this exact MCP identity.
+  // Its static catalog must not depend on Google's hosted MCP preview.
+  if (isOfficialGmailMcpConfig(target.server.url, target.server.connectionRef)) {
+    return GMAIL_REST_MCP_TOOLS.filter(
+      (tool) => !target.server.allowedTools || target.server.allowedTools.includes(tool.name),
+    );
+  }
+  let headers = { ...target.server.headers };
+  if (target.server.connectionRef) {
+    const result = await buildConnectionTokenResolver(
+      input.db,
+      input.settings,
+    )({
+      workspaceId: input.workspaceId,
+      ...(target.connection?.subjectId ? { subjectId: input.grant.subjectId } : {}),
+      serverId: target.server.id,
+      toolName: "tools/list",
+      connectionRef: { ...target.server.connectionRef, connectionId: target.connectionId },
+      destinationUrl: target.server.url,
+    });
+    if (result.status !== "ok") throw new Error("Reconnect this connector to load its tools.");
+    headers = { ...headers, ...result.headers };
+  }
+  const pinned = createPinnedIntegrationTransport({ network: input.settings });
+  const deadline = AbortSignal.timeout(15_000);
+  const client = new Client(
+    { name: "opengeni-tool-permissions", version: "0.1.0" },
+    { capabilities: {} },
+  );
+  try {
+    const transport = new StreamableHTTPClientTransport(new URL(target.server.url), {
+      requestInit: { headers },
+      fetch: async (url, init) =>
+        boundMcpResponseBody(
+          await pinned.fetch(url.toString(), {
+            ...init,
+            signal: init?.signal ? AbortSignal.any([deadline, init.signal]) : deadline,
+          }),
+          MCP_MAX_RESPONSE_BYTES,
+        ),
+    });
+    await client.connect(transport as unknown as Transport, {
+      timeout: 15_000,
+      maxTotalTimeout: 15_000,
+    });
+    const tools: ListedTool[] = [];
+    const cursors = new Set<string>();
+    let cursor: string | undefined;
+    do {
+      const page = await client.listTools(cursor ? { cursor } : undefined, {
+        timeout: 15_000,
+        maxTotalTimeout: 15_000,
+        signal: deadline,
+      });
+      tools.push(...page.tools);
+      assertMcpToolListWithinBounds(tools);
+      if (new Set(tools.map((tool) => tool.name)).size !== tools.length)
+        throw new Error("The connector returned duplicate tool names.");
+      cursor = page.nextCursor;
+      if (tools.length > 2048 || (cursor && cursors.has(cursor)))
+        throw new Error("The connector returned an invalid or oversized tool catalog.");
+      if (cursor) cursors.add(cursor);
+    } while (cursor);
+    return tools.filter(
+      (tool) => !target.server.allowedTools || target.server.allowedTools.includes(tool.name),
+    );
+  } finally {
+    await client.close().catch(() => undefined);
+  }
+}
+
+export async function getConnectorToolPermissions(
+  input: Input,
+): Promise<ConnectorToolPermissionsResponse> {
+  const target = await resolveTarget(input);
+  const policies = await listConnectorToolPermissionPolicies(input.db, {
+    accountId: input.grant.accountId,
+    workspaceId: input.workspaceId,
+    connectionId: target.connectionId,
+  });
+  const permission = (
+    name: string,
+  ): { permission: ConnectorToolPermission; inherited: boolean } => {
+    const resolved = resolveConnectorActionPolicy(policies, {
+      connectionId: target.connectionId,
+      serverId: target.server.id,
+      toolName: name,
+      actionName: "*",
+    });
+    if (!resolved.managed) return { permission: "allow", inherited: true };
+    return {
+      permission: resolved.entry?.policy ?? "block",
+      inherited: resolved.entry?.toolName !== name,
+    };
+  };
+  const defaultPolicy = policies.find(
+    (row) => row.serverId === target.server.id && row.toolName === "*" && row.actionName === "*",
+  );
+  let tools: ListedTool[] = [];
+  let discoveryError: string | null = null;
+  try {
+    tools = await listTools(input, target);
+    if (tools.some((tool) => tool.name === "*" || tool.name !== tool.name.trim())) {
+      tools = tools.filter((tool) => tool.name !== "*" && tool.name === tool.name.trim());
+      discoveryError =
+        "The connector exposes a reserved or whitespace-padded tool name. Individual permissions for these names are unsupported, so they are omitted from tool groups. The connector default still applies.";
+    }
+  } catch {
+    discoveryError =
+      "Could not load the connector's tools. Try again or reconnect. Your saved permissions still apply.";
+  }
+  return {
+    connectionId: target.connectionId,
+    serverId: target.server.id,
+    defaultPermission: defaultPolicy?.policy ?? null,
+    tools: tools.map(
+      (tool): ConnectorToolPermissionEntry => ({
+        name: tool.name,
+        ...((tool.title ?? tool.annotations?.title)
+          ? { title: tool.title ?? tool.annotations?.title }
+          : {}),
+        ...(tool.description ? { description: tool.description } : {}),
+        group: connectorToolGroup(tool),
+        ...permission(tool.name),
+        approvalRequired:
+          target.server.requireApproval === true ||
+          (Array.isArray(target.server.requireApproval) &&
+            target.server.requireApproval.includes(tool.name)),
+      }),
+    ),
+    discoveryError,
+    canManage: canManageConnectorPermissions(input.grant),
+  };
+}
+
+function canManageConnectorPermissions(grant: AccessGrant): boolean {
+  return (
+    hasPermission(grant.permissions, "capabilities:manage") &&
+    grant.principalKind !== "agent_attempt" &&
+    grant.principalKind !== "service" &&
+    !grant.serviceInitiator &&
+    !grant.serviceInitiatorContext
+  );
+}
+
+export async function updateConnectorToolPermissions(
+  input: Input & { payload: UpdateConnectorToolPermissionsRequest },
+): Promise<void> {
+  if (!canManageConnectorPermissions(input.grant))
+    throw new HTTPException(403, { message: "Connector management permission required" });
+  if (
+    input.payload.target === "tools" &&
+    input.payload.toolNames.some((name) => name === "*" || name !== name.trim())
+  )
+    throw new HTTPException(400, {
+      message: "Tool names must be exact and cannot use the connector-default wildcard.",
+    });
+  const target = await resolveTarget(input);
+  // Prevent a reconnect while the sheet is open from applying old choices to a new account.
+  if (target.connectionId !== input.payload.connectionId)
+    throw new HTTPException(409, {
+      message: "The connector account changed. Reload its permissions.",
+    });
+  await updateConnectorToolPermissionPolicies(input.db, {
+    accountId: input.grant.accountId,
+    workspaceId: input.workspaceId,
+    subjectId: input.grant.subjectId,
+    connectionId: target.connectionId,
+    serverId: target.server.id,
+    toolNames: input.payload.target === "default" ? ["*"] : input.payload.toolNames,
+    policy: input.payload.permission,
+  });
+}

package/src/domain/editable-artifacts/agent-application.ts

@@ -76,6 +76,7 @@ export type EditableArtifactAgentContext = Readonly<{
 
 export type EditableArtifactAgentMetadata = Readonly<{
   id: string;
+  artifactReference: string;
   modality: EditableArtifactModality;
   title: string;
   lifecycle: EditableArtifact["lifecycle"];
@@ -174,6 +175,14 @@ export type EditableArtifactAgentApplicationDependencies = Readonly<{
   exports: EditableArtifactDurableExportService;
   associations: EditableArtifactAgentAssociationPort;
   inspector: EditableArtifactAgentInspectionKernelPort;
+  /** Production persists proof only after a successful native query. */
+  recordInspection?: (
+    input: EditableArtifactAgentContext & {
+      artifact: EditableArtifactAgentMetadata;
+      queryHash: string;
+      queryKind: string;
+    },
+  ) => Promise<string>;
   officeImports: EditableArtifactOfficeImportPort;
   workspaceFiles: EditableArtifactAgentWorkspaceFilePort;
 }>;
@@ -291,7 +300,13 @@ export class EditableArtifactAgentApplication {
   async inspect(
     input: EditableArtifactAgentContext &
       Readonly<{ artifactId: EditableArtifactId; request: EditableArtifactAgentQuery }>,
-  ): Promise<Readonly<{ artifact: EditableArtifactAgentMetadata; projection: unknown }>> {
+  ): Promise<
+    Readonly<{
+      artifact: EditableArtifactAgentMetadata;
+      projection: unknown;
+      inspectionReceiptId?: string;
+    }>
+  > {
     const context = agentContext(input);
     const artifactId = editableArtifactId(input.artifactId);
     const state = await this.dependencies.domain.readCurrentKernelState({
@@ -304,8 +319,21 @@ export class EditableArtifactAgentApplication {
     const queryBytes = encodeQuery(input.request);
     const responseBytes = await this.dependencies.inspector.query({ state, queryBytes });
     const projection = decodeQueryResponse(input.request.modality, responseBytes);
+    const inspectionReceiptId =
+      state.modality === "document"
+        ? await this.dependencies.recordInspection?.({
+            ...context,
+            artifact: projectArtifact(state.artifact),
+            queryHash: createHash("sha256").update(queryBytes).digest("hex"),
+            queryKind: input.request.query.kind,
+          })
+        : undefined;
     await this.touch(context, artifactId);
-    return Object.freeze({ artifact: projectArtifact(state.artifact), projection });
+    return Object.freeze({
+      artifact: projectArtifact(state.artifact),
+      projection,
+      ...(inspectionReceiptId ? { inspectionReceiptId } : {}),
+    });
   }
 
   async apply(
@@ -603,6 +631,7 @@ function commandProtocolVersion(modality: EditableArtifactModality): number {
 function projectArtifact(artifact: EditableArtifact): EditableArtifactAgentMetadata {
   return Object.freeze({
     id: artifact.id,
+    artifactReference: `[Open report](/workspaces/${artifact.scope.workspaceId}/artifacts/editable/${artifact.id})`,
     modality: artifact.modality,
     title: artifact.title,
     lifecycle: artifact.lifecycle,

package/src/domain/environments.ts

@@ -60,10 +60,8 @@ export async function requireVariableSetForApi(
 }
 
 /**
- * Validates an variableSet attachment supplied in a request payload (session
- * create, scheduled task create/update, pack enable). Requires the
- * `variable-sets:use` permission unless the attachment was already authorized
- * (pack-installation-inherited attachments), and maps a missing or
+ * Validates a Variable Set attachment supplied in a session or task request.
+ * Requires attach and use permissions, and maps a missing or
  * cross-variable set to 422 because the id is payload, not the route
  * target. RLS plus the workspace_id clause make cross-workspace ids
  * indistinguishable from missing ones.
@@ -73,13 +71,10 @@ export async function validateVariableSetAttachment(
   grant: AccessGrant,
   workspaceId: string,
   variableSetId: string,
-  options: { preauthorized?: boolean } = {},
 ): Promise<VariableSet> {
   requireVariableSetEncryption(deps.settings);
-  if (!options.preauthorized) {
-    requirePermission(grant, "variable-sets:attach");
-    requirePermission(grant, "variable-sets:use");
-  }
+  requirePermission(grant, "variable-sets:attach");
+  requirePermission(grant, "variable-sets:use");
   const variableSet = await getVariableSet(
     deps.db,
     { accountId: grant.accountId, workspaceId, subjectId: grant.subjectId },

package/src/domain/file-owner.ts

@@ -1,5 +1,9 @@
 import { requireLiveAgentAttemptAuthorization } from "../session-authorization";
-import { freezeAgentLearningPolicy, type SessionRlsActorContext } from "@opengeni/db";
+import {
+  freezeAgentLearningPolicy,
+  getSessionAuthorityProjection,
+  type SessionRlsActorContext,
+} from "@opengeni/db";
 import type { AccessGrant, Permission } from "@opengeni/contracts";
 import { requirePermission, type AccessGrantAuthorization } from "../access";
 import type { ApiRouteDeps } from "../dependencies";
@@ -44,7 +48,18 @@ export async function fileOwnerContextForAgent(
       executionGeneration: attempt.executionGeneration,
     },
   });
+  const sessionAuthority = await getSessionAuthorityProjection(
+    deps.db,
+    grant.workspaceId,
+    sessionId,
+  );
+  if (!sessionAuthority) throw new Error("File session authority unavailable");
   return {
+    sessionAttachmentReadAccess: {
+      sessionId,
+      authorityEpoch: sessionAuthority.authorityEpoch,
+      actor: attempt,
+    },
     subjectId: grant.subjectId,
     initiatingHumanSubjectId: attempt.initiatingHumanSubjectId,
     privateFileOwnerSubjectId: snapshot.defaultScope === "personal" ? snapshot.subjectId : null,

package/src/domain/insights-timing.ts

@@ -0,0 +1,95 @@
+import { withDatabaseTimingObserver, type DatabaseTimingObservation } from "@opengeni/db";
+import type { Observability } from "@opengeni/observability";
+
+const phases = new Set([
+  "auth",
+  "require_workspace",
+  "model_bundle",
+  "usage_bundle",
+  "live_warm",
+  "scheduled_tasks",
+  "session_depth",
+  "floor_sessions",
+  "online_machines",
+  "attached_sessions",
+  "scheduled_fires",
+] as const);
+export type InsightsPhase = typeof phases extends Set<infer T> ? T : never;
+export type InsightsPhaseObservation = {
+  phase: InsightsPhase;
+  stage: "helper" | DatabaseTimingObservation["stage"];
+  outcome: "completed" | "failed";
+  durationMs: number;
+};
+export type InsightsPhaseObserver = (observation: InsightsPhaseObservation) => void;
+const stages = new Set([
+  "helper",
+  "transaction_admission",
+  "savepoint_admission",
+  "rls_setup",
+  "scoped_callback",
+]);
+
+function observeSafely(
+  observer: InsightsPhaseObserver,
+  observation: InsightsPhaseObservation,
+): void {
+  try {
+    void Promise.resolve(observer(observation)).catch(() => undefined);
+  } catch {
+    // Telemetry is never authoritative for results or authorization.
+  }
+}
+
+/** Helper durations overlap under Promise.all; they must not be summed as request latency. */
+export async function measureInsightsPhase<T>(
+  observer: InsightsPhaseObserver | undefined,
+  phase: InsightsPhase,
+  work: () => Promise<T>,
+): Promise<T> {
+  if (!observer) return work();
+  const started = performance.now();
+  let outcome: InsightsPhaseObservation["outcome"] = "failed";
+  try {
+    const result = await withDatabaseTimingObserver(
+      (observation) => observeSafely(observer, { ...observation, phase }),
+      work,
+    );
+    outcome = "completed";
+    return result;
+  } finally {
+    observeSafely(observer, {
+      phase,
+      stage: "helper",
+      outcome,
+      durationMs: performance.now() - started,
+    });
+  }
+}
+
+/** Closed runtime label projection: caller input, SQL and identities never become labels. */
+export function workspaceInsightsPhaseMetricObserver(
+  observability: Pick<Observability, "observeHistogram"> | null | undefined,
+): InsightsPhaseObserver | undefined {
+  if (!observability) return undefined;
+  return (observation) => {
+    try {
+      const result = observability.observeHistogram({
+        name: "opengeni_workspace_insights_phase_duration_seconds",
+        help: "Insights helper and scoped DB durations; admission includes BEGIN or SAVEPOINT, scoped callback is not pure SQL time. Concurrent phases overlap.",
+        buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2, 3, 5, 10, 30, 60],
+        labels: {
+          phase: phases.has(observation.phase) ? observation.phase : "unknown",
+          stage: stages.has(observation.stage) ? observation.stage : "unknown",
+          outcome: observation.outcome === "completed" ? "completed" : "failed",
+        },
+        value: Number.isFinite(observation.durationMs)
+          ? Math.max(0, observation.durationMs) / 1_000
+          : 0,
+      });
+      void Promise.resolve(result).catch(() => undefined);
+    } catch {
+      // Includes exporter and metric registration failures.
+    }
+  };
+}

package/src/domain/insights.ts

@@ -20,6 +20,9 @@ import {
   type Database,
 } from "@opengeni/db";
 
+import { measureInsightsPhase, type InsightsPhaseObserver } from "./insights-timing";
+export { measureInsightsPhase, workspaceInsightsPhaseMetricObserver } from "./insights-timing";
+export type { InsightsPhaseObservation, InsightsPhaseObserver } from "./insights-timing";
 const MACHINE_HEARTBEAT_FRESH_MS = 120_000;
 export const WORKSPACE_INSIGHTS_PROVIDER_FILTER_MAX_UTF8_BYTES = 256;
 export const WORKSPACE_INSIGHTS_MODEL_FILTER_MAX_UTF8_BYTES = 512;
@@ -210,10 +213,13 @@ export async function getWorkspaceInsights(
   db: Database,
   settings: Settings,
   input: GetWorkspaceInsightsInput,
+  observePhase?: InsightsPhaseObserver,
 ): Promise<WorkspaceInsightsResponse> {
   const provider = normalizeWorkspaceInsightsFilter(input.provider, "provider");
   const model = normalizeWorkspaceInsightsFilter(input.model, "model");
-  await requireWorkspace(db, input.workspaceId);
+  await measureInsightsPhase(observePhase, "require_workspace", () =>
+    requireWorkspace(db, input.workspaceId),
+  );
   const now = input.now ?? new Date();
   const window = resolveRangeWindow(input.range, now);
   const modelFilterActive = Boolean(provider || model);
@@ -221,31 +227,45 @@ export async function getWorkspaceInsights(
 
   const [modelBundle, usageBundle, liveWarm, tasks, depth, floorRows, machinesOnline] =
     await Promise.all([
-      readWorkspaceInsightsModelBundle(db, {
-        workspaceId: input.workspaceId,
-        since: window.since,
-        until: window.until,
-        priorSince: window.priorSince,
-        priorUntil: window.priorUntil,
-        granularity: input.range === "today" ? "hour" : "day",
-        ...filter,
-      }),
-      readWorkspaceInsightsUsageBundle(db, {
-        workspaceId: input.workspaceId,
-        since: window.since,
-        until: window.until,
-        priorSince: window.priorSince,
-        priorUntil: window.priorUntil,
-        monthSince: startOfUtcMonth(now),
-        granularity: input.range === "today" ? "hour" : "day",
-        warmGroupLimit: 24,
-      }),
-      listLiveWarmLeases(db, input.workspaceId),
-      listScheduledTasks(db, input.workspaceId, 100),
-      aggregateSessionDepth(db, input.workspaceId),
-      listFloorSessions(db, input.workspaceId, 24),
+      measureInsightsPhase(observePhase, "model_bundle", () =>
+        readWorkspaceInsightsModelBundle(db, {
+          workspaceId: input.workspaceId,
+          since: window.since,
+          until: window.until,
+          priorSince: window.priorSince,
+          priorUntil: window.priorUntil,
+          granularity: input.range === "today" ? "hour" : "day",
+          ...filter,
+        }),
+      ),
+      measureInsightsPhase(observePhase, "usage_bundle", () =>
+        readWorkspaceInsightsUsageBundle(db, {
+          workspaceId: input.workspaceId,
+          since: window.since,
+          until: window.until,
+          priorSince: window.priorSince,
+          priorUntil: window.priorUntil,
+          monthSince: startOfUtcMonth(now),
+          granularity: input.range === "today" ? "hour" : "day",
+          warmGroupLimit: 24,
+        }),
+      ),
+      measureInsightsPhase(observePhase, "live_warm", () =>
+        listLiveWarmLeases(db, input.workspaceId),
+      ),
+      measureInsightsPhase(observePhase, "scheduled_tasks", () =>
+        listScheduledTasks(db, input.workspaceId, 100),
+      ),
+      measureInsightsPhase(observePhase, "session_depth", () =>
+        aggregateSessionDepth(db, input.workspaceId),
+      ),
+      measureInsightsPhase(observePhase, "floor_sessions", () =>
+        listFloorSessions(db, input.workspaceId, 24),
+      ),
       settings.sandboxSelfhostedEnabled
-        ? countOnlineMachines(db, input.workspaceId, MACHINE_HEARTBEAT_FRESH_MS, now)
+        ? measureInsightsPhase(observePhase, "online_machines", () =>
+            countOnlineMachines(db, input.workspaceId, MACHINE_HEARTBEAT_FRESH_MS, now),
+          )
         : Promise.resolve(0),
     ]);
 
@@ -271,17 +291,21 @@ export async function getWorkspaceInsights(
     agentRunsUsed,
   } = usageBundle;
   const [attached, fireCounts] = await Promise.all([
-    countSessionsAttachedToGroups(
-      db,
-      input.workspaceId,
-      warmGroups.map((group) => group.groupId),
+    measureInsightsPhase(observePhase, "attached_sessions", () =>
+      countSessionsAttachedToGroups(
+        db,
+        input.workspaceId,
+        warmGroups.map((group) => group.groupId),
+      ),
+    ),
+    measureInsightsPhase(observePhase, "scheduled_fires", () =>
+      countScheduledTaskFires(db, {
+        workspaceId: input.workspaceId,
+        since: window.since,
+        until: window.until,
+        taskIds: tasks.map((task) => task.id),
+      }),
     ),
-    countScheduledTaskFires(db, {
-      workspaceId: input.workspaceId,
-      since: window.since,
-      until: window.until,
-      taskIds: tasks.map((task) => task.id),
-    }),
   ]);
   const backendByGroup = new Map(liveWarm.map((lease) => [lease.groupId, lease.backend]));
   const warmSecondsByGroup = new Map(warmGroups.map((group) => [group.groupId, group.warmSeconds]));