@opengeni/api-router 3.0.1 → 3.1.2

package/src/routes/sessions.ts

@@ -1,7 +1,66 @@
+import {
+  legacyVariableSetFields,
+  rejectLegacyVariableSetFields,
+  variableSetsRemovedResponse,
+  withoutEmptyLegacyVariableSetFields,
+} from "../http/variable-sets-removed";
+import { AZURE_LIVE_MODEL_ID, buildSessionAzureLiveBroker } from "../azure-live";
 import { getRetainedProviderCommand } from "@opengeni/db/retained-provider-commands";
-import { scheduledSessionIds } from "@opengeni/db";
-import { withSiteSessionOrigin } from "@opengeni/core";
-import { resolveSiteSessionOrigin } from "../site-session-origin";
+import { assertGoalResumeAllowed, GoalResumeBlockedError } from "@opengeni/core";
+import {
+  agentConfigDeploymentPolicy,
+  resolveFirstPartyMcpToolPolicy,
+  UnsupportedLatencyModeError,
+} from "@opengeni/config";
+import { siteAgentDataToolNames, siteAgentSiteSqlOn } from "../site-publishing/agent-data-tools";
+import { searchSessionMessagesForSubject, SessionMessageSearchCursorError } from "@opengeni/db";
+import { isVaultError, vaultErrorFromDatabase } from "@opengeni/db";
+import { listSessionEventSlices } from "@opengeni/db/session-event-slices";
+import * as sessionPreviewSchema from "@opengeni/db/schema";
+import { and, eq, sql } from "drizzle-orm";
+import {
+  FIRST_PARTY_MCP_TOOL_CAPABILITIES,
+  FirstPartyMcpToolName,
+  resolveWorkspaceAgentDefaults,
+  SessionMessageSearchRequest,
+  type AgentCapabilities,
+  type ToolRef,
+} from "@opengeni/contracts";
+import {
+  SITE_FRAME_SESSION_CREATE_FIELDS,
+  siteFrameBodyRefusal,
+} from "@opengeni/contracts/site-session-http";
+import { requireWorkspace, scheduledSessionIds } from "@opengeni/db";
+import {
+  currentSiteSessionOrigin,
+  isVerifiedDelegatedHumanAuthorization,
+  withSiteSessionOrigin,
+} from "@opengeni/core";
+import { freezeSessionRealtimeConnectionAccounts } from "@opengeni/core";
+import {
+  createRealtimeVoiceBilling,
+  RealtimeVoiceUnavailableError,
+  TranscriptionBillingRefusedError,
+} from "@opengeni/core";
+import type { CreditDebitAttribution, SessionForkPointRefusal } from "@opengeni/db";
+import { creditDebitAttributionForGrant } from "../access-grant-rls";
+import { transcriptionBillingRefusal } from "../transcription/billing-refusal";
+import { resolveSiteSessionOrigin, withOptionalSiteCommandOrigin } from "../site-session-origin";
+import { SandboxRecoveryRequest } from "@opengeni/contracts";
+import { getManagedHumanSandboxRecovery, consentManagedHumanSandboxRecovery } from "@opengeni/core";
+import { SandboxRecoveryConflictError } from "@opengeni/db";
+import { codexAccountJson } from "./codex";
+import {
+  deliverSubscriptionCoreCodexWake,
+  getSubscriptionCoreSessionCodexAccounts,
+  pinSubscriptionCoreSessionCodexAccount,
+} from "@opengeni/db";
+import { codexRouteDisposition } from "./codex-core";
+import {
+  loadCodexSessionPointerProjection,
+  type CodexSessionPointerProjection,
+} from "../codex-session-pointers";
+import { getToolActionReview, getToolReviewDetailsPage } from "@opengeni/db";
 import {
   AcknowledgeStreamRequest,
   ApplySessionGoalRevisionRequest,
@@ -43,6 +102,7 @@ import {
   RenewSessionRealtimeRequest,
   SyncSessionRealtimeLedgerRequest,
   SessionControlRequest,
+  SessionRetryRequest,
   SESSION_EVENT_RAW_DELTA_TYPES,
   SessionEventPayloadMode,
   SessionEventReadDirection,
@@ -64,13 +124,18 @@ import {
   UpdateSessionChannelRequest,
   UpdateSessionAttentionRequest,
   UpdateSessionArchiveRequest,
+  UpdateSessionRetentionRequest,
+  SetSessionUsageLimitRequest,
   UpdateSessionPinRequest,
   UpdateSessionGoalRequest,
   UpdateSessionMcpApprovalPolicyRequest,
   UpdateSessionRequest,
-  UpdateSessionVariableSetsRequest,
   UpdateSessionVisibilityRequest,
+  SessionVisibility,
   UpdateSessionToolPolicyRequest,
+  UpdateSessionAgentRequest,
+  UpdateSessionSkillsRequest,
+  AgentConfigError,
   ViewerHeartbeatRequest,
   WORKSPACE_CONTROL_ACTOR_MAX_BYTES,
   WORK_CLAIM_CANONICAL_KEY_MAX_BYTES,
@@ -98,7 +163,8 @@ import {
   type TerminalPtyExitedPayload,
   type TerminalPtyOutputDeltaPayload,
   type TerminalPtyStartedPayload,
-  type VariableSet,
+  type VaultApiError,
+  VAULT_ERROR_HTTP_STATUS,
 } from "@opengeni/contracts";
 import { streamTokenDegraded } from "@opengeni/config";
 import {
@@ -112,6 +178,7 @@ import {
   getLiveEnrollmentConnection,
   getRetainedProcess,
   getSandbox,
+  getPublishedSiteVersion,
   getSession,
   readActiveSandbox,
   deleteSessionTreeIfQuiescent,
@@ -131,18 +198,18 @@ import {
   listSessionGoalRevisions,
   rejectSessionGoalRevisionWithEvent,
   listSessionIdsInGroup,
+  countAllSessionsInGroup,
   listSessionDiscoverySummaries,
   listSessionDiscoveryAncestorPaths,
   listSessionsForSubject,
+  listSessionEntriesForSubject,
   getLatestStartedSessionTurn,
   listSessionTurns,
   projectEffectiveControlForRelatedAccess,
   projectSessionForRelatedAccess,
   recordStreamAcknowledgment,
   requestSessionCompaction,
-  switchSessionCodexAccount,
   setSessionChannel,
-  updateSessionVariableSets,
   ChannelNotFoundError,
   setSessionAttention,
   setSessionArchive,
@@ -160,6 +227,7 @@ import {
   upsertSessionGoalWithEvent,
   updatePtySessionActivity,
   QueueCommandConflictError,
+  PersonalSessionInitiatorRequiredError,
   beginSessionRealtimeInTransaction,
   activateSessionRealtimeConnectionInTransaction,
   claimSessionRealtimeConnectionInTransaction,
@@ -173,17 +241,20 @@ import {
   SessionToolPolicyVersionConflictError,
   SessionContextBusyError,
   SessionVariableSetSelectionUnavailableError,
+  SessionCreateConnectionSelectionUnavailableError,
   workspaceControlRequestLockTimeoutMs,
   SessionTenancyAccessError,
   SessionTenancyConflictError,
   SessionTenancyInvalidRequestError,
   SessionTenancyNotActivatedError,
+  SessionVisibilityWorkConflictError,
   HumanInputResponseValidationError,
   SkillHumanResponseError,
   latestWorkspaceCapture,
   sessionLatestWorkspaceCapture,
   renewSessionRealtimeInTransaction,
   syncSessionRealtimeLedgerInTransaction,
+  setSessionKeepLive,
   withWorkspaceSessionActivityRls,
   withWorkspaceRls,
   workspaceCaptureAtRevision,
@@ -257,6 +328,7 @@ import {
   type ResolvedSessionAuthorization,
 } from "@opengeni/core";
 import type { ApiRouteDeps } from "@opengeni/core";
+import { SessionRetryConflictError } from "@opengeni/db";
 import {
   attachViewer,
   detachViewer,
@@ -273,7 +345,9 @@ import {
 import { buildSessionCodexRealtimeBroker, CodexRealtimeBrokerError } from "../codex-realtime";
 import {
   acceptSessionUserMessage,
+  validateSessionMcpCredentialUpdates,
   controlHumanSessionWorkstream,
+  retryFailedSession,
   createSessionForRequest,
   deleteHumanQueuePrompt,
   editHumanQueuePrompt,
@@ -291,16 +365,29 @@ import {
   submitComposerDraftForRequest,
   updateSessionMcpApprovalPolicy,
   updateManagedHumanSessionVisibility,
+  previewManagedHumanSessionVisibilityChange,
   updateSessionToolPolicy,
+  updateSessionAgent,
+  updateSessionSkills,
   updateSessionTitle,
+  setSessionRetention,
   workflowIdForSession,
   sessionWithEffectiveToolPolicy,
-  workspaceSessionToolPolicyDefaultServerIds,
-  workspaceSessionToolPolicyServerIds,
+  workspaceSessionEffectiveToolsContext,
+  workspaceSessionToolPolicyContext,
   relayConfigFromSettings,
-  validateVariableSetAttachment,
+  getSessionUsageLimitForAccess,
+  SessionUsageLimitHttpError,
+  sessionUsageLimitForRead,
+  setSessionUsageLimitForAccess,
 } from "@opengeni/core";
 import { assertSessionExists, boundedLimit } from "../http/common";
+import { isAgentActingAsPerson } from "../http/acting-person";
+import {
+  humanSecretWriteContext,
+  prepareSecretAnswers,
+  splitSecretAnswers,
+} from "../secret-answers";
 import { browserSseDeliveryOptions, sseSessionStream } from "../http/sse";
 import {
   serveWorkspaceCapture,
@@ -310,6 +397,9 @@ import {
 import { publishSandboxFileArtifact } from "../sandbox-file-artifacts";
 import { ApiHttpError } from "../http/api-error";
 import { observeWorkDiscovery, summarizeWorkDiscoveryRows } from "../work-discovery-observability";
+import { recordAcceptedApiAdmission } from "../admission-trace";
+import { parseRequestBody, parseRequestJson } from "../http/request-body";
+import { measureSessionCreatePhase } from "../session-create-observability";
 
 type SessionRouteDeps = ApiRouteDeps & Pick<ViewerServices, "establishSandboxSession">;
 
@@ -350,6 +440,66 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     observability: deps.observability,
   };
   const workspaceCaptureManifestCache = new WorkspaceCaptureManifestCache();
+  const realtimeVoiceBilling = createRealtimeVoiceBilling({ db, settings });
+  /** Credit refusal / unavailable deployment voice as an HTTP response, else null. */
+  const realtimeVoiceRefusalResponse = (c: Context, error: unknown): Response | null => {
+    if (error instanceof TranscriptionBillingRefusedError) {
+      return transcriptionBillingRefusal(c, error);
+    }
+    if (error instanceof RealtimeVoiceUnavailableError) {
+      return c.json(
+        {
+          error: {
+            status: 409,
+            code: "realtime_voice_unavailable",
+            message: error.message,
+            retryable: false,
+            details: { reason: error.code },
+          },
+        },
+        409,
+      );
+    }
+    return null;
+  };
+  /**
+   * Bill every started minute observed so far for a deployment-funded call.
+   * Owner attribution only when the caller is the voice owner. A settlement
+   * failure is logged and retried idempotently on the next heartbeat.
+   */
+  const settleRealtimeVoice = async (input: {
+    grant: { subjectId: string };
+    attribution: CreditDebitAttribution;
+    workspaceId: string;
+    sessionId: string;
+    realtimeId: string;
+  }) => {
+    try {
+      return await realtimeVoiceBilling.settle({
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        realtimeId: input.realtimeId,
+        callerSubjectId: input.grant.subjectId,
+        attribution: input.attribution,
+      });
+    } catch (error) {
+      console.error("realtime voice settlement failed", {
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        realtimeId: input.realtimeId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return null;
+    }
+  };
+  const withSiteCommandOrigin = <T>(c: Context, grant: AccessGrant, run: () => Promise<T>) =>
+    withOptionalSiteCommandOrigin(
+      db,
+      grant,
+      c.req.header("x-opengeni-site-id"),
+      c.req.header("x-opengeni-site-version"),
+      run,
+    );
   const ptyIdentity = (pty: SandboxOpenPtySessionRow): SandboxPtyProcessIdentity => ({
     leaseId: pty.leaseId,
     sandboxGroupId: pty.sandboxGroupId,
@@ -477,7 +627,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
   });
 
   // Every deployment has one fail-closed authorization seam for every HTTP
-  // session surface. The core boundary always enforces durable OpenGeni-owned
+  // session surface. The core boundary always enforces durable Opengeni-owned
   // private-session rules; an embedding host port can add narrower policy.
   // Register it before the routes so a newly added path cannot accidentally
   // inherit workspace access without an explicit operation classification. The
@@ -557,16 +707,15 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
 
   app.post("/v1/workspaces/:workspaceId/sessions", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const authorization = await requireAccessGrantAuthorization(
-      c,
-      deps,
-      workspaceId,
-      "sessions:create",
+    const authorization = await measureSessionCreatePhase(deps.observability, "authorization", () =>
+      requireAccessGrantAuthorization(c, deps, workspaceId, "sessions:create"),
     );
     const grant = authorization.grant;
     let payload: unknown;
     try {
-      payload = await c.req.json();
+      payload = await measureSessionCreatePhase(deps.observability, "body_read", () =>
+        c.req.json(),
+      );
     } catch {
       return c.json(
         {
@@ -578,23 +727,93 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     }
     let session: Session;
     try {
+      const legacyFields = legacyVariableSetFields(payload);
+      if (legacyFields.length > 0) return variableSetsRemovedResponse(c, 422, legacyFields);
+      payload = withoutEmptyLegacyVariableSetFields(payload);
       CreateSessionRequest.parse(payload);
-      const origin = await resolveSiteSessionOrigin(
-        db,
-        workspaceId,
-        c.req.header("x-opengeni-site-id"),
-        c.req.header("x-opengeni-site-version"),
+      // only a person present in the app or the host's server sets a
+      // task usage limit; an agent acting for a person cannot, even null.
+      if (
+        (payload as { usageLimitMicros?: unknown }).usageLimitMicros !== undefined &&
+        isAgentActingAsPerson(c)
+      ) {
+        throw new SessionUsageLimitHttpError(
+          403,
+          "session_usage_limit_forbidden",
+          "Only a person or the application's server can set a task usage limit.",
+        );
+      }
+      const origin = await measureSessionCreatePhase(deps.observability, "site_origin", () =>
+        resolveSiteSessionOrigin(
+          db,
+          grant,
+          c.req.header("x-opengeni-site-id"),
+          c.req.header("x-opengeni-site-version"),
+          // A frame without a published Site (inline HTML, a preview) is
+          // recorded as that frame, so its later requests reach this session.
+          {
+            marker: c.req.header("x-opengeni-site-frame"),
+            frameId: c.req.header("x-opengeni-site-frame-id"),
+          },
+        ),
       );
+      // A Site page may start a conversation with a message and a model, and
+      // nothing else: the session gets the minimal Site profile. Only the Site
+      // itself, running its published agent as `site:<siteId>`, chooses tools.
+      const siteOrigin = origin ?? currentSiteSessionOrigin();
+      if (siteOrigin && grant.subjectId !== `site:${siteOrigin.siteId}`) {
+        const refused = siteFrameBodyRefusal("sessions.create", "/sessions", payload);
+        if (refused)
+          return c.json(
+            {
+              code: "SITE_SESSION_TOOLS_FORBIDDEN",
+              message:
+                "A Site page can start a session with a message and a model only, not choose its tools, servers, connections, permissions, vaults, sandbox, resources, Skills or learning",
+              details: { code: "site_frame_field_forbidden", field: refused },
+            },
+            403,
+          );
+        payload = await siteFrameSessionProfile(deps, workspaceId, payload, {
+          accountId: grant.accountId,
+          siteId: siteOrigin.siteId,
+          versionId: siteOrigin.versionId ?? null,
+        });
+      }
       const create = () =>
         createSessionForRequest(deps, grant, workspaceId, payload, authorization);
-      session = await (origin ? withSiteSessionOrigin(origin, create) : create());
+      session = await measureSessionCreatePhase(deps.observability, "core_create", () =>
+        origin ? withSiteSessionOrigin(origin, create) : create(),
+      );
     } catch (error) {
       return sessionCreateErrorResponse(c, error);
     }
+    // A creator may exempt its new session from the idle-session archive (a
+    // persistent agent, for example). Creation committed; this only marks it.
+    if ((payload as { keepLive?: unknown }).keepLive === true) {
+      const kept = await setSessionKeepLive(db, {
+        workspaceId,
+        sessionId: session.id,
+        keepLive: true,
+      });
+      if (kept.status === "updated") session = { ...session, retention: kept.retention };
+    }
+    // Echo a requested usage limit so clients can tell this server applied it
+    // (older servers strip the unknown field and would run unlimited).
+    if ((payload as { usageLimitMicros?: unknown }).usageLimitMicros !== undefined) {
+      const usageLimit = await sessionUsageLimitForRead(db, session, {
+        subjectId: grant.subjectId,
+      });
+      if (usageLimit) session = { ...session, usageLimit };
+    }
     // Creation has committed by this point. Keep response projection outside
     // the create-rejection boundary so a post-commit policy read cannot be
     // misreported as though the session itself was rejected.
-    return c.json(await withEffectivePolicy(deps, workspaceId, grant.subjectId, session), 202);
+    return c.json(
+      await measureSessionCreatePhase(deps.observability, "response_projection", () =>
+        withEffectivePolicy(deps, workspaceId, grant.subjectId, session),
+      ),
+      202,
+    );
   });
 
   app.get("/v1/workspaces/:workspaceId/new-session-draft", async (c) => {
@@ -681,6 +900,59 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     }
   });
 
+  app.get("/v1/workspaces/:workspaceId/session-message-search", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const authorization = await requireAccessGrantAuthorization(
+      c,
+      deps,
+      workspaceId,
+      "sessions:read",
+    );
+    const grant = authorization.grant;
+    // A single-session filter is not authority: both searches use the complete
+    // live host/agent list scope, plus ordinary private/archive/RLS boundaries.
+    let authorizationScope;
+    try {
+      authorizationScope = await requireSessionAuthorizationListScope(deps, grant, "http");
+    } catch (error) {
+      throw sessionAuthorizationHttpError(error);
+    }
+    const raw = c.req.query();
+    const parsed = SessionMessageSearchRequest.safeParse({
+      ...raw,
+      ...(raw.limit !== undefined ? { limit: Number(raw.limit) } : {}),
+    });
+    if (!parsed.success)
+      throw new HTTPException(400, { message: "Invalid session message search request" });
+    try {
+      return c.json(
+        await searchSessionMessagesForSubject(
+          db,
+          workspaceId,
+          parsed.data,
+          {
+            subjectId: grant.subjectId,
+            ...(authorizationScope ? { authorizationScope } : {}),
+            personalWorkspaceOwnerException: hasVerifiedOwningUserAuthorization(authorization),
+          },
+          { signal: c.req.raw.signal },
+        ),
+      );
+    } catch (error) {
+      if (error instanceof SessionListAccessError)
+        throw new HTTPException(403, { message: error.message });
+      if (error instanceof SessionMessageSearchCursorError)
+        throw new HTTPException(400, { message: error.message });
+      // Clients are told to cancel superseded searches, so an abort here is a
+      // routine client disconnect, never a server failure. Match the existing
+      // client-gone convention (mcp/request-abort.ts): 499 with an empty body,
+      // which a departed client never reads and monitors never count as 5xx.
+      if (c.req.raw.signal.aborted || (error instanceof Error && error.name === "AbortError"))
+        return new Response(null, { status: 499 });
+      throw error;
+    }
+  });
+
   app.get("/v1/workspaces/:workspaceId/sessions", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const authorization = await requireAccessGrantAuthorization(
@@ -698,31 +970,51 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     }
     const pageView = c.req.query("view") === "page";
     const query = sessionListQuery(c.req.query(), pageView);
-    let page: Awaited<ReturnType<typeof listSessionsForSubject>>;
+    const projection = c.req.query("projection");
+    if (projection !== undefined && projection !== "summary")
+      throw new HTTPException(400, { message: 'projection must be "summary"' });
+    if (projection && !pageView)
+      throw new HTTPException(400, { message: 'summary projection requires view="page"' });
+    const summary = projection === "summary";
+    let page: Awaited<
+      ReturnType<typeof listSessionsForSubject | typeof listSessionEntriesForSubject>
+    >;
     try {
-      page = await listSessionsForSubject(db, workspaceId, {
-        subjectId: grant.subjectId,
-        limit: boundedLimit(query.limit),
-        materializeSnapshot: pageView,
-        ...(query.cursor ? { cursor: query.cursor } : {}),
-        ...(query.search ? { search: query.search } : {}),
-        ...(query.pinsOnly ? { pinsOnly: true } : {}),
-        ...(query.archivedOnly ? { archivedOnly: true } : {}),
-        ...(query.parentSessionId !== undefined ? { parentSessionId: query.parentSessionId } : {}),
-        ...(query.channelId !== undefined ? { channelId: query.channelId } : {}),
-        ...(query.originSiteId ? { originSiteId: query.originSiteId } : {}),
-        ...(query.createdBy ? { createdBy: query.createdBy } : {}),
-        ...(query.updatedFrom ? { updatedFrom: query.updatedFrom } : {}),
-        ...(query.updatedBefore ? { updatedBefore: query.updatedBefore } : {}),
-        ...(query.createdFrom ? { createdFrom: query.createdFrom } : {}),
-        ...(query.createdBefore ? { createdBefore: query.createdBefore } : {}),
-        ...(query.scopeSubjectId ? { scopeSubjectId: query.scopeSubjectId } : {}),
-        ...(authorizationScope ? { authorizationScope } : {}),
-        // A managed human's own personal workspace has no membership row, so
-        // the list's removal fence must fall back to the organization-membership
-        // pointer, only with verified native or external owning-user provenance.
-        personalWorkspaceOwnerException: hasVerifiedOwningUserAuthorization(authorization),
-      });
+      page = await (summary ? listSessionEntriesForSubject : listSessionsForSubject)(
+        db,
+        workspaceId,
+        {
+          subjectId: grant.subjectId,
+          limit: boundedLimit(query.limit),
+          materializeSnapshot: pageView,
+          ...(query.cursor ? { cursor: query.cursor } : {}),
+          ...(query.search ? { search: query.search } : {}),
+          ...(query.pinsOnly ? { pinsOnly: true } : {}),
+          ...(query.includeTotals ? { includeTotals: true } : {}),
+          ...(query.needsYouOnly ? { needsYouOnly: true } : {}),
+          ...(query.contentArchivedOnly ? { contentArchivedOnly: true } : {}),
+          ...(query.includePinned === false ? { includePinned: false } : {}),
+          ...(query.archivedOnly ? { archivedOnly: true } : {}),
+          ...(query.sortBy ? { sortBy: query.sortBy } : {}),
+          ...(query.archiveStatus ? { archiveStatus: query.archiveStatus } : {}),
+          ...(query.parentSessionId !== undefined
+            ? { parentSessionId: query.parentSessionId }
+            : {}),
+          ...(query.channelId !== undefined ? { channelId: query.channelId } : {}),
+          ...(query.originSiteId ? { originSiteId: query.originSiteId } : {}),
+          ...(query.createdBy ? { createdBy: query.createdBy } : {}),
+          ...(query.updatedFrom ? { updatedFrom: query.updatedFrom } : {}),
+          ...(query.updatedBefore ? { updatedBefore: query.updatedBefore } : {}),
+          ...(query.createdFrom ? { createdFrom: query.createdFrom } : {}),
+          ...(query.createdBefore ? { createdBefore: query.createdBefore } : {}),
+          ...(query.scopeSubjectId ? { scopeSubjectId: query.scopeSubjectId } : {}),
+          ...(authorizationScope ? { authorizationScope } : {}),
+          // A managed human's own personal workspace has no membership row, so
+          // the list's removal fence must fall back to the organization-membership
+          // pointer, only with verified native or external owning-user provenance.
+          personalWorkspaceOwnerException: hasVerifiedOwningUserAuthorization(authorization),
+        },
+      );
     } catch (error) {
       if (error instanceof SessionListAccessError) {
         throw new HTTPException(403, { message: error.message });
@@ -743,7 +1035,6 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     // body for older clients while still making its older-pin omission visible
     // to raw HTTP consumers without changing that response shape.
     c.header("x-opengeni-pinned-truncated", page.pinnedTruncated === true ? "true" : "false");
-    const policy = await loadEffectivePolicyContext(deps, workspaceId, grant.subjectId);
     const commandActivity = await backgroundCommandActivityForSessions(db, {
       accountId: grant.accountId,
       workspaceId,
@@ -758,17 +1049,34 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
             [...page.pinned, ...page.sessions].map((session) => session.id),
           )
         : new Set<string>();
+    if ("projection" in page) {
+      const decorateEntry = (session: (typeof page.sessions)[number]) => ({
+        ...session,
+        hasSchedules: scheduleTargets.has(session.id),
+        ...(commandActivity.has(session.id)
+          ? { backgroundCommandActivity: commandActivity.get(session.id)! }
+          : {}),
+      });
+      return c.json({
+        ...page,
+        ...(query.hasPageFilters ? { filtersApplied: true as const } : {}),
+        ...(query.originSiteId ? { originSiteId: query.originSiteId } : {}),
+        pinned: page.pinned.map(decorateEntry),
+        sessions: page.sessions.map(decorateEntry),
+      });
+    }
+    const policy = await loadEffectivePolicyContext(deps, workspaceId, grant.subjectId, [
+      ...page.pinned,
+      ...page.sessions,
+    ]);
     const decorate = (session: Session): Session => {
       const activity = commandActivity.get(session.id);
-      return sessionWithEffectiveToolPolicy(
-        {
-          ...session,
-          hasSchedules: scheduleTargets.has(session.id),
-          ...(activity ? { backgroundCommandActivity: activity } : {}),
-        },
-        policy.workspaceServerIds,
-        policy.workspaceDefaultServerIds,
-      );
+      const decorated = {
+        ...session,
+        hasSchedules: scheduleTargets.has(session.id),
+        ...(activity ? { backgroundCommandActivity: activity } : {}),
+      };
+      return sessionResponse(decorated, policy);
     };
     if (pageView) {
       return c.json({
@@ -937,6 +1245,48 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     }
   });
 
+  app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/tool-reviews/:approvalId", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:read");
+    const input = {
+      accountId: grant.accountId,
+      workspaceId,
+      sessionId: c.req.param("sessionId"),
+      approvalId: c.req.param("approvalId"),
+    };
+    const review = await getToolActionReview(db, input);
+    if (!review) throw new HTTPException(404, { message: "Review not found" });
+    c.header("Cache-Control", "private, no-store");
+    return c.json(review);
+  });
+
+  app.get(
+    "/v1/workspaces/:workspaceId/sessions/:sessionId/tool-reviews/:approvalId/details",
+    async (c) => {
+      const workspaceId = c.req.param("workspaceId");
+      const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:read");
+      const query = z
+        .object({
+          actionDigest: z.string().regex(/^[0-9a-f]{64}$/),
+          path: z.string().max(2048).default(""),
+          offset: z.coerce.number().int().min(0).max(4_194_304).default(0),
+        })
+        .safeParse(c.req.query());
+      if (!query.success) throw new HTTPException(400, { message: "Invalid review page" });
+      const input = {
+        accountId: grant.accountId,
+        workspaceId,
+        sessionId: c.req.param("sessionId"),
+        approvalId: c.req.param("approvalId"),
+        ...query.data,
+      };
+      const page = await getToolReviewDetailsPage(db, input);
+      if (!page) throw new HTTPException(404, { message: "Review details unavailable" });
+      c.header("Cache-Control", "private, no-store");
+      return c.json(page);
+    },
+  );
+
   app.get("/v1/workspaces/:workspaceId/sessions/:sessionId", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:read");
@@ -954,22 +1304,38 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     if (!session) {
       throw new HTTPException(404, { message: "session not found" });
     }
-    const activity = await backgroundCommandActivityForSessions(db, {
-      accountId: grant.accountId,
-      workspaceId,
-      sessionIds: [sessionId],
-    });
-    const scheduleTargets =
+    // Independent reads of the already-authorized session: the effective
+    // policy context depends only on the session row, not on the activity or
+    // schedule annotations, so all three are read concurrently.
+    const [activity, scheduleTargets, policy] = await Promise.all([
+      backgroundCommandActivityForSessions(db, {
+        accountId: grant.accountId,
+        workspaceId,
+        sessionIds: [sessionId],
+      }),
       hasPermission(grant.permissions, "scheduled_tasks:run") &&
       hasPermission(grant.permissions, "sessions:control")
-        ? await scheduledSessionIds(db, workspaceId, [sessionId])
-        : new Set<string>();
+        ? scheduledSessionIds(db, workspaceId, [sessionId])
+        : Promise.resolve(new Set<string>()),
+      loadEffectivePolicyContext(deps, workspaceId, grant.subjectId, [session]),
+    ]);
+    // the task's usage projection. A failed read is `unavailable`,
+    // never $0 or unlimited; it does not fail the session read.
+    const usageLimit = await sessionUsageLimitForRead(db, session, {
+      subjectId: grant.subjectId,
+    });
     return c.json(
-      await withEffectivePolicy(deps, workspaceId, grant.subjectId, {
-        ...session,
-        hasSchedules: scheduleTargets.has(sessionId),
-        ...(activity.get(sessionId) ? { backgroundCommandActivity: activity.get(sessionId) } : {}),
-      }),
+      sessionResponse(
+        {
+          ...session,
+          ...(usageLimit ? { usageLimit } : {}),
+          hasSchedules: scheduleTargets.has(sessionId),
+          ...(activity.get(sessionId)
+            ? { backgroundCommandActivity: activity.get(sessionId) }
+            : {}),
+        },
+        policy,
+      ),
     );
   });
 
@@ -1065,11 +1431,42 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     }
   });
 
+  app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/visibility/preview", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const sessionId = c.req.param("sessionId");
+    const authorization = await requireAccessGrantAuthorization(c, deps, workspaceId);
+    const target = SessionVisibility.safeParse(c.req.query("visibility"));
+    if (!target.success) {
+      throw new ApiHttpError(422, {
+        code: "validation_failed",
+        message: "Invalid session visibility preview request.",
+        retryable: false,
+        details: { fields: zodErrorFields(target.error) },
+      });
+    }
+    try {
+      return c.json(
+        await previewManagedHumanSessionVisibilityChange(
+          deps,
+          authorization,
+          workspaceId,
+          sessionId,
+          target.data,
+          "http",
+        ),
+      );
+    } catch (error) {
+      throw sessionTenancyHttpError(error);
+    }
+  });
+
   app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/forks", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const sessionId = c.req.param("sessionId");
     const authorization = await requireAccessGrantAuthorization(c, deps, workspaceId);
-    const parsed = ForkSessionRequest.safeParse(await c.req.json().catch(() => null));
+    const forkLegacy = rejectLegacyVariableSetFields(c, await c.req.json().catch(() => null));
+    if ("response" in forkLegacy) return forkLegacy.response;
+    const parsed = ForkSessionRequest.safeParse(forkLegacy.payload);
     if (!parsed.success) {
       throw new ApiHttpError(422, {
         code: "validation_failed",
@@ -1131,15 +1528,35 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       });
     }
     try {
-      const result = await withWorkspaceSessionActivityRls(db, workspaceId, async (scopedDb) =>
-        beginSessionRealtimeInTransaction(scopedDb, {
+      await realtimeVoiceBilling.admit({
+        accountId: grant.accountId,
+        workspaceId,
+        model: parsed.data.model,
+        attribution: creditDebitAttributionForGrant(grant),
+      });
+    } catch (error) {
+      const refused = realtimeVoiceRefusalResponse(c, error);
+      if (refused) return refused;
+      throw error;
+    }
+    try {
+      const result = await withWorkspaceSessionActivityRls(db, workspaceId, async (scopedDb) => {
+        const accounts = await freezeSessionRealtimeConnectionAccounts({
+          db: scopedDb as unknown as Database,
+          settings,
+          grant,
+          workspaceId,
+          sessionId,
+        });
+        return beginSessionRealtimeInTransaction(scopedDb, {
           accountId: grant.accountId,
           workspaceId,
           sessionId,
           ownerSubjectId: grant.subjectId,
           ...parsed.data,
-        }),
-      );
+          ...accounts,
+        });
+      });
       await publishRealtimeMutation(grant.accountId, workspaceId, sessionId, result);
       c.header("cache-control", "private, no-store");
       return c.json({ mode: result.mode, replay: result.replay }, result.replay ? 200 : 201);
@@ -1170,6 +1587,16 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
         });
       }
       try {
+        // Settle observed minutes before renewing; out of credits keeps the
+        // current lease so the call drains and ends instead of running free.
+        const settlement = await settleRealtimeVoice({
+          grant,
+          attribution: creditDebitAttributionForGrant(grant),
+          workspaceId,
+          sessionId,
+          realtimeId,
+        });
+        const stop = settlement?.stop ?? null;
         const result = await withWorkspaceSessionActivityRls(db, workspaceId, async (scopedDb) =>
           renewSessionRealtimeInTransaction(scopedDb, {
             workspaceId,
@@ -1177,11 +1604,18 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
             realtimeId,
             ownerSubjectId: grant.subjectId,
             ...parsed.data,
+            extendLease: stop === null,
           }),
         );
         await publishRealtimeMutation(grant.accountId, workspaceId, sessionId, result);
         c.header("cache-control", "private, no-store");
-        return c.json({ mode: result.mode, replay: result.replay });
+        return c.json({
+          mode: result.mode,
+          replay: result.replay,
+          ...(stop && result.mode.state === "active"
+            ? { stop: { code: stop.code, message: stop.message } }
+            : {}),
+        });
       } catch (error) {
         throw sessionRealtimeHttpError(error);
       }
@@ -1214,10 +1648,18 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
           sessionId,
           realtimeId,
           ownerSubjectId: grant.subjectId,
+          ownerSubjectLabel: grant.subjectLabel ?? null,
           ...parsed.data,
         }),
       );
       await publishRealtimeMutation(grant.accountId, workspaceId, sessionId, result);
+      await settleRealtimeVoice({
+        grant,
+        attribution: creditDebitAttributionForGrant(grant),
+        workspaceId,
+        sessionId,
+        realtimeId,
+      });
       c.header("cache-control", "private, no-store");
       return c.json({ mode: result.mode, replay: result.replay });
     } catch (error) {
@@ -1253,21 +1695,34 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
         ...providerRequest
       } = parsed.data;
       const claim = await withWorkspaceRls(db, workspaceId, async (scopedDb) =>
-        scopedDb.transaction(async (tx) =>
-          claimSessionRealtimeConnectionInTransaction(tx as unknown as Database, {
-            workspaceId,
-            sessionId,
-            realtimeId,
-            operationId,
-            ownerSubjectId: grant.subjectId,
-            browserInstanceId,
-            ownerKey,
-            expectedVersion,
-            expectedConnectionEpoch,
-            rotate,
-            promotionMode: browserActivation === "required" ? "staged" : "legacy",
-          }),
-        ),
+        scopedDb.transaction(async (tx) => {
+          const claimed = await claimSessionRealtimeConnectionInTransaction(
+            tx as unknown as Database,
+            {
+              workspaceId,
+              sessionId,
+              realtimeId,
+              operationId,
+              ownerSubjectId: grant.subjectId,
+              browserInstanceId,
+              ownerKey,
+              expectedVersion,
+              expectedConnectionEpoch,
+              rotate,
+              promotionMode: browserActivation === "required" ? "staged" : "legacy",
+            },
+          );
+          if (
+            claimed.mode.model !== "gpt-live-1-boulder-alpha" &&
+            claimed.mode.model !== AZURE_LIVE_MODEL_ID
+          ) {
+            throw new CodexRealtimeBrokerError(
+              "invalid_request",
+              "This voice model does not use WebRTC negotiation",
+            );
+          }
+          return claimed;
+        }),
       );
       if (claim.replay) {
         if (
@@ -1302,7 +1757,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
         return c.json({
           sdp: claim.connection.sdpAnswer,
           version: "v3" as const,
-          model: "gpt-live-1-boulder-alpha" as const,
+          model: claim.mode.model,
           connectionId: claim.connection.id,
           connectionEpoch: claim.connection.connectionEpoch,
           startupFenceSequence: claim.connection.startupFenceSequence,
@@ -1310,13 +1765,40 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
           replay: true,
         });
       }
-      const broker = buildSessionCodexRealtimeBroker(
-        db,
-        settings,
-        workspaceId,
-        sessionId,
-        deps.codexFetch,
-      );
+      try {
+        await realtimeVoiceBilling.admit({
+          accountId: grant.accountId,
+          workspaceId,
+          model: claim.mode.model,
+          attribution: creditDebitAttributionForGrant(grant),
+        });
+      } catch (error) {
+        const refused = realtimeVoiceRefusalResponse(c, error);
+        if (!refused) throw error;
+        await withWorkspaceRls(db, workspaceId, async (scopedDb) =>
+          scopedDb.transaction(async (tx) =>
+            failSessionRealtimeConnectionInTransaction(tx as unknown as Database, {
+              workspaceId,
+              sessionId,
+              realtimeId,
+              connectionId: claim.connection.id,
+              operationId,
+              connectionEpoch: claim.connection.connectionEpoch,
+              failureCode: "billing_refused",
+            }),
+          ),
+        ).catch(() => undefined);
+        return refused;
+      }
+      const broker =
+        claim.mode.model === AZURE_LIVE_MODEL_ID
+          ? buildSessionAzureLiveBroker(db, settings, workspaceId, sessionId, deps.codexFetch)
+          : buildSessionCodexRealtimeBroker(
+              db,
+              settings,
+              { accountId: grant.accountId, workspaceId, sessionId },
+              deps.codexFetch,
+            );
       try {
         const answer = await broker({
           request: providerRequest,
@@ -1355,6 +1837,13 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
                 ),
               )
             : null;
+        await settleRealtimeVoice({
+          grant,
+          attribution: creditDebitAttributionForGrant(grant),
+          workspaceId,
+          sessionId,
+          realtimeId,
+        });
         return c.json({
           ...answer,
           connectionId: completed.connection.id,
@@ -1455,6 +1944,12 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
           "Realtime Gateway tokens are single-use; reconnect with a new operation",
         );
       }
+      await realtimeVoiceBilling.admit({
+        accountId: grant.accountId,
+        workspaceId,
+        model: claim.mode.model,
+        attribution: creditDebitAttributionForGrant(grant),
+      });
       const secret = await createGatewayRealtimeConnectionSecret({
         db,
         settings,
@@ -1478,6 +1973,13 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
         ),
       );
       connectionCompleted = true;
+      await settleRealtimeVoice({
+        grant,
+        attribution: creditDebitAttributionForGrant(grant),
+        workspaceId,
+        sessionId,
+        realtimeId,
+      });
       return c.json({
         ...secret,
         connectionId: completed.connection.id,
@@ -1499,11 +2001,18 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
               operationId,
               connectionEpoch: claimed.connection.connectionEpoch,
               failureCode:
-                error instanceof GatewayRealtimeBrokerError ? error.code : "gateway_error",
+                error instanceof GatewayRealtimeBrokerError
+                  ? error.code
+                  : error instanceof TranscriptionBillingRefusedError ||
+                      error instanceof RealtimeVoiceUnavailableError
+                    ? "billing_refused"
+                    : "gateway_error",
             }),
           ),
         ).catch(() => undefined);
       }
+      const refused = realtimeVoiceRefusalResponse(c, error);
+      if (refused) return refused;
       if (error instanceof SessionRealtimeConflictError) throw sessionRealtimeHttpError(error);
       if (!(error instanceof GatewayRealtimeBrokerError)) throw error;
       const status = error.code === "credential_unavailable" ? 409 : 502;
@@ -1712,29 +2221,38 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
         });
       }
       try {
-        const result = await withWorkspaceSessionActivityRls(db, workspaceId, async (scopedDb) => {
-          // Acquire origin authority before inference/session locks. A deferred
-          // realtime session has no initial worker turn; capture its exact
-          // linked actor when the ledger actually admits ordinary agent work.
-          await beforeCommit?.(scopedDb as unknown as Database);
-          return syncSessionRealtimeLedgerInTransaction(
-            scopedDb,
-            {
-              workspaceId,
-              sessionId,
-              realtimeId,
-              ownerSubjectId: grant.subjectId,
-              ...parsed.data,
-              controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
-            },
-            captureLinked
-              ? {
-                  afterDelegationAdmission: async ({ turnId }) =>
-                    captureLinked(scopedDb as unknown as Database, sessionId, turnId),
-                }
-              : {},
-          );
-        });
+        const result = await withWorkspaceSessionActivityRls(
+          db,
+          workspaceId,
+          async (scopedDb) => {
+            // Acquire origin authority before inference/session locks. A deferred
+            // realtime session has no initial worker turn; capture its exact
+            // linked actor when the ledger actually admits ordinary agent work.
+            await beforeCommit?.(scopedDb as unknown as Database);
+            return syncSessionRealtimeLedgerInTransaction(
+              scopedDb,
+              {
+                workspaceId,
+                sessionId,
+                realtimeId,
+                ownerSubjectId: grant.subjectId,
+                ownerSubjectLabel: grant.subjectLabel ?? null,
+                ...parsed.data,
+                controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
+              },
+              captureLinked
+                ? {
+                    afterDelegationAdmission: async ({ turnId }) =>
+                      captureLinked(scopedDb as unknown as Database, sessionId, turnId),
+                  }
+                : {},
+            );
+          },
+          undefined,
+          // External reauthorization takes the organization-membership lock,
+          // which precedes the tenancy fence and the canonical session prefix.
+          Boolean(beforeCommit),
+        );
         await publishRealtimeMutation(grant.accountId, workspaceId, sessionId, result);
         c.header("cache-control", "private, no-store");
         return c.json({ accepted: result.accepted, outbound: result.outbound });
@@ -1858,6 +2376,8 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
 
   // Personal chat organization: archived roots leave the ordinary rail only
   // for this member and remain recoverable through the archived list view.
+  // Archiving a chat you started that still has work also pauses it (see
+  // pauseOwnArchivedWork); archiving anyone else's chat only hides it for you.
   app.put("/v1/workspaces/:workspaceId/sessions/:sessionId/archive", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const authorization = await requireAccessGrantAuthorization(
@@ -1873,14 +2393,22 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       throw new HTTPException(400, { message: "invalid session archive request" });
     }
     try {
-      const session = await setSessionArchive(db, {
+      const archived = await setSessionArchive(db, {
         workspaceId,
         subjectId: grant.subjectId,
         sessionId,
         personalWorkspaceOwnerException: hasVerifiedOwningUserAuthorization(authorization),
         ...parsed.data,
       });
-      if (!session) throw new HTTPException(404, { message: "session not found" });
+      if (!archived) throw new HTTPException(404, { message: "session not found" });
+      let session = archived;
+      if (parsed.data.archived) {
+        try {
+          session = await pauseOwnArchivedWork(deps, grant, workspaceId, archived);
+        } catch (error) {
+          return commandConflictResponse(c, error);
+        }
+      }
       return c.json(
         await withEffectivePolicy(
           deps,
@@ -1911,9 +2439,11 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       c.req.param("sessionId"),
       ...lineage.ancestors.map((session) => session.id),
     ];
+    const lineageSessions = [...lineage.ancestors];
     const collect = (nodes: LineageNode[]) => {
       for (const node of nodes) {
         sessionIds.push(node.session.id);
+        lineageSessions.push(node.session as Session);
         collect(node.children);
       }
     };
@@ -1929,23 +2459,56 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
         session: { ...node.session, hasSchedules: targets.has(node.session.id) },
         children: decorateNodes(node.children),
       }));
-    const policy = await loadEffectivePolicyContext(deps, workspaceId, grant.subjectId);
+    const policy = await loadEffectivePolicyContext(
+      deps,
+      workspaceId,
+      grant.subjectId,
+      lineageSessions,
+    );
     return c.json({
       ...lineage,
       sessionHasSchedules: targets.has(c.req.param("sessionId")),
       ancestors: lineage.ancestors.map((session) =>
-        sessionWithEffectiveToolPolicy(
-          { ...session, hasSchedules: targets.has(session.id) },
-          policy.workspaceServerIds,
-          policy.workspaceDefaultServerIds,
-        ),
+        sessionResponse({ ...session, hasSchedules: targets.has(session.id) }, policy),
       ),
       children: decorateNodes(mapLineageNodes(lineage.children, policy)),
     });
   });
 
+  app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/codex-accounts", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    await requireAccessGrant(c, deps, workspaceId, "sessions:read");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:read");
+    // authorizeSessionHttp has already enforced private-session and agent scope.
+    await codexRouteDisposition(deps, grant.accountId);
+    const projection = await getSubscriptionCoreSessionCodexAccounts(db, {
+      accountId: grant.accountId,
+      workspaceId,
+      sessionId: c.req.param("sessionId"),
+      // A turn on the viewer's own personal connection shows it to them.
+      viewerSubjectId: grant.subjectId,
+    });
+    if (!projection) throw new HTTPException(404, { message: "session not found" });
+    const activeAccountId = projection.rotation?.activeCredentialId ?? null;
+    return c.json({
+      accounts: projection.accounts.map((account) => codexAccountJson(account)),
+      activeAccountId,
+      settings: {
+        rotationEnabled: projection.rotation?.rotationEnabled ?? false,
+        rotationStrategy: "sharded",
+        activeCredentialId: activeAccountId,
+      },
+      currentSelection: projection.currentSelection,
+      currentAccount: projection.currentAccount
+        ? codexAccountJson(projection.currentAccount)
+        : null,
+      pinnedAccountId: projection.pinnedAccountId,
+      lastAccountId: projection.lastAccountId,
+    });
+  });
+
   // Pin (or unpin) the session's Codex account. body { target: "auto" | "<id>" }:
-  // "auto" clears the pin (the session follows the workspace active pointer); a
+  // "auto" clears only the Codex pin (shared-core automatic selection); a
   // uuid pins the session to that specific account. Overrides a capacity-blocked
   // turn; a running attempt keeps its account. 404 when the session or the target
   // account id isn't in the workspace.
@@ -1964,7 +2527,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       try {
         await requireSessionAuthorization(deps, grant, {
           sessionId,
-          operation: "session.codex_account.write",
+          operation: "session.model_account.write",
           surface: "http",
         });
       } catch (error) {
@@ -1972,42 +2535,23 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       }
     }
     const pinned = target === "auto" ? null : target;
-    const mutation = await switchSessionCodexAccount(db, {
+    await codexRouteDisposition(deps, grant.accountId);
+
+    const core = await pinSubscriptionCoreSessionCodexAccount(db, {
+      accountId: grant.accountId,
       workspaceId,
       sessionId,
-      credentialId: pinned,
+      connectionId: pinned,
       subjectId: grant.subjectId,
     });
-    const ok = mutation.result.changed;
-    if (!ok) {
-      throw new HTTPException(404, {
-        message: "session or codex account not found",
-      });
+    if (!core.result.changed) {
+      throw new HTTPException(404, { message: "session or codex account not found" });
     }
-    await Promise.allSettled(
-      mutation.wakeTargets.map((wake) =>
-        workflowClient.signalCodexCapacity
-          ? workflowClient.signalCodexCapacity({
-              accountId: wake.accountId,
-              workspaceId: wake.workspaceId,
-              sessionId: wake.sessionId,
-              workflowId: wake.workflowId,
-              wakeRevision: wake.wakeRevision,
-              workflowWakeRevision: wake.workflowWakeRevision,
-            })
-          : workflowClient.wakeSessionWorkflow({
-              accountId: wake.accountId,
-              workspaceId: wake.workspaceId,
-              sessionId: wake.sessionId,
-              workflowId: wake.workflowId,
-              wakeRevision: wake.workflowWakeRevision,
-            }),
-      ),
-    );
-    await publishDurableSessionEvents(bus, workspaceId, sessionId, mutation.result.events);
+    await deliverSubscriptionCoreCodexWake(db, core.wake);
+    await publishDurableSessionEvents(bus, workspaceId, sessionId, core.result.events);
     return c.json({
       pinned: target === "auto" ? "auto" : target,
-      appliedTo: mutation.result.appliedTo,
+      appliedTo: core.result.appliedTo,
     });
   });
 
@@ -2024,7 +2568,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       operation: "session.control",
       surface: "http",
     });
-    const payload = UpdateSessionChannelRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, UpdateSessionChannelRequest);
     try {
       const updated = await setSessionChannel(db, {
         workspaceId,
@@ -2053,89 +2597,12 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     return c.json(await withEffectivePolicy(deps, workspaceId, grant.subjectId, session));
   });
 
-  // Replace the complete ordered Variable Set selection. The DB mutation
-  // serializes with turn claim, rejects live/shared sandbox use, and requests a
-  // cold rotation before the new environment can be materialized.
+  // Variable Sets were replaced by vaults. The route answers 410 so old
+  // clients learn where secrets moved instead of silently doing nothing.
   app.put("/v1/workspaces/:workspaceId/sessions/:sessionId/variable-sets", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const sessionId = c.req.param("sessionId");
-    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
-    try {
-      await requireSessionAuthorization(deps, grant, {
-        sessionId,
-        operation: "session.variable_sets.write",
-        surface: "http",
-      });
-    } catch (error) {
-      throw sessionAuthorizationHttpError(error);
-    }
-    // Detach still requires attach authority: it changes which protected
-    // resources the session may materialize. Non-empty selections additionally
-    // require use authority through validateVariableSetAttachment.
-    requirePermission(grant, "variable-sets:attach");
-    const parsed = UpdateSessionVariableSetsRequest.safeParse(await c.req.json().catch(() => null));
-    if (!parsed.success) {
-      throw new ApiHttpError(422, {
-        code: "validation_failed",
-        message: "Invalid session Variable Set request.",
-        retryable: false,
-        details: { fields: zodErrorFields(parsed.error) },
-      });
-    }
-    const variableSets: VariableSet[] = [];
-    for (const variableSetId of parsed.data.variableSetIds) {
-      variableSets.push(
-        await validateVariableSetAttachment({ settings, db }, grant, workspaceId, variableSetId),
-      );
-    }
-    const result = await updateSessionVariableSets(db, {
-      accountId: grant.accountId,
-      workspaceId,
-      sessionId,
-      subjectId: grant.subjectId,
-      variableSets: variableSets.map((variableSet) => ({
-        id: variableSet.id,
-        name: variableSet.name,
-        scope: variableSet.scope,
-      })),
-    });
-    if (result.status === "not_found") {
-      throw new HTTPException(404, { message: "session not found" });
-    }
-    if (result.status === "invalid_variable_sets") {
-      throw new ApiHttpError(422, {
-        code: "validation_failed",
-        message: "One or more selected Variable Sets are no longer available.",
-        retryable: false,
-        outcomeUnknown: false,
-        details: { variableSetIds: result.variableSetIds },
-      });
-    }
-    if (result.status === "blocked") {
-      const messages = {
-        turn_in_flight:
-          "Variable Sets can be changed only when the session has no accepted, queued, claimed, or pending work.",
-        shared_sandbox_group:
-          "Variable Sets cannot be changed while this session shares a sandbox; fork it into a separate session first.",
-        live_sandbox_holders:
-          "Close active terminal, desktop, and sandbox operations before changing Variable Sets.",
-      } as const;
-      throw new HTTPException(409, { message: messages[result.reason] });
-    }
-    if (result.status === "updated") {
-      await publishDurableSessionEvents(bus, workspaceId, sessionId, [result.event]);
-    }
-    const session = await getSessionForSubject(
-      db,
-      workspaceId,
-      sessionId,
-      grant.subjectId,
-      relatedSessionAccessFor(c),
-    );
-    if (!session) {
-      throw new HTTPException(404, { message: "session not found" });
-    }
-    return c.json(await withEffectivePolicy(deps, workspaceId, grant.subjectId, session));
+    await requireAccessGrant(c, deps, workspaceId, "sessions:control");
+    return variableSetsRemovedResponse(c, 410);
   });
 
   // Manual rename. A user-set title is permanent: the db write is
@@ -2146,7 +2613,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    const payload = UpdateSessionRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, UpdateSessionRequest);
     const titleUpdate = await updateSessionTitle(deps, grant, sessionId, payload.title, "user");
     // A session-returning member route must preserve the caller's private pin
     // projection. Returning the generic mapSession() default here would reset a
@@ -2164,6 +2631,89 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     return c.json(await withEffectivePolicy(deps, workspaceId, grant.subjectId, session));
   });
 
+  // Workspace-wide keep-live exemption from the idle-session archive. Distinct
+  // from the personal rail archive above; archived sessions are read-only.
+  app.put("/v1/workspaces/:workspaceId/sessions/:sessionId/retention", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
+    const sessionId = c.req.param("sessionId");
+    const payload = await parseRequestJson(c, UpdateSessionRetentionRequest);
+    const { result, relatedSessionAccess } = await setSessionRetention(
+      deps,
+      grant,
+      sessionId,
+      payload.keepLive,
+    );
+    if (result.status === "not_found") {
+      throw new HTTPException(404, { message: "session not found" });
+    }
+    if (result.status === "archived") {
+      return c.json(
+        {
+          code: "SESSION_ARCHIVED_READ_ONLY",
+          message:
+            "This session is already archived, so its keep-live setting can no longer change.",
+        },
+        409,
+      );
+    }
+    const session = await getSessionForSubject(
+      db,
+      workspaceId,
+      sessionId,
+      grant.subjectId,
+      relatedSessionAccess,
+    );
+    if (!session) throw new HTTPException(404, { message: "session not found" });
+    return c.json(await withEffectivePolicy(deps, workspaceId, grant.subjectId, session));
+  });
+
+  // Per-task usage limit. Reads follow session read access; a child
+  // returns its root's shared state. Writes are compare-and-set on the ROOT
+  // by a person in the app or the host's server key only, never an agent
+  // (including one acting for a person), and never wake or resume work.
+  app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/usage-limit", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const sessionId = c.req.param("sessionId");
+    if (!z.string().uuid().safeParse(sessionId).success) {
+      throw new HTTPException(404, { message: "session not found" });
+    }
+    const authorization = await requireAccessGrantAuthorization(
+      c,
+      deps,
+      workspaceId,
+      "sessions:read",
+    );
+    return c.json(await getSessionUsageLimitForAccess(deps, authorization, sessionId));
+  });
+
+  app.put("/v1/workspaces/:workspaceId/sessions/:sessionId/usage-limit", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const sessionId = c.req.param("sessionId");
+    if (!z.string().uuid().safeParse(sessionId).success) {
+      throw new HTTPException(404, { message: "session not found" });
+    }
+    // Checked first: an agent acting for a person (connected agent, admin
+    // access, personal API key) is refused whatever access it holds.
+    if (isAgentActingAsPerson(c)) {
+      throw new SessionUsageLimitHttpError(
+        403,
+        "session_usage_limit_forbidden",
+        "Only a person or the application's server can change a task usage limit.",
+      );
+    }
+    const authorization = await requireAccessGrantAuthorization(
+      c,
+      deps,
+      workspaceId,
+      "sessions:control",
+    );
+    const payload = await parseRequestJson(c, SetSessionUsageLimitRequest);
+    return c.json(
+      await setSessionUsageLimitForAccess(deps, authorization, sessionId, payload, c.req.raw),
+    );
+  });
+
   app.delete("/v1/workspaces/:workspaceId/sessions/:sessionId", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
@@ -2179,30 +2729,55 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       case "not_found":
         throw new HTTPException(404, { message: "session not found" });
       case "not_root":
-        throw new HTTPException(409, {
-          message: "delete the root session to remove the complete workstream",
+        throw new ApiHttpError(409, {
+          code: "conflict",
+          message: "Delete the chat this one belongs to; sub-chats are removed with it.",
+          retryable: false,
+          outcomeUnknown: false,
+          details: { code: "session_delete_not_root" },
         });
       case "active_sessions":
-        throw new HTTPException(409, {
-          message: "cancel the workstream and wait for active turns to finish before deleting it",
+        throw new ApiHttpError(409, {
+          code: "conflict",
+          message:
+            "This chat is still running. Stop it, then delete it once its current turn has finished.",
+          retryable: true,
+          outcomeUnknown: false,
+          details: { code: "session_delete_active_sessions" },
         });
       case "active_video_generations":
-        throw new HTTPException(409, {
-          message: "wait for active video generations to finish before deleting this workstream",
+        throw new ApiHttpError(409, {
+          code: "conflict",
+          message: "Wait for this chat's video generations to finish before deleting it.",
+          retryable: false,
+          outcomeUnknown: false,
+          details: { code: "session_delete_active_video_generations" },
         });
       case "active_background_commands":
-        throw new HTTPException(409, {
-          message: "pause or cancel this workstream's background commands before deleting it",
+        throw new ApiHttpError(409, {
+          code: "conflict",
+          message: "Stop this chat's background commands before deleting it.",
+          retryable: false,
+          outcomeUnknown: false,
+          details: { code: "session_delete_active_background_commands" },
         });
       case "live_sandboxes":
-        throw new HTTPException(409, {
+        throw new ApiHttpError(409, {
+          code: "conflict",
           message:
-            "wait for the workstream's sandbox activity to finish draining before deleting it",
+            "This chat's computer is still shutting down. Try deleting it again in a moment.",
+          retryable: true,
+          outcomeUnknown: false,
+          details: { code: "session_delete_live_sandboxes" },
         });
       case "externally_referenced":
-        throw new HTTPException(409, {
+        throw new ApiHttpError(409, {
+          code: "conflict",
           message:
-            "this workstream has durable workspace outputs or independent forks; archive it instead",
+            "This chat has saved workspace outputs or forks that depend on it. Archive it instead.",
+          retryable: false,
+          outcomeUnknown: false,
+          details: { code: "session_delete_externally_referenced" },
         });
     }
   });
@@ -2239,7 +2814,10 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
-    const payload = UpdateSessionToolPolicyRequest.parse(await c.req.json().catch(() => null));
+    const payload = parseRequestBody(
+      UpdateSessionToolPolicyRequest,
+      await c.req.json().catch(() => null),
+    );
     try {
       const session = await updateSessionToolPolicy(deps, grant, sessionId, payload);
       return c.json(await withEffectivePolicy(deps, workspaceId, grant.subjectId, session));
@@ -2258,6 +2836,63 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     }
   });
 
+  // Replace the session's agent configuration (capabilities, identity,
+  // instructions alias, renderer). Shares the tool-policy version CAS and
+  // applies from the next attempt.
+  app.put("/v1/workspaces/:workspaceId/sessions/:sessionId/agent", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
+    const sessionId = c.req.param("sessionId");
+    const payload = parseRequestBody(
+      UpdateSessionAgentRequest,
+      await c.req.json().catch(() => null),
+    );
+    try {
+      const session = await updateSessionAgent(deps, grant, sessionId, payload);
+      return c.json(await withEffectivePolicy(deps, workspaceId, grant.subjectId, session));
+    } catch (error) {
+      if (error instanceof SessionToolPolicyVersionConflictError) {
+        return c.json(
+          {
+            code: error.code,
+            message: error.message,
+            currentVersion: error.currentVersion,
+          },
+          409,
+        );
+      }
+      throw error;
+    }
+  });
+
+  // Replace the Skills the session carries itself. Shares the tool-policy
+  // version CAS and applies from the next attempt.
+  app.put("/v1/workspaces/:workspaceId/sessions/:sessionId/skills", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
+    const sessionId = c.req.param("sessionId");
+    const payload = parseRequestBody(
+      UpdateSessionSkillsRequest,
+      await c.req.json().catch(() => null),
+    );
+    try {
+      const session = await updateSessionSkills(deps, grant, sessionId, payload);
+      return c.json(await withEffectivePolicy(deps, workspaceId, grant.subjectId, session));
+    } catch (error) {
+      if (error instanceof SessionToolPolicyVersionConflictError) {
+        return c.json(
+          {
+            code: error.code,
+            message: error.message,
+            currentVersion: error.currentVersion,
+          },
+          409,
+        );
+      }
+      throw error;
+    }
+  });
+
   app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/goal", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant(c, deps, workspaceId, "sessions:read");
@@ -2265,6 +2900,12 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     await assertSessionExists(db, workspaceId, sessionId);
     const goal = await getSessionGoalWithContinuation(db, workspaceId, sessionId);
     if (!goal) {
+      // `?absent=null` opts in to a successful `null` for a goal-less session,
+      // so a browser polling a fresh chat logs no failed request. Without it
+      // the original 404 contract is unchanged for existing clients.
+      if (c.req.query("absent") === "null") {
+        return c.json(null);
+      }
       throw new HTTPException(404, { message: "session goal not found" });
     }
     return c.json(goal);
@@ -2313,7 +2954,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
       const sessionId = c.req.param("sessionId");
       await assertSessionExists(db, workspaceId, sessionId);
-      const payload = ApplySessionGoalRevisionRequest.parse(await c.req.json());
+      const payload = await parseRequestJson(c, ApplySessionGoalRevisionRequest);
       const revision = await getSessionGoalRevision(
         db,
         workspaceId,
@@ -2377,7 +3018,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
       const sessionId = c.req.param("sessionId");
       await assertSessionExists(db, workspaceId, sessionId);
-      const payload = RejectSessionGoalRevisionRequest.parse(await c.req.json());
+      const payload = await parseRequestJson(c, RejectSessionGoalRevisionRequest);
       try {
         const result = await rejectSessionGoalRevisionWithEvent(db, {
           accountId: grant.accountId,
@@ -2405,7 +3046,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
       const sessionId = c.req.param("sessionId");
       await assertSessionExists(db, workspaceId, sessionId);
-      const payload = RollbackSessionGoalRevisionRequest.parse(await c.req.json());
+      const payload = await parseRequestJson(c, RollbackSessionGoalRevisionRequest);
       const revision = await getSessionGoalRevision(
         db,
         workspaceId,
@@ -2457,7 +3098,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    const payload = UpdateSessionGoalRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, UpdateSessionGoalRequest);
     const existing = await getSessionGoal(db, workspaceId, sessionId);
     if (!existing) {
       throw new HTTPException(404, { message: "session goal not found" });
@@ -2542,6 +3183,15 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
       sessionId,
       {
         status: "active",
+        beforeResume: (tx, session, causalTurn) =>
+          assertGoalResumeAllowed({ ...deps, db: tx }, session, causalTurn).catch(
+            (error: unknown) => {
+              if (error instanceof GoalResumeBlockedError) {
+                throw new HTTPException(422, { message: error.message, cause: error });
+              }
+              throw error;
+            },
+          ),
         event: { type: "goal.resumed", actor: "api" },
       },
     );
@@ -2569,10 +3219,17 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
 
   app.delete("/v1/workspaces/:workspaceId/sessions/:sessionId/goal", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    await requireAccessGrant(c, deps, workspaceId, "sessions:control");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    const { event } = await clearSessionGoal(db, workspaceId, sessionId);
+    const { event } = await clearSessionGoal(db, workspaceId, sessionId, {
+      actor: grant.principalKind === "agent_attempt" ? "agent" : "api",
+    }).catch((error: unknown) => {
+      if (error instanceof SessionControlConflictError) {
+        throw new HTTPException(409, { message: error.message, cause: error });
+      }
+      throw error;
+    });
     if (event) {
       try {
         await bus.publish(workspaceId, sessionId, [event]);
@@ -2635,7 +3292,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    CompactSessionContextRequest.parse((await c.req.json().catch(() => ({}))) ?? {});
+    parseRequestBody(CompactSessionContextRequest, (await c.req.json().catch(() => ({}))) ?? {});
     // /compact sets one durable request. The worker clears it only in the same
     // fenced transaction that installs replacement history, so failed or stale
     // attempts cannot lose the request.
@@ -2822,9 +3479,93 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
         direction === "before" ? "X-OpenGeni-Next-Before" : "X-OpenGeni-Next-After",
         String(page.nextSequence),
       );
-    }
-    return c.json(page.events);
-  });
+    }
+    return c.json(page.events);
+  });
+
+  // Selected search hit only: never use the audit event projection here, even
+  // in summary mode (it can contain modelContext or truncate visible text).
+  app.get(
+    "/v1/workspaces/:workspaceId/sessions/:sessionId/events/:eventId/message-preview",
+    async (c) => {
+      const workspaceId = c.req.param("workspaceId");
+      await requireAccessGrant(c, deps, workspaceId, "sessions:read");
+      const sessionId = c.req.param("sessionId");
+      await assertSessionExists(db, workspaceId, sessionId);
+      const eventId = c.req.param("eventId");
+      const rawSequence = c.req.query("sequence");
+      const sequence = Number(rawSequence);
+      if (
+        !z.string().uuid().safeParse(eventId).success ||
+        rawSequence === undefined ||
+        !/^\d+$/.test(rawSequence) ||
+        !Number.isSafeInteger(sequence) ||
+        sequence < 1 ||
+        sequence > 2_147_483_647
+      )
+        throw new HTTPException(400, { message: "Invalid message preview reference" });
+
+      const notFound = () => new HTTPException(404, { message: "message not found" });
+      const maxUnits = 12_000;
+      const eventTable = sessionPreviewSchema.sessionEvents;
+      // The slice helper supports structured result views too. Check only the
+      // JSON scalar *kind* before calling it; never fetch a structured text value.
+      const candidates = await withWorkspaceRls(db, workspaceId, (tx) =>
+        tx
+          .select({ kind: sql<string | null>`jsonb_typeof(${eventTable.payload}->'text')` })
+          .from(eventTable)
+          .where(
+            and(
+              eq(eventTable.workspaceId, workspaceId),
+              eq(eventTable.sessionId, sessionId),
+              eq(eventTable.id, eventId),
+              eq(eventTable.sequence, sequence),
+              sql`${eventTable.type} in ('user.message', 'agent.message.completed')`,
+            ),
+          )
+          .limit(1),
+      );
+      if (candidates[0]?.kind !== "string") throw notFound();
+      const read = (offset: number) =>
+        listSessionEventSlices(db, workspaceId, sessionId, {
+          sourceSequence: sequence,
+          sourceOffset: offset,
+          after: sequence - 1,
+          before: sequence + 1,
+          includeTypes: ["user.message", "agent.message.completed"],
+          view: "conversation",
+        });
+      const first = await read(0);
+      const event = first.events[0];
+      const slice = first.slices?.[sequence];
+      // Includes the slice reader's duplicate, late and unclaimed-prompt gates.
+      if (!event || event.id !== eventId || event.sequence !== sequence || !slice || slice.omitted)
+        throw notFound();
+      if (slice.total > maxUnits) return c.json({ status: "unavailable" as const });
+
+      let text = slice.text;
+      let offset = slice.unit === "utf16" ? slice.text.length : Array.from(slice.text).length;
+      if (text.length > maxUnits) return c.json({ status: "unavailable" as const });
+      while (offset < slice.total) {
+        if (offset === 0) throw notFound();
+        const next = await read(offset);
+        const part = next.slices?.[sequence];
+        if (
+          next.events[0]?.id !== eventId ||
+          !part ||
+          part.omitted ||
+          part.unit !== slice.unit ||
+          part.total !== slice.total ||
+          part.offset !== offset
+        )
+          throw notFound();
+        text += part.text;
+        offset += slice.unit === "utf16" ? part.text.length : Array.from(part.text).length;
+        if (text.length > maxUnits) return c.json({ status: "unavailable" as const });
+      }
+      return c.json({ status: "available" as const, text });
+    },
+  );
 
   app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/events/stream", async (c) => {
     const workspaceId = c.req.param("workspaceId");
@@ -2919,7 +3660,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    const payload = MoveSessionQueueItemRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, MoveSessionQueueItemRequest);
     try {
       const response = await moveHumanQueuePrompt(
         deps,
@@ -2946,7 +3687,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    const payload = EditSessionQueueItemRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, EditSessionQueueItemRequest);
     try {
       const response = await editHumanQueuePrompt(
         deps,
@@ -2973,7 +3714,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    const payload = SteerSessionQueueItemRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, SteerSessionQueueItemRequest);
     try {
       const response = await steerHumanQueuePrompt(
         deps,
@@ -3000,7 +3741,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    const payload = DeleteSessionQueueItemRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, DeleteSessionQueueItemRequest);
     try {
       const response = await deleteHumanQueuePrompt(
         deps,
@@ -3040,7 +3781,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
-    const payload = SaveComposerDraftRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, SaveComposerDraftRequest);
     try {
       return c.json(
         await saveHumanComposerDraft(
@@ -3059,6 +3800,113 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     }
   });
 
+  app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/sandbox-recovery", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const authorization = await requireAccessGrantAuthorization(c, deps, workspaceId);
+    try {
+      return c.json(
+        await getManagedHumanSandboxRecovery(
+          deps,
+          authorization,
+          workspaceId,
+          c.req.param("sessionId"),
+        ),
+      );
+    } catch (error) {
+      throw sessionTenancyHttpError(error);
+    }
+  });
+
+  app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/sandbox-recovery", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const sessionId = c.req.param("sessionId");
+    const authorization = await requireAccessGrantAuthorization(c, deps, workspaceId);
+    const parsed = SandboxRecoveryRequest.safeParse(await c.req.json().catch(() => null));
+    if (!parsed.success) throw new HTTPException(400, { message: "invalid checkpoint consent" });
+    let consentCommitted = false;
+    try {
+      const receipt = await consentManagedHumanSandboxRecovery(
+        deps,
+        authorization,
+        workspaceId,
+        sessionId,
+        parsed.data,
+      );
+      consentCommitted = true;
+      const projection = await getManagedHumanSandboxRecovery(
+        deps,
+        authorization,
+        workspaceId,
+        sessionId,
+      );
+      if (
+        projection.operationId === receipt.operationId &&
+        projection.status === "consent_accepted"
+      ) {
+        // Establish/verify only. No failed-turn Retry, Send, tool callback or
+        // command replay. The ordinary cold->warming election owns creation.
+        const session = await getSession(db, workspaceId, sessionId);
+        if (session) {
+          try {
+            await withChannelARead(
+              channelAServices,
+              {
+                accountId: authorization.grant.accountId,
+                workspaceId,
+                session,
+                subjectId: authorization.grant.subjectId,
+                grant: authorization.grant,
+              },
+              async () => undefined,
+            );
+          } catch {
+            // Consent committed. Never turn a provider failure into a false
+            // rejection of consent or leak native provider bindings/messages.
+          }
+        }
+      }
+      return c.json({
+        ...receipt,
+        recovery: await getManagedHumanSandboxRecovery(deps, authorization, workspaceId, sessionId),
+      });
+    } catch (error) {
+      if (consentCommitted) {
+        // A later authorization/read failure cannot revoke the committed
+        // receipt. Return no session state, checkpoint or provider details.
+        return c.json(
+          {
+            code: "upstream_unavailable",
+            message:
+              "Recovery status could not be confirmed. Check status without resubmitting consent.",
+            outcomeUnknown: true,
+            retryable: false,
+          },
+          503,
+        );
+      }
+      if (error instanceof SandboxRecoveryConflictError)
+        return c.json({ code: error.code, message: error.message }, 409);
+      if (error instanceof SessionCommandIdempotencyError) return commandConflictResponse(c, error);
+      throw sessionTenancyHttpError(error);
+    }
+  });
+
+  app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/retry", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
+    const parsed = SessionRetryRequest.safeParse(await c.req.json().catch(() => null));
+    if (!parsed.success) throw new HTTPException(400, { message: "invalid session retry request" });
+    try {
+      return c.json(
+        await retryFailedSession(deps, grant, workspaceId, c.req.param("sessionId"), parsed.data),
+      );
+    } catch (error) {
+      if (error instanceof SessionRetryConflictError)
+        return c.json({ code: error.code, message: error.message }, 409);
+      return commandConflictResponse(c, error);
+    }
+  });
+
   app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/control", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
@@ -3112,34 +3960,34 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const payload = parseSteerSessionAdmission(await c.req.json().catch(() => null));
     let result: Awaited<ReturnType<typeof acceptSessionUserMessage>>;
     try {
-      result = await acceptSessionUserMessage(deps, grant, workspaceId, sessionId, {
-        text: payload.text,
-        annotations: payload.annotations,
-        modelContext: payload.modelContext ?? null,
-        resources: payload.resources,
-        model: payload.model ?? null,
-        reasoningEffort: payload.reasoningEffort ?? null,
-        latencyMode: payload.latencyMode ?? null,
-        mcpCredentialUpdates: payload.mcpCredentialUpdates ?? [],
-        connectionAuthorities: payload.connectionAuthorities,
-        ...(payload.selectedHostMcpDelegations
-          ? { selectedHostMcpDelegations: payload.selectedHostMcpDelegations }
-          : {}),
-        ...(payload.personalResourceAttachment
-          ? { personalResourceAttachment: payload.personalResourceAttachment }
-          : {}),
-        authorization,
-        delivery: "steer",
-        origin: "human",
-        ...(payload.controlEtag !== undefined ? { controlEtag: payload.controlEtag } : {}),
-        ...(payload.expectedDraftRevision !== undefined
-          ? { expectedDraftRevision: payload.expectedDraftRevision }
-          : {}),
-        ...(payload.clientEventId ? { clientEventId: payload.clientEventId } : {}),
-      });
+      result = await withSiteCommandOrigin(c, grant, () =>
+        acceptSessionUserMessage(deps, grant, workspaceId, sessionId, {
+          text: payload.text,
+          annotations: payload.annotations,
+          modelContext: payload.modelContext ?? null,
+          resources: payload.resources,
+          model: payload.model ?? null,
+          reasoningEffort: payload.reasoningEffort ?? null,
+          latencyMode: payload.latencyMode ?? null,
+          mcpCredentialUpdates: payload.mcpCredentialUpdates ?? [],
+          connectionAccounts: payload.connectionAccounts,
+          ...(payload.personalResourceAttachment
+            ? { personalResourceAttachment: payload.personalResourceAttachment }
+            : {}),
+          authorization,
+          delivery: "steer",
+          origin: "human",
+          ...(payload.controlEtag !== undefined ? { controlEtag: payload.controlEtag } : {}),
+          ...(payload.expectedDraftRevision !== undefined
+            ? { expectedDraftRevision: payload.expectedDraftRevision }
+            : {}),
+          ...(payload.clientEventId ? { clientEventId: payload.clientEventId } : {}),
+        }),
+      );
     } catch (error) {
       return commandConflictResponse(c, error);
     }
+    recordAcceptedApiAdmission(deps.observability, result);
     return c.json(result, 202);
   });
 
@@ -3154,15 +4002,21 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     const grant = authorization.grant;
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    const payload = SubmitComposerDraftRequest.parse(await c.req.json().catch(() => null));
+    const payload = parseRequestBody(
+      SubmitComposerDraftRequest,
+      await c.req.json().catch(() => null),
+    );
     let result: Awaited<ReturnType<typeof submitComposerDraftForRequest>>;
     try {
-      result = await submitComposerDraftForRequest(deps, grant, workspaceId, sessionId, payload, {
-        authorization,
-      });
+      result = await withSiteCommandOrigin(c, grant, () =>
+        submitComposerDraftForRequest(deps, grant, workspaceId, sessionId, payload, {
+          authorization,
+        }),
+      );
     } catch (error) {
       return commandConflictResponse(c, error);
     }
+    recordAcceptedApiAdmission(deps.observability, result);
     return c.json(result, 202);
   });
 
@@ -3197,47 +4051,73 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     if (event.type === "user.message") {
       let result: Awaited<ReturnType<typeof acceptSessionUserMessage>>;
       try {
-        result = await acceptSessionUserMessage(deps, grant, workspaceId, sessionId, {
-          text: event.payload.text,
-          annotations: event.payload.annotations,
-          modelContext: event.payload.modelContext ?? null,
-          resources: event.payload.resources ?? [],
-          model: event.payload.model ?? null,
-          reasoningEffort: event.payload.reasoningEffort ?? null,
-          latencyMode: event.payload.latencyMode ?? null,
-          mcpCredentialUpdates: event.payload.mcpCredentialUpdates ?? [],
-          connectionAuthorities: event.payload.connectionAuthorities,
-          ...(event.payload.selectedHostMcpDelegations
-            ? { selectedHostMcpDelegations: event.payload.selectedHostMcpDelegations }
-            : {}),
-          ...(event.payload.personalResourceAttachment
-            ? { personalResourceAttachment: event.payload.personalResourceAttachment }
-            : {}),
-          authorization,
-          ...(event.payload.controlEtag !== undefined
-            ? { controlEtag: event.payload.controlEtag }
-            : {}),
-          ...(event.payload.expectedDraftRevision !== undefined
-            ? { expectedDraftRevision: event.payload.expectedDraftRevision }
-            : {}),
-          ...(event.clientEventId ? { clientEventId: event.clientEventId } : {}),
-        });
+        result = await withSiteCommandOrigin(c, grant, () =>
+          acceptSessionUserMessage(deps, grant, workspaceId, sessionId, {
+            text: event.payload.text,
+            annotations: event.payload.annotations,
+            modelContext: event.payload.modelContext ?? null,
+            resources: event.payload.resources ?? [],
+            model: event.payload.model ?? null,
+            reasoningEffort: event.payload.reasoningEffort ?? null,
+            latencyMode: event.payload.latencyMode ?? null,
+            mcpCredentialUpdates: event.payload.mcpCredentialUpdates ?? [],
+            connectionAccounts: event.payload.connectionAccounts,
+            ...(event.payload.personalResourceAttachment
+              ? { personalResourceAttachment: event.payload.personalResourceAttachment }
+              : {}),
+            authorization,
+            ...(event.payload.controlEtag !== undefined
+              ? { controlEtag: event.payload.controlEtag }
+              : {}),
+            ...(event.payload.expectedDraftRevision !== undefined
+              ? { expectedDraftRevision: event.payload.expectedDraftRevision }
+              : {}),
+            ...(event.clientEventId ? { clientEventId: event.clientEventId } : {}),
+          }),
+        );
       } catch (error) {
         return commandConflictResponse(c, error);
       }
+      recordAcceptedApiAdmission(deps.observability, result);
       return c.json(result.accepted, 202);
     }
 
-    if (event.type === "user.approvalDecision") {
-      const accepted = await acceptSessionApprovalDecision(db, {
-        accountId: grant.accountId,
-        workspaceId,
-        sessionId,
-        subjectId: grant.subjectId,
-        respondedByKind: childRequiresActionRespondedByKindForGrant(grant),
-        payload: event.payload,
-        clientEventId: event.clientEventId ?? null,
+    // Responses use the same header-only validation, permission and encryption
+    // boundary as Send/Steer. Persistence belongs to the response transaction,
+    // never a separate rotation that could commit without accepting the reply.
+    const updates = event.payload.mcpCredentialUpdates ?? [];
+    let mcpCredentialUpdates = [] as ReturnType<typeof validateSessionMcpCredentialUpdates>;
+    if (updates.length) {
+      const session = await getSession(db, workspaceId, sessionId);
+      if (!session) throw new HTTPException(404, { message: "session not found" });
+      mcpCredentialUpdates = validateSessionMcpCredentialUpdates({
+        settings,
+        grant,
+        session,
+        updates,
       });
+    }
+
+    if (event.type === "user.approvalDecision") {
+      const { mcpCredentialUpdates: _writeOnlyCredentials, ...payload } = event.payload;
+      let accepted;
+      try {
+        accepted = await acceptSessionApprovalDecision(db, {
+          accountId: grant.accountId,
+          workspaceId,
+          sessionId,
+          subjectId: grant.subjectId,
+          respondedByKind: childRequiresActionRespondedByKindForGrant(grant),
+          payload,
+          mcpCredentialUpdates,
+          clientEventId: event.clientEventId ?? null,
+        });
+      } catch (error) {
+        if (error instanceof Error && error.message.startsWith("Unknown session MCP server")) {
+          throw new HTTPException(422, { message: error.message });
+        }
+        throw error;
+      }
       if (accepted.action === "conflict") {
         throw new HTTPException(409, {
           message: `session is ${accepted.sessionStatus}; no unhandled approval is pending`,
@@ -3257,21 +4137,45 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     }
 
     if (event.type === "user.humanInputResponse") {
+      // Secret values are write-only: split them off before anything else sees
+      // the response, generate/encrypt them, and let the accept transaction
+      // write them to vaults. The stored response and event get references.
+      const { response, secretAnswers: rawSecretAnswers } = splitSecretAnswers(
+        event.payload.response,
+        event.payload.secretAnswers,
+      );
       let accepted;
       try {
+        const secretAnswers = prepareSecretAnswers(settings, rawSecretAnswers, "human");
         accepted = await acceptSessionHumanInputResponse(db, {
           accountId: grant.accountId,
           workspaceId,
           sessionId,
           requestId: event.payload.requestId,
-          response: event.payload.response,
+          response,
+          ...(secretAnswers.length
+            ? {
+                secretAnswers,
+                secretWriteContext: humanSecretWriteContext({
+                  accountId: grant.accountId,
+                  workspaceId,
+                  subjectId: grant.subjectId,
+                }),
+              }
+            : {}),
           respondedBy: grant.subjectId,
           canonicalHumanSession:
-            authorization.canonicalManagedHumanSession || authorization.canonicalLocalHumanSession,
+            authorization.canonicalManagedHumanSession ||
+            authorization.canonicalLocalHumanSession ||
+            isVerifiedDelegatedHumanAuthorization(authorization),
           respondedByKind: childRequiresActionRespondedByKindForGrant(grant),
           clientEventId: event.clientEventId ?? null,
+          mcpCredentialUpdates,
         });
       } catch (error) {
+        if (error instanceof Error && error.message.startsWith("Unknown session MCP server")) {
+          throw new HTTPException(422, { message: error.message });
+        }
         if (error instanceof SkillHumanResponseError) {
           throw new HTTPException(
             error.code === "conflict" ? 409 : error.code === "forbidden" ? 403 : 422,
@@ -3292,6 +4196,15 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
             },
           );
         }
+        const vaultError = isVaultError(error) ? error : vaultErrorFromDatabase(error);
+        if (vaultError) {
+          const body: VaultApiError = {
+            error: vaultError.code,
+            message: vaultError.message,
+            ...(vaultError.details ? { details: vaultError.details } : {}),
+          };
+          return c.json(body, VAULT_ERROR_HTTP_STATUS[vaultError.code] as ContentfulStatusCode);
+        }
         throw error;
       }
       if (accepted.action === "not_found") {
@@ -3382,13 +4295,18 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
   // Resolve the shared-exposure disclosure for a session's group: `shared` when
   // the group has >1 session (addendum E.1), and the OTHER sessions' ids ONLY
   // (never their conversation/metadata; the query selects only id — stress g).
+  // `shared` counts every member, including Only-me sessions the caller cannot
+  // read, because sharing is a property of the box; the ids stay actor-scoped.
   async function resolveSharedExposure(
     workspaceId: string,
     session: { id: string; sandboxGroupId: string },
   ): Promise<{ shared: boolean; sharedSessionIds: string[] }> {
-    const ids = await listSessionIdsInGroup(db, workspaceId, session.sandboxGroupId);
+    const [ids, memberCount] = await Promise.all([
+      listSessionIdsInGroup(db, workspaceId, session.sandboxGroupId),
+      countAllSessionsInGroup(db, workspaceId, session.sandboxGroupId),
+    ]);
     const others = ids.filter((id) => id !== session.id);
-    return { shared: others.length > 0, sharedSessionIds: others };
+    return { shared: memberCount > 1 || others.length > 0, sharedSessionIds: others };
   }
 
   // GET .../stream-capabilities — the capability-negotiation read. Returns the
@@ -3755,6 +4673,7 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
         workspaceId,
         session,
         viewerSubjectId: grant.subjectId,
+        grant,
         waitSignal: c.req.raw.signal,
         ...(parsed.data.viewerId ? { viewerId: parsed.data.viewerId } : {}),
       });
@@ -4008,6 +4927,15 @@ export function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void {
     return c.json(out);
   });
 
+  app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/fs/read-workspace", async (c) => {
+    const ctx = await channelAPreamble(c, "files:read", "fs.read");
+    const req = await parseChannelABody(c, FsReadRequest);
+    const out = await withChannelARead(channelAServices, ctx, ({ service }) =>
+      service.fsRead({ ...req, workspaceOnly: true }),
+    );
+    return c.json(out);
+  });
+
   app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/artifacts/publish", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const authorization = await requireAccessGrantAuthorization(
@@ -4517,11 +5445,19 @@ function codexRealtimeHttpFailure(error: CodexRealtimeBrokerError): {
   }
 }
 
-function sessionRealtimeHttpError(error: unknown): HTTPException {
+/** Conflicts a person can hit by starting voice; the browser shows these verbatim. */
+const SESSION_REALTIME_USER_MESSAGES: Partial<Record<string, string>> = {
+  REALTIME_ACTIVE:
+    "Voice is already on for this session in another tab or window. End it there, or try again in a minute.",
+  CONTROL_NOT_ACTIVE: "Resume this session to start voice.",
+  SESSION_CANCELLED: "This session was cancelled, so voice can't start.",
+};
+
+export function sessionRealtimeHttpError(error: unknown): HTTPException {
   if (error instanceof HTTPException) return error;
   if (error instanceof SessionRealtimeConflictError) {
     return new HTTPException(error.code === "REALTIME_NOT_FOUND" ? 404 : 409, {
-      message: error.message,
+      message: SESSION_REALTIME_USER_MESSAGES[error.code] ?? error.message,
       cause: error,
     });
   }
@@ -4553,11 +5489,28 @@ export function sessionAuthorizationOperationForHttp(
   if (suffix === "/pin" && verb === "PUT") return "session.pin.write";
   if (suffix === "/attention" && verb === "PUT") return "session.attention.write";
   if (suffix === "/archive" && verb === "PUT") return "session.archive.write";
+  if (suffix === "/retention" && verb === "PUT") return "session.retention.write";
+  // Task usage limit: read with the session; change as a control write
+  // (the route additionally admits only a person or the host server key).
+  if (suffix === "/usage-limit") {
+    if (verb === "GET") return "session.read";
+    if (verb === "PUT") return "session.control";
+    return null;
+  }
   if (suffix === "/visibility" && verb === "PUT") return "session.visibility.write";
+  // Owner-only preview of the same change: identical authority to making it.
+  if (suffix === "/visibility/preview" && verb === "GET") return "session.visibility.write";
   if (suffix === "/forks" && verb === "POST") return "session.fork.create";
   if (suffix === "/channel" && verb === "PUT") return "session.channel.write";
   if (suffix === "/variable-sets" && verb === "PUT") return "session.variable_sets.write";
   if (suffix === "/tool-policy" && verb === "PUT") return "session.tool_policy.write";
+  if (suffix === "/agent" && verb === "PUT") return "session.tool_policy.write";
+  if (suffix === "/skills" && verb === "PUT") return "session.tool_policy.write";
+  if (suffix === "/admin-access") {
+    if (verb === "GET") return "session.read";
+    if (verb === "PUT" || verb === "DELETE") return "session.tool_policy.write";
+    return null;
+  }
   if (suffix === "/mcp-credentials/rotate" && verb === "POST")
     return "session.mcp.credentials.rotate";
   if (/^\/mcp-servers\/[^/]+\/approval-policy$/.test(suffix) && verb === "PATCH") {
@@ -4566,11 +5519,21 @@ export function sessionAuthorizationOperationForHttp(
   if (suffix === "/lineage" && verb === "GET") return "session.lineage.read";
   if (suffix === "/background-commands" && verb === "GET") return "session.read";
   if (suffix === "/model-context" && verb === "GET") return "session.read";
+  if (/^\/tool-reviews\/[^/]+(?:\/details)?$/.test(suffix) && verb === "GET") return "session.read";
+  if (suffix === "/codex-accounts" && verb === "GET") return "session.read";
   if (/^\/background-commands\/[^/]+$/.test(suffix) && verb === "DELETE") {
     return "session.control";
   }
   if (suffix === "/codex-account" && verb === "POST") {
-    return "session.codex_account.write";
+    return "session.model_account.write";
+  }
+  // The provider-neutral account choice (any provider) and the older
+  // per-provider pin share one internal operation. Core adapts its name at the
+  // host boundary according to the authorization port's explicit capability.
+  if (suffix === "/model-account") {
+    if (verb === "GET") return "session.read";
+    if (verb === "PUT") return "session.model_account.write";
+    return null;
   }
   if (suffix === "/realtime/webrtc" && verb === "POST") {
     return "session.realtime.start";
@@ -4615,6 +5578,8 @@ export function sessionAuthorizationOperationForHttp(
     return verb === "POST" ? "session.context.write" : null;
   }
   if (suffix === "/events/stream" && verb === "GET") return "session.stream.read";
+  if (/^\/events\/[^/]+\/message-preview$/.test(suffix) && verb === "GET")
+    return "session.events.read";
   if (suffix === "/events") {
     if (verb === "GET") return "session.events.read";
     if (verb === "POST") return "session.append";
@@ -4632,6 +5597,8 @@ export function sessionAuthorizationOperationForHttp(
   // acceptSessionUserMessageWithOutcome after the body is parsed.
   if (suffix === "/composer-draft/submit" && verb === "POST") return "session.append";
   if (suffix === "/control" && verb === "POST") return "session.control";
+  if (suffix === "/retry" && verb === "POST") return "session.control";
+  if (suffix === "/sandbox-recovery" && ["GET", "POST"].includes(verb)) return "session.control";
   if (suffix === "/steer" && verb === "POST") return "session.steer";
   if (suffix === "/human-input-requests" && verb === "GET") {
     return "session.human_input.read";
@@ -4647,10 +5614,16 @@ export function sessionAuthorizationOperationForHttp(
   if (suffix.startsWith("/viewers/") && ["POST", "DELETE"].includes(verb)) {
     return "session.viewer.control";
   }
-  if (suffix === "/fs/list" || suffix === "/fs/list-batch" || suffix === "/fs/read") {
+  if (
+    suffix === "/fs/list" ||
+    suffix === "/fs/list-batch" ||
+    suffix === "/fs/read" ||
+    suffix === "/fs/read-workspace"
+  ) {
     return verb === "POST" ? "session.files.read" : null;
   }
   if (suffix === "/artifacts/publish" && verb === "POST") return "session.files.write";
+  if (suffix.startsWith("/artifact-associations/") && verb === "GET") return "session.read";
   if (["/fs/write", "/fs/delete", "/fs/move", "/fs/mkdir"].includes(suffix)) {
     return verb === "POST" ? "session.files.write" : null;
   }
@@ -4679,6 +5652,17 @@ function sessionAuthorizationHttpError(error: unknown): HTTPException {
   throw error;
 }
 
+const SESSION_FORK_POINT_REFUSAL_MESSAGES: Record<SessionForkPointRefusal, string> = {
+  message_unavailable:
+    "Only your messages and the agent's replies can be fork points. Choose one of those, or fork the whole session.",
+  boundary_not_retained:
+    "This message is from before the conversation was compacted, so it can't be a fork point. Choose a more recent message, or fork the whole session.",
+  history_compacted:
+    "The conversation up to this message was compacted, so it can't be copied as it was then. Choose a more recent message, or fork the whole session.",
+  unfinished_tool_exchange:
+    "The agent was still waiting for a tool result at this message. Choose a later message, or fork the whole session.",
+};
+
 export function sessionTenancyHttpError(error: unknown): Error {
   if (error instanceof SessionTenancyManagedHumanRequiredError) {
     return new ApiHttpError(403, {
@@ -4690,7 +5674,7 @@ export function sessionTenancyHttpError(error: unknown): Error {
   if (error instanceof SessionTenancyNotActivatedError) {
     return new ApiHttpError(409, {
       code: "conflict",
-      message: "Session tenancy is not activated for this organization.",
+      message: "Only-me chats are not enabled for this organization.",
       retryable: false,
       details: { reason: "not_activated" },
     });
@@ -4711,6 +5695,25 @@ export function sessionTenancyHttpError(error: unknown): Error {
       },
     });
   }
+  if (error instanceof SessionVisibilityWorkConflictError) {
+    return new ApiHttpError(409, {
+      code: "conflict",
+      message:
+        error.reason === "active_work"
+          ? "The chat has work in progress. Send stopActiveWork to stop it and make the change."
+          : "The chat's work is still stopping. Retry with the same idempotency key.",
+      retryable: error.reason === "stopping_active_work",
+      details: {
+        reason: error.reason,
+        runningTurnCount: error.work.runningTurnCount,
+        queuedTurnCount: error.work.queuedTurnCount,
+        activeGoal: error.work.activeGoal,
+        liveVoice: error.work.liveVoice,
+        otherPeoplePendingUpdateCount: error.work.otherPeoplePendingUpdateCount,
+        otherPeopleAccountChoiceCount: error.work.otherPeopleAccountChoiceCount,
+      },
+    });
+  }
   if (
     error instanceof SessionTenancyAccessError ||
     error instanceof SessionAuthorizationDeniedError
@@ -4722,6 +5725,14 @@ export function sessionTenancyHttpError(error: unknown): Error {
     });
   }
   if (error instanceof SessionTenancyInvalidRequestError) {
+    if (error.forkPointRefusal) {
+      return new ApiHttpError(422, {
+        code: "validation_failed",
+        message: SESSION_FORK_POINT_REFUSAL_MESSAGES[error.forkPointRefusal],
+        retryable: false,
+        details: { reason: `fork_point_${error.forkPointRefusal}` },
+      });
+    }
     return new ApiHttpError(422, {
       code: "validation_failed",
       message: "Invalid session tenancy request.",
@@ -4795,7 +5806,7 @@ function eventEnumList<T extends string>(
   });
 }
 
-function sessionListQuery(
+export function sessionListQuery(
   query: Record<string, string>,
   allowCursor = true,
 ): {
@@ -4805,7 +5816,13 @@ function sessionListQuery(
   cursor: ReturnType<typeof decodeSessionListCursor> | undefined;
   search: string | undefined;
   pinsOnly: boolean;
+  includePinned: boolean;
+  includeTotals: boolean;
+  needsYouOnly: boolean;
+  contentArchivedOnly: boolean;
   archivedOnly: boolean;
+  sortBy: "updatedAt" | "createdAt" | "name" | undefined;
+  archiveStatus: "active" | "archived" | "all" | undefined;
   channelId: string | null | undefined;
   createdBy: { kind: "subject" | "service"; subjectId: string } | undefined;
   updatedFrom: Date | undefined;
@@ -4848,10 +5865,42 @@ function sessionListQuery(
     });
   }
   const pinsOnly = query.pinsOnly === "true";
+  if (query.includePinned !== undefined && !["true", "false"].includes(query.includePinned)) {
+    throw new HTTPException(400, { message: 'includePinned must be "true" or "false"' });
+  }
+  const includePinned = query.includePinned !== "false";
+  for (const key of ["includeTotals", "needsYouOnly", "contentArchivedOnly"]) {
+    if (query[key] !== undefined && !["true", "false"].includes(query[key]!))
+      throw new HTTPException(400, { message: `${key} must be "true" or "false"` });
+  }
+  const includeTotals = query.includeTotals === "true";
+  const needsYouOnly = query.needsYouOnly === "true";
+  const contentArchivedOnly = query.contentArchivedOnly === "true";
+  if (includeTotals && (!allowCursor || (parentSessionId !== "null" && !pinsOnly)))
+    throw new HTTPException(400, { message: "includeTotals requires a root page" });
+  if (needsYouOnly && !allowCursor)
+    throw new HTTPException(400, { message: 'needsYouOnly requires view="page"' });
+  if (pinsOnly && !includePinned) {
+    throw new HTTPException(400, { message: "pinsOnly requires includePinned" });
+  }
   if (query.archivedOnly !== undefined && query.archivedOnly !== "true") {
     throw new HTTPException(400, { message: 'archivedOnly must be the literal "true"' });
   }
   const archivedOnly = query.archivedOnly === "true";
+  const sortBy = z.enum(["updatedAt", "createdAt", "name"]).optional().safeParse(query.sortBy);
+  const archiveStatus = z
+    .enum(["active", "archived", "all"])
+    .optional()
+    .safeParse(query.archiveStatus);
+  if (!sortBy.success || !archiveStatus.success) {
+    throw new HTTPException(400, { message: "Invalid session sortBy or archiveStatus" });
+  }
+  if (archivedOnly && archiveStatus.data !== undefined && archiveStatus.data !== "archived") {
+    throw new HTTPException(400, { message: "archivedOnly conflicts with archiveStatus" });
+  }
+  if (pinsOnly && archiveStatus.data === "archived") {
+    throw new HTTPException(400, { message: "pinsOnly cannot be combined with archived status" });
+  }
   const channelId = query.channelId;
   if (
     channelId !== undefined &&
@@ -4918,12 +5967,14 @@ function sessionListQuery(
     const parsedEndUser = SessionScopeSubjectId.safeParse(query.scopeSubjectId);
     if (!parsedEndUser.success) {
       throw new HTTPException(400, {
-        message: "scopeSubjectId must be a canonical OpenGeni user subject",
+        message: "scopeSubjectId must be a canonical Opengeni user subject",
       });
     }
     scopeSubjectId = parsedEndUser.data;
   }
   const hasPageFilters =
+    needsYouOnly ||
+    contentArchivedOnly ||
     originSiteId !== undefined ||
     channelId !== undefined ||
     createdByKind !== undefined ||
@@ -4955,7 +6006,13 @@ function sessionListQuery(
     cursor,
     search: search || undefined,
     pinsOnly,
+    includePinned,
+    includeTotals,
+    needsYouOnly,
+    contentArchivedOnly,
     archivedOnly,
+    sortBy: sortBy.data,
+    archiveStatus: archiveStatus.data,
     channelId: channelId === undefined ? undefined : channelId === "null" ? null : channelId,
     createdBy:
       createdByKind && createdBySubjectId
@@ -5310,8 +6367,182 @@ function optionalEventSequence(raw: string | undefined): number | undefined {
   return Math.floor(sequence);
 }
 
+/**
+ * The minimal Site profile of a session a Site page starts: only the allowed
+ * create fields, metadata without reserved `_opengeni` keys, no vault access,
+ * and the workspace's default agent capabilities without workspace
+ * administration or browser and computer control, so the page cannot reach
+ * the viewer's Connected Machines, sandboxes or browsers. Workers it spawns
+ * only narrow that. It runs without a sandbox; its first-party tools are the
+ * ones the Site declares plus the Site's own data tools, and its MCP
+ * connections only the ones the Site declares. Everything else (resources,
+ * Skills, learning, goals) is the workspace default for a plain chat. Agents
+ * started from a Site stay clamped
+ * (`assertNotSiteClampedAgent`).
+ */
+async function siteFrameSessionProfile(
+  deps: ApiRouteDeps,
+  workspaceId: string,
+  payload: unknown,
+  frame: { accountId: string; siteId: string | null; versionId: string | null },
+): Promise<Record<string, unknown>> {
+  const body = (payload ?? {}) as Record<string, unknown>;
+  const profile: Record<string, unknown> = {};
+  for (const field of SITE_FRAME_SESSION_CREATE_FIELDS)
+    if (body[field] !== undefined && body[field] !== null) profile[field] = body[field];
+  const metadata = body.metadata;
+  profile.metadata =
+    metadata && typeof metadata === "object" && !Array.isArray(metadata)
+      ? Object.fromEntries(Object.entries(metadata).filter(([key]) => !key.startsWith("_opengeni")))
+      : {};
+  profile.vaultPolicy = { mode: "selected", vaultIds: [] };
+  // Tools are the overlap of what the Site declares and what the person may
+  // use: only the workspace MCP connections the Site version requests (the
+  // person's own access to each still applies), never the workspace
+  // default set. A frame with no published Site declares none.
+  profile.tools = await siteFrameDeclaredTools(deps, workspaceId, frame);
+  const unavailable = agentConfigDeploymentPolicy(deps.settings).unavailable;
+  const capabilities = siteFrameCapabilities(
+    resolveWorkspaceAgentDefaults((await requireWorkspace(deps.db, workspaceId)).settings)
+      ?.capabilities ?? "all",
+    unavailable,
+  );
+  profile.agent = { capabilities };
+  // First-party tools are the ones the Site declares plus the Site's own data
+  // tools, never the workspace default set; a Site page's agent runs without
+  // a sandbox.
+  profile.firstPartyMcpTools = (await siteFrameFirstPartyTools(deps, workspaceId, frame)).filter(
+    (tool) => {
+      const owner = FIRST_PARTY_MCP_TOOL_CAPABILITIES[tool];
+      if (owner === "runtime") return true;
+      if (owner === "sandbox" || unavailable[owner] !== undefined) return false;
+      const value = (capabilities as Record<string, unknown>)[owner];
+      return value === undefined ? capabilities.from === "all" : value !== false;
+    },
+  );
+  profile.sandboxBackend = "none";
+  return profile;
+}
+
+/**
+ * The first-party tools of a Site page's session: the session runtime's own,
+ * the first-party tools the Site version declares, and, for a published Site,
+ * its own data tools (`site_data_query`, `site_data_write`, and the Site SQL
+ * tools when Site SQL is on), all within the deployment's tool allowlist.
+ */
+async function siteFrameFirstPartyTools(
+  deps: ApiRouteDeps,
+  workspaceId: string,
+  frame: { accountId: string; siteId: string | null; versionId: string | null },
+): Promise<FirstPartyMcpToolName[]> {
+  const allowed = new Set<string>(resolveFirstPartyMcpToolPolicy(deps.settings).allowed);
+  const tools = new Set<FirstPartyMcpToolName>(["set_session_title", "wait_for_input"]);
+  if (frame.siteId && frame.versionId) {
+    const scope = { accountId: frame.accountId, workspaceId };
+    const version = await getPublishedSiteVersion(
+      deps.db,
+      scope,
+      frame.siteId,
+      frame.versionId,
+    ).catch(() => null);
+    for (const tool of version?.requestedTools ?? []) {
+      const parsed = FirstPartyMcpToolName.safeParse(tool.toolName);
+      if (tool.serverId === "opengeni" && parsed.success) tools.add(parsed.data);
+    }
+    if (version)
+      for (const tool of siteAgentDataToolNames({
+        viewerKind: "member",
+        siteSql: await siteAgentSiteSqlOn(deps, scope, frame.siteId),
+        allowed: [...allowed],
+      }))
+        tools.add(tool);
+  }
+  return [...tools].filter((tool) => allowed.has(tool)).sort();
+}
+
+/** The workspace MCP connections (not the first-party server) a Site version declares. */
+async function siteFrameDeclaredTools(
+  deps: ApiRouteDeps,
+  workspaceId: string,
+  frame: { accountId: string; siteId: string | null; versionId: string | null },
+): Promise<ToolRef[]> {
+  if (!frame.siteId || !frame.versionId) return [];
+  const version = await getPublishedSiteVersion(
+    deps.db,
+    { accountId: frame.accountId, workspaceId },
+    frame.siteId,
+    frame.versionId,
+  ).catch(() => null);
+  const declared = new Map<string, Set<string>>();
+  for (const { serverId, toolName } of version?.requestedTools ?? []) {
+    if (serverId === "opengeni" || !/^[A-Za-z0-9_-]{1,200}$/u.test(serverId)) continue;
+    const names = declared.get(serverId) ?? new Set<string>();
+    names.add(toolName);
+    declared.set(serverId, names);
+  }
+  return [...declared].map(([id, names]) => ({
+    kind: "mcp",
+    id,
+    optional: true,
+    allowedTools: [...names].sort(),
+  }));
+}
+
+/**
+ * A Site page's session capabilities: the workspace default with workspace
+ * administration (sandboxes, Connected Machines, `run_on`) and browser and
+ * computer control off. Capabilities this server does not offer are left to
+ * the default, so the create never fails on them.
+ */
+export function siteFrameCapabilities(
+  workspaceDefault: AgentCapabilities,
+  unavailable: Readonly<Partial<Record<string, string>>>,
+): Exclude<AgentCapabilities, string> {
+  if (typeof workspaceDefault === "string")
+    return { from: workspaceDefault, workspaceAdmin: false, browser: false };
+  const capabilities: Record<string, unknown> = {};
+  for (const [name, value] of Object.entries(workspaceDefault))
+    if (name === "from" || value === false || unavailable[name] === undefined)
+      capabilities[name] = value;
+  return {
+    ...(capabilities as Exclude<AgentCapabilities, string>),
+    workspaceAdmin: false,
+    browser: false,
+  };
+}
+
 /** Stable, value-free JSON errors for only the create-session boundary. */
 export function sessionCreateErrorResponse(c: Context, error: unknown): Response {
+  if (error instanceof SessionUsageLimitHttpError) {
+    // a create-time usage limit the caller may not set (agents and
+    // children) or that this server does not accept yet (producer flag off).
+    return c.json(
+      {
+        code: error.status === 403 ? "SESSION_CREATE_FORBIDDEN" : "SESSION_CREATE_REJECTED",
+        message: error.message,
+        details: { code: error.code },
+      },
+      error.status as 403 | 404 | 409 | 422 | 503,
+    );
+  }
+  if (error instanceof UnsupportedLatencyModeError) {
+    return c.json(
+      {
+        code: "SESSION_CREATE_REJECTED",
+        message: error.message,
+        details: {
+          code: error.code,
+          modelId: error.modelId,
+          latencyMode: error.latencyMode,
+          allowedLatencyModes: [...error.allowedLatencyModes],
+        },
+      },
+      422,
+    );
+  }
+  if (error instanceof SessionCreateConnectionSelectionUnavailableError) {
+    return c.json({ code: error.code, message: error.message, retryable: false }, 409);
+  }
   if (error instanceof SessionTenancyManagedHumanRequiredError) {
     return c.json(
       {
@@ -5374,6 +6605,24 @@ export function sessionCreateErrorResponse(c: Context, error: unknown): Response
       409,
     );
   }
+  if (
+    error instanceof HTTPException &&
+    error.status === 422 &&
+    error.cause instanceof AgentConfigError
+  ) {
+    // Typed agent-configuration failure: the specific code is details.code.
+    return c.json(
+      {
+        code: "SESSION_CREATE_REJECTED",
+        message: error.message,
+        details: {
+          code: error.cause.code,
+          ...(error.cause.capability ? { capability: error.cause.capability } : {}),
+        },
+      },
+      422,
+    );
+  }
   if (error instanceof HTTPException && error.status === 422) {
     return c.json(
       {
@@ -5425,6 +6674,52 @@ function zodErrorFields(error: ZodError): string {
   return `${shown.join(", ")}${remainder > 0 ? `, and ${remainder} more` : ""}`;
 }
 
+/** Statuses in which a chat still has work that would keep running after it is archived. */
+const ARCHIVE_LIVE_WORK_STATUSES: ReadonlySet<string> = new Set([
+  "queued",
+  "running",
+  "requires_action",
+  "recovering",
+  "waiting_capacity",
+]);
+
+/**
+ * Archiving a chat you started means you are done with it, so work it still
+ * has (a running or queued turn, a pending wait, an active goal) must not keep
+ * running out of sight. It is paused exactly like the Pause control: reversible
+ * with Resume, and a paused chat dispatches no goal continuations either. A
+ * chat someone else started is never paused: archiving only hides it for you.
+ * Settled chats are left alone so a later message to them still just runs.
+ */
+async function pauseOwnArchivedWork(
+  deps: ApiRouteDeps,
+  grant: AccessGrant,
+  workspaceId: string,
+  session: Session,
+): Promise<Session> {
+  if (session.createdBy.kind !== "subject" || session.createdBy.subjectId !== grant.subjectId)
+    return session;
+  if (!hasPermission(grant.permissions, "sessions:control")) return session;
+  if (session.effectiveControl.directState === "paused") return session;
+  const liveWork =
+    ARCHIVE_LIVE_WORK_STATUSES.has(session.status) ||
+    session.activeTurnId !== null ||
+    Boolean(session.inputWait) ||
+    (await getSessionGoal(deps.db, workspaceId, session.id))?.status === "active";
+  if (!liveWork) return session;
+  const paused = await controlHumanSessionWorkstream(
+    deps,
+    { accountId: grant.accountId, workspaceId, sessionId: session.id, subjectId: grant.subjectId },
+    {
+      action: "pause",
+      reason: "Archived",
+      // One pause per archive: a retried archive replays it instead of pausing twice.
+      clientEventId: `archive-pause:${session.id}:${session.archiveVersion}`,
+    },
+  );
+  return { ...session, effectiveControl: paused.effectiveControl };
+}
+
 function commandConflictResponse(c: Context, error: unknown): Response {
   if (error instanceof QueueCommandConflictError) {
     return c.json({ code: error.code, message: error.message, current: error.current }, 409);
@@ -5435,24 +6730,56 @@ function commandConflictResponse(c: Context, error: unknown): Response {
   if (error instanceof SessionCommandIdempotencyError) {
     return c.json({ code: error.code, message: error.message }, 409);
   }
+  if (error instanceof PersonalSessionInitiatorRequiredError) {
+    return c.json({ code: error.code, message: error.message }, 403);
+  }
   throw error;
 }
 
 type EffectivePolicyContext = {
   workspaceServerIds: string[];
   workspaceDefaultServerIds: string[];
+  effectiveToolsContext: Awaited<ReturnType<typeof workspaceSessionEffectiveToolsContext>>;
+  /** The Codex session pointers by cutover disposition (see codex-session-pointers). */
+  codexPointers: CodexSessionPointerProjection;
 };
 
+/**
+ * Everything a Session response projection needs, loaded once for all the
+ * sessions it returns. Every route that returns a Session projects it through
+ * `sessionResponse` with this context.
+ */
 async function loadEffectivePolicyContext(
   deps: ApiRouteDeps,
   workspaceId: string,
   subjectId: string,
+  sessions: readonly Session[],
 ): Promise<EffectivePolicyContext> {
-  const [workspaceServerIds, workspaceDefaultServerIds] = await Promise.all([
-    workspaceSessionToolPolicyServerIds(deps.db, workspaceId, deps.settings, subjectId),
-    workspaceSessionToolPolicyDefaultServerIds(deps.db, workspaceId, deps.settings, subjectId),
+  // Both projections read the same workspace row; hydrate it once.
+  const workspaceRead = requireWorkspace(deps.db, workspaceId);
+  void workspaceRead.catch(() => undefined);
+  const [policy, effectiveToolsContext, codexPointers] = await Promise.all([
+    workspaceSessionToolPolicyContext(
+      deps.db,
+      workspaceId,
+      deps.settings,
+      subjectId,
+      workspaceRead,
+    ),
+    workspaceSessionEffectiveToolsContext(deps, workspaceId, subjectId, sessions, workspaceRead),
+    loadCodexSessionPointerProjection(deps.db, workspaceId, sessions),
   ]);
-  return { workspaceServerIds, workspaceDefaultServerIds };
+  return { ...policy, effectiveToolsContext, codexPointers };
+}
+
+/** The response projection of one Session: Codex pointers and effective tool policy. */
+function sessionResponse(session: Session, policy: EffectivePolicyContext): Session {
+  return sessionWithEffectiveToolPolicy(
+    policy.codexPointers(session),
+    policy.workspaceServerIds,
+    policy.workspaceDefaultServerIds,
+    policy.effectiveToolsContext,
+  );
 }
 
 async function withEffectivePolicy(
@@ -5461,22 +6788,14 @@ async function withEffectivePolicy(
   subjectId: string,
   session: Session,
 ): Promise<Session> {
-  const policy = await loadEffectivePolicyContext(deps, workspaceId, subjectId);
-  return sessionWithEffectiveToolPolicy(
-    session,
-    policy.workspaceServerIds,
-    policy.workspaceDefaultServerIds,
-  );
+  const policy = await loadEffectivePolicyContext(deps, workspaceId, subjectId, [session]);
+  return sessionResponse(session, policy);
 }
 
 function mapLineageNodes(nodes: LineageNode[], policy: EffectivePolicyContext): LineageNode[] {
   return nodes.map((node) => ({
     ...node,
-    session: sessionWithEffectiveToolPolicy(
-      node.session as Session,
-      policy.workspaceServerIds,
-      policy.workspaceDefaultServerIds,
-    ),
+    session: sessionResponse(node.session as Session, policy),
     children: mapLineageNodes(node.children, policy),
   }));
 }