@opengeni/api-router 0.5.7 → 0.7.3

package/dist/{chunk-HBEJMWD3.js → chunk-EYYTFA7N.js}

@@ -22,7 +22,14 @@ import { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { cors } from "hono/cors";
 import { HTTPException as HTTPException24 } from "hono/http-exception";
-import { hasPermission as hasPermission4, requireAccessGrant as requireAccessGrant17, requirePermission } from "@opengeni/core";
+import {
+  hasPermission as hasPermission4,
+  requireAccessGrant as requireAccessGrant17,
+  requirePermission,
+  requireSessionAuthorization as requireSessionAuthorization3,
+  SessionAuthorizationDeniedError as SessionAuthorizationDeniedError2,
+  SessionAuthorizationUnavailableError as SessionAuthorizationUnavailableError2
+} from "@opengeni/core";
 
 // src/auth/managed-auth.ts
 import { ensureManagedAccessForUser } from "@opengeni/db";
@@ -280,6 +287,13 @@ import { requireLimit as requireLimit8 } from "@opengeni/core";
 // src/mcp/server.ts
 import {
   CreateScheduledTaskRequest,
+  defaultRepositoryMountPath,
+  SESSION_EVENT_RAW_DELTA_TYPES,
+  SessionEventPayloadMode,
+  SessionEventReadDirection,
+  SessionEventReadMode,
+  SessionEventSemanticClass,
+  SessionEventType,
   SessionMcpCredentialUpdateInput,
   VariableSetVariableName,
   UpdateScheduledTaskRequest
@@ -297,12 +311,16 @@ import {
   getSessionTurn,
   getVariableSet,
   getVariableSetByName,
-  listGitHubInstallationIdsForWorkspace,
+  areGitHubRepositoriesAllowedForWorkspace,
   listScheduledTaskRuns,
   listScheduledTasks,
-  listSessionEvents,
-  listSessions,
+  listSessionEventPage,
+  listSessionDiscoverySummaries,
+  projectEffectiveControlForRelatedAccess,
+  projectSessionForRelatedAccess,
   listRigs,
+  listRigChangeMonitoringSummaries,
+  listRigVersionMonitoringSummaries,
   listSocialConnections,
   listSocialPosts,
   listVariableSets,
@@ -314,6 +332,7 @@ import {
   requireSession,
   saveWorkspaceMemory,
   searchWorkspaceMemories,
+  serializeEffectiveSessionControl,
   setSessionGoalStatus,
   setVariableSetVariable,
   updateScheduledTask,
@@ -325,19 +344,54 @@ import {
 import { appendAndPublishEvents } from "@opengeni/events";
 import {
   createGitHubAppInstallationToken,
-  createSignedState,
   GitHubAppConfigurationError,
-  githubAppMissingSettings,
-  listGitHubAppRepositories,
-  stateMaxAgeSeconds
+  githubAppMissingSettings
 } from "@opengeni/github";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z4 from "zod/v4";
-import { hasPermission } from "@opengeni/core";
+import {
+  hasPermission,
+  requireSessionAuthorization,
+  requireSessionAuthorizationListScope
+} from "@opengeni/core";
 import { recordWorkspaceUsage, requireLimit } from "@opengeni/core";
+
+// src/github-access.ts
+import { listGitHubInstallationAccessForWorkspace } from "@opengeni/db";
+import { listGitHubAppRepositories } from "@opengeni/github";
+async function listWorkspaceGitHubInstallationBindings(deps, workspaceId) {
+  const installations = await listGitHubInstallationAccessForWorkspace(deps.db, workspaceId);
+  return installations.map((installation) => ({
+    installationId: installation.installationId,
+    accountLogin: installation.accountLogin,
+    accountType: installation.accountType,
+    repositoryScope: installation.repositoryScope,
+    repositoryCount: installation.repositoryIds.length,
+    createdAt: installation.createdAt,
+    updatedAt: installation.updatedAt
+  }));
+}
+async function listWorkspaceGitHubRepositories(deps, workspaceId) {
+  const access = await listGitHubInstallationAccessForWorkspace(deps.db, workspaceId);
+  if (access.length === 0) {
+    return [];
+  }
+  const installationIds = access.map((installation) => installation.installationId);
+  const repositories = deps.githubAppApi?.listRepositories ? await deps.githubAppApi.listRepositories({ installationIds }) : await listGitHubAppRepositories(deps.settings, { installationIds });
+  const accessByInstallation = new Map(
+    access.map((installation) => [installation.installationId, installation])
+  );
+  return repositories.filter((repository) => {
+    const installation = accessByInstallation.get(repository.installationId);
+    if (!installation) {
+      return false;
+    }
+    return installation.repositoryScope === "all" || installation.repositoryIds.includes(repository.id);
+  });
+}
+
+// src/mcp/server.ts
 import {
-  listRigChangesForApi,
-  listRigVersionsForApi,
   promoteVerifiedDefinitionEditChangeForApi,
   proposeRigChangeForApi,
   requireRigChangeForApi,
@@ -376,24 +430,13 @@ import {
 } from "@opengeni/core";
 
 // src/mcp/session-view.ts
-var CHARS_PER_TOKEN = 4;
-function estimateTokensFromChars(chars) {
-  return Math.ceil(chars / CHARS_PER_TOKEN);
-}
-function estimateValueTokens(value) {
-  return estimateTokensFromChars(safeStringify(value).length);
-}
-var DEFAULT_EVENT_CAP = {
-  perFieldChars: 2e3,
-  pageTokenBudget: 1e4,
-  headEvents: 8,
-  tailEvents: 8
-};
-var DEFAULT_SESSION_DETAIL_CHARS = 6e3;
+import { measureSessionEventJson } from "@opengeni/contracts";
+var SESSION_EVENT_MCP_MAX_BYTES = 64 * 1024;
+var SESSION_EVENT_MCP_FIELD_MAX_CHARS = 4e3;
+var SESSION_DETAIL_MCP_MAX_BYTES = 64 * 1024;
+var RIG_DETAIL_MCP_MAX_BYTES = 64 * 1024;
 function safeStringify(value) {
-  if (typeof value === "string") {
-    return value;
-  }
+  if (typeof value === "string") return value;
   try {
     return JSON.stringify(value) ?? String(value);
   } catch {
@@ -401,130 +444,510 @@ function safeStringify(value) {
   }
 }
 function truncationMarker(droppedChars) {
-  return `\u2026[${droppedChars} chars truncated \u2014 page with after/limit on session_events, or read the session notebook for the full content]`;
+  return `\u2026[${droppedChars} chars omitted from this model monitoring projection; request explicit forensic full mode for any retained audit preview; original source output may not have been retained]`;
 }
 function clampString(value, maxChars) {
-  if (value.length <= maxChars) {
-    return value;
-  }
+  if (value.length <= maxChars) return value;
   const dropped = value.length - maxChars;
   const headChars = Math.max(0, Math.floor(maxChars * 0.7));
   const tailChars = Math.max(0, maxChars - headChars);
-  const head = value.slice(0, headChars);
   const tail = tailChars > 0 ? value.slice(value.length - tailChars) : "";
-  return `${head}${truncationMarker(dropped)}${tail}`;
+  return `${value.slice(0, headChars)}${truncationMarker(dropped)}${tail}`;
 }
 function capPayloadValue(value, perFieldChars, depth = 0) {
-  if (typeof value === "string") {
-    return clampString(value, perFieldChars);
-  }
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (depth >= 8) {
-    return clampString(safeStringify(value), perFieldChars);
-  }
+  if (typeof value === "string") return clampString(value, perFieldChars);
+  if (value === null || typeof value !== "object") return value;
+  if (depth >= 8) return clampString(safeStringify(value), perFieldChars);
   const serializedLength = safeStringify(value).length;
-  if (serializedLength <= perFieldChars) {
-    return value;
-  }
+  if (serializedLength <= perFieldChars) return value;
   if (Array.isArray(value)) {
     const mapped = value.map((entry) => capPayloadValue(entry, perFieldChars, depth + 1));
-    if (safeStringify(mapped).length <= perFieldChars * 2) {
-      return mapped;
-    }
-    return clampString(safeStringify(value), perFieldChars);
+    return safeStringify(mapped).length <= perFieldChars * 2 ? mapped : clampString(safeStringify(value), perFieldChars);
   }
   const out = {};
   for (const [key, entry] of Object.entries(value)) {
     out[key] = capPayloadValue(entry, perFieldChars, depth + 1);
   }
-  if (safeStringify(out).length <= perFieldChars * 4) {
-    return out;
-  }
-  return clampString(safeStringify(value), perFieldChars);
+  return safeStringify(out).length <= perFieldChars * 4 ? out : clampString(safeStringify(value), perFieldChars);
 }
 function capEventPayload(event, perFieldChars) {
   const cappedPayload = capPayloadValue(event.payload, perFieldChars);
-  if (cappedPayload === event.payload) {
-    return event;
+  return cappedPayload === event.payload ? event : { ...event, payload: cappedPayload };
+}
+function prettyJsonBytes(value) {
+  return Buffer.byteLength(JSON.stringify(value, null, 2), "utf8");
+}
+function setMeasuredBytes(page) {
+  let measured = page.bytes;
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    page.bytes = measured;
+    const next = prettyJsonBytes(page);
+    if (next === measured) return next;
+    measured = next;
+  }
+  page.bytes = measured;
+  return prettyJsonBytes(page);
+}
+function boundSessionEventMcpPage(input) {
+  const maxBytes = Math.max(8 * 1024, input.maxBytes ?? SESSION_EVENT_MCP_MAX_BYTES);
+  let payloadTrimmed = false;
+  const events = input.events.map((event) => {
+    const capped = capEventPayload(event, SESSION_EVENT_MCP_FIELD_MAX_CHARS);
+    if (capped !== event) payloadTrimmed = true;
+    return capped;
+  });
+  let modelRowsDropped = false;
+  const build = () => {
+    const first = events[0]?.sequence ?? null;
+    const last = events.at(-1)?.sequence ?? null;
+    const reasons = [];
+    if (input.sourceHasMore) {
+      reasons.push(input.sourceTruncatedBy === "bytes" ? "source_bytes" : "source_count");
+    }
+    if (payloadTrimmed) reasons.push("model_payload");
+    if (modelRowsDropped) reasons.push("model_bytes");
+    const nextAfter = input.direction === "after" ? last ?? input.after : null;
+    const nextBefore = input.direction === "before" ? first ?? input.before : null;
+    const page2 = {
+      mode: input.mode,
+      payloadMode: input.payloadMode,
+      direction: input.direction,
+      events: [...events],
+      coveredSequence: first === null || last === null ? null : { first, last },
+      nextAfter,
+      nextBefore,
+      hasMore: input.sourceHasMore || modelRowsDropped,
+      truncated: reasons.length > 0,
+      ...reasons.length > 0 ? {
+        truncation: {
+          reasons,
+          omittedSide: input.direction,
+          resumeCursor: input.direction === "after" ? nextAfter : nextBefore
+        }
+      } : {},
+      bytes: 0,
+      maxBytes
+    };
+    setMeasuredBytes(page2);
+    return page2;
+  };
+  let page = build();
+  while (page.bytes > maxBytes && events.length > 0) {
+    if (input.direction === "before") events.shift();
+    else events.pop();
+    modelRowsDropped = true;
+    page = build();
+  }
+  if (page.bytes > maxBytes) {
+    throw new RangeError(`Session-event MCP metadata exceeds its ${maxBytes}-byte envelope`);
   }
-  return { ...event, payload: cappedPayload };
+  return page;
 }
-function buildTruncationEvent(template, droppedCount, firstDroppedSequence, lastDroppedSequence, markerSequence) {
+function modelStringProjection(value, maxBytes) {
+  const originalBytes = Buffer.byteLength(value, "utf8");
+  if (originalBytes <= maxBytes) {
+    return {
+      value,
+      fact: {
+        truncated: false,
+        originalBytes,
+        deliveredBytes: originalBytes,
+        originalChars: value.length
+      }
+    };
+  }
+  let omittedBytes = originalBytes - maxBytes;
+  let head = "";
+  let tail = "";
+  let marker = "";
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    marker = `\u2026[${omittedBytes} UTF-8 bytes omitted from model monitoring projection]\u2026`;
+    const contentBudget = Math.max(0, maxBytes - Buffer.byteLength(marker, "utf8"));
+    head = utf8Prefix(value, Math.floor(contentBudget * 0.7));
+    tail = utf8Suffix(value, contentBudget - Buffer.byteLength(head, "utf8"));
+    const exact = Math.max(
+      0,
+      originalBytes - Buffer.byteLength(head, "utf8") - Buffer.byteLength(tail, "utf8")
+    );
+    if (exact === omittedBytes) break;
+    omittedBytes = exact;
+  }
+  const projected = `${head}${marker}${tail}`;
   return {
-    id: "00000000-0000-0000-0000-000000000000",
-    workspaceId: template.workspaceId,
-    sessionId: template.sessionId,
-    sequence: markerSequence,
-    type: "session.status.changed",
-    payload: {
-      _truncated: true,
-      note: `${droppedCount} event(s) (sequence ${firstDroppedSequence}\u2013${lastDroppedSequence}) omitted from this monitoring view to keep the response bounded. Page the gap with session_events after=${firstDroppedSequence - 1} limit=\u2026 if you need them verbatim, or read the worker's session notebook.`,
-      droppedCount,
-      omittedSequenceRange: [firstDroppedSequence, lastDroppedSequence]
-    },
-    occurredAt: template.occurredAt,
-    clientEventId: null,
-    turnId: null
+    value: projected,
+    fact: {
+      truncated: true,
+      originalBytes,
+      deliveredBytes: Buffer.byteLength(projected, "utf8"),
+      originalChars: value.length
+    }
   };
 }
-function capEventPage(events, config = DEFAULT_EVENT_CAP) {
-  const realLast = events[events.length - 1];
-  const nextAfter = realLast ? realLast.sequence : null;
-  const trimmed = events.map((event) => capEventPayload(event, config.perFieldChars));
-  let runningTokens = 0;
-  let overBudget = false;
-  for (const event of trimmed) {
-    runningTokens += estimateValueTokens(event);
-    if (runningTokens > config.pageTokenBudget) {
-      overBudget = true;
-      break;
-    }
-  }
-  const keepCount = config.headEvents + config.tailEvents;
-  if (!overBudget || trimmed.length <= keepCount + 1) {
-    return { events: trimmed, nextAfter, truncated: overBudget && trimmed.length > keepCount + 1 };
-  }
-  const head = trimmed.slice(0, config.headEvents);
-  const tail = trimmed.slice(trimmed.length - config.tailEvents);
-  const droppedStart = config.headEvents;
-  const droppedEnd = trimmed.length - config.tailEvents - 1;
-  const droppedCount = droppedEnd - droppedStart + 1;
-  const firstDroppedSequence = trimmed[droppedStart].sequence;
-  const lastDroppedSequence = trimmed[droppedEnd].sequence;
-  const markerSequence = head[head.length - 1].sequence;
-  const marker = buildTruncationEvent(
-    realLast,
-    droppedCount,
-    firstDroppedSequence,
-    lastDroppedSequence,
-    markerSequence
-  );
+function utf8Prefix(value, maxBytes) {
+  let index = 0;
+  let bytes = 0;
+  while (index < value.length) {
+    const codePoint = value.codePointAt(index);
+    const character = String.fromCodePoint(codePoint);
+    const nextBytes = Buffer.byteLength(character, "utf8");
+    if (bytes + nextBytes > maxBytes) break;
+    bytes += nextBytes;
+    index += character.length;
+  }
+  return value.slice(0, index);
+}
+function utf8Suffix(value, maxBytes) {
+  let index = value.length;
+  let bytes = 0;
+  while (index > 0) {
+    const last = value.charCodeAt(index - 1);
+    const width = last >= 56320 && last <= 57343 && index > 1 ? 2 : 1;
+    const character = value.slice(index - width, index);
+    const nextBytes = Buffer.byteLength(character, "utf8");
+    if (bytes + nextBytes > maxBytes) break;
+    bytes += nextBytes;
+    index -= width;
+  }
+  return value.slice(index);
+}
+function previewMonitoringValue(value, state, path = "$", depth = 0) {
+  if (state.remainingNodes <= 0 || depth >= 8) {
+    state.truncated = true;
+    if (state.details.length < 24) state.details.push(`${path}: traversal boundary`);
+    return "[nested value omitted from model monitoring projection]";
+  }
+  state.remainingNodes -= 1;
+  if (typeof value === "string") {
+    const projected = modelStringProjection(value, Math.min(1e3, state.remainingStringBytes));
+    state.remainingStringBytes = Math.max(
+      0,
+      state.remainingStringBytes - projected.fact.deliveredBytes
+    );
+    if (projected.fact.truncated) {
+      state.truncated = true;
+      if (state.details.length < 24) state.details.push(`${path}: string truncated`);
+    }
+    return projected.value;
+  }
+  if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value !== "object") {
+    state.truncated = true;
+    if (state.details.length < 24) state.details.push(`${path}: non-JSON value omitted`);
+    return `[${typeof value} value omitted from model monitoring projection]`;
+  }
+  if (Array.isArray(value)) {
+    const keep2 = Math.min(24, value.length);
+    const out2 = value.slice(0, keep2).map((entry, index) => previewMonitoringValue(entry, state, `${path}[${index}]`, depth + 1));
+    if (keep2 < value.length) {
+      state.truncated = true;
+      if (state.details.length < 24) {
+        state.details.push(`${path}: ${value.length - keep2} array entries omitted`);
+      }
+      out2.push({ omittedEntries: value.length - keep2 });
+    }
+    return out2;
+  }
+  const out = {};
+  const entries = Object.entries(value);
+  const keep = Math.min(24, entries.length);
+  for (let index = 0; index < keep; index += 1) {
+    const [rawKey, entry] = entries[index];
+    const keyProjection = modelStringProjection(rawKey, 128).value;
+    const key = Object.prototype.hasOwnProperty.call(out, keyProjection) ? `${keyProjection}#${index}` : keyProjection;
+    out[key] = previewMonitoringValue(entry, state, `${path}.${keyProjection}`, depth + 1);
+  }
+  if (keep < entries.length) {
+    state.truncated = true;
+    if (state.details.length < 24) {
+      state.details.push(`${path}: ${entries.length - keep} object fields omitted`);
+    }
+    out.omittedFields = entries.length - keep;
+  }
+  return out;
+}
+function projectMonitoringContainer(value, stringBytes) {
+  const measurement = measureSessionEventJson(value);
+  const state = {
+    remainingStringBytes: stringBytes,
+    remainingNodes: 128,
+    truncated: false,
+    details: []
+  };
+  const preview = previewMonitoringValue(value, state);
+  const deliveredBytes = Buffer.byteLength(JSON.stringify(preview), "utf8");
+  const originalCount = Array.isArray(value) ? value.length : value !== null && typeof value === "object" ? Object.keys(value).length : void 0;
+  const deliveredCount = originalCount === void 0 ? void 0 : Math.min(24, originalCount);
+  const originalBytes = measurement.bytes;
+  const truncated = state.truncated || originalBytes === null || (originalBytes ?? 0) !== deliveredBytes;
   return {
-    events: [...head, marker, ...tail],
-    nextAfter,
-    truncated: true
+    value: preview,
+    fact: {
+      truncated,
+      originalBytes,
+      deliveredBytes,
+      ...originalCount === void 0 ? {} : { originalCount },
+      ...deliveredCount === void 0 ? {} : { deliveredCount },
+      ...measurement.bytes === null ? { measurementBounded: true } : {}
+    },
+    details: state.details
   };
 }
-function capSessionDetail(session, perFieldChars = DEFAULT_SESSION_DETAIL_CHARS) {
-  let changed = false;
-  const out = { ...session };
-  if (session.metadata !== void 0) {
-    const capped = capPayloadValue(session.metadata, perFieldChars);
-    if (capped !== session.metadata) {
-      out.metadata = capped;
-      changed = true;
+function boundSessionDetailMcp(session, effectiveControl = session.effectiveControl, maxBytes = SESSION_DETAIL_MCP_MAX_BYTES) {
+  const title = session.title === null ? null : modelStringProjection(session.title, 512);
+  const initialMessage = modelStringProjection(session.initialMessage, 4e3);
+  const instructions = session.instructions === null ? null : modelStringProjection(session.instructions, 4e3);
+  const metadata = projectMonitoringContainer(session.metadata, 3e3);
+  const resources = projectMonitoringContainer(session.resources, 3e3);
+  const tools = projectMonitoringContainer(session.tools, 4e3);
+  const mcpServers = projectMonitoringContainer(session.mcpServers, 3e3);
+  const permissions = projectMonitoringContainer(session.firstPartyMcpPermissions, 1500);
+  const control = projectMonitoringContainer(effectiveControl, 2e3);
+  const fieldFacts = {
+    title: title?.fact ?? {
+      truncated: false,
+      originalBytes: 0,
+      deliveredBytes: 0
+    },
+    initialMessage: initialMessage.fact,
+    instructions: instructions?.fact ?? {
+      truncated: false,
+      originalBytes: 0,
+      deliveredBytes: 0
+    },
+    metadata: metadata.fact,
+    resources: resources.fact,
+    tools: tools.fact,
+    mcpServers: mcpServers.fact,
+    firstPartyMcpPermissions: permissions.fact,
+    effectiveControl: control.fact
+  };
+  const details = [
+    ...metadata.details,
+    ...resources.details,
+    ...tools.details,
+    ...mcpServers.details,
+    ...permissions.details,
+    ...control.details
+  ].slice(0, 32);
+  const result = {
+    id: session.id,
+    workspaceId: session.workspaceId,
+    accountId: session.accountId,
+    status: session.status,
+    title: title?.value ?? null,
+    titleSource: session.titleSource,
+    initialMessage: initialMessage.value,
+    instructions: instructions?.value ?? null,
+    resources: resources.value,
+    tools: tools.value,
+    metadata: metadata.value,
+    model: modelStringProjection(session.model, 512).value,
+    sandboxBackend: modelStringProjection(session.sandboxBackend, 128).value,
+    sandboxOs: session.sandboxOs,
+    sandboxGroupId: session.sandboxGroupId,
+    activeSandboxId: session.activeSandboxId,
+    activeEpoch: session.activeEpoch,
+    variableSetId: session.variableSetId,
+    environmentId: session.environmentId,
+    rigId: session.rigId,
+    rigVersionId: session.rigVersionId,
+    firstPartyMcpPermissions: permissions.value,
+    mcpServers: mcpServers.value,
+    parentSessionId: session.parentSessionId,
+    createIdempotencyKey: session.createIdempotencyKey === null ? null : modelStringProjection(session.createIdempotencyKey, 512).value,
+    temporalWorkflowId: session.temporalWorkflowId === null ? null : modelStringProjection(session.temporalWorkflowId, 512).value,
+    activeTurnId: session.activeTurnId,
+    lastInputTokens: session.lastInputTokens,
+    queueVersion: session.queueVersion,
+    queueHeadPosition: session.queueHeadPosition,
+    queueTailPosition: session.queueTailPosition,
+    effectiveControl: control.value,
+    lastSequence: session.lastSequence,
+    codexPinnedCredentialId: session.codexPinnedCredentialId,
+    codexLastCredentialId: session.codexLastCredentialId,
+    pinned: session.pinned,
+    pinnedAt: session.pinnedAt,
+    pinVersion: session.pinVersion,
+    ...session.treeStats === void 0 ? {} : { treeStats: session.treeStats },
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    projection: {
+      truncated: Object.values(fieldFacts).some((fact) => fact.truncated),
+      fields: fieldFacts,
+      details,
+      bytes: 0,
+      maxBytes
+    }
+  };
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const measured = prettyJsonBytes(result);
+    if (result.projection.bytes === measured) break;
+    result.projection.bytes = measured;
+  }
+  const mutable = result;
+  const fallbackContainers = [
+    ["tools", fieldFacts.tools],
+    ["resources", fieldFacts.resources],
+    ["metadata", fieldFacts.metadata],
+    ["mcpServers", fieldFacts.mcpServers],
+    ["effectiveControl", fieldFacts.effectiveControl],
+    ["firstPartyMcpPermissions", fieldFacts.firstPartyMcpPermissions]
+  ];
+  for (const [field, fact] of fallbackContainers) {
+    if (result.projection.bytes <= maxBytes) break;
+    const omission = {
+      preview: `[${field} preview omitted at final session_get byte boundary]`,
+      ...fact.originalCount === void 0 ? {} : { originalCount: fact.originalCount }
+    };
+    mutable[field] = omission;
+    fact.truncated = true;
+    fact.deliveredBytes = Buffer.byteLength(JSON.stringify(omission), "utf8");
+    fact.deliveredCount = 0;
+    result.projection.truncated = true;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const measured = prettyJsonBytes(result);
+      if (result.projection.bytes === measured) break;
+      result.projection.bytes = measured;
     }
   }
-  if (typeof session.initialMessage === "string" && session.initialMessage.length > perFieldChars) {
-    out.initialMessage = clampString(
-      session.initialMessage,
-      perFieldChars
-    );
-    changed = true;
+  if (result.projection.bytes > maxBytes) {
+    throw new RangeError(`session_get projection exceeds its ${maxBytes}-byte envelope`);
   }
-  return changed ? out : session;
+  return result;
+}
+function boundRigDetailMcp(rig, versionsPage, changesPage, maxBytes = RIG_DETAIL_MCP_MAX_BYTES) {
+  const name = modelStringProjection(rig.name, 512);
+  const description = rig.description === null ? null : modelStringProjection(rig.description, 2e3);
+  const active = rig.activeVersion;
+  const activeSetup = active?.setupScript === null || active?.setupScript === void 0 ? null : modelStringProjection(active.setupScript, 8e3);
+  const activeImage = active?.image === null || active?.image === void 0 ? null : modelStringProjection(active.image, 1e3);
+  const activeChangelog = active?.changelog === null || active?.changelog === void 0 ? null : modelStringProjection(active.changelog, 2e3);
+  const activeChecks = projectMonitoringContainer(active?.checks ?? [], 5e3);
+  const activeHooks = projectMonitoringContainer(active?.credentialHooks ?? [], 1500);
+  const activeVariableSets = projectMonitoringContainer(active?.defaultVariableSetIds ?? [], 1500);
+  const versions = projectMonitoringContainer(versionsPage.versions, 4e3);
+  const changes = projectMonitoringContainer(changesPage.changes, 4e3);
+  const fieldFacts = {
+    name: name.fact,
+    description: description?.fact ?? {
+      truncated: false,
+      originalBytes: 0,
+      deliveredBytes: 0
+    },
+    activeSetupScript: activeSetup?.fact ?? {
+      truncated: false,
+      originalBytes: 0,
+      deliveredBytes: 0
+    },
+    activeImage: activeImage?.fact ?? {
+      truncated: false,
+      originalBytes: 0,
+      deliveredBytes: 0
+    },
+    activeChangelog: activeChangelog?.fact ?? {
+      truncated: false,
+      originalBytes: 0,
+      deliveredBytes: 0
+    },
+    activeChecks: activeChecks.fact,
+    activeCredentialHooks: activeHooks.fact,
+    activeDefaultVariableSetIds: activeVariableSets.fact,
+    versions: versions.fact,
+    changes: changes.fact
+  };
+  const result = {
+    rig: {
+      id: rig.id,
+      accountId: rig.accountId,
+      workspaceId: rig.workspaceId,
+      name: name.value,
+      description: description?.value ?? null,
+      createdBy: rig.createdBy === null ? null : modelStringProjection(rig.createdBy, 512).value,
+      activeVersion: active ? {
+        id: active.id,
+        rigId: active.rigId,
+        version: active.version,
+        image: activeImage?.value ?? null,
+        setupScript: activeSetup?.value ?? null,
+        checks: activeChecks.value,
+        credentialHooks: activeHooks.value,
+        defaultVariableSetIds: activeVariableSets.value,
+        changelog: activeChangelog?.value ?? null,
+        createdBy: active.createdBy === null ? null : modelStringProjection(active.createdBy, 512).value,
+        active: active.active,
+        createdAt: active.createdAt
+      } : null,
+      activeVersionHealth: rig.activeVersionHealth,
+      versionCount: rig.versionCount,
+      createdAt: rig.createdAt,
+      updatedAt: rig.updatedAt
+    },
+    versions: versions.value,
+    versionsTotal: versionsPage.total,
+    versionsTruncated: versionsPage.hasMore || versions.fact.truncated,
+    changes: changes.value,
+    changesTotal: changesPage.total,
+    changesTruncated: changesPage.hasMore || changes.fact.truncated,
+    projection: {
+      truncated: versionsPage.hasMore || changesPage.hasMore || Object.values(fieldFacts).some((fact) => fact.truncated),
+      fields: fieldFacts,
+      details: [
+        ...activeChecks.details,
+        ...activeHooks.details,
+        ...activeVariableSets.details,
+        ...versions.details,
+        ...changes.details
+      ].slice(0, 32),
+      bytes: 0,
+      maxBytes
+    }
+  };
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const measured = prettyJsonBytes(result);
+    if (result.projection.bytes === measured) break;
+    result.projection.bytes = measured;
+  }
+  const mutable = result;
+  const rigFallbacks = [
+    {
+      target: mutable.rig.activeVersion ?? {},
+      field: "checks",
+      fact: fieldFacts.activeChecks
+    },
+    { target: mutable, field: "versions", fact: fieldFacts.versions },
+    { target: mutable, field: "changes", fact: fieldFacts.changes },
+    {
+      target: mutable.rig.activeVersion ?? {},
+      field: "credentialHooks",
+      fact: fieldFacts.activeCredentialHooks
+    },
+    {
+      target: mutable.rig.activeVersion ?? {},
+      field: "defaultVariableSetIds",
+      fact: fieldFacts.activeDefaultVariableSetIds
+    }
+  ];
+  for (const fallback of rigFallbacks) {
+    if (result.projection.bytes <= maxBytes) break;
+    const omission = {
+      preview: `[${fallback.field} preview omitted at final rig_get byte boundary]`,
+      ...fallback.fact.originalCount === void 0 ? {} : { originalCount: fallback.fact.originalCount }
+    };
+    fallback.target[fallback.field] = omission;
+    fallback.fact.truncated = true;
+    fallback.fact.deliveredBytes = Buffer.byteLength(JSON.stringify(omission), "utf8");
+    fallback.fact.deliveredCount = 0;
+    result.projection.truncated = true;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const measured = prettyJsonBytes(result);
+      if (result.projection.bytes === measured) break;
+      result.projection.bytes = measured;
+    }
+  }
+  if (result.projection.bytes > maxBytes) {
+    throw new RangeError(`rig_get projection exceeds its ${maxBytes}-byte envelope`);
+  }
+  return result;
 }
 
 // src/mcp/server.ts
@@ -547,8 +970,13 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
         inputSchema: { title: z4.string().min(1).max(200) }
       },
       async ({ title }) => {
-        const result = await updateSessionTitle(deps, grant.workspaceId, sessionId, title, "agent");
-        return json({ ok: true, updated: result.updated, title: result.title ?? title });
+        await authorizeFirstPartySession(deps, grant, sessionId, "session.title.write");
+        const result = await updateSessionTitle(deps, grant, sessionId, title, "agent");
+        return json({
+          ok: true,
+          updated: result.updated,
+          title: result.title ?? title
+        });
       }
     );
   }
@@ -567,7 +995,7 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
   registerWorkspaceOrchestrationTools(server, deps, grant, can, sessionId, toolspaceMode, json);
   registerVariableSetTools(server, deps, grant, can, json);
   if (can("github:use")) {
-    registerGitHubConnectTool(server, deps, grant, options, json);
+    registerGitHubConnectTool(server, deps, json);
     if (sessionId !== null) {
       registerGitHubTokenTool(server, deps, grant, sessionId, json);
     }
@@ -587,7 +1015,9 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
         if (file.status !== "ready") {
           throw new Error(`file is ${file.status}`);
         }
-        const signed = await deps.objectStorage.createGetUrl({ key: file.objectKey });
+        const signed = await deps.objectStorage.createGetUrl({
+          key: file.objectKey
+        });
         return json({
           file: {
             id: file.id,
@@ -617,11 +1047,7 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
       },
       async ({ limit }) => {
         try {
-          const installationIds = await listGitHubInstallationIdsForWorkspace(
-            deps.db,
-            grant.workspaceId
-          );
-          const repositories = await listGitHubAppRepositories(deps.settings, { installationIds });
+          const repositories = await listWorkspaceGitHubRepositories(deps, grant.workspaceId);
           const visible = typeof limit === "number" ? repositories.slice(0, limit) : repositories;
           return json({
             repositories: visible.map(
@@ -733,7 +1159,9 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
         description: "List scheduled tasks.",
         inputSchema: { limit: z4.number().int().positive().optional() }
       },
-      async ({ limit }) => json({ tasks: await listScheduledTasks(deps.db, grant.workspaceId, limit ?? 100) })
+      async ({ limit }) => json({
+        tasks: await listScheduledTasks(deps.db, grant.workspaceId, limit ?? 100)
+      })
     );
     server.registerTool(
       "scheduled_tasks_get",
@@ -780,7 +1208,11 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
           payload,
           toolsProvided: scheduledTaskToolsProvided(args)
         });
-        await syncCreatedScheduledTask({ db: deps.db, workflowClient: deps.workflowClient, task });
+        await syncCreatedScheduledTask({
+          db: deps.db,
+          workflowClient: deps.workflowClient,
+          task
+        });
         return json(task);
       }
     );
@@ -872,7 +1304,10 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
       "scheduled_tasks_trigger",
       {
         description: "Trigger a scheduled task immediately. Pass a stable triggerId to make a retried trigger idempotent (one charge, one run).",
-        inputSchema: { id: z4.string().uuid(), triggerId: z4.string().min(1).max(128).optional() }
+        inputSchema: {
+          id: z4.string().uuid(),
+          triggerId: z4.string().min(1).max(128).optional()
+        }
       },
       async ({ id, triggerId }) => {
         const task = await requireScheduledTask(deps.db, grant.workspaceId, id);
@@ -928,7 +1363,10 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
       "scheduled_task_runs_list",
       {
         description: "List runs for a scheduled task.",
-        inputSchema: { taskId: z4.string().uuid(), limit: z4.number().int().positive().optional() }
+        inputSchema: {
+          taskId: z4.string().uuid(),
+          limit: z4.number().int().positive().optional()
+        }
       },
       async ({ taskId, limit }) => json({
         runs: await listScheduledTaskRuns(deps.db, grant.workspaceId, taskId, limit ?? 100)
@@ -991,6 +1429,7 @@ function registerGoalTools(server, deps, grant, sessionId, json) {
       }
     },
     async ({ text, successCriteria, maxAutoContinuations }) => {
+      await authorizeFirstPartySession(deps, grant, sessionId, "session.goal.write");
       await requireSession(deps.db, grant.workspaceId, sessionId);
       const callerTurnId = typeof grant.metadata?.["turnId"] === "string" ? grant.metadata["turnId"] : null;
       await assertGoalReactivationAllowed(deps, grant.workspaceId, sessionId, callerTurnId);
@@ -1030,6 +1469,7 @@ function registerGoalTools(server, deps, grant, sessionId, json) {
       }
     },
     async ({ text, successCriteria, progressNote }) => {
+      await authorizeFirstPartySession(deps, grant, sessionId, "session.goal.write");
       await requireSession(deps.db, grant.workspaceId, sessionId);
       const existing = await getSessionGoal(deps.db, grant.workspaceId, sessionId);
       if (!existing) {
@@ -1065,6 +1505,7 @@ function registerGoalTools(server, deps, grant, sessionId, json) {
       inputSchema: { evidence: z4.string().min(1) }
     },
     async ({ evidence }) => {
+      await authorizeFirstPartySession(deps, grant, sessionId, "session.goal.write");
       await requireSession(deps.db, grant.workspaceId, sessionId);
       const existing = await getSessionGoal(deps.db, grant.workspaceId, sessionId);
       if (!existing) {
@@ -1092,6 +1533,7 @@ function registerGoalTools(server, deps, grant, sessionId, json) {
       inputSchema: { rationale: z4.string().min(1) }
     },
     async ({ rationale }) => {
+      await authorizeFirstPartySession(deps, grant, sessionId, "session.goal.write");
       await requireSession(deps.db, grant.workspaceId, sessionId);
       const existing = await getSessionGoal(deps.db, grant.workspaceId, sessionId);
       if (!existing) {
@@ -1121,6 +1563,13 @@ function registerGoalTools(server, deps, grant, sessionId, json) {
     }
   );
 }
+async function authorizeFirstPartySession(deps, grant, sessionId, operation) {
+  return await requireSessionAuthorization(deps, grant, {
+    sessionId,
+    operation,
+    surface: "first_party_mcp"
+  });
+}
 var MemoryKindSchema = z4.enum(["preference", "semantic", "procedural", "decision", "episodic"]);
 function memoryPreview(text) {
   const normalized = text.replace(/\s+/g, " ").trim();
@@ -1235,7 +1684,11 @@ function registerMemoryTools(server, deps, grant, sessionId, json) {
   );
 }
 function registerFleetTools(server, deps, grant, sessionId, json) {
-  const services = { db: deps.db, settings: deps.settings, bus: deps.bus };
+  const services = {
+    db: deps.db,
+    settings: deps.settings,
+    bus: deps.bus
+  };
   const fleetContext = async () => await buildFleetContextForSession(deps, {
     accountId: grant.accountId,
     workspaceId: grant.workspaceId,
@@ -1278,7 +1731,11 @@ function registerFleetTools(server, deps, grant, sessionId, json) {
             workdir: z4.string().optional()
           }),
           z4.object({ kind: z4.literal("read"), path: z4.string().min(1) }),
-          z4.object({ kind: z4.literal("write"), path: z4.string().min(1), content: z4.string() })
+          z4.object({
+            kind: z4.literal("write"),
+            path: z4.string().min(1),
+            content: z4.string()
+          })
         ])
       }
     },
@@ -1294,7 +1751,10 @@ function registerFleetTools(server, deps, grant, sessionId, json) {
       }
     },
     async ({ kind, name }) => json(
-      await provisionSandbox(services, await fleetContext(), { kind, ...name ? { name } : {} })
+      await provisionSandbox(services, await fleetContext(), {
+        kind,
+        ...name ? { name } : {}
+      })
     )
   );
 }
@@ -1326,24 +1786,30 @@ function registerRigTools(server, deps, grant, can, sessionId, json) {
     server.registerTool(
       "rig_get",
       {
-        description: "Get a rig, its versions, and recent changes.",
+        description: "Get one rig's bounded active definition plus compact historical version/change summaries. Historical setup scripts, checks, payloads, and verification logs are represented by counts/byte facts rather than copied into model context; use the access-controlled REST detail endpoints for exact retained definitions.",
         inputSchema: {
           rigId: z4.string().uuid(),
+          versionLimit: z4.number().int().positive().optional(),
           changeLimit: z4.number().int().positive().optional()
         }
       },
-      async ({ rigId, changeLimit }) => {
+      async ({ rigId, versionLimit, changeLimit }) => {
         const rig = await requireRigForApi(deps.db, grant.workspaceId, rigId);
-        return json({
-          rig,
-          versions: await listRigVersionsForApi({ db: deps.db }, grant.workspaceId, rig.id),
-          changes: await listRigChangesForApi(
-            { db: deps.db },
+        const [versions, changes] = await Promise.all([
+          listRigVersionMonitoringSummaries(
+            deps.db,
             grant.workspaceId,
             rig.id,
-            boundedMcpLimit(changeLimit)
+            boundedRigHistoryLimit(versionLimit)
+          ),
+          listRigChangeMonitoringSummaries(
+            deps.db,
+            grant.workspaceId,
+            rig.id,
+            boundedRigHistoryLimit(changeLimit)
           )
-        });
+        ]);
+        return json(boundRigDetailMcp(rig, versions, changes));
       }
     );
     server.registerTool(
@@ -1444,6 +1910,7 @@ function exactAgentCommandContext(grant, callerSessionId) {
   return {
     accountId: grant.accountId,
     workspaceId: grant.workspaceId,
+    subjectId: grant.subjectId,
     callerSessionId,
     callerTurnId: turnId,
     callerAttemptId: attemptId,
@@ -1455,10 +1922,43 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
     server.registerTool(
       "sessions_list",
       {
-        description: "List sessions in this workspace, newest first.",
-        inputSchema: { limit: z4.number().int().positive().optional() }
+        description: `List compact high-level session status in this workspace. Defaults to creation order; use orderBy=updatedAt with decimal activity-revision updatedAfter/updatedThrough tokens for gap-free indexed incremental monitoring independent of application clocks. Cursors are opaque revision-fenced keysets. includeLastMessage is opt-in; its rendered previews share a deterministic ${SESSION_DISCOVERY_PREVIEW_MAX_BYTES}-byte UTF-8 aggregate budget, and omitted previews include a bounded session_events drill-down input (exact message type, direction=before, limit=1, monitoring summary). Use session_get for exact known targets and detailed resources/tools/settings. The list never returns full session objects or history.`,
+        inputSchema: {
+          limit: z4.number().int().positive().max(100).optional(),
+          cursor: z4.string().max(512).optional(),
+          includeLastMessage: z4.boolean().optional(),
+          orderBy: z4.enum(["createdAt", "updatedAt"]).optional(),
+          updatedAfter: z4.string().max(64).optional()
+        }
       },
-      async ({ limit }) => json({ sessions: await listSessions(deps.db, grant.workspaceId, boundedMcpLimit(limit)) })
+      async ({ limit, cursor, includeLastMessage, orderBy: requestedOrderBy, updatedAfter }) => {
+        const authorizationScope = await requireSessionAuthorizationListScope(
+          deps,
+          grant,
+          "first_party_mcp"
+        );
+        const decodedCursor = cursor ? decodeSessionDiscoveryCursor(cursor) : void 0;
+        const orderBy = requestedOrderBy ?? decodedCursor?.orderBy ?? "createdAt";
+        if (decodedCursor && decodedCursor.orderBy !== orderBy) {
+          throw new Error("sessions_list cursor order does not match orderBy");
+        }
+        const normalizedUpdatedAfter = updatedAfter !== void 0 ? normalizeSessionDiscoveryRevision(updatedAfter, "updatedAfter") : decodedCursor?.updatedAfter ?? void 0;
+        if (normalizedUpdatedAfter !== void 0 && orderBy !== "updatedAt") {
+          throw new Error("sessions_list updatedAfter requires orderBy=updatedAt");
+        }
+        if (decodedCursor && decodedCursor.updatedAfter !== (normalizedUpdatedAfter ?? null)) {
+          throw new Error("sessions_list cursor does not match updatedAfter");
+        }
+        const page = await listSessionDiscoverySummaries(deps.db, grant.workspaceId, {
+          limit: boundedSessionDiscoveryLimit(limit),
+          ...decodedCursor ? { cursor: decodedCursor } : {},
+          includeLastMessage: includeLastMessage === true,
+          orderBy,
+          ...normalizedUpdatedAfter ? { updatedAfter: normalizedUpdatedAfter } : {},
+          ...authorizationScope ? { authorizationScope } : {}
+        });
+        return json(capSessionDiscoveryPage(page, includeLastMessage === true));
+      }
     );
     server.registerTool(
       "session_get",
@@ -1467,42 +1967,95 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
         inputSchema: { sessionId: z4.string().uuid() }
       },
       async ({ sessionId }) => {
+        const authorization = await authorizeFirstPartySession(
+          deps,
+          grant,
+          sessionId,
+          "session.read"
+        );
         const session = await getSession(deps.db, grant.workspaceId, sessionId);
         if (!session) {
           throw new Error("session not found");
         }
         const queue = await getSessionQueueSnapshot(deps.db, grant.workspaceId, sessionId);
-        return json({
-          ...capSessionDetail(session),
-          effectiveControl: queue?.effectiveControl ?? null
-        });
+        const projected = projectSessionForRelatedAccess(
+          {
+            ...session,
+            effectiveControl: queue?.effectiveControl ?? session.effectiveControl
+          },
+          authorization?.relatedSessionAccess ?? "root"
+        );
+        return json(boundSessionDetailMcp(projected));
       }
     );
     server.registerTool(
       "session_events",
       {
-        description: "Read a session's event timeline (oldest first), to monitor another session's progress. Pass `after` = the highest event `sequence` already seen to page forward; the response's `nextAfter` is that cursor. The response is BYTE-CAPPED for a monitoring glance: fat per-event payloads (a worker's verbatim tool outputs, message/reasoning bodies) are clamped, and an over-budget page is reduced to its head + tail with a marker \u2014 page the gap with `after`/`limit`, or read the worker's session notebook, if you need omitted content verbatim. `nextAfter` always advances past every event the page covered, so paging never skips real events.",
+        description: "Read a compact semantic tail only when session_get status is insufficient. With no cursor, this returns the newest matching events and excludes raw message/reasoning/command/PTY deltas. Use `latest` as an exclusive lookup for the newest event in exactly one semantic class; it cannot be combined with type or class filters. Use nextBefore to page older or explicit after/nextAfter to page forward. Type/class filters run in the RLS-scoped database query. payloadMode none|summary|full controls retained audit payload projection, but every model result is independently byte-capped with explicit truncation and exact covered sequence bounds. Exact retained forensic payloads require the access-controlled REST/SDK events API with mode=forensic&payloadMode=full; generic source bytes never retained by the audit boundary remain unavailable.",
         inputSchema: {
           sessionId: z4.string().uuid(),
           after: z4.number().int().nonnegative().optional(),
-          limit: z4.number().int().positive().optional()
+          before: z4.number().int().positive().optional(),
+          limit: z4.number().int().positive().optional(),
+          direction: z4.enum(SessionEventReadDirection.options).optional(),
+          mode: z4.enum(SessionEventReadMode.options).optional(),
+          payloadMode: z4.enum(SessionEventPayloadMode.options).optional(),
+          includeTypes: z4.array(z4.enum(SessionEventType.options)).max(100).optional(),
+          excludeTypes: z4.array(z4.enum(SessionEventType.options)).max(100).optional(),
+          includeClasses: z4.array(z4.enum(SessionEventSemanticClass.options)).max(SessionEventSemanticClass.options.length).optional(),
+          excludeClasses: z4.array(z4.enum(SessionEventSemanticClass.options)).max(SessionEventSemanticClass.options.length).optional(),
+          latest: z4.enum(SessionEventSemanticClass.options).optional()
         }
       },
-      async ({ sessionId, after, limit }) => {
+      async ({
+        sessionId,
+        after,
+        before,
+        limit,
+        direction: requestedDirection,
+        mode: requestedMode,
+        payloadMode: requestedPayloadMode,
+        includeTypes,
+        excludeTypes,
+        includeClasses,
+        excludeClasses,
+        latest
+      }) => {
+        await authorizeFirstPartySession(deps, grant, sessionId, "session.events.read");
         await requireSession(deps.db, grant.workspaceId, sessionId);
-        const events = await listSessionEvents(
-          deps.db,
-          grant.workspaceId,
-          sessionId,
-          after ?? 0,
-          boundedMcpLimit(limit)
-        );
-        const capped = capEventPage(events);
-        return json({
-          events: capped.events,
-          nextAfter: capped.nextAfter ?? after ?? 0,
-          ...capped.truncated ? { truncated: true } : {}
+        if (latest && [includeTypes, excludeTypes, includeClasses, excludeClasses].some(
+          (filter) => filter !== void 0
+        )) {
+          throw new Error("latest cannot be combined with event filters");
+        }
+        const mode = requestedMode ?? (after !== void 0 ? "forensic" : "monitoring");
+        const direction = latest ? "before" : requestedDirection ?? (before !== void 0 ? "before" : after !== void 0 ? "after" : "before");
+        const payloadMode = requestedPayloadMode ?? (mode === "monitoring" ? "summary" : "full");
+        const dbPage = await listSessionEventPage(deps.db, grant.workspaceId, sessionId, {
+          after: after ?? 0,
+          ...before !== void 0 ? { before } : {},
+          direction,
+          limit: latest ? 1 : boundedSessionEventMcpLimit(limit),
+          payloadMode,
+          includeTypes: includeTypes ?? [],
+          excludeTypes: excludeTypes ?? [],
+          includeClasses: latest ? [latest] : includeClasses ?? [],
+          excludeClasses: excludeClasses ?? [],
+          ...mode === "monitoring" ? { defaultExcludeTypes: SESSION_EVENT_RAW_DELTA_TYPES } : {},
+          maxBytes: SESSION_EVENT_MCP_MAX_BYTES * 4
         });
+        return json(
+          boundSessionEventMcpPage({
+            events: dbPage.events,
+            mode,
+            payloadMode,
+            direction,
+            sourceHasMore: dbPage.hasMore,
+            sourceTruncatedBy: dbPage.truncatedBy,
+            after: after ?? 0,
+            before: before ?? null
+          })
+        );
       }
     );
   }
@@ -1551,7 +2104,11 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
           idempotencyKey: z4.string().min(1).max(200).optional(),
           // First-party MCP token permissions for the spawned session; every
           // permission must be held by this grant (validated in the domain).
-          firstPartyMcpPermissions: z4.array(z4.string()).optional(),
+          // A goal requires goals:manage in the resulting set; it is never
+          // silently added beyond the inherited or explicit authority.
+          firstPartyMcpPermissions: z4.array(z4.string()).optional().describe(
+            "Optional first-party capability set for the child. Omit to inherit this session's effective permissions. An explicit set may only narrow capabilities held by this session. A goal-bearing child requires goals:manage in the resulting set; creation fails rather than adding it implicitly."
+          ),
           // Shared-sandbox placement (addendum 05 §D). OMIT (default) to SHARE the
           // creator's box — one filesystem/repo/desktop, N independent conversations;
           // this is the SAFE DEFAULT. Pass "new" for a fresh isolated box (a different
@@ -1582,7 +2139,12 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
           // arbitrary session's wake channel without sessions:control on it.
         }
       },
-      async (args) => json(await createSessionForRequest(deps, grant, grant.workspaceId, args))
+      async (args) => {
+        if (callerSessionId !== null) {
+          await authorizeFirstPartySession(deps, grant, callerSessionId, "session.child.create");
+        }
+        return json(await createSessionForRequest(deps, grant, grant.workspaceId, args));
+      }
     );
   }
   if (can("sessions:control") && !toolspaceMode) {
@@ -1600,6 +2162,7 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
         }
       },
       async ({ sessionId: targetSessionId, text, idempotencyKey, mcpCredentialUpdates }) => {
+        await authorizeFirstPartySession(deps, grant, targetSessionId, "session.append");
         if (callerSessionId !== null) {
           if ((mcpCredentialUpdates?.length ?? 0) > 0) {
             throw new Error("internal session updates cannot change MCP credentials");
@@ -1649,8 +2212,14 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
         }
       },
       async ({ sessionId, idempotencyKey, reason }) => {
+        const authorization = await authorizeFirstPartySession(
+          deps,
+          grant,
+          sessionId,
+          "session.control"
+        );
         if (callerSessionId !== null) {
-          const controlled = await controlAgentSessionWorkstream(
+          const controlled2 = await controlAgentSessionWorkstream(
             deps,
             exactAgentCommandContext(grant, callerSessionId),
             {
@@ -1661,28 +2230,38 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
             }
           );
           return json({
-            receiptId: controlled.receipt.id,
-            effectiveControl: controlled.control,
-            interruptionCount: controlled.interruptionCount,
-            replay: controlled.replay
+            receiptId: controlled2.receipt.id,
+            effectiveControl: projectEffectiveControlForRelatedAccess(
+              serializeEffectiveSessionControl(controlled2.control),
+              sessionId,
+              authorization?.relatedSessionAccess ?? "root"
+            ),
+            interruptionCount: controlled2.interruptionCount,
+            replay: controlled2.replay
           });
         }
-        return json(
-          await controlHumanSessionWorkstream(
-            deps,
-            {
-              accountId: grant.accountId,
-              workspaceId: grant.workspaceId,
-              sessionId,
-              subjectId: grant.subjectId
-            },
-            {
-              action: "pause",
-              clientEventId: idempotencyKey,
-              ...reason ? { reason } : {}
-            }
-          )
+        const controlled = await controlHumanSessionWorkstream(
+          deps,
+          {
+            accountId: grant.accountId,
+            workspaceId: grant.workspaceId,
+            sessionId,
+            subjectId: grant.subjectId
+          },
+          {
+            action: "pause",
+            clientEventId: idempotencyKey,
+            ...reason ? { reason } : {}
+          }
         );
+        return json({
+          ...controlled,
+          effectiveControl: projectEffectiveControlForRelatedAccess(
+            controlled.effectiveControl,
+            sessionId,
+            authorization?.relatedSessionAccess ?? "root"
+          )
+        });
       }
     );
     server.registerTool(
@@ -1696,8 +2275,14 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
         }
       },
       async ({ sessionId, idempotencyKey, reason }) => {
+        const authorization = await authorizeFirstPartySession(
+          deps,
+          grant,
+          sessionId,
+          "session.control"
+        );
         if (callerSessionId !== null) {
-          const controlled = await controlAgentSessionWorkstream(
+          const controlled2 = await controlAgentSessionWorkstream(
             deps,
             exactAgentCommandContext(grant, callerSessionId),
             {
@@ -1708,28 +2293,38 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
             }
           );
           return json({
-            receiptId: controlled.receipt.id,
-            effectiveControl: controlled.control,
-            interruptionCount: controlled.interruptionCount,
-            replay: controlled.replay
+            receiptId: controlled2.receipt.id,
+            effectiveControl: projectEffectiveControlForRelatedAccess(
+              serializeEffectiveSessionControl(controlled2.control),
+              sessionId,
+              authorization?.relatedSessionAccess ?? "root"
+            ),
+            interruptionCount: controlled2.interruptionCount,
+            replay: controlled2.replay
           });
         }
-        return json(
-          await controlHumanSessionWorkstream(
-            deps,
-            {
-              accountId: grant.accountId,
-              workspaceId: grant.workspaceId,
-              sessionId,
-              subjectId: grant.subjectId
-            },
-            {
-              action: "resume",
-              clientEventId: idempotencyKey,
-              ...reason ? { reason } : {}
-            }
-          )
+        const controlled = await controlHumanSessionWorkstream(
+          deps,
+          {
+            accountId: grant.accountId,
+            workspaceId: grant.workspaceId,
+            sessionId,
+            subjectId: grant.subjectId
+          },
+          {
+            action: "resume",
+            clientEventId: idempotencyKey,
+            ...reason ? { reason } : {}
+          }
         );
+        return json({
+          ...controlled,
+          effectiveControl: projectEffectiveControlForRelatedAccess(
+            controlled.effectiveControl,
+            sessionId,
+            authorization?.relatedSessionAccess ?? "root"
+          )
+        });
       }
     );
     if (callerSessionId !== null) {
@@ -1744,6 +2339,7 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
           }
         },
         async ({ sessionId, instruction, idempotencyKey }) => {
+          await authorizeFirstPartySession(deps, grant, sessionId, "session.steer");
           const result = await steerAgentSession(
             deps,
             exactAgentCommandContext(grant, callerSessionId),
@@ -1769,15 +2365,14 @@ function registerWorkspaceOrchestrationTools(server, deps, grant, can, callerSes
         }
       },
       async ({ session_id, title }) => {
+        await authorizeFirstPartySession(deps, grant, session_id, "session.title.write");
         await requireSession(deps.db, grant.workspaceId, session_id);
-        const result = await updateSessionTitle(
-          deps,
-          grant.workspaceId,
-          session_id,
-          title,
-          "agent"
-        );
-        return json({ ok: true, updated: result.updated, title: result.title ?? title });
+        const result = await updateSessionTitle(deps, grant, session_id, title, "agent");
+        return json({
+          ok: true,
+          updated: result.updated,
+          title: result.title ?? title
+        });
       }
     );
   }
@@ -1861,7 +2456,11 @@ function registerVariableSetTools(server, deps, grant, can, json) {
       variableSetId: variableSet.id,
       variableName: parsedName.data
     });
-    const responseVariableSet = { id: variableSet.id, name: variableSet.name, created };
+    const responseVariableSet = {
+      id: variableSet.id,
+      name: variableSet.name,
+      created
+    };
     return json({
       variableSet: responseVariableSet,
       environment: responseVariableSet,
@@ -1906,11 +2505,11 @@ function registerVariableSetTools(server, deps, grant, can, json) {
     );
   }
 }
-function registerGitHubConnectTool(server, deps, grant, options, json) {
+function registerGitHubConnectTool(server, deps, json) {
   server.registerTool(
     "github_connect_link",
     {
-      description: "Create a workspace-bound GitHub App install link to share with a human. Opening it redirects to GitHub to install the app and select repositories for this workspace; completing the connection requires the person to be signed in to this OpenGeni deployment with github:manage. The link expires.",
+      description: "Report GitHub App connection availability. New installation binding is disabled until GitHub installation authority can be proven, so installUrl and linkUrl are null.",
       inputSchema: {}
     },
     async () => {
@@ -1918,23 +2517,19 @@ function registerGitHubConnectTool(server, deps, grant, options, json) {
       const missing = githubAppMissingSettings(settings);
       const slug = settings.githubAppSlug?.trim() || null;
       if (missing.length > 0 || !slug) {
-        return json({ configured: false, appSlug: slug, installUrl: null, missing });
-      }
-      const base = (settings.publicBaseUrl ?? settings.githubAppManifestBaseUrl ?? options.requestOrigin ?? "").replace(/\/+$/, "");
-      if (!base) {
-        throw new Error(
-          "github_connect_link requires OPENGENI_PUBLIC_BASE_URL (or OPENGENI_GITHUB_APP_MANIFEST_BASE_URL) so the install link can route through this deployment"
-        );
+        return json({
+          configured: false,
+          appSlug: slug,
+          installUrl: null,
+          linkUrl: null,
+          missing
+        });
       }
-      const state = createSignedState(deps.githubStateSecret, {
-        accountId: grant.accountId,
-        workspaceId: grant.workspaceId
-      });
       return json({
         configured: true,
         appSlug: slug,
-        installUrl: `${base}/v1/workspaces/${grant.workspaceId}/github/connect?state=${encodeURIComponent(state)}`,
-        expiresInSeconds: stateMaxAgeSeconds,
+        installUrl: null,
+        linkUrl: null,
         missing: []
       });
     }
@@ -1964,9 +2559,18 @@ function registerGitHubTokenTool(server, deps, grant, sessionId, json) {
       if (selected.some((item) => item.installationId !== installationId)) {
         throw new Error("GitHub App repository resources must belong to one installation");
       }
+      const repositoryIds = selected.map((item) => item.repositoryId);
+      if (!await areGitHubRepositoriesAllowedForWorkspace(
+        deps.db,
+        grant.workspaceId,
+        installationId,
+        repositoryIds
+      )) {
+        throw new Error("this workspace no longer authorizes the session's GitHub repositories");
+      }
       const token = await createGitHubAppInstallationToken(deps.settings, {
         installationId,
-        repositoryIds: selected.map((item) => item.repositoryId)
+        repositoryIds
       });
       return json({
         token,
@@ -1988,19 +2592,18 @@ function repositoryWithScheduledTaskResource(repository) {
       kind: "repository",
       uri,
       ref: repository.defaultBranch,
-      mountPath: repositoryMountPath(uri),
-      ...repository.private ? { githubInstallationId: repository.installationId, githubRepositoryId: repository.id } : {}
+      mountPath: defaultRepositoryMountPath(uri),
+      ...repository.private ? {
+        githubInstallationId: repository.installationId,
+        githubRepositoryId: repository.id
+      } : {}
     }
   };
 }
 function normalizedRepositoryUri(value) {
   const url = new URL(value);
   const path = url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
-  return `https://${url.hostname.toLowerCase()}/${path}.git`;
-}
-function repositoryMountPath(uri) {
-  const url = new URL(uri);
-  return `repos/${url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "")}`;
+  return `https://${url.host.toLowerCase()}/${path}.git`;
 }
 function boundedMcpLimit(limit) {
   if (!limit || !Number.isFinite(limit)) {
@@ -2008,6 +2611,304 @@ function boundedMcpLimit(limit) {
   }
   return Math.min(500, Math.max(1, Math.floor(limit)));
 }
+function boundedRigHistoryLimit(limit) {
+  if (!limit || !Number.isFinite(limit)) return 20;
+  return Math.min(100, Math.max(1, Math.floor(limit)));
+}
+function boundedSessionEventMcpLimit(limit) {
+  if (!limit || !Number.isFinite(limit)) return 40;
+  return Math.min(250, Math.max(1, Math.floor(limit)));
+}
+var SESSION_DISCOVERY_DEFAULT_LIMIT = 20;
+var SESSION_DISCOVERY_MAX_LIMIT = 100;
+var SESSION_DISCOVERY_TEXT_CHARS = 600;
+var SESSION_DISCOVERY_PREVIEW_MAX_BYTES = 16384;
+var SESSION_DISCOVERY_PREVIEW_OMISSION_REASON = "aggregatePreviewBudget";
+var SESSION_DISCOVERY_PAGE_MAX_BYTES = 128e3;
+var SESSION_DISCOVERY_PREVIEW_DRILL_DOWN_TOOL = "session_events";
+var SESSION_DISCOVERY_PREVIEW_DRILL_DOWN_BASE_INPUT = {
+  direction: "before",
+  limit: 1,
+  mode: "monitoring",
+  payloadMode: "summary"
+};
+function sessionDiscoveryPreviewDrillDownInput(sessionId, type) {
+  return {
+    sessionId,
+    includeTypes: [type],
+    ...SESSION_DISCOVERY_PREVIEW_DRILL_DOWN_BASE_INPUT
+  };
+}
+function boundedSessionDiscoveryLimit(limit) {
+  if (!limit || !Number.isFinite(limit)) return SESSION_DISCOVERY_DEFAULT_LIMIT;
+  return Math.min(SESSION_DISCOVERY_MAX_LIMIT, Math.max(1, Math.floor(limit)));
+}
+function encodeSessionDiscoveryCursor(cursor) {
+  return Buffer.from(
+    JSON.stringify({
+      v: 2,
+      orderBy: cursor.orderBy,
+      sortRevision: cursor.sortRevision,
+      sortAt: cursor.sortAt,
+      id: cursor.id,
+      snapshotAt: cursor.snapshotAt,
+      snapshotRevision: cursor.snapshotRevision,
+      updatedAfter: cursor.updatedAfter
+    }),
+    "utf8"
+  ).toString("base64url");
+}
+var SESSION_DISCOVERY_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?Z$/;
+var SESSION_DISCOVERY_REVISION = /^(?:0|[1-9]\d*)$/;
+var SESSION_DISCOVERY_REVISION_MAX = 9223372036854775807n;
+var SESSION_DISCOVERY_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function normalizeSessionDiscoveryTimestamp(value, label) {
+  if (!SESSION_DISCOVERY_TIMESTAMP.test(value) || Number.isNaN(new Date(value).getTime())) {
+    throw new Error(`sessions_list ${label} must be an ISO UTC date-time`);
+  }
+  return value;
+}
+function normalizeSessionDiscoveryRevision(value, label) {
+  if (!SESSION_DISCOVERY_REVISION.test(value)) {
+    throw new Error(`sessions_list ${label} must be a decimal activity revision`);
+  }
+  const revision = BigInt(value);
+  if (revision > SESSION_DISCOVERY_REVISION_MAX) {
+    throw new Error(`sessions_list ${label} exceeds the database activity revision range`);
+  }
+  return revision.toString();
+}
+function decodeSessionDiscoveryCursor(value) {
+  try {
+    const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    if (parsed.v === void 0 && typeof parsed.createdAt === "string" && typeof parsed.id === "string" && SESSION_DISCOVERY_UUID.test(parsed.id)) {
+      const createdAt = normalizeSessionDiscoveryTimestamp(
+        parsed.createdAt,
+        "legacy cursor createdAt"
+      );
+      return {
+        orderBy: "createdAt",
+        sortRevision: "0",
+        sortAt: createdAt,
+        id: parsed.id,
+        snapshotAt: createdAt,
+        snapshotRevision: "0",
+        updatedAfter: null
+      };
+    }
+    if (parsed.v === 1 && parsed.orderBy === "createdAt" && typeof parsed.sortAt === "string" && typeof parsed.snapshotAt === "string" && parsed.updatedAfter === null && typeof parsed.id === "string" && SESSION_DISCOVERY_UUID.test(parsed.id)) {
+      return {
+        orderBy: "createdAt",
+        sortRevision: "0",
+        sortAt: normalizeSessionDiscoveryTimestamp(parsed.sortAt, "cursor sortAt"),
+        id: parsed.id,
+        snapshotAt: normalizeSessionDiscoveryTimestamp(parsed.snapshotAt, "cursor snapshotAt"),
+        snapshotRevision: "0",
+        updatedAfter: null
+      };
+    }
+    if (parsed.v !== 2 || parsed.orderBy !== "createdAt" && parsed.orderBy !== "updatedAt" || typeof parsed.sortRevision !== "string" || typeof parsed.sortAt !== "string" || typeof parsed.snapshotAt !== "string" || typeof parsed.snapshotRevision !== "string" || parsed.updatedAfter !== null && typeof parsed.updatedAfter !== "string" || typeof parsed.id !== "string" || !SESSION_DISCOVERY_UUID.test(parsed.id)) {
+      throw new Error("invalid cursor fields");
+    }
+    const sortAt = normalizeSessionDiscoveryTimestamp(parsed.sortAt, "cursor sortAt");
+    const snapshotAt = normalizeSessionDiscoveryTimestamp(parsed.snapshotAt, "cursor snapshotAt");
+    const sortRevision = normalizeSessionDiscoveryRevision(
+      parsed.sortRevision,
+      "cursor sortRevision"
+    );
+    const snapshotRevision = normalizeSessionDiscoveryRevision(
+      parsed.snapshotRevision,
+      "cursor snapshotRevision"
+    );
+    const normalizedUpdatedAfter = parsed.updatedAfter === null ? null : normalizeSessionDiscoveryRevision(parsed.updatedAfter, "cursor updatedAfter");
+    if (normalizedUpdatedAfter !== null && parsed.orderBy !== "updatedAt") {
+      throw new Error("incremental cursor requires updatedAt order");
+    }
+    if (parsed.orderBy === "createdAt" && (sortRevision !== "0" || snapshotRevision !== "0")) {
+      throw new Error("creation cursor cannot carry activity revisions");
+    }
+    return {
+      orderBy: parsed.orderBy,
+      sortRevision,
+      sortAt,
+      id: parsed.id,
+      snapshotAt,
+      snapshotRevision,
+      updatedAfter: normalizedUpdatedAfter
+    };
+  } catch {
+    throw new Error("sessions_list cursor is invalid");
+  }
+}
+function capSessionDiscoveryText(value, maxChars = SESSION_DISCOVERY_TEXT_CHARS, originalChars) {
+  if (value === null) {
+    return { text: value, truncated: false };
+  }
+  const projectedChars = Array.from(value);
+  const sourceChars = Math.max(projectedChars.length, originalChars ?? projectedChars.length);
+  if (sourceChars <= maxChars) {
+    return { text: value, truncated: false };
+  }
+  let bodyChars = maxChars;
+  let marker = "";
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    const omittedChars = Math.max(0, sourceChars - bodyChars);
+    marker = `\u2026[${omittedChars} chars truncated]\u2026`;
+    const nextBodyChars = Math.max(0, maxChars - Array.from(marker).length);
+    if (nextBodyChars === bodyChars) break;
+    bodyChars = nextBodyChars;
+  }
+  return {
+    text: `${projectedChars.slice(0, bodyChars).join("")}${marker}`,
+    truncated: true
+  };
+}
+function capSessionDiscoveryPage(page, includeLastMessage) {
+  const projected = page.sessions.map((session) => {
+    const title = capSessionDiscoveryText(session.title, 200, session.titleOriginalChars);
+    const goal = session.goal ? capSessionDiscoveryText(
+      session.goal.text,
+      SESSION_DISCOVERY_TEXT_CHARS,
+      session.goal.textOriginalChars
+    ) : null;
+    const preview = includeLastMessage ? capSessionDiscoveryText(
+      session.latestMessage?.preview ?? null,
+      SESSION_DISCOVERY_TEXT_CHARS,
+      session.latestMessage?.previewOriginalChars
+    ) : null;
+    const blocker = session.effectiveControl.primaryBlocker;
+    const blockerDisplayName = blocker ? capSessionDiscoveryText(blocker.displayName, 200, blocker.displayNameOriginalChars) : null;
+    return {
+      id: session.id,
+      title: title.text,
+      titleTruncated: title.truncated,
+      parentSessionId: session.parentSessionId,
+      isRoot: session.parentSessionId === null,
+      status: session.status,
+      pause: {
+        state: session.effectiveControl.state,
+        additionalBlockerCount: session.effectiveControl.additionalBlockerCount,
+        source: blocker ? {
+          kind: blocker.kind,
+          ...blocker.sessionId ? { sessionId: blocker.sessionId } : {},
+          displayName: blockerDisplayName.text,
+          displayNameTruncated: blockerDisplayName.truncated
+        } : null
+      },
+      goal: session.goal ? {
+        status: session.goal.status,
+        summary: goal.text,
+        summaryTruncated: goal.truncated
+      } : null,
+      queuedPromptCount: session.queuedPromptCount,
+      children: session.treeStats,
+      ...includeLastMessage ? {
+        latestMessage: session.latestMessage ? {
+          type: session.latestMessage.type,
+          preview: preview.text,
+          previewTruncated: preview.truncated
+        } : null
+      } : {},
+      createdAt: session.createdAt,
+      updatedAt: session.updatedAt
+    };
+  });
+  let budgetBytes = 0;
+  const budgeted = includeLastMessage ? projected.map((session) => {
+    const latestMessage = session.latestMessage;
+    if (!latestMessage || latestMessage.preview === null) return session;
+    const candidateBytes = Buffer.byteLength(latestMessage.preview, "utf8");
+    if (budgetBytes + candidateBytes <= SESSION_DISCOVERY_PREVIEW_MAX_BYTES) {
+      budgetBytes += candidateBytes;
+      return session;
+    }
+    return {
+      ...session,
+      latestMessage: {
+        ...latestMessage,
+        preview: null,
+        previewOmitted: true,
+        previewOmissionReason: SESSION_DISCOVERY_PREVIEW_OMISSION_REASON,
+        previewDrillDownTool: SESSION_DISCOVERY_PREVIEW_DRILL_DOWN_TOOL,
+        previewDrillDownInput: sessionDiscoveryPreviewDrillDownInput(
+          session.id,
+          latestMessage.type
+        )
+      }
+    };
+  }) : projected;
+  let kept = budgeted;
+  const build = () => {
+    const previewBytes = includeLastMessage ? kept.reduce(
+      (total, session) => total + (session.latestMessage?.preview === null || !session.latestMessage ? 0 : Buffer.byteLength(session.latestMessage.preview, "utf8")),
+      0
+    ) : 0;
+    const previewOmittedCount = includeLastMessage ? kept.filter((session) => {
+      const latestMessage = session.latestMessage;
+      return latestMessage != null && "previewOmitted" in latestMessage && latestMessage.previewOmitted === true;
+    }).length : 0;
+    const lastKept = kept.at(-1);
+    const droppedForByteCap = kept.length < projected.length;
+    const sourceLast = lastKept ? page.sessions.find((session) => session.id === lastKept.id) : void 0;
+    const nextCursor = droppedForByteCap ? sourceLast ? encodeSessionDiscoveryCursor({
+      orderBy: page.orderBy,
+      sortRevision: sourceLast.sortRevision,
+      sortAt: sourceLast.sortAt,
+      id: sourceLast.id,
+      snapshotAt: page.snapshotAt,
+      snapshotRevision: page.snapshotRevision,
+      updatedAfter: page.updatedAfter
+    }) : null : page.nextCursor ? encodeSessionDiscoveryCursor(page.nextCursor) : null;
+    const result2 = {
+      sessions: kept,
+      total: page.total,
+      hasMore: page.hasMore || droppedForByteCap,
+      nextCursor,
+      orderBy: page.orderBy,
+      snapshotAt: page.snapshotAt,
+      snapshotRevision: page.snapshotRevision,
+      updatedAfter: page.updatedAfter,
+      updatedThrough: page.updatedThrough,
+      ...includeLastMessage ? {
+        latestMessagePreviewBudget: {
+          bytes: previewBytes,
+          maxBytes: SESSION_DISCOVERY_PREVIEW_MAX_BYTES,
+          omittedCount: previewOmittedCount,
+          truncated: previewOmittedCount > 0,
+          omissionReason: previewOmittedCount > 0 ? SESSION_DISCOVERY_PREVIEW_OMISSION_REASON : null,
+          drillDownTool: SESSION_DISCOVERY_PREVIEW_DRILL_DOWN_TOOL,
+          drillDownInput: {
+            includeTypes: ["user.message", "agent.message.completed"],
+            ...SESSION_DISCOVERY_PREVIEW_DRILL_DOWN_BASE_INPUT
+          }
+        }
+      } : {},
+      responseTruncated: droppedForByteCap,
+      ...droppedForByteCap ? {
+        truncationReason: `response exceeded ${SESSION_DISCOVERY_PAGE_MAX_BYTES} bytes; continue with nextCursor`
+      } : {},
+      bytes: 0,
+      maxBytes: SESSION_DISCOVERY_PAGE_MAX_BYTES
+    };
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const measured = Buffer.byteLength(JSON.stringify(result2, null, 2), "utf8");
+      if (result2.bytes === measured) break;
+      result2.bytes = measured;
+    }
+    return result2;
+  };
+  let result = build();
+  while (result.bytes > SESSION_DISCOVERY_PAGE_MAX_BYTES && kept.length > 1) {
+    kept = kept.slice(0, -1);
+    result = build();
+  }
+  if (result.bytes > SESSION_DISCOVERY_PAGE_MAX_BYTES) {
+    throw new RangeError(
+      `sessions_list metadata exceeds its ${SESSION_DISCOVERY_PAGE_MAX_BYTES}-byte envelope`
+    );
+  }
+  return result;
+}
 function parseMcpDate(raw, label) {
   const date = new Date(raw);
   if (Number.isNaN(date.getTime())) {
@@ -2020,13 +2921,18 @@ function parseMcpDate(raw, label) {
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { environmentsEncryptionKeyBytes } from "@opengeni/config";
-import { prefixedMcpToolName } from "@opengeni/contracts";
+import {
+  prefixedMcpToolName
+} from "@opengeni/contracts";
 import {
   hasPermission as hasPermission2,
   settingsWithEnabledCapabilityMcpServers
 } from "@opengeni/core";
 import {
   buildConnectionTokenResolver,
+  buildHostConnectionTokenResolver,
+  getSessionRootId,
+  getSessionTurn as getSessionTurn2,
   listSessionMcpServerMetadata,
   listSessionMcpServersForRun,
   requireSession as requireSession2,
@@ -2051,6 +2957,14 @@ async function prepareToolspaceMcpSurface(input) {
   }
   const sessionId = grant.metadata.sessionId;
   const session = await requireSession2(deps.db, grant.workspaceId, sessionId);
+  let rootSessionId = sessionId;
+  if (deps.connectionCredentials?.mcpCredentials) {
+    const resolvedRootSessionId = await getSessionRootId(deps.db, grant.workspaceId, sessionId);
+    if (!resolvedRootSessionId) {
+      throw new Error(`cannot resolve host MCP credentials for missing session ${sessionId}`);
+    }
+    rootSessionId = resolvedRootSessionId;
+  }
   const selectedIds = selectedMcpServerIds(
     session.tools,
     session.mcpServers.map((server) => server.id)
@@ -2065,12 +2979,13 @@ async function prepareToolspaceMcpSurface(input) {
     deps,
     grant,
     sessionId,
+    rootSessionId,
     proxyableIds,
     activeTurnId: session.activeTurnId ?? null,
     getRegistry
   });
   const tools = listing.map(
-    (entry) => toolspaceToolFor({ deps, grant, sessionId, entry, getRegistry })
+    (entry) => toolspaceToolFor({ deps, grant, sessionId, rootSessionId, entry, getRegistry })
   );
   return {
     sessionId,
@@ -2101,15 +3016,25 @@ async function buildToolspaceRegistry(deps, workspaceId, sessionId) {
   return new Map(withSessionServers.mcpServers.map((server) => [server.id, server]));
 }
 async function resolveToolListing(input) {
-  const { deps, grant, sessionId, proxyableIds, activeTurnId, getRegistry } = input;
-  const cacheKey = await toolListCacheKey(deps, grant.workspaceId, sessionId, proxyableIds);
+  const { deps, grant, sessionId, rootSessionId, proxyableIds, activeTurnId, getRegistry } = input;
+  if (!activeTurnId) {
+    return [];
+  }
+  const activeTurn = await getSessionTurn2(deps.db, grant.workspaceId, activeTurnId);
+  if (!activeTurn || activeTurn.sessionId !== sessionId) {
+    return [];
+  }
+  const cacheKey = await toolListCacheKey(
+    deps,
+    grant.workspaceId,
+    sessionId,
+    proxyableIds,
+    activeTurn
+  );
   const cached = readToolListCache(cacheKey);
   if (cached) {
     return cached;
   }
-  if (!activeTurnId) {
-    return [];
-  }
   const registry = await getRegistry();
   const entries = [];
   for (const serverId of proxyableIds) {
@@ -2117,9 +3042,14 @@ async function resolveToolListing(input) {
     if (!config || !toolspaceCanProxyServer(config)) {
       continue;
     }
-    const connection = await connectToolspaceServer({ deps, grant, config, sessionId }).catch(
-      () => null
-    );
+    const connection = await connectToolspaceServer({
+      deps,
+      grant,
+      config,
+      sessionId,
+      rootSessionId,
+      turn: activeTurn
+    }).catch(() => null);
     if (!connection) {
       continue;
     }
@@ -2138,11 +3068,16 @@ async function resolveToolListing(input) {
   writeToolListCache(cacheKey, entries);
   return entries;
 }
-async function toolListCacheKey(deps, workspaceId, sessionId, proxyableIds) {
+async function toolListCacheKey(deps, workspaceId, sessionId, proxyableIds, turn) {
   const metadata = await listSessionMcpServerMetadata(deps.db, workspaceId, sessionId);
   const versions = new Map(metadata.map((server) => [server.id, server.credentialVersion]));
   const signature = proxyableIds.slice().sort().map((id) => `${id}@${versions.get(id) ?? 0}`).join(",");
-  return `${workspaceId}:${sessionId}:${signature}`;
+  const authority = JSON.stringify({
+    turnId: turn.id,
+    executionGeneration: turn.executionGeneration,
+    initiator: turn.initiator
+  });
+  return `${workspaceId}:${sessionId}:${signature}:${authority}`;
 }
 function readToolListCache(key) {
   const hit = toolListCache.get(key);
@@ -2176,9 +3111,18 @@ async function settingsWithSessionMcpServersForToolspace(deps, workspaceId, sess
     if (metadata.length === 0) {
       return settings;
     }
-    throw new Error("session MCP server credentials require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY");
+    if (metadata.some((server) => server.headerNames.length > 0)) {
+      throw new Error(
+        "session MCP server credentials require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY"
+      );
+    }
   }
-  const servers = await listSessionMcpServersForRun(deps.db, workspaceId, sessionId, encryptionKey);
+  const servers = await listSessionMcpServersForRun(
+    deps.db,
+    workspaceId,
+    sessionId,
+    encryptionKey ?? null
+  );
   if (servers.length === 0) {
     return settings;
   }
@@ -2195,6 +3139,7 @@ async function settingsWithSessionMcpServersForToolspace(deps, workspaceId, sess
         ...server.timeoutMs ? { timeoutMs: server.timeoutMs } : {},
         cacheToolsList: server.cacheToolsList ?? false,
         ...server.requireApproval !== void 0 ? { requireApproval: server.requireApproval } : {},
+        ...server.connectionRef ? { connectionRef: server.connectionRef } : {},
         headers: server.headers
       }))
     ]
@@ -2222,7 +3167,7 @@ async function connectToolspaceServer(input) {
   };
 }
 function toolspaceToolFor(input) {
-  const { deps, grant, sessionId, entry, getRegistry } = input;
+  const { deps, grant, sessionId, rootSessionId, entry, getRegistry } = input;
   const { serverId, tool } = entry;
   const name = prefixedMcpToolName(serverId, tool.name);
   const approvalRequired = mcpToolRequiresApproval(entry.requireApproval, tool.name);
@@ -2244,7 +3189,7 @@ function toolspaceToolFor(input) {
           `toolspace call budget exhausted (${deps.settings.toolspaceMaxCallsPerTurn}/turn)`
         );
       }
-      const turnId = reservation.turnId;
+      const turnId = reservation.turn.id;
       const registry = await getRegistry();
       const config = registry.get(serverId);
       if (!config || !toolspaceCanProxyServer(config) || !allowedByConfig(config, tool.name)) {
@@ -2253,9 +3198,14 @@ function toolspaceToolFor(input) {
       if (mcpToolRequiresApproval(config.requireApproval, tool.name)) {
         return mcpError(APPROVAL_REQUIRED_MESSAGE);
       }
-      const connection = await connectToolspaceServer({ deps, grant, config, sessionId }).catch(
-        () => null
-      );
+      const connection = await connectToolspaceServer({
+        deps,
+        grant,
+        config,
+        sessionId,
+        rootSessionId,
+        turn: reservation.turn
+      }).catch(() => null);
       if (!connection) {
         return mcpError(`upstream tool failed: ${name}`);
       }
@@ -2335,7 +3285,11 @@ async function reserveActiveTurnCall(deps, workspaceId, sessionId) {
     session.activeTurnId,
     deps.settings.toolspaceMaxCallsPerTurn
   );
-  return reservation.reserved ? { status: "ok", turnId: session.activeTurnId } : { status: "budget_exhausted" };
+  if (!reservation.reserved) {
+    return { status: "budget_exhausted" };
+  }
+  const turn = await getSessionTurn2(deps.db, workspaceId, session.activeTurnId);
+  return turn && turn.sessionId === sessionId ? { status: "ok", turn } : { status: "no_active_turn" };
 }
 function selectedMcpServerIds(tools, sessionServerIds) {
   const out = new Set(sessionServerIds);
@@ -2382,7 +3336,18 @@ function connectionBrokerFetch(baseFetch, input) {
   if (!connectionRef) {
     return baseFetch;
   }
-  const resolveCredential = buildConnectionTokenResolver(input.deps.db, input.deps.settings);
+  const resolveCredential = input.deps.connectionCredentials?.mcpCredentials ? buildHostConnectionTokenResolver(input.deps.connectionCredentials.mcpCredentials, {
+    accountId: input.grant.accountId,
+    workspaceId: input.grant.workspaceId,
+    sessionId: input.sessionId,
+    rootSessionId: input.rootSessionId,
+    turnId: input.turn.id,
+    attemptId: input.turn.activeAttemptId,
+    executionGeneration: input.turn.executionGeneration,
+    initiator: input.turn.initiator,
+    initiatorContext: input.turn.initiatorContext,
+    surface: "toolspace"
+  }) : buildConnectionTokenResolver(input.deps.db, input.deps.settings);
   return async (requestInput, init) => {
     const request = await mcpRequestInfo(requestInput, init);
     const first = await resolveCredential({
@@ -2390,7 +3355,7 @@ function connectionBrokerFetch(baseFetch, input) {
       serverId: input.config.id,
       connectionRef,
       forceRefresh: false,
-      ...request.toolName ? { toolId: request.toolName } : {},
+      ...request.toolName ? { toolName: request.toolName } : {},
       subjectId: input.grant.subjectId
     });
     if (first.status === "auth_needed") {
@@ -2406,7 +3371,7 @@ function connectionBrokerFetch(baseFetch, input) {
         serverId: input.config.id,
         connectionRef,
         forceRefresh: true,
-        ...request.toolName ? { toolId: request.toolName } : {},
+        ...request.toolName ? { toolName: request.toolName } : {},
         subjectId: input.grant.subjectId
       });
       if (refreshed.status === "auth_needed") {
@@ -2433,9 +3398,11 @@ function authNeededFromStatus(config, first, reason) {
     status: "auth_needed",
     reason,
     providerDomain: connectionRef.providerDomain,
+    ...connectionRef.provider ? { provider: connectionRef.provider } : {},
     connectionId: first.connectionId,
     ...connectionRef.scopes ? { scopes: connectionRef.scopes } : {},
-    ...connectionRef.resource ? { resource: connectionRef.resource } : {}
+    ...connectionRef.resource ? { resource: connectionRef.resource } : {},
+    ...connectionRef.selectedResources ? { selectedResources: connectionRef.selectedResources } : {}
   };
 }
 async function authNeededFetchResponse(input, request, auth) {
@@ -2452,10 +3419,12 @@ async function authNeededFetchResponse(input, request, auth) {
           serverId: input.config.id,
           toolName: request.toolName ?? null,
           providerDomain: auth.providerDomain,
+          ...auth.provider ? { provider: auth.provider } : {},
           reason: auth.reason,
           ...auth.connectionId ? { connectionId: auth.connectionId } : {},
           ...auth.scopes ? { scopes: auth.scopes } : {},
           ...auth.resource ? { resource: auth.resource } : {},
+          ...auth.selectedResources ? { selectedResources: auth.selectedResources } : {},
           ...auth.authorizationUrl ? { authorizationUrl: auth.authorizationUrl } : {},
           subjectId: input.grant.subjectId
         }
@@ -2632,6 +3601,7 @@ function isInstallRedirectPath(path) {
 
 // src/http/auth.ts
 var githubConnectPathPattern = /^\/v1\/workspaces\/[^/]+\/github\/connect$/;
+var githubInstallationLinkPathPattern = /^\/v1\/workspaces\/[^/]+\/github\/installations$/;
 function requireAccessKey(settings) {
   return async (c, next) => {
     if (!settings.authRequired || isAuthExempt(c, settings)) {
@@ -2671,6 +3641,9 @@ function isAuthExempt(c, settings) {
   if (githubConnectPathPattern.test(path)) {
     return true;
   }
+  if (c.req.method === "POST" && githubInstallationLinkPathPattern.test(path)) {
+    return true;
+  }
   if (installExactPaths.has(path) || isInstallRedirectPath(path)) {
     return true;
   }
@@ -2929,10 +3902,9 @@ import {
   setInitialActiveCodexCredential,
   updateCodexRotationSettings,
   upsertCodexSubscriptionCredential,
-  withCodexCapacityMutation,
-  CODEX_ROTATION_STRATEGIES
+  withCodexCapacityMutation
 } from "@opengeni/db";
-import { createSignedState as createSignedState2, readSignedState } from "@opengeni/github";
+import { createSignedState, readSignedState } from "@opengeni/github";
 import { HTTPException as HTTPException4 } from "hono/http-exception";
 import { requireAccessGrant as requireAccessGrant2 } from "@opengeni/core";
 var CODEX_PROVIDER_LABEL = "Codex subscription \xB7 no credits";
@@ -3018,7 +3990,7 @@ function registerCodexRoutes(app, deps) {
         message: error instanceof CodexDeviceError ? error.message : "failed to start Codex device login"
       });
     }
-    const state = createSignedState2(githubStateSecret, {
+    const state = createSignedState(githubStateSecret, {
       workspaceId,
       deviceAuthId: start.deviceAuthId,
       userCode: start.userCode
@@ -3177,7 +4149,9 @@ function registerCodexRoutes(app, deps) {
       activeAccountId,
       settings: {
         rotationEnabled: rotation?.rotationEnabled ?? false,
-        rotationStrategy: rotation?.rotationStrategy ?? "most_remaining",
+        // sharded-rotation policy: rotation-enabled always behaves as sticky-sharded; report the
+        // effective truth, never the stored legacy residue.
+        rotationStrategy: "sharded",
         activeCredentialId: activeAccountId
       }
     });
@@ -3209,15 +4183,12 @@ function registerCodexRoutes(app, deps) {
     if (typeof body.rotationEnabled === "boolean") {
       patch.rotationEnabled = body.rotationEnabled;
     }
-    if (typeof body.rotationStrategy === "string") {
-      if (!CODEX_ROTATION_STRATEGIES.includes(body.rotationStrategy)) {
-        throw new HTTPException4(400, { message: "invalid rotation strategy" });
-      }
-      patch.rotationStrategy = body.rotationStrategy;
-    }
-    if (patch.rotationEnabled === void 0 && patch.rotationStrategy === void 0) {
+    if (patch.rotationEnabled === void 0 && body.rotationStrategy === void 0) {
       throw new HTTPException4(400, { message: "no settings to update" });
     }
+    if (patch.rotationEnabled === void 0) {
+      return c.json({ rotationStrategy: "sharded", rotationStrategyDeprecated: true });
+    }
     await ensureCodexRotationSettings(db, grant.accountId, workspaceId);
     const mutation = await withCodexCapacityMutation(
       db,
@@ -3234,7 +4205,8 @@ function registerCodexRoutes(app, deps) {
     await signalCodexCapacityTargets(deps, mutation.wakeTargets);
     return c.json({
       rotationEnabled: updated.rotationEnabled,
-      rotationStrategy: updated.rotationStrategy,
+      // sharded-rotation policy: sharded is the only behavior; the stored column is residue.
+      rotationStrategy: "sharded",
       activeCredentialId: updated.activeCredentialId
     });
   });
@@ -3385,7 +4357,7 @@ import {
   storeIntegrationOAuthClient,
   updateConnection
 } from "@opengeni/db";
-import { createSignedState as createSignedState3, readSignedState as readSignedState2 } from "@opengeni/github";
+import { createSignedState as createSignedState2, readSignedState as readSignedState2 } from "@opengeni/github";
 import { Buffer as Buffer2 } from "buffer";
 import { createHash, randomBytes } from "crypto";
 import { lookup } from "dns/promises";
@@ -3450,7 +4422,7 @@ async function startMcpOAuth(deps, context) {
     context.payload.oauthClient
   );
   const key = requireEnvironmentEncryption(settings);
-  const state = createSignedState3(requireIntegrationsStateSecret(settings), {
+  const state = createSignedState2(requireIntegrationsStateSecret(settings), {
     accountId: context.accountId,
     workspaceId: context.workspaceId,
     subjectId: context.subjectId,
@@ -5439,7 +6411,7 @@ async function buildEnrollmentCredentials(services, input) {
     // 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 (dossier §V5/§V6).
+    // makes the terminal/desktop streams unreachable.
     relayUrl: relayDialBaseFromSettings(settings),
     relayToken,
     // M-AUTH closes the placeholder: there is NO per-machine NATS Account creds
@@ -6995,46 +7967,44 @@ function looksLikeEmail(value) {
 
 // src/routes/github.ts
 import { GitHubAppManifestCreate } from "@opengeni/contracts";
-import { listGitHubInstallationIdsForWorkspace as listGitHubInstallationIdsForWorkspace2, upsertGitHubInstallation } from "@opengeni/db";
+import { deleteGitHubInstallationBinding } from "@opengeni/db";
 import {
   buildGitHubAppManifest,
   convertGitHubAppManifest,
-  createSignedState as createSignedState4,
+  createSignedState as createSignedState3,
   envLinesFromGitHubManifestConversion,
   GitHubAppApiError,
   GitHubAppConfigurationError as GitHubAppConfigurationError2,
-  githubOAuthAuthorizeUrl,
   githubAppMissingSettings as githubAppMissingSettings2,
-  listGitHubAppRepositories as listGitHubAppRepositories2,
   organizationAppManifestUrl,
   personalAppManifestUrl,
   readSignedState as readSignedState3,
-  stateMaxAgeSeconds as stateMaxAgeSeconds2,
-  verifyGitHubInstallationAccessForUser,
+  stateMaxAgeSeconds,
   verifySignedState
 } from "@opengeni/github";
-import { deleteCookie, getCookie, setCookie } from "hono/cookie";
+import { setCookie } from "hono/cookie";
 import { HTTPException as HTTPException15 } from "hono/http-exception";
 import { requireAccessGrant as requireAccessGrant10 } from "@opengeni/core";
 var githubStateCookie = "opengeni_github_state";
+var installationBindingDisabledMessage = "Connecting a GitHub App installation is disabled until GitHub installation authority can be proven";
 function registerGitHubRoutes(app, deps) {
-  const { settings, githubStateSecret } = deps;
+  const { db, settings, githubStateSecret } = deps;
   app.get("/v1/workspaces/:workspaceId/github/app", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant10(c, deps, workspaceId, "github:use");
     const missing = githubAppMissingSettings2(settings);
     const slug = settings.githubAppSlug?.trim() || null;
-    const state = createSignedState4(githubStateSecret, {
-      accountId: grant.accountId,
-      workspaceId: grant.workspaceId
-    });
-    setGitHubStateCookie(c, deps, state);
     return c.json({
       configured: missing.length === 0,
       appId: settings.githubAppId ?? null,
       clientId: settings.githubClientId ?? null,
       appSlug: slug,
-      installUrl: slug ? `https://github.com/apps/${slug}/installations/new?state=${encodeURIComponent(state)}` : null,
+      // Kept nullable for SDK compatibility. GitHub's setup callback contains
+      // a spoofable installation_id, while user-installation visibility and
+      // repository admin permission do not prove that this human may bind it.
+      installUrl: null,
+      linkUrl: null,
+      installations: await listWorkspaceGitHubInstallationBindings(deps, grant.workspaceId),
       missing
     });
   });
@@ -7048,19 +8018,7 @@ function registerGitHubRoutes(app, deps) {
     if (!statePayload || statePayload.workspaceId !== workspaceId) {
       throw new HTTPException15(400, { message: "invalid or expired GitHub installation state" });
     }
-    const slug = settings.githubAppSlug?.trim();
-    if (!slug) {
-      throw new HTTPException15(409, {
-        message: JSON.stringify({
-          message: "GitHub App is not configured",
-          missing: githubAppMissingSettings2(settings)
-        })
-      });
-    }
-    setGitHubStateCookie(c, deps, state);
-    return c.redirect(
-      `https://github.com/apps/${slug}/installations/new?state=${encodeURIComponent(state)}`
-    );
+    throw installationBindingDisabled();
   });
   app.get("/v1/workspaces/:workspaceId/github/repositories", async (c) => {
     const workspaceId = c.req.param("workspaceId");
@@ -7094,6 +8052,23 @@ function registerGitHubRoutes(app, deps) {
       });
     }
   });
+  app.delete("/v1/workspaces/:workspaceId/github/installations/:installationId", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant10(c, deps, workspaceId, "github:manage");
+    const installationId = parsePositiveInteger(c.req.param("installationId"));
+    if (installationId === null) {
+      throw new HTTPException15(400, { message: "invalid GitHub installation id" });
+    }
+    const deleted = await deleteGitHubInstallationBinding(db, {
+      accountId: grant.accountId,
+      workspaceId: grant.workspaceId,
+      installationId
+    });
+    if (!deleted) {
+      throw new HTTPException15(404, { message: "GitHub installation binding not found" });
+    }
+    return c.body(null, 204);
+  });
   app.post("/v1/workspaces/:workspaceId/github/app-manifest", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant10(c, deps, workspaceId, "github:manage");
@@ -7102,7 +8077,7 @@ function registerGitHubRoutes(app, deps) {
       /\/+$/,
       ""
     );
-    const state = createSignedState4(githubStateSecret, {
+    const state = createSignedState3(githubStateSecret, {
       accountId: grant.accountId,
       workspaceId: grant.workspaceId
     });
@@ -7134,20 +8109,15 @@ function registerGitHubRoutes(app, deps) {
     try {
       const conversion = await convertGitHubAppManifest(code);
       const envLines = envLinesFromGitHubManifestConversion(conversion);
-      const slug = String(conversion.slug ?? "");
-      const installUrl = slug ? `https://github.com/apps/${slug}/installations/new?state=${encodeURIComponent(state)}` : "";
       setGitHubStateCookie(c, deps, state);
-      return c.html(githubSuccessHtml(envLines, installUrl));
+      return c.html(githubSuccessHtml(envLines));
     } catch (error) {
       const message = error instanceof GitHubAppApiError ? error.message : String(error);
       throw new HTTPException15(502, { message });
     }
   });
   const handleGitHubInstallCallback = async (c) => {
-    const code = c.req.query("code");
     const state = c.req.query("state");
-    const installationIdRaw = c.req.query("installation_id");
-    const setupAction = c.req.query("setup_action") ?? null;
     if (!state) {
       throw new HTTPException15(400, { message: "missing GitHub installation state" });
     }
@@ -7155,162 +8125,54 @@ function registerGitHubRoutes(app, deps) {
     if (!statePayload || typeof statePayload.accountId !== "string" || typeof statePayload.workspaceId !== "string") {
       throw new HTTPException15(400, { message: "invalid or expired GitHub installation state" });
     }
-    requireGitHubStateCookie(c, state);
-    const grant = await requireAccessGrant10(c, deps, statePayload.workspaceId, "github:manage");
-    if (grant.accountId !== statePayload.accountId) {
-      throw new HTTPException15(403, {
-        message: "GitHub installation state does not match this workspace"
-      });
-    }
-    if (setupAction === "request" && !installationIdRaw) {
-      return c.html(githubSetupPendingHtml());
-    }
-    const installationId = parsePositiveInteger(installationIdRaw);
-    if (installationId === null) {
-      throw new HTTPException15(400, { message: "missing or invalid GitHub installation_id" });
-    }
-    if (!code) {
-      const clientId = settings.githubClientId?.trim();
-      if (!clientId) {
-        throw new HTTPException15(409, {
-          message: JSON.stringify({
-            message: "GitHub App is not configured",
-            missing: ["OPENGENI_GITHUB_CLIENT_ID"]
-          })
-        });
-      }
-      const oauthState = createSignedState4(githubStateSecret, {
-        accountId: grant.accountId,
-        workspaceId: grant.workspaceId,
-        installationId
-      });
-      const baseUrl = (settings.githubAppManifestBaseUrl ?? settings.publicBaseUrl ?? new URL(c.req.url).origin).replace(/\/+$/, "");
-      setGitHubStateCookie(c, deps, oauthState);
-      return c.redirect(
-        githubOAuthAuthorizeUrl({
-          clientId,
-          state: oauthState,
-          redirectUri: `${baseUrl}/v1/github/oauth/callback`
-        })
-      );
-    }
-    return await completeGitHubInstallationBinding(deps, c, {
-      code,
-      statePayload,
-      installationId
-    });
+    throw installationBindingDisabled();
   };
   app.get("/v1/github/setup", handleGitHubInstallCallback);
   app.get("/v1/github/install/callback", handleGitHubInstallCallback);
   app.get("/v1/github/oauth/callback", async (c) => {
-    const code = c.req.query("code");
     const state = c.req.query("state");
-    if (!code) {
-      throw new HTTPException15(400, { message: "missing GitHub OAuth code" });
-    }
     if (!state) {
       throw new HTTPException15(400, { message: "missing GitHub OAuth state" });
     }
     const statePayload = readSignedState3(state, githubStateSecret);
-    const installationId = parsePositiveInteger(String(statePayload?.installationId ?? ""));
-    if (!statePayload || typeof statePayload.accountId !== "string" || typeof statePayload.workspaceId !== "string" || installationId === null) {
+    if (!statePayload || typeof statePayload.accountId !== "string" || typeof statePayload.workspaceId !== "string") {
       throw new HTTPException15(400, { message: "invalid or expired GitHub OAuth state" });
     }
-    requireGitHubStateCookie(c, state);
-    return await completeGitHubInstallationBinding(deps, c, {
-      code,
-      statePayload,
-      installationId
-    });
+    throw installationBindingDisabled();
   });
-}
-async function completeGitHubInstallationBinding(deps, c, input) {
-  const { db, settings } = deps;
-  if (!input.statePayload.workspaceId || !input.statePayload.accountId) {
-    throw new HTTPException15(400, { message: "invalid or expired GitHub installation state" });
-  }
-  const grant = await requireAccessGrant10(c, deps, input.statePayload.workspaceId, "github:manage");
-  if (grant.accountId !== input.statePayload.accountId) {
-    throw new HTTPException15(403, {
-      message: "GitHub installation state does not match this workspace"
-    });
-  }
-  try {
-    const installation = await verifyGitHubInstallationAccessForUser(settings, {
-      code: input.code,
-      installationId: input.installationId
-    });
-    if (!installation) {
-      throw new HTTPException15(404, {
-        message: "GitHub App installation was not found for this app"
-      });
-    }
-    if (installation.suspended) {
-      throw new HTTPException15(409, { message: "GitHub App installation is suspended" });
-    }
-    await upsertGitHubInstallation(db, {
-      accountId: grant.accountId,
-      workspaceId: grant.workspaceId,
-      installationId: input.installationId,
-      accountLogin: installation.accountLogin,
-      accountType: installation.accountType
-    });
-    const returnUrl = openGeniReturnUrl(settings, c, input.statePayload.workspaceId);
-    deleteCookie(c, githubStateCookie, { path: "/v1/github" });
-    return c.html(
-      githubSetupSuccessHtml(
-        installation.accountLogin ?? `installation ${input.installationId}`,
-        returnUrl
-      )
-    );
-  } catch (error) {
-    if (error instanceof HTTPException15) {
-      throw error;
+  app.post("/v1/workspaces/:workspaceId/github/installations", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const form = new URLSearchParams(await c.req.text());
+    const state = form.get("oauth_state");
+    if (!state) {
+      throw new HTTPException15(400, { message: "missing GitHub OAuth state" });
     }
-    if (error instanceof GitHubAppConfigurationError2) {
-      throw new HTTPException15(409, {
-        message: JSON.stringify({ message: error.message, missing: error.missing })
-      });
+    const statePayload = readSignedState3(state, githubStateSecret);
+    if (!statePayload || typeof statePayload.accountId !== "string" || statePayload.accountId.length === 0 || statePayload.workspaceId !== workspaceId) {
+      throw new HTTPException15(400, { message: "invalid or expired GitHub OAuth state" });
     }
-    throw new HTTPException15(502, {
-      message: error instanceof Error ? error.message : String(error)
-    });
-  }
+    throw installationBindingDisabled();
+  });
+}
+function installationBindingDisabled() {
+  return new HTTPException15(410, { message: installationBindingDisabledMessage });
 }
 function setGitHubStateCookie(c, deps, state) {
   setCookie(c, githubStateCookie, state, {
     httpOnly: true,
     sameSite: "Lax",
     secure: isSecureRequest(c, deps),
-    path: "/v1/github",
-    maxAge: stateMaxAgeSeconds2
+    path: "/v1",
+    maxAge: stateMaxAgeSeconds
   });
 }
-function requireGitHubStateCookie(c, state) {
-  if (getCookie(c, githubStateCookie) !== state) {
-    throw new HTTPException15(400, {
-      message: "invalid or expired GitHub installation browser state"
-    });
-  }
-}
 function isSecureRequest(c, deps) {
   return deps.settings.publicBaseUrl?.startsWith("https://") || c.req.header("x-forwarded-proto") === "https" || new URL(c.req.url).protocol === "https:";
 }
-async function listWorkspaceGitHubRepositories(deps, workspaceId) {
-  const installationIds = await listGitHubInstallationIdsForWorkspace2(deps.db, workspaceId);
-  return await listGitHubAppRepositories2(deps.settings, { installationIds });
-}
-function githubSuccessHtml(envLines, installUrl) {
+function githubSuccessHtml(envLines) {
   const envText = envLines.join("\n");
   const escaped = escapeHtml2(envText);
-  const install = installUrl ? `<a class="button secondary" href="${escapeHtml2(installUrl)}">Install on repositories</a>` : "";
-  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>GitHub App Created</title><style>body{font-family:system-ui,sans-serif;margin:0;min-height:100vh;display:grid;place-items:center;background:#0b0b0d;color:#f4f4f5}main{width:min(760px,calc(100vw - 32px));border:1px solid #27272a;border-radius:8px;padding:28px;background:#111114}h1{margin:0 0 10px;font-size:24px;line-height:1.2}p{margin:0 0 18px;color:#d4d4d8}.env-header{display:flex;align-items:center;justify-content:space-between;gap:12px;margin:22px 0 8px}.env-header h2{margin:0;font-size:13px;line-height:1.2;text-transform:uppercase;letter-spacing:.08em;color:#a1a1aa}pre{white-space:pre-wrap;word-break:break-word;max-height:380px;overflow:auto;background:#09090b;border:1px solid #27272a;border-radius:8px;padding:16px;font-size:13px;line-height:1.5}.actions{display:flex;flex-wrap:wrap;gap:10px;margin-top:18px}.button,button{display:inline-flex;align-items:center;justify-content:center;min-height:36px;border-radius:6px;border:1px solid #3f3f46;padding:0 12px;background:#f4f4f5;color:#09090b;font:600 14px system-ui,sans-serif;text-decoration:none;cursor:pointer}.button.secondary{background:transparent;color:#fafafa}.button.secondary:hover,button.secondary:hover{background:#27272a}button:disabled{cursor:not-allowed;opacity:.7}</style></head><body><main><h1>GitHub App created</h1><p>Add these values to .env, then restart API and worker.</p><div class="env-header"><h2>Environment variables</h2><button id="copy-env" type="button">Copy env</button></div><pre id="env-lines">${escaped}</pre><div class="actions">${install}</div><script>(()=>{const button=document.getElementById("copy-env");const env=document.getElementById("env-lines");async function copyText(text){if(navigator.clipboard&&window.isSecureContext){await navigator.clipboard.writeText(text);return;}const area=document.createElement("textarea");area.value=text;area.setAttribute("readonly","");area.style.position="fixed";area.style.inset="-9999px";document.body.append(area);area.select();document.execCommand("copy");area.remove();}button?.addEventListener("click",async()=>{try{await copyText(env?.textContent||"");button.textContent="Copied";setTimeout(()=>button.textContent="Copy env",1600);}catch{button.textContent="Copy failed";setTimeout(()=>button.textContent="Copy env",2200);}});})();</script></main></body></html>`;
-}
-function githubSetupSuccessHtml(account, returnUrl) {
-  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>GitHub App Connected</title><style>body{font-family:system-ui,sans-serif;margin:0;min-height:100vh;display:grid;place-items:center;background:#0b0b0d;color:#f4f4f5}main{width:min(640px,calc(100vw - 32px));border:1px solid #27272a;border-radius:8px;padding:28px;background:#111114}h1{margin:0 0 10px;font-size:24px;line-height:1.2}p{margin:0 0 18px;color:#d4d4d8}.button{display:inline-flex;align-items:center;justify-content:center;min-height:36px;border-radius:6px;border:1px solid #3f3f46;padding:0 12px;background:#f4f4f5;color:#09090b;font:600 14px system-ui,sans-serif;text-decoration:none}.button:hover{background:#e4e4e7}</style></head><body><main><h1>GitHub App connected</h1><p>${escapeHtml2(account)} is now available to this OpenGeni workspace.</p><a class="button" href="${escapeHtml2(returnUrl)}">Back to OpenGeni</a></main></body></html>`;
-}
-function githubSetupPendingHtml() {
-  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>GitHub App Requested</title><style>body{font-family:system-ui,sans-serif;margin:0;min-height:100vh;display:grid;place-items:center;background:#0b0b0d;color:#f4f4f5}main{width:min(640px,calc(100vw - 32px));border:1px solid #27272a;border-radius:8px;padding:28px;background:#111114}h1{margin:0 0 10px;font-size:24px;line-height:1.2}p{margin:0;color:#d4d4d8}</style></head><body><main><h1>GitHub App request sent</h1><p>An organization administrator must approve the installation before OpenGeni can connect it to this workspace.</p></main></body></html>`;
+  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>GitHub App Created</title><style>body{font-family:system-ui,sans-serif;margin:0;min-height:100vh;display:grid;place-items:center;background:#0b0b0d;color:#f4f4f5}main{width:min(760px,calc(100vw - 32px));border:1px solid #27272a;border-radius:8px;padding:28px;background:#111114}h1{margin:0 0 10px;font-size:24px;line-height:1.2}p{margin:0 0 18px;color:#d4d4d8}.env-header{display:flex;align-items:center;justify-content:space-between;gap:12px;margin:22px 0 8px}.env-header h2{margin:0;font-size:13px;line-height:1.2;text-transform:uppercase;letter-spacing:.08em;color:#a1a1aa}pre{white-space:pre-wrap;word-break:break-word;max-height:380px;overflow:auto;background:#09090b;border:1px solid #27272a;border-radius:8px;padding:16px;font-size:13px;line-height:1.5}button{display:inline-flex;align-items:center;justify-content:center;min-height:36px;border-radius:6px;border:1px solid #3f3f46;padding:0 12px;background:#f4f4f5;color:#09090b;font:600 14px system-ui,sans-serif;cursor:pointer}button:disabled{cursor:not-allowed;opacity:.7}</style></head><body><main><h1>GitHub App created</h1><p>Add these values to .env, then restart API and worker.</p><div class="env-header"><h2>Environment variables</h2><button id="copy-env" type="button">Copy env</button></div><pre id="env-lines">${escaped}</pre><script>(()=>{const button=document.getElementById("copy-env");const env=document.getElementById("env-lines");async function copyText(text){if(navigator.clipboard&&window.isSecureContext){await navigator.clipboard.writeText(text);return;}const area=document.createElement("textarea");area.value=text;area.setAttribute("readonly","");area.style.position="fixed";area.style.inset="-9999px";document.body.append(area);area.select();document.execCommand("copy");area.remove();}button?.addEventListener("click",async()=>{try{await copyText(env?.textContent||"");button.textContent="Copied";setTimeout(()=>button.textContent="Copy env",1600);}catch{button.textContent="Copy failed";setTimeout(()=>button.textContent="Copy env",2200);}});})();</script></main></body></html>`;
 }
 function parsePositiveInteger(value) {
   if (!value || !/^\d+$/.test(value)) {
@@ -7331,14 +8193,6 @@ function escapeHtml2(value) {
     })[char] ?? char
   );
 }
-function openGeniReturnUrl(settings, c, workspaceId) {
-  const base = (settings.publicBaseUrl ?? new URL(c.req.url).origin).replace(/\/+$/, "");
-  const url = new URL(base || new URL(c.req.url).origin);
-  if (workspaceId) {
-    url.searchParams.set("workspaceId", workspaceId);
-  }
-  return url.toString();
-}
 
 // src/routes/packs.ts
 import {
@@ -7603,8 +8457,8 @@ import {
   createRigForApi,
   createRigVersionForApi,
   deleteRigForApi,
-  listRigChangesForApi as listRigChangesForApi2,
-  listRigVersionsForApi as listRigVersionsForApi2,
+  listRigChangesForApi,
+  listRigVersionsForApi,
   promoteVerifiedDefinitionEditChangeForApi as promoteVerifiedDefinitionEditChangeForApi2,
   proposeRigChangeForApi as proposeRigChangeForApi2,
   requireRigChangeForApi as requireRigChangeForApi2,
@@ -7674,7 +8528,7 @@ function registerRigRoutes(app, deps) {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant12(c, deps, workspaceId, "rigs:use");
     const rig = await requireRigForApi2(db, workspaceId, c.req.param("rigId"));
-    return c.json(await listRigVersionsForApi2({ db }, workspaceId, rig.id));
+    return c.json(await listRigVersionsForApi({ db }, workspaceId, rig.id));
   });
   app.post("/v1/workspaces/:workspaceId/rigs/:rigId/versions", async (c) => {
     const workspaceId = c.req.param("workspaceId");
@@ -7695,7 +8549,7 @@ function registerRigRoutes(app, deps) {
     await requireAccessGrant12(c, deps, workspaceId, "rigs:use");
     const rig = await requireRigForApi2(db, workspaceId, c.req.param("rigId"));
     return c.json(
-      await listRigChangesForApi2({ db }, workspaceId, rig.id, boundedLimit(c.req.query("limit")))
+      await listRigChangesForApi({ db }, workspaceId, rig.id, boundedLimit(c.req.query("limit")))
     );
   });
   app.post("/v1/workspaces/:workspaceId/rigs/:rigId/changes", async (c) => {
@@ -7914,6 +8768,7 @@ import {
   FsMoveRequest,
   FsReadRequest,
   FsWriteRequest,
+  HumanInputRequestStatus,
   GitDiffRequest,
   GitLogRequest,
   GitShowRequest,
@@ -7924,6 +8779,12 @@ import {
   PtyResizeRequest,
   PtyWriteRequest,
   SessionControlRequest,
+  SESSION_EVENT_RAW_DELTA_TYPES as SESSION_EVENT_RAW_DELTA_TYPES2,
+  SessionEventPayloadMode as SessionEventPayloadMode2,
+  SessionEventReadDirection as SessionEventReadDirection2,
+  SessionEventReadMode as SessionEventReadMode2,
+  SessionEventSemanticClass as SessionEventSemanticClass2,
+  SessionEventType as SessionEventType2,
   SaveComposerDraftRequest,
   SteerSessionQueueItemRequest,
   SteerSessionMessageRequest,
@@ -7931,11 +8792,14 @@ import {
   UpdateSessionPinRequest,
   UpdateSessionGoalRequest,
   UpdateSessionRequest,
-  ViewerHeartbeatRequest
+  ViewerHeartbeatRequest,
+  WORKSPACE_CONTROL_ACTOR_MAX_BYTES,
+  workspaceControlUtf8Bytes
 } from "@opengeni/contracts";
 import { streamTokenDegraded } from "@opengeni/config";
 import {
   acceptSessionApprovalDecision,
+  acceptSessionHumanInputResponse,
   clearSessionGoal,
   clearSessionContext,
   closePtySession,
@@ -7944,13 +8808,17 @@ import {
   getSession as getSession4,
   getSessionForSubject,
   getSessionGoal as getSessionGoal2,
+  getSessionHumanInputRequest,
   getSessionQueueSnapshot as getSessionQueueSnapshot2,
   getStreamAcknowledgment,
   insertPtySession,
-  listSessionEvents as listSessionEvents3,
+  listSessionEventPage as listSessionEventPage2,
+  listSessionHumanInputRequests,
   listSessionIdsInGroup,
   listSessionsForSubject,
   listSessionTurns,
+  projectEffectiveControlForRelatedAccess as projectEffectiveControlForRelatedAccess2,
+  projectSessionForRelatedAccess as projectSessionForRelatedAccess2,
   recordStreamAcknowledgment,
   requestSessionCompaction,
   setSessionCodexPin,
@@ -7968,11 +8836,13 @@ import {
   SessionCommandIdempotencyError,
   SessionControlConflictError,
   SessionContextBusyError,
+  HumanInputResponseValidationError,
   latestWorkspaceCapture,
   workspaceCaptureAtRevision
 } from "@opengeni/db";
 import {
   appendAndPublishEvents as appendAndPublishEvents5,
+  boundSessionEventHttpPage,
   coalesceSessionEventDeltas,
   publishDurableSessionEvents
 } from "@opengeni/events";
@@ -8007,7 +8877,11 @@ import {
   ChannelAConflictError,
   ChannelANotFoundError,
   ChannelAUnsupportedError,
-  ChannelAValidationError
+  ChannelAUnavailableError,
+  ChannelAValidationError,
+  toolspaceTokenFileFromEnvironment,
+  withToolspaceTokenSession,
+  withRunCredentialsSession
 } from "@opengeni/runtime/sandbox";
 import { routingEnabled, wrapChannelABoxWithRouting } from "@opengeni/core";
 async function withChannelA(services, ctx, fn) {
@@ -8158,8 +9032,13 @@ async function withChannelA(services, ctx, fn) {
       { workspaceId, sessionId: session.id },
       established
     ).session : established.session;
+    const credentialSession = withRunCredentialsSession(routedSession, session.id);
+    const scopedSession = environment.OPENGENI_TOOLSPACE_TOKEN_FILE ? withToolspaceTokenSession(
+      credentialSession,
+      toolspaceTokenFileFromEnvironment(environment, session.id)
+    ) : credentialSession;
     const service = new SandboxChannelAService({
-      session: routedSession,
+      session: scopedSession,
       leaseEpoch: leaseSnapshot.leaseEpoch,
       emit
     });
@@ -8173,6 +9052,8 @@ async function withChannelA(services, ctx, fn) {
 }
 function mapChannelAError(error) {
   if (error instanceof HTTPException18) return error;
+  if (error instanceof ChannelAUnavailableError)
+    return new HTTPException18(503, { message: error.message });
   if (error instanceof ChannelAValidationError)
     return new HTTPException18(400, { message: error.message });
   if (error instanceof ChannelANotFoundError)
@@ -8190,7 +9071,14 @@ async function dropEstablishedHandle(established) {
 // src/routes/sessions.ts
 import { negotiateCapabilities } from "@opengeni/runtime/sandbox";
 import { HTTPException as HTTPException21 } from "hono/http-exception";
-import { requireAccessGrant as requireAccessGrant14 } from "@opengeni/core";
+import {
+  requireAccessGrant as requireAccessGrant14,
+  requireSessionAuthorization as requireSessionAuthorization2,
+  requireSessionAuthorizationListScope as requireSessionAuthorizationListScope2,
+  SESSION_AUTHORIZATION_DEFAULT_REAUTHORIZE_MS,
+  SessionAuthorizationDeniedError,
+  SessionAuthorizationUnavailableError
+} from "@opengeni/core";
 
 // src/sandbox/viewer.ts
 import { createHash as createHash2 } from "crypto";
@@ -8772,73 +9660,297 @@ import {
 } from "@opengeni/core";
 
 // src/http/sse.ts
-import { listSessionEvents as listSessionEvents2, listWorkspaceControlEvents } from "@opengeni/db";
-import { formatSse } from "@opengeni/events";
-async function sseSessionStream(db, bus, workspaceId, sessionId, after, signal) {
+import { listSessionEvents, listWorkspaceControlEvents } from "@opengeni/db";
+import {
+  formatSessionEventSse,
+  formatWorkspaceControlEventSse,
+  SESSION_EVENT_SSE_FRAME_MAX_BYTES
+} from "@opengeni/events";
+var SESSION_REPLAY_PAGE_SIZE = 100;
+var WORKSPACE_CONTROL_REPLAY_PAGE_SIZE = 100;
+var SSE_QUEUED_FRAME_MAX_COUNT = 1;
+var SSE_WRITE_STALL_TIMEOUT_MS = 3e4;
+function createByteBoundedSseStream(options = {}) {
+  const maxQueuedBytes = options.maxQueuedBytes ?? SESSION_EVENT_SSE_FRAME_MAX_BYTES;
+  const stallTimeoutMs = options.stallTimeoutMs ?? SSE_WRITE_STALL_TIMEOUT_MS;
+  if (!Number.isSafeInteger(maxQueuedBytes) || maxQueuedBytes <= 0) {
+    throw new RangeError("SSE byte high-water mark must be a positive safe integer");
+  }
+  if (!Number.isSafeInteger(stallTimeoutMs) || stallTimeoutMs <= 0) {
+    throw new RangeError("SSE write stall timeout must be a positive safe integer");
+  }
   const encoder = new TextEncoder();
   let controller;
+  let stopped = false;
+  let capacityWake = null;
+  let queuedFrames = 0;
+  let queuedBytes = 0;
+  const wakeWriter = () => {
+    const wake = capacityWake;
+    capacityWake = null;
+    wake?.();
+  };
+  const stop = (settle) => {
+    if (stopped) return;
+    stopped = true;
+    wakeWriter();
+    options.onStop?.();
+    try {
+      settle();
+    } catch {
+    }
+  };
+  const stream = new ReadableStream(
+    {
+      start: (rawController) => {
+        controller = rawController;
+      },
+      pull: () => {
+        queuedFrames = 0;
+        queuedBytes = 0;
+        wakeWriter();
+      },
+      cancel: () => {
+        if (stopped) return;
+        stopped = true;
+        wakeWriter();
+        options.onStop?.();
+      }
+    },
+    {
+      highWaterMark: SSE_QUEUED_FRAME_MAX_COUNT,
+      size: () => 1
+    }
+  );
+  return {
+    stream,
+    write: async (frame) => {
+      const chunk = encoder.encode(frame);
+      if (chunk.byteLength > maxQueuedBytes) {
+        const error = new RangeError(
+          `SSE frame cannot fit in the configured queue (${chunk.byteLength} > ${maxQueuedBytes} bytes)`
+        );
+        options.onObservation?.({
+          reason: "frame_too_large",
+          desiredSize: controller.desiredSize,
+          queuedFrames,
+          queuedBytes
+        });
+        stop(() => controller.error(error));
+        throw error;
+      }
+      for (; ; ) {
+        if (stopped) return false;
+        const desired = controller.desiredSize;
+        if (desired === null) return false;
+        if (desired >= 1 && queuedFrames === 0) {
+          controller.enqueue(chunk);
+          queuedFrames = 1;
+          queuedBytes = chunk.byteLength;
+          return true;
+        }
+        options.onObservation?.({
+          reason: "desired_size_non_positive",
+          desiredSize: desired,
+          queuedFrames,
+          queuedBytes
+        });
+        const outcome = await new Promise((resolve) => {
+          let settled = false;
+          const finish = (result) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            if (capacityWake === wake) capacityWake = null;
+            resolve(result);
+          };
+          const wake = () => finish("capacity");
+          const timer = setTimeout(() => finish("timeout"), stallTimeoutMs);
+          capacityWake = wake;
+        });
+        if (outcome === "timeout" && !stopped) {
+          const error = new TypeError(
+            `SSE consumer did not drain the single-frame queue within ${stallTimeoutMs}ms`
+          );
+          options.onObservation?.({
+            reason: "stall_timeout",
+            desiredSize: controller.desiredSize,
+            queuedFrames,
+            queuedBytes
+          });
+          stop(() => controller.error(error));
+          throw error;
+        }
+      }
+    },
+    close: () => stop(() => controller.close()),
+    fail: (error) => stop(() => controller.error(error)),
+    stopped: () => stopped
+  };
+}
+function createLatestWinsDelivery(send, onError) {
+  let newest = null;
+  let running = null;
+  let stopped = false;
+  const start = () => {
+    if (stopped || running || !newest) return;
+    const run = async () => {
+      for (; ; ) {
+        if (stopped || !newest) return;
+        const target = newest;
+        newest = null;
+        await send(target);
+      }
+    };
+    running = run().catch((error) => {
+      stopped = true;
+      newest = null;
+      onError(error);
+    }).finally(() => {
+      running = null;
+      start();
+    });
+  };
+  return {
+    publish: (events) => {
+      if (stopped) return;
+      for (const event of events) {
+        if (!newest || event.sequence > newest.sequence) newest = event;
+      }
+      start();
+    },
+    stop: () => {
+      stopped = true;
+      newest = null;
+    },
+    whenIdle: async () => {
+      for (; ; ) {
+        const pending = running;
+        if (!pending) return;
+        await pending;
+      }
+    },
+    pendingSequence: () => newest?.sequence ?? null
+  };
+}
+async function sseSessionStream(db, bus, workspaceId, sessionId, after, signal, options = {}) {
+  if (options.reauthorize && options.reauthorizeAfterMs !== void 0 && (!Number.isSafeInteger(options.reauthorizeAfterMs) || options.reauthorizeAfterMs < 1e3 || options.reauthorizeAfterMs > 6e4)) {
+    throw new RangeError("session stream reauthorization must be between 1000 and 60000ms");
+  }
   let lastSent = after;
-  let replaying = true;
-  const buffered = [];
+  let bootstrapping = true;
+  let newestBuffered = null;
   let unsubscribe = null;
-  const stream = new ReadableStream({
-    start: async (rawController) => {
-      controller = rawController;
-      const send = async (event) => {
-        if (event.sequence <= lastSent) {
-          return;
-        }
-        if (event.sequence > lastSent + 1) {
-          const missing = await listSessionEvents2(
-            db,
-            workspaceId,
-            sessionId,
-            lastSent,
-            event.sequence - lastSent - 1
+  let delivery = null;
+  let reauthorizationTimer = null;
+  let detachAbortListener = () => {
+  };
+  const stopUpstream = () => {
+    detachAbortListener();
+    if (reauthorizationTimer) {
+      clearTimeout(reauthorizationTimer);
+      reauthorizationTimer = null;
+    }
+    delivery?.stop();
+    const release = unsubscribe;
+    unsubscribe = null;
+    release?.();
+  };
+  const channel = createByteBoundedSseStream({
+    maxQueuedBytes: options.maxQueuedBytes ?? SESSION_EVENT_SSE_FRAME_MAX_BYTES,
+    ...options.stallTimeoutMs === void 0 ? {} : { stallTimeoutMs: options.stallTimeoutMs },
+    onObservation: sseObservationReporter("session", options),
+    onStop: stopUpstream
+  });
+  const fail = (error) => {
+    channel.fail(retryableSseFailure("session event stream delivery failed", error));
+  };
+  const scheduleReauthorization = () => {
+    if (!options.reauthorize || channel.stopped()) return;
+    const interval = options.reauthorizeAfterMs ?? 15e3;
+    reauthorizationTimer = setTimeout(() => {
+      reauthorizationTimer = null;
+      void options.reauthorize().then(scheduleReauthorization).catch((error) => fail(error));
+    }, interval);
+  };
+  scheduleReauthorization();
+  const writeFrame = async (frame) => {
+    if (!await channel.write(frame)) {
+      throw new SseStreamStoppedError();
+    }
+  };
+  const send = async (event) => {
+    if (event.sequence <= lastSent) return;
+    if (event.sequence > lastSent + 1) {
+      while (lastSent + 1 < event.sequence) {
+        const previousLastSent = lastSent;
+        const missing = await listSessionEvents(db, workspaceId, sessionId, {
+          after: lastSent,
+          limit: Math.min(SESSION_REPLAY_PAGE_SIZE, event.sequence - lastSent - 1)
+        });
+        if (missing.length === 0) {
+          throw new Error(
+            `Session event replay stalled before sequence ${event.sequence}; last sent ${lastSent}`
           );
-          for (const missed of missing) {
-            if (missed.sequence > lastSent) {
-              controller.enqueue(encoder.encode(formatSse(missed)));
-              lastSent = missed.sequence;
-            }
+        }
+        for (const missed of missing) {
+          if (missed.sequence >= event.sequence) break;
+          if (missed.sequence > lastSent) {
+            await writeFrame(formatSessionEventSse(missed));
+            lastSent = missed.sequence;
           }
         }
-        controller.enqueue(encoder.encode(formatSse(event)));
-        lastSent = event.sequence;
-      };
-      unsubscribe = await bus.subscribe(workspaceId, sessionId, async (events) => {
-        if (replaying) {
-          buffered.push(...events);
-          return;
+        if (lastSent === previousLastSent) {
+          throw new Error(
+            `Session event replay made no progress before sequence ${event.sequence}; last sent ${lastSent}`
+          );
         }
-        for (const event of events.sort((a, b) => a.sequence - b.sequence)) {
-          await send(event);
+      }
+    }
+    await writeFrame(formatSessionEventSse(event));
+    lastSent = event.sequence;
+  };
+  delivery = createLatestWinsDelivery(send, fail);
+  void (async () => {
+    const release = await bus.subscribe(workspaceId, sessionId, (events) => {
+      if (bootstrapping) {
+        for (const event of events) {
+          if (!newestBuffered || event.sequence > newestBuffered.sequence) {
+            newestBuffered = event;
+          }
         }
-      });
-      await replaySessionEvents(
-        (cursor, limit) => listSessionEvents2(db, workspaceId, sessionId, cursor, limit),
-        send,
-        after
-      );
-      replaying = false;
-      for (const event of buffered.sort((a, b) => a.sequence - b.sequence)) {
-        await send(event);
+      } else {
+        delivery?.publish(events);
       }
-      buffered.length = 0;
-      controller.enqueue(encoder.encode(": connected\n\n"));
-    },
-    cancel: () => {
-      unsubscribe?.();
+    });
+    if (channel.stopped()) {
+      release();
+      return;
     }
-  });
-  signal.addEventListener(
-    "abort",
-    () => {
-      unsubscribe?.();
-    },
-    { once: true }
-  );
-  return new Response(stream, {
+    unsubscribe = release;
+    await replaySessionEvents(
+      (cursor, limit) => listSessionEvents(db, workspaceId, sessionId, cursor, limit),
+      send,
+      after,
+      SESSION_REPLAY_PAGE_SIZE
+    );
+    await writeFrame(": connected\n\n");
+    bootstrapping = false;
+    const buffered = newestBuffered;
+    newestBuffered = null;
+    if (buffered) delivery.publish([buffered]);
+  })().catch((error) => {
+    if (!(error instanceof SseStreamStoppedError)) fail(error);
+  });
+  const abort = () => {
+    channel.close();
+  };
+  if (signal.aborted) abort();
+  else {
+    signal.addEventListener("abort", abort, { once: true });
+    detachAbortListener = () => signal.removeEventListener("abort", abort);
+  }
+  return new Response(channel.stream, {
     headers: {
       "Content-Type": "text/event-stream; charset=utf-8",
       "Cache-Control": "no-cache, no-transform",
@@ -8846,62 +9958,125 @@ async function sseSessionStream(db, bus, workspaceId, sessionId, after, signal)
     }
   });
 }
-async function replaySessionEvents(loadPage, send, after, pageSize = 1e3) {
+async function replaySessionEvents(loadPage, send, after, pageSize = SESSION_REPLAY_PAGE_SIZE) {
   let cursor = after;
   while (true) {
+    const previousCursor = cursor;
     const page = await loadPage(cursor, pageSize);
     if (page.length === 0) {
       return;
     }
     for (const event of page.sort((a, b) => a.sequence - b.sequence)) {
+      if (event.sequence <= cursor) continue;
       await send(event);
-      cursor = Math.max(cursor, event.sequence);
+      cursor = event.sequence;
     }
     if (page.length < pageSize) {
       return;
     }
+    if (cursor === previousCursor) {
+      throw new Error(
+        `Session event replay made no progress after sequence ${cursor}; refusing to repeat a full stale page`
+      );
+    }
   }
 }
-async function sseWorkspaceControlStream(db, bus, workspaceId, after, signal) {
-  const encoder = new TextEncoder();
+async function sseWorkspaceControlStream(db, bus, workspaceId, after, signal, options = {}) {
   let lastSent = after;
-  let replaying = true;
-  const buffered = [];
+  let bootstrapping = true;
+  let newestBuffered = null;
   let unsubscribe = null;
-  const stream = new ReadableStream({
-    start: async (controller) => {
-      const send = (event) => {
-        if (event.sequence <= lastSent) return;
-        controller.enqueue(encoder.encode(formatSse(event)));
-        lastSent = event.sequence;
-      };
-      unsubscribe = await bus.subscribeWorkspaceControl(workspaceId, async (event) => {
-        if (replaying) {
-          buffered.push(event);
-        } else {
-          send(event);
+  let delivery = null;
+  let detachAbortListener = () => {
+  };
+  const stopUpstream = () => {
+    detachAbortListener();
+    delivery?.stop();
+    const release = unsubscribe;
+    unsubscribe = null;
+    release?.();
+  };
+  const channel = createByteBoundedSseStream({
+    maxQueuedBytes: options.maxQueuedBytes ?? SESSION_EVENT_SSE_FRAME_MAX_BYTES,
+    ...options.stallTimeoutMs === void 0 ? {} : { stallTimeoutMs: options.stallTimeoutMs },
+    onObservation: sseObservationReporter("workspace_control", options),
+    onStop: stopUpstream
+  });
+  const fail = (error) => {
+    channel.fail(retryableSseFailure("workspace control stream delivery failed", error));
+  };
+  const writeFrame = async (frame) => {
+    if (!await channel.write(frame)) throw new SseStreamStoppedError();
+  };
+  const send = async (event) => {
+    if (event.sequence <= lastSent) return;
+    if (event.sequence > lastSent + 1) {
+      while (lastSent < event.sequence) {
+        const previousLastSent = lastSent;
+        const limit = Math.min(
+          WORKSPACE_CONTROL_REPLAY_PAGE_SIZE,
+          Math.max(1, event.sequence - lastSent)
+        );
+        const missing = await listWorkspaceControlEvents(db, workspaceId, lastSent, limit);
+        let reachedIncoming = false;
+        for (const missed of missing.sort((a, b) => a.sequence - b.sequence)) {
+          if (missed.sequence >= event.sequence) {
+            reachedIncoming = true;
+            break;
+          }
+          if (missed.sequence > lastSent) {
+            await writeFrame(formatWorkspaceControlEventSse(missed));
+            lastSent = missed.sequence;
+          }
         }
-      });
-      let cursor = after;
-      while (true) {
-        const page = await listWorkspaceControlEvents(db, workspaceId, cursor, 1e3);
-        for (const event of page) {
-          send(event);
-          cursor = Math.max(cursor, event.sequence);
+        if (reachedIncoming || missing.length < limit) break;
+        if (lastSent === previousLastSent) {
+          throw new Error(
+            `Workspace control gap fill returned a full stale page before sequence ${event.sequence}; last sent ${lastSent}`
+          );
         }
-        if (page.length < 1e3) break;
       }
-      replaying = false;
-      for (const event of buffered.sort((left, right) => left.sequence - right.sequence)) {
-        send(event);
+    }
+    await writeFrame(formatWorkspaceControlEventSse(event));
+    lastSent = event.sequence;
+  };
+  delivery = createLatestWinsDelivery(send, fail);
+  void (async () => {
+    const release = await bus.subscribeWorkspaceControl(workspaceId, (event) => {
+      if (bootstrapping) {
+        if (!newestBuffered || event.sequence > newestBuffered.sequence) newestBuffered = event;
+      } else {
+        delivery?.publish([event]);
       }
-      buffered.length = 0;
-      controller.enqueue(encoder.encode(": connected\n\n"));
-    },
-    cancel: () => unsubscribe?.()
-  });
-  signal.addEventListener("abort", () => unsubscribe?.(), { once: true });
-  return new Response(stream, {
+    });
+    if (channel.stopped()) {
+      release();
+      return;
+    }
+    unsubscribe = release;
+    await replayWorkspaceControlEvents(
+      (cursor, limit) => listWorkspaceControlEvents(db, workspaceId, cursor, limit),
+      send,
+      after,
+      WORKSPACE_CONTROL_REPLAY_PAGE_SIZE
+    );
+    await writeFrame(": connected\n\n");
+    bootstrapping = false;
+    const buffered = newestBuffered;
+    newestBuffered = null;
+    if (buffered) delivery.publish([buffered]);
+  })().catch((error) => {
+    if (!(error instanceof SseStreamStoppedError)) fail(error);
+  });
+  const abort = () => {
+    channel.close();
+  };
+  if (signal.aborted) abort();
+  else {
+    signal.addEventListener("abort", abort, { once: true });
+    detachAbortListener = () => signal.removeEventListener("abort", abort);
+  }
+  return new Response(channel.stream, {
     headers: {
       "Content-Type": "text/event-stream; charset=utf-8",
       "Cache-Control": "no-cache, no-transform",
@@ -8909,6 +10084,49 @@ async function sseWorkspaceControlStream(db, bus, workspaceId, after, signal) {
     }
   });
 }
+async function replayWorkspaceControlEvents(loadPage, send, after, pageSize) {
+  let cursor = after;
+  while (true) {
+    const previousCursor = cursor;
+    const page = await loadPage(cursor, pageSize);
+    if (page.length === 0) return;
+    for (const event of page.sort((a, b) => a.sequence - b.sequence)) {
+      if (event.sequence <= cursor) continue;
+      await send(event);
+      cursor = event.sequence;
+    }
+    if (page.length < pageSize) return;
+    if (cursor === previousCursor) {
+      throw new Error(
+        `Workspace control replay made no progress after sequence ${cursor}; refusing to repeat a full stale page`
+      );
+    }
+  }
+}
+var SseStreamStoppedError = class extends Error {
+};
+function sseObservationReporter(stream, options) {
+  return (observation) => {
+    options.onObservation?.(observation);
+    options.observability?.incrementCounter({
+      name: "opengeni_sse_delivery_bound_events_total",
+      help: "SSE writes that encountered a configured queue, frame, or stall bound.",
+      labels: { stream, reason: observation.reason }
+    });
+    if (observation.reason !== "desired_size_non_positive") {
+      options.observability?.warn("SSE delivery terminated at a bounded stream seam", {
+        stream,
+        reason: observation.reason,
+        desiredSize: observation.desiredSize,
+        queuedFrames: observation.queuedFrames,
+        queuedBytes: observation.queuedBytes
+      });
+    }
+  };
+}
+function retryableSseFailure(message, error) {
+  return error instanceof TypeError ? error : new TypeError(message, { cause: error });
+}
 
 // src/routes/workspace-capture.ts
 import {
@@ -8927,6 +10145,13 @@ function signedUrl(signed) {
 }
 async function loadManifest(row, storage) {
   if (!row.manifestKey) return null;
+  const stats = WorkspaceCaptureStats.safeParse(row.stats);
+  if (!stats.success) {
+    console.warn(
+      `workspace capture read \u2014 row stats failed schema validation (session=${row.sessionId} rev=${row.revision})`
+    );
+    return null;
+  }
   const blob = await storage.getObjectBytes(row.manifestKey);
   if (!blob) return null;
   let json;
@@ -8945,7 +10170,16 @@ async function loadManifest(row, storage) {
     );
     return null;
   }
-  return { manifest: parsed.data, byteLength: blob.bytes.byteLength };
+  const manifest = parsed.data;
+  const servedStats = stats.data;
+  const statsMatch = manifest.stats.repoCount === servedStats.repoCount && manifest.stats.fileCount === servedStats.fileCount && manifest.stats.additions === servedStats.additions && manifest.stats.deletions === servedStats.deletions && manifest.stats.totalBytes === servedStats.totalBytes && manifest.stats.tooLargeCount === servedStats.tooLargeCount && manifest.stats.binaryCount === servedStats.binaryCount && manifest.stats.treeEntryCount === servedStats.treeEntryCount && manifest.stats.treeTruncated === servedStats.treeTruncated && manifest.stats.durationMs === servedStats.durationMs && (manifest.stats.fingerprint ?? null) === (servedStats.fingerprint ?? null);
+  if (manifest.revision !== row.revision || manifest.capturedAt !== row.capturedAt || manifest.turnId !== row.turnId || manifest.leaseEpoch !== row.leaseEpoch || !statsMatch || manifest.repos.length !== manifest.stats.repoCount || manifest.files.length !== manifest.stats.fileCount || manifest.treeTruncated !== manifest.stats.treeTruncated) {
+    console.warn(
+      `workspace capture read \u2014 manifest identity did not match row (session=${row.sessionId} rev=${row.revision})`
+    );
+    return null;
+  }
+  return { manifest, byteLength: blob.bytes.byteLength, stats: servedStats };
 }
 async function serveWorkspaceCapture(row, storage) {
   if (!row) {
@@ -8966,13 +10200,8 @@ async function serveWorkspaceCapture(row, storage) {
     });
   }
   if (row.state !== "available" || !row.manifestKey) return { available: false };
-  const stats = WorkspaceCaptureStats.safeParse(row.stats);
-  if (!stats.success) {
-    console.warn(
-      `workspace capture read \u2014 row stats failed schema validation (session=${row.sessionId} rev=${row.revision})`
-    );
-    return { available: false };
-  }
+  const loaded = await loadManifest(row, storage);
+  if (!loaded) return { available: false };
   const meta = {
     available: true,
     revision: row.revision,
@@ -8980,32 +10209,12 @@ async function serveWorkspaceCapture(row, storage) {
     turnId: row.turnId,
     leaseEpoch: row.leaseEpoch,
     sizeBytes: row.sizeBytes ?? 0,
-    stats: stats.data
+    stats: loaded.stats
   };
-  const blob = await storage.getObjectBytes(row.manifestKey);
-  if (!blob) {
-    return { available: false };
-  }
-  if (blob.bytes.byteLength <= CAPTURE_INLINE_MANIFEST_MAX_BYTES) {
-    let json;
-    try {
-      json = JSON.parse(new TextDecoder().decode(blob.bytes));
-    } catch {
-      console.warn(
-        `workspace capture read \u2014 manifest blob is not valid JSON (session=${row.sessionId} rev=${row.revision})`
-      );
-      return { available: false };
-    }
-    const manifest = WorkspaceCaptureManifest.safeParse(json);
-    if (!manifest.success) {
-      console.warn(
-        `workspace capture read \u2014 manifest failed schema validation (session=${row.sessionId} rev=${row.revision})`
-      );
-      return { available: false };
-    }
+  if (loaded.byteLength <= CAPTURE_INLINE_MANIFEST_MAX_BYTES) {
     return GetWorkspaceCaptureResponse.parse({
       ...meta,
-      manifest: manifest.data,
+      manifest: loaded.manifest,
       manifestUrl: null
     });
   }
@@ -9079,6 +10288,49 @@ async function serveWorkspaceCaptureFile(row, path, storage) {
 // src/routes/sessions.ts
 function registerSessionRoutes(app, deps) {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
+  const requestSessionAuthorization = /* @__PURE__ */ new WeakMap();
+  const relatedSessionAccessFor = (c) => requestSessionAuthorization.get(c.req.raw)?.relatedSessionAccess ?? "root";
+  const projectQueueSnapshot = (snapshot, sessionId, access) => ({
+    ...snapshot,
+    effectiveControl: projectEffectiveControlForRelatedAccess2(
+      snapshot.effectiveControl,
+      sessionId,
+      access
+    )
+  });
+  const authorizeSessionHttp = async (c, next) => {
+    if (!deps.sessionAuthorization) {
+      await next();
+      return;
+    }
+    const workspaceId = c.req.param("workspaceId") ?? "";
+    const sessionId = c.req.param("sessionId") ?? "";
+    const operation = sessionAuthorizationOperationForHttp(
+      c.req.method,
+      new URL(c.req.url).pathname,
+      sessionId
+    );
+    if (operation === "session.stream.read") {
+      await next();
+      return;
+    }
+    if (!operation) {
+      throw sessionAuthorizationHttpError(new SessionAuthorizationUnavailableError());
+    }
+    const grant = await requireAccessGrant14(c, deps, workspaceId);
+    try {
+      const authorization = await requireSessionAuthorization2(deps, grant, {
+        sessionId,
+        operation,
+        surface: "http"
+      });
+      if (authorization) requestSessionAuthorization.set(c.req.raw, authorization);
+    } catch (error) {
+      throw sessionAuthorizationHttpError(error);
+    }
+    await next();
+  };
+  app.use("/v1/workspaces/:workspaceId/sessions/:sessionId/*", authorizeSessionHttp);
   app.post("/v1/workspaces/:workspaceId/sessions", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant14(c, deps, workspaceId, "sessions:create");
@@ -9088,6 +10340,12 @@ function registerSessionRoutes(app, deps) {
   app.get("/v1/workspaces/:workspaceId/sessions", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant14(c, deps, workspaceId, "sessions:read");
+    let authorizationScope;
+    try {
+      authorizationScope = await requireSessionAuthorizationListScope2(deps, grant, "http");
+    } catch (error) {
+      throw sessionAuthorizationHttpError(error);
+    }
     const pageView = c.req.query("view") === "page";
     const query = sessionListQuery(c.req.query(), pageView);
     let page;
@@ -9097,7 +10355,8 @@ function registerSessionRoutes(app, deps) {
         limit: boundedLimit(query.limit),
         ...query.cursor ? { cursor: query.cursor } : {},
         ...query.search ? { search: query.search } : {},
-        ...query.parentSessionId !== void 0 ? { parentSessionId: query.parentSessionId } : {}
+        ...query.parentSessionId !== void 0 ? { parentSessionId: query.parentSessionId } : {},
+        ...authorizationScope ? { authorizationScope } : {}
       });
     } catch (error) {
       if (error instanceof SessionListAccessError) {
@@ -9108,6 +10367,7 @@ function registerSessionRoutes(app, deps) {
       }
       throw error;
     }
+    c.header("x-opengeni-pinned-truncated", page.pinnedTruncated === true ? "true" : "false");
     if (pageView) {
       return c.json(page);
     }
@@ -9120,7 +10380,13 @@ function registerSessionRoutes(app, deps) {
     if (!z2.string().uuid().safeParse(sessionId).success) {
       throw new HTTPException21(404, { message: "session not found" });
     }
-    const session = await getSessionForSubject(db, workspaceId, sessionId, grant.subjectId);
+    const session = await getSessionForSubject(
+      db,
+      workspaceId,
+      sessionId,
+      grant.subjectId,
+      relatedSessionAccessFor(c)
+    );
     if (!session) {
       throw new HTTPException21(404, { message: "session not found" });
     }
@@ -9147,14 +10413,17 @@ function registerSessionRoutes(app, deps) {
       if (!session) {
         throw new HTTPException21(404, { message: "session not found" });
       }
-      return c.json(session);
+      return c.json(projectSessionForRelatedAccess2(session, relatedSessionAccessFor(c)));
     } catch (error) {
       if (error instanceof SessionPinAccessError) {
         throw new HTTPException21(403, { message: error.message });
       }
       if (error instanceof SessionPinVersionConflictError) {
         return c.json(
-          { message: "session pin changed in another client", current: error.current },
+          {
+            message: "session pin changed in another client",
+            current: error.current
+          },
           409
         );
       }
@@ -9163,8 +10432,8 @@ function registerSessionRoutes(app, deps) {
   });
   app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/lineage", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    await requireAccessGrant14(c, deps, workspaceId, "sessions:read");
-    return c.json(await readSessionLineage(db, workspaceId, c.req.param("sessionId")));
+    const grant = await requireAccessGrant14(c, deps, workspaceId, "sessions:read");
+    return c.json(await readSessionLineage(deps, grant, c.req.param("sessionId")));
   });
   app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/codex-account", async (c) => {
     const workspaceId = c.req.param("workspaceId");
@@ -9173,7 +10442,9 @@ function registerSessionRoutes(app, deps) {
     const body = await c.req.json();
     const target = typeof body.target === "string" ? body.target : "";
     if (!target) {
-      throw new HTTPException21(400, { message: 'target is required ("auto" or an account id)' });
+      throw new HTTPException21(400, {
+        message: 'target is required ("auto" or an account id)'
+      });
     }
     const pinned = target === "auto" ? null : target;
     const mutation = await withCodexCapacityMutation2(
@@ -9186,7 +10457,9 @@ function registerSessionRoutes(app, deps) {
     );
     const ok = mutation.result;
     if (!ok) {
-      throw new HTTPException21(404, { message: "session or codex account not found" });
+      throw new HTTPException21(404, {
+        message: "session or codex account not found"
+      });
     }
     await Promise.allSettled(
       mutation.wakeTargets.map(
@@ -9214,8 +10487,14 @@ function registerSessionRoutes(app, deps) {
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
     const payload = UpdateSessionRequest.parse(await c.req.json());
-    await updateSessionTitle2({ db, bus }, workspaceId, sessionId, payload.title, "user");
-    const session = await getSessionForSubject(db, workspaceId, sessionId, grant.subjectId);
+    const titleUpdate = await updateSessionTitle2(deps, grant, sessionId, payload.title, "user");
+    const session = await getSessionForSubject(
+      db,
+      workspaceId,
+      sessionId,
+      grant.subjectId,
+      titleUpdate.relatedSessionAccess
+    );
     if (!session) {
       throw new HTTPException21(404, { message: "session not found" });
     }
@@ -9373,28 +10652,132 @@ function registerSessionRoutes(app, deps) {
       workflowId: requested.temporalWorkflowId,
       wakeRevision: requested.wakeRevision
     });
-    return c.json({ status: "pending", message: "Compaction will run at the next safe boundary." });
+    return c.json({
+      status: "pending",
+      message: "Compaction will run at the next safe boundary."
+    });
   });
   app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/events", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant14(c, deps, workspaceId, "sessions:read");
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    const after = eventSequence(c.req.query("after"), 0);
-    const before = optionalEventSequence(c.req.query("before"));
+    const rawAfter = c.req.query("after");
+    const rawBefore = c.req.query("before");
+    const after = eventSequence(rawAfter, 0);
+    const before = optionalEventSequence(rawBefore);
     const compact = compactEvents(c.req.query("compact"));
-    const limit = eventListLimit(c.req.query("limit"), compact ? 5e3 : 2e3);
-    const events = await listSessionEvents3(db, workspaceId, sessionId, {
+    const explicitReplay = rawAfter !== void 0 || rawBefore !== void 0 || compact;
+    const mode = eventEnumValue(
+      c.req.query("mode"),
+      SessionEventReadMode2,
+      "mode",
+      explicitReplay ? "forensic" : "monitoring"
+    );
+    const latestClass = eventEnumValue(
+      c.req.query("latest"),
+      SessionEventSemanticClass2,
+      "latest",
+      void 0
+    );
+    if (latestClass && ["includeTypes", "excludeTypes", "includeClasses", "excludeClasses"].some(
+      (name) => c.req.query(name) !== void 0
+    )) {
+      throw new HTTPException21(400, {
+        message: "latest cannot be combined with event filters"
+      });
+    }
+    const direction = latestClass ? "before" : eventEnumValue(
+      c.req.query("direction"),
+      SessionEventReadDirection2,
+      "direction",
+      before !== void 0 ? "before" : rawAfter !== void 0 ? "after" : mode === "monitoring" ? "before" : "after"
+    );
+    const payloadMode = eventEnumValue(
+      c.req.query("payloadMode"),
+      SessionEventPayloadMode2,
+      "payloadMode",
+      mode === "monitoring" ? "summary" : "full"
+    );
+    const includeTypes = eventEnumList(
+      c.req.query("includeTypes"),
+      SessionEventType2,
+      "includeTypes"
+    );
+    const excludeTypes = eventEnumList(
+      c.req.query("excludeTypes"),
+      SessionEventType2,
+      "excludeTypes"
+    );
+    const includeClasses = eventEnumList(
+      c.req.query("includeClasses"),
+      SessionEventSemanticClass2,
+      "includeClasses"
+    );
+    const excludeClasses = eventEnumList(
+      c.req.query("excludeClasses"),
+      SessionEventSemanticClass2,
+      "excludeClasses"
+    );
+    const limit = latestClass ? 1 : eventListLimit(
+      c.req.query("limit"),
+      compact ? 5e3 : mode === "monitoring" ? 250 : 2e3,
+      mode === "monitoring" ? 40 : 500
+    );
+    const dbPage = await listSessionEventPage2(db, workspaceId, sessionId, {
       after,
       ...before !== void 0 ? { before } : {},
-      limit
+      limit,
+      direction,
+      payloadMode,
+      includeTypes,
+      excludeTypes,
+      includeClasses: latestClass ? [latestClass] : includeClasses,
+      excludeClasses,
+      ...mode === "monitoring" ? { defaultExcludeTypes: SESSION_EVENT_RAW_DELTA_TYPES2 } : {}
     });
-    return c.json(compact ? coalesceSessionEventDeltas(events) : events);
+    const events = dbPage.events;
+    const projected = compact ? coalesceSessionEventDeltas(events) : events;
+    const page = boundSessionEventHttpPage(projected, {
+      direction
+    });
+    const hasMore = dbPage.hasMore || page.truncated;
+    c.header("X-OpenGeni-Page-Bytes", String(page.bytes));
+    c.header("X-OpenGeni-Page-Max-Bytes", String(1024 * 1024));
+    c.header("X-OpenGeni-Page-Truncated", String(hasMore));
+    c.header("X-OpenGeni-Has-More", String(hasMore));
+    c.header("X-OpenGeni-Event-Mode", mode);
+    c.header("X-OpenGeni-Event-Direction", direction);
+    c.header("X-OpenGeni-Payload-Mode", payloadMode);
+    c.header("X-OpenGeni-Forensic-Exact", String(mode === "forensic" && payloadMode === "full"));
+    const coveredFirst = page.events[0]?.sequence;
+    const coveredLast = page.events.at(-1)?.sequence;
+    if (coveredFirst !== void 0) c.header("X-OpenGeni-Covered-First", String(coveredFirst));
+    if (coveredLast !== void 0) c.header("X-OpenGeni-Covered-Last", String(coveredLast));
+    const truncatedBy = page.truncated ? "http_bytes" : dbPage.truncatedBy;
+    if (truncatedBy) c.header("X-OpenGeni-Truncated-By", truncatedBy);
+    if (page.nextSequence !== null) {
+      c.header(
+        direction === "before" ? "X-OpenGeni-Next-Before" : "X-OpenGeni-Next-After",
+        String(page.nextSequence)
+      );
+    }
+    return c.json(page.events);
   });
   app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/events/stream", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    await requireAccessGrant14(c, deps, workspaceId, "sessions:read");
+    const grant = await requireAccessGrant14(c, deps, workspaceId, "sessions:read");
     const sessionId = c.req.param("sessionId");
+    let authorization;
+    try {
+      authorization = await requireSessionAuthorization2(deps, grant, {
+        sessionId,
+        operation: "session.stream.read",
+        surface: "stream"
+      });
+    } catch (error) {
+      throw sessionAuthorizationHttpError(error);
+    }
     await assertSessionExists(db, workspaceId, sessionId);
     const after = Number(c.req.query("after") ?? c.req.header("Last-Event-ID") ?? 0);
     return sseSessionStream(
@@ -9403,7 +10786,20 @@ function registerSessionRoutes(app, deps) {
       workspaceId,
       sessionId,
       Number.isFinite(after) ? after : 0,
-      c.req.raw.signal
+      c.req.raw.signal,
+      {
+        observability: deps.observability,
+        ...authorization ? {
+          reauthorizeAfterMs: authorization.reauthorizeAfterMs ?? SESSION_AUTHORIZATION_DEFAULT_REAUTHORIZE_MS,
+          reauthorize: async () => {
+            await requireSessionAuthorization2(deps, grant, {
+              sessionId,
+              operation: "session.stream.read",
+              surface: "stream"
+            });
+          }
+        } : {}
+      }
     );
   });
   app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/turns", async (c) => {
@@ -9421,7 +10817,7 @@ function registerSessionRoutes(app, deps) {
     const sessionId = c.req.param("sessionId");
     const snapshot = await getSessionQueueSnapshot2(db, workspaceId, sessionId);
     if (!snapshot) throw new HTTPException21(404, { message: "session not found" });
-    return c.json(snapshot);
+    return c.json(projectQueueSnapshot(snapshot, sessionId, relatedSessionAccessFor(c)));
   });
   app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/queue/:turnId/move", async (c) => {
     const workspaceId = c.req.param("workspaceId");
@@ -9430,14 +10826,21 @@ function registerSessionRoutes(app, deps) {
     await assertSessionExists(db, workspaceId, sessionId);
     const payload = MoveSessionQueueItemRequest.parse(await c.req.json());
     try {
-      return c.json(
-        await moveHumanQueuePrompt(
-          { db, bus },
-          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
-          c.req.param("turnId"),
-          payload
-        )
+      const response = await moveHumanQueuePrompt(
+        deps,
+        {
+          accountId: grant.accountId,
+          workspaceId,
+          sessionId,
+          subjectId: grant.subjectId
+        },
+        c.req.param("turnId"),
+        payload
       );
+      return c.json({
+        ...response,
+        snapshot: projectQueueSnapshot(response.snapshot, sessionId, relatedSessionAccessFor(c))
+      });
     } catch (error) {
       return commandConflictResponse(c, error);
     }
@@ -9449,14 +10852,21 @@ function registerSessionRoutes(app, deps) {
     await assertSessionExists(db, workspaceId, sessionId);
     const payload = EditSessionQueueItemRequest.parse(await c.req.json());
     try {
-      return c.json(
-        await editHumanQueuePrompt(
-          { db, bus },
-          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
-          c.req.param("turnId"),
-          payload
-        )
+      const response = await editHumanQueuePrompt(
+        deps,
+        {
+          accountId: grant.accountId,
+          workspaceId,
+          sessionId,
+          subjectId: grant.subjectId
+        },
+        c.req.param("turnId"),
+        payload
       );
+      return c.json({
+        ...response,
+        snapshot: projectQueueSnapshot(response.snapshot, sessionId, relatedSessionAccessFor(c))
+      });
     } catch (error) {
       return commandConflictResponse(c, error);
     }
@@ -9468,14 +10878,21 @@ function registerSessionRoutes(app, deps) {
     await assertSessionExists(db, workspaceId, sessionId);
     const payload = SteerSessionQueueItemRequest.parse(await c.req.json());
     try {
-      return c.json(
-        await steerHumanQueuePrompt(
-          { db, bus },
-          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
-          c.req.param("turnId"),
-          payload
-        )
+      const response = await steerHumanQueuePrompt(
+        deps,
+        {
+          accountId: grant.accountId,
+          workspaceId,
+          sessionId,
+          subjectId: grant.subjectId
+        },
+        c.req.param("turnId"),
+        payload
       );
+      return c.json({
+        ...response,
+        snapshot: projectQueueSnapshot(response.snapshot, sessionId, relatedSessionAccessFor(c))
+      });
     } catch (error) {
       return commandConflictResponse(c, error);
     }
@@ -9487,14 +10904,21 @@ function registerSessionRoutes(app, deps) {
     await assertSessionExists(db, workspaceId, sessionId);
     const payload = DeleteSessionQueueItemRequest.parse(await c.req.json());
     try {
-      return c.json(
-        await deleteHumanQueuePrompt(
-          { db, bus },
-          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
-          c.req.param("turnId"),
-          payload
-        )
+      const response = await deleteHumanQueuePrompt(
+        deps,
+        {
+          accountId: grant.accountId,
+          workspaceId,
+          sessionId,
+          subjectId: grant.subjectId
+        },
+        c.req.param("turnId"),
+        payload
       );
+      return c.json({
+        ...response,
+        snapshot: projectQueueSnapshot(response.snapshot, sessionId, relatedSessionAccessFor(c))
+      });
     } catch (error) {
       return commandConflictResponse(c, error);
     }
@@ -9504,7 +10928,7 @@ function registerSessionRoutes(app, deps) {
     const grant = await requireAccessGrant14(c, deps, workspaceId, "sessions:read");
     const sessionId = c.req.param("sessionId");
     return c.json(
-      await getHumanComposerDraft(db, {
+      await getHumanComposerDraft(deps, {
         accountId: grant.accountId,
         workspaceId,
         sessionId,
@@ -9520,8 +10944,13 @@ function registerSessionRoutes(app, deps) {
     try {
       return c.json(
         await saveHumanComposerDraft(
-          db,
-          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
+          deps,
+          {
+            accountId: grant.accountId,
+            workspaceId,
+            sessionId,
+            subjectId: grant.subjectId
+          },
           payload
         )
       );
@@ -9532,16 +10961,33 @@ function registerSessionRoutes(app, deps) {
   app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/control", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant14(c, deps, workspaceId, "sessions:control");
+    if (workspaceControlUtf8Bytes(grant.subjectId) > WORKSPACE_CONTROL_ACTOR_MAX_BYTES) {
+      throw new HTTPException21(400, { message: "workspace-control actor is too large" });
+    }
     const sessionId = c.req.param("sessionId");
-    const payload = SessionControlRequest.parse(await c.req.json());
+    const parsed = SessionControlRequest.safeParse(await c.req.json().catch(() => null));
+    if (!parsed.success) {
+      throw new HTTPException21(400, { message: "invalid session control request" });
+    }
     try {
-      return c.json(
-        await controlHumanSessionWorkstream2(
-          { db, bus, workflowClient },
-          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
-          payload
-        )
+      const response = await controlHumanSessionWorkstream2(
+        deps,
+        {
+          accountId: grant.accountId,
+          workspaceId,
+          sessionId,
+          subjectId: grant.subjectId
+        },
+        parsed.data
       );
+      return c.json({
+        ...response,
+        effectiveControl: projectEffectiveControlForRelatedAccess2(
+          response.effectiveControl,
+          sessionId,
+          relatedSessionAccessFor(c)
+        )
+      });
     } catch (error) {
       return commandConflictResponse(c, error);
     }
@@ -9555,6 +11001,7 @@ function registerSessionRoutes(app, deps) {
     const payload = SteerSessionMessageRequest.parse(raw);
     const result = await acceptSessionUserMessage2(deps, grant, workspaceId, sessionId, {
       text: payload.text,
+      turnInstructions: payload.turnInstructions ?? null,
       resources: payload.resources,
       tools: payload.tools,
       toolsProvided: userMessagePayloadHasOwnProperty({ payload: raw }, "tools"),
@@ -9575,9 +11022,22 @@ function registerSessionRoutes(app, deps) {
     const sessionId = c.req.param("sessionId");
     const rawEvent = await c.req.json();
     const event = ClientSessionEvent.parse(rawEvent);
+    const refinedOperation = event.type === "user.approvalDecision" ? "session.approval.write" : event.type === "user.humanInputResponse" ? "session.human_input.write" : null;
+    if (refinedOperation) {
+      try {
+        await requireSessionAuthorization2(deps, grant, {
+          sessionId,
+          operation: refinedOperation,
+          surface: "http"
+        });
+      } catch (error) {
+        throw sessionAuthorizationHttpError(error);
+      }
+    }
     if (event.type === "user.message") {
       const { accepted } = await acceptSessionUserMessage2(deps, grant, workspaceId, sessionId, {
         text: event.payload.text,
+        turnInstructions: event.payload.turnInstructions ?? null,
         resources: event.payload.resources ?? [],
         tools: event.payload.tools ?? [],
         toolsProvided: userMessagePayloadHasOwnProperty(rawEvent, "tools"),
@@ -9615,7 +11075,79 @@ function registerSessionRoutes(app, deps) {
       });
       return c.json(accepted.event, 202);
     }
+    if (event.type === "user.humanInputResponse") {
+      let accepted;
+      try {
+        accepted = await acceptSessionHumanInputResponse(db, {
+          accountId: grant.accountId,
+          workspaceId,
+          sessionId,
+          requestId: event.payload.requestId,
+          response: event.payload.response,
+          respondedBy: grant.subjectId,
+          clientEventId: event.clientEventId ?? null
+        });
+      } catch (error) {
+        if (error instanceof HumanInputResponseValidationError) {
+          throw new HTTPException21(error.code === "SKIP_NOT_ALLOWED" ? 409 : 422, {
+            message: error.message
+          });
+        }
+        throw error;
+      }
+      if (accepted.action === "not_found") {
+        throw new HTTPException21(404, { message: "human-input request not found" });
+      }
+      await publishDurableSessionEvents(bus, workspaceId, sessionId, accepted.events);
+      if (accepted.workflowWakeRevision !== null) {
+        await workflowClient.signalApprovalDecision({
+          accountId: grant.accountId,
+          workspaceId,
+          sessionId,
+          eventId: accepted.events[0]?.id ?? event.payload.requestId,
+          workflowId: workflowIdForSession(sessionId),
+          workflowWakeRevision: accepted.workflowWakeRevision
+        });
+      }
+      if (accepted.action === "conflict") {
+        throw new HTTPException21(409, {
+          message: `human-input request is ${accepted.request.status}`
+        });
+      }
+      return c.json(accepted.event, 202);
+    }
+  });
+  app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/human-input-requests", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    await requireAccessGrant14(c, deps, workspaceId, "sessions:read");
+    const sessionId = c.req.param("sessionId");
+    await assertSessionExists(db, workspaceId, sessionId);
+    const rawStatus = c.req.query("status");
+    const status = rawStatus ? HumanInputRequestStatus.safeParse(rawStatus) : null;
+    if (status && !status.success) {
+      throw new HTTPException21(400, { message: "invalid human-input request status" });
+    }
+    const requests = await listSessionHumanInputRequests(db, workspaceId, sessionId, {
+      ...status?.success ? { status: status.data } : {}
+    });
+    return c.json({ requests });
   });
+  app.get(
+    "/v1/workspaces/:workspaceId/sessions/:sessionId/human-input-requests/:requestId",
+    async (c) => {
+      const workspaceId = c.req.param("workspaceId");
+      await requireAccessGrant14(c, deps, workspaceId, "sessions:read");
+      const sessionId = c.req.param("sessionId");
+      const request = await getSessionHumanInputRequest(
+        db,
+        workspaceId,
+        sessionId,
+        c.req.param("requestId")
+      );
+      if (!request) throw new HTTPException21(404, { message: "human-input request not found" });
+      return c.json(request);
+    }
+  );
   function assertOwnershipEnabled() {
     if (!settings.sandboxOwnershipEnabled) {
       throw new HTTPException21(404, {
@@ -9642,6 +11174,7 @@ function registerSessionRoutes(app, deps) {
       { workspaceId, sandboxGroupId: session.sandboxGroupId }
     );
     const { shared, sharedSessionIds } = await resolveSharedExposure(workspaceId, session);
+    const visibleSharedSessionIds = relatedSessionAccessFor(c) === "root" ? sharedSessionIds : [];
     const ack = await getStreamAcknowledgment(db, {
       workspaceId,
       sandboxGroupId: session.sandboxGroupId,
@@ -9696,13 +11229,13 @@ function registerSessionRoutes(app, deps) {
       // tracks the desktop tier + a desktop-capable backend.
       computerUseEnabled: settings.computerUseEnabled,
       computerUseReadOnly: settings.computerUseReadOnly,
-      // Graceful degrade (I8/OD-8): if desktop is enabled but no stream-token
+      // Graceful degrade (stream-token availability contract): if desktop is enabled but no stream-token
       // secret is resolvable, the desktop cell reports transport:null rather
       // than advertising a plane we can never authorize.
       streamTokenSecretAvailable: !streamTokenDegraded(settings),
       desktopAcknowledged: acknowledged,
       shared,
-      sharedSessionIds,
+      sharedSessionIds: visibleSharedSessionIds,
       // The minted live address (null when not unlocked/degraded). The resolver
       // only folds it in when the desktop gates pass + the ack is present.
       ...desktopStream ? {
@@ -9752,7 +11285,9 @@ function registerSessionRoutes(app, deps) {
       }
       const parsed = AcknowledgeStreamRequest.safeParse(await c.req.json().catch(() => ({})));
       if (!parsed.success) {
-        throw new HTTPException21(400, { message: "invalid stream acknowledgment request" });
+        throw new HTTPException21(400, {
+          message: "invalid stream acknowledgment request"
+        });
       }
       const recorded = await recordStreamAcknowledgment(db, {
         accountId: grant.accountId,
@@ -9779,7 +11314,9 @@ function registerSessionRoutes(app, deps) {
     }
     const parsed = AttachViewerRequest.safeParse(await c.req.json().catch(() => ({})));
     if (!parsed.success) {
-      throw new HTTPException21(400, { message: "invalid viewer attach request" });
+      throw new HTTPException21(400, {
+        message: "invalid viewer attach request"
+      });
     }
     const wantDesktop = parsed.data.desktop ?? false;
     const { shared } = await resolveSharedExposure(workspaceId, session);
@@ -9790,10 +11327,14 @@ function registerSessionRoutes(app, deps) {
         subjectId: grant.subjectId
       });
       if (!ack?.acknowledgedUnredacted) {
-        throw new HTTPException21(409, { message: "stream_acknowledgment_required" });
+        throw new HTTPException21(409, {
+          message: "stream_acknowledgment_required"
+        });
       }
       if (shared && !ack.acknowledgedShared) {
-        throw new HTTPException21(409, { message: "shared_acknowledgment_required" });
+        throw new HTTPException21(409, {
+          message: "shared_acknowledgment_required"
+        });
       }
     }
     const activeSandbox = session.activeSandboxId ? await getSandbox2(db, workspaceId, session.activeSandboxId) : null;
@@ -9916,7 +11457,9 @@ function registerSessionRoutes(app, deps) {
       }
       const parsed = ViewerHeartbeatRequest.safeParse(await c.req.json().catch(() => ({})));
       if (!parsed.success) {
-        throw new HTTPException21(400, { message: "viewer heartbeat requires { leaseEpoch }" });
+        throw new HTTPException21(400, {
+          message: "viewer heartbeat requires { leaseEpoch }"
+        });
       }
       const alive = await heartbeatViewer(
         { db, settings },
@@ -9969,7 +11512,10 @@ function registerSessionRoutes(app, deps) {
         viewerId: c.req.param("viewerId"),
         idleGraceMs: settings.sandboxIdleGraceMs
       });
-      return c.json({ liveness: result?.liveness ?? null, refcount: result?.refcount ?? null });
+      return c.json({
+        liveness: result?.liveness ?? null,
+        refcount: result?.refcount ?? null
+      });
     }
   );
   async function channelAPreamble(c, permission) {
@@ -9981,7 +11527,12 @@ function registerSessionRoutes(app, deps) {
     if (!session) {
       throw new HTTPException21(404, { message: "session not found" });
     }
-    return { accountId: grant.accountId, workspaceId, session, subjectId: grant.subjectId };
+    return {
+      accountId: grant.accountId,
+      workspaceId,
+      session,
+      subjectId: grant.subjectId
+    };
   }
   async function parseChannelABody(c, schema) {
     const raw = await c.req.json().catch(() => void 0);
@@ -10111,7 +11662,9 @@ function registerSessionRoutes(app, deps) {
     const sessionId = c.req.param("sessionId") ?? "";
     const path = c.req.query("path");
     if (!path) {
-      throw new HTTPException21(400, { message: "path query parameter is required" });
+      throw new HTTPException21(400, {
+        message: "path query parameter is required"
+      });
     }
     const session = await getSession4(db, workspaceId, sessionId);
     if (!session) {
@@ -10125,7 +11678,9 @@ function registerSessionRoutes(app, deps) {
     if (revisionParam !== void 0 && revisionParam !== "") {
       const revision = Number(revisionParam);
       if (!Number.isInteger(revision) || revision < 0) {
-        throw new HTTPException21(400, { message: "revision must be a non-negative integer" });
+        throw new HTTPException21(400, {
+          message: "revision must be a non-negative integer"
+        });
       }
       row = await workspaceCaptureAtRevision(db, workspaceId, sessionId, revision);
     } else {
@@ -10192,7 +11747,9 @@ function registerSessionRoutes(app, deps) {
       throw new HTTPException21(404, { message: "pty not found or closed" });
     }
     if (pty.execSessionId === null) {
-      throw new HTTPException21(409, { message: "interactive terminal unsupported on this backend" });
+      throw new HTTPException21(409, {
+        message: "interactive terminal unsupported on this backend"
+      });
     }
     let seq = 1;
     await withChannelA({ db, settings, bus }, ctx, async ({ service }) => {
@@ -10255,7 +11812,11 @@ function registerSessionRoutes(app, deps) {
         workspaceId: ctx.workspaceId,
         ptyId: req.ptyId
       });
-      const exited = { ptyId: req.ptyId, exitCode: 0, reason: "exit" };
+      const exited = {
+        ptyId: req.ptyId,
+        exitCode: 0,
+        reason: "exit"
+      };
       await appendAndPublishEvents5(db, bus, ctx.workspaceId, ctx.session.id, [
         { type: "terminal.pty.exited", payload: exited }
       ]);
@@ -10263,13 +11824,114 @@ function registerSessionRoutes(app, deps) {
     return c.body(null, 204);
   });
 }
-function eventListLimit(raw, max = 2e3) {
-  const limit = Number(raw ?? 500);
+function eventListLimit(raw, max = 2e3, fallback = 500) {
+  const limit = Number(raw ?? fallback);
   if (!Number.isFinite(limit)) {
-    return 500;
+    return fallback;
   }
   return Math.min(max, Math.max(1, Math.floor(limit)));
 }
+function sessionAuthorizationOperationForHttp(method, pathname, sessionId) {
+  const marker = `/sessions/${sessionId}`;
+  const markerAt = pathname.indexOf(marker);
+  if (markerAt < 0) return null;
+  const suffix = pathname.slice(markerAt + marker.length);
+  const verb = method.toUpperCase();
+  if (suffix === "") {
+    if (verb === "GET") return "session.read";
+    if (verb === "PATCH") return "session.title.write";
+    return null;
+  }
+  if (suffix === "/pin" && verb === "PUT") return "session.pin.write";
+  if (suffix === "/lineage" && verb === "GET") return "session.lineage.read";
+  if (suffix === "/codex-account" && verb === "POST") {
+    return "session.codex_account.write";
+  }
+  if (suffix === "/goal") {
+    return verb === "GET" ? "session.goal.read" : ["PATCH", "DELETE"].includes(verb) ? "session.goal.write" : null;
+  }
+  if (suffix === "/context/clear" || suffix === "/context/compact") {
+    return verb === "POST" ? "session.context.write" : null;
+  }
+  if (suffix === "/events/stream" && verb === "GET") return "session.stream.read";
+  if (suffix === "/events") {
+    if (verb === "GET") return "session.events.read";
+    if (verb === "POST") return "session.append";
+    return null;
+  }
+  if (suffix === "/turns" && verb === "GET") return "session.turns.read";
+  if (suffix === "/queue" && verb === "GET") return "session.queue.read";
+  if (suffix.startsWith("/queue/") && verb === "POST") return "session.queue.control";
+  if (suffix === "/composer-draft") {
+    if (verb === "GET") return "session.composer.read";
+    if (verb === "PUT") return "session.composer.write";
+    return null;
+  }
+  if (suffix === "/control" && verb === "POST") return "session.control";
+  if (suffix === "/steer" && verb === "POST") return "session.steer";
+  if (suffix === "/human-input-requests" && verb === "GET") {
+    return "session.human_input.read";
+  }
+  if (suffix.startsWith("/human-input-requests/") && verb === "GET") {
+    return "session.human_input.read";
+  }
+  if (suffix === "/stream-capabilities" && verb === "GET") return "session.viewer.read";
+  if (suffix === "/stream-capabilities/acknowledge" && verb === "POST") {
+    return "session.stream.acknowledge";
+  }
+  if (suffix === "/viewers" && verb === "POST") return "session.viewer.control";
+  if (suffix.startsWith("/viewers/") && ["POST", "DELETE"].includes(verb)) {
+    return "session.viewer.control";
+  }
+  if (suffix === "/fs/list" || suffix === "/fs/read") {
+    return verb === "POST" ? "session.files.read" : null;
+  }
+  if (["/fs/write", "/fs/delete", "/fs/move", "/fs/mkdir"].includes(suffix)) {
+    return verb === "POST" ? "session.files.write" : null;
+  }
+  if (suffix.startsWith("/git/") && verb === "POST") return "session.git.read";
+  if ((suffix === "/workspace/capture" || suffix === "/workspace/capture/file") && verb === "GET") {
+    return "session.capture.read";
+  }
+  if (suffix === "/terminal/exec" && verb === "POST") return "session.terminal.control";
+  if (suffix === "/terminal/pty" && verb === "POST") return "session.terminal.control";
+  if (suffix.startsWith("/terminal/pty/") && verb === "POST") {
+    return "session.terminal.control";
+  }
+  return null;
+}
+function sessionAuthorizationHttpError(error) {
+  if (error instanceof SessionAuthorizationDeniedError) {
+    return new HTTPException21(404, { message: "session not found" });
+  }
+  if (error instanceof SessionAuthorizationUnavailableError) {
+    return new HTTPException21(503, { message: "session authorization is unavailable" });
+  }
+  if (error instanceof HTTPException21) return error;
+  throw error;
+}
+function eventEnumValue(raw, schema, name, fallback) {
+  if (raw === void 0) return fallback;
+  const parsed = schema.safeParse(raw);
+  if (!parsed.success) {
+    throw new HTTPException21(400, { message: `${name} is invalid` });
+  }
+  return parsed.data;
+}
+function eventEnumList(raw, schema, name) {
+  if (raw === void 0 || raw.trim() === "") return [];
+  const values = raw.split(",").map((value) => value.trim()).filter(Boolean);
+  if (values.length > 100) {
+    throw new HTTPException21(400, { message: `${name} accepts at most 100 values` });
+  }
+  return values.map((value) => {
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+      throw new HTTPException21(400, { message: `${name} contains an invalid value` });
+    }
+    return parsed.data;
+  });
+}
 function sessionListQuery(query, allowCursor = true) {
   const parentSessionId = query.parentSessionId;
   if (parentSessionId !== void 0 && parentSessionId !== "null" && !z2.string().uuid().safeParse(parentSessionId).success) {
@@ -10284,7 +11946,9 @@ function sessionListQuery(query, allowCursor = true) {
   }
   const search = query.search?.trim();
   if (search && search.length > 200) {
-    throw new HTTPException21(400, { message: "search must be at most 200 characters" });
+    throw new HTTPException21(400, {
+      message: "search must be at most 200 characters"
+    });
   }
   return {
     limit: query.limit,
@@ -10467,9 +12131,11 @@ import {
   UpdateWorkspaceModelPolicyRequest,
   UpdateWorkspaceRequest,
   UpdateWorkspaceSettingsRequest,
+  WORKSPACE_CONTROL_ACTOR_MAX_BYTES as WORKSPACE_CONTROL_ACTOR_MAX_BYTES2,
   WorkspaceInferenceControlRequest,
   Workspace,
-  WorkspaceMember
+  WorkspaceMember,
+  workspaceControlUtf8Bytes as workspaceControlUtf8Bytes2
 } from "@opengeni/contracts";
 import {
   allWorkspacePermissions,
@@ -10492,6 +12158,7 @@ import {
   updateWorkspaceSettings,
   upsertWorkspaceModelPolicy
 } from "@opengeni/db";
+import { boundWorkspaceControlHttpPage } from "@opengeni/events";
 import { HTTPException as HTTPException23 } from "hono/http-exception";
 import { hasPermission as hasPermission3, requireAccessContext as requireAccessContext2, requireAccessGrant as requireAccessGrant16 } from "@opengeni/core";
 import { requireLimit as requireLimit7 } from "@opengeni/core";
@@ -10601,12 +12268,18 @@ function registerWorkspaceRoutes(app, deps) {
   app.post("/v1/workspaces/:workspaceId/inference-control", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant16(c, deps, workspaceId, "workspace:admin");
-    const payload = WorkspaceInferenceControlRequest.parse(await c.req.json());
+    if (workspaceControlUtf8Bytes2(grant.subjectId) > WORKSPACE_CONTROL_ACTOR_MAX_BYTES2) {
+      throw new HTTPException23(400, { message: "workspace-control actor is too large" });
+    }
+    const parsed = WorkspaceInferenceControlRequest.safeParse(await c.req.json().catch(() => null));
+    if (!parsed.success) {
+      throw new HTTPException23(400, { message: "invalid workspace inference-control request" });
+    }
     return c.json(
       await controlHumanWorkspace(
         { db: deps.db, bus: deps.bus, workflowClient: deps.workflowClient },
         { accountId: grant.accountId, workspaceId, subjectId: grant.subjectId },
-        payload
+        parsed.data
       )
     );
   });
@@ -10614,20 +12287,30 @@ function registerWorkspaceRoutes(app, deps) {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant16(c, deps, workspaceId, "workspace:read");
     const after = Math.max(0, Number.parseInt(c.req.query("after") ?? "0", 10) || 0);
-    return c.json(
-      await listWorkspaceControlEvents2(
-        deps.db,
-        workspaceId,
-        after,
-        boundedLimit(c.req.query("limit"))
-      )
-    );
+    const limit = boundedLimit(c.req.query("limit"));
+    const fetched = await listWorkspaceControlEvents2(deps.db, workspaceId, after, limit + 1);
+    const countHasMore = fetched.length > limit;
+    const page = boundWorkspaceControlHttpPage(fetched.slice(0, limit));
+    const truncated = countHasMore || page.truncated;
+    c.header("X-OpenGeni-Page-Bytes", String(page.bytes));
+    c.header("X-OpenGeni-Page-Truncated", String(truncated));
+    if (page.nextSequence !== null) {
+      c.header("X-OpenGeni-Next-After", String(page.nextSequence));
+    }
+    return c.json(page.events);
   });
   app.get("/v1/workspaces/:workspaceId/control-events/stream", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant16(c, deps, workspaceId, "workspace:read");
     const after = Math.max(0, Number.parseInt(c.req.query("after") ?? "0", 10) || 0);
-    return await sseWorkspaceControlStream(deps.db, deps.bus, workspaceId, after, c.req.raw.signal);
+    return await sseWorkspaceControlStream(
+      deps.db,
+      deps.bus,
+      workspaceId,
+      after,
+      c.req.raw.signal,
+      { observability: deps.observability }
+    );
   });
   app.put("/v1/workspaces/:workspaceId/default-rig", async (c) => {
     const workspaceId = c.req.param("workspaceId");
@@ -10743,6 +12426,7 @@ import {
   validateFileResources,
   validateGitHubRepositorySelection,
   validateGitHubRepositorySelectionShape,
+  validateGitHubRepositorySelectionShapes,
   validateToolRefs,
   withDefaultEnabledCapabilityMcpTools
 } from "@opengeni/core";
@@ -10788,8 +12472,10 @@ function createApp(deps) {
   };
   const sandboxClient = deps.sandboxClient ?? createApiSandboxClient(deps.settings);
   const resumeBoxById = deps.resumeBoxById ?? makeResumeBoxById(sandboxClient);
+  const observability = deps.observability ?? createObservability(deps.settings, { component: "api" });
   const routeDeps = {
     ...deps,
+    observability,
     githubStateSecret: deps.githubStateSecret ?? deps.settings.githubAppManifestStateSecret ?? crypto.randomUUID(),
     managedAuth,
     objectStorage,
@@ -10799,7 +12485,6 @@ function createApp(deps) {
     resumeBoxById
   };
   const app = new Hono();
-  const observability = deps.observability ?? createObservability(deps.settings, { component: "api" });
   app.use(
     "*",
     cors({
@@ -10970,7 +12655,29 @@ function createApp(deps) {
   app.all("/v1/workspaces/:workspaceId/mcp", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireMcpAccessGrant(c, routeDeps, workspaceId);
-    const toolspace = isToolspaceGrant(routeDeps.settings, grant) ? await prepareToolspaceMcpSurface({ deps: routeDeps, grant }) : null;
+    const toolspaceGrant = isToolspaceGrant(routeDeps.settings, grant);
+    const boundSessionId = grant.metadata?.sessionId;
+    if (toolspaceGrant || typeof boundSessionId === "string") {
+      if (typeof boundSessionId !== "string") {
+        throw new HTTPException24(404, { message: "session not found" });
+      }
+      try {
+        await requireSessionAuthorization3(routeDeps, grant, {
+          sessionId: boundSessionId,
+          operation: toolspaceGrant ? "session.toolspace.call" : "session.first_party_mcp.call",
+          surface: toolspaceGrant ? "toolspace" : "first_party_mcp"
+        });
+      } catch (error) {
+        if (error instanceof SessionAuthorizationDeniedError2) {
+          throw new HTTPException24(404, { message: "session not found" });
+        }
+        if (error instanceof SessionAuthorizationUnavailableError2) {
+          throw new HTTPException24(503, { message: "session authorization is unavailable" });
+        }
+        throw error;
+      }
+    }
+    const toolspace = toolspaceGrant ? await prepareToolspaceMcpSurface({ deps: routeDeps, grant }) : null;
     const workspace = await getWorkspace2(routeDeps.db, workspaceId);
     const workspaceMemoryEnabled = resolveWorkspaceMemoryEnabled(workspace?.settings);
     const transport = new WebStandardStreamableHTTPServerTransport2({
@@ -11319,6 +13026,18 @@ var routeLabelPatterns = [
     pattern: /^\/v1\/workspaces\/[^/]+\/github\/repositories\/sync$/,
     label: "/v1/workspaces/:workspaceId/github/repositories/sync"
   },
+  {
+    pattern: /^\/v1\/workspaces\/[^/]+\/github\/connect$/,
+    label: "/v1/workspaces/:workspaceId/github/connect"
+  },
+  {
+    pattern: /^\/v1\/workspaces\/[^/]+\/github\/installations$/,
+    label: "/v1/workspaces/:workspaceId/github/installations"
+  },
+  {
+    pattern: /^\/v1\/workspaces\/[^/]+\/github\/installations\/[^/]+$/,
+    label: "/v1/workspaces/:workspaceId/github/installations/:installationId"
+  },
   {
     pattern: /^\/v1\/workspaces\/[^/]+\/github\/app-manifest$/,
     label: "/v1/workspaces/:workspaceId/github/app-manifest"
@@ -11478,8 +13197,9 @@ export {
   validateFileResources,
   validateGitHubRepositorySelection,
   validateGitHubRepositorySelectionShape,
+  validateGitHubRepositorySelectionShapes,
   validateToolRefs,
   withDefaultEnabledCapabilityMcpTools,
   workflowIdForSession2 as workflowIdForSession
 };
-//# sourceMappingURL=chunk-HBEJMWD3.js.map
+//# sourceMappingURL=chunk-EYYTFA7N.js.map